Add the base Enlightenment Foundation Libraries - eina, eet, evas, ecore, embryo, and edje.

Note that embryo wont be used, but I'm not sure yet if you can build edje without it.

16 files changed, 18023 insertions, 0 deletions

diff --git a/libraries/ecore/src/lib/ecore_evas/Ecore_Evas.h b/libraries/ecore/src/lib/ecore_evas/Ecore_Evas.h
new file mode 100644
index 0000000..256e57c
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/Ecore_Evas.h
@@ -0,0 +1,1660 @@
+#ifndef _ECORE_EVAS_H
+#define _ECORE_EVAS_H
+
+#include <Evas.h>
+#include <Ecore_Getopt.h>
+#include <Ecore_Input.h>
+
+#ifdef EAPI
+# undef EAPI
+#endif
+
+#ifdef _WIN32
+# ifdef EFL_ECORE_EVAS_BUILD
+#  ifdef DLL_EXPORT
+#   define EAPI __declspec(dllexport)
+#  else
+#   define EAPI
+#  endif /* ! DLL_EXPORT */
+# else
+#  define EAPI __declspec(dllimport)
+# endif /* ! EFL_ECORE_EVAS_BUILD */
+#else
+# ifdef __GNUC__
+#  if __GNUC__ >= 4
+#   define EAPI __attribute__ ((visibility("default")))
+#  else
+#   define EAPI
+#  endif
+# else
+#  define EAPI
+# endif
+#endif /* ! _WIN32 */
+
+/**
+ * @file Ecore_Evas.h
+ * @brief Evas wrapper functions
+ *
+ * The following is a list of example that partially exemplify Ecore_Evas's API:
+ * @li @ref ecore_evas_callbacks_example_c
+ * @li @ref ecore_evas_object_example_c
+ * @li @ref ecore_evas_basics_example_c
+ */
+
+/* FIXME:
+ * to do soon:
+ * - iconfication api needs to work
+ * - maximization api needs to work
+ * - document all calls
+ *
+ * later:
+ * - buffer back-end that renders to an evas_image_object ???
+ * - qt back-end ???
+ * - dfb back-end ??? (dfb's threads make this REALLY HARD)
+ */
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/**
+ * @defgroup Ecore_Evas_Group Ecore_Evas wrapper/helper set of functions
+ *
+ * This is a list of examples of these functions:
+ * - @ref Ecore_Evas_Window_Sizes_Example_c
+ * - @ref Ecore_Evas_Buffer_Example_01_c
+ * - @ref Ecore_Evas_Buffer_Example_02_c
+ * @{
+ */
+
+/* these are dummy and just tell u what API levels ecore_evas supports - not if
+ * the actual support is compiled in. you need to query for that separately.
+ */
+#define HAVE_ECORE_EVAS_X 1
+#define HAVE_ECORE_EVAS_FB 1
+#define HAVE_ECORE_EVAS_X11_GL 1
+#define HAVE_ECORE_EVAS_X11_16 1
+#define HAVE_ECORE_EVAS_DIRECTFB 1
+#define HAVE_ECORE_EVAS_WIN32 1
+#define HAVE_ECORE_EVAS_COCOA 1
+#define HAVE_ECORE_EVAS_SDL 1
+#define HAVE_ECORE_EVAS_WINCE 1
+#define HAVE_ECORE_EVAS_EWS 1
+#define HAVE_ECORE_EVAS_PSL1GHT 1
+
+typedef enum _Ecore_Evas_Engine_Type
+{
+   ECORE_EVAS_ENGINE_SOFTWARE_BUFFER,
+   ECORE_EVAS_ENGINE_SOFTWARE_XLIB,
+   ECORE_EVAS_ENGINE_XRENDER_X11,
+   ECORE_EVAS_ENGINE_OPENGL_X11,
+   ECORE_EVAS_ENGINE_SOFTWARE_XCB,
+   ECORE_EVAS_ENGINE_XRENDER_XCB,
+   ECORE_EVAS_ENGINE_SOFTWARE_GDI,
+   ECORE_EVAS_ENGINE_SOFTWARE_DDRAW,
+   ECORE_EVAS_ENGINE_DIRECT3D,
+   ECORE_EVAS_ENGINE_OPENGL_GLEW,
+   ECORE_EVAS_ENGINE_OPENGL_COCOA,
+   ECORE_EVAS_ENGINE_SOFTWARE_SDL,
+   ECORE_EVAS_ENGINE_DIRECTFB,
+   ECORE_EVAS_ENGINE_SOFTWARE_FB,
+   ECORE_EVAS_ENGINE_SOFTWARE_8_X11,
+   ECORE_EVAS_ENGINE_SOFTWARE_16_X11,
+   ECORE_EVAS_ENGINE_SOFTWARE_16_DDRAW,
+   ECORE_EVAS_ENGINE_SOFTWARE_16_WINCE,
+   ECORE_EVAS_ENGINE_OPENGL_SDL,
+   ECORE_EVAS_ENGINE_EWS,
+   ECORE_EVAS_ENGINE_PSL1GHT
+} Ecore_Evas_Engine_Type;
+
+typedef enum _Ecore_Evas_Avoid_Damage_Type
+{
+   ECORE_EVAS_AVOID_DAMAGE_NONE = 0,
+   ECORE_EVAS_AVOID_DAMAGE_EXPOSE = 1,
+   ECORE_EVAS_AVOID_DAMAGE_BUILT_IN = 2
+} Ecore_Evas_Avoid_Damage_Type;
+
+typedef enum _Ecore_Evas_Object_Associate_Flags
+{
+  ECORE_EVAS_OBJECT_ASSOCIATE_BASE  = 0,
+  ECORE_EVAS_OBJECT_ASSOCIATE_STACK = 1 << 0,
+  ECORE_EVAS_OBJECT_ASSOCIATE_LAYER = 1 << 1,
+  ECORE_EVAS_OBJECT_ASSOCIATE_DEL = 1 << 2
+} Ecore_Evas_Object_Associate_Flags;
+
+#ifndef _ECORE_X_H
+#define _ECORE_X_WINDOW_PREDEF
+typedef unsigned int Ecore_X_Window;
+#endif
+
+#ifndef _ECORE_DIRECTFB_H
+#define _ECORE_DIRECTFB_WINDOW_PREDEF
+typedef struct _Ecore_DirectFB_Window Ecore_DirectFB_Window;
+#endif
+
+#ifndef __ECORE_WIN32_H__
+typedef struct _Ecore_Win32_Window Ecore_Win32_Window;
+#endif
+
+#ifndef __ECORE_WINCE_H__
+typedef struct _Ecore_WinCE_Window Ecore_WinCE_Window;
+#endif
+
+#ifndef __ECORE_COCOA_H__
+typedef struct _Ecore_Cocoa_Window Ecore_Cocoa_Window;
+#endif
+
+#ifndef _ECORE_EVAS_PRIVATE_H
+/* basic data types */
+typedef struct _Ecore_Evas Ecore_Evas;
+#endif
+
+/* module setup/shutdown calls */
+
+EAPI int         ecore_evas_engine_type_supported_get(Ecore_Evas_Engine_Type engine);
+
+/**
+ * @brief Init the Ecore_Evas system.
+ *
+ * @return How many times the lib has been initialized, 0 indicates failure.
+ *
+ * Set up the Evas wrapper system. Init Evas and Ecore libraries.
+ *
+ * @see ecore_evas_shutdown()
+ */
+EAPI int         ecore_evas_init(void);
+/**
+ * @brief Shut down the Ecore_Evas system.
+ *
+ * @return 0 if ecore evas is fully shut down, or > 0 if it still being used.
+ *
+ * This closes the Evas wrapper system down. Shut down Evas and Ecore libraries.
+ *
+ * @see ecore_evas_init()
+ */
+EAPI int         ecore_evas_shutdown(void);
+
+EAPI void        ecore_evas_app_comp_sync_set(Eina_Bool do_sync);
+EAPI Eina_Bool   ecore_evas_app_comp_sync_get(void);
+
+/**
+ * @brief Returns a list of supported engines names.
+ *
+ * @return Newly allocated list with engines names. Engines names
+ * strings are internal and should be considered constants, do not
+ * free or modify them, to free the list use ecore_evas_engines_free().
+ */
+EAPI Eina_List  *ecore_evas_engines_get(void);
+/**
+ * @brief Free list returned by ecore_evas_engines_get()
+ */
+EAPI void        ecore_evas_engines_free(Eina_List *engines);
+/**
+ * @brief Creates a new Ecore_Evas based on engine name and common parameters.
+ *
+ * @param engine_name engine name as returned by
+ *        ecore_evas_engines_get() or NULL to use environment variable
+ *        ECORE_EVAS_ENGINE, that can be undefined and in this case
+ *        this call will try to find the first working engine.
+ * @param x horizontal position of window (not supported in all engines)
+ * @param y vertical position of window (not supported in all engines)
+ * @param w width of window
+ * @param h height of window
+ * @param extra_options string with extra parameter, dependent on engines
+ *        or NULL. String is usually in the form: 'key1=value1;key2=value2'.
+ *        Pay attention that when getting that from shell commands, most
+ *        consider ';' as the command terminator, so you need to escape
+ *        it or use quotes.
+ *
+ * @return Ecore_Evas instance or NULL if creation failed.
+ */
+EAPI Ecore_Evas *ecore_evas_new(const char *engine_name, int x, int y, int w, int h, const char *extra_options);
+/**
+ * @brief Set whether an Ecore_Evas has an alpha channel or not.
+ *
+ * @param ee The Ecore_Evas to shape
+ * @param alpha EINA_TRUE to enable the alpha channel, EINA_FALSE to disable it
+ *
+ * This function allows you to make an Ecore_Evas translucent using an
+ * alpha channel. See ecore_evas_shaped_set() for details. The difference
+ * between a shaped window and a window with an alpha channel is that an
+ * alpha channel supports multiple levels of transpararency, as opposed to
+ * the 1 bit transparency of a shaped window (a pixel is either opaque, or
+ * it's transparent).
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ */
+EAPI void        ecore_evas_alpha_set(Ecore_Evas *ee, Eina_Bool alpha);
+/**
+ * @brief Query whether an Ecore_Evas has an alpha channel.
+ * @param ee The Ecore_Evas to query.
+ * @return EINA_TRUE if ee has an alpha channel, EINA_FALSE if it does not.
+ *
+ * This function returns EINA_TRUE if @p ee has an alpha channel, and EINA_FALSE
+ * if it does not.
+ *
+ * @see ecore_evas_alpha_set()
+ */
+EAPI Eina_Bool   ecore_evas_alpha_get(const Ecore_Evas *ee);
+/**
+ * @brief Set whether an Ecore_Evas has an transparent window or not.
+ *
+ * @param ee The Ecore_Evas to shape
+ * @param transparent EINA_TRUE to enable the transparent window, EINA_FALSE to
+ * disable it
+ *
+ * This function sets some translucency options, for more complete support see
+ * ecore_evas_alpha_set().
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ *
+ * @see ecore_evas_alpha_set()
+ */
+EAPI void        ecore_evas_transparent_set(Ecore_Evas *ee, Eina_Bool transparent);
+/**
+ * @brief  Query whether an Ecore_Evas is transparent.
+ *
+ * @param ee The Ecore_Evas to query.
+ * @return EINA_TRUE if ee is transparent, EINA_FALSE if it isn't.
+ *
+ * @see ecore_evas_transparent_set()
+ */
+EAPI Eina_Bool   ecore_evas_transparent_get(const Ecore_Evas *ee);
+/**
+ * @brief  Get the geometry of an Ecore_Evas.
+ *
+ * @param ee The Ecore_Evas whose geometry y
+ * @param x A pointer to an int to place the x coordinate in
+ * @param y A pointer to an int to place the y coordinate in
+ * @param w A pointer to an int to place the w size in
+ * @param h A pointer to an int to place the h size in
+ *
+ * This function takes four pointers to (already allocated) ints, and places
+ * the geometry of @p ee in them. If any of the parameters is not desired you
+ * may pass NULL on them.
+ *
+ * @code
+ * int x, y, w, h;
+ * ecore_evas_geometry_get(ee, &x, &y, &w, &h);
+ * @endcode
+ *
+ * @see ecore_evas_new()
+ * @see ecore_evas_resize()
+ * @see ecore_evas_move()
+ * @see ecore_evas_move_resize()
+ */
+EAPI void        ecore_evas_geometry_get(const Ecore_Evas *ee, int *x, int *y, int *w, int *h);
+/**
+ * @brief  Get the geometry which an Ecore_Evas was latest recently requested.
+ *
+ * @param ee The Ecore_Evas whose geometry y
+ * @param x A pointer to an int to place the x coordinate in
+ * @param y A pointer to an int to place the y coordinate in
+ * @param w A pointer to an int to place the w size in
+ * @param h A pointer to an int to place the h size in
+ *
+ * This function takes four pointers to (already allocated) ints, and places
+ * the geometry which @p ee was latest recently requested . If any of the parameters is not desired you
+ * may pass NULL on them. 
+ * This function can represent recently requested geomety. 
+ * ecore_evas_geometry_get function returns the value is updated after engine finished request.
+ * By comparison, ecore_evas_request_geometry_get returns recently requested value.
+ *
+ * @code
+ * int x, y, w, h;
+ * ecore_evas_request_geometry_get(ee, &x, &y, &w, &h);
+ * @endcode
+ *
+ * @since 1.1
+ */
+EAPI void        ecore_evas_request_geometry_get(const Ecore_Evas *ee, int *x, int *y, int *w, int *h);
+/**
+ * @brief Set the focus of an Ecore_Evas' window.
+ *
+ * @param ee The Ecore_Evas
+ * @param on EINA_TRUE for focus, EINA_FALSE to defocus.
+ *
+ * This function focuses @p ee if @p on is EINA_TRUE, or unfocuses @p ee if @p
+ * on is EINA_FALSE.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ */
+EAPI void        ecore_evas_focus_set(Ecore_Evas *ee, Eina_Bool on);
+/**
+ * @brief Query whether an Ecore_Evas' window is focused or not.
+ *
+ * @param ee The Ecore_Evas to set
+ * @return EINA_TRUE if @p ee if focused, EINA_FALSE if not.
+ *
+ * @see ecore_evas_focus_set()
+ */
+EAPI Eina_Bool   ecore_evas_focus_get(const Ecore_Evas *ee);
+/**
+ * @brief Iconify or uniconify an Ecore_Evas' window.
+ *
+ * @param ee The Ecore_Evas
+ * @param on EINA_TRUE to iconify, EINA_FALSE to uniconify.
+ *
+ * This function iconifies @p ee if @p on is EINA_TRUE, or uniconifies @p ee if
+ * @p on is EINA_FALSE.
+ *
+ * @note Iconify and minize are synonims.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ */
+EAPI void        ecore_evas_iconified_set(Ecore_Evas *ee, Eina_Bool on);
+/**
+ * @brief Query whether an Ecore_Evas' window is iconified or not.
+ *
+ * @param ee The Ecore_Evas to set
+ * @return EINA_TRUE if @p ee is iconified, EINA_FALSE if not.
+ *
+ * @note Iconify and minize are synonims.
+ *
+ * @see ecore_evas_iconified_set()
+ */
+EAPI Eina_Bool   ecore_evas_iconified_get(const Ecore_Evas *ee);
+/**
+ * @brief Set whether an Ecore_Evas' window is borderless or not.
+ *
+ * @param ee The Ecore_Evas
+ * @param on EINA_TRUE for borderless, EINA_FALSE for bordered.
+ *
+ * This function makes @p ee borderless if @p on is EINA_TRUE, or bordered if @p
+ * on is EINA_FALSE.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ */
+EAPI void        ecore_evas_borderless_set(Ecore_Evas *ee, Eina_Bool on);
+/**
+ * @brief Query whether an Ecore_Evas' window is borderless or not.
+ *
+ * @param ee The Ecore_Evas to set
+ * @return EINA_TRUE if @p ee is borderless, EINA_FALSE if not.
+ *
+ * @see ecore_evas_borderless_set()
+ */
+EAPI Eina_Bool   ecore_evas_borderless_get(const Ecore_Evas *ee);
+/**
+ * @brief Set whether or not an Ecore_Evas' window is fullscreen.
+ *
+ * @param ee The Ecore_Evas
+ * @param on EINA_TRUE fullscreen, EINA_FALSE not.
+ *
+ * This function causes @p ee to be fullscreen if @p on is EINA_TRUE,
+ * or not if @p on is EINA_FALSE.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ */
+EAPI void        ecore_evas_fullscreen_set(Ecore_Evas *ee, Eina_Bool on);
+/**
+ * @brief Query whether an Ecore_Evas' window is fullscreen or not.
+ *
+ * @param ee The Ecore_Evas to set
+ * @return EINA_TRUE if @p ee is fullscreen, EINA_FALSE if not.
+ *
+ * @see ecore_evas_fullscreen_set()
+ */
+EAPI Eina_Bool   ecore_evas_fullscreen_get(const Ecore_Evas *ee);
+/**
+ * @brief Set if this evas should ignore @b all events.
+ *
+ * @param ee The Ecore_Evas whose window's to ignore events.
+ * @param ignore The Ecore_Evas new ignore state.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ */
+EAPI void        ecore_evas_ignore_events_set(Ecore_Evas *ee, Eina_Bool ignore);
+/**
+ * @brief Returns the ignore state of an Ecore_Evas' window.
+ *
+ * @param ee The Ecore_Evas whose window's ignore events state is returned.
+ * @return The Ecore_Evas window's ignore state.
+ *
+ * @see ecore_evas_ignore_events_set()
+ */
+EAPI Eina_Bool   ecore_evas_ignore_events_get(const Ecore_Evas *ee);
+/**
+ * @brief Query whether an Ecore_Evas' window is visible or not.
+ *
+ * @param ee The Ecore_Evas to query.
+ * @return 1 if visible, 0 if not.
+ *
+ * This function queries @p ee and returns 1 if it is visible, and 0 if not.
+ *
+ * @see ecore_evas_show()
+ * @see ecore_evas_hide()
+ */
+EAPI int         ecore_evas_visibility_get(const Ecore_Evas *ee);
+/**
+ * @brief Set the layer of an Ecore_Evas' window.
+ *
+ * @param ee The Ecore_Evas
+ * @param layer The layer to put @p ee on.
+ *
+ * This function moves @p ee to the layer @p layer.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ *
+ * @see ecore_evas_lower()
+ * @see ecore_evas_raise()
+ */
+EAPI void        ecore_evas_layer_set(Ecore_Evas *ee, int layer);
+/**
+ * @brief Get the layer of an Ecore_Evas' window.
+ *
+ * @param ee The Ecore_Evas to set
+ * @return the layer @p ee's window is on.
+ *
+ * @see ecore_evas_layer_set()
+ * @see ecore_evas_lower()
+ * @see ecore_evas_raise()
+ */
+EAPI int         ecore_evas_layer_get(const Ecore_Evas *ee);
+/**
+ * @brief Maximize (or unmaximize) an Ecore_Evas' window.
+ *
+ * @param ee The Ecore_Evas
+ * @param on EINA_TRUE to maximize, EINA_FALSE to unmaximize.
+ *
+ * This function maximizes @p ee if @p on is EINA_TRUE, or unmaximizes @p ee
+ * if @p on is EINA_FALSE.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ */
+EAPI void        ecore_evas_maximized_set(Ecore_Evas *ee, Eina_Bool on);
+/**
+ * @brief Query whether an Ecore_Evas' window is maximized or not.
+ *
+ * @param ee The Ecore_Evas to set
+ * @return EINA_TRUE if @p ee is maximized, EINA_FALSE if not.
+ *
+ * @see ecore_evas_maximized_set()
+ */
+EAPI Eina_Bool   ecore_evas_maximized_get(const Ecore_Evas *ee);
+/**
+ * @brief Move an Ecore_Evas.
+ *
+ * @param ee The Ecore_Evas to move
+ * @param x The x coordinate to move to
+ * @param y The y coordinate to move to
+ *
+ * This moves @p ee to the screen coordinates (@p x, @p y)
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ *
+ * @see ecore_evas_new()
+ * @see ecore_evas_resize()
+ * @see ecore_evas_move_resize()
+ */
+EAPI void        ecore_evas_move(Ecore_Evas *ee, int x, int y);
+/**
+ * @brief Resize an Ecore_Evas.
+ *
+ * @param ee The Ecore_Evas to move
+ * @param w The w coordinate to resize to
+ * @param h The h coordinate to resize to
+ *
+ * This resizes @p ee to @p w x @p h.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ *
+ * @see ecore_evas_new()
+ * @see ecore_evas_move()
+ * @see ecore_evas_move_resize()
+ */
+EAPI void        ecore_evas_resize(Ecore_Evas *ee, int w, int h);
+/**
+ * @brief Move and resize an Ecore_Evas
+ *
+ * @param ee The Ecore_Evas to move and resize
+ * @param x The x coordinate to move to
+ * @param y The y coordinate to move to
+ * @param w The w coordinate to resize to
+ * @param h The h coordinate to resize to
+ *
+ * This moves @p ee to the screen coordinates (@p x, @p y) and  resizes
+ * it to @p w x @p h.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ *
+ * @see ecore_evas_new()
+ * @see ecore_evas_move()
+ * @see ecore_evas_resize()
+ */
+EAPI void        ecore_evas_move_resize(Ecore_Evas *ee, int x, int y, int w, int h);
+/**
+ * @brief Set the rotation of an Ecore_Evas' window.
+ *
+ * @param ee The Ecore_Evas
+ * @param rot the angle (in degrees) of rotation.
+ *
+ * The allowed values of @p rot depend on the engine being used. Most only
+ * allow multiples of 90.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ *
+ * @see ecore_evas_rotation_with_resize_set()
+ */
+EAPI void        ecore_evas_rotation_set(Ecore_Evas *ee, int rot);
+/**
+ * @brief Set the rotation of an Ecore_Evas' window
+ *
+ * @param ee The Ecore_Evas
+ * @param rot the angle (in degrees) of rotation.
+ *
+ * Like ecore_evas_rotation_set(), but it also resizes the window's contents so
+ * that they fit inside the current window geometry.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ *
+ * @see ecore_evas_rotation_set()
+ */
+EAPI void        ecore_evas_rotation_with_resize_set(Ecore_Evas *ee, int rot);
+/**
+ * @brief Get the rotation of an Ecore_Evas' window
+ *
+ * @param ee The Ecore_Evas
+ * @return the angle (in degrees) of rotation.
+ *
+ * @see ecore_evas_rotation_set()
+ * @see ecore_evas_rotation_with_resize_set()
+ */
+EAPI int         ecore_evas_rotation_get(const Ecore_Evas *ee);
+/**
+ * @brief Raise an Ecore_Evas' window.
+ *
+ * @param ee The Ecore_Evas to raise.
+ *
+ * This functions raises the Ecore_Evas to the front.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ *
+ * @see ecore_evas_lower()
+ * @see ecore_evas_layer_set()
+ */
+EAPI void        ecore_evas_raise(Ecore_Evas *ee);
+/**
+ * @brief Lower an Ecore_Evas' window.
+ *
+ * @param ee The Ecore_Evas to raise.
+ *
+ * This functions lowers the Ecore_Evas to the back.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ *
+ * @see ecore_evas_raise()
+ * @see ecore_evas_layer_set()
+ */
+EAPI void        ecore_evas_lower(Ecore_Evas *ee);
+/**
+ * @brief Set the title of an Ecore_Evas' window.
+ *
+ * @param ee The Ecore_Evas whose title you wish to set.
+ * @param t The title
+ *
+ * This function sets the title of @p ee to @p t.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ */
+EAPI void        ecore_evas_title_set(Ecore_Evas *ee, const char *t);
+/**
+ * @brief Get the title of an Ecore_Evas' window.
+ *
+ * @param ee The Ecore_Evas whose title you wish to get.
+ * @return The title of @p ee.
+ *
+ * This function returns the title of @p ee.
+ *
+ * @see ecore_evas_title_set()
+ */
+EAPI const char *ecore_evas_title_get(const Ecore_Evas *ee);
+/**
+ * @brief Set the name and class of an Ecore_Evas' window.
+ *
+ * @param ee the Ecore_Evas
+ * @param n the name
+ * @param c the class
+ *
+ * This function sets the name of @p ee to @p n, and its class to @p c. The
+ * meaning of @p name and @p class depends on the underlying windowing system.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ */
+EAPI void        ecore_evas_name_class_set(Ecore_Evas *ee, const char *n, const char *c);
+/**
+ * @brief Get the name and class of an Ecore_Evas' window
+ *
+ * @p ee The Ecore_Evas to query
+ * @p n A pointer to a string to place the name in.
+ * @p c A pointer to a string to place the class in.
+ *
+ * This function gets the name of @p ee into @p n, and its class into
+ * @p c.
+ *
+ * @see ecore_evas_name_class_set()
+ */
+EAPI void        ecore_evas_name_class_get(const Ecore_Evas *ee, const char **n, const char **c);
+/**
+ * @brief Returns a pointer to the underlying window.
+ *
+ * @param ee The Ecore_Evas whose window is desired.
+ *
+ * @warning Support for this depends on the underlying windowing system.
+ */
+EAPI Ecore_Window ecore_evas_window_get(const Ecore_Evas *ee);
+
+
+/* engine/target specific init calls */
+EAPI Ecore_Evas     *ecore_evas_software_x11_new(const char *disp_name, Ecore_X_Window parent, int x, int y, int w, int h);
+EAPI Ecore_X_Window  ecore_evas_software_x11_window_get(const Ecore_Evas *ee);
+EAPI void            ecore_evas_software_x11_direct_resize_set(Ecore_Evas *ee, Eina_Bool on);
+EAPI Eina_Bool       ecore_evas_software_x11_direct_resize_get(const Ecore_Evas *ee);
+EAPI void            ecore_evas_software_x11_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win);
+
+#define ECORE_EVAS_GL_X11_OPT_NONE     0
+#define ECORE_EVAS_GL_X11_OPT_INDIRECT 1
+#define ECORE_EVAS_GL_X11_OPT_VSYNC    2
+#define ECORE_EVAS_GL_X11_OPT_LAST     3
+
+EAPI Ecore_Evas     *ecore_evas_gl_x11_new(const char *disp_name, Ecore_X_Window parent, int x, int y, int w, int h);
+EAPI Ecore_Evas     *ecore_evas_gl_x11_options_new(const char *disp_name, Ecore_X_Window parent, int x, int y, int w, int h, const int *opt);
+EAPI Ecore_X_Window  ecore_evas_gl_x11_window_get(const Ecore_Evas *ee);
+EAPI void            ecore_evas_gl_x11_direct_resize_set(Ecore_Evas *ee, Eina_Bool on);
+EAPI Eina_Bool       ecore_evas_gl_x11_direct_resize_get(const Ecore_Evas *ee);
+EAPI void            ecore_evas_gl_x11_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win);
+EAPI void            ecore_evas_gl_x11_pre_post_swap_callback_set(const Ecore_Evas *ee, void *data, void (*pre_cb) (void *data, Evas *e), void (*post_cb) (void *data, Evas *e));
+
+EAPI Ecore_Evas     *ecore_evas_xrender_x11_new(const char *disp_name, Ecore_X_Window parent, int x, int y, int w, int h);
+EAPI Ecore_X_Window  ecore_evas_xrender_x11_window_get(const Ecore_Evas *ee);
+EAPI void            ecore_evas_xrender_x11_direct_resize_set(Ecore_Evas *ee, Eina_Bool on);
+EAPI Eina_Bool       ecore_evas_xrender_x11_direct_resize_get(const Ecore_Evas *ee);
+EAPI void            ecore_evas_xrender_x11_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win);
+
+EAPI Ecore_Evas     *ecore_evas_software_x11_8_new(const char *disp_name, Ecore_X_Window parent, int x, int y, int w, int h);
+EAPI Ecore_X_Window  ecore_evas_software_x11_8_window_get(const Ecore_Evas *ee);
+EAPI Ecore_X_Window  ecore_evas_software_x11_8_subwindow_get(const Ecore_Evas *ee);
+EAPI void            ecore_evas_software_x11_8_direct_resize_set(Ecore_Evas *ee, Eina_Bool on);
+EAPI Eina_Bool       ecore_evas_software_x11_8_direct_resize_get(const Ecore_Evas *ee);
+EAPI void            ecore_evas_software_x11_8_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win);
+
+EAPI Ecore_Evas     *ecore_evas_software_x11_16_new(const char *disp_name, Ecore_X_Window parent, int x, int y, int w, int h);
+EAPI Ecore_X_Window  ecore_evas_software_x11_16_window_get(const Ecore_Evas *ee);
+EAPI void            ecore_evas_software_x11_16_direct_resize_set(Ecore_Evas *ee, Eina_Bool on);
+EAPI Eina_Bool       ecore_evas_software_x11_16_direct_resize_get(const Ecore_Evas *ee);
+EAPI void            ecore_evas_software_x11_16_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win);
+
+EAPI Ecore_Evas     *ecore_evas_fb_new(const char *disp_name, int rotation, int w, int h);
+
+EAPI Ecore_Evas     *ecore_evas_directfb_new(const char *disp_name, int windowed, int x, int y, int w, int h);
+EAPI Ecore_DirectFB_Window *ecore_evas_directfb_window_get(const Ecore_Evas *ee);
+
+/**
+ * @brief Create a new @c Ecore_Evas canvas bound to the Evas
+ * @b buffer engine
+ *
+ * @param w The width of the canvas, in pixels
+ * @param h The height of the canvas, in pixels
+ * @return A new @c Ecore_Evas instance or @c NULL, on failure
+ *
+ * This creates a new buffer canvas wrapper, with image data array
+ * @b bound to the ARGB format, 8 bits per pixel.
+ *
+ * This function will allocate the needed pixels array with canonical
+ * @c malloc(). If you wish a custom function to allocate it, consider
+ * using ecore_evas_buffer_allocfunc_new(), instead.
+ *
+ * @note This function actually is a wrapper on
+ * ecore_evas_buffer_allocfunc_new(), using the same @a w and @a h
+ * arguments and canonical @c malloc() and @c free() to the memory
+ * allocation and freeing functions. See that function's documentation
+ * for more details.
+ */
+EAPI Ecore_Evas     *ecore_evas_buffer_new(int w, int h);
+
+/**
+ * @brief Create a new @c Ecore_Evas canvas bound to the Evas
+ * @b buffer engine, giving custom allocation and freeing functions for
+ * the canvas memory region
+ *
+ * @param w The width of the canvas, in canvas units
+ * @param h The height of the canvas, in canvas units
+ * @param alloc_func Function to be called to allocate the memory
+ * needed for the new buffer canvas. @a data will be passed the same
+ * value as the @p data of this function, while @a size will be passed
+ * @p w times @p h times @c sizeof(int).
+ * @param free_func Function to be called to free the memory used by
+ * the new buffer canvas. @a data will be passed the same value as the
+ * @p data of this function, while @a pix will be passed the canvas
+ * memory pointer.
+ * @param data Custom data to be passed to the allocation and freeing
+ * functions
+ * @return A new @c Ecore_Evas instance or @c NULL, on failure
+ *
+ * This creates a new buffer canvas wrapper, with image data array
+ * @b bound to the ARGB format, 8 bits per pixel.
+ *
+ * This function is useful when one wants an @c Ecore_Evas buffer
+ * canvas with a custom allocation function, like one getting memory
+ * chunks from a memory pool, for example.
+ *
+ * On any resizing of this @c Ecore_Evas buffer canvas, its image data
+ * will be @b freed, to be allocated again with the new size.
+ *
+ * @note @p w and @p h sizes have to greater or equal to 1. Otherwise,
+ * they'll be interpreted as 1, exactly.
+ *
+ * @see ecore_evas_buffer_new()
+ */
+EAPI Ecore_Evas     *ecore_evas_buffer_allocfunc_new(int w, int h, void *(*alloc_func) (void *data, int size), void (*free_func) (void *data, void *pix), const void *data);
+
+/**
+ * @brief Grab a pointer to the actual pixels array of a given
+ * @c Ecore_Evas @b buffer canvas/window.
+ *
+ * @param ee An @c Ecore_Evas handle
+ * @return A pointer to the internal pixels array of @p ee
+ *
+ * Besides returning a pointer to the actual pixel array of the given
+ * canvas, this call will force a <b>rendering update on @p ee</b>,
+ * first.
+ *
+ * A common use case for this call is to create an image object, from
+ * @b another canvas, to have as data @p ee's contents, thus
+ * snapshoting the canvas. For that case, one can also use the
+ * ecore_evas_object_image_new() helper function.
+ */
+EAPI const void     *ecore_evas_buffer_pixels_get(Ecore_Evas *ee);
+
+/**
+ * @brief Create a new @c Ecore_Evas canvas bound to the Evas
+ * @b ews (Ecore + Evas Single Process Windowing System) engine
+ *
+ * EWS is a simple single process windowing system. The backing store
+ * is also an @c Ecore_Evas that can be setup with
+ * ecore_evas_ews_setup() and retrieved with
+ * ecore_evas_ews_ecore_evas_get(). It will allow window management
+ * using events prefixed with @c ECORE_EVAS_EVENT_EWS_.
+ *
+ * The EWS windows (returned by this function or
+ * ecore_evas_new("ews"...)) will all be software buffer windows
+ * automatic rendered to the backing store.
+ *
+ * @param x horizontal position of window, in pixels
+ * @param y vertical position of window, in pixels
+ * @param w The width of the canvas, in pixels
+ * @param h The height of the canvas, in pixels
+ * @return A new @c Ecore_Evas instance or @c NULL, on failure
+ *
+ * @see ecore_evas_ews_setup()
+ * @see ecore_evas_ews_ecore_evas_get()
+ *
+ * @since 1.1
+ */
+EAPI Ecore_Evas     *ecore_evas_ews_new(int x, int y, int w, int h);
+
+
+/**
+ * Returns the backing store image object that represents the given
+ * window in EWS.
+ *
+ * @note This should not be modified anyhow, but may be helpful to
+ *       determine stacking and geometry of it for window managers
+ *       that decorate windows.
+ *
+ * @see ecore_evas_ews_manager_set()
+ * @see ecore_evas_ews_evas_get()
+ * @since 1.1
+ */
+EAPI Evas_Object *ecore_evas_ews_backing_store_get(const Ecore_Evas *ee);
+
+/**
+ * Calls the window to be deleted (freed), but can let user decide to
+ * forbid it by using ecore_evas_callback_delete_request_set()
+ *
+ * @since 1.1
+ */
+EAPI void ecore_evas_ews_delete_request(Ecore_Evas *ee);
+
+/**
+ * @brief Create an Evas image object with image data <b>bound to an
+ * own, internal @c Ecore_Evas canvas wrapper<b>
+ *
+ * @param ee_target @c Ecore_Evas to have the canvas receiving the new
+ * image object
+ * @return A handle to the new image object
+ *
+ * This will create a @b special Evas image object. The image's pixel
+ * array will get bound to the same image data array of an @b internal
+ * @b buffer @c Ecore_Evas canvas. The user of this function is, then,
+ * supposed to grab that @c Ecore_Evas handle, with
+ * ecore_evas_object_ecore_evas_get(), and use its canvas to render
+ * whichever contents he/she wants, @b independently of the contents
+ * of the canvas owned by @p ee_target. Those contents will reflect on
+ * the canvas of @p ee, though, being exactly the image data of the
+ * object returned by this function.
+ *
+ * This is a helper function for the scenario of one wanting to grab a
+ * buffer canvas' contents (with ecore_evas_buffer_pixels_get()) to be
+ * used on another canvas, for whichever reason. The most common goal
+ * of this setup is to @b save an image file with a whole canvas as
+ * contents, which could not be achieved by using an image file within
+ * the target canvas.
+ *
+ * @warning Always resize the returned image and its underlying
+ * @c Ecore_Evas handle accordingly. They must be kept with same sizes
+ * for things to work as expected. Also, you @b must issue
+ * @c evas_object_image_size_set() on the image with that same size. If
+ * the image is to be shown in a canvas bound to an engine different
+ * than the buffer one, then you must also set this image's @b fill
+ * properties accordingly.
+ *
+ * @note The image returned will always be bound to the
+ * @c EVAS_COLORSPACE_ARGB8888 colorspace, always.
+ *
+ * @note Use ecore_evas_object_evas_get() to grab the image's internal
+ * own canvas directly.
+ *
+ * @note If snapshoting this image's internal canvas, remember to
+ * flush its internal @c Ecore_Evas firstly, with
+ * ecore_evas_manual_render().
+ */
+EAPI Evas_Object    *ecore_evas_object_image_new(Ecore_Evas *ee_target);
+
+/**
+ * @brief Retrieve the internal @c Ecore_Evas handle of an image
+ * object created via ecore_evas_object_image_new()
+ *
+ * @param obj A handle to an image object created via
+ * ecore_evas_object_image_new()
+ * @return The underlying @c Ecore_Evas handle in @p obj
+ */
+EAPI Ecore_Evas     *ecore_evas_object_ecore_evas_get(Evas_Object *obj);
+
+/**
+ * @brief Retrieve the canvas bound to the internal @c Ecore_Evas
+ * handle of an image object created via ecore_evas_object_image_new()
+ *
+ * @param obj A handle to an image object created via
+ * ecore_evas_object_image_new()
+ * @return A handle to @p obj's underlying @c Ecore_Evas's canvas
+ */
+EAPI Evas           *ecore_evas_object_evas_get(Evas_Object *obj);
+
+EAPI Ecore_Evas     *ecore_evas_software_gdi_new(Ecore_Win32_Window *parent,
+                                                 int                 x,
+                                                 int                 y,
+                                                 int                 width,
+                                                 int                 height);
+
+EAPI Ecore_Evas     *ecore_evas_software_ddraw_new(Ecore_Win32_Window *parent,
+                                                   int                 x,
+                                                   int                 y,
+                                                   int                 width,
+                                                   int                 height);
+
+EAPI Ecore_Evas     *ecore_evas_software_16_ddraw_new(Ecore_Win32_Window *parent,
+                                                      int                 x,
+                                                      int                 y,
+                                                      int                 width,
+                                                      int                 height);
+
+EAPI Ecore_Evas     *ecore_evas_direct3d_new(Ecore_Win32_Window *parent,
+                                             int                 x,
+                                             int                 y,
+                                             int                 width,
+                                             int                 height);
+
+EAPI Ecore_Evas *ecore_evas_gl_glew_new(Ecore_Win32_Window *parent,
+                                        int                 x,
+                                        int                 y,
+                                        int                 width,
+                                        int                 height);
+
+EAPI Ecore_Win32_Window *ecore_evas_win32_window_get(const Ecore_Evas *ee);
+
+EAPI Ecore_Evas     *ecore_evas_sdl_new(const char* name, int w, int h, int fullscreen, int hwsurface, int noframe, int alpha);
+EAPI Ecore_Evas     *ecore_evas_sdl16_new(const char* name, int w, int h, int fullscreen, int hwsurface, int noframe, int alpha);
+EAPI Ecore_Evas     *ecore_evas_gl_sdl_new(const char* name, int w, int h, int fullscreen, int noframe);
+
+EAPI Ecore_Evas     *ecore_evas_software_wince_new(Ecore_WinCE_Window *parent,
+                                                   int                 x,
+                                                   int                 y,
+                                                   int                 width,
+                                                   int                 height);
+
+EAPI Ecore_Evas     *ecore_evas_software_wince_fb_new(Ecore_WinCE_Window *parent,
+                                                      int                 x,
+                                                      int                 y,
+                                                      int                 width,
+                                                      int                 height);
+
+EAPI Ecore_Evas     *ecore_evas_software_wince_gapi_new(Ecore_WinCE_Window *parent,
+                                                        int                 x,
+                                                        int                 y,
+                                                        int                 width,
+                                                        int                 height);
+
+EAPI Ecore_Evas     *ecore_evas_software_wince_ddraw_new(Ecore_WinCE_Window *parent,
+                                                         int                 x,
+                                                         int                 y,
+                                                         int                 width,
+                                                         int                 height);
+
+EAPI Ecore_Evas     *ecore_evas_software_wince_gdi_new(Ecore_WinCE_Window *parent,
+                                                       int                 x,
+                                                       int                 y,
+                                                       int                 width,
+                                                       int                 height);
+
+EAPI Ecore_WinCE_Window *ecore_evas_software_wince_window_get(const Ecore_Evas *ee);
+
+EAPI Ecore_Evas *ecore_evas_cocoa_new(Ecore_Cocoa_Window *parent,
+                                      int x,
+                                      int y,
+                                      int w,
+                                      int h);
+
+EAPI Ecore_Evas *ecore_evas_psl1ght_new(const char* name, int w, int h);
+
+
+/* generic manipulation calls */
+/**
+ * @brief Get the engine name used by this Ecore_Evas(window).
+ *
+ * @param ee Ecore_Evas whose engine's name is desired.
+ * @return A string that can(usually) be used in ecore_evas_new()
+ *
+ * @see ecore_evas_free()
+ */
+EAPI const char *ecore_evas_engine_name_get(const Ecore_Evas *ee);
+/**
+ * @brief Return the Ecore_Evas for this Evas
+ *
+ * @param e The Evas to get the Ecore_Evas from
+ * @return The Ecore_Evas that holds this Evas, or NULL if not held by one.
+ *
+ * @warning Only use on Evas' created with ecore evas!
+ */
+EAPI Ecore_Evas *ecore_evas_ecore_evas_get(const Evas *e);
+/**
+ * @brief Free an Ecore_Evas
+ *
+ * @param ee The Ecore_Evas to free
+ *
+ * This frees up any memory used by the Ecore_Evas.
+ */
+EAPI void        ecore_evas_free(Ecore_Evas *ee);
+/**
+ * @brief Retrieve user data associated with an Ecore_Evas.
+ *
+ * @param ee The Ecore_Evas to retrieve the user data from.
+ * @param key The key which the user data to be retrieved is associated with.
+ *
+ * This function retrieves user specific data that has been stored within an
+ * Ecore_Evas structure with ecore_evas_data_set().
+ *
+ * @returns NULL on error or no data found, A pointer to the user data on
+ *     success.
+ *
+ * @see ecore_evas_data_set()
+ */
+EAPI void       *ecore_evas_data_get(const Ecore_Evas *ee, const char *key);
+/**
+ * @brief Store user data in an Ecore_Evas structure.
+ *
+ * @param ee The Ecore_Evas to store the user data in.
+ * @param key A unique string to associate the user data against. Cannot
+ * be NULL.
+ * @param data A pointer to the user data to store.
+ *
+ * This function associates the @p data with a @p key which is stored by
+ * the Ecore_Evas @p ee. Be aware that a call to ecore_evas_free() will
+ * not free any memory for the associated user data, this is the responsibility
+ * of the caller.
+ *
+ * @see ecore_evas_callback_pre_free_set()
+ * @see ecore_evas_free()
+ * @see ecore_evas_data_get()
+ */
+EAPI void        ecore_evas_data_set(Ecore_Evas *ee, const char *key, const void *data);
+/**
+ * Set a callback for Ecore_Evas resize events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called whenever @p ee is resized.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_resize_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas move events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called whenever @p ee is moved.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_move_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas show events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called whenever @p ee is shown.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_show_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas hide events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called whenever @p ee is hidden.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_hide_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas delete request events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called whenever @p ee gets a delete request.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_delete_request_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas destroy events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called whenever @p ee is destroyed.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_destroy_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas focus in events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called whenever @p ee gets focus.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_focus_in_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas focus out events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called whenever @p ee loses focus.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_focus_out_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas sticky events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called whenever @p ee becomes sticky.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_sticky_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas un-sticky events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called whenever @p ee becomes un-sticky.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_unsticky_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas mouse in events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called whenever the mouse enters @p ee.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_mouse_in_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas mouse out events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called whenever the mouse leaves @p ee.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_mouse_out_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas pre render events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called just before the evas in @p ee is rendered.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_pre_render_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas mouse post render events.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called just after the evas in @p ee is rendered.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_post_render_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+/**
+ * Set a callback for Ecore_Evas pre-free event.
+ * @param ee The Ecore_Evas to set callbacks on
+ * @param func The function to call
+ *
+ * A call to this function will set a callback on an Ecore_Evas, causing
+ * @p func to be called just before the instance @p ee is freed.
+ *
+ * @warning If and when this function is called depends on the underlying
+ * windowing system.
+ */
+EAPI void        ecore_evas_callback_pre_free_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+EAPI Evas       *ecore_evas_get(const Ecore_Evas *ee);
+EAPI void        ecore_evas_managed_move(Ecore_Evas *ee, int x, int y);
+EAPI void        ecore_evas_shaped_set(Ecore_Evas *ee, Eina_Bool shaped);
+EAPI Eina_Bool   ecore_evas_shaped_get(const Ecore_Evas *ee);
+/**
+ * @brief Show an Ecore_Evas' window
+ *
+ * @param ee The Ecore_Evas to show.
+ *
+ * This function makes @p ee visible.
+ */
+EAPI void        ecore_evas_show(Ecore_Evas *ee);
+/**
+ * @brief Hide an Ecore_Evas' window
+ *
+ * @param ee The Ecore_Evas to hide.
+ *
+ * This function makes @p ee hidden(not visible).
+ */
+EAPI void        ecore_evas_hide(Ecore_Evas *ee);
+EAPI void        ecore_evas_activate(Ecore_Evas *ee);
+
+
+/**
+ * Set the minimum size of a given @c Ecore_Evas window
+ *
+ * @param ee An @c Ecore_Evas window's handle
+ * @param w The minimum width
+ * @param h The minimum height
+ *
+ * This function sets the minimum size of @p ee to be @p w x @p h.
+ * One won't be able to resize that window to dimensions smaller than
+ * the ones set.
+ *
+ * @note When base sizes are set, via ecore_evas_size_base_set(),
+ * they'll be used to calculate a window's minimum size, instead of
+ * those set by this function.
+ *
+ * @see ecore_evas_size_min_get()
+ */
+EAPI void        ecore_evas_size_min_set(Ecore_Evas *ee, int w, int h);
+
+/**
+ * Get the minimum size set for a given @c Ecore_Evas window
+ *
+ * @param ee An @c Ecore_Evas window's handle
+ * @param w A pointer to an int to place the minimum width in.
+ * @param h A pointer to an int to place the minimum height in.
+ *
+ * @note Use @c NULL pointers on the size components you're not
+ * interested in: they'll be ignored by the function.
+ *
+ * @see ecore_evas_size_min_set() for more details
+ */
+EAPI void        ecore_evas_size_min_get(const Ecore_Evas *ee, int *w, int *h);
+
+/**
+ * Set the maximum size of a given @c Ecore_Evas window
+ *
+ * @param ee An @c Ecore_Evas window's handle
+ * @param w The maximum width
+ * @param h The maximum height
+ *
+ * This function sets the maximum size of @p ee to be @p w x @p h.
+ * One won't be able to resize that window to dimensions bigger than
+ * the ones set.
+ *
+ * @see ecore_evas_size_max_get()
+ */
+EAPI void        ecore_evas_size_max_set(Ecore_Evas *ee, int w, int h);
+
+/**
+ * Get the maximum size set for a given @c Ecore_Evas window
+ *
+ * @param ee An @c Ecore_Evas window's handle
+ * @param w A pointer to an int to place the maximum width in.
+ * @param h A pointer to an int to place the maximum height in.
+ *
+ * @note Use @c NULL pointers on the size components you're not
+ * interested in: they'll be ignored by the function.
+ *
+ * @see ecore_evas_size_max_set() for more details
+ */
+EAPI void        ecore_evas_size_max_get(const Ecore_Evas *ee, int *w, int *h);
+
+/**
+ * Set the base size for a given @c Ecore_Evas window
+ *
+ * @param ee An @c Ecore_Evas window's handle
+ * @param w The base width
+ * @param h The base height
+ *
+ * This function sets the @b base size of @p ee to be @p w x @p h.
+ * When base sizes are set, they'll be used to calculate a window's
+ * @b minimum size, instead of those set by ecore_evas_size_min_get().
+ *
+ * @see ecore_evas_size_base_get()
+ */
+EAPI void        ecore_evas_size_base_set(Ecore_Evas *ee, int w, int h);
+
+/**
+ * Get the base size set for a given @c Ecore_Evas window
+ *
+ * @param ee An @c Ecore_Evas window's handle
+ * @param w A pointer to an int to place the base width in.
+ * @param h A pointer to an int to place the base height in.
+ *
+ * @note Use @c NULL pointers on the size components you're not
+ * interested in: they'll be ignored by the function.
+ *
+ * @see ecore_evas_size_base_set() for more details
+ */
+EAPI void        ecore_evas_size_base_get(const Ecore_Evas *ee, int *w, int *h);
+
+/**
+ * Set the "size step" for a given @c Ecore_Evas window
+ *
+ * @param ee An @c Ecore_Evas window's handle
+ * @param w The step width
+ * @param h The step height
+ *
+ * This function sets the size steps of @p ee to be @p w x @p h. This
+ * limits the size of this @cEcore_Evas window to be @b always an
+ * integer multiple of the step size, for each axis.
+ */
+EAPI void        ecore_evas_size_step_set(Ecore_Evas *ee, int w, int h);
+
+/**
+ * Get the "size step" set for a given @c Ecore_Evas window
+ *
+ * @param ee An @c Ecore_Evas window's handle
+ * @param w A pointer to an int to place the step width in.
+ * @param h A pointer to an int to place the step height in.
+ *
+ * @note Use @c NULL pointers on the size components you're not
+ * interested in: they'll be ignored by the function.
+ *
+ * @see ecore_evas_size_base_set() for more details
+ */
+EAPI void        ecore_evas_size_step_get(const Ecore_Evas *ee, int *w, int *h);
+
+/**
+ * @brief Set the cursor of an Ecore_Evas.
+ *
+ * @param ee The Ecore_Evas
+ * @param file  The path to an image file for the cursor.
+ * @param layer The layer in which the cursor will appear.
+ * @param hot_x The x coordinate of the cursor's hot spot.
+ * @param hot_y The y coordinate of the cursor's hot spot.
+ *
+ * This function makes the mouse cursor over @p ee be the image specified by
+ * @p file. The actual point within the image that the mouse is at is specified
+ * by @p hot_x and @p hot_y, which are coordinates with respect to the top left
+ * corner of the cursor image.
+ *
+ * @note This function creates an object from the image and uses
+ * ecore_evas_object_cursor_set().
+ *
+ * @see ecore_evas_object_cursor_set()
+ */
+EAPI void        ecore_evas_cursor_set(Ecore_Evas *ee, const char *file, int layer, int hot_x, int hot_y);
+/**
+ * @brief Get information about an Ecore_Evas' cursor
+ *
+ * @param ee The Ecore_Evas to set
+ * @param obj A pointer to an Evas_Object to place the cursor Evas_Object.
+ * @param layer A pointer to an int to place the cursor's layer in.
+ * @param hot_x A pointer to an int to place the cursor's hot_x coordinate in.
+ * @param hot_y A pointer to an int to place the cursor's hot_y coordinate in.
+ *
+ * This function queries information about an Ecore_Evas' cursor.
+ *
+ * @see ecore_evas_cursor_set()
+ * @see ecore_evas_object_cursor_set()
+ */
+EAPI void        ecore_evas_cursor_get(const Ecore_Evas *ee, Evas_Object **obj, int *layer, int *hot_x, int *hot_y);
+/**
+ * @brief Set the cursor of an Ecore_Evas
+ *
+ * @param ee The Ecore_Evas
+ *
+ * @param obj The Evas_Object which will be the cursor.
+ * @param layer The layer in which the cursor will appear.
+ * @param hot_x The x coordinate of the cursor's hot spot.
+ * @param hot_y The y coordinate of the cursor's hot spot.
+ *
+ * This function makes the mouse cursor over @p ee be the object specified by
+ * @p obj. The actual point within the object that the mouse is at is specified
+ * by @p hot_x and @p hot_y, which are coordinates with respect to the top left
+ * corner of the cursor object.
+ *
+ * @see ecore_evas_cursor_set()
+ */
+EAPI void        ecore_evas_object_cursor_set(Ecore_Evas *ee, Evas_Object *obj, int layer, int hot_x, int hot_y);
+EAPI void        ecore_evas_override_set(Ecore_Evas *ee, Eina_Bool on);
+EAPI Eina_Bool   ecore_evas_override_get(const Ecore_Evas *ee);
+EAPI void        ecore_evas_avoid_damage_set(Ecore_Evas *ee, Ecore_Evas_Avoid_Damage_Type on);
+EAPI Ecore_Evas_Avoid_Damage_Type ecore_evas_avoid_damage_get(const Ecore_Evas *ee);
+EAPI void        ecore_evas_withdrawn_set(Ecore_Evas *ee, Eina_Bool withdrawn);
+EAPI Eina_Bool   ecore_evas_withdrawn_get(const Ecore_Evas *ee);
+EAPI void        ecore_evas_sticky_set(Ecore_Evas *ee, Eina_Bool sticky);
+EAPI Eina_Bool   ecore_evas_sticky_get(const Ecore_Evas *ee);
+EAPI void        ecore_evas_manual_render_set(Ecore_Evas *ee, Eina_Bool manual_render);
+EAPI Eina_Bool   ecore_evas_manual_render_get(const Ecore_Evas *ee);
+
+/**
+ * @brief Registers an @c Ecore_Evas to receive events through ecore_input_evas.
+ *
+ * @param ee The @c Ecore_Evas handle.
+ *
+ * This function calls ecore_event_window_register() with the @p ee as its @c
+ * id argument, @c window argument, and uses its @c Evas too. It is useful when
+ * no @c window information is available on a given @c Ecore_Evas backend.
+ *
+ * @see ecore_evas_input_event_unregister()
+ * @since 1.1
+ */
+EAPI void        ecore_evas_input_event_register(Ecore_Evas *ee);
+/**
+ * @brief Unregisters an @c Ecore_Evas receiving events through ecore_input_evas.
+ *
+ * @param ee The @c Ecore_Evas handle.
+ *
+ * @see ecore_evas_input_event_register()
+ * @since 1.1
+ */
+EAPI void        ecore_evas_input_event_unregister(Ecore_Evas *ee);
+
+/**
+ * @brief Force immediate rendering on a given @c Ecore_Evas window
+ *
+ * @param ee An @c Ecore_Evas handle
+ *
+ * Use this call to forcefully flush the @p ee's canvas rendering
+ * pipeline, thus bring its window to an up to date state.
+ */
+EAPI void        ecore_evas_manual_render(Ecore_Evas *ee);
+EAPI void        ecore_evas_comp_sync_set(Ecore_Evas *ee, Eina_Bool do_sync);
+EAPI Eina_Bool   ecore_evas_comp_sync_get(const Ecore_Evas *ee);
+/**
+ * @brief Get geometry of screen associated with this Ecore_Evas.
+ *
+ * @param ee The Ecore_Evas whose window's to query container screen geometry.
+ * @param x where to return the horizontal offset value. May be NULL.
+ * @param y where to return the vertical offset value. May be NULL.
+ * @param w where to return the width value. May be NULL.
+ * @param h where to return the height value. May be NULL.
+ *
+ * @since 1.1
+ */
+EAPI void        ecore_evas_screen_geometry_get(const Ecore_Evas *ee, int *x, int *y, int *w, int *h);
+
+/**
+ * @brief Associate the given object to this ecore evas.
+ *
+ * @param ee The Ecore_Evas to associate to @a obj
+ * @param obj The object to associate to @a ee
+ * @param flags The association flags.
+ * @return EINA_TRUE on success, EINA_FALSE otherwise.
+ *
+ * Association means that operations on one will affect the other, for
+ * example moving the object will move the window, resize the object will
+ * also affect the ecore evas window, hide and show applies as well.
+ *
+ * This is meant to simplify development, since you often need to associate
+ * these events with your "base" objects, background or bottom-most object.
+ *
+ * Be aware that some methods might not be what you would like, deleting
+ * either the window or the object will delete the other. If you want to
+ * change that behavior, let's say to hide window when it's closed, you
+ * must use ecore_evas_callback_delete_request_set() and set your own code,
+ * like ecore_evas_hide(). Just remember that if you override delete_request
+ * and still want to delete the window/object, you must do that yourself.
+ *
+ * Since we now define delete_request, deleting windows will not quit
+ * main loop, if you wish to do so, you should listen for EVAS_CALLBACK_FREE
+ * on the object, that way you get notified and you can call
+ * ecore_main_loop_quit().
+ *
+ * Flags can be OR'ed of:
+ * @li ECORE_EVAS_OBJECT_ASSOCIATE_BASE (or 0): to listen to basic events
+ *     like delete, resize and move, but no stacking or layer are used.
+ * @li ECORE_EVAS_OBJECT_ASSOCIATE_STACK: stacking operations will act
+ *     on the Ecore_Evas, not the object. So evas_object_raise() will
+ *     call ecore_evas_raise(). Relative operations (stack_above, stack_below)
+ *     are still not implemented.
+ * @li ECORE_EVAS_OBJECT_ASSOCIATE_LAYER: stacking operations will act
+ *     on the Ecore_Evas, not the object. So evas_object_layer_set() will
+ *     call ecore_evas_layer_set().
+ * @li ECORE_EVAS_OBJECT_ASSOCIATE_DEL: the object delete will delete the
+ *     ecore_evas as well as delete_requests on the ecore_evas will delete
+ *     etc.
+ */
+EAPI Eina_Bool    ecore_evas_object_associate(Ecore_Evas *ee, Evas_Object *obj, Ecore_Evas_Object_Associate_Flags flags);
+/**
+ * @brief Cancel the association set with ecore_evas_object_associate().
+ *
+ * @param ee The Ecore_Evas to dissociate from @a obj
+ * @param obj The object to dissociate from @a ee
+ * @return EINA_TRUE on success, EINA_FALSE otherwise.
+ */
+EAPI Eina_Bool    ecore_evas_object_dissociate(Ecore_Evas *ee, Evas_Object *obj);
+/**
+ * @brief Get the object associated with @p ee
+ *
+ * @param ee The Ecore_Evas to get the object from.
+ * @return The associated object, or NULL if there is no associated object.
+ */
+EAPI Evas_Object *ecore_evas_object_associate_get(const Ecore_Evas *ee);
+
+/* helper function to be used with ECORE_GETOPT_CALLBACK_*() */
+EAPI unsigned char ecore_getopt_callback_ecore_evas_list_engines(const Ecore_Getopt *parser, const Ecore_Getopt_Desc *desc, const char *str, void *data, Ecore_Getopt_Value *storage);
+
+/**
+ * @brief Get a list of all the ecore_evases.
+ *
+ * @return A list of ecore_evases.
+ *
+ * The returned list of ecore evases is only valid until the canvases are
+ * destroyed (and should not be cached for instance). The list can be freed by
+ * just deleting the list.
+ */
+EAPI Eina_List   *ecore_evas_ecore_evas_list_get(void);
+
+/* specific calls to an x11 environment ecore_evas */
+EAPI void           ecore_evas_x11_leader_set(Ecore_Evas *ee, Ecore_X_Window win);
+EAPI Ecore_X_Window ecore_evas_x11_leader_get(Ecore_Evas *ee);
+EAPI void           ecore_evas_x11_leader_default_set(Ecore_Evas *ee);
+EAPI void           ecore_evas_x11_shape_input_rectangle_set(Ecore_Evas *ee, int x, int y, int w, int h);
+EAPI void           ecore_evas_x11_shape_input_rectangle_add(Ecore_Evas *ee, int x, int y, int w, int h);
+EAPI void           ecore_evas_x11_shape_input_rectangle_subtract(Ecore_Evas *ee, int x, int y, int w, int h);
+EAPI void           ecore_evas_x11_shape_input_empty(Ecore_Evas *ee);
+EAPI void           ecore_evas_x11_shape_input_reset(Ecore_Evas *ee);
+EAPI void           ecore_evas_x11_shape_input_apply(Ecore_Evas *ee);
+
+/**
+ * @defgroup Ecore_Evas_Ews Ecore_Evas Single Process Windowing System.
+ *
+ * These are global scope functions to manage the EWS to be used by
+ * ecore_evas_ews_new().
+ *
+ * @since 1.1
+ * @{
+ */
+
+/**
+ * Sets the engine to be used by the backing store engine.
+ *
+ * @return EINA_TRUE on success, EINA_FALSE if ews is already in use.
+ * @since 1.1
+ */
+EAPI Eina_Bool ecore_evas_ews_engine_set(const char *engine, const char *options);
+
+/**
+ * Reconfigure the backing store used.
+ * @since 1.1
+ */
+EAPI Eina_Bool ecore_evas_ews_setup(int x, int y, int w, int h);
+
+/**
+ * Return the internal backing store in use.
+ *
+ * @note this will foced it to be created, making future calls to
+ * ecore_evas_ews_engine_set() void.
+ *
+ * @see ecore_evas_ews_evas_get()
+ * @since 1.1
+ */
+EAPI Ecore_Evas *ecore_evas_ews_ecore_evas_get(void);
+
+/**
+ * Return the internal backing store in use.
+ *
+ * @note this will foced it to be created, making future calls to
+ * ecore_evas_ews_engine_set() void.
+ *
+ * @see ecore_evas_ews_ecore_evas_get()
+ * @since 1.1
+ */
+EAPI Evas *ecore_evas_ews_evas_get(void);
+
+/**
+ * Get the current background.
+ */
+EAPI Evas_Object *ecore_evas_ews_background_get(void);
+
+/**
+ * Set the current background, must be created at evas ecore_evas_ews_evas_get()
+ *
+ * It will be kept at lowest layer (EVAS_LAYER_MIN) and below
+ * everything else. You can set any object, default is a black
+ * rectangle.
+ *
+ * @note previous object will be deleted!
+ */
+EAPI void ecore_evas_ews_background_set(Evas_Object *o);
+
+/**
+ * Return all Ecore_Evas* created by EWS.
+ *
+ * @note do not change the returned list or its contents.
+ * @since 1.1
+ */
+EAPI const Eina_List *ecore_evas_ews_children_get(void);
+
+/**
+ * Set the identifier of the manager taking care of internal windows.
+ *
+ * The ECORE_EVAS_EWS_EVENT_MANAGER_CHANGE event is issued. Consider
+ * handling it to know if you should stop handling events yourself
+ * (ie: another manager took over)
+ *
+ * @param manager any unique identifier address.
+ *
+ * @see ecore_evas_ews_manager_get()
+ * @since 1.1
+ */
+EAPI void        ecore_evas_ews_manager_set(const void *manager);
+
+/**
+ * Get the identifier of the manager taking care of internal windows.
+ *
+ * @return the value set by ecore_evas_ews_manager_set()
+ * @since 1.1
+ */
+EAPI const void *ecore_evas_ews_manager_get(void);
+
+EAPI extern int ECORE_EVAS_EWS_EVENT_MANAGER_CHANGE; /**< manager was changed */
+EAPI extern int ECORE_EVAS_EWS_EVENT_ADD; /**< window was created */
+EAPI extern int ECORE_EVAS_EWS_EVENT_DEL; /**< window was deleted, pointer is already invalid but may be used as reference for further cleanup work. */
+EAPI extern int ECORE_EVAS_EWS_EVENT_RESIZE; /**< window was resized */
+EAPI extern int ECORE_EVAS_EWS_EVENT_MOVE; /**< window was moved */
+EAPI extern int ECORE_EVAS_EWS_EVENT_SHOW; /**< window become visible */
+EAPI extern int ECORE_EVAS_EWS_EVENT_HIDE; /**< window become hidden */
+EAPI extern int ECORE_EVAS_EWS_EVENT_FOCUS; /**< window was focused */
+EAPI extern int ECORE_EVAS_EWS_EVENT_UNFOCUS; /**< window lost focus */
+EAPI extern int ECORE_EVAS_EWS_EVENT_RAISE; /**< window was raised */
+EAPI extern int ECORE_EVAS_EWS_EVENT_LOWER; /**< window was lowered */
+EAPI extern int ECORE_EVAS_EWS_EVENT_ACTIVATE; /**< window was activated */
+
+EAPI extern int ECORE_EVAS_EWS_EVENT_ICONIFIED_CHANGE; /**< window minimized/iconified changed */
+EAPI extern int ECORE_EVAS_EWS_EVENT_MAXIMIZED_CHANGE; /**< window maximized changed */
+EAPI extern int ECORE_EVAS_EWS_EVENT_LAYER_CHANGE; /**< window layer changed */
+EAPI extern int ECORE_EVAS_EWS_EVENT_FULLSCREEN_CHANGE; /**< window fullscreen changed */
+EAPI extern int ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE; /**< some other window property changed (title, name, class, alpha, transparent, shaped...) */
+
+/**
+ * @}
+ */
+
+
+/**
+ * @}
+ */
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif
diff --git a/libraries/ecore/src/lib/ecore_evas/Makefile.am b/libraries/ecore/src/lib/ecore_evas/Makefile.am
new file mode 100644
index 0000000..fbb7190
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/Makefile.am
@@ -0,0 +1,131 @@
+MAINTAINERCLEANFILES = Makefile.in
+
+if BUILD_ECORE_X
+ECORE_X_INC = -I$(top_srcdir)/src/lib/ecore_x @x_cflags@ @ECORE_XCB_CFLAGS@
+ECORE_X_LIB = $(top_builddir)/src/lib/ecore_x/libecore_x.la @x_libs@ @ECORE_XCB_LIBS@
+else
+ECORE_X_INC =
+ECORE_X_LIB =
+endif
+
+if BUILD_ECORE_FB
+ECORE_FB_INC = -I$(top_srcdir)/src/lib/ecore_fb
+ECORE_FB_LIB = $(top_builddir)/src/lib/ecore_fb/libecore_fb.la
+else
+ECORE_FB_INC =
+ECORE_FB_LIB =
+endif
+
+if BUILD_ECORE_DIRECTFB
+ECORE_DIRECTFB_INC = -I$(top_srcdir)/src/lib/ecore_directfb -I@DIRECTFB_CFLAGS@
+ECORE_DIRECTFB_LIB = $(top_builddir)/src/lib/ecore_directfb/libecore_directfb.la
+else
+ECORE_DIRECTFB_INC =
+ECORE_DIRECTFB_LIB =
+endif
+
+if BUILD_ECORE_WIN32
+ECORE_WIN32_INC = -I$(top_srcdir)/src/lib/ecore_win32
+ECORE_WIN32_LIB = $(top_builddir)/src/lib/ecore_win32/libecore_win32.la
+else
+ECORE_WIN32_INC =
+ECORE_WIN32_LIB =
+endif
+
+if BUILD_ECORE_SDL
+ECORE_SDL_INC = -I$(top_srcdir)/src/lib/ecore_sdl @SDL_CFLAGS@
+ECORE_SDL_LIB = $(top_builddir)/src/lib/ecore_sdl/libecore_sdl.la
+ECORE_SDL_LIBADD = @SDL_LIBS@ $(ECORE_SDL_LIB)
+else
+ECORE_SDL_INC =
+ECORE_SDL_LIB =
+ECORE_SDL_LIBADD =
+endif
+
+if BUILD_ECORE_COCOA
+ECORE_COCOA_INC = -I$(top_srcdir)/src/lib/ecore_cocoa
+ECORE_COCOA_LIB = $(top_builddir)/src/lib/ecore_cocoa/libecore_cocoa.la
+else
+ECORE_COCOA_INC =
+ECORE_COCOA_LIB =
+endif
+
+if BUILD_ECORE_WINCE
+ECORE_WINCE_INC = -I$(top_srcdir)/src/lib/ecore_wince
+ECORE_WINCE_LIB = $(top_builddir)/src/lib/ecore_wince/libecore_wince.la
+else
+ECORE_WINCE_INC =
+ECORE_WINCE_LIB =
+endif
+
+if BUILD_ECORE_PSL1GHT
+ECORE_PSL1GHT_INC = -I$(top_srcdir)/src/lib/ecore_psl1ght
+ECORE_PSL1GHT_LIB = $(top_builddir)/src/lib/ecore_psl1ght/libecore_psl1ght.la
+else
+ECORE_PSL1GHT_INC =
+ECORE_PSL1GHT_LIB =
+endif
+
+AM_CPPFLAGS = \
+-I$(top_srcdir)/src/lib/ecore \
+-I$(top_srcdir)/src/lib/ecore_evas \
+-I$(top_srcdir)/src/lib/ecore_input \
+-I$(top_srcdir)/src/lib/ecore_input_evas \
+-I$(top_builddir)/src/lib/ecore \
+-I$(top_builddir)/src/lib/ecore_evas \
+-I$(top_builddir)/src/lib/ecore_input \
+-I$(top_builddir)/src/lib/ecore_input_evas \
+@EFL_ECORE_EVAS_BUILD@ \
+$(ECORE_X_INC) \
+$(ECORE_FB_INC) \
+$(ECORE_DIRECTFB_INC) \
+$(ECORE_WIN32_INC) \
+$(ECORE_SDL_INC) \
+$(ECORE_COCOA_INC) \
+$(ECORE_WINCE_INC) \
+$(ECORE_PSL1GHT_INC) \
+@EVAS_CFLAGS@ \
+@EINA_CFLAGS@ \
+@EVIL_CFLAGS@
+
+AM_CFLAGS = @WIN32_CFLAGS@
+
+lib_LTLIBRARIES = libecore_evas.la
+includes_HEADERS = Ecore_Evas.h
+includesdir = $(includedir)/ecore-@VMAJ@
+
+libecore_evas_la_SOURCES = \
+ecore_evas.c \
+ecore_evas_util.c \
+ecore_evas_x.c \
+ecore_evas_fb.c \
+ecore_evas_buffer.c \
+ecore_evas_directfb.c \
+ecore_evas_win32.c \
+ecore_evas_sdl.c \
+ecore_evas_cocoa.c \
+ecore_evas_wince.c \
+ecore_evas_ews.c \
+ecore_evas_psl1ght.c
+
+libecore_evas_la_LIBADD = \
+$(ECORE_X_LIB) \
+$(ECORE_FB_LIB) \
+$(ECORE_DIRECTFB_LIB) \
+$(ECORE_WIN32_LIB) \
+$(ECORE_SDL_LIB) \
+$(ECORE_SDL_LIBADD) \
+$(ECORE_COCOA_LIB) \
+$(ECORE_WINCE_LIB) \
+$(ECORE_PSL1GHT_LIB) \
+$(top_builddir)/src/lib/ecore_input/libecore_input.la \
+$(top_builddir)/src/lib/ecore_input_evas/libecore_input_evas.la \
+$(top_builddir)/src/lib/ecore/libecore.la \
+@EVAS_LIBS@ \
+@EINA_LIBS@ \
+@EVIL_LIBS@
+
+libecore_evas_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
+
+EXTRA_DIST = \
+ecore_evas_private.h
diff --git a/libraries/ecore/src/lib/ecore_evas/Makefile.in b/libraries/ecore/src/lib/ecore_evas/Makefile.in
new file mode 100644
index 0000000..793e59d
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/Makefile.in
@@ -0,0 +1,921 @@
+# Makefile.in generated by automake 1.11.1 from Makefile.am.
+# @configure_input@
+
+# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
+# 2003, 2004, 2005, 2006, 2007, 2008, 2009  Free Software Foundation,
+# Inc.
+# This Makefile.in is free software; the Free Software Foundation
+# gives unlimited permission to copy and/or distribute it,
+# with or without modifications, as long as this notice is preserved.
+
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
+# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
+# PARTICULAR PURPOSE.
+
+@SET_MAKE@
+
+
+VPATH = @srcdir@
+pkgdatadir = $(datadir)/@PACKAGE@
+pkgincludedir = $(includedir)/@PACKAGE@
+pkglibdir = $(libdir)/@PACKAGE@
+pkglibexecdir = $(libexecdir)/@PACKAGE@
+am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
+install_sh_DATA = $(install_sh) -c -m 644
+install_sh_PROGRAM = $(install_sh) -c
+install_sh_SCRIPT = $(install_sh) -c
+INSTALL_HEADER = $(INSTALL_DATA)
+transform = $(program_transform_name)
+NORMAL_INSTALL = :
+PRE_INSTALL = :
+POST_INSTALL = :
+NORMAL_UNINSTALL = :
+PRE_UNINSTALL = :
+POST_UNINSTALL = :
+build_triplet = @build@
+host_triplet = @host@
+subdir = src/lib/ecore_evas
+DIST_COMMON = $(includes_HEADERS) $(srcdir)/Makefile.am \
+        $(srcdir)/Makefile.in
+ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
+am__aclocal_m4_deps = $(top_srcdir)/m4/ac_attribute.m4 \
+        $(top_srcdir)/m4/ac_path_generic.m4 \
+        $(top_srcdir)/m4/check_x_extension.m4 \
+        $(top_srcdir)/m4/ecore_check_module.m4 \
+        $(top_srcdir)/m4/ecore_check_options.m4 \
+        $(top_srcdir)/m4/efl_compiler_flag.m4 \
+        $(top_srcdir)/m4/efl_doxygen.m4 \
+        $(top_srcdir)/m4/efl_examples.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
+am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
+        $(ACLOCAL_M4)
+mkinstalldirs = $(SHELL) $(top_srcdir)/mkinstalldirs
+CONFIG_HEADER = $(top_builddir)/config.h
+CONFIG_CLEAN_FILES =
+CONFIG_CLEAN_VPATH_FILES =
+am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
+am__vpath_adj = case $$p in \
+    $(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
+    *) f=$$p;; \
+  esac;
+am__strip_dir = f=`echo $$p | sed -e 's|^.*/||'`;
+am__install_max = 40
+am__nobase_strip_setup = \
+  srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*|]/\\\\&/g'`
+am__nobase_strip = \
+  for p in $$list; do echo "$$p"; done | sed -e "s|$$srcdirstrip/||"
+am__nobase_list = $(am__nobase_strip_setup); \
+  for p in $$list; do echo "$$p $$p"; done | \
+  sed "s| $$srcdirstrip/| |;"' / .*\//!s/ .*/ ./; s,\( .*\)/[^/]*$$,\1,' | \
+  $(AWK) 'BEGIN { files["."] = "" } { files[$$2] = files[$$2] " " $$1; \
+    if (++n[$$2] == $(am__install_max)) \
+      { print $$2, files[$$2]; n[$$2] = 0; files[$$2] = "" } } \
+    END { for (dir in files) print dir, files[dir] }'
+am__base_list = \
+  sed '$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;$$!N;s/\n/ /g' | \
+  sed '$$!N;$$!N;$$!N;$$!N;s/\n/ /g'
+am__installdirs = "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includesdir)"
+LTLIBRARIES = $(lib_LTLIBRARIES)
+@BUILD_ECORE_X_TRUE@am__DEPENDENCIES_1 = $(top_builddir)/src/lib/ecore_x/libecore_x.la
+@BUILD_ECORE_FB_TRUE@am__DEPENDENCIES_2 = $(top_builddir)/src/lib/ecore_fb/libecore_fb.la
+@BUILD_ECORE_DIRECTFB_TRUE@am__DEPENDENCIES_3 = $(top_builddir)/src/lib/ecore_directfb/libecore_directfb.la
+@BUILD_ECORE_WIN32_TRUE@am__DEPENDENCIES_4 = $(top_builddir)/src/lib/ecore_win32/libecore_win32.la
+@BUILD_ECORE_SDL_TRUE@am__DEPENDENCIES_5 = $(top_builddir)/src/lib/ecore_sdl/libecore_sdl.la
+@BUILD_ECORE_SDL_TRUE@am__DEPENDENCIES_6 = $(am__DEPENDENCIES_5)
+@BUILD_ECORE_COCOA_TRUE@am__DEPENDENCIES_7 = $(top_builddir)/src/lib/ecore_cocoa/libecore_cocoa.la
+@BUILD_ECORE_WINCE_TRUE@am__DEPENDENCIES_8 = $(top_builddir)/src/lib/ecore_wince/libecore_wince.la
+@BUILD_ECORE_PSL1GHT_TRUE@am__DEPENDENCIES_9 = $(top_builddir)/src/lib/ecore_psl1ght/libecore_psl1ght.la
+libecore_evas_la_DEPENDENCIES = $(am__DEPENDENCIES_1) \
+        $(am__DEPENDENCIES_2) $(am__DEPENDENCIES_3) \
+        $(am__DEPENDENCIES_4) $(am__DEPENDENCIES_5) \
+        $(am__DEPENDENCIES_6) $(am__DEPENDENCIES_7) \
+        $(am__DEPENDENCIES_8) $(am__DEPENDENCIES_9) \
+        $(top_builddir)/src/lib/ecore_input/libecore_input.la \
+        $(top_builddir)/src/lib/ecore_input_evas/libecore_input_evas.la \
+        $(top_builddir)/src/lib/ecore/libecore.la
+am_libecore_evas_la_OBJECTS = ecore_evas.lo ecore_evas_util.lo \
+        ecore_evas_x.lo ecore_evas_fb.lo ecore_evas_buffer.lo \
+        ecore_evas_directfb.lo ecore_evas_win32.lo ecore_evas_sdl.lo \
+        ecore_evas_cocoa.lo ecore_evas_wince.lo ecore_evas_ews.lo \
+        ecore_evas_psl1ght.lo
+libecore_evas_la_OBJECTS = $(am_libecore_evas_la_OBJECTS)
+AM_V_lt = $(am__v_lt_$(V))
+am__v_lt_ = $(am__v_lt_$(AM_DEFAULT_VERBOSITY))
+am__v_lt_0 = --silent
+libecore_evas_la_LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC \
+        $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=link $(CCLD) \
+        $(AM_CFLAGS) $(CFLAGS) $(libecore_evas_la_LDFLAGS) $(LDFLAGS) \
+        -o $@
+DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
+depcomp = $(SHELL) $(top_srcdir)/depcomp
+am__depfiles_maybe = depfiles
+am__mv = mv -f
+COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
+        $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
+LTCOMPILE = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=compile $(CC) $(DEFS) \
+        $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) \
+        $(AM_CFLAGS) $(CFLAGS)
+AM_V_CC = $(am__v_CC_$(V))
+am__v_CC_ = $(am__v_CC_$(AM_DEFAULT_VERBOSITY))
+am__v_CC_0 = @echo "  CC    " $@;
+AM_V_at = $(am__v_at_$(V))
+am__v_at_ = $(am__v_at_$(AM_DEFAULT_VERBOSITY))
+am__v_at_0 = @
+CCLD = $(CC)
+LINK = $(LIBTOOL) $(AM_V_lt) --tag=CC $(AM_LIBTOOLFLAGS) \
+        $(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
+        $(AM_LDFLAGS) $(LDFLAGS) -o $@
+AM_V_CCLD = $(am__v_CCLD_$(V))
+am__v_CCLD_ = $(am__v_CCLD_$(AM_DEFAULT_VERBOSITY))
+am__v_CCLD_0 = @echo "  CCLD  " $@;
+AM_V_GEN = $(am__v_GEN_$(V))
+am__v_GEN_ = $(am__v_GEN_$(AM_DEFAULT_VERBOSITY))
+am__v_GEN_0 = @echo "  GEN   " $@;
+SOURCES = $(libecore_evas_la_SOURCES)
+DIST_SOURCES = $(libecore_evas_la_SOURCES)
+HEADERS = $(includes_HEADERS)
+ETAGS = etags
+CTAGS = ctags
+DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
+ACLOCAL = @ACLOCAL@
+ALLOCA = @ALLOCA@
+AMTAR = @AMTAR@
+AM_DEFAULT_VERBOSITY = @AM_DEFAULT_VERBOSITY@
+AR = @AR@
+AS = @AS@
+AUTOCONF = @AUTOCONF@
+AUTOHEADER = @AUTOHEADER@
+AUTOMAKE = @AUTOMAKE@
+AWK = @AWK@
+CARES_CFLAGS = @CARES_CFLAGS@
+CARES_LIBS = @CARES_LIBS@
+CC = @CC@
+CCDEPMODE = @CCDEPMODE@
+CFLAGS = @CFLAGS@
+CHECK_CFLAGS = @CHECK_CFLAGS@
+CHECK_LIBS = @CHECK_LIBS@
+CPP = @CPP@
+CPPFLAGS = @CPPFLAGS@
+CURL_CFLAGS = @CURL_CFLAGS@
+CURL_LIBS = @CURL_LIBS@
+CXX = @CXX@
+CXXCPP = @CXXCPP@
+CXXDEPMODE = @CXXDEPMODE@
+CXXFLAGS = @CXXFLAGS@
+CYGPATH_W = @CYGPATH_W@
+DEFS = @DEFS@
+DEPDIR = @DEPDIR@
+DIRECTFB_CFLAGS = @DIRECTFB_CFLAGS@
+DIRECTFB_LIBS = @DIRECTFB_LIBS@
+DLLTOOL = @DLLTOOL@
+DSYMUTIL = @DSYMUTIL@
+DUMPBIN = @DUMPBIN@
+ECHO_C = @ECHO_C@
+ECHO_N = @ECHO_N@
+ECHO_T = @ECHO_T@
+ECORE_XCB_CFLAGS = @ECORE_XCB_CFLAGS@
+ECORE_XCB_LIBS = @ECORE_XCB_LIBS@
+EFL_ECORE_BUILD = @EFL_ECORE_BUILD@
+EFL_ECORE_CON_BUILD = @EFL_ECORE_CON_BUILD@
+EFL_ECORE_EVAS_BUILD = @EFL_ECORE_EVAS_BUILD@
+EFL_ECORE_FILE_BUILD = @EFL_ECORE_FILE_BUILD@
+EFL_ECORE_IMF_BUILD = @EFL_ECORE_IMF_BUILD@
+EFL_ECORE_IMF_EVAS_BUILD = @EFL_ECORE_IMF_EVAS_BUILD@
+EFL_ECORE_INPUT_BUILD = @EFL_ECORE_INPUT_BUILD@
+EFL_ECORE_INPUT_EVAS_BUILD = @EFL_ECORE_INPUT_EVAS_BUILD@
+EFL_ECORE_IPC_BUILD = @EFL_ECORE_IPC_BUILD@
+EFL_ECORE_PSL1GHT_BUILD = @EFL_ECORE_PSL1GHT_BUILD@
+EFL_ECORE_SDL_BUILD = @EFL_ECORE_SDL_BUILD@
+EFL_ECORE_WIN32_BUILD = @EFL_ECORE_WIN32_BUILD@
+EFL_ECORE_WINCE_BUILD = @EFL_ECORE_WINCE_BUILD@
+EFL_PTHREAD_CFLAGS = @EFL_PTHREAD_CFLAGS@
+EFL_PTHREAD_LIBS = @EFL_PTHREAD_LIBS@
+EGREP = @EGREP@
+EINA_CFLAGS = @EINA_CFLAGS@
+EINA_LIBS = @EINA_LIBS@
+ESCAPE_CFLAGS = @ESCAPE_CFLAGS@
+ESCAPE_LIBS = @ESCAPE_LIBS@
+EVAS_CFLAGS = @EVAS_CFLAGS@
+EVAS_LIBS = @EVAS_LIBS@
+EVIL_CFLAGS = @EVIL_CFLAGS@
+EVIL_LIBS = @EVIL_LIBS@
+EXEEXT = @EXEEXT@
+FGREP = @FGREP@
+GETTEXT_MACRO_VERSION = @GETTEXT_MACRO_VERSION@
+GLIB_CFLAGS = @GLIB_CFLAGS@
+GLIB_LIBS = @GLIB_LIBS@
+GMSGFMT = @GMSGFMT@
+GMSGFMT_015 = @GMSGFMT_015@
+GREP = @GREP@
+INSTALL = @INSTALL@
+INSTALL_DATA = @INSTALL_DATA@
+INSTALL_PROGRAM = @INSTALL_PROGRAM@
+INSTALL_SCRIPT = @INSTALL_SCRIPT@
+INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
+INTLLIBS = @INTLLIBS@
+INTL_MACOSX_LIBS = @INTL_MACOSX_LIBS@
+KEYSYMDEFS = @KEYSYMDEFS@
+LD = @LD@
+LDFLAGS = @LDFLAGS@
+LIBGCRYPT_CFLAGS = @LIBGCRYPT_CFLAGS@
+LIBGCRYPT_CONFIG = @LIBGCRYPT_CONFIG@
+LIBGCRYPT_LIBS = @LIBGCRYPT_LIBS@
+LIBICONV = @LIBICONV@
+LIBINTL = @LIBINTL@
+LIBOBJS = @LIBOBJS@
+LIBS = @LIBS@
+LIBTOOL = @LIBTOOL@
+LIPO = @LIPO@
+LN_S = @LN_S@
+LTLIBICONV = @LTLIBICONV@
+LTLIBINTL = @LTLIBINTL@
+LTLIBOBJS = @LTLIBOBJS@
+MAKEINFO = @MAKEINFO@
+MKDIR_P = @MKDIR_P@
+MSGFMT = @MSGFMT@
+MSGFMT_015 = @MSGFMT_015@
+MSGMERGE = @MSGMERGE@
+NM = @NM@
+NMEDIT = @NMEDIT@
+OBJC = @OBJC@
+OBJCDEPMODE = @OBJCDEPMODE@
+OBJCFLAGS = @OBJCFLAGS@
+OBJDUMP = @OBJDUMP@
+OBJEXT = @OBJEXT@
+OTOOL = @OTOOL@
+OTOOL64 = @OTOOL64@
+PACKAGE = @PACKAGE@
+PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
+PACKAGE_NAME = @PACKAGE_NAME@
+PACKAGE_STRING = @PACKAGE_STRING@
+PACKAGE_TARNAME = @PACKAGE_TARNAME@
+PACKAGE_URL = @PACKAGE_URL@
+PACKAGE_VERSION = @PACKAGE_VERSION@
+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@
+SDL_CFLAGS = @SDL_CFLAGS@
+SDL_CONFIG = @SDL_CONFIG@
+SDL_LIBS = @SDL_LIBS@
+SED = @SED@
+SET_MAKE = @SET_MAKE@
+SHELL = @SHELL@
+SSL_CFLAGS = @SSL_CFLAGS@
+SSL_LIBS = @SSL_LIBS@
+STRIP = @STRIP@
+TLS2_CFLAGS = @TLS2_CFLAGS@
+TLS2_LIBS = @TLS2_LIBS@
+TLS_CFLAGS = @TLS_CFLAGS@
+TLS_LIBS = @TLS_LIBS@
+TSLIB_CFLAGS = @TSLIB_CFLAGS@
+TSLIB_LIBS = @TSLIB_LIBS@
+USE_NLS = @USE_NLS@
+VERSION = @VERSION@
+VMAJ = @VMAJ@
+WIN32_CFLAGS = @WIN32_CFLAGS@
+WIN32_CPPFLAGS = @WIN32_CPPFLAGS@
+WIN32_LIBS = @WIN32_LIBS@
+XCB_COMPOSITE_CFLAGS = @XCB_COMPOSITE_CFLAGS@
+XCB_COMPOSITE_LIBS = @XCB_COMPOSITE_LIBS@
+XCB_CURSOR_CFLAGS = @XCB_CURSOR_CFLAGS@
+XCB_CURSOR_LIBS = @XCB_CURSOR_LIBS@
+XCB_DAMAGE_CFLAGS = @XCB_DAMAGE_CFLAGS@
+XCB_DAMAGE_LIBS = @XCB_DAMAGE_LIBS@
+XCB_DPMS_CFLAGS = @XCB_DPMS_CFLAGS@
+XCB_DPMS_LIBS = @XCB_DPMS_LIBS@
+XCB_RANDR_CFLAGS = @XCB_RANDR_CFLAGS@
+XCB_RANDR_LIBS = @XCB_RANDR_LIBS@
+XCB_RENDER_CFLAGS = @XCB_RENDER_CFLAGS@
+XCB_RENDER_LIBS = @XCB_RENDER_LIBS@
+XCB_SCREENSAVER_CFLAGS = @XCB_SCREENSAVER_CFLAGS@
+XCB_SCREENSAVER_LIBS = @XCB_SCREENSAVER_LIBS@
+XCB_SHAPE_CFLAGS = @XCB_SHAPE_CFLAGS@
+XCB_SHAPE_LIBS = @XCB_SHAPE_LIBS@
+XCB_SYNC_CFLAGS = @XCB_SYNC_CFLAGS@
+XCB_SYNC_LIBS = @XCB_SYNC_LIBS@
+XCB_X11_CFLAGS = @XCB_X11_CFLAGS@
+XCB_X11_LIBS = @XCB_X11_LIBS@
+XCB_XFIXES_CFLAGS = @XCB_XFIXES_CFLAGS@
+XCB_XFIXES_LIBS = @XCB_XFIXES_LIBS@
+XCB_XGESTURE_CFLAGS = @XCB_XGESTURE_CFLAGS@
+XCB_XGESTURE_LIBS = @XCB_XGESTURE_LIBS@
+XCB_XINERAMA_CFLAGS = @XCB_XINERAMA_CFLAGS@
+XCB_XINERAMA_LIBS = @XCB_XINERAMA_LIBS@
+XCB_XINPUT_CFLAGS = @XCB_XINPUT_CFLAGS@
+XCB_XINPUT_LIBS = @XCB_XINPUT_LIBS@
+XCB_XPRINT_CFLAGS = @XCB_XPRINT_CFLAGS@
+XCB_XPRINT_LIBS = @XCB_XPRINT_LIBS@
+XCB_XTEST_CFLAGS = @XCB_XTEST_CFLAGS@
+XCB_XTEST_LIBS = @XCB_XTEST_LIBS@
+XCOMPOSITE_CFLAGS = @XCOMPOSITE_CFLAGS@
+XCOMPOSITE_LIBS = @XCOMPOSITE_LIBS@
+XDAMAGE_CFLAGS = @XDAMAGE_CFLAGS@
+XDAMAGE_LIBS = @XDAMAGE_LIBS@
+XDPMS_CFLAGS = @XDPMS_CFLAGS@
+XDPMS_LIBS = @XDPMS_LIBS@
+XFIXES_CFLAGS = @XFIXES_CFLAGS@
+XFIXES_LIBS = @XFIXES_LIBS@
+XGESTURE_CFLAGS = @XGESTURE_CFLAGS@
+XGESTURE_LIBS = @XGESTURE_LIBS@
+XGETTEXT = @XGETTEXT@
+XGETTEXT_015 = @XGETTEXT_015@
+XGETTEXT_EXTRA_OPTIONS = @XGETTEXT_EXTRA_OPTIONS@
+XI2_CFLAGS = @XI2_CFLAGS@
+XI2_LIBS = @XI2_LIBS@
+XINERAMA_CFLAGS = @XINERAMA_CFLAGS@
+XINERAMA_LIBS = @XINERAMA_LIBS@
+XKB_CFLAGS = @XKB_CFLAGS@
+XKB_LIBS = @XKB_LIBS@
+XMKMF = @XMKMF@
+XPRINT_CFLAGS = @XPRINT_CFLAGS@
+XPRINT_LIBS = @XPRINT_LIBS@
+XRANDR_CFLAGS = @XRANDR_CFLAGS@
+XRANDR_LIBS = @XRANDR_LIBS@
+XRENDER_CFLAGS = @XRENDER_CFLAGS@
+XRENDER_LIBS = @XRENDER_LIBS@
+XSS_CFLAGS = @XSS_CFLAGS@
+XSS_LIBS = @XSS_LIBS@
+XTEST_CFLAGS = @XTEST_CFLAGS@
+XTEST_LIBS = @XTEST_LIBS@
+X_CFLAGS = @X_CFLAGS@
+X_EXTRA_LIBS = @X_EXTRA_LIBS@
+X_LIBS = @X_LIBS@
+X_PRE_LIBS = @X_PRE_LIBS@
+Xcursor_cflags = @Xcursor_cflags@
+Xcursor_libs = @Xcursor_libs@
+abs_builddir = @abs_builddir@
+abs_srcdir = @abs_srcdir@
+abs_top_builddir = @abs_top_builddir@
+abs_top_srcdir = @abs_top_srcdir@
+ac_ct_CC = @ac_ct_CC@
+ac_ct_CXX = @ac_ct_CXX@
+ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
+ac_ct_OBJC = @ac_ct_OBJC@
+am__include = @am__include@
+am__leading_dot = @am__leading_dot@
+am__quote = @am__quote@
+am__tar = @am__tar@
+am__untar = @am__untar@
+bindir = @bindir@
+build = @build@
+build_alias = @build_alias@
+build_cpu = @build_cpu@
+build_os = @build_os@
+build_vendor = @build_vendor@
+builddir = @builddir@
+cocoa_ldflags = @cocoa_ldflags@
+datadir = @datadir@
+datarootdir = @datarootdir@
+dlopen_libs = @dlopen_libs@
+docdir = @docdir@
+dvidir = @dvidir@
+ecore_cocoa_cflags = @ecore_cocoa_cflags@
+ecore_cocoa_libs = @ecore_cocoa_libs@
+ecore_con_cflags = @ecore_con_cflags@
+ecore_con_libs = @ecore_con_libs@
+ecore_directfb_cflags = @ecore_directfb_cflags@
+ecore_directfb_libs = @ecore_directfb_libs@
+ecore_evas_cflags = @ecore_evas_cflags@
+ecore_evas_libs = @ecore_evas_libs@
+ecore_fb_cflags = @ecore_fb_cflags@
+ecore_fb_libs = @ecore_fb_libs@
+ecore_file_cflags = @ecore_file_cflags@
+ecore_file_libs = @ecore_file_libs@
+ecore_imf_cflags = @ecore_imf_cflags@
+ecore_imf_evas_cflags = @ecore_imf_evas_cflags@
+ecore_imf_evas_libs = @ecore_imf_evas_libs@
+ecore_imf_libs = @ecore_imf_libs@
+ecore_imf_xim_cflags = @ecore_imf_xim_cflags@
+ecore_imf_xim_libs = @ecore_imf_xim_libs@
+ecore_input_cflags = @ecore_input_cflags@
+ecore_input_evas_cflags = @ecore_input_evas_cflags@
+ecore_input_evas_libs = @ecore_input_evas_libs@
+ecore_input_libs = @ecore_input_libs@
+ecore_ipc_cflags = @ecore_ipc_cflags@
+ecore_ipc_libs = @ecore_ipc_libs@
+ecore_psl1ght_cflags = @ecore_psl1ght_cflags@
+ecore_psl1ght_libs = @ecore_psl1ght_libs@
+ecore_sdl_cflags = @ecore_sdl_cflags@
+ecore_sdl_libs = @ecore_sdl_libs@
+ecore_win32_cflags = @ecore_win32_cflags@
+ecore_win32_libs = @ecore_win32_libs@
+ecore_wince_cflags = @ecore_wince_cflags@
+ecore_wince_libs = @ecore_wince_libs@
+ecore_x_cflags = @ecore_x_cflags@
+ecore_x_libs = @ecore_x_libs@
+ecore_x_libs_private = @ecore_x_libs_private@
+efl_doxygen = @efl_doxygen@
+efl_have_doxygen = @efl_have_doxygen@
+exec_prefix = @exec_prefix@
+have_ecore_x_xcb_define = @have_ecore_x_xcb_define@
+host = @host@
+host_alias = @host_alias@
+host_cpu = @host_cpu@
+host_os = @host_os@
+host_vendor = @host_vendor@
+htmldir = @htmldir@
+includedir = @includedir@
+infodir = @infodir@
+install_sh = @install_sh@
+libdir = @libdir@
+libexecdir = @libexecdir@
+localedir = @localedir@
+localstatedir = @localstatedir@
+lt_ECHO = @lt_ECHO@
+lt_enable_auto_import = @lt_enable_auto_import@
+mandir = @mandir@
+mkdir_p = @mkdir_p@
+oldincludedir = @oldincludedir@
+pdfdir = @pdfdir@
+pkgconfig_requires_private = @pkgconfig_requires_private@
+prefix = @prefix@
+program_transform_name = @program_transform_name@
+psdir = @psdir@
+release_info = @release_info@
+requirements_ecore = @requirements_ecore@
+requirements_ecore_cocoa = @requirements_ecore_cocoa@
+requirements_ecore_con = @requirements_ecore_con@
+requirements_ecore_directfb = @requirements_ecore_directfb@
+requirements_ecore_evas = @requirements_ecore_evas@
+requirements_ecore_fb = @requirements_ecore_fb@
+requirements_ecore_file = @requirements_ecore_file@
+requirements_ecore_imf = @requirements_ecore_imf@
+requirements_ecore_imf_evas = @requirements_ecore_imf_evas@
+requirements_ecore_imf_xim = @requirements_ecore_imf_xim@
+requirements_ecore_input = @requirements_ecore_input@
+requirements_ecore_input_evas = @requirements_ecore_input_evas@
+requirements_ecore_ipc = @requirements_ecore_ipc@
+requirements_ecore_psl1ght = @requirements_ecore_psl1ght@
+requirements_ecore_sdl = @requirements_ecore_sdl@
+requirements_ecore_win32 = @requirements_ecore_win32@
+requirements_ecore_wince = @requirements_ecore_wince@
+requirements_ecore_x = @requirements_ecore_x@
+rt_libs = @rt_libs@
+sbindir = @sbindir@
+sharedstatedir = @sharedstatedir@
+srcdir = @srcdir@
+sysconfdir = @sysconfdir@
+target_alias = @target_alias@
+top_build_prefix = @top_build_prefix@
+top_builddir = @top_builddir@
+top_srcdir = @top_srcdir@
+version_info = @version_info@
+x_cflags = @x_cflags@
+x_includes = @x_includes@
+x_libs = @x_libs@
+MAINTAINERCLEANFILES = Makefile.in
+@BUILD_ECORE_X_FALSE@ECORE_X_INC = 
+@BUILD_ECORE_X_TRUE@ECORE_X_INC = -I$(top_srcdir)/src/lib/ecore_x @x_cflags@ @ECORE_XCB_CFLAGS@
+@BUILD_ECORE_X_FALSE@ECORE_X_LIB = 
+@BUILD_ECORE_X_TRUE@ECORE_X_LIB = $(top_builddir)/src/lib/ecore_x/libecore_x.la @x_libs@ @ECORE_XCB_LIBS@
+@BUILD_ECORE_FB_FALSE@ECORE_FB_INC = 
+@BUILD_ECORE_FB_TRUE@ECORE_FB_INC = -I$(top_srcdir)/src/lib/ecore_fb
+@BUILD_ECORE_FB_FALSE@ECORE_FB_LIB = 
+@BUILD_ECORE_FB_TRUE@ECORE_FB_LIB = $(top_builddir)/src/lib/ecore_fb/libecore_fb.la
+@BUILD_ECORE_DIRECTFB_FALSE@ECORE_DIRECTFB_INC = 
+@BUILD_ECORE_DIRECTFB_TRUE@ECORE_DIRECTFB_INC = -I$(top_srcdir)/src/lib/ecore_directfb -I@DIRECTFB_CFLAGS@
+@BUILD_ECORE_DIRECTFB_FALSE@ECORE_DIRECTFB_LIB = 
+@BUILD_ECORE_DIRECTFB_TRUE@ECORE_DIRECTFB_LIB = $(top_builddir)/src/lib/ecore_directfb/libecore_directfb.la
+@BUILD_ECORE_WIN32_FALSE@ECORE_WIN32_INC = 
+@BUILD_ECORE_WIN32_TRUE@ECORE_WIN32_INC = -I$(top_srcdir)/src/lib/ecore_win32
+@BUILD_ECORE_WIN32_FALSE@ECORE_WIN32_LIB = 
+@BUILD_ECORE_WIN32_TRUE@ECORE_WIN32_LIB = $(top_builddir)/src/lib/ecore_win32/libecore_win32.la
+@BUILD_ECORE_SDL_FALSE@ECORE_SDL_INC = 
+@BUILD_ECORE_SDL_TRUE@ECORE_SDL_INC = -I$(top_srcdir)/src/lib/ecore_sdl @SDL_CFLAGS@
+@BUILD_ECORE_SDL_FALSE@ECORE_SDL_LIB = 
+@BUILD_ECORE_SDL_TRUE@ECORE_SDL_LIB = $(top_builddir)/src/lib/ecore_sdl/libecore_sdl.la
+@BUILD_ECORE_SDL_FALSE@ECORE_SDL_LIBADD = 
+@BUILD_ECORE_SDL_TRUE@ECORE_SDL_LIBADD = @SDL_LIBS@ $(ECORE_SDL_LIB)
+@BUILD_ECORE_COCOA_FALSE@ECORE_COCOA_INC = 
+@BUILD_ECORE_COCOA_TRUE@ECORE_COCOA_INC = -I$(top_srcdir)/src/lib/ecore_cocoa
+@BUILD_ECORE_COCOA_FALSE@ECORE_COCOA_LIB = 
+@BUILD_ECORE_COCOA_TRUE@ECORE_COCOA_LIB = $(top_builddir)/src/lib/ecore_cocoa/libecore_cocoa.la
+@BUILD_ECORE_WINCE_FALSE@ECORE_WINCE_INC = 
+@BUILD_ECORE_WINCE_TRUE@ECORE_WINCE_INC = -I$(top_srcdir)/src/lib/ecore_wince
+@BUILD_ECORE_WINCE_FALSE@ECORE_WINCE_LIB = 
+@BUILD_ECORE_WINCE_TRUE@ECORE_WINCE_LIB = $(top_builddir)/src/lib/ecore_wince/libecore_wince.la
+@BUILD_ECORE_PSL1GHT_FALSE@ECORE_PSL1GHT_INC = 
+@BUILD_ECORE_PSL1GHT_TRUE@ECORE_PSL1GHT_INC = -I$(top_srcdir)/src/lib/ecore_psl1ght
+@BUILD_ECORE_PSL1GHT_FALSE@ECORE_PSL1GHT_LIB = 
+@BUILD_ECORE_PSL1GHT_TRUE@ECORE_PSL1GHT_LIB = $(top_builddir)/src/lib/ecore_psl1ght/libecore_psl1ght.la
+AM_CPPFLAGS = \
+-I$(top_srcdir)/src/lib/ecore \
+-I$(top_srcdir)/src/lib/ecore_evas \
+-I$(top_srcdir)/src/lib/ecore_input \
+-I$(top_srcdir)/src/lib/ecore_input_evas \
+-I$(top_builddir)/src/lib/ecore \
+-I$(top_builddir)/src/lib/ecore_evas \
+-I$(top_builddir)/src/lib/ecore_input \
+-I$(top_builddir)/src/lib/ecore_input_evas \
+@EFL_ECORE_EVAS_BUILD@ \
+$(ECORE_X_INC) \
+$(ECORE_FB_INC) \
+$(ECORE_DIRECTFB_INC) \
+$(ECORE_WIN32_INC) \
+$(ECORE_SDL_INC) \
+$(ECORE_COCOA_INC) \
+$(ECORE_WINCE_INC) \
+$(ECORE_PSL1GHT_INC) \
+@EVAS_CFLAGS@ \
+@EINA_CFLAGS@ \
+@EVIL_CFLAGS@
+
+AM_CFLAGS = @WIN32_CFLAGS@
+lib_LTLIBRARIES = libecore_evas.la
+includes_HEADERS = Ecore_Evas.h
+includesdir = $(includedir)/ecore-@VMAJ@
+libecore_evas_la_SOURCES = \
+ecore_evas.c \
+ecore_evas_util.c \
+ecore_evas_x.c \
+ecore_evas_fb.c \
+ecore_evas_buffer.c \
+ecore_evas_directfb.c \
+ecore_evas_win32.c \
+ecore_evas_sdl.c \
+ecore_evas_cocoa.c \
+ecore_evas_wince.c \
+ecore_evas_ews.c \
+ecore_evas_psl1ght.c
+
+libecore_evas_la_LIBADD = \
+$(ECORE_X_LIB) \
+$(ECORE_FB_LIB) \
+$(ECORE_DIRECTFB_LIB) \
+$(ECORE_WIN32_LIB) \
+$(ECORE_SDL_LIB) \
+$(ECORE_SDL_LIBADD) \
+$(ECORE_COCOA_LIB) \
+$(ECORE_WINCE_LIB) \
+$(ECORE_PSL1GHT_LIB) \
+$(top_builddir)/src/lib/ecore_input/libecore_input.la \
+$(top_builddir)/src/lib/ecore_input_evas/libecore_input_evas.la \
+$(top_builddir)/src/lib/ecore/libecore.la \
+@EVAS_LIBS@ \
+@EINA_LIBS@ \
+@EVIL_LIBS@
+
+libecore_evas_la_LDFLAGS = -no-undefined @lt_enable_auto_import@ -version-info @version_info@ @release_info@
+EXTRA_DIST = \
+ecore_evas_private.h
+
+all: all-am
+
+.SUFFIXES:
+.SUFFIXES: .c .lo .o .obj
+$(srcdir)/Makefile.in:  $(srcdir)/Makefile.am  $(am__configure_deps)
+        @for dep in $?; do \
+          case '$(am__configure_deps)' in \
+            *$$dep*) \
+              ( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
+                && { if test -f $@; then exit 0; else break; fi; }; \
+              exit 1;; \
+          esac; \
+        done; \
+        echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/lib/ecore_evas/Makefile'; \
+        $(am__cd) $(top_srcdir) && \
+          $(AUTOMAKE) --gnu src/lib/ecore_evas/Makefile
+.PRECIOUS: Makefile
+Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
+        @case '$?' in \
+          *config.status*) \
+            cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
+          *) \
+            echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
+            cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
+        esac;
+
+$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
+        cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+
+$(top_srcdir)/configure:  $(am__configure_deps)
+        cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(ACLOCAL_M4):  $(am__aclocal_m4_deps)
+        cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
+$(am__aclocal_m4_deps):
+install-libLTLIBRARIES: $(lib_LTLIBRARIES)
+        @$(NORMAL_INSTALL)
+        test -z "$(libdir)" || $(MKDIR_P) "$(DESTDIR)$(libdir)"
+        @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+        list2=; for p in $$list; do \
+          if test -f $$p; then \
+            list2="$$list2 $$p"; \
+          else :; fi; \
+        done; \
+        test -z "$$list2" || { \
+          echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 '$(DESTDIR)$(libdir)'"; \
+          $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(INSTALL) $(INSTALL_STRIP_FLAG) $$list2 "$(DESTDIR)$(libdir)"; \
+        }
+
+uninstall-libLTLIBRARIES:
+        @$(NORMAL_UNINSTALL)
+        @list='$(lib_LTLIBRARIES)'; test -n "$(libdir)" || list=; \
+        for p in $$list; do \
+          $(am__strip_dir) \
+          echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$f'"; \
+          $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$f"; \
+        done
+
+clean-libLTLIBRARIES:
+        -test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
+        @list='$(lib_LTLIBRARIES)'; for p in $$list; do \
+          dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
+          test "$$dir" != "$$p" || dir=.; \
+          echo "rm -f \"$${dir}/so_locations\""; \
+          rm -f "$${dir}/so_locations"; \
+        done
+libecore_evas.la: $(libecore_evas_la_OBJECTS) $(libecore_evas_la_DEPENDENCIES) 
+        $(AM_V_CCLD)$(libecore_evas_la_LINK) -rpath $(libdir) $(libecore_evas_la_OBJECTS) $(libecore_evas_la_LIBADD) $(LIBS)
+
+mostlyclean-compile:
+        -rm -f *.$(OBJEXT)
+
+distclean-compile:
+        -rm -f *.tab.c
+
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_evas.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_evas_buffer.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_evas_cocoa.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_evas_directfb.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_evas_ews.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_evas_fb.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_evas_psl1ght.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_evas_sdl.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_evas_util.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_evas_win32.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_evas_wince.Plo@am__quote@
+@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ecore_evas_x.Plo@am__quote@
+
+.c.o:
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@am__fastdepCC_FALSE@   $(AM_V_CC) @AM_BACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(COMPILE) -c $<
+
+.c.obj:
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
+@am__fastdepCC_FALSE@   $(AM_V_CC) @AM_BACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(COMPILE) -c `$(CYGPATH_W) '$<'`
+
+.c.lo:
+@am__fastdepCC_TRUE@    $(AM_V_CC)$(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
+@am__fastdepCC_TRUE@    $(AM_V_at)$(am__mv) $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
+@am__fastdepCC_FALSE@   $(AM_V_CC) @AM_BACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
+@AMDEP_TRUE@@am__fastdepCC_FALSE@       DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
+@am__fastdepCC_FALSE@   $(LTCOMPILE) -c -o $@ $<
+
+mostlyclean-libtool:
+        -rm -f *.lo
+
+clean-libtool:
+        -rm -rf .libs _libs
+install-includesHEADERS: $(includes_HEADERS)
+        @$(NORMAL_INSTALL)
+        test -z "$(includesdir)" || $(MKDIR_P) "$(DESTDIR)$(includesdir)"
+        @list='$(includes_HEADERS)'; test -n "$(includesdir)" || list=; \
+        for p in $$list; do \
+          if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
+          echo "$$d$$p"; \
+        done | $(am__base_list) | \
+        while read files; do \
+          echo " $(INSTALL_HEADER) $$files '$(DESTDIR)$(includesdir)'"; \
+          $(INSTALL_HEADER) $$files "$(DESTDIR)$(includesdir)" || exit $$?; \
+        done
+
+uninstall-includesHEADERS:
+        @$(NORMAL_UNINSTALL)
+        @list='$(includes_HEADERS)'; test -n "$(includesdir)" || list=; \
+        files=`for p in $$list; do echo $$p; done | sed -e 's|^.*/||'`; \
+        test -n "$$files" || exit 0; \
+        echo " ( cd '$(DESTDIR)$(includesdir)' && rm -f" $$files ")"; \
+        cd "$(DESTDIR)$(includesdir)" && rm -f $$files
+
+ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
+        list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
+        unique=`for i in $$list; do \
+            if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+          done | \
+          $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+              END { if (nonempty) { for (i in files) print i; }; }'`; \
+        mkid -fID $$unique
+tags: TAGS
+
+TAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+                $(TAGS_FILES) $(LISP)
+        set x; \
+        here=`pwd`; \
+        list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+        unique=`for i in $$list; do \
+            if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+          done | \
+          $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+              END { if (nonempty) { for (i in files) print i; }; }'`; \
+        shift; \
+        if test -z "$(ETAGS_ARGS)$$*$$unique"; then :; else \
+          test -n "$$unique" || unique=$$empty_fix; \
+          if test $$# -gt 0; then \
+            $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+              "$$@" $$unique; \
+          else \
+            $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
+              $$unique; \
+          fi; \
+        fi
+ctags: CTAGS
+CTAGS:  $(HEADERS) $(SOURCES)  $(TAGS_DEPENDENCIES) \
+                $(TAGS_FILES) $(LISP)
+        list='$(SOURCES) $(HEADERS)  $(LISP) $(TAGS_FILES)'; \
+        unique=`for i in $$list; do \
+            if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
+          done | \
+          $(AWK) '{ files[$$0] = 1; nonempty = 1; } \
+              END { if (nonempty) { for (i in files) print i; }; }'`; \
+        test -z "$(CTAGS_ARGS)$$unique" \
+          || $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
+             $$unique
+
+GTAGS:
+        here=`$(am__cd) $(top_builddir) && pwd` \
+          && $(am__cd) $(top_srcdir) \
+          && gtags -i $(GTAGS_ARGS) "$$here"
+
+distclean-tags:
+        -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
+
+distdir: $(DISTFILES)
+        @srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+        topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
+        list='$(DISTFILES)'; \
+          dist_files=`for file in $$list; do echo $$file; done | \
+          sed -e "s|^$$srcdirstrip/||;t" \
+              -e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
+        case $$dist_files in \
+          */*) $(MKDIR_P) `echo "$$dist_files" | \
+                           sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
+                           sort -u` ;; \
+        esac; \
+        for file in $$dist_files; do \
+          if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
+          if test -d $$d/$$file; then \
+            dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
+            if test -d "$(distdir)/$$file"; then \
+              find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+            fi; \
+            if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
+              cp -fpR $(srcdir)/$$file "$(distdir)$$dir" || exit 1; \
+              find "$(distdir)/$$file" -type d ! -perm -700 -exec chmod u+rwx {} \;; \
+            fi; \
+            cp -fpR $$d/$$file "$(distdir)$$dir" || exit 1; \
+          else \
+            test -f "$(distdir)/$$file" \
+            || cp -p $$d/$$file "$(distdir)/$$file" \
+            || exit 1; \
+          fi; \
+        done
+check-am: all-am
+check: check-am
+all-am: Makefile $(LTLIBRARIES) $(HEADERS)
+installdirs:
+        for dir in "$(DESTDIR)$(libdir)" "$(DESTDIR)$(includesdir)"; do \
+          test -z "$$dir" || $(MKDIR_P) "$$dir"; \
+        done
+install: install-am
+install-exec: install-exec-am
+install-data: install-data-am
+uninstall: uninstall-am
+
+install-am: all-am
+        @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
+
+installcheck: installcheck-am
+install-strip:
+        $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
+          install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
+          `test -z '$(STRIP)' || \
+            echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
+mostlyclean-generic:
+
+clean-generic:
+
+distclean-generic:
+        -test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
+        -test . = "$(srcdir)" || test -z "$(CONFIG_CLEAN_VPATH_FILES)" || rm -f $(CONFIG_CLEAN_VPATH_FILES)
+
+maintainer-clean-generic:
+        @echo "This command is intended for maintainers to use"
+        @echo "it deletes files that may require special tools to rebuild."
+        -test -z "$(MAINTAINERCLEANFILES)" || rm -f $(MAINTAINERCLEANFILES)
+clean: clean-am
+
+clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
+        mostlyclean-am
+
+distclean: distclean-am
+        -rm -rf ./$(DEPDIR)
+        -rm -f Makefile
+distclean-am: clean-am distclean-compile distclean-generic \
+        distclean-tags
+
+dvi: dvi-am
+
+dvi-am:
+
+html: html-am
+
+html-am:
+
+info: info-am
+
+info-am:
+
+install-data-am: install-includesHEADERS
+
+install-dvi: install-dvi-am
+
+install-dvi-am:
+
+install-exec-am: install-libLTLIBRARIES
+
+install-html: install-html-am
+
+install-html-am:
+
+install-info: install-info-am
+
+install-info-am:
+
+install-man:
+
+install-pdf: install-pdf-am
+
+install-pdf-am:
+
+install-ps: install-ps-am
+
+install-ps-am:
+
+installcheck-am:
+
+maintainer-clean: maintainer-clean-am
+        -rm -rf ./$(DEPDIR)
+        -rm -f Makefile
+maintainer-clean-am: distclean-am maintainer-clean-generic
+
+mostlyclean: mostlyclean-am
+
+mostlyclean-am: mostlyclean-compile mostlyclean-generic \
+        mostlyclean-libtool
+
+pdf: pdf-am
+
+pdf-am:
+
+ps: ps-am
+
+ps-am:
+
+uninstall-am: uninstall-includesHEADERS uninstall-libLTLIBRARIES
+
+.MAKE: install-am install-strip
+
+.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
+        clean-libLTLIBRARIES clean-libtool ctags distclean \
+        distclean-compile distclean-generic distclean-libtool \
+        distclean-tags distdir dvi dvi-am html html-am info info-am \
+        install install-am install-data install-data-am install-dvi \
+        install-dvi-am install-exec install-exec-am install-html \
+        install-html-am install-includesHEADERS install-info \
+        install-info-am install-libLTLIBRARIES install-man install-pdf \
+        install-pdf-am install-ps install-ps-am install-strip \
+        installcheck installcheck-am installdirs maintainer-clean \
+        maintainer-clean-generic mostlyclean mostlyclean-compile \
+        mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
+        tags uninstall uninstall-am uninstall-includesHEADERS \
+        uninstall-libLTLIBRARIES
+
+
+# Tell versions [3.59,3.63) of GNU make to not export all variables.
+# Otherwise a system limit (for SysV at least) may be exceeded.
+.NOEXPORT:
diff --git a/libraries/ecore/src/lib/ecore_evas/ecore_evas.c b/libraries/ecore/src/lib/ecore_evas/ecore_evas.c
new file mode 100644
index 0000000..dc42f92
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/ecore_evas.c
@@ -0,0 +1,2588 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <string.h>
+#include <sys/types.h>
+#include <errno.h>
+
+#ifndef _MSC_VER
+# include <unistd.h>
+#endif
+
+#ifdef HAVE_EVIL
+# include <Evil.h>
+#endif
+
+#include "Ecore.h"
+#include "ecore_private.h"
+#include "Ecore_Input.h"
+
+#include "ecore_evas_private.h"
+#include "Ecore_Evas.h"
+
+Eina_Bool _ecore_evas_app_comp_sync = 1;
+int _ecore_evas_log_dom = -1;
+static int _ecore_evas_init_count = 0;
+static Ecore_Fd_Handler *_ecore_evas_async_events_fd = NULL;
+static Eina_Bool _ecore_evas_async_events_fd_handler(void *data, Ecore_Fd_Handler *fd_handler);
+
+static Ecore_Idle_Enterer *ecore_evas_idle_enterer = NULL;
+static Ecore_Evas *ecore_evases = NULL;
+static int _ecore_evas_fps_debug = 0;
+
+static Eina_Bool
+_ecore_evas_idle_enter(void *data __UNUSED__)
+{
+   Ecore_Evas *ee;
+   double t1 = 0.0;
+   double t2 = 0.0;
+   int rend = 0;
+
+   if (!ecore_evases) return ECORE_CALLBACK_RENEW;
+   if (_ecore_evas_fps_debug)
+     {
+        t1 = ecore_time_get();
+     }
+   EINA_INLIST_FOREACH(ecore_evases, ee)
+     {
+        if (!ee->manual_render)
+          {
+             if (ee->engine.func->fn_render)
+               rend |= ee->engine.func->fn_render(ee);
+          }
+     }
+   if (_ecore_evas_fps_debug)
+     {
+        t2 = ecore_time_get();
+        if (rend)
+          _ecore_evas_fps_debug_rendertime_add(t2 - t1);
+     }
+   return ECORE_CALLBACK_RENEW;
+}
+
+/**
+ * Query if a particular renginering engine target has support
+ * @param  engine The engine to check support for
+ * @return 1 if the particular engine is supported, 0 if it is not
+ *
+ * Query if engine @param engine is supported by ecore_evas. 1 is returned if
+ * it is, and 0 is returned if it is not supported.
+ */
+EAPI int
+ecore_evas_engine_type_supported_get(Ecore_Evas_Engine_Type engine)
+{
+   switch (engine)
+     {
+      case ECORE_EVAS_ENGINE_SOFTWARE_BUFFER:
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_BUFFER
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      case ECORE_EVAS_ENGINE_SOFTWARE_XLIB:
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_XLIB
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      case ECORE_EVAS_ENGINE_XRENDER_X11:
+        return EINA_FALSE;
+      case ECORE_EVAS_ENGINE_OPENGL_X11:
+#ifdef BUILD_ECORE_EVAS_OPENGL_X11
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      case ECORE_EVAS_ENGINE_SOFTWARE_XCB:
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_XCB
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      case ECORE_EVAS_ENGINE_XRENDER_XCB:
+        return EINA_FALSE;
+      case ECORE_EVAS_ENGINE_SOFTWARE_GDI:
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_GDI
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      case ECORE_EVAS_ENGINE_SOFTWARE_DDRAW:
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_DDRAW
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      case ECORE_EVAS_ENGINE_DIRECT3D:
+#ifdef BUILD_ECORE_EVAS_DIRECT3D
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      case ECORE_EVAS_ENGINE_OPENGL_GLEW:
+#ifdef BUILD_ECORE_EVAS_OPENGL_GLEW
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+     case ECORE_EVAS_ENGINE_SOFTWARE_SDL:
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_SDL
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+     case ECORE_EVAS_ENGINE_OPENGL_SDL:
+#ifdef BUILD_ECORE_EVAS_OPENGL_SDL
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      case ECORE_EVAS_ENGINE_DIRECTFB:
+#ifdef BUILD_ECORE_EVAS_DIRECTFB
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      case ECORE_EVAS_ENGINE_SOFTWARE_FB:
+#ifdef BUILD_ECORE_EVAS_FB
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+
+          case ECORE_EVAS_ENGINE_SOFTWARE_8_X11:
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_8_X11
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+
+      case ECORE_EVAS_ENGINE_SOFTWARE_16_X11:
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_X11
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      case ECORE_EVAS_ENGINE_SOFTWARE_16_DDRAW:
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_DDRAW
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      case ECORE_EVAS_ENGINE_SOFTWARE_16_WINCE:
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_WINCE
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      case ECORE_EVAS_ENGINE_OPENGL_COCOA:
+#ifdef BUILD_ECORE_EVAS_OPENGL_COCOA
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      case ECORE_EVAS_ENGINE_EWS:
+#ifdef BUILD_ECORE_EVAS_EWS
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+     case ECORE_EVAS_ENGINE_PSL1GHT:
+#ifdef BUILD_ECORE_EVAS_PSL1GHT
+        return EINA_TRUE;
+#else
+        return EINA_FALSE;
+#endif
+      default:
+        return EINA_FALSE;
+     };
+}
+
+EAPI int
+ecore_evas_init(void)
+{
+   int fd;
+
+   if (++_ecore_evas_init_count != 1)
+     return _ecore_evas_init_count;
+
+   if (!evas_init())
+     return --_ecore_evas_init_count;
+
+   if (!ecore_init())
+     goto shutdown_evas;
+
+   _ecore_evas_log_dom = eina_log_domain_register
+     ("ecore_evas", ECORE_EVAS_DEFAULT_LOG_COLOR);
+   if(_ecore_evas_log_dom < 0)
+     {
+        EINA_LOG_ERR("Impossible to create a log domain for Ecore_Evas.");
+        goto shutdown_ecore;
+     }
+
+   fd = evas_async_events_fd_get();
+   if (fd > 0)
+     _ecore_evas_async_events_fd = ecore_main_fd_handler_add(fd,
+                                                             ECORE_FD_READ,
+                                                             _ecore_evas_async_events_fd_handler, NULL,
+                                                             NULL, NULL);
+
+   ecore_evas_idle_enterer =
+     ecore_idle_enterer_add(_ecore_evas_idle_enter, NULL);
+   if (getenv("ECORE_EVAS_FPS_DEBUG")) _ecore_evas_fps_debug = 1;
+   if (_ecore_evas_fps_debug) _ecore_evas_fps_debug_init();
+
+#ifdef BUILD_ECORE_EVAS_EWS
+   _ecore_evas_ews_events_init();
+#endif
+
+   if (getenv("ECORE_EVAS_COMP_NOSYNC"))
+      _ecore_evas_app_comp_sync = 0;
+   return _ecore_evas_init_count;
+
+ shutdown_ecore:
+   ecore_shutdown();
+ shutdown_evas:
+   evas_shutdown();
+
+   return --_ecore_evas_init_count;
+}
+
+EAPI int
+ecore_evas_shutdown(void)
+{
+   if (--_ecore_evas_init_count != 0)
+     return _ecore_evas_init_count;
+
+   while (ecore_evases) _ecore_evas_free(ecore_evases);
+
+   if (_ecore_evas_fps_debug) _ecore_evas_fps_debug_shutdown();
+   ecore_idle_enterer_del(ecore_evas_idle_enterer);
+   ecore_evas_idle_enterer = NULL;
+
+#ifdef BUILD_ECORE_EVAS_X11
+   while (_ecore_evas_x_shutdown());
+#endif
+#ifdef BUILD_ECORE_EVAS_WIN32
+   while (_ecore_evas_win32_shutdown());
+#endif
+#ifdef BUILD_ECORE_EVAS_FB
+   while (_ecore_evas_fb_shutdown());
+#endif
+#ifdef BUILD_ECORE_EVAS_EWS
+   while (_ecore_evas_ews_shutdown());
+#endif
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_BUFFER
+   while (_ecore_evas_buffer_shutdown());
+#endif
+#ifdef BUILD_ECORE_EVAS_DIRECTFB
+   while (_ecore_evas_directfb_shutdown());
+#endif
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_WINCE
+   while (_ecore_evas_wince_shutdown());
+#endif
+   if (_ecore_evas_async_events_fd)
+     ecore_main_fd_handler_del(_ecore_evas_async_events_fd);
+
+   eina_log_domain_unregister(_ecore_evas_log_dom);
+   _ecore_evas_log_dom = -1;
+   ecore_shutdown();
+   evas_shutdown();
+
+   return _ecore_evas_init_count;
+}
+
+EAPI void
+ecore_evas_app_comp_sync_set(Eina_Bool do_sync)
+{
+   _ecore_evas_app_comp_sync = do_sync;
+}
+
+EAPI Eina_Bool
+ecore_evas_app_comp_sync_get(void)
+{
+   return _ecore_evas_app_comp_sync;
+}
+
+struct ecore_evas_engine {
+   const char *name;
+   Ecore_Evas *(*constructor)(int x, int y, int w, int h, const char *extra_options);
+};
+
+/* inline is just to avoid need to ifdef around it */
+static inline const char *
+_ecore_evas_parse_extra_options_str(const char *extra_options, const char *key, char **value)
+{
+   int len = strlen(key);
+
+   while (extra_options)
+     {
+        const char *p;
+
+        if (strncmp(extra_options, key, len) != 0)
+          {
+             extra_options = strchr(extra_options, ';');
+             if (extra_options)
+               extra_options++;
+             continue;
+          }
+
+        extra_options += len;
+        p = strchr(extra_options, ';');
+        if (p)
+          {
+             len = p - extra_options;
+             *value = malloc(len + 1);
+             memcpy(*value, extra_options, len);
+             (*value)[len] = '\0';
+             extra_options = p + 1;
+          }
+        else
+          {
+             *value = strdup(extra_options);
+             extra_options = NULL;
+          }
+     }
+   return extra_options;
+}
+
+/* inline is just to avoid need to ifdef around it */
+static inline const char *
+_ecore_evas_parse_extra_options_uint(const char *extra_options, const char *key, unsigned int *value)
+{
+   int len = strlen(key);
+
+   while (extra_options)
+     {
+        const char *p;
+
+        if (strncmp(extra_options, key, len) != 0)
+          {
+             extra_options = strchr(extra_options, ';');
+             if (extra_options)
+               extra_options++;
+             continue;
+          }
+
+        extra_options += len;
+        *value = strtol(extra_options, NULL, 0);
+
+        p = strchr(extra_options, ';');
+        if (p)
+          extra_options = p + 1;
+        else
+          extra_options = NULL;
+     }
+   return extra_options;
+}
+
+/* inline is just to avoid need to ifdef around it */
+static inline const char *
+_ecore_evas_parse_extra_options_x(const char *extra_options, char **disp_name, unsigned int *parent)
+{
+   _ecore_evas_parse_extra_options_str(extra_options, "display=", disp_name);
+   _ecore_evas_parse_extra_options_uint(extra_options, "parent=", parent);
+   return extra_options;
+}
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+static Ecore_Evas *
+_ecore_evas_constructor_software_x11(int x, int y, int w, int h, const char *extra_options)
+{
+   unsigned int parent = 0;
+   char *disp_name = NULL;
+   Ecore_Evas *ee;
+
+   _ecore_evas_parse_extra_options_x(extra_options, &disp_name, &parent);
+   ee = ecore_evas_software_x11_new(disp_name, parent, x, y, w, h);
+   free(disp_name);
+
+   return ee;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_OPENGL_COCOA
+static Ecore_Evas *
+_ecore_evas_constructor_cocoa(int x, int y, int w, int h, const char *extra_options)
+{
+   char *name = NULL;
+   Ecore_Evas *ee;
+
+   _ecore_evas_parse_extra_options_str(extra_options, "name=", &name);
+   ee = ecore_evas_cocoa_new(NULL, x, y, w, h);
+   free(name);
+
+   if (ee) ecore_evas_move(ee, x, y);
+   return ee;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_OPENGL_X11
+static Ecore_Evas *
+_ecore_evas_constructor_opengl_x11(int x, int y, int w, int h, const char *extra_options)
+{
+   Ecore_X_Window parent = 0;
+   char *disp_name = NULL;
+   Ecore_Evas *ee;
+
+   _ecore_evas_parse_extra_options_x(extra_options, &disp_name, &parent);
+   ee = ecore_evas_gl_x11_new(disp_name, parent, x, y, w, h);
+   free(disp_name);
+
+   return ee;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_8_X11
+static Ecore_Evas *
+_ecore_evas_constructor_software_8_x11(int x, int y, int w, int h, const char *extra_options)
+{
+   Ecore_X_Window parent = 0;
+   char *disp_name = NULL;
+   Ecore_Evas *ee;
+
+   _ecore_evas_parse_extra_options_x(extra_options, &disp_name, &parent);
+   ee = ecore_evas_software_x11_8_new(disp_name, parent, x, y, w, h);
+   free(disp_name);
+
+   return ee;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_X11
+static Ecore_Evas *
+_ecore_evas_constructor_software_16_x11(int x, int y, int w, int h, const char *extra_options)
+{
+   Ecore_X_Window parent = 0;
+   char *disp_name = NULL;
+   Ecore_Evas *ee;
+
+   _ecore_evas_parse_extra_options_x(extra_options, &disp_name, &parent);
+   ee = ecore_evas_software_x11_16_new(disp_name, parent, x, y, w, h);
+   free(disp_name);
+
+   return ee;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_SDL
+static Ecore_Evas *
+_ecore_evas_constructor_sdl(int x __UNUSED__, int y __UNUSED__, int w, int h, const char *extra_options)
+{
+   Ecore_Evas *ee;
+   unsigned int fullscreen = 0, hwsurface = 0, noframe = 0, alpha = 0;
+   char *name = NULL;
+
+   _ecore_evas_parse_extra_options_str(extra_options, "name=", &name);
+   _ecore_evas_parse_extra_options_uint(extra_options, "fullscreen=", &fullscreen);
+   _ecore_evas_parse_extra_options_uint(extra_options, "hwsurface=", &hwsurface);
+   _ecore_evas_parse_extra_options_uint(extra_options, "noframe=", &noframe);
+   _ecore_evas_parse_extra_options_uint(extra_options, "alpha=", &alpha);
+
+   ee = ecore_evas_sdl_new(name, w, h, fullscreen, hwsurface, noframe, alpha);
+   free(name);
+
+   return ee;
+}
+
+static Ecore_Evas *
+_ecore_evas_constructor_sdl16(int x __UNUSED__, int y __UNUSED__, int w, int h, const char *extra_options)
+{
+   Ecore_Evas *ee;
+   unsigned int fullscreen = 0, hwsurface = 0, noframe = 0, alpha = 0;
+   char *name = NULL;
+
+   _ecore_evas_parse_extra_options_str(extra_options, "name=", &name);
+   _ecore_evas_parse_extra_options_uint(extra_options, "fullscreen=", &fullscreen);
+   _ecore_evas_parse_extra_options_uint(extra_options, "hwsurface=", &hwsurface);
+   _ecore_evas_parse_extra_options_uint(extra_options, "alpha=", &alpha);
+
+   ee = ecore_evas_sdl16_new(name, w, h, fullscreen, hwsurface, noframe, alpha);
+   free(name);
+
+   return ee;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_OPENGL_SDL
+static Ecore_Evas *
+_ecore_evas_constructor_opengl_sdl(int x __UNUSED__, int y __UNUSED__, int w, int h, const char *extra_options)
+{
+   Ecore_Evas *ee;
+   unsigned int fullscreen = 0, noframe = 0;
+   char *name = NULL;
+
+   _ecore_evas_parse_extra_options_str(extra_options, "name=", &name);
+   _ecore_evas_parse_extra_options_uint(extra_options, "fullscreen=", &fullscreen);
+   _ecore_evas_parse_extra_options_uint(extra_options, "noframe=", &noframe);
+
+   ee = ecore_evas_gl_sdl_new(name, w, h, fullscreen, noframe);
+   free(name);
+
+   return ee;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_DIRECTFB
+static Ecore_Evas *
+_ecore_evas_constructor_directfb(int x, int y, int w, int h, const char *extra_options)
+{
+   Ecore_Evas *ee;
+   char *disp_name = NULL;
+   unsigned int windowed = 1;
+
+   _ecore_evas_parse_extra_options_str(extra_options, "display=", &disp_name);
+   _ecore_evas_parse_extra_options_uint(extra_options, "windowed=", &windowed);
+
+   ee = ecore_evas_directfb_new(disp_name, windowed, x, y, w, h);
+   free(disp_name);
+
+   return ee;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_FB
+static Ecore_Evas *
+_ecore_evas_constructor_fb(int x __UNUSED__, int y __UNUSED__, int w, int h, const char *extra_options)
+{
+   Ecore_Evas *ee;
+   char *disp_name = NULL;
+   unsigned int rotation = 0;
+
+   _ecore_evas_parse_extra_options_str(extra_options, "display=", &disp_name);
+   _ecore_evas_parse_extra_options_uint(extra_options, "rotation=", &rotation);
+
+   ee = ecore_evas_fb_new(disp_name, rotation, w, h);
+   free(disp_name);
+
+   return ee;
+}
+#endif
+
+
+#ifdef BUILD_ECORE_EVAS_PSL1GHT
+static Ecore_Evas *
+_ecore_evas_constructor_psl1ght(int x __UNUSED__, int y __UNUSED__, int w, int h, const char *extra_options)
+{
+   Ecore_Evas *ee;
+   char *name = NULL;
+
+   _ecore_evas_parse_extra_options_str(extra_options, "name=", &name);
+   ee = ecore_evas_psl1ght_new(name, w, h);
+   free(name);
+
+   if (ee) ecore_evas_move(ee, x, y);
+   return ee;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_GDI
+static Ecore_Evas *
+_ecore_evas_constructor_software_gdi(int x, int y, int w, int h, const char *extra_options)
+{
+   return ecore_evas_software_gdi_new(NULL, x, y, w, h);
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_DDRAW
+static Ecore_Evas *
+_ecore_evas_constructor_software_ddraw(int x, int y, int w, int h, const char *extra_options)
+{
+   return ecore_evas_software_ddraw_new(NULL, x, y, w, h);
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_DIRECT3D
+static Ecore_Evas *
+_ecore_evas_constructor_direct3d(int x, int y, int w, int h, const char *extra_options)
+{
+   return ecore_evas_direct3d_new(NULL, x, y, w, h);
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_OPENGL_GLEW
+static Ecore_Evas *
+_ecore_evas_constructor_opengl_glew(int x, int y, int w, int h, const char *extra_options)
+{
+   return ecore_evas_gl_glew_new(NULL, x, y, w, h);
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_DDRAW
+static Ecore_Evas *
+_ecore_evas_constructor_software_16_ddraw(int x, int y, int w, int h, const char *extra_options)
+{
+   return ecore_evas_software_16_ddraw_new(NULL, x, y, w, h);
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_WINCE
+static Ecore_Evas *
+_ecore_evas_constructor_software_16_wince(int x, int y, int w, int h, const char *extra_options __UNUSED__)
+{
+   return ecore_evas_software_wince_new(NULL, x, y, w, h);
+}
+
+static Ecore_Evas *
+_ecore_evas_constructor_software_16_wince_fb(int x, int y, int w, int h, const char *extra_options __UNUSED__)
+{
+   return ecore_evas_software_wince_fb_new(NULL, x, y, w, h);
+}
+
+static Ecore_Evas *
+_ecore_evas_constructor_software_16_wince_gapi(int x, int y, int w, int h, const char *extra_options __UNUSED__)
+{
+   return ecore_evas_software_wince_gapi_new(NULL, x, y, w, h);
+}
+
+static Ecore_Evas *
+_ecore_evas_constructor_software_16_wince_gdi(int x, int y, int w, int h, const char *extra_options __UNUSED__)
+{
+   return ecore_evas_software_wince_gdi_new(NULL, x, y, w, h);
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_BUFFER
+static Ecore_Evas *
+_ecore_evas_constructor_buffer(int x __UNUSED__, int y __UNUSED__, int w, int h, const char *extra_options __UNUSED__)
+{
+   return ecore_evas_buffer_new(w, h);
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_EWS
+static Ecore_Evas *
+_ecore_evas_constructor_ews(int x, int y, int w, int h, const char *extra_options __UNUSED__)
+{
+   return ecore_evas_ews_new(x, y, w, h);
+}
+#endif
+
+/* note: keep sorted by priority, highest first */
+static const struct ecore_evas_engine _engines[] = {
+  /* unix */
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+  {"software_x11", _ecore_evas_constructor_software_x11},
+#endif
+#ifdef BUILD_ECORE_EVAS_OPENGL_X11
+  {"opengl_x11", _ecore_evas_constructor_opengl_x11},
+#endif
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_8_X11
+  {"software_8_x11", _ecore_evas_constructor_software_8_x11},
+#endif
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_X11
+  {"software_16_x11", _ecore_evas_constructor_software_16_x11},
+#endif
+#ifdef BUILD_ECORE_EVAS_DIRECTFB
+  {"directfb", _ecore_evas_constructor_directfb},
+#endif
+#ifdef BUILD_ECORE_EVAS_FB
+  {"fb", _ecore_evas_constructor_fb},
+#endif
+
+  /* windows */
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_GDI
+  {"software_gdi", _ecore_evas_constructor_software_gdi},
+#endif
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_DDRAW
+  {"software_ddraw", _ecore_evas_constructor_software_ddraw},
+#endif
+#ifdef BUILD_ECORE_EVAS_DIRECT3D
+  {"direct3d", _ecore_evas_constructor_direct3d},
+#endif
+#ifdef BUILD_ECORE_EVAS_OPENGL_GLEW
+  {"opengl_glew", _ecore_evas_constructor_opengl_glew},
+#endif
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_DDRAW
+  {"software_16_ddraw", _ecore_evas_constructor_software_16_ddraw},
+#endif
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_WINCE
+  {"software_16_wince", _ecore_evas_constructor_software_16_wince},
+  {"software_16_wince_fb", _ecore_evas_constructor_software_16_wince_fb},
+  {"software_16_wince_gapi", _ecore_evas_constructor_software_16_wince_gapi},
+  {"software_16_wince_gdi", _ecore_evas_constructor_software_16_wince_gdi},
+#endif
+
+  /* Apple */
+#ifdef BUILD_ECORE_EVAS_OPENGL_COCOA
+  {"opengl_cocoa", _ecore_evas_constructor_cocoa},
+#endif
+
+  /* PS3 support */
+#ifdef BUILD_ECORE_EVAS_PSL1GHT
+  {"psl1ght", _ecore_evas_constructor_psl1ght},
+#endif
+
+  /* Last chance to have a window */
+#ifdef BUILD_ECORE_EVAS_OPENGL_SDL
+  {"opengl_sdl", _ecore_evas_constructor_opengl_sdl},
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_SDL
+  {"sdl", _ecore_evas_constructor_sdl},
+  {"software_16_sdl", _ecore_evas_constructor_sdl16},
+#endif
+
+  /* independent */
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_BUFFER
+  {"buffer", _ecore_evas_constructor_buffer},
+#endif
+
+#ifdef BUILD_ECORE_EVAS_EWS
+  {"ews", _ecore_evas_constructor_ews},
+#endif
+  {NULL, NULL}
+};
+
+EAPI Eina_List *
+ecore_evas_engines_get(void)
+{
+   const struct ecore_evas_engine *itr;
+   Eina_List *lst = NULL;
+
+   for (itr = _engines; itr->name; itr++)
+     lst = eina_list_append(lst, itr->name);
+
+   return lst;
+}
+
+EAPI void
+ecore_evas_engines_free(Eina_List *engines)
+{
+   eina_list_free(engines);
+}
+
+static Ecore_Evas *
+_ecore_evas_new_auto_discover(int x, int y, int w, int h, const char *extra_options)
+{
+   const struct ecore_evas_engine *itr;
+
+   DBG("auto discover engine");
+
+   for (itr = _engines; itr->constructor; itr++)
+     {
+        Ecore_Evas *ee = itr->constructor(x, y, w, h, extra_options);
+        if (ee)
+          {
+             INF("auto discovered '%s'", itr->name);
+             return ee;
+          }
+     }
+
+   WRN("could not auto discover.");
+   return NULL;
+}
+
+EAPI Ecore_Evas *
+ecore_evas_new(const char *engine_name, int x, int y, int w, int h, const char *extra_options)
+{
+   const struct ecore_evas_engine *itr;
+
+   if (!engine_name)
+     {
+        engine_name = getenv("ECORE_EVAS_ENGINE");
+        if (engine_name)
+          DBG("no engine_name provided, using ECORE_EVAS_ENGINE='%s'",
+              engine_name);
+     }
+   if (!engine_name)
+     return _ecore_evas_new_auto_discover(x, y, w, h, extra_options);
+
+   for (itr = _engines; itr->name; itr++)
+     if (strcmp(itr->name, engine_name) == 0)
+       {
+          INF("using engine '%s', extra_options=%s",
+              engine_name, extra_options ? extra_options : "(null)");
+          return itr->constructor(x, y, w, h, extra_options);
+       }
+
+   WRN("unknown engine '%s'", engine_name);
+   return NULL;
+}
+
+EAPI const char *
+ecore_evas_engine_name_get(const Ecore_Evas *ee)
+{
+   if (!ee)
+     return NULL;
+   return ee->driver;
+}
+
+EAPI Ecore_Evas *
+ecore_evas_ecore_evas_get(const Evas *e)
+{
+   Ecore_Evas *ee = evas_data_attach_get(e);
+   if (!ee) return NULL;
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS, "ecore_evas_ecore_evas_get");
+        return NULL;
+     }
+   return ee;
+}
+
+EAPI void
+ecore_evas_free(Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_free");
+        return;
+     }
+   _ecore_evas_free(ee);
+   return;
+}
+
+EAPI void *
+ecore_evas_data_get(const Ecore_Evas *ee, const char *key)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_data_get");
+        return NULL;
+     }
+
+   if (!key) return NULL;
+   if (!ee->data) return NULL;
+
+   return eina_hash_find(ee->data, key);
+}
+
+EAPI void
+ecore_evas_data_set(Ecore_Evas *ee, const char *key, const void *data)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_data_set");
+        return;
+     }
+
+   if (!key) return;
+
+   if (ee->data)
+     eina_hash_del(ee->data, key, NULL);
+   if (data)
+     {
+       if (!ee->data)
+         ee->data = eina_hash_string_superfast_new(NULL);
+       eina_hash_add(ee->data, key, data);
+     }
+}
+
+#define IFC(_ee, _fn)  if (_ee->engine.func->_fn) {_ee->engine.func->_fn
+#define IFE            return;}
+
+EAPI void
+ecore_evas_callback_resize_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_resize_set");
+        return;
+     }
+   IFC(ee, fn_callback_resize_set) (ee, func);
+   IFE;
+   ee->func.fn_resize = func;
+}
+
+EAPI void
+ecore_evas_callback_move_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_move_set");
+        return;
+     }
+   IFC(ee, fn_callback_move_set) (ee, func);
+   IFE;
+   ee->func.fn_move = func;
+}
+
+EAPI void
+ecore_evas_callback_show_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_show_set");
+        return;
+     }
+   IFC(ee, fn_callback_show_set) (ee, func);
+   IFE;
+   ee->func.fn_show = func;
+}
+
+EAPI void
+ecore_evas_callback_hide_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_hide_set");
+        return;
+     }
+   IFC(ee, fn_callback_hide_set) (ee, func);
+   IFE;
+   ee->func.fn_hide = func;
+}
+
+EAPI void
+ecore_evas_callback_delete_request_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_delete_request_set");
+        return;
+     }
+   IFC(ee, fn_callback_delete_request_set) (ee, func);
+   IFE;
+   ee->func.fn_delete_request = func;
+}
+
+EAPI void
+ecore_evas_callback_destroy_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_destroy_set");
+        return;
+     }
+   IFC(ee, fn_callback_destroy_set) (ee, func);
+   IFE;
+   ee->func.fn_destroy = func;
+}
+
+EAPI void
+ecore_evas_callback_focus_in_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_focus_in_set");
+        return;
+     }
+   IFC(ee, fn_callback_focus_in_set) (ee, func);
+   IFE;
+   ee->func.fn_focus_in = func;
+}
+
+EAPI void
+ecore_evas_callback_focus_out_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_focus_out_set");
+        return;
+     }
+   IFC(ee, fn_callback_focus_out_set) (ee, func);
+   IFE;
+   ee->func.fn_focus_out = func;
+}
+
+EAPI void
+ecore_evas_callback_sticky_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_sticky_set");
+        return;
+     }
+   IFC(ee, fn_callback_sticky_set) (ee, func);
+   IFE;
+   ee->func.fn_sticky = func;
+}
+
+EAPI void
+ecore_evas_callback_unsticky_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_unsticky_set");
+        return;
+     }
+   IFC(ee, fn_callback_unsticky_set) (ee, func);
+   IFE;
+   ee->func.fn_unsticky = func;
+}
+
+EAPI void
+ecore_evas_callback_mouse_in_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_mouse_in_set");
+        return;
+     }
+   IFC(ee, fn_callback_mouse_in_set) (ee, func);
+   IFE;
+   ee->func.fn_mouse_in = func;
+}
+
+EAPI void
+ecore_evas_callback_mouse_out_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_mouse_out_set");
+        return;
+     }
+   IFC(ee, fn_callback_mouse_out_set) (ee, func);
+   IFE;
+   ee->func.fn_mouse_out = func;
+}
+
+EAPI void
+ecore_evas_callback_pre_render_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_pre_render_set");
+        return;
+     }
+   IFC(ee, fn_callback_pre_render_set) (ee, func);
+   IFE;
+   ee->func.fn_pre_render = func;
+}
+
+EAPI void
+ecore_evas_callback_post_render_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_post_render_set");
+        return;
+     }
+   IFC(ee, fn_callback_post_render_set) (ee, func);
+   IFE;
+   ee->func.fn_post_render = func;
+}
+
+EAPI void
+ecore_evas_callback_pre_free_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_callback_pre_free_set");
+        return;
+     }
+   ee->func.fn_pre_free = func;
+}
+
+/**
+ * Get an Ecore_Evas's Evas
+ * @param ee The Ecore_Evas whose Evas you wish to get
+ * @return The Evas wrapped by @p ee
+ *
+ * This function returns the Evas contained within @p ee.
+ */
+EAPI Evas *
+ecore_evas_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_get");
+        return NULL;
+     }
+   return ee->evas;
+}
+
+EAPI void
+ecore_evas_move(Ecore_Evas *ee, int x, int y)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_move");
+        return;
+     }
+   if (ee->prop.fullscreen) return;
+   IFC(ee, fn_move) (ee, x, y);
+   IFE;
+}
+
+/**
+ * Provide Managed move co-ordinates for an Ecore_Evas
+ * @param ee The Ecore_Evas to move
+ * @param x The x coordinate to set as the managed location
+ * @param y The y coordinate to set as the managed location
+ *
+ * This sets the managed geometry position of the @p ee to (@p x, @p y)
+ */
+EAPI void
+ecore_evas_managed_move(Ecore_Evas *ee, int x, int y)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_move");
+        return;
+     }
+   IFC(ee, fn_managed_move) (ee, x, y);
+   IFE;
+}
+
+EAPI void
+ecore_evas_resize(Ecore_Evas *ee, int w, int h)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_resize");
+        return;
+     }
+   if (ee->prop.fullscreen) return;
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+        IFC(ee, fn_resize) (ee, h, w);
+        IFE;
+     }
+   else
+     {
+        IFC(ee, fn_resize) (ee, w, h);
+        IFE;
+     }
+}
+
+EAPI void
+ecore_evas_move_resize(Ecore_Evas *ee, int x, int y, int w, int h)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_move_resize");
+        return;
+     }
+   if (ee->prop.fullscreen) return;
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+        IFC(ee, fn_move_resize) (ee, x, y, h, w);
+        IFE;
+     }
+   else
+     {
+        IFC(ee, fn_move_resize) (ee, x, y, w, h);
+        IFE;
+     }
+}
+
+EAPI void
+ecore_evas_geometry_get(const Ecore_Evas *ee, int *x, int *y, int *w, int *h)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_geometry_get");
+        return;
+     }
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+        if (x) *x = ee->x;
+        if (y) *y = ee->y;
+        if (w) *w = ee->h;
+        if (h) *h = ee->w;
+     }
+   else
+     {
+        if (x) *x = ee->x;
+        if (y) *y = ee->y;
+        if (w) *w = ee->w;
+        if (h) *h = ee->h;
+     }
+}
+
+EAPI void
+ecore_evas_request_geometry_get(const Ecore_Evas *ee, int *x, int *y, int *w, int *h)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_request_geometry_get");
+        return;
+     }
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+        if (x) *x = ee->req.x;
+        if (y) *y = ee->req.y;
+        if (w) *w = ee->req.h;
+        if (h) *h = ee->req.w;
+     }
+   else
+     {
+        if (x) *x = ee->req.x;
+        if (y) *y = ee->req.y;
+        if (w) *w = ee->req.w;
+        if (h) *h = ee->req.h;
+     }
+}
+
+EAPI void
+ecore_evas_rotation_set(Ecore_Evas *ee, int rot)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_rotation_set");
+        return;
+     }
+   rot = rot % 360;
+   while (rot < 0) rot += 360;
+   while (rot >= 360) rot -= 360;
+   IFC(ee, fn_rotation_set) (ee, rot, 0);
+   /* make sure everything gets redrawn */
+   evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+   evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
+   IFE;
+}
+
+EAPI void
+ecore_evas_rotation_with_resize_set(Ecore_Evas *ee, int rot)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_rotation_set");
+        return;
+     }
+   rot = rot % 360;
+   while (rot < 0) rot += 360;
+   while (rot >= 360) rot -= 360;
+   IFC(ee, fn_rotation_set) (ee, rot, 1);
+   /* make sure everything gets redrawn */
+   evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+   evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
+   IFE;
+}
+
+EAPI int
+ecore_evas_rotation_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_rotation_get");
+        return 0;
+     }
+   return ee->rotation;
+}
+
+/**
+ * Set whether an Ecore_Evas is shaped or not.
+ * @param ee The Ecore_Evas to shape
+ * @param shaped EINA_TRUE to shape, EINA_FALSE to not
+ *
+ * This function allows one to make an Ecore_Evas shaped to the contents of the
+ * evas. If @p shaped is EINA_TRUE, @p ee will be transparent in parts of the evas that
+ * contain no objects. If @p shaped is EINA_FALSE, then @p ee will be rectangular, and
+ * and parts with no data will show random framebuffer artifacting. For
+ * non-shaped Ecore_Evases, it is recommend to cover the entire evas with a
+ * background object.
+ */
+EAPI void
+ecore_evas_shaped_set(Ecore_Evas *ee, Eina_Bool shaped)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_shaped_set");
+        return;
+     }
+   IFC(ee, fn_shaped_set) (ee, shaped);
+   IFE;
+}
+
+/**
+ * Query whether an Ecore_Evas is shaped or not.
+ * @param ee The Ecore_Evas to query.
+ * @return EINA_TRUE if shaped, EINA_FALSE if not.
+ *
+ * This function returns EINA_TRUE if @p ee is shaped, and EINA_FALSE if not.
+ */
+EAPI Eina_Bool
+ecore_evas_shaped_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_shaped_get");
+        return EINA_FALSE;
+     }
+   return ee->shaped ? EINA_TRUE : EINA_FALSE;
+}
+
+EAPI void
+ecore_evas_alpha_set(Ecore_Evas *ee, Eina_Bool alpha)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_alpha_set");
+        return;
+     }
+   IFC(ee, fn_alpha_set) (ee, alpha);
+   IFE;
+}
+
+EAPI Eina_Bool
+ecore_evas_alpha_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_alpha_get");
+        return EINA_FALSE;
+     }
+   return ee->alpha ? EINA_TRUE : EINA_FALSE;
+}
+
+EAPI void
+ecore_evas_transparent_set(Ecore_Evas *ee, Eina_Bool transparent)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_transparent_set");
+        return;
+     }
+   IFC(ee, fn_transparent_set) (ee, transparent);
+   IFE;
+}
+
+EAPI Eina_Bool
+ecore_evas_transparent_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_transparent_get");
+        return EINA_FALSE;
+     }
+   return ee->transparent ? EINA_TRUE : 0;
+}
+
+EAPI void
+ecore_evas_show(Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_show");
+        return;
+     }
+   IFC(ee, fn_show) (ee);
+   IFE;
+}
+
+EAPI void
+ecore_evas_hide(Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_hide");
+        return;
+     }
+   IFC(ee, fn_hide) (ee);
+   IFE;
+}
+
+ EAPI int
+ecore_evas_visibility_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_visibility_get");
+        return 0;
+     }
+   return ee->visible ? 1:0;
+}
+
+EAPI void
+ecore_evas_raise(Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_raise");
+        return;
+     }
+   IFC(ee, fn_raise) (ee);
+   IFE;
+}
+
+EAPI void
+ecore_evas_lower(Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_lower");
+        return;
+     }
+   IFC(ee, fn_lower) (ee);
+   IFE;
+}
+
+/**
+ * Activate (set focus to, via the window manager) an Ecore_Evas' window.
+ * @param ee The Ecore_Evas to activate.
+ *
+ * This functions activates the Ecore_Evas.
+ */
+EAPI void
+ecore_evas_activate(Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_activate");
+        return;
+     }
+   IFC(ee, fn_activate) (ee);
+   IFE;
+}
+
+EAPI void
+ecore_evas_title_set(Ecore_Evas *ee, const char *t)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_title_set");
+        return;
+     }
+   IFC(ee, fn_title_set) (ee, t);
+   IFE;
+}
+
+EAPI const char *
+ecore_evas_title_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_title_get");
+        return NULL;
+     }
+   return ee->prop.title;
+}
+
+EAPI void
+ecore_evas_name_class_set(Ecore_Evas *ee, const char *n, const char *c)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_name_class_set");
+        return;
+     }
+   IFC(ee, fn_name_class_set) (ee, n, c);
+   IFE;
+}
+
+EAPI void
+ecore_evas_name_class_get(const Ecore_Evas *ee, const char **n, const char **c)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_name_class_get");
+        return;
+     }
+   if (n) *n = ee->prop.name;
+   if (c) *c = ee->prop.clas;
+}
+
+EAPI void
+ecore_evas_size_min_set(Ecore_Evas *ee, int w, int h)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_size_min_set");
+        return;
+     }
+   if (w < 0) w = 0;
+   if (h < 0) h = 0;
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+        IFC(ee, fn_size_min_set) (ee, h, w);
+        IFE;
+     }
+   else
+     {
+        IFC(ee, fn_size_min_set) (ee, w, h);
+        IFE;
+     }
+}
+
+EAPI void
+ecore_evas_size_min_get(const Ecore_Evas *ee, int *w, int *h)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_size_min_get");
+        return;
+     }
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+        if (w) *w = ee->prop.min.h;
+        if (h) *h = ee->prop.min.w;
+     }
+   else
+     {
+        if (w) *w = ee->prop.min.w;
+        if (h) *h = ee->prop.min.h;
+     }
+}
+
+EAPI void
+ecore_evas_size_max_set(Ecore_Evas *ee, int w, int h)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_size_max_set");
+        return;
+     }
+   if (w < 0) w = 0;
+   if (h < 0) h = 0;
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+        IFC(ee, fn_size_max_set) (ee, h, w);
+        IFE;
+     }
+   else
+     {
+        IFC(ee, fn_size_max_set) (ee, w, h);
+        IFE;
+     }
+}
+
+EAPI void
+ecore_evas_size_max_get(const Ecore_Evas *ee, int *w, int *h)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_size_max_get");
+        return;
+     }
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+        if (w) *w = ee->prop.max.h;
+        if (h) *h = ee->prop.max.w;
+     }
+   else
+     {
+        if (w) *w = ee->prop.max.w;
+        if (h) *h = ee->prop.max.h;
+     }
+}
+
+EAPI void
+ecore_evas_size_base_set(Ecore_Evas *ee, int w, int h)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_size_base_set");
+        return;
+     }
+   if (w < 0) w = 0;
+   if (h < 0) h = 0;
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+        IFC(ee, fn_size_base_set) (ee, h, w);
+        IFE;
+     }
+   else
+     {
+        IFC(ee, fn_size_base_set) (ee, w, h);
+        IFE;
+     }
+}
+
+EAPI void
+ecore_evas_size_base_get(const Ecore_Evas *ee, int *w, int *h)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_size_base_get");
+        return;
+     }
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+        if (w) *w = ee->prop.base.h;
+        if (h) *h = ee->prop.base.w;
+     }
+   else
+     {
+        if (w) *w = ee->prop.base.w;
+        if (h) *h = ee->prop.base.h;
+     }
+}
+
+EAPI void
+ecore_evas_size_step_set(Ecore_Evas *ee, int w, int h)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_size_step_set");
+        return;
+     }
+   if (w < 0) w = 0;
+   if (h < 0) h = 0;
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+        IFC(ee, fn_size_step_set) (ee, h, w);
+        IFE;
+     }
+   else
+     {
+        IFC(ee, fn_size_step_set) (ee, w, h);
+        IFE;
+     }
+}
+
+EAPI void
+ecore_evas_size_step_get(const Ecore_Evas *ee, int *w, int *h)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_size_step_get");
+        return;
+     }
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+        if (w) *w = ee->prop.step.h;
+        if (h) *h = ee->prop.step.w;
+     }
+   else
+     {
+        if (w) *w = ee->prop.step.w;
+        if (h) *h = ee->prop.step.h;
+     }
+}
+
+EAPI void
+ecore_evas_cursor_set(Ecore_Evas *ee, const char *file, int layer, int hot_x, int hot_y)
+{
+   Evas_Object  *obj = NULL;
+
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_cursor_set");
+        return;
+     }
+
+   if (file)
+     {
+        int x, y;
+
+        obj = evas_object_image_add(ee->evas);
+        evas_object_image_file_set(obj, file, NULL);
+        evas_object_image_size_get(obj, &x, &y);
+        evas_object_resize(obj, x, y);
+        evas_object_image_fill_set(obj, 0, 0, x, y);
+     }
+
+   IFC(ee, fn_object_cursor_set) (ee, obj, layer, hot_x, hot_y);
+   IFE;
+}
+
+EAPI void
+ecore_evas_object_cursor_set(Ecore_Evas *ee, Evas_Object *obj, int layer, int hot_x, int hot_y)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_cursor_set");
+        return;
+     }
+   IFC(ee, fn_object_cursor_set) (ee, obj, layer, hot_x, hot_y);
+   IFE;
+}
+
+EAPI void
+ecore_evas_cursor_get(const Ecore_Evas *ee, Evas_Object **obj, int *layer, int *hot_x, int *hot_y)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_cursor_get");
+        return;
+     }
+   if (obj) *obj = ee->prop.cursor.object;
+   if (layer) *layer = ee->prop.cursor.layer;
+   if (hot_x) *hot_x = ee->prop.cursor.hot.x;
+   if (hot_y) *hot_y = ee->prop.cursor.hot.y;
+}
+
+EAPI void
+ecore_evas_layer_set(Ecore_Evas *ee, int layer)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_layer_set");
+        return;
+     }
+   IFC(ee, fn_layer_set) (ee, layer);
+   IFE;
+}
+
+EAPI int
+ecore_evas_layer_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_layer_get");
+        return 0;
+     }
+   return ee->prop.layer;
+}
+
+EAPI void
+ecore_evas_focus_set(Ecore_Evas *ee, Eina_Bool on)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_focus_set");
+        return;
+     }
+   IFC(ee, fn_focus_set) (ee, on);
+   IFE;
+}
+
+EAPI Eina_Bool
+ecore_evas_focus_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_focus_get");
+        return EINA_FALSE;
+     }
+   return ee->prop.focused ? EINA_TRUE : EINA_FALSE;
+}
+
+EAPI void
+ecore_evas_iconified_set(Ecore_Evas *ee, Eina_Bool on)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_iconified_set");
+        return;
+     }
+   IFC(ee, fn_iconified_set) (ee, on);
+   IFE;
+}
+
+EAPI Eina_Bool
+ecore_evas_iconified_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_iconified_get");
+        return EINA_FALSE;
+     }
+   return ee->prop.iconified ? EINA_TRUE : EINA_FALSE;
+}
+
+EAPI void
+ecore_evas_borderless_set(Ecore_Evas *ee, Eina_Bool on)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_borderless_set");
+        return;
+     }
+   IFC(ee, fn_borderless_set) (ee, on);
+   IFE;
+}
+
+EAPI Eina_Bool
+ecore_evas_borderless_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_borderless_get");
+        return EINA_FALSE;
+     }
+   return ee->prop.borderless ? EINA_TRUE : EINA_FALSE;
+}
+
+/**
+ * Tell the WM whether or not to ignore an Ecore_Evas' window
+ * @param ee The Ecore_Evas
+ * @param on EINA_TRUE to ignore, EINA_FALSE to not.
+ *
+ * This function causes the window manager to ignore @p ee if @p on is EINA_TRUE,
+ * or not ignore @p ee if @p on is EINA_FALSE.
+ */
+EAPI void
+ecore_evas_override_set(Ecore_Evas *ee, Eina_Bool on)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_override_set");
+        return;
+     }
+   IFC(ee, fn_override_set) (ee, on);
+   IFE;
+}
+
+/**
+ * Query whether an Ecore_Evas' window is overridden or not
+ * @param ee The Ecore_Evas to set
+ * @return EINA_TRUE if @p ee is overridden, EINA_FALSE if not.
+ *
+ */
+EAPI Eina_Bool
+ecore_evas_override_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_override_get");
+        return EINA_FALSE;
+     }
+   return ee->prop.override ? EINA_TRUE : EINA_FALSE;
+}
+
+EAPI void
+ecore_evas_maximized_set(Ecore_Evas *ee, Eina_Bool on)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_maximized_set");
+        return;
+     }
+   IFC(ee, fn_maximized_set) (ee, on);
+   IFE;
+}
+
+EAPI Eina_Bool
+ecore_evas_maximized_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_maximized_get");
+        return EINA_FALSE;
+     }
+   return ee->prop.maximized ? EINA_TRUE : EINA_FALSE;
+}
+
+EAPI void
+ecore_evas_fullscreen_set(Ecore_Evas *ee, Eina_Bool on)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_fullscreen_set");
+        return;
+     }
+   IFC(ee, fn_fullscreen_set) (ee, on);
+   IFE;
+}
+
+EAPI Eina_Bool
+ecore_evas_fullscreen_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_fullscreen_get");
+        return EINA_FALSE;
+     }
+   return ee->prop.fullscreen ? EINA_TRUE : EINA_FALSE;
+}
+
+/**
+ * Set whether or not an Ecore_Evas' window should avoid damage
+ *
+ * @param ee The Ecore_Evas
+ * @param The type of the damage management
+ *
+ * This function causes @p ee to be drawn to a pixmap to avoid recalculations.
+ * On expose events it will copy from the pixmap to the window.
+ */
+EAPI void
+ecore_evas_avoid_damage_set(Ecore_Evas *ee, Ecore_Evas_Avoid_Damage_Type on)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_avoid_damage_set");
+        return;
+     }
+   IFC(ee, fn_avoid_damage_set) (ee, on);
+   IFE;
+}
+
+/**
+ * Query whether an Ecore_Evas' window avoids damage or not
+ * @param ee The Ecore_Evas to set
+ * @return The type of the damage management
+ *
+ */
+EAPI Ecore_Evas_Avoid_Damage_Type
+ecore_evas_avoid_damage_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_avoid_damage_get");
+        return ECORE_EVAS_AVOID_DAMAGE_NONE;
+     }
+   return ee->prop.avoid_damage;
+}
+
+/**
+ * Set the withdrawn state of an Ecore_Evas' window.
+ * @param ee The Ecore_Evas whose window's withdrawn state is set.
+ * @param withdrawn The Ecore_Evas window's new withdrawn state.
+ *
+ */
+EAPI void
+ecore_evas_withdrawn_set(Ecore_Evas *ee, Eina_Bool withdrawn)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_withdrawn_set");
+        return;
+     }
+
+   IFC(ee, fn_withdrawn_set) (ee, withdrawn);
+   IFE;
+}
+
+/**
+ * Returns the withdrawn state of an Ecore_Evas' window.
+ * @param ee The Ecore_Evas whose window's withdrawn state is returned.
+ * @return The Ecore_Evas window's withdrawn state.
+ *
+ */
+EAPI Eina_Bool
+ecore_evas_withdrawn_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_withdrawn_get");
+        return EINA_FALSE;
+     } else
+     return ee->prop.withdrawn ? EINA_TRUE : EINA_FALSE;
+}
+
+/**
+ * Set the sticky state of an Ecore_Evas window.
+ *
+ * @param ee The Ecore_Evas whose window's sticky state is set.
+ * @param sticky The Ecore_Evas window's new sticky state.
+ *
+ */
+EAPI void
+ecore_evas_sticky_set(Ecore_Evas *ee, Eina_Bool sticky)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_sticky_set");
+        return;
+     }
+
+   IFC(ee, fn_sticky_set) (ee, sticky);
+   IFE;
+}
+
+/**
+ * Returns the sticky state of an Ecore_Evas' window.
+ *
+ * @param ee The Ecore_Evas whose window's sticky state is returned.
+ * @return The Ecore_Evas window's sticky state.
+ *
+ */
+EAPI Eina_Bool
+ecore_evas_sticky_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_sticky_get");
+        return EINA_FALSE;
+     } else
+     return ee->prop.sticky ? EINA_TRUE : EINA_FALSE;
+}
+
+EAPI void
+ecore_evas_ignore_events_set(Ecore_Evas *ee, Eina_Bool ignore)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_ignore_events_set");
+        return;
+     }
+
+   IFC(ee, fn_ignore_events_set) (ee, ignore);
+   IFE;
+}
+
+EAPI Eina_Bool
+ecore_evas_ignore_events_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_ignore_events_get");
+        return EINA_FALSE;
+     }
+   return ee->ignore_events ? EINA_TRUE : EINA_FALSE;
+}
+
+EAPI void
+ecore_evas_manual_render_set(Ecore_Evas *ee, Eina_Bool manual_render)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_manual_render_set");
+        return;
+     }
+   ee->manual_render = manual_render;
+}
+
+EAPI Eina_Bool
+ecore_evas_manual_render_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_manual_render_get");
+        return EINA_FALSE;
+     }
+   return ee->manual_render ? EINA_TRUE : EINA_FALSE;
+}
+
+EAPI void
+ecore_evas_manual_render(Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_manual_render");
+        return;
+     }
+   if (ee->engine.func->fn_render)
+     ee->engine.func->fn_render(ee);
+}
+
+EAPI void
+ecore_evas_comp_sync_set(Ecore_Evas *ee, Eina_Bool do_sync)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_comp_sync_set");
+        return;
+     }
+   ee->no_comp_sync = !do_sync;
+}
+
+EAPI Eina_Bool
+ecore_evas_comp_sync_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_comp_sync_get");
+        return EINA_FALSE;
+     }
+   return !ee->no_comp_sync;
+}
+
+EAPI Ecore_Window
+ecore_evas_window_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+   {
+      ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+         "ecore_evas_window_get");
+      return 0;
+   }
+
+   return ee->prop.window;
+}
+
+EAPI void
+ecore_evas_screen_geometry_get(const Ecore_Evas *ee, int *x, int *y, int *w, int *h)
+{
+   if (x) *x = 0;
+   if (y) *y = 0;
+   if (w) *w = 0;
+   if (h) *h = 0;
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_screen_geometry_get");
+        return;
+     }
+
+   IFC(ee, fn_screen_geometry_get) (ee, x, y, w, h);
+   IFE;
+}
+
+/* fps debug calls - for debugging how much time your app actually spends */
+/* rendering graphics... :) */
+
+static int _ecore_evas_fps_debug_init_count = 0;
+static int _ecore_evas_fps_debug_fd = -1;
+unsigned int *_ecore_evas_fps_rendertime_mmap = NULL;
+
+void
+_ecore_evas_fps_debug_init(void)
+{
+   char buf[4096];
+   const char *tmp;
+
+   _ecore_evas_fps_debug_init_count++;
+   if (_ecore_evas_fps_debug_init_count > 1) return;
+
+#ifndef HAVE_EVIL
+   tmp = "/tmp";
+#else
+   tmp = evil_tmpdir_get ();
+#endif /* HAVE_EVIL */
+   snprintf(buf, sizeof(buf), "%s/.ecore_evas_fps_debug-%i", tmp, (int)getpid());
+   _ecore_evas_fps_debug_fd = open(buf, O_CREAT | O_TRUNC | O_RDWR, 0644);
+   if (_ecore_evas_fps_debug_fd < 0)
+     {
+        unlink(buf);
+        _ecore_evas_fps_debug_fd = open(buf, O_CREAT | O_TRUNC | O_RDWR, 0644);
+     }
+   if (_ecore_evas_fps_debug_fd >= 0)
+     {
+        unsigned int zero = 0;
+        char *buf2 = (char *)&zero;
+        ssize_t todo = sizeof(unsigned int);
+
+        while (todo > 0)
+          {
+             ssize_t r = write(_ecore_evas_fps_debug_fd, buf2, todo);
+             if (r > 0)
+               {
+                  todo -= r;
+                  buf2 += r;
+               }
+             else if ((r < 0) && (errno == EINTR))
+               continue;
+             else
+               {
+                  ERR("could not write to file '%s' fd %d: %s",
+                      buf, _ecore_evas_fps_debug_fd, strerror(errno));
+                  close(_ecore_evas_fps_debug_fd);
+                  _ecore_evas_fps_debug_fd = -1;
+                  return;
+               }
+          }
+        _ecore_evas_fps_rendertime_mmap = mmap(NULL, sizeof(unsigned int),
+                                               PROT_READ | PROT_WRITE,
+                                               MAP_SHARED,
+                                               _ecore_evas_fps_debug_fd, 0);
+        if (_ecore_evas_fps_rendertime_mmap == MAP_FAILED)
+          _ecore_evas_fps_rendertime_mmap = NULL;
+     }
+}
+
+void
+_ecore_evas_fps_debug_shutdown(void)
+{
+   _ecore_evas_fps_debug_init_count--;
+   if (_ecore_evas_fps_debug_init_count > 0) return;
+   if (_ecore_evas_fps_debug_fd >= 0)
+     {
+        char buf[4096];
+
+        snprintf(buf, sizeof(buf), "/tmp/.ecore_evas_fps_debug-%i", (int)getpid());
+        unlink(buf);
+        if (_ecore_evas_fps_rendertime_mmap)
+          {
+             munmap(_ecore_evas_fps_rendertime_mmap, sizeof(int));
+             _ecore_evas_fps_rendertime_mmap = NULL;
+          }
+        close(_ecore_evas_fps_debug_fd);
+        _ecore_evas_fps_debug_fd = -1;
+     }
+}
+
+void
+_ecore_evas_fps_debug_rendertime_add(double t)
+{
+   static double rtime = 0.0;
+   static double rlapse = 0.0;
+   static int frames = 0;
+   static int flapse = 0;
+   double tim;
+
+   tim = ecore_time_get();
+   rtime += t;
+   frames++;
+   if (rlapse == 0.0)
+     {
+        rlapse = tim;
+        flapse = frames;
+     }
+   else if ((tim - rlapse) >= 0.5)
+     {
+        printf("FRAME: %i, FPS: %3.1f, RTIME %3.0f%%\n",
+               frames,
+               (frames - flapse) / (tim - rlapse),
+               (100.0 * rtime) / (tim - rlapse)
+               );
+        rlapse = tim;
+        flapse = frames;
+        rtime = 0.0;
+     }
+}
+
+void
+_ecore_evas_register(Ecore_Evas *ee)
+{
+   ee->registered = 1;
+   ecore_evases = (Ecore_Evas *)eina_inlist_prepend
+     (EINA_INLIST_GET(ecore_evases), EINA_INLIST_GET(ee));
+}
+
+void
+_ecore_evas_ref(Ecore_Evas *ee)
+{
+   ee->refcount++;
+}
+
+void
+_ecore_evas_unref(Ecore_Evas *ee)
+{
+   ee->refcount--;
+   if (ee->refcount == 0)
+     {
+        if (ee->deleted) _ecore_evas_free(ee);
+     }
+   else if (ee->refcount < -1)
+     ERR("Ecore_Evas %p->refcount=%d < 0", ee, ee->refcount);
+}
+
+void
+_ecore_evas_free(Ecore_Evas *ee)
+{
+   ee->deleted = EINA_TRUE;
+   if (ee->refcount > 0) return;
+
+   if (ee->func.fn_pre_free) ee->func.fn_pre_free(ee);
+   while (ee->sub_ecore_evas)
+     {
+        _ecore_evas_free(ee->sub_ecore_evas->data);
+     }
+   if (ee->data) eina_hash_free(ee->data);
+   ee->data = NULL;
+   if (ee->name) free(ee->name);
+   ee->name = NULL;
+   if (ee->prop.title) free(ee->prop.title);
+   ee->prop.title = NULL;
+   if (ee->prop.name) free(ee->prop.name);
+   ee->prop.name = NULL;
+   if (ee->prop.clas) free(ee->prop.clas);
+   ee->prop.clas = NULL;
+   if (ee->prop.cursor.object) evas_object_del(ee->prop.cursor.object);
+   ee->prop.cursor.object = NULL;
+   if (ee->evas) evas_free(ee->evas);
+   ee->evas = NULL;
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_NONE);
+   ee->driver = NULL;
+   if (ee->engine.idle_flush_timer)
+     ecore_timer_del(ee->engine.idle_flush_timer);
+   if (ee->engine.func->fn_free) ee->engine.func->fn_free(ee);
+   if (ee->registered)
+     {
+        ecore_evases = (Ecore_Evas *)eina_inlist_remove
+          (EINA_INLIST_GET(ecore_evases), EINA_INLIST_GET(ee));
+     }
+   free(ee);
+}
+
+static Eina_Bool
+_ecore_evas_cb_idle_flush(void *data)
+{
+   Ecore_Evas *ee;
+
+   ee = (Ecore_Evas *)data;
+   evas_render_idle_flush(ee->evas);
+   ee->engine.idle_flush_timer = NULL;
+   return ECORE_CALLBACK_CANCEL;
+}
+
+static Eina_Bool
+_ecore_evas_async_events_fd_handler(void *data __UNUSED__, Ecore_Fd_Handler *fd_handler __UNUSED__)
+{
+   evas_async_events_process();
+
+   return ECORE_CALLBACK_RENEW;
+}
+
+void
+_ecore_evas_idle_timeout_update(Ecore_Evas *ee)
+{
+   if (ee->engine.idle_flush_timer)
+     ecore_timer_del(ee->engine.idle_flush_timer);
+   ee->engine.idle_flush_timer = ecore_timer_add(IDLE_FLUSH_TIME,
+                                                 _ecore_evas_cb_idle_flush,
+                                                 ee);
+}
+
+void
+_ecore_evas_mouse_move_process(Ecore_Evas *ee, int x, int y, unsigned int timestamp)
+{
+   ee->mouse.x = x;
+   ee->mouse.y = y;
+   if (ee->prop.cursor.object)
+     {
+        evas_object_show(ee->prop.cursor.object);
+        if (ee->rotation == 0)
+          evas_object_move(ee->prop.cursor.object,
+                           x - ee->prop.cursor.hot.x,
+                           y - ee->prop.cursor.hot.y);
+        else if (ee->rotation == 90)
+          evas_object_move(ee->prop.cursor.object,
+                           ee->h - y - 1 - ee->prop.cursor.hot.x,
+                           x - ee->prop.cursor.hot.y);
+        else if (ee->rotation == 180)
+          evas_object_move(ee->prop.cursor.object,
+                           ee->w - x - 1 - ee->prop.cursor.hot.x,
+                           ee->h - y - 1 - ee->prop.cursor.hot.y);
+        else if (ee->rotation == 270)
+          evas_object_move(ee->prop.cursor.object,
+                           y - ee->prop.cursor.hot.x,
+                           ee->w - x - 1 - ee->prop.cursor.hot.y);
+     }
+   if (ee->rotation == 0)
+     evas_event_feed_mouse_move(ee->evas, x, y, timestamp, NULL);
+   else if (ee->rotation == 90)
+     evas_event_feed_mouse_move(ee->evas, ee->h - y - 1, x, timestamp, NULL);
+   else if (ee->rotation == 180)
+     evas_event_feed_mouse_move(ee->evas, ee->w - x - 1, ee->h - y - 1, timestamp, NULL);
+   else if (ee->rotation == 270)
+     evas_event_feed_mouse_move(ee->evas, y, ee->w - x - 1, timestamp, NULL);
+}
+
+void
+_ecore_evas_mouse_multi_move_process(Ecore_Evas *ee, int device,
+                                     int x, int y,
+                                     double radius,
+                                     double radius_x, double radius_y,
+                                     double pressure,
+                                     double angle,
+                                     double mx, double my,
+                                     unsigned int timestamp)
+{
+   if (ee->rotation == 0)
+      evas_event_feed_multi_move(ee->evas, device,
+                                 x, y,
+                                 radius,
+                                 radius_x, radius_y,
+                                 pressure,
+                                 angle - ee->rotation,
+                                 mx, my,
+                                 timestamp, NULL);
+   else if (ee->rotation == 90)
+      evas_event_feed_multi_move(ee->evas, device,
+                                 ee->h - y - 1, x,
+                                 radius,
+                                 radius_y, radius_x,
+                                 pressure,
+                                 angle - ee->rotation,
+                                 ee->h - my - 1, mx,
+                                 timestamp, NULL);
+   else if (ee->rotation == 180)
+      evas_event_feed_multi_move(ee->evas, device,
+                                 ee->w - x - 1, ee->h - y - 1,
+                                 radius,
+                                 radius_x, radius_y,
+                                 pressure,
+                                 angle - ee->rotation,
+                                 ee->w - mx - 1, ee->h - my - 1,
+                                 timestamp, NULL);
+   else if (ee->rotation == 270)
+      evas_event_feed_multi_move(ee->evas, device,
+                                 y, ee->w - x - 1,
+                                 radius,
+                                 radius_y, radius_x,
+                                 pressure,
+                                 angle - ee->rotation,
+                                 my, ee->w - mx - 1,
+                                 timestamp, NULL);
+}
+
+void
+_ecore_evas_mouse_multi_down_process(Ecore_Evas *ee, int device,
+                                     int x, int y,
+                                     double radius,
+                                     double radius_x, double radius_y,
+                                     double pressure,
+                                     double angle,
+                                     double mx, double my,
+                                     Evas_Button_Flags flags,
+                                     unsigned int timestamp)
+{
+   if (ee->rotation == 0)
+      evas_event_feed_multi_down(ee->evas, device,
+                                 x, y,
+                                 radius,
+                                 radius_x, radius_y,
+                                 pressure,
+                                 angle - ee->rotation,
+                                 mx, my,
+                                 flags, timestamp, NULL);
+   else if (ee->rotation == 90)
+      evas_event_feed_multi_down(ee->evas, device,
+                                 ee->h - y - 1, x,
+                                 radius,
+                                 radius_y, radius_x,
+                                 pressure,
+                                 angle - ee->rotation,
+                                 ee->h - my - 1, mx,
+                                 flags, timestamp, NULL);
+   else if (ee->rotation == 180)
+      evas_event_feed_multi_down(ee->evas, device,
+                                 ee->w - x - 1, ee->h - y - 1,
+                                 radius,
+                                 radius_x, radius_y,
+                                 pressure,
+                                 angle - ee->rotation,
+                                 ee->w - mx - 1, ee->h - my - 1,
+                                 flags, timestamp, NULL);
+   else if (ee->rotation == 270)
+      evas_event_feed_multi_down(ee->evas, device,
+                                 y, ee->w - x - 1,
+                                 radius,
+                                 radius_y, radius_x,
+                                 pressure,
+                                 angle - ee->rotation,
+                                 my, ee->w - mx - 1,
+                                 flags, timestamp, NULL);
+}
+
+void
+_ecore_evas_mouse_multi_up_process(Ecore_Evas *ee, int device,
+                                   int x, int y,
+                                   double radius,
+                                   double radius_x, double radius_y,
+                                   double pressure,
+                                   double angle,
+                                   double mx, double my,
+                                   Evas_Button_Flags flags,
+                                   unsigned int timestamp)
+{
+   if (ee->rotation == 0)
+      evas_event_feed_multi_up(ee->evas, device,
+                               x, y,
+                               radius,
+                               radius_x, radius_y,
+                               pressure,
+                               angle - ee->rotation,
+                               mx, my,
+                               flags, timestamp, NULL);
+   else if (ee->rotation == 90)
+      evas_event_feed_multi_up(ee->evas, device,
+                               ee->h - y - 1, x,
+                               radius,
+                               radius_y, radius_x,
+                               pressure,
+                               angle - ee->rotation,
+                               ee->h - my - 1, mx,
+                               flags, timestamp, NULL);
+   else if (ee->rotation == 180)
+      evas_event_feed_multi_up(ee->evas, device,
+                               ee->w - x - 1, ee->h - y - 1,
+                               radius,
+                               radius_x, radius_y,
+                               pressure,
+                               angle - ee->rotation,
+                               ee->w - mx - 1, ee->h - my - 1,
+                               flags, timestamp, NULL);
+   else if (ee->rotation == 270)
+      evas_event_feed_multi_up(ee->evas, device,
+                               y, ee->w - x - 1,
+                               radius,
+                               radius_y, radius_x,
+                               pressure,
+                               angle - ee->rotation,
+                               my, ee->w - mx - 1,
+                               flags, timestamp, NULL);
+}
+
+EAPI Eina_List *
+ecore_evas_ecore_evas_list_get(void)
+{
+   Ecore_Evas *ee;
+   Eina_List *l = NULL;
+
+   EINA_INLIST_FOREACH(ecore_evases, ee)
+     {
+        l = eina_list_append(l, ee);
+     }
+
+   return l;
+}
+
+EAPI void
+ecore_evas_input_event_register(Ecore_Evas *ee)
+{
+   ecore_event_window_register((Ecore_Window)ee, ee, ee->evas,
+                               (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                               (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                               (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                               (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+}
+
+EAPI void
+ecore_evas_input_event_unregister(Ecore_Evas *ee)
+{
+   ecore_event_window_unregister((Ecore_Window)ee);
+}
diff --git a/libraries/ecore/src/lib/ecore_evas/ecore_evas_buffer.c b/libraries/ecore/src/lib/ecore_evas/ecore_evas_buffer.c
new file mode 100644
index 0000000..a3e49d6
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/ecore_evas_buffer.c
@@ -0,0 +1,827 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+// NOTE: if you fix this, consider fixing ecore_evas_ews.c as it is similar!
+
+#include <Ecore.h>
+#include "ecore_private.h"
+#include <Ecore_Input.h>
+
+#include "ecore_evas_private.h"
+#include "Ecore_Evas.h"
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_BUFFER
+static int _ecore_evas_init_count = 0;
+
+static int
+_ecore_evas_buffer_init(void)
+{
+   _ecore_evas_init_count++;
+   return _ecore_evas_init_count;
+}
+
+static void
+_ecore_evas_buffer_free(Ecore_Evas *ee)
+{
+   if (ee->engine.buffer.image)
+     {
+        Ecore_Evas *ee2;
+
+        ee2 = evas_object_data_get(ee->engine.buffer.image, "Ecore_Evas_Parent");
+        evas_object_del(ee->engine.buffer.image);
+        ee2->sub_ecore_evas = eina_list_remove(ee2->sub_ecore_evas, ee);
+     }
+   else
+     {
+        ee->engine.buffer.free_func(ee->engine.buffer.data,
+                                    ee->engine.buffer.pixels);
+     }
+   _ecore_evas_buffer_shutdown();
+}
+
+static void
+_ecore_evas_resize(Ecore_Evas *ee, int w, int h)
+{
+   Evas_Engine_Info_Buffer *einfo;
+   int stride = 0;
+
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   ee->req.w = w;
+   ee->req.h = h;
+   if ((w == ee->w) && (h == ee->h)) return;
+   ee->w = w;
+   ee->h = h;
+   evas_output_size_set(ee->evas, ee->w, ee->h);
+   evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+   evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+
+   if (ee->engine.buffer.image)
+     {
+        ee->engine.buffer.pixels = evas_object_image_data_get(ee->engine.buffer.image, 1);
+        stride = evas_object_image_stride_get(ee->engine.buffer.image);
+     }
+   else
+     {
+        if (ee->engine.buffer.pixels)
+          ee->engine.buffer.free_func(ee->engine.buffer.data,
+                                      ee->engine.buffer.pixels);
+        ee->engine.buffer.pixels =
+          ee->engine.buffer.alloc_func(ee->engine.buffer.data,
+                                       ee->w * ee->h * sizeof(int));
+        stride = ee->w * sizeof(int);
+     }
+
+   einfo = (Evas_Engine_Info_Buffer *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_ARGB32;
+        einfo->info.dest_buffer = ee->engine.buffer.pixels;
+        einfo->info.dest_buffer_row_bytes = stride;
+        einfo->info.use_color_key = 0;
+        einfo->info.alpha_threshold = 0;
+        einfo->info.func.new_update_region = NULL;
+        einfo->info.func.free_update_region = NULL;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+     }
+   if (ee->engine.buffer.image)
+      evas_object_image_data_set(ee->engine.buffer.image, ee->engine.buffer.pixels);
+   if (ee->func.fn_resize) ee->func.fn_resize(ee);
+}
+
+int
+_ecore_evas_buffer_shutdown(void)
+{
+   _ecore_evas_init_count--;
+   if (_ecore_evas_init_count < 0) _ecore_evas_init_count = 0;
+   return _ecore_evas_init_count;
+}
+
+static void
+_ecore_evas_show(Ecore_Evas *ee)
+{
+   if (ee->engine.buffer.image) return;
+   if (ee->prop.focused) return;
+   ee->prop.focused = 1;
+   evas_focus_in(ee->evas);
+   if (ee->func.fn_focus_in) ee->func.fn_focus_in(ee);
+}
+
+int
+_ecore_evas_buffer_render(Ecore_Evas *ee)
+{
+   Eina_List *updates = NULL, *l, *ll;
+   Ecore_Evas *ee2;
+   int rend = 0;
+
+   EINA_LIST_FOREACH(ee->sub_ecore_evas, ll, ee2)
+     {
+        if (ee2->func.fn_pre_render) ee2->func.fn_pre_render(ee2);
+        if (ee2->engine.func->fn_render)
+           rend |= ee2->engine.func->fn_render(ee2);
+        if (ee2->func.fn_post_render) ee2->func.fn_post_render(ee2);
+     }
+   if (ee->engine.buffer.image)
+     {
+        int w, h;
+
+        evas_object_image_size_get(ee->engine.buffer.image, &w, &h);
+        if ((w != ee->w) || (h != ee->h))
+           _ecore_evas_resize(ee, w, h);
+        ee->engine.buffer.pixels = evas_object_image_data_get(ee->engine.buffer.image, 1);
+     }
+   if (ee->engine.buffer.pixels)
+     {
+        updates = evas_render_updates(ee->evas);
+     }
+   if (ee->engine.buffer.image)
+     {
+        Eina_Rectangle *r;
+
+        evas_object_image_data_set(ee->engine.buffer.image, ee->engine.buffer.pixels);
+        EINA_LIST_FOREACH(updates, l, r)
+           evas_object_image_data_update_add(ee->engine.buffer.image,
+                                             r->x, r->y, r->w, r->h);
+     }
+   if (updates)
+     {
+        evas_render_updates_free(updates);
+        _ecore_evas_idle_timeout_update(ee);
+     }
+
+   return updates ? 1 : rend;
+}
+
+// NOTE: if you fix this, consider fixing ecore_evas_ews.c as it is similar!
+static void
+_ecore_evas_buffer_coord_translate(Ecore_Evas *ee, Evas_Coord *x, Evas_Coord *y)
+{
+   Evas_Coord xx, yy, ww, hh, fx, fy, fw, fh;
+
+   evas_object_geometry_get(ee->engine.buffer.image, &xx, &yy, &ww, &hh);
+   evas_object_image_fill_get(ee->engine.buffer.image, &fx, &fy, &fw, &fh);
+
+   if (fw < 1) fw = 1;
+   if (fh < 1) fh = 1;
+
+   if ((fx == 0) && (fy == 0) && (fw == ww) && (fh == hh))
+     {
+        *x = (ee->w * (*x - xx)) / fw;
+        *y = (ee->h * (*y - yy)) / fh;
+     }
+   else
+     {
+        xx = (*x - xx) - fx;
+        while (xx < 0) xx += fw;
+        while (xx > fw) xx -= fw;
+        *x = (ee->w * xx) / fw;
+
+        yy = (*y - yy) - fy;
+        while (yy < 0) yy += fh;
+        while (yy > fh) yy -= fh;
+        *y = (ee->h * yy) / fh;
+     }
+}
+
+static void
+_ecore_evas_buffer_cb_mouse_in(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee;
+   Evas_Event_Mouse_In *ev;
+
+   ee = data;
+   ev = event_info;
+   evas_event_feed_mouse_in(ee->evas, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_buffer_cb_mouse_out(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee;
+   Evas_Event_Mouse_Out *ev;
+
+   ee = data;
+   ev = event_info;
+   evas_event_feed_mouse_out(ee->evas, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_buffer_cb_mouse_down(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee;
+   Evas_Event_Mouse_Down *ev;
+
+   ee = data;
+   ev = event_info;
+   evas_event_feed_mouse_down(ee->evas, ev->button, ev->flags, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_buffer_cb_mouse_up(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee;
+   Evas_Event_Mouse_Up *ev;
+
+   ee = data;
+   ev = event_info;
+   evas_event_feed_mouse_up(ee->evas, ev->button, ev->flags, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_buffer_cb_mouse_move(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee;
+   Evas_Event_Mouse_Move *ev;
+   Evas_Coord x, y;
+
+   ee = data;
+   ev = event_info;
+   x = ev->cur.canvas.x;
+   y = ev->cur.canvas.y;
+   _ecore_evas_buffer_coord_translate(ee, &x, &y);
+   _ecore_evas_mouse_move_process(ee, x, y, ev->timestamp);
+}
+
+static void
+_ecore_evas_buffer_cb_mouse_wheel(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee;
+   Evas_Event_Mouse_Wheel *ev;
+
+   ee = data;
+   ev = event_info;
+   evas_event_feed_mouse_wheel(ee->evas, ev->direction, ev->z, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_buffer_cb_multi_down(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee;
+   Evas_Event_Multi_Down *ev;
+   Evas_Coord x, y, xx, yy;
+   double xf, yf;
+
+   ee = data;
+   ev = event_info;
+   x = ev->canvas.x;
+   y = ev->canvas.y;
+   xx = x;
+   yy = y;
+   _ecore_evas_buffer_coord_translate(ee, &x, &y);
+   xf = (ev->canvas.xsub - (double)xx) + (double)x;
+   yf = (ev->canvas.ysub - (double)yy) + (double)y;
+   evas_event_feed_multi_down(ee->evas, ev->device, x, y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, xf, yf, ev->flags, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_buffer_cb_multi_up(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee;
+   Evas_Event_Multi_Up *ev;
+   Evas_Coord x, y, xx, yy;
+   double xf, yf;
+
+   ee = data;
+   ev = event_info;
+   x = ev->canvas.x;
+   y = ev->canvas.y;
+   xx = x;
+   yy = y;
+   _ecore_evas_buffer_coord_translate(ee, &x, &y);
+   xf = (ev->canvas.xsub - (double)xx) + (double)x;
+   yf = (ev->canvas.ysub - (double)yy) + (double)y;
+   evas_event_feed_multi_up(ee->evas, ev->device, x, y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, xf, yf, ev->flags, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_buffer_cb_multi_move(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee;
+   Evas_Event_Multi_Move *ev;
+   Evas_Coord x, y, xx, yy;
+   double xf, yf;
+
+   ee = data;
+   ev = event_info;
+   x = ev->cur.canvas.x;
+   y = ev->cur.canvas.y;
+   xx = x;
+   yy = y;
+   _ecore_evas_buffer_coord_translate(ee, &x, &y);
+   xf = (ev->cur.canvas.xsub - (double)xx) + (double)x;
+   yf = (ev->cur.canvas.ysub - (double)yy) + (double)y;
+   evas_event_feed_multi_move(ee->evas, ev->device, x, y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, xf, yf, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_buffer_cb_free(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee;
+
+   ee = data;
+   if (ee->driver) _ecore_evas_free(ee);
+}
+
+static void
+_ecore_evas_buffer_cb_key_down(void *data, Evas *e, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee;
+   Evas_Event_Key_Down *ev;
+
+   ee = data;
+   ev = event_info;
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Shift"))
+     evas_key_modifier_on(ee->evas, "Shift");
+   else
+     evas_key_modifier_off(ee->evas, "Shift");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Control"))
+     evas_key_modifier_on(ee->evas, "Control");
+   else
+     evas_key_modifier_off(ee->evas, "Control");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Alt"))
+     evas_key_modifier_on(ee->evas, "Alt");
+   else
+     evas_key_modifier_off(ee->evas, "Alt");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Meta"))
+     evas_key_modifier_on(ee->evas, "Meta");
+   else
+     evas_key_modifier_off(ee->evas, "Meta");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Hyper"))
+     evas_key_modifier_on(ee->evas, "Hyper");
+   else
+     evas_key_modifier_off(ee->evas, "Hyper");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Super"))
+     evas_key_modifier_on(ee->evas, "Super");
+   else
+     evas_key_modifier_off(ee->evas, "Super");
+   if (evas_key_lock_is_set(evas_key_lock_get(e), "Scroll_Lock"))
+     evas_key_lock_on(ee->evas, "Scroll_Lock");
+   else
+     evas_key_lock_off(ee->evas, "Scroll_Lock");
+   if (evas_key_lock_is_set(evas_key_lock_get(e), "Num_Lock"))
+     evas_key_lock_on(ee->evas, "Num_Lock");
+   else
+     evas_key_lock_off(ee->evas, "Num_Lock");
+   if (evas_key_lock_is_set(evas_key_lock_get(e), "Caps_Lock"))
+     evas_key_lock_on(ee->evas, "Caps_Lock");
+   else
+     evas_key_lock_off(ee->evas, "Caps_Lock");
+   evas_event_feed_key_down(ee->evas, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_buffer_cb_key_up(void *data, Evas *e, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee;
+   Evas_Event_Key_Up *ev;
+
+   ee = data;
+   ev = event_info;
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Shift"))
+     evas_key_modifier_on(ee->evas, "Shift");
+   else
+     evas_key_modifier_off(ee->evas, "Shift");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Control"))
+     evas_key_modifier_on(ee->evas, "Control");
+   else
+     evas_key_modifier_off(ee->evas, "Control");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Alt"))
+     evas_key_modifier_on(ee->evas, "Alt");
+   else
+     evas_key_modifier_off(ee->evas, "Alt");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Meta"))
+     evas_key_modifier_on(ee->evas, "Meta");
+   else
+     evas_key_modifier_off(ee->evas, "Meta");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Hyper"))
+     evas_key_modifier_on(ee->evas, "Hyper");
+   else
+     evas_key_modifier_off(ee->evas, "Hyper");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Super"))
+     evas_key_modifier_on(ee->evas, "Super");
+   else
+     evas_key_modifier_off(ee->evas, "Super");
+   if (evas_key_lock_is_set(evas_key_lock_get(e), "Scroll_Lock"))
+     evas_key_lock_on(ee->evas, "Scroll_Lock");
+   else
+     evas_key_lock_off(ee->evas, "Scroll_Lock");
+   if (evas_key_lock_is_set(evas_key_lock_get(e), "Num_Lock"))
+     evas_key_lock_on(ee->evas, "Num_Lock");
+   else
+     evas_key_lock_off(ee->evas, "Num_Lock");
+   if (evas_key_lock_is_set(evas_key_lock_get(e), "Caps_Lock"))
+     evas_key_lock_on(ee->evas, "Caps_Lock");
+   else
+     evas_key_lock_off(ee->evas, "Caps_Lock");
+   evas_event_feed_key_up(ee->evas, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_buffer_cb_focus_in(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee;
+
+   ee = data;
+   ee->prop.focused = 1;
+   evas_focus_in(ee->evas);
+   if (ee->func.fn_focus_in) ee->func.fn_focus_in(ee);
+}
+
+static void
+_ecore_evas_buffer_cb_focus_out(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee;
+
+   ee = data;
+   ee->prop.focused = 0;
+   evas_focus_out(ee->evas);
+   if (ee->func.fn_focus_out) ee->func.fn_focus_out(ee);
+}
+
+static void
+_ecore_evas_buffer_cb_show(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee;
+
+   ee = data;
+   ee->visible = 1;
+   if (ee->func.fn_show) ee->func.fn_show(ee);
+}
+
+static void
+_ecore_evas_buffer_cb_hide(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee;
+
+   ee = data;
+   ee->visible = 0;
+   if (ee->func.fn_hide) ee->func.fn_hide(ee);
+}
+
+static void
+_ecore_evas_buffer_alpha_set(Ecore_Evas *ee, int alpha)
+{
+   if (((ee->alpha) && (alpha)) || ((!ee->alpha) && (!alpha))) return;
+   ee->alpha = alpha;
+   if (ee->engine.buffer.image)
+      evas_object_image_alpha_set(ee->engine.buffer.image, ee->alpha);
+}
+
+static Ecore_Evas_Engine_Func _ecore_buffer_engine_func =
+{
+   _ecore_evas_buffer_free,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     _ecore_evas_resize,
+     NULL,
+     NULL,
+     NULL,
+     _ecore_evas_show,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     _ecore_evas_buffer_alpha_set,
+     NULL, //transparent
+
+     NULL, // render
+     NULL  // screen_geometry_get
+};
+#endif
+
+static void *
+_ecore_evas_buffer_pix_alloc(void *data __UNUSED__, int size)
+{
+   return malloc(size);
+}
+
+static void
+_ecore_evas_buffer_pix_free(void *data __UNUSED__, void *pix)
+{
+   free(pix);
+}
+
+EAPI Ecore_Evas *
+ecore_evas_buffer_new(int w, int h)
+{
+    return ecore_evas_buffer_allocfunc_new
+     (w, h, _ecore_evas_buffer_pix_alloc, _ecore_evas_buffer_pix_free, NULL);
+}
+
+EAPI Ecore_Evas *
+ecore_evas_buffer_allocfunc_new(int w, int h, void *(*alloc_func) (void *data, int size), void (*free_func) (void *data, void *pix), const void *data)
+{
+// NOTE: if you fix this, consider fixing ecore_evas_ews.c as it is similar!
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_BUFFER
+   Evas_Engine_Info_Buffer *einfo;
+   Ecore_Evas *ee;
+   int rmethod;
+
+   if ((!alloc_func) || (!free_func)) return NULL;
+   rmethod = evas_render_method_lookup("buffer");
+   if (!rmethod) return NULL;
+   ee = calloc(1, sizeof(Ecore_Evas));
+   if (!ee) return NULL;
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+   _ecore_evas_buffer_init();
+
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_buffer_engine_func;
+   ee->engine.buffer.alloc_func = alloc_func;
+   ee->engine.buffer.free_func = free_func;
+   ee->engine.buffer.data = (void *)data;
+
+   ee->driver = "buffer";
+
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   ee->rotation = 0;
+   ee->visible = 1;
+   ee->w = w;
+   ee->h = h;
+   ee->req.w = ee->w;
+   ee->req.h = ee->h;
+
+   ee->prop.max.w = 0;
+   ee->prop.max.h = 0;
+   ee->prop.layer = 0;
+   ee->prop.focused = 1;
+   ee->prop.borderless = 1;
+   ee->prop.override = 1;
+   ee->prop.maximized = 1;
+   ee->prop.fullscreen = 0;
+   ee->prop.withdrawn = 0;
+   ee->prop.sticky = 0;
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_method_set(ee->evas, rmethod);
+   evas_output_size_set(ee->evas, w, h);
+   evas_output_viewport_set(ee->evas, 0, 0, w, h);
+
+   ee->engine.buffer.pixels =
+     ee->engine.buffer.alloc_func
+     (ee->engine.buffer.data, w * h * sizeof(int));
+
+   einfo = (Evas_Engine_Info_Buffer *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_ARGB32;
+        einfo->info.dest_buffer = ee->engine.buffer.pixels;
+        einfo->info.dest_buffer_row_bytes = ee->w * sizeof(int);
+        einfo->info.use_color_key = 0;
+        einfo->info.alpha_threshold = 0;
+        einfo->info.func.new_update_region = NULL;
+        einfo->info.func.free_update_region = NULL;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             ecore_evas_free(ee);
+             return NULL;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        ecore_evas_free(ee);
+        return NULL;
+     }
+   evas_key_modifier_add(ee->evas, "Shift");
+   evas_key_modifier_add(ee->evas, "Control");
+   evas_key_modifier_add(ee->evas, "Alt");
+   evas_key_modifier_add(ee->evas, "Meta");
+   evas_key_modifier_add(ee->evas, "Hyper");
+   evas_key_modifier_add(ee->evas, "Super");
+   evas_key_lock_add(ee->evas, "Caps_Lock");
+   evas_key_lock_add(ee->evas, "Num_Lock");
+   evas_key_lock_add(ee->evas, "Scroll_Lock");
+
+   evas_event_feed_mouse_in(ee->evas, 0, NULL);
+
+   ee->engine.func->fn_render = _ecore_evas_buffer_render;
+   _ecore_evas_register(ee);
+
+   evas_event_feed_mouse_in(ee->evas, (unsigned int)((unsigned long long)(ecore_time_get() * 1000.0) & 0xffffffff), NULL);
+   
+   return ee;
+#else
+   return NULL;
+#endif
+}
+
+EAPI const void *
+ecore_evas_buffer_pixels_get(Ecore_Evas *ee)
+{
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_BUFFER
+   _ecore_evas_buffer_render(ee);
+   return ee->engine.buffer.pixels;
+#else
+   return NULL;
+#endif
+}
+
+EAPI Evas *
+ecore_evas_object_evas_get(Evas_Object *obj)
+{
+   Ecore_Evas *ee;
+
+   ee = evas_object_data_get(obj, "Ecore_Evas");
+   if (!ee) return NULL;
+
+   return ecore_evas_get(ee);
+}
+
+EAPI Ecore_Evas *
+ecore_evas_object_ecore_evas_get(Evas_Object *obj)
+{
+   return evas_object_data_get(obj, "Ecore_Evas");
+}
+
+EAPI Evas_Object *
+ecore_evas_object_image_new(Ecore_Evas *ee_target)
+{
+// NOTE: if you fix this, consider fixing ecore_evas_ews.c as it is similar!
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_BUFFER
+   Evas_Object *o;
+   Evas_Engine_Info_Buffer *einfo;
+   Ecore_Evas *ee;
+   int rmethod;
+   int w = 1, h = 1;
+
+   rmethod = evas_render_method_lookup("buffer");
+   if (!rmethod) return NULL;
+   ee = calloc(1, sizeof(Ecore_Evas));
+   if (!ee) return NULL;
+
+   o = evas_object_image_add(ee_target->evas);
+   evas_object_image_content_hint_set(o, EVAS_IMAGE_CONTENT_HINT_DYNAMIC);
+   evas_object_image_colorspace_set(o, EVAS_COLORSPACE_ARGB8888);
+   evas_object_image_alpha_set(o, 0);
+   evas_object_image_size_set(o, w, h);
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+   _ecore_evas_buffer_init();
+
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_buffer_engine_func;
+
+   ee->driver = "buffer";
+
+   ee->rotation = 0;
+   ee->visible = 0;
+   ee->w = w;
+   ee->h = h;
+   ee->req.w = ee->w;
+   ee->req.h = ee->h;
+
+   ee->prop.max.w = 0;
+   ee->prop.max.h = 0;
+   ee->prop.layer = 0;
+   ee->prop.focused = 0;
+   ee->prop.borderless = 1;
+   ee->prop.override = 1;
+   ee->prop.maximized = 0;
+   ee->prop.fullscreen = 0;
+   ee->prop.withdrawn = 0;
+   ee->prop.sticky = 0;
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_method_set(ee->evas, rmethod);
+   evas_output_size_set(ee->evas, w, h);
+   evas_output_viewport_set(ee->evas, 0, 0, w, h);
+
+   ee->engine.buffer.image = o;
+   evas_object_data_set(ee->engine.buffer.image, "Ecore_Evas", ee);
+   evas_object_data_set(ee->engine.buffer.image, "Ecore_Evas_Parent", ee_target);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_MOUSE_IN,
+                                  _ecore_evas_buffer_cb_mouse_in, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_MOUSE_OUT,
+                                  _ecore_evas_buffer_cb_mouse_out, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_MOUSE_DOWN,
+                                  _ecore_evas_buffer_cb_mouse_down, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_MOUSE_UP,
+                                  _ecore_evas_buffer_cb_mouse_up, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_MOUSE_MOVE,
+                                  _ecore_evas_buffer_cb_mouse_move, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_MOUSE_WHEEL,
+                                  _ecore_evas_buffer_cb_mouse_wheel, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_MULTI_DOWN,
+                                  _ecore_evas_buffer_cb_multi_down, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_MULTI_UP,
+                                  _ecore_evas_buffer_cb_multi_up, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_MULTI_MOVE,
+                                  _ecore_evas_buffer_cb_multi_move, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_FREE,
+                                  _ecore_evas_buffer_cb_free, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_KEY_DOWN,
+                                  _ecore_evas_buffer_cb_key_down, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_KEY_UP,
+                                  _ecore_evas_buffer_cb_key_up, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_FOCUS_IN,
+                                  _ecore_evas_buffer_cb_focus_in, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_FOCUS_OUT,
+                                  _ecore_evas_buffer_cb_focus_out, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_SHOW,
+                                  _ecore_evas_buffer_cb_show, ee);
+   evas_object_event_callback_add(ee->engine.buffer.image,
+                                  EVAS_CALLBACK_HIDE,
+                                  _ecore_evas_buffer_cb_hide, ee);
+   einfo = (Evas_Engine_Info_Buffer *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        ee->engine.buffer.pixels = evas_object_image_data_get(o, 1);
+        einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_ARGB32;
+        einfo->info.dest_buffer = ee->engine.buffer.pixels;
+        einfo->info.dest_buffer_row_bytes = evas_object_image_stride_get(o);
+        einfo->info.use_color_key = 0;
+        einfo->info.alpha_threshold = 0;
+        einfo->info.func.new_update_region = NULL;
+        einfo->info.func.free_update_region = NULL;
+        evas_object_image_data_set(o, ee->engine.buffer.pixels);
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             ecore_evas_free(ee);
+             return NULL;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+        ecore_evas_free(ee);
+        return NULL;
+     }
+   evas_key_modifier_add(ee->evas, "Shift");
+   evas_key_modifier_add(ee->evas, "Control");
+   evas_key_modifier_add(ee->evas, "Alt");
+   evas_key_modifier_add(ee->evas, "Meta");
+   evas_key_modifier_add(ee->evas, "Hyper");
+   evas_key_modifier_add(ee->evas, "Super");
+   evas_key_lock_add(ee->evas, "Caps_Lock");
+   evas_key_lock_add(ee->evas, "Num_Lock");
+   evas_key_lock_add(ee->evas, "Scroll_Lock");
+
+   ee_target->sub_ecore_evas = eina_list_append(ee_target->sub_ecore_evas, ee);
+
+   ee->engine.func->fn_render = _ecore_evas_buffer_render;
+
+   return o;
+#else
+   return NULL;
+#endif
+}
diff --git a/libraries/ecore/src/lib/ecore_evas/ecore_evas_cocoa.c b/libraries/ecore/src/lib/ecore_evas/ecore_evas_cocoa.c
new file mode 100644
index 0000000..1f946d5
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/ecore_evas_cocoa.c
@@ -0,0 +1,574 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include "Ecore.h"
+#include "ecore_private.h"
+#include "Ecore_Input.h"
+#include "Ecore_Input_Evas.h"
+
+#ifdef BUILD_ECORE_EVAS_OPENGL_COCOA
+#include <Ecore_Cocoa.h>
+#include <Evas_Engine_Gl_Cocoa.h>
+#endif
+
+#include "ecore_evas_private.h"
+#include "Ecore_Evas.h"
+
+
+#ifdef BUILD_ECORE_EVAS_OPENGL_COCOA
+
+// FIXME: this engine has lots of problems. only 1 window at a time, drawRect looks wrong, doesnt handle resizes and more
+
+static int                      _ecore_evas_init_count = 0;
+static Ecore_Evas               *ecore_evases = NULL;
+static Ecore_Event_Handler      *ecore_evas_event_handlers[4] = {
+  NULL, NULL, NULL, NULL
+};
+static Ecore_Idle_Enterer       *ecore_evas_idle_enterer = NULL;
+static Ecore_Poller             *ecore_evas_event = NULL;
+
+static const char               *ecore_evas_cocoa_default = "EFL Cocoa";
+
+
+static int
+_ecore_evas_cocoa_render(Ecore_Evas *ee)
+{
+   int rend = 0;
+   Eina_List *updates = NULL;
+   Eina_List *ll;
+   Ecore_Evas *ee2;
+
+   DBG("Render");
+
+   EINA_LIST_FOREACH(ee->sub_ecore_evas, ll, ee2)
+     {
+        if (ee2->func.fn_pre_render) ee2->func.fn_pre_render(ee2);
+        if (ee2->engine.func->fn_render)
+          rend |= ee2->engine.func->fn_render(ee2);
+        if (ee2->func.fn_post_render) ee2->func.fn_post_render(ee2);
+     }
+
+   if (ee->func.fn_pre_render) ee->func.fn_pre_render(ee);
+   updates = evas_render_updates(ee->evas);
+   if (ee->prop.avoid_damage)
+     {
+        updates = evas_render_updates(ee->evas);
+        if (updates) evas_render_updates_free(updates);
+     }
+   else if ((ee->visible) ||
+            ((ee->should_be_visible) && (ee->prop.fullscreen)) ||
+            ((ee->should_be_visible) && (ee->prop.override)))
+     {
+        if (ee->shaped)
+          {
+             updates = evas_render_updates(ee->evas);
+             if (updates) evas_render_updates_free(updates);
+          }
+        else
+          {
+             updates = evas_render_updates(ee->evas);
+             if (updates) evas_render_updates_free(updates);
+          }
+     }
+   else
+     evas_norender(ee->evas);
+   if (updates) rend = 1;
+   if (ee->func.fn_post_render) ee->func.fn_post_render(ee);
+
+   if (rend)
+     {
+        static int frames = 0;
+        static double t0 = 0.0;
+        double t, td;
+
+        t = ecore_time_get();
+        frames++;
+        if ((t - t0) > 1.0)
+          {
+             td = t - t0;
+             printf("FPS: %3.3f\n", (double)frames / td);
+             frames = 0;
+             t0 = t;
+          }
+     }
+
+   return rend;
+}
+
+
+static Ecore_Evas *
+_ecore_evas_cocoa_match(void)
+{
+  DBG("Match");
+  return ecore_evases;
+}
+
+static int
+_ecore_evas_cocoa_event_got_focus(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+  Ecore_Evas                   *ee;
+
+  DBG("Got Focus");
+
+  ee = _ecore_evas_cocoa_match();
+
+  if (!ee) return ECORE_CALLBACK_PASS_ON;
+  ee->prop.focused = 1;
+  evas_focus_in(ee->evas);
+  if (ee->func.fn_focus_in) ee->func.fn_focus_in(ee);
+   
+  return ECORE_CALLBACK_PASS_ON;
+}
+
+static int
+_ecore_evas_cocoa_event_lost_focus(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+  Ecore_Evas                   *ee;
+
+  DBG("Lost Focus");
+
+  ee = _ecore_evas_cocoa_match();
+
+  if (!ee) return ECORE_CALLBACK_PASS_ON;
+  evas_focus_out(ee->evas);
+  ee->prop.focused = 0;
+  if (ee->func.fn_focus_out) ee->func.fn_focus_out(ee);
+
+  return ECORE_CALLBACK_PASS_ON;
+}
+
+static int
+_ecore_evas_cocoa_event_video_resize(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+  /*Ecore_Cocoa_Event_Video_Resize *e;
+   Ecore_Evas                   *ee;
+
+   e = event;
+   ee = _ecore_evas_cocoa_match();
+
+   if (!ee) return 1; // pass on event
+   evas_output_size_set(ee->evas, e->w, e->h);
+
+   return 0;*/
+
+  DBG("Video Resize");
+  return ECORE_CALLBACK_PASS_ON;
+}
+
+static int
+_ecore_evas_cocoa_event_video_expose(void *data __UNUSED__, int type __UNUSED__, void *event __UNUSED__)
+{
+  Ecore_Evas                   *ee;
+  int                          w;
+  int                          h;
+
+  DBG("Video Expose");
+
+  ee = _ecore_evas_cocoa_match();
+
+  if (!ee) return ECORE_CALLBACK_PASS_ON;
+  evas_output_size_get(ee->evas, &w, &h);
+  evas_damage_rectangle_add(ee->evas, 0, 0, w, h);
+
+  return ECORE_CALLBACK_PASS_ON;
+}
+
+static int
+_ecore_evas_idle_enter(void *data __UNUSED__)
+{
+  Ecore_Evas  *ee;
+  double       t1 = 0.;
+  double       t2 = 0.;
+
+  DBG("Idle enter");
+
+  EINA_INLIST_FOREACH(ecore_evases, ee)
+    {
+      if (ee->visible)
+        evas_render(ee->evas);
+      else
+        evas_norender(ee->evas);
+    }
+
+  return EINA_TRUE;
+}
+
+static int
+_ecore_evas_cocoa_event(void *data)
+{
+  //  ecore_cocoa_feed_events();
+
+  DBG("Cocoa Event");
+
+  return 1;
+}
+
+static int
+_ecore_evas_cocoa_init(void)
+{
+  DBG("Cocoa Init");
+  _ecore_evas_init_count++;
+  if (_ecore_evas_init_count > 1) 
+    return _ecore_evas_init_count;
+
+  ecore_evas_event_handlers[0] = ecore_event_handler_add(ECORE_COCOA_EVENT_GOT_FOCUS, _ecore_evas_cocoa_event_got_focus, NULL);
+  ecore_evas_event_handlers[1] = ecore_event_handler_add(ECORE_COCOA_EVENT_LOST_FOCUS, _ecore_evas_cocoa_event_lost_focus, NULL);
+  ecore_evas_event_handlers[2] = ecore_event_handler_add(ECORE_COCOA_EVENT_RESIZE, _ecore_evas_cocoa_event_video_resize, NULL);
+  ecore_evas_event_handlers[3] = ecore_event_handler_add(ECORE_COCOA_EVENT_EXPOSE, _ecore_evas_cocoa_event_video_expose, NULL);
+
+  ecore_event_evas_init();  
+  return _ecore_evas_init_count;
+}
+
+static int
+_ecore_evas_cocoa_shutdown(void)
+{
+  DBG("Cocoa SHutodwn");
+  _ecore_evas_init_count--;
+  if (_ecore_evas_init_count == 0)
+    {
+      int i;
+
+      while (ecore_evases) _ecore_evas_free(ecore_evases);
+
+      for (i = 0; i < sizeof (ecore_evas_event_handlers) / sizeof (Ecore_Event_Handler*); i++)
+        ecore_event_handler_del(ecore_evas_event_handlers[i]);
+      ecore_event_evas_shutdown();
+      ecore_idle_enterer_del(ecore_evas_idle_enterer);
+      ecore_evas_idle_enterer = NULL;
+      ecore_poller_del(ecore_evas_event);
+      ecore_evas_event = NULL;
+
+      ecore_event_evas_shutdown();
+    }
+  if (_ecore_evas_init_count < 0) _ecore_evas_init_count = 0;
+  return _ecore_evas_init_count;
+}
+
+static void
+_ecore_evas_cocoa_free(Ecore_Evas *ee)
+{
+  DBG("Cocoa Free");
+  ecore_evases = (Ecore_Evas *) eina_inlist_remove(EINA_INLIST_GET(ecore_evases), EINA_INLIST_GET(ee));
+  ecore_event_window_unregister(0);
+  _ecore_evas_cocoa_shutdown();
+  ecore_cocoa_shutdown();
+}
+
+static void
+_ecore_evas_resize(Ecore_Evas *ee, int w, int h)
+{
+  DBG("Resize");
+  if ((w == ee->w) && (h == ee->h)) return;
+  ee->w = w;
+  ee->h = h;
+
+  printf("Ecore_Evas Resize %d %d\n", w, h);
+
+  ecore_cocoa_window_resize(ee->prop.window, w, h);
+
+  evas_output_size_set(ee->evas, ee->w, ee->h);
+  evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+  evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+
+  if (ee->func.fn_resize) ee->func.fn_resize(ee);
+}
+
+static void
+_ecore_evas_move_resize(Ecore_Evas *ee, int x, int y, int w, int h)
+{
+  DBG("Move Resize");
+  if ((w == ee->w) && (h == ee->h)) return;
+  ee->w = w;
+  ee->h = h;
+
+  ecore_cocoa_window_move_resize(ee->prop.window, x, y, w, h);
+
+  evas_output_size_set(ee->evas, ee->w, ee->h);
+  evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+  evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+
+  if (ee->func.fn_resize) ee->func.fn_resize(ee);
+}
+
+
+static void
+_ecore_evas_show(Ecore_Evas *ee, int x, int y, int w, int h)
+{
+  DBG("Show");
+   ee->should_be_visible = 1;
+   if (ee->prop.avoid_damage)
+     _ecore_evas_cocoa_render(ee);
+
+   ecore_cocoa_window_show(ee->prop.window);
+   evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+}
+
+
+static void
+_ecore_evas_hide(Ecore_Evas *ee, int x, int y, int w, int h)
+{
+  DBG("Hide");
+
+   ecore_cocoa_window_hide(ee->prop.window);
+   ee->should_be_visible = 0;
+}
+
+static void
+_ecore_evas_title_set(Ecore_Evas *ee, const char *title)
+{
+   INF("ecore evas title set");
+
+   if (ee->prop.title) free(ee->prop.title);
+   ee->prop.title = NULL;
+   if (title) ee->prop.title = strdup(title);
+   ecore_cocoa_window_title_set(ee->prop.window,
+                                ee->prop.title);
+}
+
+static void
+_ecore_evas_object_cursor_del(void *data, Evas *e, Evas_Object *obj, void *event_info)
+{
+  Ecore_Evas *ee;
+
+  DBG("Cursor DEL");
+
+  ee = data;
+  if (ee)
+    ee->prop.cursor.object = NULL;
+}
+
+static void
+_ecore_evas_object_cursor_set(Ecore_Evas *ee, Evas_Object *obj, int layer, int hot_x, int hot_y)
+{
+  int x, y;
+  DBG("Cursor Set");
+  if (ee->prop.cursor.object) evas_object_del(ee->prop.cursor.object);
+
+  if (obj == NULL)
+    {
+      ee->prop.cursor.object = NULL;
+      ee->prop.cursor.layer = 0;
+      ee->prop.cursor.hot.x = 0;
+      ee->prop.cursor.hot.y = 0;
+      return;
+    }
+
+  ee->prop.cursor.object = obj;
+  ee->prop.cursor.layer = layer;
+  ee->prop.cursor.hot.x = hot_x;
+  ee->prop.cursor.hot.y = hot_y;
+
+  evas_pointer_output_xy_get(ee->evas, &x, &y);
+  evas_object_layer_set(ee->prop.cursor.object, ee->prop.cursor.layer);
+  evas_object_move(ee->prop.cursor.object,
+                   x - ee->prop.cursor.hot.x,
+                   y - ee->prop.cursor.hot.y);
+
+  evas_object_pass_events_set(ee->prop.cursor.object, 1);
+
+  if (evas_pointer_inside_get(ee->evas))
+    evas_object_show(ee->prop.cursor.object);
+
+  evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL, _ecore_evas_object_cursor_del, ee);
+}
+
+static int
+_ecore_evas_engine_cocoa_init(Ecore_Evas *ee)
+{
+   Evas_Engine_Info_GL_Cocoa *einfo;
+   const char                *driver;
+   int                        rmethod;
+
+   DBG("Cocoa Init");
+
+   driver = "gl_cocoa";
+
+   rmethod = evas_render_method_lookup(driver);
+   if (!rmethod)
+     return 0;
+
+   ee->driver = driver;
+   evas_output_method_set(ee->evas, rmethod);
+
+   einfo = (Evas_Engine_Info_GL_Cocoa *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        /* FIXME: REDRAW_DEBUG missing for now */
+        einfo->window = ee->prop.window;
+        //einfo->info.depth = ecore_win32_screen_depth_get();
+        //einfo->info.rotation = 0;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             return 0;
+          }
+        ecore_cocoa_window_view_set(einfo->window, einfo->view);
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        return 0;
+     }
+
+   return 1;
+}
+
+static Ecore_Evas_Engine_Func _ecore_cocoa_engine_func =
+  {
+    _ecore_evas_cocoa_free,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL, //move
+    NULL,
+    _ecore_evas_resize,
+    _ecore_evas_move_resize,
+    NULL, //rotation
+    NULL, //shaped
+    _ecore_evas_show,
+    _ecore_evas_hide,
+    NULL, //raise
+    NULL, //lower
+    NULL, //activate
+    _ecore_evas_title_set,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    _ecore_evas_object_cursor_set,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL,
+    NULL, //transparent    
+    NULL, // render
+    NULL
+  };
+#endif
+
+EAPI Ecore_Evas *
+ecore_evas_cocoa_new(Ecore_Cocoa_Window *parent, int x, int y, int w, int h)
+{
+#ifdef BUILD_ECORE_EVAS_OPENGL_COCOA
+  Evas_Engine_Info_GL_Cocoa *einfo;
+  Ecore_Evas           *ee;
+  int                  rmethod;
+
+  DBG("Cocoa new");
+
+  if (!ecore_cocoa_init())
+    return NULL;
+
+  ee = calloc(1, sizeof(Ecore_Evas));
+  if (!ee)
+    goto shutdown_ecore_cocoa;
+
+  ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+  _ecore_evas_cocoa_init();
+
+  ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_cocoa_engine_func;
+
+  if (w < 1) w = 1;
+  if (h < 1) h = 1;
+  ee->visible = 1;
+  ee->x = x;
+  ee->y = y;
+  ee->w = w;
+  ee->h = h;
+  ee->req.x = ee->x;
+  ee->req.y = ee->y;
+  ee->req.w = ee->w;
+  ee->req.h = ee->h;
+
+  ee->semi_sync = 1;
+
+
+  ee->prop.max.w = 32767;
+  ee->prop.max.h = 32767;
+  ee->prop.layer = 4;
+  ee->prop.request_pos = 0;
+  ee->prop.sticky = 0;
+  ee->prop.window = 0;
+
+  printf("Create New Evas\n");
+
+  ee->evas = evas_new();
+  
+  if (!ee->evas)
+    goto free_name;
+
+  evas_data_attach_set(ee->evas, ee);
+  evas_output_method_set(ee->evas, rmethod);
+  evas_output_size_set(ee->evas, w, h);
+  evas_output_viewport_set(ee->evas, 0, 0, w, h);
+
+  printf("Create New Cocoa Window\n");
+  ee->prop.window = (Ecore_Cocoa_Window*)ecore_cocoa_window_new(x, y, w, h);
+  printf("Window Created %p\n", ee->prop.window);
+  if (!ee->prop.window)
+    {
+      _ecore_evas_cocoa_shutdown();
+      free(ee);
+      return NULL;
+    }
+
+  printf("Init Evas engine cocoa\n");
+  if (!_ecore_evas_engine_cocoa_init(ee))
+    {
+      _ecore_evas_cocoa_shutdown();
+      free(ee);
+      return NULL;
+    }
+  
+  
+  ee->engine.func->fn_render = _ecore_evas_cocoa_render;
+  _ecore_evas_register(ee);
+  ecore_event_window_register(0, ee, ee->evas, NULL, NULL, NULL, NULL);
+  
+  evas_event_feed_mouse_in(ee->evas, (unsigned int)((unsigned long long)(ecore_time_get() * 1000.0) & 0xffffffff), NULL);
+  printf("Ecore Evas returned : %p\n", ee);
+  return ee;
+  
+ free_window:
+  /* FIXME: free window here */
+ free_evas:
+  free(ee->evas);
+ free_name:
+  free(ee->name);
+ free_ee:
+  _ecore_evas_cocoa_shutdown();
+  free(ee);
+ shutdown_ecore_cocoa:
+  ecore_cocoa_shutdown();
+  
+  return NULL;
+#else
+  ERR("Cocoa support in ecore-evas not enabled");
+  return NULL;
+  parent = NULL;
+  x = y = w = h = 0;
+#endif
+}
diff --git a/libraries/ecore/src/lib/ecore_evas/ecore_evas_directfb.c b/libraries/ecore/src/lib/ecore_evas/ecore_evas_directfb.c
new file mode 100644
index 0000000..457f9e9
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/ecore_evas_directfb.c
@@ -0,0 +1,596 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <string.h>
+
+#include <Ecore.h>
+#include "ecore_private.h"
+#ifdef BUILD_ECORE_EVAS_DIRECTFB
+#include <Ecore_DirectFB.h>
+#endif
+
+#include "ecore_evas_private.h"
+#include "Ecore_Evas.h"
+
+#ifdef BUILD_ECORE_EVAS_DIRECTFB
+static int _ecore_evas_init_count = 0;
+static Ecore_Event_Handler *ecore_evas_event_handlers[13];
+
+static Eina_Hash *ecore_evases_hash = NULL;
+
+static int
+_ecore_evas_directfb_render(Ecore_Evas *ee)
+{
+   Eina_List *updates, *ll;
+   Ecore_Evas *ee2;
+   int rend = 0;
+
+   EINA_LIST_FOREACH(ee->sub_ecore_evas, ll, ee2)
+     {
+        if (ee2->func.fn_pre_render) ee2->func.fn_pre_render(ee2);
+        if (ee2->engine.func->fn_render)
+          rend |= ee2->engine.func->fn_render(ee2);
+        if (ee2->func.fn_post_render) ee2->func.fn_post_render(ee2);
+     }
+
+   if (ee->func.fn_pre_render) ee->func.fn_pre_render(ee);
+   updates = evas_render_updates(ee->evas);
+   if (updates)
+     {
+        evas_render_updates_free(updates);
+        _ecore_evas_idle_timeout_update(ee);
+     }
+   if (ee->func.fn_post_render) ee->func.fn_post_render(ee);
+
+   return updates ? 1 : rend;
+}
+
+static char *
+_ecore_evas_directfb_winid_str_get(Ecore_X_Window win)
+{
+   const char *vals = "qWeRtYuIoP5$&<~";
+   static char id[9];
+   unsigned int val;
+   val = (unsigned int)win;
+   id[0] = vals[(val >> 28) & 0xf];
+   id[1] = vals[(val >> 24) & 0xf];
+   id[2] = vals[(val >> 20) & 0xf];
+   id[3] = vals[(val >> 16) & 0xf];
+   id[4] = vals[(val >> 12) & 0xf];
+   id[5] = vals[(val >>  8) & 0xf];
+   id[6] = vals[(val >>  4) & 0xf];
+   id[7] = vals[(val      ) & 0xf];
+   id[8] = 0;
+   return id;
+}
+
+static Ecore_Evas *
+_ecore_evas_directfb_match(DFBWindowID win)
+{
+   Ecore_Evas *ee;
+
+   ee = eina_hash_find(ecore_evases_hash, _ecore_evas_directfb_winid_str_get(win));
+   return ee;
+}
+
+static Eina_Bool
+_ecore_evas_directfb_event_key_down(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_DirectFB_Event_Key_Down *e;
+
+   e = event;
+   ee = _ecore_evas_directfb_match(e->win);
+
+   if (!ee) return EINA_TRUE; /* pass on event */
+   evas_event_feed_key_down(ee->evas, e->name, e->name, e->string,
+                            e->key_compose, e->time, NULL);
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_ecore_evas_directfb_event_key_up(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_DirectFB_Event_Key_Up *e;
+
+   e = event;
+   ee = _ecore_evas_directfb_match(e->win);
+
+   if (!ee) return EINA_TRUE; /* pass on event */
+   evas_event_feed_key_up(ee->evas, e->name, e->name, e->string,
+                          e->key_compose, e->time, NULL);
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_ecore_evas_directfb_event_motion(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_DirectFB_Event_Motion *e;
+
+   e = event;
+   ee = _ecore_evas_directfb_match(e->win);
+
+   if (!ee) return EINA_TRUE; /* pass on event */
+   _ecore_evas_mouse_move_process(ee, e->x, e->y, e->time);
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_ecore_evas_directfb_event_button_down(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_DirectFB_Event_Button_Down *e;
+
+   e = event;
+   ee = _ecore_evas_directfb_match(e->win);
+
+   if (!ee) return EINA_TRUE; /* pass on event */
+   // _ecore_evas_mouse_move_process(ee, e->x, e->y, e->time);
+   evas_event_feed_mouse_down(ee->evas, e->button, EVAS_BUTTON_NONE, e->time, NULL);
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_ecore_evas_directfb_event_button_up(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_DirectFB_Event_Button_Up *e;
+   Evas_Button_Flags flags = EVAS_BUTTON_NONE;
+
+   e = event;
+   ee = _ecore_evas_directfb_match(e->win);
+
+   if (!ee) return EINA_TRUE; /* pass on event */
+   //_ecore_evas_mouse_move_process(ee, e->x, e->y, e->time);
+   evas_event_feed_mouse_up(ee->evas, e->button, flags, e->time, NULL);
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_ecore_evas_directfb_event_enter(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_DirectFB_Event_Enter *e;
+
+   e = event;
+   ee = _ecore_evas_directfb_match(e->win);
+
+   if (!ee) return EINA_TRUE; /* pass on event */
+   evas_event_feed_mouse_in(ee->evas, e->time, NULL);
+   //_ecore_evas_mouse_move_process(ee, e->x, e->y, e->time);
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_ecore_evas_directfb_event_leave(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_DirectFB_Event_Leave *e;
+
+   e = event;
+   ee = _ecore_evas_directfb_match(e->win);
+
+   if (!ee) return EINA_TRUE; /* pass on event */
+   evas_event_feed_mouse_out(ee->evas, e->time, NULL);
+   //_ecore_evas_mouse_move_process(ee, e->x, e->y, e->time);
+   if (ee->func.fn_mouse_out) ee->func.fn_mouse_out(ee);
+   if (ee->prop.cursor.object) evas_object_hide(ee->prop.cursor.object);
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_ecore_evas_directfb_event_wheel(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_DirectFB_Event_Wheel *e;
+
+   e = event;
+   ee = _ecore_evas_directfb_match(e->win);
+
+   if (!ee) return EINA_TRUE; /* pass on event */
+   evas_event_feed_mouse_wheel(ee->evas, e->direction, e->z, e->time, NULL);
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_ecore_evas_directfb_event_got_focus(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_DirectFB_Event_Got_Focus *e;
+
+   e = event;
+   ee = _ecore_evas_directfb_match(e->win);
+
+   if (!ee) return EINA_TRUE; /* pass on event */
+   ee->prop.focused = 1;
+   return EINA_TRUE;
+}
+
+static Eina_Bool
+_ecore_evas_directfb_event_lost_focus(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_DirectFB_Event_Lost_Focus *e;
+
+   e = event;
+   ee = _ecore_evas_directfb_match(e->win);
+
+   if (!ee) return EINA_TRUE; /* pass on event */
+   ee->prop.focused = 0;
+   return EINA_TRUE;
+}
+
+int
+_ecore_evas_directfb_shutdown(void)
+{
+   _ecore_evas_init_count--;
+   if (_ecore_evas_init_count == 0)
+     {
+        int i;
+
+        for (i = 0; i < 8; i++)
+          ecore_event_handler_del(ecore_evas_event_handlers[i]);
+     }
+   if (_ecore_evas_init_count < 0) _ecore_evas_init_count = 0;
+   return _ecore_evas_init_count;
+}
+
+
+
+
+
+int
+_ecore_evas_directfb_init(void)
+{
+   _ecore_evas_init_count++;
+   if (_ecore_evas_init_count > 1) return _ecore_evas_init_count;
+
+   ecore_evas_event_handlers[0]  = ecore_event_handler_add(ECORE_DIRECTFB_EVENT_KEY_DOWN, _ecore_evas_directfb_event_key_down, NULL);
+   ecore_evas_event_handlers[1]  = ecore_event_handler_add(ECORE_DIRECTFB_EVENT_KEY_UP, _ecore_evas_directfb_event_key_up, NULL);
+   ecore_evas_event_handlers[2]  = ecore_event_handler_add(ECORE_DIRECTFB_EVENT_BUTTON_DOWN, _ecore_evas_directfb_event_button_down, NULL);
+   ecore_evas_event_handlers[3]  = ecore_event_handler_add(ECORE_DIRECTFB_EVENT_BUTTON_UP, _ecore_evas_directfb_event_button_up, NULL);
+   ecore_evas_event_handlers[4]  = ecore_event_handler_add(ECORE_DIRECTFB_EVENT_MOTION, _ecore_evas_directfb_event_motion, NULL);
+   ecore_evas_event_handlers[5]  = ecore_event_handler_add(ECORE_DIRECTFB_EVENT_ENTER, _ecore_evas_directfb_event_enter, NULL);
+   ecore_evas_event_handlers[6]  = ecore_event_handler_add(ECORE_DIRECTFB_EVENT_LEAVE, _ecore_evas_directfb_event_leave, NULL);
+   ecore_evas_event_handlers[7]  = ecore_event_handler_add(ECORE_DIRECTFB_EVENT_WHEEL, _ecore_evas_directfb_event_wheel, NULL);
+   ecore_evas_event_handlers[8]  = ecore_event_handler_add(ECORE_DIRECTFB_EVENT_GOT_FOCUS, _ecore_evas_directfb_event_got_focus, NULL);
+   ecore_evas_event_handlers[9]  = ecore_event_handler_add(ECORE_DIRECTFB_EVENT_LOST_FOCUS, _ecore_evas_directfb_event_lost_focus, NULL);
+   ecore_evas_event_handlers[10]  = NULL;
+   ecore_evas_event_handlers[11]  = NULL;
+   ecore_evas_event_handlers[12]  = NULL;
+
+   return _ecore_evas_init_count;
+}
+
+/* engine functions */
+/********************/
+
+static void
+_ecore_evas_directfb_free(Ecore_Evas *ee)
+{
+   eina_hash_del(ecore_evases_hash, _ecore_evas_directfb_winid_str_get(ee->engine.directfb.window->id), ee);
+   ecore_directfb_window_free(ee->engine.directfb.window);
+   _ecore_evas_directfb_shutdown();
+   ecore_directfb_shutdown();
+}
+
+static void
+_ecore_evas_directfb_move(Ecore_Evas *ee, int x, int y)
+{
+   ecore_directfb_window_move(ee->engine.directfb.window, x, y);
+}
+
+static void
+_ecore_evas_directfb_resize(Ecore_Evas *ee, int w, int h)
+{
+   ee->req.w = w;
+   ee->req.h = h;
+   if ((w == ee->w) && (h == ee->h)) return;
+   ecore_directfb_window_resize(ee->engine.directfb.window, w, h);
+   ee->w = w;
+   ee->h = h;
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+        evas_output_size_set(ee->evas, ee->h, ee->w);
+        evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+     }
+   else
+     {
+        evas_output_size_set(ee->evas, ee->w, ee->h);
+        evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+     }
+}
+
+static void
+_ecore_evas_directfb_focus_set(Ecore_Evas *ee, int on __UNUSED__)
+{
+   ecore_directfb_window_focus(ee->engine.directfb.window);
+}
+
+static void
+_ecore_evas_directfb_hide(Ecore_Evas *ee)
+{
+   ecore_directfb_window_hide(ee->engine.directfb.window);
+   ee->should_be_visible = 0;
+}
+
+static void
+_ecore_evas_directfb_show(Ecore_Evas *ee)
+{
+   ecore_directfb_window_show(ee->engine.directfb.window);
+   ee->should_be_visible = 1;
+}
+
+static void
+_ecore_evas_directfb_shaped_set(Ecore_Evas *ee, int shaped)
+{
+   if (((ee->shaped) && (shaped)) || ((!ee->shaped) && (!shaped)))
+     return;
+   ee->shaped = shaped;
+   if(ee->shaped)
+     ecore_directfb_window_shaped_set(ee->engine.directfb.window, 1);
+   else
+     ecore_directfb_window_shaped_set(ee->engine.directfb.window, 0);
+
+}
+
+static void
+_ecore_evas_object_cursor_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee;
+
+   ee = data;
+   if (ee)
+     ee->prop.cursor.object = NULL;
+}
+
+static void
+_ecore_evas_directfb_object_cursor_set(Ecore_Evas *ee, Evas_Object *obj, int layer, int hot_x, int hot_y)
+{
+   int x, y;
+
+   if (ee->prop.cursor.object) evas_object_del(ee->prop.cursor.object);
+
+   if (!obj)
+     {
+        ee->prop.cursor.object = NULL;
+        ee->prop.cursor.layer = 0;
+        ee->prop.cursor.hot.x = 0;
+        ee->prop.cursor.hot.y = 0;
+        ecore_directfb_window_cursor_show(ee->engine.directfb.window, 1);
+        return;
+
+     }
+
+   ee->prop.cursor.object = obj;
+   ee->prop.cursor.layer = layer;
+   ee->prop.cursor.hot.x = hot_x;
+   ee->prop.cursor.hot.y = hot_y;
+
+   ecore_directfb_window_cursor_show(ee->engine.directfb.window, 0);
+
+   evas_pointer_output_xy_get(ee->evas, &x, &y);
+   evas_object_layer_set(ee->prop.cursor.object, ee->prop.cursor.layer);
+   evas_object_move(ee->prop.cursor.object,x - ee->prop.cursor.hot.x,y - ee->prop.cursor.hot.y);
+   evas_object_pass_events_set(ee->prop.cursor.object, 1);
+   if (evas_pointer_inside_get(ee->evas))
+     evas_object_show(ee->prop.cursor.object);
+
+   evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL, _ecore_evas_object_cursor_del, ee);
+}
+
+static void
+_ecore_evas_directfb_fullscreen_set(Ecore_Evas *ee, int on)
+{
+   Evas_Engine_Info_DirectFB *einfo;
+   int w;
+   int h;
+   int resized = 0;
+
+   if (((ee->prop.fullscreen) && (on)) || ((!ee->prop.fullscreen) && (!on)))
+     return;
+
+   if (on)
+     ecore_directfb_window_fullscreen_set(ee->engine.directfb.window, 1);
+   else
+     ecore_directfb_window_fullscreen_set(ee->engine.directfb.window, 0);
+   /* set the new size of the evas */
+   ecore_directfb_window_size_get(ee->engine.directfb.window, &w, &h);
+   if( (ee->w != w) || (ee->h != h))
+     {
+        resized = 1;
+        ee->w = w;
+        ee->h = h;
+        ee->req.w = ee->w;
+        ee->req.h = ee->h;
+        if ((ee->rotation == 90) || (ee->rotation == 270))
+          {
+             evas_output_size_set(ee->evas, ee->h, ee->w);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+          }
+        else
+          {
+             evas_output_size_set(ee->evas, ee->w, ee->h);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+          }
+     }
+   einfo = (Evas_Engine_Info_DirectFB *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        einfo->info.surface = ee->engine.directfb.window->surface;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+     }
+   ee->prop.fullscreen = on;
+   if (resized)
+     {
+        if(ee->func.fn_resize) ee->func.fn_resize(ee);
+     }
+}
+
+static void *
+_ecore_evas_directfb_window_get(const Ecore_Evas *ee)
+{
+   return ee->engine.directfb.window;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_DIRECTFB
+static Ecore_Evas_Engine_Func _ecore_directfb_engine_func =
+{
+   _ecore_evas_directfb_free,        /* free an ecore_evas */
+     NULL,                                /* cb resize */
+     NULL,                                /* cb move */
+     NULL,                                /* cb show */
+     NULL,                                /* cb hide */
+     NULL,                                /* cb delete request */
+     NULL,                                /* cb destroy */
+     NULL,                                /* cb focus in */
+     NULL,                                /* cb focus out */
+     NULL,                              /* cb sticky */
+     NULL,                              /* cb unsticky */
+     NULL,                                /* cb mouse in */
+     NULL,                                /* cb mouse out */
+     NULL,                                /* cb pre render */
+     NULL,                                /* cb post render */
+     _ecore_evas_directfb_move,                /* move */
+     NULL,                              /* managed move */
+     _ecore_evas_directfb_resize,        /* resize */
+     NULL,                                /* move resize */
+     NULL,//_ecore_evas_directfb_rotation_set,/* rotation */
+     _ecore_evas_directfb_shaped_set,   /* shaped */
+     _ecore_evas_directfb_show,                /* show */
+     _ecore_evas_directfb_hide,                /* hide */
+     NULL,                                /* raise */
+     NULL,                                /* lower */
+     NULL,                                /* activate */
+     NULL,                                /* title set */
+     NULL,                                /* name class set */
+     NULL,                                /* size min */
+     NULL,                                /* size max */
+     NULL,                                /* size base */
+     NULL,                                /* size step */
+     _ecore_evas_directfb_object_cursor_set, /* set cursor to an evas object */
+     NULL,                                /* layer set */
+     _ecore_evas_directfb_focus_set,        /* focus */
+     NULL,                                /* iconified */
+     NULL,                                /* borderless */
+     NULL,                                /* override */
+     NULL,                                /* maximized */
+     _ecore_evas_directfb_fullscreen_set,/* fullscreen */
+     NULL,                                /* avoid damage */
+     NULL,                                /* withdrawn */
+     NULL,                                /* sticky */
+     NULL,                              /* ignore events */
+     NULL,                              /* alpha */
+     NULL, //transparent
+
+     NULL, // render
+     NULL  // screen_geometry_get
+};
+#endif
+
+/* api */
+/*******/
+
+#ifdef BUILD_ECORE_EVAS_DIRECTFB
+EAPI Ecore_Evas *
+ecore_evas_directfb_new(const char *disp_name, int windowed, int x, int y, int w, int h)
+{
+   Evas_Engine_Info_DirectFB *einfo;
+   Ecore_Evas *ee;
+   Ecore_DirectFB_Window *window;
+   int rmethod;
+
+   rmethod = evas_render_method_lookup("directfb");
+   if (!rmethod) return NULL;
+   if (!ecore_directfb_init(disp_name)) return NULL;
+   ee = calloc(1, sizeof(Ecore_Evas));
+   if (!ee) return NULL;
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+   _ecore_evas_directfb_init();
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_directfb_engine_func;
+
+   ee->driver = "directfb";
+   if (disp_name) ee->name = strdup(disp_name);
+
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+
+   ee->rotation = 0;
+   ee->visible = 1;
+   ee->x = x;
+   ee->y = y;
+   ee->w = w;
+   ee->h = h;
+   ee->req.x = ee->x;
+   ee->req.y = ee->y;
+   ee->req.w = ee->w;
+   ee->req.h = ee->h;
+   ee->prop.layer = 1;
+   ee->prop.fullscreen = 0;
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_method_set(ee->evas, rmethod);
+   evas_output_size_set(ee->evas, w, h);
+   evas_output_viewport_set(ee->evas, 0, 0, w, h);
+   einfo = (Evas_Engine_Info_DirectFB *)evas_engine_info_get(ee->evas);
+
+   window = ecore_directfb_window_new(x,y,w,h);
+   ee->engine.directfb.window = window;
+   if (einfo)
+     {
+        einfo->info.dfb = ecore_directfb_interface_get();
+        einfo->info.surface = window->surface;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             ecore_evas_free(ee);
+             return NULL;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        ecore_evas_free(ee);
+        return NULL;
+     }
+
+   ee->engine.func->fn_render = _ecore_evas_directfb_render;
+   _ecore_evas_register(ee);
+
+   if (!ecore_evases_hash)
+     ecore_evases_hash = eina_hash_string_superfast_new(NULL);
+   eina_hash_add(ecore_evases_hash, _ecore_evas_directfb_winid_str_get(ee->engine.directfb.window->id), ee);
+
+   return ee;
+}
+#else
+EAPI Ecore_Evas *
+ecore_evas_directfb_new(const char *disp_name __UNUSED__, int windowed __UNUSED__, int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
+{
+   return NULL;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_DIRECTFB
+EAPI Ecore_DirectFB_Window *
+ecore_evas_directfb_window_get(const Ecore_Evas *ee)
+{
+   return (Ecore_DirectFB_Window *) _ecore_evas_directfb_window_get(ee);
+}
+#else
+EAPI Ecore_DirectFB_Window *
+ecore_evas_directfb_window_get(const Ecore_Evas *ee __UNUSED__)
+{
+  return NULL;
+}
+#endif
diff --git a/libraries/ecore/src/lib/ecore_evas/ecore_evas_ews.c b/libraries/ecore/src/lib/ecore_evas/ecore_evas_ews.c
new file mode 100644
index 0000000..e19fb05
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/ecore_evas_ews.c
@@ -0,0 +1,1454 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <Ecore.h>
+#include "ecore_private.h"
+#include <Ecore_Input.h>
+
+#include "ecore_evas_private.h"
+#include "Ecore_Evas.h"
+
+EAPI int ECORE_EVAS_EWS_EVENT_MANAGER_CHANGE = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_ADD = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_DEL = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_RESIZE = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_MOVE = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_SHOW = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_HIDE = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_FOCUS = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_UNFOCUS = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_RAISE = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_LOWER = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_ACTIVATE = 0;
+
+EAPI int ECORE_EVAS_EWS_EVENT_ICONIFIED_CHANGE = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_MAXIMIZED_CHANGE = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_LAYER_CHANGE = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_FULLSCREEN_CHANGE = 0;
+EAPI int ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE = 0;
+
+#ifdef BUILD_ECORE_EVAS_EWS
+static int _ecore_evas_init_count = 0;
+
+static Ecore_Evas *_ews_ee = NULL;
+static Evas_Object *_ews_bg = NULL;
+static Eina_List *_ews_children = NULL;
+static const void *_ews_manager = NULL;
+static char *_ews_engine = NULL;
+static char *_ews_options = NULL;
+static int _ews_x = 0;
+static int _ews_y = 0;
+static int _ews_w = 1024;
+static int _ews_h = 768;
+static Eina_Bool _ews_defaults_engine = EINA_TRUE;
+static Eina_Bool _ews_defaults_geo = EINA_TRUE;
+
+static const char EWS_ENGINE_NAME[] = "ews";
+
+static void
+_ecore_evas_ews_pre_free(Ecore_Evas *ee __UNUSED__)
+{
+   DBG("EWS backing store free'd");
+   _ews_children = eina_list_free(_ews_children);
+   _ews_ee = NULL;
+   _ews_bg = NULL;
+}
+
+static void
+_ecore_evas_ews_del_request(Ecore_Evas *ee __UNUSED__)
+{
+   INF("EWS backing store deletion is forbidden!");
+}
+
+static Ecore_Evas *
+_ecore_evas_ews_ee_new(void)
+{
+   Ecore_Evas *ee = ecore_evas_new(_ews_engine, _ews_x, _ews_y, _ews_w, _ews_h,
+                                   _ews_options);
+   if (!ee)
+     ERR("Failed: ecore_evas_new(%s, %d, %d, %d, %d, %s)",
+         _ews_engine, _ews_x, _ews_y, _ews_w, _ews_h, _ews_options);
+   else
+     {
+        ecore_evas_size_min_set(ee, _ews_w, _ews_h);
+        ecore_evas_size_max_set(ee, _ews_w, _ews_h);
+        ecore_evas_callback_pre_free_set(ee, _ecore_evas_ews_pre_free);
+        ecore_evas_callback_delete_request_set(ee, _ecore_evas_ews_del_request);
+        ecore_evas_name_class_set(ee, "ecore_evas_ews", "ews");
+        ecore_evas_title_set
+          (ee, "EWS: Ecore + Evas Single Process Windowing System");
+        ecore_evas_show(ee);
+     }
+
+   return ee;
+}
+
+static void
+_ecore_evas_ews_env_setup(void)
+{
+   const char *env = getenv("ECORE_EVAS_EWS");
+   char *p, *n, *tmp;
+
+   if (_ews_defaults_engine)
+     {
+        free(_ews_engine);
+        _ews_engine = NULL;
+        free(_ews_options);
+        _ews_options = NULL;
+     }
+   if (_ews_defaults_geo)
+     {
+        _ews_x = 0;
+        _ews_y = 0;
+        _ews_w = 1024;
+        _ews_h = 768;
+     }
+
+   if ((!env) || (!*env)) return;
+
+   p = tmp = strdup(env);
+   if (!tmp) return;
+
+   n = strchr(p, ':');
+   if (n) *n = '\0';
+   if (_ews_defaults_engine) _ews_engine = strdup(p);
+   if (!n) goto end;
+
+   p = n + 1;
+   n = strchr(p, ':');
+   if (!n) goto end;
+   *n = '\0';
+   if (_ews_defaults_geo) _ews_x = atoi(p);
+
+   p = n + 1;
+   n = strchr(p, ':');
+   if (!n) goto end;
+   *n = '\0';
+   if (_ews_defaults_geo) _ews_y = atoi(p);
+
+   p = n + 1;
+   n = strchr(p, ':');
+   if (!n) goto end;
+   *n = '\0';
+   if (_ews_defaults_geo) _ews_w = atoi(p);
+
+   p = n + 1;
+   n = strchr(p, ':');
+   if (n) *n = '\0';
+   if (_ews_defaults_geo) _ews_h = atoi(p);
+   if (!n) goto end;
+
+   p = n + 1;
+   if (_ews_defaults_engine) _ews_options = strdup(p);
+
+ end:
+   free(tmp);
+}
+
+static void
+_ecore_evas_ews_event_free(void *data __UNUSED__, void *ev)
+{
+   Ecore_Evas *ee = ev;
+   _ecore_evas_unref(ee);
+}
+
+static void
+_ecore_evas_ews_event(Ecore_Evas *ee, int event)
+{
+   _ecore_evas_ref(ee);
+   ecore_event_add(event, ee, _ecore_evas_ews_event_free, NULL);
+}
+
+static void
+_ecore_evas_ews_event_free_del(void *data __UNUSED__, void *ev __UNUSED__)
+{
+   _ecore_evas_ews_shutdown();
+}
+
+static void
+_ecore_evas_ews_free(Ecore_Evas *ee)
+{
+   evas_object_del(ee->engine.ews.image);
+   _ews_ee->sub_ecore_evas = eina_list_remove(_ews_ee->sub_ecore_evas, ee);
+
+   ecore_event_add(ECORE_EVAS_EWS_EVENT_DEL, ee, _ecore_evas_ews_event_free_del, NULL);
+}
+
+static void
+_ecore_evas_ews_move(Ecore_Evas *ee, int x, int y)
+{
+   ee->req.x = x;
+   ee->req.y = y;
+
+   if ((x == ee->x) && (y == ee->y)) return;
+   ee->x = x;
+   ee->y = y;
+   evas_object_move(ee->engine.ews.image, x, y);
+   if (ee->func.fn_move) ee->func.fn_move(ee);
+
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_MOVE);
+}
+
+static void
+_ecore_evas_ews_managed_move(Ecore_Evas *ee, int x, int y)
+{
+   ee->req.x = x;
+   ee->req.y = y;
+
+   if ((x == ee->x) && (y == ee->y)) return;
+   ee->x = x;
+   ee->y = y;
+   if (ee->func.fn_move) ee->func.fn_move(ee);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_MOVE);
+}
+
+static void
+_ecore_evas_ews_resize_internal(Ecore_Evas *ee, int w, int h)
+{
+   Evas_Engine_Info_Buffer *einfo;
+   void *pixels;
+   int stride;
+
+   evas_output_size_set(ee->evas, w, h);
+   evas_output_viewport_set(ee->evas, 0, 0, w, h);
+   evas_damage_rectangle_add(ee->evas, 0, 0, w, h);
+
+   evas_object_image_size_set(ee->engine.ews.image, w, h);
+   evas_object_image_fill_set(ee->engine.ews.image, 0, 0, w, h);
+   evas_object_resize(ee->engine.ews.image, w, h);
+
+   pixels = evas_object_image_data_get(ee->engine.ews.image, 1);
+   evas_object_image_data_set(ee->engine.ews.image, pixels); // refcount
+   stride = evas_object_image_stride_get(ee->engine.ews.image);
+
+   einfo = (Evas_Engine_Info_Buffer *)evas_engine_info_get(ee->evas);
+   EINA_SAFETY_ON_NULL_RETURN(einfo);
+
+   einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_ARGB32;
+   einfo->info.dest_buffer = pixels;
+   einfo->info.dest_buffer_row_bytes = stride;
+   einfo->info.use_color_key = 0;
+   einfo->info.alpha_threshold = 0;
+   einfo->info.func.new_update_region = NULL;
+   einfo->info.func.free_update_region = NULL;
+   evas_object_image_data_set(ee->engine.ews.image, pixels);
+   if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+     {
+        ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+     }
+}
+
+static void
+_ecore_evas_ews_resize(Ecore_Evas *ee, int w, int h)
+{
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+
+   ee->req.w = w;
+   ee->req.h = h;
+
+   if ((w == ee->w) && (h == ee->h)) return;
+   ee->w = w;
+   ee->h = h;
+   _ecore_evas_ews_resize_internal(ee, w, h);
+   if (ee->func.fn_resize) ee->func.fn_resize(ee);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_RESIZE);
+}
+
+static void
+_ecore_evas_ews_move_resize(Ecore_Evas *ee, int x, int y, int w, int h)
+{
+   _ecore_evas_ews_move(ee, x, y);
+   _ecore_evas_ews_resize(ee, w, h);
+}
+
+static void
+_ecore_evas_ews_rotation_set(Ecore_Evas *ee, int rot, int resize)
+{
+   if (ee->rotation == rot) return;
+   ee->rotation = rot;
+
+   ERR("TODO: rot=%d, resize=%d", rot, resize);
+
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_shaped_set(Ecore_Evas *ee, int val)
+{
+   if (ee->shaped == val) return;
+   ee->shaped = val;
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_show(Ecore_Evas *ee)
+{
+   ee->should_be_visible = EINA_TRUE;
+   evas_object_show(ee->engine.ews.image);
+   if (ee->prop.fullscreen)
+     evas_object_focus_set(ee->engine.ews.image, EINA_TRUE);
+
+   if (ee->func.fn_show) ee->func.fn_show(ee);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_SHOW);
+}
+
+static void
+_ecore_evas_ews_hide(Ecore_Evas *ee)
+{
+   ee->should_be_visible = EINA_FALSE;
+   evas_object_hide(ee->engine.ews.image);
+
+   if (ee->func.fn_hide) ee->func.fn_hide(ee);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_HIDE);
+}
+
+static void
+_ecore_evas_ews_raise(Ecore_Evas *ee)
+{
+   evas_object_raise(ee->engine.ews.image);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_RAISE);
+}
+
+static void
+_ecore_evas_ews_lower(Ecore_Evas *ee)
+{
+   evas_object_lower(ee->engine.ews.image);
+   evas_object_lower(_ews_bg);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_LOWER);
+}
+
+static void
+_ecore_evas_ews_activate(Ecore_Evas *ee)
+{
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_ACTIVATE);
+}
+
+static void
+_ecore_evas_ews_title_set(Ecore_Evas *ee, const char *t)
+{
+   if (ee->prop.title) free(ee->prop.title);
+   ee->prop.title = NULL;
+   if (t) ee->prop.title = strdup(t);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_name_class_set(Ecore_Evas *ee, const char *n, const char *c)
+{
+   if (ee->prop.name) free(ee->prop.name);
+   if (ee->prop.clas) free(ee->prop.clas);
+   ee->prop.name = NULL;
+   ee->prop.clas = NULL;
+   if (n) ee->prop.name = strdup(n);
+   if (c) ee->prop.clas = strdup(c);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_size_min_set(Ecore_Evas *ee, int w, int h)
+{
+   if (w < 0) w = 0;
+   if (h < 0) h = 0;
+   if ((ee->prop.min.w == w) && (ee->prop.min.h == h)) return;
+   ee->prop.min.w = w;
+   ee->prop.min.h = h;
+   evas_object_size_hint_min_set(ee->engine.ews.image, w, h);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_size_max_set(Ecore_Evas *ee, int w, int h)
+{
+   if (w < 0) w = 0;
+   if (h < 0) h = 0;
+   if ((ee->prop.max.w == w) && (ee->prop.max.h == h)) return;
+   ee->prop.max.w = w;
+   ee->prop.max.h = h;
+   evas_object_size_hint_max_set(ee->engine.ews.image, w, h);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_size_base_set(Ecore_Evas *ee, int w, int h)
+{
+   if (w < 0) w = 0;
+   if (h < 0) h = 0;
+   if ((ee->prop.base.w == w) && (ee->prop.base.h == h)) return;
+   ee->prop.base.w = w;
+   ee->prop.base.h = h;
+   evas_object_size_hint_request_set(ee->engine.ews.image, w, h);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_size_step_set(Ecore_Evas *ee, int w, int h)
+{
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   if ((ee->prop.step.w == w) && (ee->prop.step.h == h)) return;
+   ee->prop.step.w = w;
+   ee->prop.step.h = h;
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_object_cursor_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   ee->prop.cursor.object = NULL;
+}
+
+static void
+_ecore_evas_ews_object_cursor_set(Ecore_Evas *ee, Evas_Object *obj, int layer, int hot_x, int hot_y)
+{
+   int x, y;
+
+   if (ee->prop.cursor.object) evas_object_del(ee->prop.cursor.object);
+
+   if (!obj)
+     {
+        ee->prop.cursor.object = NULL;
+        ee->prop.cursor.layer = 0;
+        ee->prop.cursor.hot.x = 0;
+        ee->prop.cursor.hot.y = 0;
+        return;
+     }
+
+   ee->prop.cursor.object = obj;
+   ee->prop.cursor.layer = layer;
+   ee->prop.cursor.hot.x = hot_x;
+   ee->prop.cursor.hot.y = hot_y;
+   evas_pointer_output_xy_get(ee->evas, &x, &y);
+   evas_object_layer_set(ee->prop.cursor.object, ee->prop.cursor.layer);
+   evas_object_move(ee->prop.cursor.object,
+                    x - ee->prop.cursor.hot.x,
+                    y - ee->prop.cursor.hot.y);
+   evas_object_pass_events_set(ee->prop.cursor.object, 1);
+   if (evas_pointer_inside_get(ee->evas))
+     evas_object_show(ee->prop.cursor.object);
+
+   evas_object_event_callback_add
+     (obj, EVAS_CALLBACK_DEL, _ecore_evas_ews_object_cursor_del, ee);
+
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_layer_set(Ecore_Evas *ee, int layer)
+{
+   if (layer < EVAS_LAYER_MIN + 1)
+     layer = EVAS_LAYER_MIN + 1;
+   else if (layer > EVAS_LAYER_MAX)
+     layer = EVAS_LAYER_MAX;
+
+   if (ee->prop.layer == layer) return;
+   ee->prop.layer = layer;
+   evas_object_layer_set(ee->engine.ews.image, layer);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_LAYER_CHANGE);
+}
+
+static void
+_ecore_evas_ews_focus_set(Ecore_Evas *ee, int val)
+{
+   evas_object_focus_set(ee->engine.ews.image, val);
+   ee->prop.focused = val;
+   if (val)
+     {
+        evas_focus_in(ee->evas);
+        if (ee->func.fn_focus_in) ee->func.fn_focus_in(ee);
+        _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_FOCUS);
+     }
+   else
+     {
+        evas_focus_out(ee->evas);
+        if (ee->func.fn_focus_out) ee->func.fn_focus_out(ee);
+        _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_UNFOCUS);
+     }
+}
+
+static void
+_ecore_evas_ews_iconified_set(Ecore_Evas *ee, int val)
+{
+   if (ee->prop.iconified == val) return;
+   ee->prop.iconified = val;
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_ICONIFIED_CHANGE);
+}
+
+static void
+_ecore_evas_ews_borderless_set(Ecore_Evas *ee, int val)
+{
+   if (ee->prop.borderless == val) return;
+   ee->prop.borderless = val;
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_override_set(Ecore_Evas *ee, int val)
+{
+   if (ee->prop.override == val) return;
+   if (ee->visible) evas_object_show(ee->engine.ews.image);
+   if (ee->prop.focused) evas_object_focus_set(ee->engine.ews.image, EINA_TRUE);
+   ee->prop.override = val;
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_maximized_set(Ecore_Evas *ee, int val)
+{
+   if (ee->prop.maximized == val) return;
+   ee->prop.maximized = val;
+   if (val) evas_object_show(ee->engine.ews.image);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_MAXIMIZED_CHANGE);
+}
+
+static void
+_ecore_evas_ews_fullscreen_set(Ecore_Evas *ee, int val)
+{
+   if (ee->prop.fullscreen == val) return;
+   ee->prop.fullscreen = val;
+
+   if (!val)
+     {
+        evas_object_move(ee->engine.ews.image, ee->x, ee->y);
+        evas_object_resize(ee->engine.ews.image, ee->w, ee->h);
+     }
+   else
+     {
+        Evas_Coord w, h;
+        ecore_evas_geometry_get(_ews_ee, NULL, NULL, &w, &h);
+        evas_object_move(ee->engine.ews.image, 0, 0);
+        evas_object_resize(ee->engine.ews.image, w, h);
+        evas_object_focus_set(ee->engine.ews.image, EINA_TRUE);
+     }
+
+   if (ee->should_be_visible)
+     evas_object_show(ee->engine.ews.image);
+   else
+     evas_object_hide(ee->engine.ews.image);
+
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_FULLSCREEN_CHANGE);
+}
+
+static void
+_ecore_evas_ews_avoid_damage_set(Ecore_Evas *ee, int val)
+{
+   if (ee->prop.avoid_damage == val) return;
+   ee->prop.avoid_damage = val;
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_withdrawn_set(Ecore_Evas *ee, int val)
+{
+   if (ee->prop.withdrawn == val) return;
+   ee->prop.withdrawn = val;
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_sticky_set(Ecore_Evas *ee, int val)
+{
+   if (ee->prop.sticky == val) return;
+   ee->prop.sticky = val;
+   if ((val) && (ee->func.fn_sticky)) ee->func.fn_sticky(ee);
+   else if ((!val) && (ee->func.fn_unsticky)) ee->func.fn_unsticky(ee);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_ignore_events_set(Ecore_Evas *ee, int val)
+{
+   if (ee->ignore_events == val) return;
+   ee->ignore_events = val;
+   evas_object_pass_events_set(ee->engine.ews.image, val);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_alpha_set(Ecore_Evas *ee, int val)
+{
+   if (ee->alpha == val) return;
+   ee->alpha = val;
+   evas_object_image_alpha_set(ee->engine.ews.image, val);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static void
+_ecore_evas_ews_transparent_set(Ecore_Evas *ee, int val)
+{
+   if (ee->transparent == val) return;
+   ee->transparent = val;
+   evas_object_image_alpha_set(ee->engine.ews.image, val);
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE);
+}
+
+static int
+_ecore_evas_ews_render(Ecore_Evas *ee)
+{
+   Eina_List *updates = NULL, *l, *ll;
+   Ecore_Evas *ee2;
+   Eina_Rectangle *r;
+   int w, h, rend = 0;
+   void *pixels;
+   
+   EINA_LIST_FOREACH(ee->sub_ecore_evas, ll, ee2)
+     {
+        if (ee2->func.fn_pre_render) ee2->func.fn_pre_render(ee2);
+        rend |= _ecore_evas_ews_render(ee2);
+        if (ee2->func.fn_post_render) ee2->func.fn_post_render(ee2);
+     }
+
+   evas_object_image_size_get(ee->engine.ews.image, &w, &h);
+   if ((w != ee->w) || (h != ee->h))
+     ecore_evas_resize(ee, w, h);
+
+   pixels = evas_object_image_data_get(ee->engine.ews.image, 1);
+   if (pixels)
+     {
+        updates = evas_render_updates(ee->evas);
+     }
+   evas_object_image_data_set(ee->engine.ews.image, pixels);
+   
+   EINA_LIST_FOREACH(updates, l, r)
+     evas_object_image_data_update_add(ee->engine.ews.image,
+                                       r->x, r->y, r->w, r->h);
+
+   if (updates)
+     {
+        evas_render_updates_free(updates);
+        _ecore_evas_idle_timeout_update(ee);
+     }
+
+   return updates ? 1 : rend;
+}
+
+static void
+_ecore_evas_ews_screen_geometry_get(const Ecore_Evas *ee __UNUSED__, int *x, int *y, int *w, int *h)
+{
+   ecore_evas_geometry_get(_ews_ee, x, y, w, h);
+}
+
+static const Ecore_Evas_Engine_Func _ecore_ews_engine_func =
+{
+     _ecore_evas_ews_free,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     _ecore_evas_ews_move,
+     _ecore_evas_ews_managed_move,
+     _ecore_evas_ews_resize,
+     _ecore_evas_ews_move_resize,
+     _ecore_evas_ews_rotation_set,
+     _ecore_evas_ews_shaped_set,
+     _ecore_evas_ews_show,
+     _ecore_evas_ews_hide,
+     _ecore_evas_ews_raise,
+     _ecore_evas_ews_lower,
+     _ecore_evas_ews_activate,
+     _ecore_evas_ews_title_set,
+     _ecore_evas_ews_name_class_set,
+     _ecore_evas_ews_size_min_set,
+     _ecore_evas_ews_size_max_set,
+     _ecore_evas_ews_size_base_set,
+     _ecore_evas_ews_size_step_set,
+     _ecore_evas_ews_object_cursor_set,
+     _ecore_evas_ews_layer_set,
+     _ecore_evas_ews_focus_set,
+     _ecore_evas_ews_iconified_set,
+     _ecore_evas_ews_borderless_set,
+     _ecore_evas_ews_override_set,
+     _ecore_evas_ews_maximized_set,
+     _ecore_evas_ews_fullscreen_set,
+     _ecore_evas_ews_avoid_damage_set,
+     _ecore_evas_ews_withdrawn_set,
+     _ecore_evas_ews_sticky_set,
+     _ecore_evas_ews_ignore_events_set,
+     _ecore_evas_ews_alpha_set,
+     _ecore_evas_ews_transparent_set,
+     _ecore_evas_ews_render,
+     _ecore_evas_ews_screen_geometry_get
+};
+
+void
+_ecore_evas_ews_events_init(void)
+{
+   if (ECORE_EVAS_EWS_EVENT_MANAGER_CHANGE != 0) return;
+   ECORE_EVAS_EWS_EVENT_MANAGER_CHANGE = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_ADD = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_DEL = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_RESIZE = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_MOVE = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_SHOW = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_HIDE = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_FOCUS = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_UNFOCUS = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_RAISE = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_LOWER = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_ACTIVATE = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_ICONIFIED_CHANGE = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_MAXIMIZED_CHANGE = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_LAYER_CHANGE = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_FULLSCREEN_CHANGE = ecore_event_type_new();
+   ECORE_EVAS_EWS_EVENT_CONFIG_CHANGE = ecore_event_type_new();
+}
+
+static int
+_ecore_evas_ews_init(void)
+{
+   _ecore_evas_init_count++;
+   if (_ecore_evas_init_count > 1) return _ecore_evas_init_count;
+
+   _ecore_evas_ews_env_setup();
+
+   return _ecore_evas_init_count;
+}
+
+int
+_ecore_evas_ews_shutdown(void)
+{
+   _ecore_evas_init_count--;
+   if (_ecore_evas_init_count == 0)
+     {
+        if (_ews_ee)
+          {
+             ecore_evas_free(_ews_ee);
+             _ews_ee = NULL;
+          }
+        if (_ews_children)
+          {
+             eina_list_free(_ews_children);
+             _ews_children = NULL;
+          }
+
+        free(_ews_engine);
+        _ews_engine = NULL;
+        free(_ews_options);
+        _ews_options = NULL;
+        _ews_defaults_engine = EINA_TRUE;
+        _ews_defaults_geo = EINA_TRUE;
+
+     }
+   if (_ecore_evas_init_count < 0) _ecore_evas_init_count = 0;
+   return _ecore_evas_init_count;
+}
+
+static void
+_ecore_evas_ews_coord_translate(Ecore_Evas *ee, Evas_Coord *x, Evas_Coord *y)
+{
+   Evas_Coord xx, yy, ww, hh, fx, fy, fw, fh;
+
+   evas_object_geometry_get(ee->engine.ews.image, &xx, &yy, &ww, &hh);
+   evas_object_image_fill_get(ee->engine.ews.image, &fx, &fy, &fw, &fh);
+
+   if (fw < 1) fw = 1;
+   if (fh < 1) fh = 1;
+
+   if ((fx == 0) && (fy == 0) && (fw == ww) && (fh == hh))
+     {
+        *x = (ee->w * (*x - xx)) / fw;
+        *y = (ee->h * (*y - yy)) / fh;
+     }
+   else
+     {
+        xx = (*x - xx) - fx;
+        while (xx < 0) xx += fw;
+        while (xx > fw) xx -= fw;
+        *x = (ee->w * xx) / fw;
+
+        yy = (*y - yy) - fy;
+        while (yy < 0) yy += fh;
+        while (yy > fh) yy -= fh;
+        *y = (ee->h * yy) / fh;
+     }
+}
+
+static void
+_ecore_evas_ews_modifiers_apply(Ecore_Evas *ee, const Evas_Modifier *modifier)
+{
+   Evas *e = ee->evas;
+
+   if (evas_key_modifier_is_set(modifier, "Shift"))
+     evas_key_modifier_on(e, "Shift");
+   else evas_key_modifier_off(e, "Shift");
+
+   if (evas_key_modifier_is_set(modifier, "Control"))
+     evas_key_modifier_on(e, "Control");
+   else evas_key_modifier_off(e, "Control");
+
+   if (evas_key_modifier_is_set(modifier, "Alt"))
+     evas_key_modifier_on(e, "Alt");
+   else evas_key_modifier_off(e, "Alt");
+
+   if (evas_key_modifier_is_set(modifier, "Super"))
+     evas_key_modifier_on(e, "Super");
+   else evas_key_modifier_off(e, "Super");
+
+   if (evas_key_modifier_is_set(modifier, "Hyper"))
+     evas_key_modifier_on(e, "Hyper");
+   else evas_key_modifier_off(e, "Hyper");
+
+   if (evas_key_modifier_is_set(modifier, "Scroll_Lock"))
+     evas_key_lock_on(e, "Scroll_Lock");
+   else evas_key_lock_off(e, "Scroll_Lock");
+
+   if (evas_key_modifier_is_set(modifier, "Num_Lock"))
+     evas_key_lock_on(e, "Num_Lock");
+   else evas_key_lock_off(e, "Num_Lock");
+
+   if (evas_key_modifier_is_set(modifier, "Caps_Lock"))
+     evas_key_lock_on(e, "Caps_Lock");
+   else evas_key_lock_off(e, "Caps_Lock");
+
+   if (evas_key_modifier_is_set(modifier, "Shift_Lock"))
+     evas_key_lock_on(e, "Shift_Lock");
+   else evas_key_lock_off(e, "Shift_Lock");
+}
+
+static void
+_ecore_evas_ews_cb_mouse_in(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   Evas_Event_Mouse_In *ev = event_info;
+   Evas_Coord x = ev->canvas.x;
+   Evas_Coord y = ev->canvas.y;
+   _ecore_evas_ews_coord_translate(ee, &x, &y);
+   if (ee->func.fn_mouse_in) ee->func.fn_mouse_in(ee);
+   _ecore_evas_ews_modifiers_apply(ee, ev->modifiers);
+   evas_event_feed_mouse_in(ee->evas, ev->timestamp, NULL);
+   _ecore_evas_mouse_move_process(ee, x, y, ev->timestamp);
+}
+
+static void
+_ecore_evas_ews_cb_mouse_out(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   Evas_Event_Mouse_Out *ev = event_info;
+   Evas_Coord x = ev->canvas.x;
+   Evas_Coord y = ev->canvas.y;
+   // TODO: consider grab mode in EWS
+   _ecore_evas_ews_coord_translate(ee, &x, &y);
+   if (ee->func.fn_mouse_out) ee->func.fn_mouse_out(ee);
+   _ecore_evas_ews_modifiers_apply(ee, ev->modifiers);
+   evas_event_feed_mouse_out(ee->evas, ev->timestamp, NULL);
+   if (ee->prop.cursor.object) evas_object_hide(ee->prop.cursor.object);
+   _ecore_evas_mouse_move_process(ee, x, y, ev->timestamp);
+}
+
+static void
+_ecore_evas_ews_cb_mouse_down(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee = data;
+   Evas_Event_Mouse_Down *ev = event_info;
+   _ecore_evas_ews_modifiers_apply(ee, ev->modifiers);
+   evas_event_feed_mouse_down(ee->evas, ev->button, ev->flags, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_ews_cb_mouse_up(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee = data;
+   Evas_Event_Mouse_Up *ev = event_info;
+   _ecore_evas_ews_modifiers_apply(ee, ev->modifiers);
+   evas_event_feed_mouse_up(ee->evas, ev->button, ev->flags, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_ews_cb_mouse_move(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee = data;
+   Evas_Event_Mouse_Move *ev = event_info;
+   Evas_Coord x = ev->cur.canvas.x;
+   Evas_Coord y = ev->cur.canvas.y;
+   _ecore_evas_ews_coord_translate(ee, &x, &y);
+   _ecore_evas_ews_modifiers_apply(ee, ev->modifiers);
+   _ecore_evas_mouse_move_process(ee, x, y, ev->timestamp);
+}
+
+static void
+_ecore_evas_ews_cb_mouse_wheel(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee = data;
+   Evas_Event_Mouse_Wheel *ev = event_info;
+   _ecore_evas_ews_modifiers_apply(ee, ev->modifiers);
+   evas_event_feed_mouse_wheel(ee->evas, ev->direction, ev->z, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_ews_cb_multi_down(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee = data;
+   Evas_Event_Multi_Down *ev = event_info;
+   Evas_Coord x, y, xx, yy;
+   double xf, yf;
+
+   x = ev->canvas.x;
+   y = ev->canvas.y;
+   xx = x;
+   yy = y;
+   _ecore_evas_ews_coord_translate(ee, &x, &y);
+   xf = (ev->canvas.xsub - (double)xx) + (double)x;
+   yf = (ev->canvas.ysub - (double)yy) + (double)y;
+   _ecore_evas_ews_modifiers_apply(ee, ev->modifiers);
+   evas_event_feed_multi_down(ee->evas, ev->device, x, y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, xf, yf, ev->flags, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_ews_cb_multi_up(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee = data;
+   Evas_Event_Multi_Up *ev = event_info;
+   Evas_Coord x, y, xx, yy;
+   double xf, yf;
+
+   x = ev->canvas.x;
+   y = ev->canvas.y;
+   xx = x;
+   yy = y;
+   _ecore_evas_ews_coord_translate(ee, &x, &y);
+   xf = (ev->canvas.xsub - (double)xx) + (double)x;
+   yf = (ev->canvas.ysub - (double)yy) + (double)y;
+   _ecore_evas_ews_modifiers_apply(ee, ev->modifiers);
+   evas_event_feed_multi_up(ee->evas, ev->device, x, y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, xf, yf, ev->flags, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_ews_cb_multi_move(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee = data;
+   Evas_Event_Multi_Move *ev = event_info;
+   Evas_Coord x, y, xx, yy;
+   double xf, yf;
+
+   x = ev->cur.canvas.x;
+   y = ev->cur.canvas.y;
+   xx = x;
+   yy = y;
+   _ecore_evas_ews_coord_translate(ee, &x, &y);
+   xf = (ev->cur.canvas.xsub - (double)xx) + (double)x;
+   yf = (ev->cur.canvas.ysub - (double)yy) + (double)y;
+   _ecore_evas_ews_modifiers_apply(ee, ev->modifiers);
+   evas_event_feed_multi_move(ee->evas, ev->device, x, y, ev->radius, ev->radius_x, ev->radius_y, ev->pressure, ev->angle, xf, yf, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_ews_cb_free(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   if (ee->driver) _ecore_evas_free(ee);
+}
+
+static void
+_ecore_evas_ews_cb_key_down(void *data, Evas *e, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee = data;
+   Evas_Event_Key_Down *ev = event_info;
+
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Shift"))
+     evas_key_modifier_on(ee->evas, "Shift");
+   else
+     evas_key_modifier_off(ee->evas, "Shift");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Control"))
+     evas_key_modifier_on(ee->evas, "Control");
+   else
+     evas_key_modifier_off(ee->evas, "Control");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Alt"))
+     evas_key_modifier_on(ee->evas, "Alt");
+   else
+     evas_key_modifier_off(ee->evas, "Alt");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Meta"))
+     evas_key_modifier_on(ee->evas, "Meta");
+   else
+     evas_key_modifier_off(ee->evas, "Meta");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Hyper"))
+     evas_key_modifier_on(ee->evas, "Hyper");
+   else
+     evas_key_modifier_off(ee->evas, "Hyper");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Super"))
+     evas_key_modifier_on(ee->evas, "Super");
+   else
+     evas_key_modifier_off(ee->evas, "Super");
+   if (evas_key_lock_is_set(evas_key_lock_get(e), "Scroll_Lock"))
+     evas_key_lock_on(ee->evas, "Scroll_Lock");
+   else
+     evas_key_lock_off(ee->evas, "Scroll_Lock");
+   if (evas_key_lock_is_set(evas_key_lock_get(e), "Num_Lock"))
+     evas_key_lock_on(ee->evas, "Num_Lock");
+   else
+     evas_key_lock_off(ee->evas, "Num_Lock");
+   if (evas_key_lock_is_set(evas_key_lock_get(e), "Caps_Lock"))
+     evas_key_lock_on(ee->evas, "Caps_Lock");
+   else
+     evas_key_lock_off(ee->evas, "Caps_Lock");
+   evas_event_feed_key_down(ee->evas, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_ews_cb_key_up(void *data, Evas *e, Evas_Object *obj __UNUSED__, void *event_info)
+{
+   Ecore_Evas *ee = data;
+   Evas_Event_Key_Up *ev = event_info;
+
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Shift"))
+     evas_key_modifier_on(ee->evas, "Shift");
+   else
+     evas_key_modifier_off(ee->evas, "Shift");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Control"))
+     evas_key_modifier_on(ee->evas, "Control");
+   else
+     evas_key_modifier_off(ee->evas, "Control");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Alt"))
+     evas_key_modifier_on(ee->evas, "Alt");
+   else
+     evas_key_modifier_off(ee->evas, "Alt");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Meta"))
+     evas_key_modifier_on(ee->evas, "Meta");
+   else
+     evas_key_modifier_off(ee->evas, "Meta");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Hyper"))
+     evas_key_modifier_on(ee->evas, "Hyper");
+   else
+     evas_key_modifier_off(ee->evas, "Hyper");
+   if (evas_key_modifier_is_set(evas_key_modifier_get(e), "Super"))
+     evas_key_modifier_on(ee->evas, "Super");
+   else
+     evas_key_modifier_off(ee->evas, "Super");
+   if (evas_key_lock_is_set(evas_key_lock_get(e), "Scroll_Lock"))
+     evas_key_lock_on(ee->evas, "Scroll_Lock");
+   else
+     evas_key_lock_off(ee->evas, "Scroll_Lock");
+   if (evas_key_lock_is_set(evas_key_lock_get(e), "Num_Lock"))
+     evas_key_lock_on(ee->evas, "Num_Lock");
+   else
+     evas_key_lock_off(ee->evas, "Num_Lock");
+   if (evas_key_lock_is_set(evas_key_lock_get(e), "Caps_Lock"))
+     evas_key_lock_on(ee->evas, "Caps_Lock");
+   else
+     evas_key_lock_off(ee->evas, "Caps_Lock");
+   evas_event_feed_key_up(ee->evas, ev->keyname, ev->key, ev->string, ev->compose, ev->timestamp, NULL);
+}
+
+static void
+_ecore_evas_ews_cb_focus_in(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   ecore_evas_focus_set(ee, EINA_TRUE);
+}
+
+static void
+_ecore_evas_ews_cb_focus_out(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   if (ee->deleted) return;
+   ecore_evas_focus_set(ee, EINA_FALSE);
+}
+
+static void
+_ecore_evas_ews_cb_show(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   ecore_evas_show(ee);
+}
+
+static void
+_ecore_evas_ews_cb_hide(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   if (ee->deleted) return;
+   ecore_evas_hide(ee);
+}
+#endif
+
+EAPI Ecore_Evas *
+ecore_evas_ews_new(int x, int y, int w, int h)
+{
+// basically a copy of ecore_evas_buffer_new() keep in sync...
+#ifdef BUILD_ECORE_EVAS_EWS
+   Evas_Object *o;
+   Evas_Engine_Info_Buffer *einfo;
+   Ecore_Evas *ee;
+   int rmethod;
+
+   if (_ecore_evas_ews_init() < 1) return NULL;
+
+   if (!_ews_ee) _ews_ee = _ecore_evas_ews_ee_new();
+   if (!_ews_ee)
+     {
+        ERR("Could not create EWS backing store");
+        _ecore_evas_ews_shutdown();
+        return NULL;
+     }
+
+   rmethod = evas_render_method_lookup("buffer");
+   if (!rmethod) return NULL;
+   ee = calloc(1, sizeof(Ecore_Evas));
+   if (!ee) return NULL;
+
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+
+   o = evas_object_image_add(_ews_ee->evas);
+   evas_object_image_content_hint_set(o, EVAS_IMAGE_CONTENT_HINT_DYNAMIC);
+   evas_object_image_colorspace_set(o, EVAS_COLORSPACE_ARGB8888);
+   evas_object_image_size_set(o, w, h);
+   evas_object_image_alpha_set(o, 1);
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_ews_engine_func;
+
+   ee->driver = EWS_ENGINE_NAME;
+
+   ee->x = 0;
+   ee->y = 0;
+   ee->w = w;
+   ee->h = h;
+   ee->req.x = ee->x;
+   ee->req.y = ee->y;
+   ee->req.w = ee->w;
+   ee->req.h = ee->h;
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_method_set(ee->evas, rmethod);
+   evas_output_size_set(ee->evas, w, h);
+   evas_output_viewport_set(ee->evas, 0, 0, w, h);
+
+   evas_object_move(o, x, y);
+   evas_object_resize(o, w, h);
+   evas_object_image_fill_set(o, 0, 0, w, h);
+
+   ee->engine.ews.image = o;
+   evas_object_data_set(ee->engine.ews.image, "Ecore_Evas", ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_MOUSE_IN,
+                                  _ecore_evas_ews_cb_mouse_in, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_MOUSE_OUT,
+                                  _ecore_evas_ews_cb_mouse_out, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_MOUSE_DOWN,
+                                  _ecore_evas_ews_cb_mouse_down, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_MOUSE_UP,
+                                  _ecore_evas_ews_cb_mouse_up, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_MOUSE_MOVE,
+                                  _ecore_evas_ews_cb_mouse_move, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_MOUSE_WHEEL,
+                                  _ecore_evas_ews_cb_mouse_wheel, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_MULTI_DOWN,
+                                  _ecore_evas_ews_cb_multi_down, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_MULTI_UP,
+                                  _ecore_evas_ews_cb_multi_up, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_MULTI_MOVE,
+                                  _ecore_evas_ews_cb_multi_move, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_FREE,
+                                  _ecore_evas_ews_cb_free, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_KEY_DOWN,
+                                  _ecore_evas_ews_cb_key_down, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_KEY_UP,
+                                  _ecore_evas_ews_cb_key_up, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_FOCUS_IN,
+                                  _ecore_evas_ews_cb_focus_in, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_FOCUS_OUT,
+                                  _ecore_evas_ews_cb_focus_out, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_SHOW,
+                                  _ecore_evas_ews_cb_show, ee);
+   evas_object_event_callback_add(ee->engine.ews.image,
+                                  EVAS_CALLBACK_HIDE,
+                                  _ecore_evas_ews_cb_hide, ee);
+   einfo = (Evas_Engine_Info_Buffer *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        void *pixels = evas_object_image_data_get(o, 1);
+        evas_object_image_data_set(o, pixels); // refcount
+        einfo->info.depth_type = EVAS_ENGINE_BUFFER_DEPTH_ARGB32;
+        einfo->info.dest_buffer = pixels;
+        einfo->info.dest_buffer_row_bytes = evas_object_image_stride_get(o);
+        einfo->info.use_color_key = 0;
+        einfo->info.alpha_threshold = 0;
+        einfo->info.func.new_update_region = NULL;
+        einfo->info.func.free_update_region = NULL;
+        evas_object_image_data_set(o, pixels);
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             ecore_evas_free(ee);
+             return NULL;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+        ecore_evas_free(ee);
+        return NULL;
+     }
+   evas_key_modifier_add(ee->evas, "Shift");
+   evas_key_modifier_add(ee->evas, "Control");
+   evas_key_modifier_add(ee->evas, "Alt");
+   evas_key_modifier_add(ee->evas, "Meta");
+   evas_key_modifier_add(ee->evas, "Hyper");
+   evas_key_modifier_add(ee->evas, "Super");
+   evas_key_lock_add(ee->evas, "Caps_Lock");
+   evas_key_lock_add(ee->evas, "Num_Lock");
+   evas_key_lock_add(ee->evas, "Scroll_Lock");
+
+   _ews_ee->sub_ecore_evas = eina_list_append(_ews_ee->sub_ecore_evas, ee);
+   _ews_children = eina_list_append(_ews_children, ee);
+
+   _ecore_evas_ews_event(ee, ECORE_EVAS_EWS_EVENT_ADD);
+
+   return ee;
+#else
+   return NULL;
+   (void)x;
+   (void)y;
+   (void)w;
+   (void)h;
+#endif
+}
+
+EAPI Evas_Object *
+ecore_evas_ews_backing_store_get(const Ecore_Evas *ee)
+{
+#ifdef BUILD_ECORE_EVAS_EWS
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_ews_backing_store_get");
+        return NULL;
+     }
+   return ee->engine.ews.image;
+#else
+   return NULL;
+   (void)ee;
+#endif
+}
+
+EAPI void
+ecore_evas_ews_delete_request(Ecore_Evas *ee)
+{
+#ifdef BUILD_ECORE_EVAS_EWS
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_ews_delete_request");
+        return;
+     }
+   if (ee->func.fn_delete_request) ee->func.fn_delete_request(ee);
+   else ecore_evas_free(ee);
+#else
+   (void)ee;
+#endif
+}
+
+
+EAPI Eina_Bool
+ecore_evas_ews_engine_set(const char *engine, const char *options)
+{
+#ifdef BUILD_ECORE_EVAS_EWS
+   if (_ews_ee) return EINA_FALSE;
+
+   free(_ews_engine);
+   free(_ews_options);
+
+   _ews_engine = engine ? strdup(engine) : NULL;
+   _ews_options = options ? strdup(options) : NULL;
+
+   if ((engine) && (!_ews_engine)) return EINA_FALSE;
+   if ((options) && (!_ews_options)) return EINA_FALSE;
+
+   _ews_defaults_engine = EINA_FALSE;
+   return EINA_TRUE;
+#else
+   return EINA_FALSE;
+   (void)engine;
+   (void)options;
+#endif
+}
+
+EAPI Eina_Bool
+ecore_evas_ews_setup(int x, int y, int w, int h)
+{
+#ifdef BUILD_ECORE_EVAS_EWS
+   Eina_Bool ret = EINA_TRUE;
+
+   _ews_defaults_geo = EINA_FALSE;
+   _ews_x = x;
+   _ews_y = y;
+   _ews_w = w;
+   _ews_h = h;
+
+   if (!_ews_ee) return EINA_TRUE;
+
+   /* move-resize is not as implemented as move + resize */
+   ecore_evas_move(_ews_ee, x, y);
+   ecore_evas_size_min_set(_ews_ee, w, h);
+   ecore_evas_size_max_set(_ews_ee, w, h);
+   ecore_evas_resize(_ews_ee, w, h);
+
+   ecore_evas_geometry_get(_ews_ee, &x, &y, &w, &h);
+
+#define TST(n) if ((n != _ews_##n))                     \
+     {                                                  \
+        WRN("Asked %d, got %d for "#n, _ews_##n, n);    \
+        ret = EINA_FALSE;                               \
+     }
+   TST(x);
+   TST(y);
+   TST(w);
+   TST(h);
+#undef TST
+   return ret;
+#else
+   return EINA_FALSE;
+   (void)x;
+   (void)y;
+   (void)w;
+   (void)h;
+#endif
+}
+
+EAPI Ecore_Evas *
+ecore_evas_ews_ecore_evas_get(void)
+{
+#ifdef BUILD_ECORE_EVAS_EWS
+   if (!_ews_ee) _ews_ee = _ecore_evas_ews_ee_new();
+   return _ews_ee;
+#else
+   return NULL;
+#endif
+}
+
+EAPI Evas *
+ecore_evas_ews_evas_get(void)
+{
+#ifdef BUILD_ECORE_EVAS_EWS
+   return ecore_evas_get(ecore_evas_ews_ecore_evas_get());
+#else
+   return NULL;
+#endif
+}
+
+EAPI Evas_Object *
+ecore_evas_ews_background_get(void)
+{
+#ifdef BUILD_ECORE_EVAS_EWS
+   return _ews_bg;
+#else
+   return NULL;
+#endif
+}
+
+#ifdef BUILD_ECORE_EVAS_EWS
+static void
+_ecore_evas_ews_background_free(void *data __UNUSED__, Evas *e __UNUSED__, Evas_Object *o __UNUSED__, void *event_info __UNUSED__)
+{
+   _ews_bg = NULL;
+   ecore_evas_ews_background_set(NULL);
+}
+#endif
+
+EAPI void
+ecore_evas_ews_background_set(Evas_Object *o)
+{
+#ifdef BUILD_ECORE_EVAS_EWS
+   if ((o) && (o == _ews_bg)) return;
+
+   if (_ews_bg)
+     {
+        evas_object_del(_ews_bg);
+        _ews_bg = NULL;
+     }
+
+   if ((!o) && (_ews_ee))
+     {
+        o = evas_object_rectangle_add(ecore_evas_get(_ews_ee));
+        evas_object_color_set(o, 0, 0, 0, 255);
+     }
+
+   if (_ews_ee)
+     {
+        Evas_Coord w, h;
+        Evas *e = ecore_evas_get(_ews_ee);
+
+        if (e != evas_object_evas_get(o))
+          {
+             ERR("background not in ecore_evas_ews_evas_get() canvas!");
+             return;
+          }
+
+        evas_output_viewport_get(e, NULL, NULL, &w, &h);
+        evas_object_move(o, 0, 0);
+        evas_object_resize(o, w, h);
+        evas_object_layer_set(o, EVAS_LAYER_MIN);
+        evas_object_lower(o);
+        evas_object_show(o);
+
+        evas_object_event_callback_add
+          (o, EVAS_CALLBACK_FREE, _ecore_evas_ews_background_free, NULL);
+     }
+
+   _ews_bg = o;
+#else
+   return;
+   (void)o;
+#endif
+}
+
+
+EAPI const Eina_List *
+ecore_evas_ews_children_get(void)
+{
+#ifdef BUILD_ECORE_EVAS_EWS
+   return _ews_children;
+#else
+   return NULL;
+#endif
+}
+
+EAPI void
+ecore_evas_ews_manager_set(const void *manager)
+{
+#ifdef BUILD_ECORE_EVAS_EWS
+   if (_ews_manager ==  manager) return;
+   _ews_manager = manager;
+   ecore_event_add(ECORE_EVAS_EWS_EVENT_MANAGER_CHANGE, NULL, NULL, NULL);
+#else
+   (void)manager;
+#endif
+}
+
+EAPI const void *
+ecore_evas_ews_manager_get(void)
+{
+#ifdef BUILD_ECORE_EVAS_EWS
+   return _ews_manager;
+#else
+   return NULL;
+#endif
+}
diff --git a/libraries/ecore/src/lib/ecore_evas/ecore_evas_fb.c b/libraries/ecore/src/lib/ecore_evas/ecore_evas_fb.c
new file mode 100644
index 0000000..3ee913e
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/ecore_evas_fb.c
@@ -0,0 +1,659 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <sys/types.h>
+#include <dirent.h>
+
+#include <Ecore.h>
+#include "ecore_private.h"
+#ifdef BUILD_ECORE_EVAS_FB
+#include <Ecore_Fb.h>
+#include <ecore_fb_private.h>
+#endif
+
+#include "ecore_evas_private.h"
+#include "Ecore_Evas.h"
+
+#ifdef BUILD_ECORE_EVAS_FB
+static int _ecore_evas_init_count = 0;
+
+static char *ecore_evas_default_display = "0";
+static Eina_List *ecore_evas_input_devices = NULL;
+static Ecore_Event_Handler *ecore_evas_event_handlers[4] = {NULL, NULL, NULL, NULL};
+
+static void
+_ecore_evas_mouse_move_process_fb(Ecore_Evas *ee, int x, int y)
+{
+   int fbw, fbh;
+
+   ee->mouse.x = x;
+   ee->mouse.y = y;
+   ecore_fb_size_get(&fbw, &fbh);
+   if (ee->prop.cursor.object)
+     {
+        evas_object_show(ee->prop.cursor.object);
+        if (ee->rotation == 0)
+          evas_object_move(ee->prop.cursor.object,
+                           x - ee->prop.cursor.hot.x,
+                           y - ee->prop.cursor.hot.y);
+        else if (ee->rotation == 90)
+          evas_object_move(ee->prop.cursor.object,
+                           (fbh - ee->h) + ee->h - y - 1 - ee->prop.cursor.hot.x,
+                           x - ee->prop.cursor.hot.y);
+        else if (ee->rotation == 180)
+          evas_object_move(ee->prop.cursor.object,
+                           (fbw - ee->w) + ee->w - x - 1 - ee->prop.cursor.hot.x,
+                           (fbh - ee->h) + ee->h - y - 1 - ee->prop.cursor.hot.y);
+        else if (ee->rotation == 270)
+          evas_object_move(ee->prop.cursor.object,
+                           y - ee->prop.cursor.hot.x,
+                           (fbw - ee->w) + ee->w - x - 1 - ee->prop.cursor.hot.y);
+     }
+}
+
+static Ecore_Evas *fb_ee = NULL;
+
+static Ecore_Evas *
+_ecore_evas_fb_match(void)
+{
+   return fb_ee;
+}
+
+static void
+_ecore_evas_fb_lose(void *data __UNUSED__)
+{
+   Eina_List *ll;
+   Ecore_Fb_Input_Device *dev;
+
+   if (fb_ee) fb_ee->visible = 0;
+
+   EINA_LIST_FOREACH(ecore_evas_input_devices, ll, dev)
+     ecore_fb_input_device_listen(dev, 0);
+}
+
+static void
+_ecore_evas_fb_gain(void *data __UNUSED__)
+{
+   Ecore_Evas *ee;
+   Eina_List *ll;
+   Ecore_Fb_Input_Device *dev;
+
+   if (fb_ee)
+     {
+        ee = fb_ee;
+
+        ee->visible = 1;
+        if ((ee->rotation == 90) || (ee->rotation == 270))
+          evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
+        else
+          evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+     }
+
+   EINA_LIST_FOREACH(ecore_evas_input_devices, ll, dev)
+     ecore_fb_input_device_listen(dev, 1);
+}
+
+static Eina_Bool
+_ecore_evas_event_mouse_button_down(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_Event_Mouse_Button *e;
+
+   e = event;
+   ee = _ecore_evas_fb_match();
+   if (!ee) return ECORE_CALLBACK_PASS_ON;
+   _ecore_evas_mouse_move_process_fb(ee, e->x, e->y);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_event_mouse_button_up(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_Event_Mouse_Button *e;
+
+   e = event;
+   ee = _ecore_evas_fb_match();
+   if (!ee) return ECORE_CALLBACK_PASS_ON;
+   _ecore_evas_mouse_move_process_fb(ee, e->x, e->y);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_event_mouse_move(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_Event_Mouse_Move *e;
+
+   e = event;
+   ee = _ecore_evas_fb_match();
+   if (!ee) return ECORE_CALLBACK_PASS_ON;
+   _ecore_evas_mouse_move_process_fb(ee, e->x, e->y);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_event_mouse_wheel(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_Event_Mouse_Wheel *e;
+
+   e = event;
+   ee = _ecore_evas_fb_match();
+   if (!ee) return ECORE_CALLBACK_PASS_ON;
+   _ecore_evas_mouse_move_process_fb(ee, e->x, e->y);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static int
+_ecore_evas_fb_render(Ecore_Evas *ee)
+{
+   int rend = 0;
+
+   if (ee->visible)
+     {
+        Eina_List *updates;
+
+        Eina_List *ll;
+        Ecore_Evas *ee2;
+        if (ee->func.fn_pre_render) ee->func.fn_pre_render(ee);
+
+        EINA_LIST_FOREACH(ee->sub_ecore_evas, ll, ee2)
+          {
+             if (ee2->func.fn_pre_render) ee2->func.fn_pre_render(ee2);
+             if (ee2->engine.func->fn_render)
+               rend |= ee2->engine.func->fn_render(ee2);
+             if (ee2->func.fn_post_render) ee2->func.fn_post_render(ee2);
+          }
+
+        updates = evas_render_updates(ee->evas);
+        if (updates)
+          {
+             evas_render_updates_free(updates);
+             _ecore_evas_idle_timeout_update(ee);
+             rend = 1;
+          }
+        if (ee->func.fn_post_render) ee->func.fn_post_render(ee);
+     }
+   else
+     evas_norender(ee->evas);
+   return rend;
+}
+
+static int
+_ecore_evas_fb_init(Ecore_Evas *ee, int w, int h)
+{
+   Ecore_Fb_Input_Device *device;
+   Ecore_Fb_Input_Device_Cap caps;
+   int mouse_handled = 0;
+
+   DIR *input_dir;
+   struct dirent *input_entry;
+
+   _ecore_evas_init_count++;
+   if (_ecore_evas_init_count > 1) return _ecore_evas_init_count;
+
+   ecore_event_evas_init();
+
+   /* register all input devices */
+   input_dir = opendir("/dev/input/");
+   if (!input_dir) return _ecore_evas_init_count;
+
+   while ((input_entry = readdir(input_dir)))
+     {
+        char device_path[256];
+
+        if (strncmp(input_entry->d_name, "event", 5) != 0)
+          continue;
+
+        snprintf(device_path, 256, "/dev/input/%s", input_entry->d_name);
+        if (!(device = ecore_fb_input_device_open(device_path)))
+          continue;
+        ecore_fb_input_device_window_set(device, ee);
+
+        caps = ecore_fb_input_device_cap_get(device);
+
+        /* Mouse */
+#ifdef HAVE_TSLIB
+        if (caps & ECORE_FB_INPUT_DEVICE_CAP_RELATIVE)
+#else
+        if ((caps & ECORE_FB_INPUT_DEVICE_CAP_RELATIVE) || (caps & ECORE_FB_INPUT_DEVICE_CAP_ABSOLUTE))
+#endif
+          {
+             ecore_fb_input_device_axis_size_set(device, w, h);
+             ecore_fb_input_device_listen(device,1);
+             ecore_evas_input_devices = eina_list_append(ecore_evas_input_devices, device);
+             if (!mouse_handled)
+               {
+                  ecore_evas_event_handlers[0]  = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, _ecore_evas_event_mouse_button_down, NULL);
+                  ecore_evas_event_handlers[1]  = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP, _ecore_evas_event_mouse_button_up, NULL);
+                  ecore_evas_event_handlers[2]  = ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE, _ecore_evas_event_mouse_move, NULL);
+                  ecore_evas_event_handlers[3]  = ecore_event_handler_add(ECORE_EVENT_MOUSE_WHEEL, _ecore_evas_event_mouse_wheel, NULL);
+                  mouse_handled = 1;
+               }
+          }
+        /* Keyboard */
+        else if ((caps & ECORE_FB_INPUT_DEVICE_CAP_KEYS_OR_BUTTONS) && !(caps & ECORE_FB_INPUT_DEVICE_CAP_ABSOLUTE))
+          {
+             ecore_fb_input_device_listen(device,1);
+             ecore_evas_input_devices = eina_list_append(ecore_evas_input_devices, device);
+          }
+     }
+   closedir(input_dir);
+
+   if (!mouse_handled)
+     {
+        if (ecore_fb_ts_init())
+          {
+             ecore_fb_ts_event_window_set(ee);
+             ecore_evas_event_handlers[0]  = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_DOWN, _ecore_evas_event_mouse_button_down, NULL);
+             ecore_evas_event_handlers[1]  = ecore_event_handler_add(ECORE_EVENT_MOUSE_BUTTON_UP, _ecore_evas_event_mouse_button_up, NULL);
+             ecore_evas_event_handlers[2]  = ecore_event_handler_add(ECORE_EVENT_MOUSE_MOVE, _ecore_evas_event_mouse_move, NULL);
+             mouse_handled = 1;
+          }
+     }
+   return _ecore_evas_init_count;
+}
+
+static void
+_ecore_evas_fb_free(Ecore_Evas *ee)
+{
+   ecore_evas_input_event_unregister(ee);
+   if (fb_ee == ee) fb_ee = NULL;
+   _ecore_evas_fb_shutdown();
+   ecore_fb_shutdown();
+}
+
+static void
+_ecore_evas_resize(Ecore_Evas *ee, int w, int h)
+{
+   ee->req.w = w;
+   ee->req.h = h;
+   if ((w == ee->w) && (h == ee->h)) return;
+   ee->w = w;
+   ee->h = h;
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+       evas_output_size_set(ee->evas, ee->h, ee->w);
+       evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+       evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
+     }
+   else
+     {
+       evas_output_size_set(ee->evas, ee->w, ee->h);
+       evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+       evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+     }
+   if (ee->func.fn_resize) ee->func.fn_resize(ee);
+}
+
+static void
+_ecore_evas_move_resize(Ecore_Evas *ee, int x __UNUSED__, int y __UNUSED__, int w, int h)
+{
+   ee->req.w = w;
+   ee->req.h = h;
+   if ((w == ee->w) && (h == ee->h)) return;
+   ee->w = w;
+   ee->h = h;
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     {
+       evas_output_size_set(ee->evas, ee->h, ee->w);
+       evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+       evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
+     }
+   else
+     {
+       evas_output_size_set(ee->evas, ee->w, ee->h);
+       evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+       evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+     }
+   if (ee->func.fn_resize) ee->func.fn_resize(ee);
+}
+
+static void
+_ecore_evas_rotation_set(Ecore_Evas *ee, int rotation, int resize __UNUSED__)
+{
+   Evas_Engine_Info_FB *einfo;
+   int rot_dif;
+
+   if (ee->rotation == rotation) return;
+   einfo = (Evas_Engine_Info_FB *)evas_engine_info_get(ee->evas);
+   if (!einfo) return;
+   rot_dif = ee->rotation - rotation;
+   if (rot_dif < 0) rot_dif = -rot_dif;
+   if (rot_dif != 180)
+     {
+
+        einfo->info.rotation = rotation;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+        if (!ee->prop.fullscreen)
+          {
+             int tmp;
+
+             tmp = ee->w;
+             ee->w = ee->h;
+             ee->h = tmp;
+             ee->req.w = ee->w;
+             ee->req.h = ee->h;
+          }
+        else
+          {
+             if ((rotation == 0) || (rotation == 180))
+               {
+                  evas_output_size_set(ee->evas, ee->w, ee->h);
+                  evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+               }
+             else
+               {
+                  evas_output_size_set(ee->evas, ee->h, ee->w);
+                  evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+               }
+          }
+        ee->rotation = rotation;
+     }
+   else
+     {
+        einfo->info.rotation = rotation;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+        ee->rotation = rotation;
+     }
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
+   else
+     evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+   _ecore_evas_mouse_move_process_fb(ee, ee->mouse.x, ee->mouse.y);
+   if (ee->func.fn_resize) ee->func.fn_resize(ee);
+}
+
+static void
+_ecore_evas_show(Ecore_Evas *ee)
+{
+   if (ee->prop.focused) return;
+   ee->prop.focused = 1;
+   evas_focus_in(ee->evas);
+   if (ee->func.fn_focus_in) ee->func.fn_focus_in(ee);
+}
+
+static void
+_ecore_evas_object_cursor_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee;
+
+   ee = data;
+   if (ee)
+     ee->prop.cursor.object = NULL;
+}
+
+static void
+_ecore_evas_object_cursor_set(Ecore_Evas *ee, Evas_Object *obj, int layer, int hot_x, int hot_y)
+{
+   int x, y;
+
+   if (ee->prop.cursor.object) evas_object_del(ee->prop.cursor.object);
+
+   if (!obj)
+     {
+        ee->prop.cursor.object = NULL;
+        ee->prop.cursor.layer = 0;
+        ee->prop.cursor.hot.x = 0;
+        ee->prop.cursor.hot.y = 0;
+        return;
+     }
+
+   ee->prop.cursor.object = obj;
+   ee->prop.cursor.layer = layer;
+   ee->prop.cursor.hot.x = hot_x;
+   ee->prop.cursor.hot.y = hot_y;
+   evas_pointer_output_xy_get(ee->evas, &x, &y);
+   evas_object_layer_set(ee->prop.cursor.object, ee->prop.cursor.layer);
+   evas_object_move(ee->prop.cursor.object,
+                    x - ee->prop.cursor.hot.x,
+                    y - ee->prop.cursor.hot.y);
+   evas_object_pass_events_set(ee->prop.cursor.object, 1);
+   if (evas_pointer_inside_get(ee->evas))
+     evas_object_show(ee->prop.cursor.object);
+
+   evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL, _ecore_evas_object_cursor_del, ee);
+}
+
+static void
+_ecore_evas_fullscreen_set(Ecore_Evas *ee, int on)
+{
+   Eina_List *l;
+   Ecore_Fb_Input_Device *dev;
+   int resized = 0;
+
+   if (((ee->prop.fullscreen) && (on)) ||
+       ((!ee->prop.fullscreen) && (!on))) return;
+   if (on)
+     {
+        int w, h;
+
+        ee->engine.fb.real_w = ee->w;
+        ee->engine.fb.real_h = ee->h;
+        w = ee->w;
+        h = ee->h;
+        ecore_fb_size_get(&w, &h);
+        if ((w == 0) && (h == 0))
+          {
+             w = ee->w;
+             h = ee->h;
+          }
+        if ((w != ee->w) || (h != ee->h)) resized = 1;
+        ee->w = w;
+        ee->h = h;
+        ee->req.w = ee->w;
+        ee->req.h = ee->h;
+        evas_output_size_set(ee->evas, ee->w, ee->h);
+        evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+        evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+     }
+   else
+     {
+        if ((ee->engine.fb.real_w != ee->w) || (ee->engine.fb.real_h != ee->h)) resized = 1;
+        ee->w = ee->engine.fb.real_w;
+        ee->h = ee->engine.fb.real_h;
+        ee->req.w = ee->w;
+        ee->req.h = ee->h;
+        evas_output_size_set(ee->evas, ee->w, ee->h);
+        evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+        evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+     }
+   ee->prop.fullscreen = on;
+   EINA_LIST_FOREACH(ecore_evas_input_devices, l, dev)
+     ecore_fb_input_device_axis_size_set(dev, ee->w, ee->h);
+   /* rescale the input device area */
+   if (resized)
+     {
+        if (ee->func.fn_resize) ee->func.fn_resize(ee);
+     }
+}
+
+int
+_ecore_evas_fb_shutdown(void)
+{
+   _ecore_evas_init_count--;
+   if (_ecore_evas_init_count == 0)
+     {
+        int i;
+
+        for (i = 0; i < 4; i++)
+          {
+             if (ecore_evas_event_handlers[i])
+               ecore_event_handler_del(ecore_evas_event_handlers[i]);
+          }
+        ecore_fb_ts_shutdown();
+        ecore_event_evas_shutdown();
+     }
+   if (_ecore_evas_init_count < 0) _ecore_evas_init_count = 0;
+   return _ecore_evas_init_count;
+}
+
+static Ecore_Evas_Engine_Func _ecore_fb_engine_func =
+{
+   _ecore_evas_fb_free,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     _ecore_evas_resize,
+     _ecore_evas_move_resize,
+     _ecore_evas_rotation_set,
+     NULL,
+     _ecore_evas_show,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     _ecore_evas_object_cursor_set,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     _ecore_evas_fullscreen_set,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL, //transparent
+
+     NULL, // render
+     NULL  // screen_geometry_get
+};
+#endif
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#ifdef BUILD_ECORE_EVAS_FB
+EAPI Ecore_Evas *
+ecore_evas_fb_new(const char *disp_name, int rotation, int w, int h)
+{
+   Evas_Engine_Info_FB *einfo;
+   Ecore_Evas *ee;
+
+   int rmethod;
+
+   if (!disp_name)
+   disp_name = ecore_evas_default_display;
+
+   rmethod = evas_render_method_lookup("fb");
+   if (!rmethod) return NULL;
+
+   if (!ecore_fb_init(disp_name)) return NULL;
+   ecore_fb_callback_gain_set(_ecore_evas_fb_gain, NULL);
+   ecore_fb_callback_lose_set(_ecore_evas_fb_lose, NULL);
+   ee = calloc(1, sizeof(Ecore_Evas));
+   if (!ee) return NULL;
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+   _ecore_evas_fb_init(ee, w, h);
+
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_fb_engine_func;
+
+   ee->driver = "fb";
+   if (disp_name) ee->name = strdup(disp_name);
+
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   ee->rotation = rotation;
+   ee->visible = 1;
+   ee->w = w;
+   ee->h = h;
+   ee->req.w = ee->w;
+   ee->req.h = ee->h;
+
+   ee->prop.max.w = 0;
+   ee->prop.max.h = 0;
+   ee->prop.layer = 0;
+   ee->prop.focused = 1;
+   ee->prop.borderless = 1;
+   ee->prop.override = 1;
+   ee->prop.maximized = 1;
+   ee->prop.fullscreen = 0;
+   ee->prop.withdrawn = 0;
+   ee->prop.sticky = 0;
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_method_set(ee->evas, rmethod);
+
+   if ((rotation == 90) || (rotation == 270))
+     {
+       evas_output_size_set(ee->evas, h, w);
+       evas_output_viewport_set(ee->evas, 0, 0, h, w);
+     }
+   else
+     {
+       evas_output_size_set(ee->evas, w, h);
+       evas_output_viewport_set(ee->evas, 0, 0, w, h);
+     }
+
+   einfo = (Evas_Engine_Info_FB *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        einfo->info.virtual_terminal = 0;
+        einfo->info.device_number = strtol(disp_name, NULL, 10);
+        einfo->info.refresh = 0;
+        einfo->info.rotation = ee->rotation;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             ecore_evas_free(ee);
+             return NULL;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        ecore_evas_free(ee);
+        return NULL;
+     }
+
+   ecore_evas_input_event_register(ee);
+
+   ee->engine.func->fn_render = _ecore_evas_fb_render;
+   _ecore_evas_register(ee);
+   fb_ee = ee;
+   evas_event_feed_mouse_in(ee->evas, (unsigned int)((unsigned long long)(ecore_time_get() * 1000.0) & 0xffffffff), NULL);
+   return ee;
+}
+#else
+EAPI Ecore_Evas *
+ecore_evas_fb_new(const char *disp_name __UNUSED__, int rotation __UNUSED__, int w __UNUSED__, int h __UNUSED__)
+{
+   return NULL;
+}
+#endif
diff --git a/libraries/ecore/src/lib/ecore_evas/ecore_evas_private.h b/libraries/ecore/src/lib/ecore_evas/ecore_evas_private.h
new file mode 100644
index 0000000..2c20761
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/ecore_evas_private.h
@@ -0,0 +1,433 @@
+#ifndef _ECORE_EVAS_PRIVATE_H
+#define _ECORE_EVAS_PRIVATE_H
+
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+
+#ifdef HAVE_SYS_MMAN_H
+# include <sys/mman.h>
+#endif
+
+#include <Evas.h>
+#include <Ecore.h>
+#include <ecore_private.h>
+#include <Ecore_Input.h>
+#include <Ecore_Input_Evas.h>
+
+#define ECORE_MAGIC_EVAS 0x76543211
+
+#ifdef BUILD_ECORE_EVAS_X11
+# include <Ecore_X.h>
+# include <Ecore_X_Atoms.h>
+# ifdef HAVE_ECORE_X_XCB
+#  include <xcb/xcb.h>
+# endif
+# ifdef HAVE_ECORE_X_XLIB
+#  include <X11/Xlib.h>
+#  include <X11/Xutil.h>
+# endif
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+# include <Evas_Engine_Software_X11.h>
+#endif
+
+#ifdef BUILD_ECORE_EVAS_OPENGL_X11
+# include <Evas_Engine_GL_X11.h>
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_8_X11
+# include <Evas_Engine_Software_8_X11.h>
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_X11
+# include <Evas_Engine_Software_16_X11.h>
+#endif
+
+#ifdef BUILD_ECORE_EVAS_FB
+# include <Evas_Engine_FB.h>
+#endif
+
+#ifdef BUILD_ECORE_EVAS_DIRECTFB
+# include <Evas_Engine_DirectFB.h>
+# include "Ecore_DirectFB.h"
+#endif
+
+#if defined(BUILD_ECORE_EVAS_SOFTWARE_BUFFER) || defined(BUILD_ECORE_EVAS_EWS)
+# include <Evas_Engine_Buffer.h>
+#endif
+
+#ifdef BUILD_ECORE_EVAS_WIN32
+# include "Ecore_Win32.h"
+# ifdef BUILD_ECORE_EVAS_SOFTWARE_GDI
+#  include <Evas_Engine_Software_Gdi.h>
+# endif
+# ifdef BUILD_ECORE_EVAS_SOFTWARE_DDRAW
+#  include <Evas_Engine_Software_DDraw.h>
+# endif
+# ifdef BUILD_ECORE_EVAS_DIRECT3D
+#  include <Evas_Engine_Direct3D.h>
+# endif
+# ifdef BUILD_ECORE_EVAS_OPENGL_GLEW
+#  include <Evas_Engine_GL_Glew.h>
+# endif
+# ifdef BUILD_ECORE_EVAS_SOFTWARE_16_DDRAW
+#  include <Evas_Engine_Software_16_DDraw.h>
+# endif
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_WINCE
+# include "Ecore_WinCE.h"
+# include <Evas_Engine_Software_16_WinCE.h>
+#endif
+
+#ifdef BUILD_ECORE_EVAS_GL_COCOA
+# include "Ecore_Cocoa.h"
+# include <Evas_Engine_Gl_Cocoa.h>
+#endif
+
+/**
+   Log domain macros and variable
+ **/
+
+extern int _ecore_evas_log_dom;
+
+#ifdef ECORE_EVAS_DEFAULT_LOG_COLOR
+# undef ECORE_EVAS_DEFAULT_LOG_COLOR
+#endif
+#define ECORE_EVAS_DEFAULT_LOG_COLOR EINA_COLOR_BLUE
+
+#ifdef ERR
+# undef ERR
+#endif
+#define ERR(...) EINA_LOG_DOM_ERR(_ecore_evas_log_dom, __VA_ARGS__)
+#ifdef DBG
+# undef DBG
+#endif
+#define DBG(...) EINA_LOG_DOM_DBG(_ecore_evas_log_dom, __VA_ARGS__)
+#ifdef INF
+# undef INF
+#endif
+#define INF(...) EINA_LOG_DOM_INFO(_ecore_evas_log_dom, __VA_ARGS__)
+#ifdef WRN
+# undef WRN
+#endif
+#define WRN(...) EINA_LOG_DOM_WARN(_ecore_evas_log_dom, __VA_ARGS__)
+#ifdef CRIT
+# undef CRIT
+#endif
+#define CRIT(...) EINA_LOG_DOM_CRIT(_ecore_evas_log_dom, __VA_ARGS__)
+
+
+#define IDLE_FLUSH_TIME 0.5
+#ifndef _ECORE_EVAS_H
+typedef struct _Ecore_Evas Ecore_Evas;
+#endif
+
+typedef struct _Ecore_Evas_Engine Ecore_Evas_Engine;
+typedef struct _Ecore_Evas_Engine_Func Ecore_Evas_Engine_Func;
+
+struct _Ecore_Evas_Engine_Func
+{
+   void (*fn_free) (Ecore_Evas *ee);
+   void (*fn_callback_resize_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_callback_move_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_callback_show_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_callback_hide_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_callback_delete_request_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_callback_destroy_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_callback_focus_in_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_callback_focus_out_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_callback_mouse_in_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_callback_mouse_out_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_callback_sticky_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_callback_unsticky_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_callback_pre_render_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_callback_post_render_set) (Ecore_Evas *ee, void (*func) (Ecore_Evas *ee));
+   void (*fn_move) (Ecore_Evas *ee, int x, int y);
+   void (*fn_managed_move) (Ecore_Evas *ee, int x, int y);
+   void (*fn_resize) (Ecore_Evas *ee, int w, int h);
+   void (*fn_move_resize) (Ecore_Evas *ee, int x, int y, int w, int h);
+   void (*fn_rotation_set) (Ecore_Evas *ee, int rot, int resize);
+   void (*fn_shaped_set) (Ecore_Evas *ee, int shaped);
+   void (*fn_show) (Ecore_Evas *ee);
+   void (*fn_hide) (Ecore_Evas *ee);
+   void (*fn_raise) (Ecore_Evas *ee);
+   void (*fn_lower) (Ecore_Evas *ee);
+   void (*fn_activate) (Ecore_Evas *ee);
+   void (*fn_title_set) (Ecore_Evas *ee, const char *t);
+   void (*fn_name_class_set) (Ecore_Evas *ee, const char *n, const char *c);
+   void (*fn_size_min_set) (Ecore_Evas *ee, int w, int h);
+   void (*fn_size_max_set) (Ecore_Evas *ee, int w, int h);
+   void (*fn_size_base_set) (Ecore_Evas *ee, int w, int h);
+   void (*fn_size_step_set) (Ecore_Evas *ee, int w, int h);
+   void (*fn_object_cursor_set) (Ecore_Evas *ee, Evas_Object *obj, int layer, int hot_x, int hot_y);
+   void (*fn_layer_set) (Ecore_Evas *ee, int layer);
+   void (*fn_focus_set) (Ecore_Evas *ee, int on);
+   void (*fn_iconified_set) (Ecore_Evas *ee, int on);
+   void (*fn_borderless_set) (Ecore_Evas *ee, int on);
+   void (*fn_override_set) (Ecore_Evas *ee, int on);
+   void (*fn_maximized_set) (Ecore_Evas *ee, int on);
+   void (*fn_fullscreen_set) (Ecore_Evas *ee, int on);
+   void (*fn_avoid_damage_set) (Ecore_Evas *ee, int on);
+   void (*fn_withdrawn_set) (Ecore_Evas *ee, int withdrawn);
+   void (*fn_sticky_set) (Ecore_Evas *ee, int sticky);
+   void (*fn_ignore_events_set) (Ecore_Evas *ee, int ignore);
+   void (*fn_alpha_set) (Ecore_Evas *ee, int alpha);
+   void (*fn_transparent_set) (Ecore_Evas *ee, int transparent);
+
+   int (*fn_render) (Ecore_Evas *ee);
+   void (*fn_screen_geometry_get) (const Ecore_Evas *ee, int *x, int *y, int *w, int *h);
+};
+
+struct _Ecore_Evas_Engine
+{
+   Ecore_Evas_Engine_Func *func;
+
+/* TODO: UGLY! This should be an union or inheritance! */
+#ifdef BUILD_ECORE_EVAS_X11
+   struct 
+     {
+      Ecore_X_Window win_root;
+      Eina_List     *win_extra;
+      Ecore_X_Pixmap pmap;
+      Ecore_X_Pixmap mask;
+      Ecore_X_GC     gc;
+      Ecore_X_XRegion *damages;
+      Ecore_X_Sync_Counter sync_counter;
+      Ecore_X_Window leader;
+      Ecore_X_Sync_Counter netwm_sync_counter;
+      int            netwm_sync_val_hi;
+      unsigned int   netwm_sync_val_lo;
+      int            sync_val; // bigger! this will screw up at 2 billion frames (414 days of continual rendering @ 60fps)
+      int            screen_num;
+      int            px, py, pw, ph;
+      unsigned char  direct_resize : 1;
+      unsigned char  using_bg_pixmap : 1;
+      unsigned char  managed : 1;
+      unsigned char  sync_began : 1;
+      unsigned char  sync_cancel : 1;
+      unsigned char  netwm_sync_set : 1;
+      unsigned char  configure_coming : 1;
+      struct {
+           unsigned char modal : 1;
+           unsigned char sticky : 1;
+           unsigned char maximized_v : 1;
+           unsigned char maximized_h : 1;
+           unsigned char shaded : 1;
+           unsigned char skip_taskbar : 1;
+           unsigned char skip_pager : 1;
+           unsigned char fullscreen : 1;
+           unsigned char above : 1;
+           unsigned char below : 1;
+      } state;
+      Ecore_X_Window win_shaped_input;
+   } x;
+#endif
+#ifdef BUILD_ECORE_EVAS_FB
+   struct {
+      int real_w;
+      int real_h;
+   } fb;
+#endif
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_BUFFER
+   struct {
+      void *pixels;
+      Evas_Object *image;
+      void  (*free_func) (void *data, void *pix);
+      void *(*alloc_func) (void *data, int size);
+      void *data;
+   } buffer;
+#endif
+#ifdef BUILD_ECORE_EVAS_DIRECTFB
+   struct {
+      Ecore_DirectFB_Window *window;
+   } directfb;
+#endif
+#ifdef BUILD_ECORE_EVAS_WIN32
+   struct {
+      Ecore_Win32_Window *parent;
+      struct {
+         unsigned char region     : 1;
+         unsigned char fullscreen : 1;
+      } state;
+   } win32;
+#endif
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_WINCE
+   struct {
+      Ecore_WinCE_Window *window;
+      struct {
+         unsigned char fullscreen : 1;
+      } state;
+   } wince;
+#endif
+#ifdef BUILD_ECORE_EVAS_EWS
+   struct {
+      Evas_Object *image;
+   } ews;
+#endif
+
+   Ecore_Timer *idle_flush_timer;
+};
+
+struct _Ecore_Evas
+{
+   EINA_INLIST;
+   ECORE_MAGIC;
+   Evas       *evas;
+   const char *driver;
+   char       *name;
+   int         x, y, w, h;
+   short       rotation;
+   Eina_Bool   shaped  : 1;
+   Eina_Bool   visible : 1;
+   Eina_Bool   draw_ok : 1;
+   Eina_Bool   should_be_visible : 1;
+   Eina_Bool   alpha  : 1;
+   Eina_Bool   transparent  : 1;
+
+   Eina_Hash  *data;
+
+   struct {
+      int      x, y, w, h;
+   } req;
+   
+   struct {
+      int      x, y;
+   } mouse;
+
+   struct {
+      int      w, h;
+   } expecting_resize;
+
+   struct {
+      char           *title;
+      char           *name;
+      char           *clas;
+      struct {
+         int          w, h;
+      } min,
+        max,
+        base,
+        step;
+      struct {
+         Evas_Object *object;
+         int          layer;
+         struct {
+            int       x, y;
+         } hot;
+      } cursor;
+      int             layer;
+      Ecore_Window    window;
+      unsigned char   avoid_damage;
+      char            focused      : 1;
+      char            iconified    : 1;
+      char            borderless   : 1;
+      char            override     : 1;
+      char            maximized    : 1;
+      char            fullscreen   : 1;
+      char            withdrawn    : 1;
+      char            sticky       : 1;
+      char            request_pos  : 1;
+   } prop;
+
+   struct {
+      void          (*fn_resize) (Ecore_Evas *ee);
+      void          (*fn_move) (Ecore_Evas *ee);
+      void          (*fn_show) (Ecore_Evas *ee);
+      void          (*fn_hide) (Ecore_Evas *ee);
+      void          (*fn_delete_request) (Ecore_Evas *ee);
+      void          (*fn_destroy) (Ecore_Evas *ee);
+      void          (*fn_focus_in) (Ecore_Evas *ee);
+      void          (*fn_focus_out) (Ecore_Evas *ee);
+      void          (*fn_sticky) (Ecore_Evas *ee);
+      void          (*fn_unsticky) (Ecore_Evas *ee);
+      void          (*fn_mouse_in) (Ecore_Evas *ee);
+      void          (*fn_mouse_out) (Ecore_Evas *ee);
+      void          (*fn_pre_render) (Ecore_Evas *ee);
+      void          (*fn_post_render) (Ecore_Evas *ee);
+      void          (*fn_pre_free) (Ecore_Evas *ee);
+   } func;
+
+   Ecore_Evas_Engine engine;
+   Eina_List *sub_ecore_evas;
+
+   int refcount;
+
+   unsigned char ignore_events : 1;
+   unsigned char manual_render : 1;
+   unsigned char registered : 1;
+   unsigned char no_comp_sync  : 1;
+   unsigned char semi_sync  : 1;
+   unsigned char deleted : 1;
+};
+
+void _ecore_evas_ref(Ecore_Evas *ee);
+void _ecore_evas_unref(Ecore_Evas *ee);
+
+#ifdef BUILD_ECORE_EVAS_X11
+int _ecore_evas_x_shutdown(void);
+#endif
+#ifdef BUILD_ECORE_EVAS_FB
+int _ecore_evas_fb_shutdown(void);
+#endif
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_BUFFER
+int _ecore_evas_buffer_shutdown(void);
+int _ecore_evas_buffer_render(Ecore_Evas *ee);
+#endif
+#ifdef BUILD_ECORE_EVAS_DIRECTFB
+int _ecore_evas_directfb_shutdown(void);
+#endif
+#ifdef BUILD_ECORE_EVAS_WIN32
+int _ecore_evas_win32_shutdown(void);
+#endif
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_WINCE
+int _ecore_evas_wince_shutdown(void);
+#endif
+#ifdef BUILD_ECORE_EVAS_EWS
+void _ecore_evas_ews_events_init(void);
+int _ecore_evas_ews_shutdown(void);
+#endif
+
+void _ecore_evas_fps_debug_init(void);
+void _ecore_evas_fps_debug_shutdown(void);
+void _ecore_evas_fps_debug_rendertime_add(double t);
+void _ecore_evas_register(Ecore_Evas *ee);
+void _ecore_evas_free(Ecore_Evas *ee);
+void _ecore_evas_idle_timeout_update(Ecore_Evas *ee);
+void _ecore_evas_mouse_move_process(Ecore_Evas *ee, int x, int y, unsigned int timestamp);
+void _ecore_evas_mouse_multi_move_process(Ecore_Evas *ee, int device,
+                                          int x, int y,
+                                          double radius,
+                                          double radius_x, double radius_y,
+                                          double pressure,
+                                          double angle,
+                                          double mx, double my,
+                                          unsigned int timestamp);
+void _ecore_evas_mouse_multi_down_process(Ecore_Evas *ee, int device,
+                                          int x, int y,
+                                          double radius,
+                                          double radius_x, double radius_y,
+                                          double pressure,
+                                          double angle,
+                                          double mx, double my,
+                                          Evas_Button_Flags flags,
+                                          unsigned int timestamp);
+void _ecore_evas_mouse_multi_up_process(Ecore_Evas *ee, int device,
+                                        int x, int y,
+                                        double radius,
+                                        double radius_x, double radius_y,
+                                        double pressure,
+                                        double angle,
+                                        double mx, double my,
+                                        Evas_Button_Flags flags,
+                                        unsigned int timestamp);
+
+extern Eina_Bool _ecore_evas_app_comp_sync;
+
+#endif
diff --git a/libraries/ecore/src/lib/ecore_evas/ecore_evas_psl1ght.c b/libraries/ecore/src/lib/ecore_evas/ecore_evas_psl1ght.c
new file mode 100644
index 0000000..0849c79
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/ecore_evas_psl1ght.c
@@ -0,0 +1,476 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <Ecore.h>
+#include <Ecore_Input.h>
+#include <Ecore_Input_Evas.h>
+
+#include "ecore_evas_private.h"
+#include "Ecore_Evas.h"
+
+#ifdef BUILD_ECORE_EVAS_PSL1GHT
+#include <Ecore_Psl1ght.h>
+#include <Evas_Engine_PSL1GHT.h>
+
+static int _ecore_evas_init_count = 0;
+
+static Ecore_Evas *psl1ght_ee = NULL;
+static Ecore_Event_Handler *ecore_evas_event_handlers[4] = {
+   NULL, NULL, NULL, NULL
+};
+
+static const char *ecore_evas_psl1ght_default = "EFL PSL1GHT";
+static int _ecore_evas_fps_debug = 0;
+static Ecore_Poller *ecore_evas_event;
+
+static unsigned int
+_ecore_evas_time_get()
+{
+   return (unsigned long long)(ecore_time_get() * 1000.0) & 0xffffffff;
+}
+
+static Ecore_Evas *
+_ecore_evas_psl1ght_match(void)
+{
+   return psl1ght_ee;
+}
+
+static Eina_Bool
+_ecore_evas_psl1ght_event_got_focus(void *data __UNUSED__, int type __UNUSED__, void *event __UNUSED__)
+{
+   Ecore_Evas *ee;
+
+   ee = _ecore_evas_psl1ght_match();
+
+   if (!ee) return ECORE_CALLBACK_PASS_ON;
+   /* pass on event */
+   ee->prop.focused = 1;
+   evas_focus_in(ee->evas);
+   if (ee->func.fn_focus_in) ee->func.fn_focus_in(ee);
+   
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_psl1ght_event_lost_focus(void *data __UNUSED__, int type __UNUSED__, void *event __UNUSED__)
+{
+   Ecore_Evas *ee;
+
+   ee = _ecore_evas_psl1ght_match();
+
+   if (!ee) return ECORE_CALLBACK_PASS_ON;
+   /* pass on event */
+   evas_focus_out(ee->evas);
+   ee->prop.focused = 0;
+   if (ee->func.fn_focus_out) ee->func.fn_focus_out(ee);
+   
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_psl1ght_event_video_expose(void *data __UNUSED__, int type __UNUSED__, void *event __UNUSED__)
+{
+   Ecore_Evas *ee;
+   int w;
+   int h;
+
+   ee = _ecore_evas_psl1ght_match();
+
+   if (!ee) return ECORE_CALLBACK_PASS_ON;
+   evas_output_size_get(ee->evas, &w, &h);
+   evas_damage_rectangle_add(ee->evas, 0, 0, w, h);
+
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_psl1ght_event_key_modifiers(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_Psl1ght_Event_Key_Modifiers *e = event;
+
+   ee = _ecore_evas_psl1ght_match();
+
+   if (!ee) return ECORE_CALLBACK_PASS_ON;
+   ecore_event_evas_modifier_lock_update(ee->evas, e->modifiers);
+
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static int
+_ecore_evas_render(Ecore_Evas *ee)
+{
+   Eina_List *updates;
+
+   updates = evas_render_updates(ee->evas);
+   if (updates)
+     {
+        evas_render_updates_free(updates);
+        _ecore_evas_idle_timeout_update(ee);
+     }
+   return updates ? 1 : 0;
+}
+
+static int
+_ecore_evas_psl1ght_render(Ecore_Evas *ee)
+{
+   int rend = 0;
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_BUFFER
+   Eina_List *ll;
+   Ecore_Evas *ee2;
+
+   EINA_LIST_FOREACH(ee->sub_ecore_evas, ll, ee2)
+     {
+        if (ee2->func.fn_pre_render) ee2->func.fn_pre_render(ee2);
+        rend |= _ecore_evas_buffer_render(ee2);
+        if (ee2->func.fn_post_render) ee2->func.fn_post_render(ee2);
+     }
+#endif
+
+   if (ee->func.fn_pre_render) ee->func.fn_pre_render(ee);
+
+   if (ee->prop.avoid_damage) rend = _ecore_evas_render(ee);
+   else if ((ee->visible) ||
+            ((ee->should_be_visible) && (ee->prop.fullscreen)) ||
+            ((ee->should_be_visible) && (ee->prop.override)))
+     rend |= _ecore_evas_render(ee);
+   else
+     evas_norender(ee->evas);
+
+   if (ee->func.fn_post_render) ee->func.fn_post_render(ee);
+   return rend;
+}
+
+static Eina_Bool
+_ecore_evas_psl1ght_event(void *data __UNUSED__)
+{
+   ecore_psl1ght_poll_events();
+   return ECORE_CALLBACK_RENEW;
+}
+
+static int
+_ecore_evas_psl1ght_init(int w __UNUSED__, int h __UNUSED__)
+{
+   _ecore_evas_init_count++;
+   if (_ecore_evas_init_count > 1) return _ecore_evas_init_count;
+
+   _ecore_evas_fps_debug = 1;
+
+   // this is pretty bad: poller? and set poll time? pol time is meant to be
+   // adjustable for things like polling battery state, or amoutn of spare
+   // memory etc.
+   //
+   ecore_evas_event = ecore_poller_add(ECORE_POLLER_CORE, 1, _ecore_evas_psl1ght_event, NULL);
+   ecore_poller_poll_interval_set(ECORE_POLLER_CORE, 0.006);
+
+   if (_ecore_evas_fps_debug)
+     _ecore_evas_fps_debug_init();
+
+   ecore_event_evas_init();
+
+   ecore_evas_event_handlers[0] = ecore_event_handler_add(ECORE_PSL1GHT_EVENT_GOT_FOCUS, _ecore_evas_psl1ght_event_got_focus, NULL);
+   ecore_evas_event_handlers[1] = ecore_event_handler_add(ECORE_PSL1GHT_EVENT_LOST_FOCUS, _ecore_evas_psl1ght_event_lost_focus, NULL);
+   ecore_evas_event_handlers[2] = ecore_event_handler_add(ECORE_PSL1GHT_EVENT_EXPOSE, _ecore_evas_psl1ght_event_video_expose, NULL);
+   ecore_evas_event_handlers[3] = ecore_event_handler_add(ECORE_PSL1GHT_EVENT_KEY_MODIFIERS, _ecore_evas_psl1ght_event_key_modifiers, NULL);
+
+   return _ecore_evas_init_count;
+}
+
+static int
+_ecore_evas_psl1ght_shutdown(void)
+{
+   _ecore_evas_init_count--;
+   if (_ecore_evas_init_count == 0)
+     {
+        unsigned int i;
+
+        for (i = 0; i < sizeof (ecore_evas_event_handlers) / sizeof (Ecore_Event_Handler *); i++)
+          ecore_event_handler_del(ecore_evas_event_handlers[i]);
+        ecore_event_evas_shutdown();
+        ecore_poller_del(ecore_evas_event);
+        ecore_evas_event = NULL;
+        if (_ecore_evas_fps_debug)
+          _ecore_evas_fps_debug_shutdown();
+     }
+   if (_ecore_evas_init_count < 0) _ecore_evas_init_count = 0;
+   return _ecore_evas_init_count;
+}
+
+static void
+_ecore_evas_psl1ght_free(Ecore_Evas *ee)
+{
+   if (psl1ght_ee == ee) psl1ght_ee = NULL;
+
+   ecore_event_window_unregister(0);
+   _ecore_evas_psl1ght_shutdown();
+   ecore_psl1ght_shutdown();
+}
+
+static void
+_ecore_evas_screen_resized(Ecore_Evas *ee)
+{
+   int w, h;
+
+   /* Do not resize if the window is not fullscreen */
+   if (ee->prop.fullscreen == 0) return;
+
+   ecore_psl1ght_screen_resolution_get (&w, &h);
+
+   if (w != ee->w || h != ee->h)
+     {
+        ee->req.w = ee->w = w;
+        ee->req.h = ee->h = h;
+        evas_output_size_set(ee->evas, ee->w, ee->h);
+        evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+        ecore_psl1ght_resolution_set (w, h);
+        evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+
+        _ecore_evas_mouse_move_process(ee, ee->mouse.x, ee->mouse.y,
+                                       _ecore_evas_time_get());
+        if (ee->func.fn_resize) ee->func.fn_resize(ee);
+     }
+}
+
+static void
+_ecore_evas_resize(Ecore_Evas *ee, int w, int h)
+{
+   if ((w == ee->w) && (h == ee->h)) return;
+   ee->w = w;
+   ee->h = h;
+
+   evas_output_size_set(ee->evas, ee->w, ee->h);
+
+   evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+   evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+
+   ecore_psl1ght_resolution_set (w, h);
+
+   if (ee->func.fn_resize) ee->func.fn_resize(ee);
+
+   _ecore_evas_screen_resized (ee);
+}
+
+static void
+_ecore_evas_move_resize(Ecore_Evas *ee, int x __UNUSED__, int y __UNUSED__, int w, int h)
+{
+   _ecore_evas_resize (ee, w, h);
+}
+
+static void
+_ecore_evas_show(Ecore_Evas *ee)
+{
+   if (ee->prop.focused) return;
+   ee->prop.focused = 1;
+   evas_focus_in(ee->evas);
+   if (ee->func.fn_focus_in) ee->func.fn_focus_in(ee);
+}
+
+static void
+_ecore_evas_screen_geometry_get(const Ecore_Evas *ee __UNUSED__, int *x, int *y, int *w, int *h)
+{
+   if (x) *x = 0;
+   if (y) *y = 0;
+   ecore_psl1ght_screen_resolution_get (w, h);
+}
+
+static void
+_ecore_evas_object_cursor_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee;
+
+   ee = data;
+   if (ee)
+     ee->prop.cursor.object = NULL;
+}
+
+static void
+_ecore_evas_object_cursor_set(Ecore_Evas *ee, Evas_Object *obj, int layer, int hot_x, int hot_y)
+{
+   int x, y;
+
+   if (ee->prop.cursor.object) evas_object_del(ee->prop.cursor.object);
+
+   if (!obj)
+     {
+        ee->prop.cursor.object = NULL;
+        ee->prop.cursor.layer = 0;
+        ee->prop.cursor.hot.x = 0;
+        ee->prop.cursor.hot.y = 0;
+        return;
+     }
+
+   ee->prop.cursor.object = obj;
+   ee->prop.cursor.layer = layer;
+   ee->prop.cursor.hot.x = hot_x;
+   ee->prop.cursor.hot.y = hot_y;
+   evas_pointer_output_xy_get(ee->evas, &x, &y);
+   evas_object_layer_set(ee->prop.cursor.object, ee->prop.cursor.layer);
+   evas_object_move(ee->prop.cursor.object,
+                    x - ee->prop.cursor.hot.x,
+                    y - ee->prop.cursor.hot.y);
+   evas_object_pass_events_set(ee->prop.cursor.object, 1);
+   if (evas_pointer_inside_get(ee->evas))
+     evas_object_show(ee->prop.cursor.object);
+
+   evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL, _ecore_evas_object_cursor_del, ee);
+}
+
+static Ecore_Evas_Engine_Func _ecore_psl1ght_engine_func =
+{
+   _ecore_evas_psl1ght_free,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   _ecore_evas_resize,
+   _ecore_evas_move_resize,
+   NULL,
+   NULL,
+   _ecore_evas_show,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   _ecore_evas_object_cursor_set,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL, //transparent
+
+   NULL, // render
+   _ecore_evas_screen_geometry_get  // screen_geometry_get
+};
+
+EAPI Ecore_Evas *
+ecore_evas_psl1ght_new(const char *name, int w, int h)
+{
+   void *einfo;
+   Ecore_Evas *ee;
+
+   if (!name)
+     name = ecore_evas_psl1ght_default;
+
+   ee = calloc(1, sizeof(Ecore_Evas));
+   if (!ee) return NULL;
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_psl1ght_engine_func;
+
+   ee->driver = "psl1ght";
+   if (name) ee->name = strdup(name);
+
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   ee->visible = 1;
+   ee->w = w;
+   ee->h = h;
+
+   ee->prop.max.w = 0;
+   ee->prop.max.h = 0;
+   ee->prop.layer = 0;
+   ee->prop.focused = 1;
+   ee->prop.borderless = 1;
+   ee->prop.override = 1;
+   ee->prop.maximized = 1;
+   ee->prop.fullscreen = 0;
+   ee->prop.withdrawn = 0;
+   ee->prop.sticky = 0;
+   ee->prop.window = 0;
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_method_set(ee->evas, evas_render_method_lookup("psl1ght"));
+
+   evas_output_size_set(ee->evas, w, h);
+   evas_output_viewport_set(ee->evas, 0, 0, w, h);
+
+   einfo = evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             ecore_evas_free(ee);
+             return NULL;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        ecore_evas_free(ee);
+        return NULL;
+     }
+
+   if (!ecore_psl1ght_init(name))
+     {
+        evas_free(ee->evas);
+        if (ee->name) free(ee->name);
+        free(ee);
+        return NULL;
+     }
+   ecore_psl1ght_resolution_set (w, h);
+
+   _ecore_evas_psl1ght_init(w, h);
+
+   ecore_event_window_register(0, ee, ee->evas,
+                               (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                               (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                               (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                               (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+
+   ee->engine.func->fn_render = _ecore_evas_psl1ght_render;
+   _ecore_evas_register(ee);
+
+   psl1ght_ee = ee;
+
+   _ecore_evas_screen_resized (ee);
+
+   if (getenv("ECORE_EVAS_PSL1GHT_CURSOR_PATH"))
+     ecore_evas_cursor_set(ee, getenv("ECORE_EVAS_PSL1GHT_CURSOR_PATH"), EVAS_LAYER_MAX, 0, 0);
+
+   evas_event_feed_mouse_in(ee->evas, (unsigned int)((unsigned long long)(ecore_time_get() * 1000.0) & 0xffffffff), NULL);
+   
+   return ee;
+}
+
+#else /* BUILD_ECORE_EVAS_PSL1GHT */
+
+EAPI Ecore_Evas *
+ecore_evas_psl1ght_new(const char *name __UNUSED__, int w __UNUSED__, int h __UNUSED__)
+{
+   ERR("OUTCH !");
+   return NULL;
+}
+
+#endif /* BUILD_ECORE_EVAS_PSL1GHT */
diff --git a/libraries/ecore/src/lib/ecore_evas/ecore_evas_sdl.c b/libraries/ecore/src/lib/ecore_evas/ecore_evas_sdl.c
new file mode 100644
index 0000000..b333d96
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/ecore_evas_sdl.c
@@ -0,0 +1,542 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <Ecore.h>
+#include <Ecore_Input.h>
+#include <Ecore_Input_Evas.h>
+#if defined(BUILD_ECORE_EVAS_SOFTWARE_SDL) || defined(BUILD_ECORE_EVAS_OPENGL_SDL)
+# include <Ecore_Sdl.h>
+# ifdef BUILD_ECORE_EVAS_SOFTWARE_SDL
+#  include <Evas_Engine_SDL.h>
+# endif
+# ifdef BUILD_ECORE_EVAS_OPENGL_SDL
+#  include <Evas_Engine_GL_SDL.h>
+# endif
+#endif
+
+#include "ecore_evas_private.h"
+#include "Ecore_Evas.h"
+
+// fixme: 1 sdl window only at a time? seems wrong
+
+#if defined(BUILD_ECORE_EVAS_SOFTWARE_SDL) || defined(BUILD_ECORE_EVAS_OPENGL_SDL)
+
+/* static char *ecore_evas_default_display = "0"; */
+/* static Ecore_List *ecore_evas_input_devices = NULL; */
+
+static int                      _ecore_evas_init_count = 0;
+
+static Ecore_Evas               *sdl_ee = NULL;
+static Ecore_Event_Handler      *ecore_evas_event_handlers[4] = {
+   NULL, NULL, NULL, NULL
+};
+
+static const char               *ecore_evas_sdl_default = "EFL SDL";
+static int                      _ecore_evas_fps_debug = 0;
+static Ecore_Poller             *ecore_evas_event;
+
+static Ecore_Evas *
+_ecore_evas_sdl_match(void)
+{
+   return sdl_ee;
+}
+
+static Eina_Bool
+_ecore_evas_sdl_event_got_focus(void *data __UNUSED__, int type __UNUSED__, void *event __UNUSED__)
+{
+   Ecore_Evas                   *ee;
+
+   ee = _ecore_evas_sdl_match();
+
+   if (!ee) return ECORE_CALLBACK_PASS_ON;
+   /* pass on event */
+   ee->prop.focused = 1;
+   evas_focus_in(ee->evas);
+   if (ee->func.fn_focus_in) ee->func.fn_focus_in(ee);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_sdl_event_lost_focus(void *data __UNUSED__, int type __UNUSED__, void *event __UNUSED__)
+{
+   Ecore_Evas                   *ee;
+
+   ee = _ecore_evas_sdl_match();
+
+   if (!ee) return ECORE_CALLBACK_PASS_ON;
+   /* pass on event */
+   ee->prop.focused = 0;
+   evas_focus_out(ee->evas);
+   if (ee->func.fn_focus_out) ee->func.fn_focus_out(ee);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_sdl_event_video_resize(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Sdl_Event_Video_Resize *e;
+   Ecore_Evas                   *ee;
+
+   e = event;
+   ee = _ecore_evas_sdl_match();
+
+   if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+   evas_output_size_set(ee->evas, e->w, e->h);
+
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_sdl_event_video_expose(void *data __UNUSED__, int type __UNUSED__, void *event __UNUSED__)
+{
+   Ecore_Evas                   *ee;
+   int                          w;
+   int                          h;
+
+   ee = _ecore_evas_sdl_match();
+
+   if (!ee) return ECORE_CALLBACK_PASS_ON;
+   evas_output_size_get(ee->evas, &w, &h);
+   evas_damage_rectangle_add(ee->evas, 0, 0, w, h);
+
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static int
+_ecore_evas_render(Ecore_Evas *ee)
+{
+   Eina_List *updates;
+
+   updates = evas_render_updates(ee->evas);
+   if (updates)
+     {
+        evas_render_updates_free(updates);
+        _ecore_evas_idle_timeout_update(ee);
+     }
+   return updates ? 1 : 0;
+}
+
+static int
+_ecore_evas_sdl_render(Ecore_Evas *ee)
+{
+   int rend = 0;
+   Eina_List *ll;
+   Ecore_Evas *ee2;
+
+   EINA_LIST_FOREACH(ee->sub_ecore_evas, ll, ee2)
+     {
+        if (ee2->func.fn_pre_render) ee2->func.fn_pre_render(ee2);
+        if (ee2->engine.func->fn_render)
+          rend |= ee2->engine.func->fn_render(ee2);
+        if (ee2->func.fn_post_render) ee2->func.fn_post_render(ee2);
+     }
+
+   if (ee->func.fn_pre_render) ee->func.fn_pre_render(ee);
+
+   if (ee->prop.avoid_damage) rend = _ecore_evas_render(ee);
+   else if ((ee->visible) ||
+            ((ee->should_be_visible) && (ee->prop.fullscreen)) ||
+            ((ee->should_be_visible) && (ee->prop.override)))
+     rend |= _ecore_evas_render(ee);
+   else
+     evas_norender(ee->evas);
+
+   if (ee->func.fn_post_render) ee->func.fn_post_render(ee);
+   return rend;
+}
+
+static Eina_Bool
+_ecore_evas_sdl_event(void *data __UNUSED__)
+{
+   ecore_sdl_feed_events();
+   return ECORE_CALLBACK_RENEW;
+}
+
+static int
+_ecore_evas_sdl_init(int w __UNUSED__, int h __UNUSED__)
+{
+   _ecore_evas_init_count++;
+   if (_ecore_evas_init_count > 1) return _ecore_evas_init_count;
+
+#ifndef _WIN32
+   if (getenv("ECORE_EVAS_FPS_DEBUG")) _ecore_evas_fps_debug = 1;
+#endif /* _WIN32 */
+   // this is pretty bad: poller? and set poll time? pol time is meant to be
+   // adjustable for things like polling battery state, or amoutn of spare
+   // memory etc.
+   //
+   ecore_evas_event = ecore_poller_add(ECORE_POLLER_CORE, 1, _ecore_evas_sdl_event, NULL);
+   ecore_poller_poll_interval_set(ECORE_POLLER_CORE, 0.006);
+#ifndef _WIN32
+   if (_ecore_evas_fps_debug) _ecore_evas_fps_debug_init();
+#endif /* _WIN32 */
+
+   ecore_event_evas_init();
+
+   ecore_evas_event_handlers[0] = ecore_event_handler_add(ECORE_SDL_EVENT_GOT_FOCUS, _ecore_evas_sdl_event_got_focus, NULL);
+   ecore_evas_event_handlers[1] = ecore_event_handler_add(ECORE_SDL_EVENT_LOST_FOCUS, _ecore_evas_sdl_event_lost_focus, NULL);
+   ecore_evas_event_handlers[2] = ecore_event_handler_add(ECORE_SDL_EVENT_RESIZE, _ecore_evas_sdl_event_video_resize, NULL);
+   ecore_evas_event_handlers[3] = ecore_event_handler_add(ECORE_SDL_EVENT_EXPOSE, _ecore_evas_sdl_event_video_expose, NULL);
+
+   return _ecore_evas_init_count;
+}
+
+static int
+_ecore_evas_sdl_shutdown(void)
+{
+   _ecore_evas_init_count--;
+   if (_ecore_evas_init_count == 0)
+     {
+        int i;
+
+        for (i = 0; i < sizeof (ecore_evas_event_handlers) / sizeof (Ecore_Event_Handler*); i++)
+          ecore_event_handler_del(ecore_evas_event_handlers[i]);
+        ecore_event_evas_shutdown();
+        ecore_poller_del(ecore_evas_event);
+        ecore_evas_event = NULL;
+#ifndef _WIN32
+        if (_ecore_evas_fps_debug) _ecore_evas_fps_debug_shutdown();
+#endif /* _WIN32 */
+     }
+   if (_ecore_evas_init_count < 0) _ecore_evas_init_count = 0;
+   return _ecore_evas_init_count;
+}
+
+static void
+_ecore_evas_sdl_free(Ecore_Evas *ee)
+{
+   if (sdl_ee == ee) sdl_ee = NULL;
+
+   ecore_event_window_unregister(0);
+   _ecore_evas_sdl_shutdown();
+   ecore_sdl_shutdown();
+}
+
+static void
+_ecore_evas_resize(Ecore_Evas *ee, int w, int h)
+{
+   if ((w == ee->w) && (h == ee->h)) return;
+   ee->w = w;
+   ee->h = h;
+
+   evas_output_size_set(ee->evas, ee->w, ee->h);
+   evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+   evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+
+   if (ee->func.fn_resize) ee->func.fn_resize(ee);
+}
+
+static void
+_ecore_evas_move_resize(Ecore_Evas *ee, int x __UNUSED__, int y __UNUSED__, int w, int h)
+{
+   if ((w == ee->w) && (h == ee->h)) return;
+   ee->w = w;
+   ee->h = h;
+
+   evas_output_size_set(ee->evas, ee->w, ee->h);
+   evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+   evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+
+   if (ee->func.fn_resize) ee->func.fn_resize(ee);
+}
+
+static void
+_ecore_evas_show(Ecore_Evas *ee)
+{
+   if (ee->prop.focused) return;
+   ee->prop.focused = 1;
+   evas_event_feed_mouse_in(ee->evas, (unsigned int)((unsigned long long)(ecore_time_get() * 1000.0) & 0xffffffff), NULL);
+}
+
+static void
+_ecore_evas_object_cursor_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee;
+
+   ee = data;
+   if (ee) ee->prop.cursor.object = NULL;
+}
+
+static void
+_ecore_evas_object_cursor_set(Ecore_Evas *ee, Evas_Object *obj, int layer, int hot_x, int hot_y)
+{
+   int x, y;
+
+   if (ee->prop.cursor.object) evas_object_del(ee->prop.cursor.object);
+
+   if (!obj)
+     {
+        ee->prop.cursor.object = NULL;
+        ee->prop.cursor.layer = 0;
+        ee->prop.cursor.hot.x = 0;
+        ee->prop.cursor.hot.y = 0;
+        return;
+     }
+
+   ee->prop.cursor.object = obj;
+   ee->prop.cursor.layer = layer;
+   ee->prop.cursor.hot.x = hot_x;
+   ee->prop.cursor.hot.y = hot_y;
+   evas_pointer_output_xy_get(ee->evas, &x, &y);
+   evas_object_layer_set(ee->prop.cursor.object, ee->prop.cursor.layer);
+   evas_object_move(ee->prop.cursor.object,
+                    x - ee->prop.cursor.hot.x,
+                    y - ee->prop.cursor.hot.y);
+   evas_object_pass_events_set(ee->prop.cursor.object, 1);
+   if (evas_pointer_inside_get(ee->evas))
+     evas_object_show(ee->prop.cursor.object);
+
+   evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL, _ecore_evas_object_cursor_del, ee);
+}
+
+static Ecore_Evas_Engine_Func _ecore_sdl_engine_func =
+{
+   _ecore_evas_sdl_free,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   _ecore_evas_resize,
+   _ecore_evas_move_resize,
+   NULL,
+   NULL,
+   _ecore_evas_show,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   _ecore_evas_object_cursor_set,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL, //transparent
+
+   NULL, // render
+   NULL  // screen_geometry_get
+};
+
+static Ecore_Evas*
+_ecore_evas_internal_sdl_new(int rmethod, const char* name, int w, int h, int fullscreen, int hwsurface, int noframe, int alpha)
+{
+   void                 *einfo;
+   Ecore_Evas           *ee;
+
+   if (!name)
+     name = ecore_evas_sdl_default;
+
+   ee = calloc(1, sizeof(Ecore_Evas));
+   if (!ee) return NULL;
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_sdl_engine_func;
+
+   ee->driver = "sdl";
+   if (name) ee->name = strdup(name);
+
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   ee->visible = 1;
+   ee->w = w;
+   ee->h = h;
+
+   ee->prop.max.w = 0;
+   ee->prop.max.h = 0;
+   ee->prop.layer = 0;
+   ee->prop.focused = 1;
+   ee->prop.borderless = 1;
+   ee->prop.override = 1;
+   ee->prop.maximized = 1;
+   ee->prop.fullscreen = fullscreen;
+   ee->prop.withdrawn = 0;
+   ee->prop.sticky = 0;
+   ee->prop.window = 0;
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_method_set(ee->evas, rmethod);
+
+   evas_output_size_set(ee->evas, w, h);
+   evas_output_viewport_set(ee->evas, 0, 0, w, h);
+
+   if (rmethod == evas_render_method_lookup("software_sdl") ||
+       rmethod == evas_render_method_lookup("software_16_sdl") )
+     {
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_SDL
+        einfo = evas_engine_info_get(ee->evas);
+        if (einfo)
+          {
+             ((Evas_Engine_Info_SDL *)einfo)->info.rotation = 0;
+             ((Evas_Engine_Info_SDL *)einfo)->info.fullscreen = fullscreen;
+             ((Evas_Engine_Info_SDL *)einfo)->info.hwsurface = hwsurface;
+             ((Evas_Engine_Info_SDL *)einfo)->info.noframe = noframe;
+             ((Evas_Engine_Info_SDL *)einfo)->info.alpha = alpha;
+             if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+               {
+                  ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                  ecore_evas_free(ee);
+                  return NULL;
+               }
+          }
+        else
+          {
+             ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+             ecore_evas_free(ee);
+             return NULL;
+          }
+#endif
+     }
+   else if (rmethod == evas_render_method_lookup("gl_sdl"))
+     {
+#ifdef BUILD_ECORE_EVAS_OPENGL_SDL
+        einfo = evas_engine_info_get(ee->evas);
+        if (einfo)
+          {
+             ((Evas_Engine_Info_GL_SDL *)einfo)->flags.fullscreen = fullscreen;
+             ((Evas_Engine_Info_GL_SDL *)einfo)->flags.noframe = noframe;
+             if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+               {
+                  ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                  ecore_evas_free(ee);
+                  return NULL;
+               }
+          }
+        else
+          {
+             ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+             ecore_evas_free(ee);
+             return NULL;
+          }
+#endif
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        ecore_evas_free(ee);
+        return NULL;
+     }
+
+   if (!ecore_sdl_init(name))
+     {
+        evas_free(ee->evas);
+        if (ee->name) free(ee->name);
+        free(ee);
+        return NULL;
+     }
+
+   _ecore_evas_sdl_init(w, h);
+
+   ecore_event_window_register(0, ee, ee->evas,
+                               (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                               (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                               (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                               (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+
+   SDL_ShowCursor(SDL_DISABLE);
+
+   ee->engine.func->fn_render = _ecore_evas_sdl_render;
+   _ecore_evas_register(ee);
+
+   sdl_ee = ee;
+   return ee;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_SDL
+EAPI Ecore_Evas*
+ecore_evas_sdl_new(const char* name, int w, int h, int fullscreen, int hwsurface, int noframe, int alpha)
+{
+   Ecore_Evas          *ee;
+   int                  rmethod;
+
+   rmethod = evas_render_method_lookup("software_sdl");
+   if (!rmethod) return NULL;
+
+   ee = _ecore_evas_internal_sdl_new(rmethod, name, w, h, fullscreen, hwsurface, noframe, alpha);
+   ee->driver = "sdl";
+   return ee;
+}
+#else
+EAPI Ecore_Evas*
+ecore_evas_sdl_new(const char* name __UNUSED__, int w __UNUSED__, int h __UNUSED__, int fullscreen __UNUSED__, int hwsurface __UNUSED__, int noframe __UNUSED__, int alpha __UNUSED__)
+{
+   ERR("OUTCH !");
+   return NULL;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_SDL
+EAPI Ecore_Evas*
+ecore_evas_sdl16_new(const char* name, int w, int h, int fullscreen, int hwsurface, int noframe, int alpha)
+{
+   Ecore_Evas          *ee;
+   int                  rmethod;
+
+   rmethod = evas_render_method_lookup("software_16_sdl");
+   if (!rmethod) return NULL;
+
+   ee = _ecore_evas_internal_sdl_new(rmethod, name, w, h, fullscreen, hwsurface, noframe, alpha);
+   ee->driver = "software_16_sdl";
+   return ee;
+}
+#else
+EAPI Ecore_Evas*
+ecore_evas_sdl16_new(const char* name __UNUSED__, int w __UNUSED__, int h __UNUSED__, int fullscreen __UNUSED__, int hwsurface __UNUSED__, int noframe __UNUSED__, int alpha __UNUSED__)
+{
+   ERR("OUTCH !");
+   return NULL;
+}
+#endif
+
+#ifdef BUILD_ECORE_EVAS_OPENGL_SDL
+EAPI Ecore_Evas*
+ecore_evas_gl_sdl_new(const char* name, int w, int h, int fullscreen, int noframe)
+{
+   Ecore_Evas          *ee;
+   int                  rmethod;
+
+   rmethod = evas_render_method_lookup("gl_sdl");
+   if (!rmethod) return NULL;
+
+   ee = _ecore_evas_internal_sdl_new(rmethod, name, w, h, fullscreen, 0, noframe, 0);
+   ee->driver = "gl_sdl";
+   return ee;
+}
+#else
+EAPI Ecore_Evas*
+ecore_evas_gl_sdl_new(const char* name __UNUSED__, int w __UNUSED__, int h __UNUSED__, int fullscreen __UNUSED__, int noframe __UNUSED__)
+{
+   ERR("OUTCH !");
+   return NULL;
+}
+#endif
+
diff --git a/libraries/ecore/src/lib/ecore_evas/ecore_evas_util.c b/libraries/ecore/src/lib/ecore_evas/ecore_evas_util.c
new file mode 100644
index 0000000..95b6d22
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/ecore_evas_util.c
@@ -0,0 +1,437 @@
+#ifdef HAVE_CONFIG_H
+# include <config.h>
+#endif
+
+#include <string.h>
+
+#include <Ecore.h>
+#include "ecore_private.h"
+
+#include "ecore_evas_private.h"
+#include "Ecore_Evas.h"
+
+static const char ASSOCIATE_KEY[] = "__Ecore_Evas_Associate";
+
+static void _ecore_evas_object_associate(Ecore_Evas *ee, Evas_Object *obj, Ecore_Evas_Object_Associate_Flags flags);
+static void _ecore_evas_object_dissociate(Ecore_Evas *ee, Evas_Object *obj);
+
+
+static Evas_Object *
+_ecore_evas_associate_get(const Ecore_Evas *ee)
+{
+   return ecore_evas_data_get(ee, ASSOCIATE_KEY);
+}
+
+static void
+_ecore_evas_associate_set(Ecore_Evas *ee, Evas_Object *obj)
+{
+   ecore_evas_data_set(ee, ASSOCIATE_KEY, obj);
+}
+
+static void
+_ecore_evas_associate_del(Ecore_Evas *ee)
+{
+   ecore_evas_data_set(ee, ASSOCIATE_KEY, NULL);
+}
+
+static Ecore_Evas *
+_evas_object_associate_get(const Evas_Object *obj)
+{
+   return evas_object_data_get(obj, ASSOCIATE_KEY);
+}
+
+static void
+_evas_object_associate_set(Evas_Object *obj, Ecore_Evas *ee)
+{
+   evas_object_data_set(obj, ASSOCIATE_KEY, ee);
+}
+
+static void
+_evas_object_associate_del(Evas_Object *obj)
+{
+   evas_object_data_del(obj, ASSOCIATE_KEY);
+}
+
+/** Associated Events: ******************************************************/
+
+/* Interceptors Callbacks */
+
+static void
+_ecore_evas_obj_intercept_move(void *data, Evas_Object *obj, Evas_Coord x, Evas_Coord y)
+{
+   Ecore_Evas *ee = data;
+   // FIXME: account for frame
+   ecore_evas_move(ee, x, y);
+   if (ecore_evas_override_get(ee)) evas_object_move(obj, x, y);
+}
+
+static void
+_ecore_evas_obj_intercept_raise(void *data, Evas_Object *obj __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   ecore_evas_raise(ee);
+}
+
+static void
+_ecore_evas_obj_intercept_lower(void *data, Evas_Object *obj __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   ecore_evas_lower(ee);
+}
+
+static void
+_ecore_evas_obj_intercept_stack_above(void *data __UNUSED__, Evas_Object *obj __UNUSED__, Evas_Object *above __UNUSED__)
+{
+   INF("TODO: %s", __FUNCTION__);
+}
+
+static void
+_ecore_evas_obj_intercept_stack_below(void *data __UNUSED__, Evas_Object *obj __UNUSED__, Evas_Object *below __UNUSED__)
+{
+   INF("TODO: %s", __FUNCTION__);
+}
+
+static void
+_ecore_evas_obj_intercept_layer_set(void *data, Evas_Object *obj __UNUSED__, int l)
+{
+   Ecore_Evas *ee = data;
+   ecore_evas_layer_set(ee, l);
+}
+
+/* Event Callbacks */
+
+static void
+_ecore_evas_obj_callback_show(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   ecore_evas_show(ee);
+}
+
+static void
+_ecore_evas_obj_callback_hide(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   ecore_evas_hide(ee);
+}
+
+static void
+_ecore_evas_obj_callback_resize(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   Evas_Coord ow, oh, w, h;
+
+   evas_object_geometry_get(obj, NULL, NULL, &ow, &oh);
+   ecore_evas_geometry_get(ee, NULL, NULL, &w, &h);
+   /*if ((w != ow) || (h != oh))*/ /* avoid recursion on ecore_evas_resize side */
+     ecore_evas_resize(ee, ow, oh);
+}
+
+static void
+_ecore_evas_obj_callback_changed_size_hints(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   Evas_Coord w, h;
+
+   evas_object_size_hint_min_get(obj, &w, &h);
+   ecore_evas_size_min_set(ee, w, h);
+
+   evas_object_size_hint_max_get(obj, &w, &h);
+   if (w < 1) w = -1;
+   if (h < 1) h = -1;
+   ecore_evas_size_max_set(ee, w, h);
+}
+
+static void
+_ecore_evas_obj_callback_del(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   _ecore_evas_object_dissociate(ee, obj);
+   ecore_evas_free(ee);
+}
+
+static void
+_ecore_evas_obj_callback_del_dissociate(void *data, Evas *e __UNUSED__, Evas_Object *obj, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+   _ecore_evas_object_dissociate(ee, obj);
+}
+
+static void
+_ecore_evas_delete_request(Ecore_Evas *ee)
+{
+   Evas_Object *obj = _ecore_evas_associate_get(ee);
+   _ecore_evas_object_dissociate(ee, obj);
+   evas_object_del(obj);
+   ecore_evas_free(ee);
+}
+
+static void
+_ecore_evas_destroy(Ecore_Evas *ee)
+{
+   Evas_Object *obj = _ecore_evas_associate_get(ee);
+   if (!obj)
+     return;
+   _ecore_evas_object_dissociate(ee, obj);
+   evas_object_del(obj);
+}
+
+static void
+_ecore_evas_resize(Ecore_Evas *ee)
+{
+   Evas_Object *obj = _ecore_evas_associate_get(ee);
+   Evas_Coord w, h;
+   ecore_evas_geometry_get(ee, NULL, NULL, &w, &h);
+   evas_object_resize(obj, w, h);
+}
+
+static void
+_ecore_evas_pre_free(Ecore_Evas *ee)
+{
+   Evas_Object *obj = _ecore_evas_associate_get(ee);
+   if (!obj)
+     return;
+   _ecore_evas_object_dissociate(ee, obj);
+   evas_object_del(obj);
+}
+
+static int
+_ecore_evas_object_evas_check(const char *function, const Ecore_Evas *ee, const Evas_Object *obj)
+{
+   const char *name, *type;
+   Evas *e;
+
+   e = evas_object_evas_get(obj);
+   if (e == ee->evas)
+     return 1;
+
+   name = evas_object_name_get(obj);
+   type = evas_object_type_get(obj);
+
+   ERR("ERROR: %s(): object %p (name=\"%s\", type=\"%s\") evas "
+       "is not the same as this Ecore_Evas evas: %p != %p",
+       function, obj,
+       name ? name : "", type ? type : "", e, ee->evas);
+   fflush(stderr);
+   if (getenv("ECORE_ERROR_ABORT")) abort();
+
+   return 0;
+}
+
+EAPI Eina_Bool
+ecore_evas_object_associate(Ecore_Evas *ee, Evas_Object *obj, Ecore_Evas_Object_Associate_Flags flags)
+{
+   Ecore_Evas *old_ee;
+   Evas_Object *old_obj;
+
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+   {
+      ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS, __FUNCTION__);
+      return EINA_FALSE;
+   }
+
+   CHECK_PARAM_POINTER_RETURN("obj", obj, EINA_FALSE);
+   if (!_ecore_evas_object_evas_check(__FUNCTION__, ee, obj))
+     return EINA_FALSE;
+
+   old_ee = _evas_object_associate_get(obj);;
+   if (old_ee)
+     ecore_evas_object_dissociate(old_ee, obj);
+
+   old_obj = _ecore_evas_associate_get(ee);
+   if (old_obj)
+     ecore_evas_object_dissociate(ee, old_obj);
+
+   _ecore_evas_object_associate(ee, obj, flags);
+   return EINA_TRUE;
+}
+
+EAPI Eina_Bool
+ecore_evas_object_dissociate(Ecore_Evas *ee, Evas_Object *obj)
+{
+   Ecore_Evas *old_ee;
+   Evas_Object *old_obj;
+
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+   {
+      ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS, __FUNCTION__);
+      return EINA_FALSE;
+   }
+
+   CHECK_PARAM_POINTER_RETURN("obj", obj, EINA_FALSE);
+   old_ee = _evas_object_associate_get(obj);
+   if (ee != old_ee) {
+      ERR("ERROR: trying to dissociate object that is not using "
+          "this Ecore_Evas: %p != %p", ee, old_ee);
+      return EINA_FALSE;
+   }
+
+   old_obj = _ecore_evas_associate_get(ee);
+   if (old_obj != obj) {
+      ERR("ERROR: trying to dissociate object that is not being "
+          "used by this Ecore_Evas: %p != %p", old_obj, obj);
+      return EINA_FALSE;
+   }
+
+   _ecore_evas_object_dissociate(ee, obj);
+
+   return EINA_TRUE;
+}
+
+EAPI Evas_Object *
+ecore_evas_object_associate_get(const Ecore_Evas *ee)
+{
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+   {
+      ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS, __FUNCTION__);
+      return NULL;
+   }
+   return _ecore_evas_associate_get(ee);
+}
+
+static void
+_ecore_evas_object_associate(Ecore_Evas *ee, Evas_Object *obj, Ecore_Evas_Object_Associate_Flags flags)
+{
+   evas_object_event_callback_add
+     (obj, EVAS_CALLBACK_SHOW,
+      _ecore_evas_obj_callback_show, ee);
+   evas_object_event_callback_add
+     (obj, EVAS_CALLBACK_HIDE,
+      _ecore_evas_obj_callback_hide, ee);
+   evas_object_event_callback_add
+     (obj, EVAS_CALLBACK_RESIZE,
+      _ecore_evas_obj_callback_resize, ee);
+   evas_object_event_callback_add
+     (obj, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
+      _ecore_evas_obj_callback_changed_size_hints, ee);
+   if (flags & ECORE_EVAS_OBJECT_ASSOCIATE_DEL)
+     evas_object_event_callback_add
+       (obj, EVAS_CALLBACK_DEL, _ecore_evas_obj_callback_del, ee);
+   else
+     evas_object_event_callback_add
+       (obj, EVAS_CALLBACK_DEL, _ecore_evas_obj_callback_del_dissociate, ee);
+
+   evas_object_intercept_move_callback_add
+     (obj, _ecore_evas_obj_intercept_move, ee);
+
+   if (flags & ECORE_EVAS_OBJECT_ASSOCIATE_STACK)
+     {
+        evas_object_intercept_raise_callback_add
+          (obj, _ecore_evas_obj_intercept_raise, ee);
+        evas_object_intercept_lower_callback_add
+          (obj, _ecore_evas_obj_intercept_lower, ee);
+        evas_object_intercept_stack_above_callback_add
+          (obj, _ecore_evas_obj_intercept_stack_above, ee);
+        evas_object_intercept_stack_below_callback_add
+          (obj, _ecore_evas_obj_intercept_stack_below, ee);
+     }
+
+   if (flags & ECORE_EVAS_OBJECT_ASSOCIATE_LAYER)
+     evas_object_intercept_layer_set_callback_add
+       (obj, _ecore_evas_obj_intercept_layer_set, ee);
+
+   if (flags & ECORE_EVAS_OBJECT_ASSOCIATE_DEL)
+     {
+        ecore_evas_callback_delete_request_set(ee, _ecore_evas_delete_request);
+        ecore_evas_callback_destroy_set(ee, _ecore_evas_destroy);
+     }
+   ecore_evas_callback_pre_free_set(ee, _ecore_evas_pre_free);
+   ecore_evas_callback_resize_set(ee, _ecore_evas_resize);
+
+   _evas_object_associate_set(obj, ee);
+   _ecore_evas_associate_set(ee, obj);
+}
+
+static void
+_ecore_evas_object_dissociate(Ecore_Evas *ee, Evas_Object *obj)
+{
+   evas_object_event_callback_del_full
+     (obj, EVAS_CALLBACK_SHOW,
+      _ecore_evas_obj_callback_show, ee);
+   evas_object_event_callback_del_full
+     (obj, EVAS_CALLBACK_HIDE,
+      _ecore_evas_obj_callback_hide, ee);
+   evas_object_event_callback_del_full
+     (obj, EVAS_CALLBACK_RESIZE,
+      _ecore_evas_obj_callback_resize, ee);
+   evas_object_event_callback_del_full
+     (obj, EVAS_CALLBACK_CHANGED_SIZE_HINTS,
+      _ecore_evas_obj_callback_changed_size_hints, ee);
+   evas_object_event_callback_del_full
+     (obj, EVAS_CALLBACK_DEL, _ecore_evas_obj_callback_del, ee);
+   evas_object_event_callback_del_full
+     (obj, EVAS_CALLBACK_DEL, _ecore_evas_obj_callback_del_dissociate, ee);
+
+   evas_object_intercept_move_callback_del
+     (obj, _ecore_evas_obj_intercept_move);
+
+   evas_object_intercept_raise_callback_del
+     (obj, _ecore_evas_obj_intercept_raise);
+   evas_object_intercept_lower_callback_del
+     (obj, _ecore_evas_obj_intercept_lower);
+   evas_object_intercept_stack_above_callback_del
+     (obj, _ecore_evas_obj_intercept_stack_above);
+   evas_object_intercept_stack_below_callback_del
+     (obj, _ecore_evas_obj_intercept_stack_below);
+
+   evas_object_intercept_layer_set_callback_del
+     (obj, _ecore_evas_obj_intercept_layer_set);
+
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+   {
+      ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS, __FUNCTION__);
+   }
+   else
+   {
+      if (ee->func.fn_delete_request == _ecore_evas_delete_request)
+        ecore_evas_callback_delete_request_set(ee, NULL);
+      if (ee->func.fn_destroy == _ecore_evas_destroy)
+        ecore_evas_callback_destroy_set(ee, NULL);
+      if (ee->func.fn_resize == _ecore_evas_resize)
+        ecore_evas_callback_resize_set(ee, NULL);
+      if (ee->func.fn_pre_free == _ecore_evas_pre_free)
+        ecore_evas_callback_pre_free_set(ee, NULL);
+
+      _ecore_evas_associate_del(ee);
+   }
+
+   _evas_object_associate_del(obj);
+}
+
+/**
+ * Helper ecore_getopt callback to list available Ecore_Evas engines.
+ *
+ * This will list all available engines except buffer, this is useful
+ * for applications to let user choose how they should create windows
+ * with ecore_evas_new().
+ *
+ * @c callback_data value is used as @c FILE* and says where to output
+ * messages, by default it is @c stdout. You can specify this value
+ * with ECORE_GETOPT_CALLBACK_FULL() or ECORE_GETOPT_CALLBACK_ARGS().
+ *
+ * If there is a boolean storage provided, then it is marked with 1
+ * when this option is executed.
+ */
+unsigned char
+ecore_getopt_callback_ecore_evas_list_engines(const Ecore_Getopt *parser __UNUSED__, const Ecore_Getopt_Desc *desc __UNUSED__, const char *str __UNUSED__, void *data, Ecore_Getopt_Value *storage)
+{
+   Eina_List  *lst, *n;
+   const char *engine;
+   FILE *fp = data;
+
+   if (!fp)
+     fp = stdout;
+
+   lst = ecore_evas_engines_get();
+
+   fputs("supported engines:\n", fp);
+   EINA_LIST_FOREACH(lst, n, engine)
+     if (strcmp(engine, "buffer") != 0)
+       fprintf(fp, "\t%s\n", engine);
+
+   ecore_evas_engines_free(lst);
+
+   if (storage->boolp)
+     *storage->boolp = 1;
+
+   return 1;
+}
diff --git a/libraries/ecore/src/lib/ecore_evas/ecore_evas_win32.c b/libraries/ecore/src/lib/ecore_evas/ecore_evas_win32.c
new file mode 100644
index 0000000..2ca7cb0
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/ecore_evas_win32.c
@@ -0,0 +1,1451 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdlib.h> /* for NULL */
+
+#include <Ecore.h>
+#include "ecore_private.h"
+#ifdef BUILD_ECORE_EVAS_WIN32
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
+# undef WIN32_LEAN_AND_MEAN
+# include <Ecore_Win32.h>
+# include <ecore_win32_private.h>
+#endif /* BUILD_ECORE_EVAS_WIN32 */
+
+#include "ecore_evas_private.h"
+#include "Ecore_Evas.h"
+
+#ifdef BUILD_ECORE_EVAS_WIN32
+
+#define ECORE_EVAS_EVENT_COUNT 10
+
+static int _ecore_evas_init_count = 0;
+
+static Ecore_Event_Handler *ecore_evas_event_handlers[ECORE_EVAS_EVENT_COUNT];
+
+static Eina_Bool _ecore_evas_win32_event_mouse_in(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_win32_event_mouse_out(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_win32_event_window_focus_in(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_win32_event_window_focus_out(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_win32_event_window_damage(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_win32_event_window_destroy(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_win32_event_window_show(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_win32_event_window_hide(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_win32_event_window_configure(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_win32_event_window_delete_request(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+/* Private functions */
+
+static int
+_ecore_evas_win32_render(Ecore_Evas *ee)
+{
+   int rend = 0;
+   Eina_List *updates = NULL;
+   Eina_List *ll;
+   Ecore_Evas *ee2;
+
+   EINA_LIST_FOREACH(ee->sub_ecore_evas, ll, ee2)
+     {
+        if (ee2->func.fn_pre_render) ee2->func.fn_pre_render(ee2);
+        if (ee2->engine.func->fn_render)
+          rend |= ee2->engine.func->fn_render(ee2);
+        if (ee2->func.fn_post_render) ee2->func.fn_post_render(ee2);
+     }
+
+   if (ee->func.fn_pre_render) ee->func.fn_pre_render(ee);
+   if (ee->prop.avoid_damage)
+     {
+        updates = evas_render_updates(ee->evas);
+        if (updates) evas_render_updates_free(updates);
+     }
+   else if ((ee->visible) ||
+            ((ee->should_be_visible) && (ee->prop.fullscreen)) ||
+            ((ee->should_be_visible) && (ee->prop.override)))
+     {
+        if (ee->shaped)
+          {
+             updates = evas_render_updates(ee->evas);
+             if (updates) evas_render_updates_free(updates);
+          }
+        else
+          {
+             updates = evas_render_updates(ee->evas);
+             if (updates) evas_render_updates_free(updates);
+          }
+     }
+   else
+     evas_norender(ee->evas);
+   if (updates) rend = 1;
+   if (ee->func.fn_post_render) ee->func.fn_post_render(ee);
+   return rend;
+}
+
+static int
+_ecore_evas_win32_init(void)
+{
+   _ecore_evas_init_count++;
+   if (_ecore_evas_init_count > 1)
+     return _ecore_evas_init_count;
+
+   ecore_evas_event_handlers[0]  = ecore_event_handler_add(ECORE_WIN32_EVENT_MOUSE_IN, _ecore_evas_win32_event_mouse_in, NULL);
+   ecore_evas_event_handlers[1]  = ecore_event_handler_add(ECORE_WIN32_EVENT_MOUSE_OUT, _ecore_evas_win32_event_mouse_out, NULL);
+   ecore_evas_event_handlers[2]  = ecore_event_handler_add(ECORE_WIN32_EVENT_WINDOW_FOCUS_IN, _ecore_evas_win32_event_window_focus_in, NULL);
+   ecore_evas_event_handlers[3]  = ecore_event_handler_add(ECORE_WIN32_EVENT_WINDOW_FOCUS_OUT, _ecore_evas_win32_event_window_focus_out, NULL);
+   ecore_evas_event_handlers[4]  = ecore_event_handler_add(ECORE_WIN32_EVENT_WINDOW_DAMAGE, _ecore_evas_win32_event_window_damage, NULL);
+   ecore_evas_event_handlers[5]  = ecore_event_handler_add(ECORE_WIN32_EVENT_WINDOW_DESTROY, _ecore_evas_win32_event_window_destroy, NULL);
+   ecore_evas_event_handlers[6]  = ecore_event_handler_add(ECORE_WIN32_EVENT_WINDOW_SHOW, _ecore_evas_win32_event_window_show, NULL);
+   ecore_evas_event_handlers[7]  = ecore_event_handler_add(ECORE_WIN32_EVENT_WINDOW_HIDE, _ecore_evas_win32_event_window_hide, NULL);
+   ecore_evas_event_handlers[8]  = ecore_event_handler_add(ECORE_WIN32_EVENT_WINDOW_CONFIGURE, _ecore_evas_win32_event_window_configure, NULL);
+   ecore_evas_event_handlers[9]  = ecore_event_handler_add(ECORE_WIN32_EVENT_WINDOW_DELETE_REQUEST, _ecore_evas_win32_event_window_delete_request, NULL);
+
+   ecore_event_evas_init();
+   return _ecore_evas_init_count;
+}
+
+int
+_ecore_evas_win32_shutdown(void)
+{
+   _ecore_evas_init_count--;
+   if (_ecore_evas_init_count == 0)
+     {
+        int i;
+
+        for (i = 0; i < ECORE_EVAS_EVENT_COUNT; i++)
+          ecore_event_handler_del(ecore_evas_event_handlers[i]);
+        ecore_event_evas_shutdown();
+     }
+
+   if (_ecore_evas_init_count < 0) _ecore_evas_init_count = 0;
+
+   return _ecore_evas_init_count;
+}
+
+static Eina_Bool
+_ecore_evas_win32_event_mouse_in(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                 *ee;
+   Ecore_Win32_Event_Mouse_In *e;
+
+   INF("mouse in");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if ((!ee) || (ee->ignore_events)) return 1; /* pass on event */
+   if ((Ecore_Window)e->window != ee->prop.window) return 1;
+
+   if (ee->func.fn_mouse_in) ee->func.fn_mouse_in(ee);
+   /* FIXME to do */
+/*    _ecore_evas_x_modifier_locks_update(ee, e->modifiers); */
+   evas_event_feed_mouse_in(ee->evas, e->time, NULL);
+   evas_focus_in(ee->evas);
+   _ecore_evas_mouse_move_process(ee, e->x, e->y, e->time);
+
+   return 1;
+}
+
+static Eina_Bool
+_ecore_evas_win32_event_mouse_out(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                  *ee;
+   Ecore_Win32_Event_Mouse_Out *e;
+
+   INF("mouse out");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if ((!ee) || (ee->ignore_events)) return 1; /* pass on event */
+   if ((Ecore_Window)e->window != ee->prop.window) return 1;
+
+   /* FIXME to do */
+/*    _ecore_evas_x_modifier_locks_update(ee, e->modifiers); */
+   _ecore_evas_mouse_move_process(ee, e->x, e->y, e->time);
+
+   evas_event_feed_mouse_out(ee->evas, e->time, NULL);
+   if (ee->func.fn_mouse_out) ee->func.fn_mouse_out(ee);
+   if (ee->prop.cursor.object) evas_object_hide(ee->prop.cursor.object);
+
+   return 1;
+}
+
+static Eina_Bool
+_ecore_evas_win32_event_window_focus_in(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_Win32_Event_Window_Focus_In *e;
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON;
+   if ((Ecore_Window)e->window != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+
+   ee->prop.focused = 1;
+   evas_focus_in(ee->evas);
+   if (ee->func.fn_focus_in) ee->func.fn_focus_in(ee);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_win32_event_window_focus_out(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_Win32_Event_Window_Focus_Out *e;
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON;
+   if ((Ecore_Window)e->window != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+
+   evas_focus_out(ee->evas);
+   ee->prop.focused = 0;
+   if (ee->func.fn_focus_out) ee->func.fn_focus_out(ee);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_win32_event_window_damage(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                      *ee;
+   Ecore_Win32_Event_Window_Damage *e;
+
+   INF("window damage");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if (!ee) return 1; /* pass on event */
+   if ((Ecore_Window)e->window != ee->prop.window) return 1;
+
+   if (ee->prop.avoid_damage)
+     {
+#ifdef _MSC_VER
+# pragma message ("[ECORE] [WIN32] No Region code")
+#else
+# warning [ECORE] [WIN32] No Region code
+#endif /* ! _MSC_VER */
+     }
+   else
+     {
+        if (ee->rotation == 0)
+          evas_damage_rectangle_add(ee->evas,
+                                    e->x,
+                                    e->y,
+                                    e->width,
+                                    e->height);
+        else if (ee->rotation == 90)
+          evas_damage_rectangle_add(ee->evas,
+                                    ee->h - e->y - e->height,
+                                    e->x,
+                                    e->height,
+                                    e->width);
+        else if (ee->rotation == 180)
+          evas_damage_rectangle_add(ee->evas,
+                                    ee->w - e->x - e->width,
+                                    ee->h - e->y - e->height,
+                                    e->width,
+                                    e->height);
+        else if (ee->rotation == 270)
+          evas_damage_rectangle_add(ee->evas,
+                                    e->y,
+                                    ee->w - e->x - e->width,
+                                    e->height,
+                                    e->width);
+     }
+
+   return 1;
+}
+
+static Eina_Bool
+_ecore_evas_win32_event_window_destroy(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                       *ee;
+   Ecore_Win32_Event_Window_Destroy *e;
+
+   INF("window destroy");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if (!ee) return 1; /* pass on event */
+   if ((Ecore_Window)e->window != ee->prop.window) return 1;
+   if (ee->func.fn_destroy) ee->func.fn_destroy(ee);
+   ecore_evas_free(ee);
+
+   return 1;
+}
+
+static Eina_Bool
+_ecore_evas_win32_event_window_show(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                    *ee;
+   Ecore_Win32_Event_Window_Show *e;
+
+   INF("window show");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if (!ee) return 1; /* pass on event */
+   if ((Ecore_Window)e->window != ee->prop.window) return 1;
+   if (ee->visible) return 0; /* dont pass it on */
+   ee->visible = 1;
+   if (ee->func.fn_show) ee->func.fn_show(ee);
+
+   return 1;
+}
+
+static Eina_Bool
+_ecore_evas_win32_event_window_hide(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                    *ee;
+   Ecore_Win32_Event_Window_Hide *e;
+
+   INF("window hide");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if (!ee) return 1; /* pass on event */
+   if ((Ecore_Window)e->window != ee->prop.window) return 1;
+   if (!ee->visible) return 0; /* dont pass it on */
+   ee->visible = 0;
+   if (ee->func.fn_hide) ee->func.fn_hide(ee);
+
+   return 1;
+}
+
+static Eina_Bool
+_ecore_evas_win32_event_window_configure(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                         *ee;
+   Ecore_Win32_Event_Window_Configure *e;
+
+   INF("window configure");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if (!ee) return 1; /* pass on event */
+   if ((Ecore_Window)e->window != ee->prop.window) return 1;
+
+   if ((ee->x != e->x) || (ee->y != e->y))
+     {
+        ee->x = e->x;
+        ee->y = e->y;
+        ee->req.x = ee->x;
+        ee->req.y = ee->y;
+
+        if (ee->func.fn_move) ee->func.fn_move(ee);
+     }
+
+   if ((ee->w != e->width) || (ee->h != e->height))
+     {
+        ee->w = e->width;
+        ee->h = e->height;
+        ee->req.w = ee->w;
+        ee->req.h = ee->h;
+
+        if ((ee->rotation == 90) || (ee->rotation == 270))
+          {
+             evas_output_size_set(ee->evas, ee->h, ee->w);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+          }
+        else
+          {
+             evas_output_size_set(ee->evas, ee->w, ee->h);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+          }
+        if (ee->prop.avoid_damage)
+          {
+             int pdam;
+
+             pdam = ecore_evas_avoid_damage_get(ee);
+             ecore_evas_avoid_damage_set(ee, 0);
+             ecore_evas_avoid_damage_set(ee, pdam);
+          }
+/*         if (ee->shaped) */
+/*           _ecore_evas_win32_region_border_resize(ee); */
+        if ((ee->expecting_resize.w > 0) &&
+            (ee->expecting_resize.h > 0))
+          {
+             if ((ee->expecting_resize.w == ee->w) &&
+                 (ee->expecting_resize.h == ee->h))
+               _ecore_evas_mouse_move_process(ee, ee->mouse.x, ee->mouse.y,
+                                              ecore_win32_current_time_get());
+             ee->expecting_resize.w = 0;
+             ee->expecting_resize.h = 0;
+          }
+        if (ee->func.fn_resize) ee->func.fn_resize(ee);
+     }
+
+   return 1;
+}
+
+static Eina_Bool
+_ecore_evas_win32_event_window_delete_request(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                              *ee;
+   Ecore_Win32_Event_Window_Delete_Request *e;
+
+   INF("window delete request");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if (!ee) return 1; /* pass on event */
+   if ((Ecore_Window)e->window != ee->prop.window) return 1;
+   if (ee->func.fn_delete_request) ee->func.fn_delete_request(ee);
+
+   INF(" * ee event delete\n");
+   return 1;
+}
+
+
+/* Ecore_Evas interface */
+
+static void
+_ecore_evas_win32_free(Ecore_Evas *ee)
+{
+   INF("ecore evas free");
+
+   ecore_win32_window_free((struct _Ecore_Win32_Window *)ee->prop.window);
+   ecore_event_window_unregister(ee->prop.window);
+   _ecore_evas_win32_shutdown();
+   ecore_win32_shutdown();
+}
+
+static void
+_ecore_evas_win32_callback_delete_request_set(Ecore_Evas *ee,
+                                              void (*func) (Ecore_Evas *ee))
+{
+   ee->func.fn_delete_request = func;
+}
+
+static void
+_ecore_evas_win32_move(Ecore_Evas *ee, int x, int y)
+{
+  INF("ecore evas move (%dx%d)", x, y);
+   ee->req.x = x;
+   ee->req.y = y;
+
+   if ((x != ee->x) || (y != ee->y))
+     {
+        ee->x = x;
+        ee->y = y;
+        ecore_win32_window_move((struct _Ecore_Win32_Window *)ee->prop.window,
+                                x, y);
+        if (ee->func.fn_move) ee->func.fn_move(ee);
+     }
+}
+
+static void
+_ecore_evas_win32_resize(Ecore_Evas *ee, int width, int height)
+{
+   INF("ecore evas resize (%dx%d)", width, height);
+   ee->req.w = width;
+   ee->req.h = height;
+
+   if ((ee->w != width) || (ee->h != height))
+     {
+        ee->w = width;
+        ee->h = height;
+        ecore_win32_window_resize((struct _Ecore_Win32_Window *)ee->prop.window,
+                                  width, height);
+        if ((ee->rotation == 90) || (ee->rotation == 270))
+          {
+             evas_output_size_set(ee->evas, ee->h, ee->w);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+          }
+        else
+          {
+             evas_output_size_set(ee->evas, ee->w, ee->h);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+          }
+        if (ee->prop.avoid_damage)
+          {
+             int pdam;
+
+             pdam = ecore_evas_avoid_damage_get(ee);
+             ecore_evas_avoid_damage_set(ee, 0);
+             ecore_evas_avoid_damage_set(ee, pdam);
+          }
+/*         if ((ee->shaped) || (ee->alpha)) */
+/*           _ecore_evas_win32_region_border_resize(ee); */
+        if (ee->func.fn_resize) ee->func.fn_resize(ee);
+     }
+}
+
+static void
+_ecore_evas_win32_move_resize(Ecore_Evas *ee, int x, int y, int width, int height)
+{
+   INF("ecore evas resize (%dx%d %dx%d)", x, y, width, height);
+   ee->req.x = x;
+   ee->req.y = y;
+   ee->req.w = width;
+   ee->req.h = height;
+
+   if ((ee->w != width) || (ee->h != height) || (x != ee->x) || (y != ee->y))
+     {
+        int change_size = 0;
+        int change_pos = 0;
+
+        if ((ee->w != width) || (ee->h != height)) change_size = 1;
+        if ((x != ee->x) || (y != ee->y)) change_pos = 1;
+
+        ee->x = x;
+        ee->y = y;
+        ee->w = width;
+        ee->h = height;
+        ecore_win32_window_move_resize((struct _Ecore_Win32_Window *)ee->prop.window,
+                                       x, y, width, height);
+        if ((ee->rotation == 90) || (ee->rotation == 270))
+          {
+             evas_output_size_set(ee->evas, ee->h, ee->w);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+          }
+        else
+          {
+             evas_output_size_set(ee->evas, ee->w, ee->h);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+          }
+        if (ee->prop.avoid_damage)
+          {
+             int pdam;
+
+             pdam = ecore_evas_avoid_damage_get(ee);
+             ecore_evas_avoid_damage_set(ee, 0);
+             ecore_evas_avoid_damage_set(ee, pdam);
+          }
+/*         if ((ee->shaped) || (ee->alpha)) */
+/*           _ecore_evas_win32_region_border_resize(ee); */
+        if (change_pos)
+          {
+             if (ee->func.fn_move) ee->func.fn_move(ee);
+          }
+        if (change_size)
+          {
+             if (ee->func.fn_resize) ee->func.fn_resize(ee);
+          }
+     }
+}
+
+static void
+_ecore_evas_win32_rotation_set_internal(Ecore_Evas *ee, int rotation)
+{
+   int rot_dif;
+
+   rot_dif = ee->rotation - rotation;
+   if (rot_dif < 0) rot_dif = -rot_dif;
+
+   if (rot_dif != 180)
+     {
+        int minw, minh, maxw, maxh, basew, baseh, stepw, steph;
+
+        if (!ee->prop.fullscreen)
+          {
+             ecore_win32_window_resize((struct _Ecore_Win32_Window *)ee->prop.window,
+                                       ee->h, ee->w);
+             ee->expecting_resize.w = ee->h;
+             ee->expecting_resize.h = ee->w;
+          }
+        else
+          {
+             int w, h;
+
+             ecore_win32_window_size_get((struct _Ecore_Win32_Window *)ee->prop.window,
+                                         &w, &h);
+             ecore_win32_window_resize((struct _Ecore_Win32_Window *)ee->prop.window,
+                                       h, w);
+             if ((rotation == 0) || (rotation == 180))
+               {
+                  evas_output_size_set(ee->evas, ee->w, ee->h);
+                  evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+               }
+             else
+               {
+                  evas_output_size_set(ee->evas, ee->h, ee->w);
+                  evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+               }
+             if (ee->func.fn_resize) ee->func.fn_resize(ee);
+          }
+        ecore_evas_size_min_get(ee, &minw, &minh);
+        ecore_evas_size_max_get(ee, &maxw, &maxh);
+        ecore_evas_size_base_get(ee, &basew, &baseh);
+        ecore_evas_size_step_get(ee, &stepw, &steph);
+        ee->rotation = rotation;
+        ecore_evas_size_min_set(ee, minh, minw);
+        ecore_evas_size_max_set(ee, maxh, maxw);
+        ecore_evas_size_base_set(ee, baseh, basew);
+        ecore_evas_size_step_set(ee, steph, stepw);
+        _ecore_evas_mouse_move_process(ee, ee->mouse.x, ee->mouse.y,
+                                       ecore_win32_current_time_get());
+     }
+   else
+     {
+        ee->rotation = rotation;
+        _ecore_evas_mouse_move_process(ee, ee->mouse.x, ee->mouse.y,
+                                       ecore_win32_current_time_get());
+        if (ee->func.fn_resize) ee->func.fn_resize(ee);
+     }
+
+   if ((ee->rotation == 90) || (ee->rotation == 270))
+     evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
+   else
+     evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+}
+
+static void
+_ecore_evas_win32_rotation_set(Ecore_Evas *ee, int rotation, int resize)
+{
+   INF("ecore evas rotation: %s", rotation ? "yes" : "no");
+
+   if (ee->rotation == rotation) return;
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_GDI
+   if (!strcmp(ee->driver, "software_gdi"))
+     {
+        Evas_Engine_Info_Software_Gdi *einfo;
+
+        einfo = (Evas_Engine_Info_Software_Gdi *)evas_engine_info_get(ee->evas);
+        if (!einfo) return;
+        einfo->info.rotation = rotation;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+        _ecore_evas_win32_rotation_set_internal(ee, rotation);
+     }
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_GDI */
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_DDRAW
+   if (!strcmp(ee->driver, "software_ddraw"))
+     {
+        Evas_Engine_Info_Software_DDraw *einfo;
+
+        einfo = (Evas_Engine_Info_Software_DDraw *)evas_engine_info_get(ee->evas);
+        if (!einfo) return;
+        einfo->info.rotation = rotation;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+        _ecore_evas_win32_rotation_set_internal(ee, rotation);
+     }
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_DDRAW */
+}
+
+static void
+_ecore_evas_win32_shaped_set(Ecore_Evas *ee, int shaped)
+{
+   if (((ee->shaped) && (shaped)) || ((!ee->shaped) && (!shaped)))
+     return;
+
+   if (!strcmp(ee->driver, "software_ddraw")) return;
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_GDI
+   if (!strcmp(ee->driver, "software_gdi"))
+     {
+        Evas_Engine_Info_Software_Gdi *einfo;
+
+        einfo = (Evas_Engine_Info_Software_Gdi *)evas_engine_info_get(ee->evas);
+        ee->shaped = shaped;
+        if (einfo)
+          {
+             ee->engine.win32.state.region = ee->shaped;
+             einfo->info.region = ee->engine.win32.state.region;
+             if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+               {
+                  ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+               }
+             if (ee->shaped)
+               evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+          }
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_GDI */
+     }
+}
+
+static void
+_ecore_evas_win32_show(Ecore_Evas *ee)
+{
+   INF("ecore evas show");
+
+   ee->should_be_visible = 1;
+   if (ee->prop.avoid_damage)
+     _ecore_evas_win32_render(ee);
+   ecore_win32_window_show((struct _Ecore_Win32_Window *)ee->prop.window);
+/*    if (ee->prop.fullscreen) */
+/*      ecore_win32_window_focus(ee->prop.window); */
+}
+
+static void
+_ecore_evas_win32_hide(Ecore_Evas *ee)
+{
+   INF("ecore evas hide");
+
+   ecore_win32_window_hide((struct _Ecore_Win32_Window *)ee->prop.window);
+   ee->should_be_visible = 0;
+}
+
+static void
+_ecore_evas_win32_raise(Ecore_Evas *ee)
+{
+   INF("ecore evas raise");
+
+   if (!ee->prop.fullscreen)
+     ecore_win32_window_raise((struct _Ecore_Win32_Window *)ee->prop.window);
+   else
+     ecore_win32_window_raise((struct _Ecore_Win32_Window *)ee->prop.window);
+}
+
+static void
+_ecore_evas_win32_lower(Ecore_Evas *ee)
+{
+   INF("ecore evas lower");
+
+   if (!ee->prop.fullscreen)
+     ecore_win32_window_lower((struct _Ecore_Win32_Window *)ee->prop.window);
+   else
+     ecore_win32_window_lower((struct _Ecore_Win32_Window *)ee->prop.window);
+}
+
+static void
+_ecore_evas_win32_activate(Ecore_Evas *ee)
+{
+   INF("ecore evas activate");
+
+   ecore_win32_window_focus_set((struct _Ecore_Win32_Window *)ee->prop.window);
+}
+
+static void
+_ecore_evas_win32_title_set(Ecore_Evas *ee, const char *title)
+{
+   INF("ecore evas title set");
+
+   if (ee->prop.title) free(ee->prop.title);
+   ee->prop.title = NULL;
+   if (title) ee->prop.title = strdup(title);
+   ecore_win32_window_title_set((struct _Ecore_Win32_Window *)ee->prop.window,
+                                ee->prop.title);
+}
+
+static void
+_ecore_evas_win32_size_min_set(Ecore_Evas *ee, int width, int height)
+{
+   if (width < 0) width = 0;
+   if (height < 0) height = 0;
+   if ((ee->prop.min.w == width) && (ee->prop.min.h == height)) return;
+   ee->prop.min.w = width;
+   ee->prop.min.h = height;
+   ecore_win32_window_size_min_set((struct _Ecore_Win32_Window *)ee->prop.window,
+                                   width, height);
+}
+
+static void
+_ecore_evas_win32_size_max_set(Ecore_Evas *ee, int width, int height)
+{
+   if (width < 0) width = 0;
+   if (height < 0) height = 0;
+   if ((ee->prop.max.w == width) && (ee->prop.max.h == height)) return;
+   ee->prop.max.w = width;
+   ee->prop.max.h = height;
+   ecore_win32_window_size_max_set((struct _Ecore_Win32_Window *)ee->prop.window,
+                                   width, height);
+}
+
+static void
+_ecore_evas_win32_size_base_set(Ecore_Evas *ee, int width, int height)
+{
+   if (width < 0) width = 0;
+   if (height < 0) height = 0;
+   if ((ee->prop.base.w == width) && (ee->prop.base.h == height)) return;
+   ee->prop.base.w = width;
+   ee->prop.base.h = height;
+   ecore_win32_window_size_base_set((struct _Ecore_Win32_Window *)ee->prop.window,
+                                    width, height);
+}
+
+static void
+_ecore_evas_win32_size_step_set(Ecore_Evas *ee, int width, int height)
+{
+   if (width < 1) width = 1;
+   if (height < 1) height = 1;
+   if ((ee->prop.step.w == width) && (ee->prop.step.h == height)) return;
+   ee->prop.step.w = width;
+   ee->prop.step.h = height;
+   ecore_win32_window_size_step_set((struct _Ecore_Win32_Window *)ee->prop.window,
+                                    width, height);
+}
+
+static void
+_ecore_evas_win32_cursor_set(Ecore_Evas *ee, Evas_Object *obj, int layer, int hot_x, int hot_y)
+{
+#if 0
+   int x, y;
+
+   if (ee->prop.cursor.object) evas_object_del(ee->prop.cursor.object);
+
+   if (obj == NULL)
+     {
+        ee->prop.cursor.object = NULL;
+        ee->prop.cursor.layer = 0;
+        ee->prop.cursor.hot.x = 0;
+        ee->prop.cursor.hot.y = 0;
+        ecore_win32_window_cursor_show(ee->prop.window, 1);
+        return;
+     }
+
+   ee->prop.cursor.object = obj;
+   ee->prop.cursor.layer = layer;
+   ee->prop.cursor.hot.x = hot_x;
+   ee->prop.cursor.hot.y = hot_y;
+
+   ecore_win32_window_cursor_show(ee->prop.window, 0);
+
+   evas_pointer_output_xy_get(ee->evas, &x, &y);
+   evas_object_layer_set(ee->prop.cursor.object, ee->prop.cursor.layer);
+   evas_object_move(ee->prop.cursor.object,
+                    x - ee->prop.cursor.hot.x,
+                    y - ee->prop.cursor.hot.y);
+   evas_object_pass_events_set(ee->prop.cursor.object, 1);
+   if (evas_pointer_inside_get(ee->evas))
+     evas_object_show(ee->prop.cursor.object);
+#endif
+}
+
+static void
+_ecore_evas_win32_focus_set(Ecore_Evas *ee, int on __UNUSED__)
+{
+   ecore_win32_window_focus_set((struct _Ecore_Win32_Window *)ee->prop.window);
+}
+
+static void
+_ecore_evas_win32_iconified_set(Ecore_Evas *ee, int on)
+{
+/*    if (((ee->prop.borderless) && (on)) || */
+/*        ((!ee->prop.borderless) && (!on))) return; */
+   ee->prop.iconified = on;
+   ecore_win32_window_iconified_set((struct _Ecore_Win32_Window *)ee->prop.window,
+                                    ee->prop.iconified);
+}
+
+static void
+_ecore_evas_win32_borderless_set(Ecore_Evas *ee, int on)
+{
+   if (((ee->prop.borderless) && (on)) ||
+       ((!ee->prop.borderless) && (!on))) return;
+   ee->prop.borderless = on;
+   ecore_win32_window_borderless_set((struct _Ecore_Win32_Window *)ee->prop.window,
+                                     ee->prop.borderless);
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_GDI
+   if (!strcmp(ee->driver, "software_gdi"))
+     {
+        Evas_Engine_Info_Software_Gdi *einfo;
+
+        einfo = (Evas_Engine_Info_Software_Gdi *)evas_engine_info_get(ee->evas);
+        if (einfo)
+          {
+            einfo->info.borderless = ee->prop.borderless;
+             if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+               {
+                  ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+               }
+             if (ee->prop.borderless)
+               evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+          }
+     }
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_GDI */
+}
+
+static void
+_ecore_evas_win32_fullscreen_set(Ecore_Evas *ee, int on)
+{
+   struct _Ecore_Win32_Window *window;
+
+   INF("ecore evas fullscreen set");
+
+   if ((ee->engine.win32.state.fullscreen && on) ||
+      (!ee->engine.win32.state.fullscreen && !on))
+     return;
+
+   ee->engine.win32.state.fullscreen = on;
+   ee->prop.fullscreen = on;
+
+   window = (struct _Ecore_Win32_Window *)ee->prop.window;
+
+   if (on != 0)
+   {
+      ecore_win32_window_shape_set((struct _Ecore_Win32_Window *)ee->prop.window,
+                                   0, 0, NULL);
+      ecore_win32_window_fullscreen_set((struct _Ecore_Win32_Window *)ee->prop.window,
+                                        on);
+   }
+   else
+   {
+      ecore_win32_window_fullscreen_set(window, on);
+      ecore_win32_window_shape_set(window,
+                                   window->shape.width,
+                                   window->shape.height,
+                                   window->shape.mask);
+   }
+
+   /* Nothing to be done for the GDI backend at the evas level */
+
+#ifdef BUILD_ECORE_EVAS_SOFTWRE_DDRAW
+   if (strcmp(ee->driver, "software_ddraw") == 0)
+     {
+        Evas_Engine_Info_Software_DDraw *einfo;
+
+        einfo = (Evas_Engine_Info_Software_DDraw *)evas_engine_info_get(ecore_evas_get(ee));
+        if (einfo)
+          {
+             einfo->info.fullscreen = !!on;
+/*           einfo->info.layered = window->shape.layered; */
+             if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+               {
+                  ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+               }
+          }
+     }
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_DDRAW */
+
+#ifdef BUILD_ECORE_EVAS_DIRECT3D
+   if (strcmp(ee->driver, "direct3d") == 0)
+     {
+        Evas_Engine_Info_Direct3D *einfo;
+
+        einfo = (Evas_Engine_Info_Direct3D *)evas_engine_info_get(ecore_evas_get(ee));
+        if (einfo)
+          {
+             einfo->info.fullscreen = !!on;
+             einfo->info.layered = window->shape.layered;
+             if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+               {
+                  ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+               }
+          }
+     }
+#endif /* BUILD_ECORE_EVAS_DIRECT3D */
+}
+
+
+static Ecore_Evas_Engine_Func _ecore_win32_engine_func =
+{
+   _ecore_evas_win32_free,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     _ecore_evas_win32_callback_delete_request_set,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     _ecore_evas_win32_move,
+     NULL,
+     _ecore_evas_win32_resize,
+     _ecore_evas_win32_move_resize,
+     _ecore_evas_win32_rotation_set,
+     _ecore_evas_win32_shaped_set,
+     _ecore_evas_win32_show,
+     _ecore_evas_win32_hide,
+     _ecore_evas_win32_raise,
+     _ecore_evas_win32_lower,
+     _ecore_evas_win32_activate,
+     _ecore_evas_win32_title_set,
+     NULL, /* _ecore_evas_x_name_class_set */
+     _ecore_evas_win32_size_min_set,
+     _ecore_evas_win32_size_max_set,
+     _ecore_evas_win32_size_base_set,
+     _ecore_evas_win32_size_step_set,
+     _ecore_evas_win32_cursor_set,
+     NULL, /* _ecore_evas_x_layer_set */
+     _ecore_evas_win32_focus_set,
+     _ecore_evas_win32_iconified_set,
+     _ecore_evas_win32_borderless_set,
+     NULL, /* _ecore_evas_x_override_set */
+     NULL,
+     _ecore_evas_win32_fullscreen_set,
+     NULL, /* _ecore_evas_x_avoid_damage_set */
+     NULL, /* _ecore_evas_x_withdrawn_set */
+     NULL, /* _ecore_evas_x_sticky_set */
+     NULL, /* _ecore_evas_x_ignore_events_set */
+     NULL,  /* _ecore_evas_x_alpha_set */
+     NULL, //transparent
+
+     NULL, // render
+     NULL  //screen_geometry_get
+};
+
+#endif /* BUILD_ECORE_EVAS_WIN32 */
+
+/* API */
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_GDI
+static int
+_ecore_evas_engine_software_gdi_init(Ecore_Evas *ee)
+{
+   Evas_Engine_Info_Software_Gdi *einfo;
+   const char                    *driver;
+   int                            rmethod;
+
+   driver = "software_gdi";
+
+   rmethod = evas_render_method_lookup(driver);
+   if (!rmethod)
+     return 0;
+
+   ee->driver = driver;
+   evas_output_method_set(ee->evas, rmethod);
+
+   einfo = (Evas_Engine_Info_Software_Gdi *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        /* FIXME: REDRAW_DEBUG missing for now */
+        einfo->info.window = ((struct _Ecore_Win32_Window *)ee->prop.window)->window;
+        einfo->info.depth = ecore_win32_screen_depth_get();
+        einfo->info.rotation = 0;
+        einfo->info.borderless = 0;
+        einfo->info.fullscreen = 0;
+        einfo->info.region = 0;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             return 0;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        return 0;
+     }
+
+   return 1;
+}
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_GDI */
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_DDRAW
+static int
+_ecore_evas_engine_software_ddraw_init(Ecore_Evas *ee)
+{
+   Evas_Engine_Info_Software_DDraw *einfo;
+   const char                      *driver;
+   int                              rmethod;
+
+   driver = "software_ddraw";
+
+   rmethod = evas_render_method_lookup(driver);
+   if (!rmethod)
+     return 0;
+
+   ee->driver = driver;
+   evas_output_method_set(ee->evas, rmethod);
+
+   einfo = (Evas_Engine_Info_Software_DDraw *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        /* FIXME: REDRAW_DEBUG missing for now */
+        einfo->info.window = ((struct _Ecore_Win32_Window *)ee->prop.window)->window;
+        einfo->info.depth = ecore_win32_screen_depth_get();
+        einfo->info.rotation = 0;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             return 0;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        return 0;
+     }
+
+   return 1;
+}
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_DDRAW */
+
+#ifdef BUILD_ECORE_EVAS_DIRECT3D
+static int
+_ecore_evas_engine_direct3d_init(Ecore_Evas *ee)
+{
+   Evas_Engine_Info_Direct3D *einfo;
+   const char                *driver;
+   int                        rmethod;
+
+   driver = "direct3d";
+
+   rmethod = evas_render_method_lookup(driver);
+   if (!rmethod)
+     return 0;
+
+   ee->driver = driver;
+   evas_output_method_set(ee->evas, rmethod);
+
+   einfo = (Evas_Engine_Info_Direct3D *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        /* FIXME: REDRAW_DEBUG missing for now */
+        einfo->info.window = ((struct _Ecore_Win32_Window *)ee->prop.window)->window;
+        einfo->info.depth = ecore_win32_screen_depth_get();
+        einfo->info.rotation = 0;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             return 0;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        return 0;
+     }
+
+   return 1;
+}
+#endif /* BUILD_ECORE_EVAS_DIRECT3D */
+
+#ifdef BUILD_ECORE_EVAS_OPENGL_GLEW
+static int
+_ecore_evas_engine_opengl_glew_init(Ecore_Evas *ee)
+{
+   Evas_Engine_Info_GL_Glew *einfo;
+   const char               *driver;
+   int                       rmethod;
+
+   driver = "gl_glew";
+
+   rmethod = evas_render_method_lookup(driver);
+   if (!rmethod)
+     return 0;
+
+   ee->driver = driver;
+   evas_output_method_set(ee->evas, rmethod);
+
+   einfo = (Evas_Engine_Info_GL_Glew *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        /* FIXME: REDRAW_DEBUG missing for now */
+        einfo->info.window = ((struct _Ecore_Win32_Window *)ee->prop.window)->window;
+        einfo->info.depth = ecore_win32_screen_depth_get();
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             return 0;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        return 0;
+     }
+
+   return 1;
+}
+#endif /* BUILD_ECORE_EVAS_OPENGL_GLEW */
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_DDRAW
+static int
+_ecore_evas_engine_software_16_ddraw_init(Ecore_Evas *ee)
+{
+   Evas_Engine_Info_Software_DDraw *einfo;
+   const char                      *driver;
+   int                              rmethod;
+
+   driver = "software_16_ddraw";
+
+   rmethod = evas_render_method_lookup(driver);
+   if (!rmethod)
+     return 0;
+
+   ee->driver = driver;
+   evas_output_method_set(ee->evas, rmethod);
+
+   if (ecore_win32_screen_depth_get() != 16)
+     return 0;
+
+   einfo = (Evas_Engine_Info_Software_16_DDraw *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        /* FIXME: REDRAW_DEBUG missing for now */
+        einfo->info.window = ((struct _Ecore_Win32_Window *)ee->prop.window)->window;
+        einfo->info.depth = ecore_win32_screen_depth_get();
+        einfo->info.rotation = 0;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             return 0;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        return 0;
+     }
+
+   return 1;
+}
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_16_DDRAW */
+
+#ifdef BUILD_ECORE_EVAS_WIN32
+static Ecore_Evas *
+_ecore_evas_win32_new_internal(int (*_ecore_evas_engine_init)(Ecore_Evas *ee),
+                               Ecore_Win32_Window *parent,
+                               int                 x,
+                               int                 y,
+                               int                 width,
+                               int                 height)
+{
+   Ecore_Evas *ee;
+
+   if (!ecore_win32_init())
+     return NULL;
+
+   ee = calloc(1, sizeof(Ecore_Evas));
+   if (!ee)
+     return NULL;
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+   _ecore_evas_win32_init();
+
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_win32_engine_func;
+
+   if (width < 1) width = 1;
+   if (height < 1) height = 1;
+   ee->x = x;
+   ee->y = y;
+   ee->w = width;
+   ee->h = height;
+   ee->req.x = ee->x;
+   ee->req.y = ee->y;
+   ee->req.w = ee->w;
+   ee->req.h = ee->h;
+
+   ee->prop.max.w = 32767;
+   ee->prop.max.h = 32767;
+   ee->prop.layer = 4;
+   ee->prop.request_pos = 0;
+   ee->prop.sticky = 0;
+   /* FIXME: sticky to add */
+   ee->prop.window = 0;
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_size_set(ee->evas, width, height);
+   evas_output_viewport_set(ee->evas, 0, 0, width, height);
+
+   ee->engine.win32.parent = parent;
+   ee->prop.window = (Ecore_Window)ecore_win32_window_new(parent, x, y, width, height);
+   if (!ee->prop.window)
+     {
+        _ecore_evas_win32_shutdown();
+        free(ee);
+        return NULL;
+     }
+
+   if (!_ecore_evas_engine_init(ee))
+     {
+        _ecore_evas_win32_shutdown();
+        free(ee);
+        return NULL;
+     }
+
+   ee->engine.func->fn_render = _ecore_evas_win32_render;
+   _ecore_evas_register(ee);
+   ecore_event_window_register(ee->prop.window, ee, ee->evas,
+                               (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                               (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                               (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                               (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+
+   return ee;
+}
+
+#endif /* BUILD_ECORE_EVAS_WIN32 */
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_GDI
+
+EAPI Ecore_Evas *
+ecore_evas_software_gdi_new(Ecore_Win32_Window *parent,
+                            int                 x,
+                            int                 y,
+                            int                 width,
+                            int                 height)
+{
+   return _ecore_evas_win32_new_internal(_ecore_evas_engine_software_gdi_init,
+                                         parent,
+                                         x,
+                                         y,
+                                         width,
+                                         height);
+}
+
+#else
+
+EAPI Ecore_Evas *
+ecore_evas_software_gdi_new(Ecore_Win32_Window *parent __UNUSED__,
+                            int                 x __UNUSED__,
+                            int                 y __UNUSED__,
+                            int                 width __UNUSED__,
+                            int                 height __UNUSED__)
+{
+   return NULL;
+}
+
+#endif /* ! BUILD_ECORE_EVAS_SOFTWARE_GDI */
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_DDRAW
+
+EAPI Ecore_Evas *
+ecore_evas_software_ddraw_new(Ecore_Win32_Window *parent,
+                              int                 x,
+                              int                 y,
+                              int                 width,
+                              int                 height)
+{
+   return _ecore_evas_win32_new_internal(_ecore_evas_engine_software_ddraw_init,
+                                         parent,
+                                         x,
+                                         y,
+                                         width,
+                                         height);
+}
+
+#else
+
+EAPI Ecore_Evas *
+ecore_evas_software_ddraw_new(Ecore_Win32_Window *parent __UNUSED__,
+                              int                 x __UNUSED__,
+                              int                 y __UNUSED__,
+                              int                 width __UNUSED__,
+                              int                 height __UNUSED__)
+{
+   return NULL;
+}
+
+#endif /* ! BUILD_ECORE_EVAS_SOFTWARE_DDRAW */
+
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_DDRAW
+
+EAPI Ecore_Evas *
+ecore_evas_software_16_ddraw_new(Ecore_Win32_Window *parent,
+                                 int                 x,
+                                 int                 y,
+                                 int                 width,
+                                 int                 height)
+{
+   return _ecore_evas_win32_new_internal(_ecore_evas_engine_software_16_ddraw_init,
+                                         parent,
+                                         x,
+                                         y,
+                                         width,
+                                         height);
+}
+
+#else
+
+EAPI Ecore_Evas *
+ecore_evas_software_16_ddraw_new(Ecore_Win32_Window *parent __UNUSED__,
+                                 int                 x __UNUSED__,
+                                 int                 y __UNUSED__,
+                                 int                 width __UNUSED__,
+                                 int                 height __UNUSED__)
+{
+   return NULL;
+}
+
+#endif /* ! BUILD_ECORE_EVAS_SOFTWARE_16_DDRAW */
+
+
+#ifdef BUILD_ECORE_EVAS_DIRECT3D
+
+EAPI Ecore_Evas *
+ecore_evas_direct3d_new(Ecore_Win32_Window *parent,
+                        int                 x,
+                        int                 y,
+                        int                 width,
+                        int                 height)
+{
+   return _ecore_evas_win32_new_internal(_ecore_evas_engine_direct3d_init,
+                                         parent,
+                                         x,
+                                         y,
+                                         width,
+                                         height);
+}
+
+#else
+
+EAPI Ecore_Evas *
+ecore_evas_direct3d_new(Ecore_Win32_Window *parent __UNUSED__,
+                        int                 x __UNUSED__,
+                        int                 y __UNUSED__,
+                        int                 width __UNUSED__,
+                        int                 height __UNUSED__)
+{
+   return NULL;
+}
+
+#endif /* ! BUILD_ECORE_EVAS_DIRECT3D */
+
+
+#ifdef BUILD_ECORE_EVAS_OPENGL_GLEW
+
+EAPI Ecore_Evas *
+ecore_evas_gl_glew_new(Ecore_Win32_Window *parent,
+                       int                 x,
+                       int                 y,
+                       int                 width,
+                       int                 height)
+{
+   return _ecore_evas_win32_new_internal(_ecore_evas_engine_opengl_glew_init,
+                                         parent,
+                                         x,
+                                         y,
+                                         width,
+                                         height);
+}
+
+#else
+
+EAPI Ecore_Evas *
+ecore_evas_gl_glew_new(Ecore_Win32_Window *parent __UNUSED__,
+                       int                 x __UNUSED__,
+                       int                 y __UNUSED__,
+                       int                 width __UNUSED__,
+                       int                 height __UNUSED__)
+{
+   return NULL;
+}
+
+#endif /* BUILD_ECORE_EVAS_OPENGL_GLEW */
+
+
+#ifdef BUILD_ECORE_EVAS_WIN32
+
+EAPI Ecore_Win32_Window *
+ecore_evas_win32_window_get(const Ecore_Evas *ee)
+{
+   return (Ecore_Win32_Window *) ecore_evas_window_get(ee);
+}
+
+#else
+
+EAPI Ecore_Win32_Window *
+ecore_evas_win32_window_get(const Ecore_Evas *ee __UNUSED__)
+{
+   return NULL;
+}
+
+#endif /* BUILD_ECORE_EVAS_WIN32 */
diff --git a/libraries/ecore/src/lib/ecore_evas/ecore_evas_wince.c b/libraries/ecore/src/lib/ecore_evas/ecore_evas_wince.c
new file mode 100644
index 0000000..e102cb7
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/ecore_evas_wince.c
@@ -0,0 +1,985 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <stdlib.h> /* for NULL */
+
+#include <Ecore.h>
+#include "ecore_private.h"
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_WINCE
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
+# undef WIN32_LEAN_AND_MEAN
+# include <Ecore_WinCE.h>
+# include <ecore_wince_private.h>
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_16_WINCE */
+
+#include "ecore_evas_private.h"
+#include "Ecore_Evas.h"
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_WINCE
+
+#define ECORE_EVAS_EVENT_COUNT 9
+
+static int _ecore_evas_init_count = 0;
+
+static Ecore_Event_Handler *ecore_evas_event_handlers[ECORE_EVAS_EVENT_COUNT];
+
+static Eina_Bool _ecore_evas_wince_event_mouse_in(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_wince_event_mouse_out(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_wince_event_window_focus_in(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_wince_event_window_focus_out(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_wince_event_window_damage(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_wince_event_window_destroy(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_wince_event_window_show(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_wince_event_window_hide(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+static Eina_Bool _ecore_evas_wince_event_window_delete_request(void *data __UNUSED__, int type __UNUSED__, void *event);
+
+/* Private functions */
+
+static int
+_ecore_evas_wince_render(Ecore_Evas *ee)
+{
+   int rend = 0;
+   Eina_List *updates = NULL;
+   Eina_List *ll;
+   Ecore_Evas *ee2;
+
+   EINA_LIST_FOREACH(ee->sub_ecore_evas, ll, ee2)
+     {
+        if (ee2->func.fn_pre_render) ee2->func.fn_pre_render(ee2);
+        if (ee2->engine.func->fn_render)
+          rend |= ee2->engine.func->fn_render(ee2);
+        if (ee2->func.fn_post_render) ee2->func.fn_post_render(ee2);
+     }
+
+   if (ee->func.fn_pre_render) ee->func.fn_pre_render(ee);
+   if (ee->prop.avoid_damage)
+     {
+        updates = evas_render_updates(ee->evas);
+        if (updates) evas_render_updates_free(updates);
+     }
+   else if ((ee->visible) ||
+            ((ee->should_be_visible) && (ee->prop.fullscreen)) ||
+            ((ee->should_be_visible) && (ee->prop.override)))
+     {
+        if (ee->shaped)
+          {
+             updates = evas_render_updates(ee->evas);
+             if (updates) evas_render_updates_free(updates);
+          }
+        else
+          {
+             updates = evas_render_updates(ee->evas);
+             if (updates) evas_render_updates_free(updates);
+          }
+     }
+   else
+     evas_norender(ee->evas);
+   if (updates) rend = 1;
+   if (ee->func.fn_post_render) ee->func.fn_post_render(ee);
+   return rend;
+}
+
+static int
+_ecore_evas_wince_init(void)
+{
+   _ecore_evas_init_count++;
+   if (_ecore_evas_init_count > 1)
+     return _ecore_evas_init_count;
+
+   ecore_evas_event_handlers[0]  = ecore_event_handler_add(ECORE_WINCE_EVENT_MOUSE_IN, _ecore_evas_wince_event_mouse_in, NULL);
+   ecore_evas_event_handlers[1]  = ecore_event_handler_add(ECORE_WINCE_EVENT_MOUSE_OUT, _ecore_evas_wince_event_mouse_out, NULL);
+   ecore_evas_event_handlers[2]  = ecore_event_handler_add(ECORE_WINCE_EVENT_WINDOW_FOCUS_IN, _ecore_evas_wince_event_window_focus_in, NULL);
+   ecore_evas_event_handlers[3]  = ecore_event_handler_add(ECORE_WINCE_EVENT_WINDOW_FOCUS_OUT, _ecore_evas_wince_event_window_focus_out, NULL);
+   ecore_evas_event_handlers[4]  = ecore_event_handler_add(ECORE_WINCE_EVENT_WINDOW_DAMAGE, _ecore_evas_wince_event_window_damage, NULL);
+   ecore_evas_event_handlers[5]  = ecore_event_handler_add(ECORE_WINCE_EVENT_WINDOW_DESTROY, _ecore_evas_wince_event_window_destroy, NULL);
+   ecore_evas_event_handlers[6]  = ecore_event_handler_add(ECORE_WINCE_EVENT_WINDOW_SHOW, _ecore_evas_wince_event_window_show, NULL);
+   ecore_evas_event_handlers[7]  = ecore_event_handler_add(ECORE_WINCE_EVENT_WINDOW_HIDE, _ecore_evas_wince_event_window_hide, NULL);
+   ecore_evas_event_handlers[8]  = ecore_event_handler_add(ECORE_WINCE_EVENT_WINDOW_DELETE_REQUEST, _ecore_evas_wince_event_window_delete_request, NULL);
+
+   ecore_event_evas_init();
+   return _ecore_evas_init_count;
+}
+
+int
+_ecore_evas_wince_shutdown(void)
+{
+   _ecore_evas_init_count--;
+   if (_ecore_evas_init_count == 0)
+     {
+        int i;
+
+        for (i = 0; i < ECORE_EVAS_EVENT_COUNT; i++)
+          ecore_event_handler_del(ecore_evas_event_handlers[i]);
+        ecore_event_evas_shutdown();
+     }
+
+   if (_ecore_evas_init_count < 0) _ecore_evas_init_count = 0;
+
+   return _ecore_evas_init_count;
+}
+
+static Eina_Bool
+_ecore_evas_wince_event_mouse_in(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                 *ee;
+   Ecore_WinCE_Event_Mouse_In *e;
+
+   INF("mouse in");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if ((!ee) || (ee->ignore_events)) return 1; /* pass on event */
+   if (e->window != (Ecore_WinCE_Window *)ee->prop.window) return 1;
+
+   if (ee->func.fn_mouse_in) ee->func.fn_mouse_in(ee);
+   /* FIXME to do */
+/*    _ecore_evas_x_modifier_locks_update(ee, e->modifiers); */
+   evas_event_feed_mouse_in(ee->evas, e->time, NULL);
+   _ecore_evas_mouse_move_process(ee, e->x, e->y, e->time);
+
+   return 1;
+}
+
+static Eina_Bool
+_ecore_evas_wince_event_mouse_out(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                  *ee;
+   Ecore_WinCE_Event_Mouse_Out *e;
+
+   INF("mouse out");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if ((!ee) || (ee->ignore_events)) return 1; /* pass on event */
+   if (e->window != (Ecore_WinCE_Window *)ee->prop.window) return 1;
+
+   /* FIXME to do */
+/*    _ecore_evas_x_modifier_locks_update(ee, e->modifiers); */
+   _ecore_evas_mouse_move_process(ee, e->x, e->y, e->time);
+
+   evas_event_feed_mouse_out(ee->evas, e->time, NULL);
+   if (ee->func.fn_mouse_out) ee->func.fn_mouse_out(ee);
+   if (ee->prop.cursor.object) evas_object_hide(ee->prop.cursor.object);
+
+   return 1;
+}
+
+static Eina_Bool
+_ecore_evas_wince_event_window_focus_in(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_WinCE_Event_Window_Focus_In *e;
+
+   e = event;
+   ee = ecore_event_window_match(e->window);
+   if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON;
+   if (e->window != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+
+   ee->prop.focused = 1;
+   evas_focus_in(ee->evas);
+   if (ee->func.fn_focus_in) ee->func.fn_focus_in(ee);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_wince_event_window_focus_out(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_WinCE_Event_Window_Focus_Out *e;
+
+   e = event;
+   ee = ecore_event_window_match(e->window);
+   if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON;
+   if (e->window != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+
+   evas_focus_out(ee->evas);
+   ee->prop.focused = 0;
+   if (ee->func.fn_focus_out) ee->func.fn_focus_out(ee);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_wince_event_window_damage(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                      *ee;
+   Ecore_WinCE_Event_Window_Damage *e;
+
+   INF("window damage");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if (!ee) return 1; /* pass on event */
+   if (e->window != (Ecore_WinCE_Window *)ee->prop.window) return 1;
+
+   if (ee->prop.avoid_damage)
+     {
+#warning [ECORE] [WINCE] No Region code
+     }
+   else
+     {
+        if (ee->rotation == 0)
+          evas_damage_rectangle_add(ee->evas,
+                                    e->x,
+                                    e->y,
+                                    e->width,
+                                    e->height);
+        else if (ee->rotation == 90)
+          evas_damage_rectangle_add(ee->evas,
+                                    ee->h - e->y - e->height,
+                                    e->x,
+                                    e->height,
+                                    e->width);
+        else if (ee->rotation == 180)
+          evas_damage_rectangle_add(ee->evas,
+                                    ee->w - e->x - e->width,
+                                    ee->h - e->y - e->height,
+                                    e->width,
+                                    e->height);
+        else if (ee->rotation == 270)
+          evas_damage_rectangle_add(ee->evas,
+                                    e->y,
+                                    ee->w - e->x - e->width,
+                                    e->height,
+                                    e->width);
+     }
+
+   return 1;
+}
+
+static Eina_Bool
+_ecore_evas_wince_event_window_destroy(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                       *ee;
+   Ecore_WinCE_Event_Window_Destroy *e;
+
+   INF("window destroy");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if (!ee) return 1; /* pass on event */
+   if (e->window != (Ecore_WinCE_Window *)ee->prop.window) return 1;
+   if (ee->func.fn_destroy) ee->func.fn_destroy(ee);
+   ecore_evas_free(ee);
+
+   return 1;
+}
+
+static Eina_Bool
+_ecore_evas_wince_event_window_show(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                    *ee;
+   Ecore_WinCE_Event_Window_Show *e;
+
+   INF("window show");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if (!ee) return 1; /* pass on event */
+   if (e->window != (Ecore_WinCE_Window *)ee->prop.window) return 1;
+   if (ee->visible) return 0; /* dont pass it on */
+   ee->visible = 1;
+   if (ee->func.fn_show) ee->func.fn_show(ee);
+
+   return 1;
+}
+
+static Eina_Bool
+_ecore_evas_wince_event_window_hide(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                    *ee;
+   Ecore_WinCE_Event_Window_Hide *e;
+
+   INF("window hide");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if (!ee) return 1; /* pass on event */
+   if (e->window != (Ecore_WinCE_Window *)ee->prop.window) return 1;
+   if (!ee->visible) return 0; /* dont pass it on */
+   ee->visible = 0;
+   if (ee->func.fn_hide) ee->func.fn_hide(ee);
+
+   return 1;
+}
+
+static Eina_Bool
+_ecore_evas_wince_event_window_delete_request(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas                              *ee;
+   Ecore_WinCE_Event_Window_Delete_Request *e;
+
+   INF("window delete request");
+
+   e = event;
+   ee = ecore_event_window_match((Ecore_Window)e->window);
+   if (!ee) return 1; /* pass on event */
+   if (e->window != (Ecore_WinCE_Window *)ee->prop.window) return 1;
+   if (ee->func.fn_delete_request) ee->func.fn_delete_request(ee);
+
+   return 1;
+}
+
+
+/* Ecore_Evas interface */
+
+static void
+_ecore_evas_wince_free(Ecore_Evas *ee)
+{
+   INF("ecore evas free");
+
+   ecore_wince_window_free((Ecore_WinCE_Window *)ee->prop.window);
+   ecore_event_window_unregister(ee->prop.window);
+   _ecore_evas_wince_shutdown();
+   ecore_wince_shutdown();
+}
+
+static void
+_ecore_evas_wince_callback_delete_request_set(Ecore_Evas *ee,
+                                              void (*func) (Ecore_Evas *ee))
+{
+   ee->func.fn_delete_request = func;
+}
+
+static void
+_ecore_evas_wince_move(Ecore_Evas *ee, int x, int y)
+{
+  INF("ecore evas move (%dx%d)", x, y);
+   ee->req.x = x;
+   ee->req.y = y;
+
+   if ((x != ee->x) || (y != ee->y))
+     {
+        ee->x = x;
+        ee->y = y;
+        ecore_wince_window_move((Ecore_WinCE_Window *)ee->prop.window, x, y);
+        if (ee->func.fn_move) ee->func.fn_move(ee);
+     }
+}
+
+static void
+_ecore_evas_wince_resize(Ecore_Evas *ee, int width, int height)
+{
+   INF("ecore evas resize (%dx%d)", width, height);
+   ee->req.w = width;
+   ee->req.h = height;
+
+   if ((ee->w != width) || (ee->h != height))
+     {
+        ee->w = width;
+        ee->h = height;
+        ecore_wince_window_resize((Ecore_WinCE_Window *)ee->prop.window, width, height);
+        if ((ee->rotation == 90) || (ee->rotation == 270))
+          {
+             evas_output_size_set(ee->evas, ee->h, ee->w);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+          }
+        else
+          {
+             evas_output_size_set(ee->evas, ee->w, ee->h);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+          }
+        /* FIXME: damage and shape */
+
+        if (ee->func.fn_resize) ee->func.fn_resize(ee);
+     }
+}
+
+static void
+_ecore_evas_wince_move_resize(Ecore_Evas *ee, int x, int y, int width, int height)
+{
+   INF("ecore evas resize (%dx%d %dx%d)", x, y, width, height);
+   ee->req.x = x;
+   ee->req.y = y;
+   ee->req.w = width;
+   ee->req.h = height;
+
+   if ((ee->w != width) || (ee->h != height) || (x != ee->x) || (y != ee->y))
+     {
+        int change_size = 0;
+        int change_pos = 0;
+
+        if ((ee->w != width) || (ee->h != height)) change_size = 1;
+        if ((x != ee->x) || (y != ee->y)) change_pos = 1;
+
+        ee->x = x;
+        ee->y = y;
+        ee->w = width;
+        ee->h = height;
+        ecore_wince_window_move_resize((Ecore_WinCE_Window *)ee->prop.window, x, y, width, height);
+        if ((ee->rotation == 90) || (ee->rotation == 270))
+          {
+             evas_output_size_set(ee->evas, ee->h, ee->w);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+          }
+        else
+          {
+             evas_output_size_set(ee->evas, ee->w, ee->h);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+          }
+        /* FIXME: damage and shape */
+        if (change_pos)
+          {
+             if (ee->func.fn_move) ee->func.fn_move(ee);
+          }
+        if (change_size)
+          {
+             if (ee->func.fn_resize) ee->func.fn_resize(ee);
+          }
+     }
+}
+
+/* static void */
+/* _ecore_evas_wince_rotation_set(Ecore_Evas *ee, int rotation) */
+/* { */
+/*    int rot_dif; */
+
+/*    if (ee->rotation == rotation) return; */
+/*    rot_dif = ee->rotation - rotation; */
+/*    if (rot_dif < 0) rot_dif = -rot_dif; */
+/*    if (!strcmp(ee->driver, "software_ddraw")) */
+/*      { */
+/*        Evas_Engine_Info_Software_16_WinCE *einfo; */
+
+/*        einfo = (Evas_Engine_Info_Software_16_WinCE *)evas_engine_info_get(ee->evas); */
+/*        if (!einfo) return; */
+/*        if (rot_dif != 180) */
+/*          { */
+/*             int minw, minh, maxw, maxh, basew, baseh, stepw, steph; */
+
+/*             einfo->info.rotation = rotation; */
+/*             evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo); */
+/*             if (!ee->prop.fullscreen) */
+/*               { */
+/*                  ecore_wince_window_resize(ee->prop.window, ee->h, ee->w); */
+/*                  ee->expecting_resize.w = ee->h; */
+/*                  ee->expecting_resize.h = ee->w; */
+/*               } */
+/*             else */
+/*               { */
+/*                  int w, h; */
+
+/*                  ecore_wince_window_size_get(ee->prop.window, &w, &h); */
+/*                  ecore_wince_window_resize(ee->prop.window, h, w); */
+/*                  if ((rotation == 0) || (rotation == 180)) */
+/*                    { */
+/*                       evas_output_size_set(ee->evas, ee->w, ee->h); */
+/*                       evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h); */
+/*                    } */
+/*                  else */
+/*                    { */
+/*                       evas_output_size_set(ee->evas, ee->h, ee->w); */
+/*                       evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w); */
+/*                    } */
+/*                  if (ee->func.fn_resize) ee->func.fn_resize(ee); */
+/*               } */
+/*             ecore_evas_size_min_get(ee, &minw, &minh); */
+/*             ecore_evas_size_max_get(ee, &maxw, &maxh); */
+/*             ecore_evas_size_base_get(ee, &basew, &baseh); */
+/*             ecore_evas_size_step_get(ee, &stepw, &steph); */
+/*             ee->rotation = rotation; */
+/*             ecore_evas_size_min_set(ee, minh, minw); */
+/*             ecore_evas_size_max_set(ee, maxh, maxw); */
+/*             ecore_evas_size_base_set(ee, baseh, basew); */
+/*             ecore_evas_size_step_set(ee, steph, stepw); */
+/*             _ecore_evas_wince_mouse_move_process(ee, ee->mouse.x, ee->mouse.y, */
+/*                                                   ecore_wince_current_time_get()); */
+/*          } */
+/*        else */
+/*          { */
+/*             einfo->info.rotation = rotation; */
+/*             evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo); */
+/*             ee->rotation = rotation; */
+/*             _ecore_evas_wince_mouse_move_process(ee, ee->mouse.x, ee->mouse.y, */
+/*                                                   ecore_wince_current_time_get()); */
+/*             if (ee->func.fn_resize) ee->func.fn_resize(ee); */
+/*          } */
+/*        if ((ee->rotation == 90) || (ee->rotation == 270)) */
+/*          evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w); */
+/*        else */
+/*          evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h); */
+/*      } */
+/* } */
+
+static void
+_ecore_evas_wince_show(Ecore_Evas *ee)
+{
+   INF("ecore evas show");
+
+   ee->should_be_visible = 1;
+   if (ee->prop.avoid_damage)
+     _ecore_evas_wince_render(ee);
+   ecore_wince_window_show((Ecore_WinCE_Window *)ee->prop.window);
+/*    if (ee->prop.fullscreen) */
+/*      ecore_wince_window_focus(ee->prop.window); */
+}
+
+static void
+_ecore_evas_wince_hide(Ecore_Evas *ee)
+{
+   INF("ecore evas hide");
+
+   ecore_wince_window_hide((Ecore_WinCE_Window *)ee->prop.window);
+   ee->should_be_visible = 0;
+}
+
+/* static void */
+/* _ecore_evas_wince_raise(Ecore_Evas *ee) */
+/* { */
+/*    if (!ee->prop.fullscreen) */
+/*      ecore_wince_window_raise(ee->prop.window); */
+/*    else */
+/*      ecore_wince_window_raise(ee->prop.window); */
+/* } */
+
+/* static void */
+/* _ecore_evas_wince_lower(Ecore_Evas *ee) */
+/* { */
+/*    if (!ee->prop.fullscreen) */
+/*      ecore_wince_window_lower(ee->prop.window); */
+/*    else */
+/*      ecore_wince_window_lower(ee->prop.window); */
+/* } */
+
+static void
+_ecore_evas_wince_title_set(Ecore_Evas *ee, const char *title)
+{
+   INF("ecore evas title set");
+
+   if (ee->prop.title) free(ee->prop.title);
+   ee->prop.title = NULL;
+   if (title) ee->prop.title = strdup(title);
+   ecore_wince_window_title_set((Ecore_WinCE_Window *)ee->prop.window, ee->prop.title);
+}
+
+/* static void */
+/* _ecore_evas_wince_size_min_set(Ecore_Evas *ee, int width, int height) */
+/* { */
+/*    if (width < 0) width = 0; */
+/*    if (height < 0) height = 0; */
+/*    if ((ee->prop.min.w == width) && (ee->prop.min.h == height)) return; */
+/*    ee->prop.min.w = width; */
+/*    ee->prop.min.h = height; */
+/*    ecore_wince_window_size_min_set(ee->prop.window, width, height); */
+/* } */
+
+/* static void */
+/* _ecore_evas_wince_size_max_set(Ecore_Evas *ee, int width, int height) */
+/* { */
+/*    if (width < 0) width = 0; */
+/*    if (height < 0) height = 0; */
+/*    if ((ee->prop.max.w == width) && (ee->prop.max.h == height)) return; */
+/*    ee->prop.max.w = width; */
+/*    ee->prop.max.h = height; */
+/*    ecore_wince_window_size_max_set(ee->prop.window, width, height); */
+/* } */
+
+/* static void */
+/* _ecore_evas_wince_size_base_set(Ecore_Evas *ee, int width, int height) */
+/* { */
+/*    if (width < 0) width = 0; */
+/*    if (height < 0) height = 0; */
+/*    if ((ee->prop.base.w == width) && (ee->prop.base.h == height)) return; */
+/*    ee->prop.base.w = width; */
+/*    ee->prop.base.h = height; */
+/*    ecore_wince_window_size_base_set(ee->prop.window, width, height); */
+/* } */
+
+/* static void */
+/* _ecore_evas_wince_size_step_set(Ecore_Evas *ee, int width, int height) */
+/* { */
+/*    if (width < 1) width = 1; */
+/*    if (height < 1) height = 1; */
+/*    if ((ee->prop.step.w == width) && (ee->prop.step.h == height)) return; */
+/*    ee->prop.step.w = width; */
+/*    ee->prop.step.h = height; */
+/*    ecore_wince_window_size_step_set(ee->prop.window, width, height); */
+/* } */
+
+static void
+_ecore_evas_wince_cursor_set(Ecore_Evas *ee, Evas_Object *obj, int layer, int hot_x, int hot_y)
+{
+#if 0
+   int x, y;
+
+   if (ee->prop.cursor.object) evas_object_del(ee->prop.cursor.object);
+
+   if (obj == NULL)
+     {
+        ee->prop.cursor.object = NULL;
+        ee->prop.cursor.layer = 0;
+        ee->prop.cursor.hot.x = 0;
+        ee->prop.cursor.hot.y = 0;
+        ecore_wince_window_cursor_show(ee->prop.window, 1);
+        return;
+     }
+
+   ee->prop.cursor.object = obj;
+   ee->prop.cursor.layer = layer;
+   ee->prop.cursor.hot.x = hot_x;
+   ee->prop.cursor.hot.y = hot_y;
+
+   ecore_wince_window_cursor_show(ee->prop.window, 0);
+
+   evas_pointer_output_xy_get(ee->evas, &x, &y);
+   evas_object_layer_set(ee->prop.cursor.object, ee->prop.cursor.layer);
+   evas_object_move(ee->prop.cursor.object,
+                    x - ee->prop.cursor.hot.x,
+                    y - ee->prop.cursor.hot.y);
+   evas_object_pass_events_set(ee->prop.cursor.object, 1);
+   if (evas_pointer_inside_get(ee->evas))
+     evas_object_show(ee->prop.cursor.object);
+#endif
+}
+
+/* static void */
+/* _ecore_evas_wince_focus_set(Ecore_Evas *ee, int on __UNUSED__) */
+/* { */
+/*    ecore_wince_window_focus_set(ee->prop.window); */
+/* } */
+
+/* static void */
+/* _ecore_evas_wince_iconified_set(Ecore_Evas *ee, int on) */
+/* { */
+/* /\*    if (((ee->prop.borderless) && (on)) || *\/ */
+/* /\*        ((!ee->prop.borderless) && (!on))) return; *\/ */
+/*    ee->prop.iconified = on; */
+/*    ecore_wince_window_iconified_set(ee->prop.window, ee->prop.iconified); */
+/* } */
+
+/* static void */
+/* _ecore_evas_wince_borderless_set(Ecore_Evas *ee, int on) */
+/* { */
+/*    if (((ee->prop.borderless) && (on)) || */
+/*        ((!ee->prop.borderless) && (!on))) return; */
+/*    ee->prop.borderless = on; */
+/*    ecore_wince_window_borderless_set(ee->prop.window, ee->prop.borderless); */
+/* } */
+
+static void
+_ecore_evas_wince_fullscreen_set(Ecore_Evas *ee, int on)
+{
+   Evas_Engine_Info_Software_16_WinCE *einfo;
+   struct _Ecore_WinCE_Window         *window;
+
+   INF("ecore evas fullscreen set");
+
+   if ((ee->engine.wince.state.fullscreen && on) ||
+      (!ee->engine.wince.state.fullscreen && !on))
+     return;
+
+   ee->engine.wince.state.fullscreen = on;
+   ee->prop.fullscreen = on;
+
+   window = (struct _Ecore_WinCE_Window *)ee->prop.window;
+
+   if (on != 0)
+   {
+/*       ecore_win32_window_shape_set(ee->engine.win32.window, 0, 0, NULL); */
+      ecore_wince_window_fullscreen_set((Ecore_WinCE_Window *)ee->prop.window, on);
+      ee->w = GetSystemMetrics(SM_CXSCREEN);
+      ee->h = GetSystemMetrics(SM_CYSCREEN);
+      ee->req.w = ee->w;
+      ee->req.h = ee->h;
+      evas_output_size_set(ee->evas, ee->w, ee->h);
+      evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+   }
+   else
+   {
+      int w;
+      int h;
+
+      ecore_wince_window_fullscreen_set((Ecore_WinCE_Window *)ee->prop.window, on);
+      ecore_wince_window_size_get((Ecore_WinCE_Window *)ee->prop.window, &w, &h);
+      ee->w = w;
+      ee->h = h;
+      ee->req.w = ee->w;
+      ee->req.h = ee->h;
+      evas_output_size_set(ee->evas, ee->w, ee->h);
+      evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+/*       ecore_win32_window_shape_set(window, */
+/*                                    window->shape.width, */
+/*                                    window->shape.height, */
+/*                                    window->shape.mask); */
+   }
+
+   einfo = (Evas_Engine_Info_Software_16_WinCE *)evas_engine_info_get(ecore_evas_get(ee));
+   if (einfo)
+     {
+        einfo->info.fullscreen = !!on;
+/*         einfo->info.layered = window->shape.layered; */
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+     }
+}
+
+static Ecore_Evas_Engine_Func _ecore_wince_engine_func =
+{
+   _ecore_evas_wince_free,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   _ecore_evas_wince_callback_delete_request_set,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   NULL,
+   _ecore_evas_wince_move,
+   NULL,
+   _ecore_evas_wince_resize,
+   _ecore_evas_wince_move_resize,
+   NULL, //_ecore_evas_wince_rotation_set,
+   NULL, /* _ecore_evas_x_shaped_set */
+   _ecore_evas_wince_show,
+   _ecore_evas_wince_hide,
+   NULL, //_ecore_evas_wince_raise,
+   NULL, //_ecore_evas_wince_lower,
+   NULL, //_ecore_evas_wince_activate,
+   _ecore_evas_wince_title_set,
+   NULL, /* _ecore_evas_x_name_class_set */
+   NULL, //_ecore_evas_wince_size_min_set,
+   NULL, //_ecore_evas_wince_size_max_set,
+   NULL, //_ecore_evas_wince_size_base_set,
+   NULL, //_ecore_evas_wince_size_step_set,
+   _ecore_evas_wince_cursor_set,
+   NULL, /* _ecore_evas_x_layer_set */
+   NULL, //_ecore_evas_wince_focus_set,
+   NULL, //_ecore_evas_wince_iconified_set,
+   NULL, //_ecore_evas_wince_borderless_set,
+   NULL, /* _ecore_evas_x_override_set */
+   NULL,
+   _ecore_evas_wince_fullscreen_set,
+   NULL, /* _ecore_evas_x_avoid_damage_set */
+   NULL, /* _ecore_evas_x_withdrawn_set */
+   NULL, /* _ecore_evas_x_sticky_set */
+   NULL, /* _ecore_evas_x_ignore_events_set */
+   NULL, /* _ecore_evas_x_alpha_set */
+   NULL, //transparent
+
+   NULL, // render
+   NULL  // screen_geometry_get
+};
+
+/* API */
+
+static Ecore_Evas *
+ecore_evas_software_wince_new_internal(int                 backend,
+                                       Ecore_WinCE_Window *parent,
+                                       int                 x,
+                                       int                 y,
+                                       int                 width,
+                                       int                 height,
+                                       int                 fullscreen)
+{
+   Evas_Engine_Info_Software_16_WinCE *einfo;
+   Ecore_Evas                         *ee;
+   int                                 rmethod;
+
+   rmethod = evas_render_method_lookup("software_16_wince");
+   if (!rmethod)
+     return NULL;
+
+   if (!ecore_wince_init())
+     return NULL;
+
+   ee = calloc(1, sizeof(Ecore_Evas));
+   if (!ee)
+     {
+        ecore_wince_shutdown();
+        return NULL;
+     }
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+   if (!_ecore_evas_wince_init())
+     {
+        free(ee);
+        ecore_wince_shutdown();
+        return NULL;
+     }
+
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_wince_engine_func;
+
+   ee->driver = "software_16_wince";
+
+   if (width < 1) width = 1;
+   if (height < 1) height = 1;
+   ee->x = x;
+   ee->y = y;
+   ee->w = width;
+   ee->h = height;
+   ee->req.x = ee->x;
+   ee->req.y = ee->y;
+   ee->req.w = ee->w;
+   ee->req.h = ee->h;
+
+   ee->prop.max.w = 32767;
+   ee->prop.max.h = 32767;
+   ee->prop.layer = 4;
+   ee->prop.request_pos = 0;
+   ee->prop.sticky = 0;
+   /* FIXME: sticky to add */
+
+   ee->prop.window = (Ecore_Window)ecore_wince_window_new((Ecore_WinCE_Window *)parent, x, y, width, height);
+   if (!ee->prop.window)
+     {
+        _ecore_evas_wince_shutdown();
+        free(ee);
+        ecore_wince_shutdown();
+        return NULL;
+     }
+
+   ecore_wince_window_fullscreen_set((Ecore_WinCE_Window *)ee->prop.window, fullscreen);
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_method_set(ee->evas, rmethod);
+   evas_output_size_set(ee->evas, width, height);
+   evas_output_viewport_set(ee->evas, 0, 0, width, height);
+
+   einfo = (Evas_Engine_Info_Software_16_WinCE *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        /* FIXME: REDRAW_DEBUG missing for now */
+        einfo->info.window = ((struct _Ecore_WinCE_Window *)ee->prop.window)->window;
+        einfo->info.width = width;
+        einfo->info.height = height;
+        einfo->info.backend = backend;
+        einfo->info.rotation = 0;
+        einfo->info.fullscreen = fullscreen;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             _ecore_evas_wince_shutdown();
+             free(ee);
+             ecore_wince_shutdown();
+             return NULL;
+          }
+
+        ecore_wince_window_backend_set((Ecore_WinCE_Window *)ee->prop.window, backend);
+        ecore_wince_window_suspend_cb_set((Ecore_WinCE_Window *)ee->prop.window, einfo->func.suspend);
+        ecore_wince_window_resume_cb_set((Ecore_WinCE_Window *)ee->prop.window, einfo->func.resume);
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        _ecore_evas_wince_shutdown();
+        free(ee);
+        ecore_wince_shutdown();
+        return NULL;
+     }
+
+   ee->engine.func->fn_render = _ecore_evas_wince_render;
+   _ecore_evas_register(ee);
+   ecore_event_window_register(ee->prop.window, ee, ee->evas,
+                               (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                               (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                               (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                               (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+   evas_focus_in(ee->evas);
+
+   return ee;
+}
+
+#else
+
+static Ecore_Evas *
+ecore_evas_software_wince_new_internal(int                 backend __UNUSED__,
+                                       Ecore_WinCE_Window *parent __UNUSED__,
+                                       int                 x __UNUSED__,
+                                       int                 y __UNUSED__,
+                                       int                 width __UNUSED__,
+                                       int                 height __UNUSED__,
+                                       int                 fullscreen __UNUSED__)
+{
+   return NULL;
+}
+
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_16_WINCE */
+
+
+EAPI Ecore_Evas *
+ecore_evas_software_wince_new(Ecore_WinCE_Window *parent,
+                              int                 x,
+                              int                 y,
+                              int                 width,
+                              int                 height)
+{
+   return ecore_evas_software_wince_new_internal(0, parent, x, y, width, height, 1);
+}
+
+EAPI Ecore_Evas *
+ecore_evas_software_wince_fb_new(Ecore_WinCE_Window *parent,
+                                 int                 x,
+                                 int                 y,
+                                 int                 width,
+                                 int                 height)
+{
+   return ecore_evas_software_wince_new_internal(1, parent, x, y, width, height, 1);
+}
+
+EAPI Ecore_Evas *
+ecore_evas_software_wince_gapi_new(Ecore_WinCE_Window *parent,
+                                   int                 x,
+                                   int                 y,
+                                   int                 width,
+                                   int                 height)
+{
+   return ecore_evas_software_wince_new_internal(2, parent, x, y, width, height, 1);
+}
+
+EAPI Ecore_Evas *
+ecore_evas_software_wince_ddraw_new(Ecore_WinCE_Window *parent,
+                                    int                 x,
+                                    int                 y,
+                                    int                 width,
+                                    int                 height)
+{
+   return ecore_evas_software_wince_new_internal(3, parent, x, y, width, height, 1);
+}
+
+EAPI Ecore_Evas *
+ecore_evas_software_wince_gdi_new(Ecore_WinCE_Window *parent,
+                                  int                 x,
+                                  int                 y,
+                                  int                 width,
+                                  int                 height)
+{
+   return ecore_evas_software_wince_new_internal(4, parent, x, y, width, height, 0);
+}
+
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_16_WINCE
+
+EAPI Ecore_WinCE_Window *
+ecore_evas_software_wince_window_get(const Ecore_Evas *ee)
+{
+   return (Ecore_WinCE_Window *) ecore_evas_window_get(ee);
+}
+
+#else
+
+EAPI Ecore_WinCE_Window *
+ecore_evas_software_wince_window_get(const Ecore_Evas *ee __UNUSED__)
+{
+   return NULL;
+}
+
+#endif /* ! BUILD_ECORE_EVAS_SOFTWARE_16_WINCE */
diff --git a/libraries/ecore/src/lib/ecore_evas/ecore_evas_x.c b/libraries/ecore/src/lib/ecore_evas/ecore_evas_x.c
new file mode 100644
index 0000000..d9ccd6e
--- /dev/null
+++ b/libraries/ecore/src/lib/ecore_evas/ecore_evas_x.c
@@ -0,0 +1,4289 @@
+#include <string.h>
+#include "ecore_evas_private.h"
+#include "Ecore_Evas.h"
+
+#ifdef BUILD_ECORE_EVAS_X11
+static int _ecore_evas_init_count = 0;
+
+static Ecore_Event_Handler *ecore_evas_event_handlers[13];
+
+static int leader_ref = 0;
+static Ecore_X_Window leader_win = 0;
+
+static void
+_ecore_evas_x_group_leader_set(Ecore_Evas *ee)
+{
+   leader_ref++;
+   if (leader_ref == 1)
+     {
+        char *id = NULL;
+
+        leader_win =
+          ecore_x_window_override_new(ee->engine.x.win_root, 1234, 5678, 1, 2);
+        ecore_x_window_defaults_set(leader_win);
+        if ((id = getenv("DESKTOP_STARTUP_ID")))
+          ecore_x_netwm_startup_id_set(leader_win,id);
+        ecore_x_icccm_client_leader_set(leader_win, leader_win);
+     }
+   ee->engine.x.leader = leader_win;
+   ecore_x_icccm_client_leader_set(ee->prop.window, leader_win);
+}
+
+static void
+_ecore_evas_x_group_leader_unset(Ecore_Evas *ee)
+{
+   ecore_x_window_prop_property_del(ee->prop.window,
+                                    ECORE_X_ATOM_WM_CLIENT_LEADER);
+   if (ee->engine.x.leader == leader_win)
+     {
+        leader_ref--;
+        if (leader_ref <= 0)
+          {
+             ecore_x_window_free(leader_win);
+             leader_win = 0;
+          }
+        ee->engine.x.leader = 0;
+     }
+}
+
+static void
+_ecore_evas_x_group_leader_update(Ecore_Evas *ee)
+{
+   if (ee->engine.x.leader)
+      ecore_x_icccm_client_leader_set(ee->prop.window, ee->engine.x.leader);
+}
+
+static void
+_ecore_evas_x_protocols_set(Ecore_Evas *ee)
+{
+   Ecore_X_Atom protos[3];
+   unsigned int num = 0, tmp = 0;
+
+   if (ee->func.fn_delete_request)
+     protos[num++] = ECORE_X_ATOM_WM_DELETE_WINDOW;
+   protos[num++] = ECORE_X_ATOM_NET_WM_PING;
+   protos[num++] = ECORE_X_ATOM_NET_WM_SYNC_REQUEST;
+   ecore_x_icccm_protocol_atoms_set(ee->prop.window, protos, num);
+
+   if (!ee->engine.x.netwm_sync_counter)
+     ee->engine.x.netwm_sync_counter = ecore_x_sync_counter_new(0);
+
+   tmp = ee->engine.x.netwm_sync_counter;
+   ecore_x_window_prop_card32_set(ee->prop.window,
+                                  ECORE_X_ATOM_NET_WM_SYNC_REQUEST_COUNTER,
+                                  &tmp, 1);
+}
+
+static void
+_ecore_evas_x_sync_set(Ecore_Evas *ee)
+{
+   if (((ee->should_be_visible) || (ee->visible)) &&
+       ((ecore_x_e_comp_sync_supported_get(ee->engine.x.win_root)) &&
+           (!ee->no_comp_sync) && (_ecore_evas_app_comp_sync)))
+     {
+        if (!ee->engine.x.sync_counter)
+           ee->engine.x.sync_counter = ecore_x_sync_counter_new(0);
+     }
+   else
+     {
+        if (ee->engine.x.sync_counter)
+           ecore_x_sync_counter_free(ee->engine.x.sync_counter);
+        ee->engine.x.sync_counter = 0;
+     }
+   ecore_x_e_comp_sync_counter_set(ee->prop.window, ee->engine.x.sync_counter);
+}
+
+static void
+_ecore_evas_x_sync_clear(Ecore_Evas *ee)
+{
+   if (!ee->engine.x.sync_counter) return;
+   ecore_x_sync_counter_free(ee->engine.x.sync_counter);
+   ee->engine.x.sync_counter = 0;
+}
+
+# ifdef BUILD_ECORE_EVAS_OPENGL_X11
+static Ecore_X_Window
+_ecore_evas_x_gl_window_new(Ecore_Evas *ee, Ecore_X_Window parent, int x, int y, int w, int h, int override, int argb, const int *opt)
+{
+   Evas_Engine_Info_GL_X11 *einfo;
+   Ecore_X_Window win;
+
+   einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        int screen;
+
+        if (opt)
+          {
+             int op;
+
+             for (op = 0; opt[op]; op++)
+               {
+                  if (opt[op] == ECORE_EVAS_GL_X11_OPT_INDIRECT)
+                    {
+                       op++;
+                       einfo->indirect = opt[op];
+                    }
+                  else if (opt[op] == ECORE_EVAS_GL_X11_OPT_VSYNC)
+                    {
+                       op++;
+                       einfo->vsync = opt[op];
+                    }
+               }
+          }
+
+        /* FIXME: this is inefficient as its 1 or more round trips */
+        screen = ecore_x_screen_index_get(ecore_x_default_screen_get());
+        if (ecore_x_screen_count_get() > 1)
+          {
+             Ecore_X_Window *roots;
+             int num, i;
+
+             num = 0;
+             roots = ecore_x_window_root_list(&num);
+             if (roots)
+               {
+                  Ecore_X_Window root;
+
+                  root = ecore_x_window_root_get(parent);
+                  for (i = 0; i < num; i++)
+                    {
+                       if (root == roots[i])
+                         {
+                            screen = i;
+                            break;
+                         }
+                    }
+                  free(roots);
+               }
+          }
+
+        einfo->info.display = ecore_x_display_get();
+        einfo->info.screen = screen;
+
+        einfo->info.destination_alpha = argb;
+
+        einfo->info.visual = einfo->func.best_visual_get(einfo);
+        einfo->info.colormap = einfo->func.best_colormap_get(einfo);
+        einfo->info.depth = einfo->func.best_depth_get(einfo);
+
+        if ((!einfo->info.visual) ||
+            (!einfo->info.colormap) || (!einfo->info.depth))
+          {
+             WRN("OpenGL X11 init engine '%s' failed - no visual, colormap or depth.", ee->driver);
+             if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+               {
+                  ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                  return 0;
+               }
+          }
+
+        if (argb)
+          {
+             if (override)
+               win = ecore_x_window_override_argb_new(parent, x, y, w, h);
+             else
+               win = ecore_x_window_argb_new(parent, x, y, w, h);
+          }
+        else
+          {
+             if (override)
+               win = ecore_x_window_override_new(parent, x, y, w, h);
+             else
+               win = ecore_x_window_new(parent, x, y, w, h);
+          }
+
+        ecore_x_window_pixel_gravity_set(win, ECORE_X_GRAVITY_FORGET);
+
+        /* attr.backing_store = NotUseful; */
+        /* attr.override_redirect = override; */
+        /* attr.colormap = einfo->info.colormap; */
+        /* attr.border_pixel = 0; */
+        /* attr.background_pixmap = None; */
+        /* attr.event_mask = */
+        /*   KeyPressMask | KeyReleaseMask | */
+        /*   ExposureMask | ButtonPressMask | ButtonReleaseMask | */
+        /*   EnterWindowMask | LeaveWindowMask | */
+        /*   PointerMotionMask | StructureNotifyMask | VisibilityChangeMask | */
+        /*   FocusChangeMask | PropertyChangeMask | ColormapChangeMask; */
+        /* attr.bit_gravity = ForgetGravity; */
+
+        /* win = */
+        /*   XCreateWindow(einfo->info.display, parent, x, y, w, h, 0, */
+        /*                 einfo->info.depth, InputOutput, einfo->info.visual, */
+        /*                 CWBackingStore | CWColormap | CWBackPixmap | */
+        /*                 CWBorderPixel | CWBitGravity | CWEventMask | */
+        /*                 CWOverrideRedirect, &attr); */
+
+        einfo->info.drawable = win;
+
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+             ecore_x_window_free(win);
+             return 0;
+          }
+     }
+   else
+     win = 0;
+
+   return win;
+}
+#endif
+
+static int
+_ecore_evas_x_render(Ecore_Evas *ee)
+{
+   int rend = 0;
+   Eina_List *updates = NULL;
+   Eina_List *ll;
+   Ecore_Evas *ee2;
+
+   if ((!ee->no_comp_sync) && (_ecore_evas_app_comp_sync) &&
+       (ee->engine.x.sync_counter) && (!ee->engine.x.sync_began) &&
+       (!ee->engine.x.sync_cancel))
+     return 0;
+
+   EINA_LIST_FOREACH(ee->sub_ecore_evas, ll, ee2)
+     {
+        if (ee2->func.fn_pre_render) ee2->func.fn_pre_render(ee2);
+        if (ee2->engine.func->fn_render)
+          rend |= ee2->engine.func->fn_render(ee2);
+        if (ee2->func.fn_post_render) ee2->func.fn_post_render(ee2);
+     }
+
+   if (ee->func.fn_pre_render) ee->func.fn_pre_render(ee);
+   updates = evas_render_updates(ee->evas);
+   if (ee->prop.avoid_damage)
+     {
+        if (ee->engine.x.using_bg_pixmap)
+          {
+             if (updates)
+               {
+                  Eina_List *l = NULL;
+                  Eina_Rectangle *r;
+
+                  EINA_LIST_FOREACH(updates, l, r)
+                    ecore_x_window_area_clear(ee->prop.window,
+                                              r->x, r->y, r->w, r->h);
+                  if (ee->shaped)
+                    {
+#ifdef EVAS_FRAME_QUEUING
+                       evas_sync(ee->evas);
+#endif
+                       ecore_x_window_shape_mask_set(ee->prop.window,
+                                                     ee->engine.x.mask);
+                    }
+                  if (ee->alpha)
+                    {
+#ifdef EVAS_FRAME_QUEUING
+                       /* wait until ee->engine.x.mask being updated */
+//                     evas_sync(ee->evas);
+#endif
+//                     ecore_x_window_shape_input_mask_set(ee->prop.window, ee->engine.x.mask);
+                    }
+                  evas_render_updates_free(updates);
+                  _ecore_evas_idle_timeout_update(ee);
+                  rend = 1;
+               }
+          }
+        else
+          {
+             if (updates)
+               {
+                  Eina_List *l = NULL;
+                  Eina_Rectangle *r;
+
+                  EINA_LIST_FOREACH(updates, l, r)
+                    {
+                       Ecore_X_Rectangle rect;
+                       Ecore_X_XRegion *tmpr;
+
+                       if (!ee->engine.x.damages)
+                         ee->engine.x.damages = ecore_x_xregion_new();
+                       tmpr = ecore_x_xregion_new();
+                       if (ee->rotation == 0)
+                         {
+                            rect.x = r->x;
+                            rect.y = r->y;
+                            rect.width = r->w;
+                            rect.height = r->h;
+                         }
+                       else if (ee->rotation == 90)
+                         {
+                            rect.x = r->y;
+                            rect.y = ee->h - r->x - r->w;
+                            rect.width = r->h;
+                            rect.height = r->w;
+                         }
+                       else if (ee->rotation == 180)
+                         {
+                            rect.x = ee->w - r->x - r->w;
+                            rect.y = ee->h - r->y - r->h;
+                            rect.width = r->w;
+                            rect.height = r->h;
+                         }
+                       else if (ee->rotation == 270)
+                         {
+                            rect.x = ee->w - r->y - r->h;
+                            rect.y = r->x;
+                            rect.width = r->h;
+                            rect.height = r->w;
+                         }
+                       ecore_x_xregion_union_rect(tmpr, ee->engine.x.damages,
+                                                  &rect);
+                       ecore_x_xregion_free(ee->engine.x.damages);
+                       ee->engine.x.damages = tmpr;
+                    }
+                  if (ee->engine.x.damages)
+                    {
+                       /* if we have a damage pixmap - we can avoid exposures by
+                        * disabling them just for setting the mask */
+                       ecore_x_event_mask_set(ee->prop.window,
+                                              ECORE_X_EVENT_MASK_KEY_DOWN |
+                                              ECORE_X_EVENT_MASK_KEY_UP |
+                                              ECORE_X_EVENT_MASK_MOUSE_DOWN |
+                                              ECORE_X_EVENT_MASK_MOUSE_UP |
+                                              ECORE_X_EVENT_MASK_MOUSE_IN |
+                                              ECORE_X_EVENT_MASK_MOUSE_OUT |
+                                              ECORE_X_EVENT_MASK_MOUSE_MOVE |
+                                              //                                         ECORE_X_EVENT_MASK_WINDOW_DAMAGE |
+                                              ECORE_X_EVENT_MASK_WINDOW_VISIBILITY |
+                                              ECORE_X_EVENT_MASK_WINDOW_CONFIGURE |
+                                              ECORE_X_EVENT_MASK_WINDOW_FOCUS_CHANGE |
+                                              ECORE_X_EVENT_MASK_WINDOW_PROPERTY |
+                                              ECORE_X_EVENT_MASK_WINDOW_COLORMAP
+                                             );
+                       if (ee->shaped)
+                         ecore_x_window_shape_mask_set(ee->prop.window,
+                                                       ee->engine.x.mask);
+                       /* and re-enable them again */
+                       ecore_x_event_mask_set(ee->prop.window,
+                                              ECORE_X_EVENT_MASK_KEY_DOWN |
+                                              ECORE_X_EVENT_MASK_KEY_UP |
+                                              ECORE_X_EVENT_MASK_MOUSE_DOWN |
+                                              ECORE_X_EVENT_MASK_MOUSE_UP |
+                                              ECORE_X_EVENT_MASK_MOUSE_IN |
+                                              ECORE_X_EVENT_MASK_MOUSE_OUT |
+                                              ECORE_X_EVENT_MASK_MOUSE_MOVE |
+                                              ECORE_X_EVENT_MASK_WINDOW_DAMAGE |
+                                              ECORE_X_EVENT_MASK_WINDOW_VISIBILITY |
+                                              ECORE_X_EVENT_MASK_WINDOW_CONFIGURE |
+                                              ECORE_X_EVENT_MASK_WINDOW_FOCUS_CHANGE |
+                                              ECORE_X_EVENT_MASK_WINDOW_PROPERTY |
+                                              ECORE_X_EVENT_MASK_WINDOW_COLORMAP
+                                             );
+                       ecore_x_xregion_set(ee->engine.x.damages, ee->engine.x.gc);
+                       ecore_x_pixmap_paste(ee->engine.x.pmap, ee->prop.window,
+                                            ee->engine.x.gc, 0, 0, ee->w, ee->h,
+                                            0, 0);
+                       ecore_x_xregion_free(ee->engine.x.damages);
+                       ee->engine.x.damages = NULL;
+                    }
+                  evas_render_updates_free(updates);
+                  _ecore_evas_idle_timeout_update(ee);
+                  rend = 1;
+               }
+          }
+     }
+   else if (((ee->visible) && (ee->draw_ok)) ||
+            ((ee->should_be_visible) && (ee->prop.fullscreen)) ||
+            ((ee->should_be_visible) && (ee->prop.override)))
+     {
+        if (updates)
+          {
+             if (ee->shaped)
+               {
+#ifdef EVAS_FRAME_QUEUING
+                  evas_sync(ee->evas);
+#endif
+                  ecore_x_window_shape_mask_set(ee->prop.window,
+                                                ee->engine.x.mask);
+               }
+             if (ee->alpha)
+               {
+#ifdef EVAS_FRAME_QUEUING
+                  /* wait until ee->engine.x.mask being updated */
+//                evas_sync(ee->evas);
+#endif
+//                ecore_x_window_shape_input_mask_set(ee->prop.window, ee->engine.x.mask);
+               }
+             evas_render_updates_free(updates);
+             _ecore_evas_idle_timeout_update(ee);
+             rend = 1;
+          }
+     }
+   else
+     evas_norender(ee->evas);
+   if (ee->func.fn_post_render) ee->func.fn_post_render(ee);
+/*
+   if (rend)
+     {
+        static int frames = 0;
+        static double t0 = 0.0;
+        double t, td;
+
+        t = ecore_time_get();
+        frames++;
+        if ((t - t0) > 1.0)
+          {
+             td = t - t0;
+             printf("FPS: %3.3f\n", (double)frames / td);
+             frames = 0;
+             t0 = t;
+          }
+     }
+ */
+
+   return rend;
+}
+
+static void
+_ecore_evas_x_resize_shape(Ecore_Evas *ee)
+{
+   if (!strcmp(ee->driver, "software_x11"))
+     {
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+        Evas_Engine_Info_Software_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
+        if (einfo)
+          {
+             unsigned int foreground;
+             Ecore_X_GC gc;
+
+             if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+             ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, 1);
+             foreground = 0;
+             gc = ecore_x_gc_new(ee->engine.x.mask,
+                                 ECORE_X_GC_VALUE_MASK_FOREGROUND,
+                                 &foreground);
+             ecore_x_drawable_rectangle_fill(ee->engine.x.mask, gc,
+                                             0, 0, ee->w, ee->h);
+             ecore_x_gc_free(gc);
+             einfo->info.mask = ee->engine.x.mask;
+             if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+               {
+                  ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+               }
+             evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+          }
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
+     }
+   else if (!strcmp(ee->driver, "software_16_x11"))
+     {
+#if BUILD_ECORE_EVAS_SOFTWARE_16_X11
+# if 0 /* XXX no shaped window support for software_16_x11 */
+        Evas_Engine_Info_Software_16_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_16_X11 *)evas_engine_info_get(ee->evas);
+        if (einfo)
+          {
+             if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+             ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, 1);
+             einfo->info.mask = ee->engine.x.mask;
+             if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+               {
+                  ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+               }
+             evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+          }
+# endif /* XXX no shaped window support for software_16_x11 */
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_16_X11 */
+     }
+   if (!strcmp(ee->driver, "software_8_x11"))
+     {
+#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
+        Evas_Engine_Info_Software_8_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_8_X11 *)evas_engine_info_get(ee->evas);
+        if (einfo)
+          {
+             unsigned int foreground;
+             Ecore_X_GC gc;
+
+             if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+             ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, 1);
+             foreground = 0;
+             gc = ecore_x_gc_new(ee->engine.x.mask,
+                                 ECORE_X_GC_VALUE_MASK_FOREGROUND,
+                                 &foreground);
+             ecore_x_drawable_rectangle_fill(ee->engine.x.mask, gc,
+                                             0, 0, ee->w, ee->h);
+             ecore_x_gc_free(gc);
+             einfo->info.mask = ee->engine.x.mask;
+             if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+               {
+                  ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+               }
+             evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+          }
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_8_X11 */
+     }
+}
+
+/* TODO: we need to make this work for all the states, not just sticky */
+static Eina_Bool
+_ecore_evas_x_event_property_change(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_X_Event_Window_Property *e;
+
+   e = event;
+   ee = ecore_event_window_match(e->win);
+   if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+   if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+   if (e->atom == ECORE_X_ATOM_NET_WM_STATE)
+     {
+        unsigned int i, num;
+        Ecore_X_Window_State *state;
+        int sticky = 0;
+
+        /* TODO: we need to move those to the end, with if statements */
+        ee->engine.x.state.modal = 0;
+        ee->engine.x.state.maximized_v = 0;
+        ee->engine.x.state.maximized_h = 0;
+        ee->engine.x.state.shaded = 0;
+        ee->engine.x.state.skip_taskbar = 0;
+        ee->engine.x.state.skip_pager = 0;
+        ee->prop.fullscreen = 0;
+        ee->engine.x.state.fullscreen = 0;
+        ee->engine.x.state.above = 0;
+        ee->engine.x.state.below = 0;
+
+        ecore_x_netwm_window_state_get(e->win, &state, &num);
+        if (state)
+          {
+             for (i = 0; i < num; i++)
+               {
+                  switch (state[i])
+                    {
+                     case ECORE_X_WINDOW_STATE_MODAL:
+                        ee->engine.x.state.modal = 1;
+                        break;
+                     case ECORE_X_WINDOW_STATE_STICKY:
+                        if (ee->prop.sticky && ee->engine.x.state.sticky)
+                          break;
+
+                        sticky = 1;
+                        ee->prop.sticky = 1;
+                        ee->engine.x.state.sticky = 1;
+                        if (ee->func.fn_sticky) ee->func.fn_sticky(ee);
+                        break;
+                     case ECORE_X_WINDOW_STATE_MAXIMIZED_VERT:
+                        ee->engine.x.state.maximized_v = 1;
+                        break;
+                     case ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ:
+                        ee->engine.x.state.maximized_h = 1;
+                        break;
+                     case ECORE_X_WINDOW_STATE_SHADED:
+                        ee->engine.x.state.shaded = 1;
+                        break;
+                     case ECORE_X_WINDOW_STATE_SKIP_TASKBAR:
+                        ee->engine.x.state.skip_taskbar = 1;
+                        break;
+                     case ECORE_X_WINDOW_STATE_SKIP_PAGER:
+                        ee->engine.x.state.skip_pager = 1;
+                        break;
+                     case ECORE_X_WINDOW_STATE_FULLSCREEN:
+                        ee->prop.fullscreen = 1;
+                        ee->engine.x.state.fullscreen = 1;
+                        break;
+                     case ECORE_X_WINDOW_STATE_ABOVE:
+                        ee->engine.x.state.above = 1;
+                        break;
+                     case ECORE_X_WINDOW_STATE_BELOW:
+                        ee->engine.x.state.below = 1;
+                        break;
+                     default:
+                        break;
+                    }
+               }
+             free(state);
+          }
+
+        if ((ee->prop.sticky) && (!sticky))
+          {
+             ee->prop.sticky = 0;
+             ee->engine.x.state.sticky = 0;
+             if (ee->func.fn_unsticky) ee->func.fn_unsticky(ee);
+          }
+     }
+
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_x_event_visibility_change(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_X_Event_Window_Visibility_Change *e;
+
+   e = event;
+   ee = ecore_event_window_match(e->win);
+   if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+   if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+//   printf("VIS CHANGE OBSCURED: %p %i\n", ee, e->fully_obscured);
+   if (e->fully_obscured)
+     {
+        /* FIXME: round trip */
+        if (!ecore_x_screen_is_composited(ee->engine.x.screen_num))
+          ee->draw_ok = 0;
+     }
+   else
+     ee->draw_ok = 1;
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_x_event_client_message(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_X_Event_Client_Message *e;
+
+   e = event;
+   if (e->format != 32) return ECORE_CALLBACK_PASS_ON;
+   if (e->message_type == ECORE_X_ATOM_E_COMP_SYNC_BEGIN)
+     {
+        ee = ecore_event_window_match(e->data.l[0]);
+        if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+        if (e->data.l[0] != (long)ee->prop.window)
+          return ECORE_CALLBACK_PASS_ON;
+        if (!ee->engine.x.sync_began)
+          {
+             // qeue a damage + draw. work around an event re-ordering thing.
+             evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+          }
+        ee->engine.x.sync_began = 1;
+        ee->engine.x.sync_cancel = 0;
+     }
+   else if (e->message_type == ECORE_X_ATOM_E_COMP_SYNC_END)
+     {
+        ee = ecore_event_window_match(e->data.l[0]);
+        if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+        if (e->data.l[0] != (long)ee->prop.window)
+          return ECORE_CALLBACK_PASS_ON;
+        ee->engine.x.sync_began = 0;
+        ee->engine.x.sync_cancel = 0;
+     }
+   else if (e->message_type == ECORE_X_ATOM_E_COMP_SYNC_CANCEL)
+     {
+        ee = ecore_event_window_match(e->data.l[0]);
+        if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+        if (e->data.l[0] != (long)ee->prop.window)
+          return ECORE_CALLBACK_PASS_ON;
+        ee->engine.x.sync_began = 0;
+        ee->engine.x.sync_cancel = 1;
+     }
+   else if ((e->message_type == ECORE_X_ATOM_WM_PROTOCOLS) &&
+            (e->data.l[0] == (int)ECORE_X_ATOM_NET_WM_SYNC_REQUEST))
+     {
+        ee = ecore_event_window_match(e->win);
+        if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+        ee->engine.x.netwm_sync_val_lo = (unsigned int)e->data.l[2];
+        ee->engine.x.netwm_sync_val_hi = (int)e->data.l[3];
+        ee->engine.x.netwm_sync_set = 1;
+     }
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_x_event_mouse_in(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_X_Event_Mouse_In *e;
+
+   e = event;
+   ee = ecore_event_window_match(e->win);
+   if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+   if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+/*    { */
+/*       time_t t; */
+/*       char *ct; */
+
+/*       const char *modes[] = { */
+/*        "MODE_NORMAL", */
+/*        "MODE_WHILE_GRABBED", */
+/*        "MODE_GRAB", */
+/*        "MODE_UNGRAB" */
+/*       }; */
+/*       const char *details[] = { */
+/*        "DETAIL_ANCESTOR", */
+/*        "DETAIL_VIRTUAL", */
+/*        "DETAIL_INFERIOR", */
+/*        "DETAIL_NON_LINEAR", */
+/*        "DETAIL_NON_LINEAR_VIRTUAL", */
+/*        "DETAIL_POINTER", */
+/*        "DETAIL_POINTER_ROOT", */
+/*        "DETAIL_DETAIL_NONE" */
+/*       }; */
+/*       t = time(NULL); */
+/*       ct = ctime(&t); */
+/*       ct[strlen(ct) - 1] = 0; */
+/*       printf("@@ ->IN 0x%x 0x%x %s md=%s dt=%s\n", */
+/*             e->win, e->event_win, */
+/*             ct, */
+/*             modes[e->mode], */
+/*             details[e->detail]); */
+/*    } */
+   // disable. causes more problems than it fixes
+   //   if ((e->mode == ECORE_X_EVENT_MODE_GRAB) ||
+   //       (e->mode == ECORE_X_EVENT_MODE_UNGRAB))
+   //     return 0;
+   /* if (e->mode != ECORE_X_EVENT_MODE_NORMAL) return 0; */
+   if (ee->func.fn_mouse_in) ee->func.fn_mouse_in(ee);
+   ecore_event_evas_modifier_lock_update(ee->evas, e->modifiers);
+   evas_event_feed_mouse_in(ee->evas, e->time, NULL);
+   _ecore_evas_mouse_move_process(ee, e->x, e->y, e->time);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_x_event_mouse_out(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_X_Event_Mouse_Out *e;
+
+   e = event;
+   ee = ecore_event_window_match(e->win);
+   if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON;
+   /* pass on event */
+   if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+/*    { */
+/*       time_t t; */
+/*       char *ct; */
+
+/*       const char *modes[] = { */
+/*        "MODE_NORMAL", */
+/*        "MODE_WHILE_GRABBED", */
+/*        "MODE_GRAB", */
+/*        "MODE_UNGRAB" */
+/*       }; */
+/*       const char *details[] = { */
+/*        "DETAIL_ANCESTOR", */
+/*        "DETAIL_VIRTUAL", */
+/*        "DETAIL_INFERIOR", */
+/*        "DETAIL_NON_LINEAR", */
+/*        "DETAIL_NON_LINEAR_VIRTUAL", */
+/*        "DETAIL_POINTER", */
+/*        "DETAIL_POINTER_ROOT", */
+/*        "DETAIL_DETAIL_NONE" */
+/*       }; */
+/*       t = time(NULL); */
+/*       ct = ctime(&t); */
+/*       ct[strlen(ct) - 1] = 0; */
+/*       printf("@@ ->OUT 0x%x 0x%x %s md=%s dt=%s\n", */
+/*             e->win, e->event_win, */
+/*             ct, */
+/*             modes[e->mode], */
+/*             details[e->detail]); */
+/*    } */
+   // disable. causes more problems than it fixes
+   //   if ((e->mode == ECORE_X_EVENT_MODE_GRAB) ||
+   //       (e->mode == ECORE_X_EVENT_MODE_UNGRAB))
+   //     return 0;
+   /* if (e->mode != ECORE_X_EVENT_MODE_NORMAL) return 0; */
+   ecore_event_evas_modifier_lock_update(ee->evas, e->modifiers);
+   _ecore_evas_mouse_move_process(ee, e->x, e->y, e->time);
+   if (e->mode == ECORE_X_EVENT_MODE_GRAB)
+     evas_event_feed_mouse_cancel(ee->evas, e->time, NULL);
+   evas_event_feed_mouse_out(ee->evas, e->time, NULL);
+   if (ee->func.fn_mouse_out) ee->func.fn_mouse_out(ee);
+   if (ee->prop.cursor.object) evas_object_hide(ee->prop.cursor.object);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_x_event_window_focus_in(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_X_Event_Window_Focus_In *e;
+
+   e = event;
+   ee = ecore_event_window_match(e->win);
+   if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+   if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+   if (e->mode == ECORE_X_EVENT_MODE_UNGRAB) return ECORE_CALLBACK_PASS_ON;
+   ee->prop.focused = 1;
+   evas_focus_in(ee->evas);
+   if (ee->func.fn_focus_in) ee->func.fn_focus_in(ee);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_x_event_window_focus_out(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_X_Event_Window_Focus_Out *e;
+
+   e = event;
+   ee = ecore_event_window_match(e->win);
+   if ((!ee) || (ee->ignore_events)) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+   if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+   if (e->mode == ECORE_X_EVENT_MODE_GRAB) return ECORE_CALLBACK_PASS_ON;
+//   if (ee->prop.fullscreen)
+//     ecore_x_window_focus(ee->prop.window);
+   evas_focus_out(ee->evas);
+   ee->prop.focused = 0;
+   if (ee->func.fn_focus_out) ee->func.fn_focus_out(ee);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_x_event_window_damage(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_X_Event_Window_Damage *e;
+
+   e = event;
+   ee = ecore_event_window_match(e->win);
+   if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+   if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+   if (ee->engine.x.using_bg_pixmap) return ECORE_CALLBACK_PASS_ON;
+//   printf("EXPOSE %p [%i] %i %i %ix%i\n", ee, ee->prop.avoid_damage, e->x, e->y, e->w, e->h);
+   if (ee->prop.avoid_damage)
+     {
+        Ecore_X_Rectangle rect;
+        Ecore_X_XRegion *tmpr;
+
+        if (!ee->engine.x.damages)
+          ee->engine.x.damages = ecore_x_xregion_new();
+        tmpr = ecore_x_xregion_new();
+        rect.x = e->x;
+        rect.y = e->y;
+        rect.width = e->w;
+        rect.height = e->h;
+        ecore_x_xregion_union_rect(tmpr, ee->engine.x.damages, &rect);
+        ecore_x_xregion_free(ee->engine.x.damages);
+        ee->engine.x.damages = tmpr;
+/* no - this breaks things badly. disable. Ecore_X_Rectangle != XRectangle - see
+ *  the typedefs in x's headers and ecore_x's. also same with Region - it's a pointer in x - not an X ID
+        Ecore_X_Rectangle rect;
+        Ecore_X_XRegion  *tmpr;
+
+        if (!ee->engine.x.damages) ee->engine.x.damages = ecore_x_xregion_new();
+        tmpr = ecore_x_xregion_new();
+        rect.x = e->x;
+        rect.y = e->y;
+        rect.width = e->w;
+        rect.height = e->h;
+        ecore_x_xregion_union_rect(tmpr, ee->engine.x.damages, &rect);
+        ecore_x_xregion_free(ee->engine.x.damages);
+        ee->engine.x.damages = tmpr;
+ */
+     }
+   else
+     {
+        if (ee->rotation == 0)
+          evas_damage_rectangle_add(ee->evas, e->x, e->y, e->w, e->h);
+        else if (ee->rotation == 90)
+          evas_damage_rectangle_add(ee->evas,
+                                    ee->h - e->y - e->h, e->x, e->h, e->w);
+        else if (ee->rotation == 180)
+          evas_damage_rectangle_add(ee->evas, ee->w - e->x - e->w,
+                                    ee->h - e->y - e->h, e->w, e->h);
+        else if (ee->rotation == 270)
+          evas_damage_rectangle_add(ee->evas, e->y, ee->w - e->x - e->w,
+                                    e->h, e->w);
+     }
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_x_event_window_destroy(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_X_Event_Window_Destroy *e;
+
+   e = event;
+   ee = ecore_event_window_match(e->win);
+   if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+   if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+   if (ee->func.fn_destroy) ee->func.fn_destroy(ee);
+   _ecore_evas_x_sync_clear(ee);
+   ecore_evas_free(ee);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_x_event_window_configure(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_X_Event_Window_Configure *e;
+
+   e = event;
+   ee = ecore_event_window_match(e->win);
+   if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+   if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+   if (ee->engine.x.direct_resize) return ECORE_CALLBACK_PASS_ON;
+
+   ee->engine.x.configure_coming = 0;
+   if ((e->from_wm) || (ee->prop.override))
+     {
+        if ((ee->x != e->x) || (ee->y != e->y))
+          {
+             ee->x = e->x;
+             ee->y = e->y;
+             ee->req.x = ee->x;
+             ee->req.y = ee->y;
+             if (ee->func.fn_move) ee->func.fn_move(ee);
+          }
+     }
+   if ((ee->w != e->w) || (ee->h != e->h))
+     {
+        ee->w = e->w;
+        ee->h = e->h;
+        ee->req.w = ee->w;
+        ee->req.h = ee->h;
+        if ((ee->rotation == 90) || (ee->rotation == 270))
+          {
+             evas_output_size_set(ee->evas, ee->h, ee->w);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+          }
+        else
+          {
+             evas_output_size_set(ee->evas, ee->w, ee->h);
+             evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+          }
+        if (ee->prop.avoid_damage)
+          {
+             int pdam;
+
+             pdam = ecore_evas_avoid_damage_get(ee);
+             ecore_evas_avoid_damage_set(ee, 0);
+             ecore_evas_avoid_damage_set(ee, pdam);
+          }
+        if ((ee->shaped) || (ee->alpha))
+          _ecore_evas_x_resize_shape(ee);
+        if ((ee->expecting_resize.w > 0) && (ee->expecting_resize.h > 0))
+          {
+             if ((ee->expecting_resize.w == ee->w) &&
+                 (ee->expecting_resize.h == ee->h))
+               _ecore_evas_mouse_move_process(ee, ee->mouse.x, ee->mouse.y,
+                                              ecore_x_current_time_get());
+             ee->expecting_resize.w = 0;
+             ee->expecting_resize.h = 0;
+          }
+        if (ee->func.fn_resize) ee->func.fn_resize(ee);
+     }
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_x_event_window_delete_request(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_X_Event_Window_Delete_Request *e;
+
+   e = event;
+   ee = ecore_event_window_match(e->win);
+   if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+   if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+   if (ee->func.fn_delete_request) ee->func.fn_delete_request(ee);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_x_event_window_show(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_X_Event_Window_Show *e;
+   static int first_map_bug = -1;
+
+   e = event;
+   ee = ecore_event_window_match(e->win);
+   if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+   if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+   if (first_map_bug < 0)
+     {
+        char *bug = NULL;
+
+        if ((bug = getenv("ECORE_EVAS_GL_FIRST_MAP_BUG")))
+          first_map_bug = atoi(bug);
+        else
+          first_map_bug = 0;
+     }
+   if ((first_map_bug) && (!strcmp(ee->driver, "opengl_x11")))
+     evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+   if (ee->visible) return ECORE_CALLBACK_PASS_ON;
+//   if (ee->visible) return ECORE_CALLBACK_DONE;
+//   printf("SHOW EVENT %p\n", ee);
+   ee->visible = 1;
+   if (ee->func.fn_show) ee->func.fn_show(ee);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+static Eina_Bool
+_ecore_evas_x_event_window_hide(void *data __UNUSED__, int type __UNUSED__, void *event)
+{
+   Ecore_Evas *ee;
+   Ecore_X_Event_Window_Hide *e;
+
+   e = event;
+   ee = ecore_event_window_match(e->win);
+   if (!ee) return ECORE_CALLBACK_PASS_ON; /* pass on event */
+   if (e->win != ee->prop.window) return ECORE_CALLBACK_PASS_ON;
+   if (!ee->visible) return ECORE_CALLBACK_PASS_ON;
+//   if (!ee->visible) return ECORE_CALLBACK_DONE;
+//   printf("HIDE EVENT %p\n", ee);
+   ee->visible = 0;
+   if (ee->func.fn_hide) ee->func.fn_hide(ee);
+   return ECORE_CALLBACK_PASS_ON;
+}
+
+/* FIXME, should be in idler */
+/* FIXME, round trip */
+static void
+_ecore_evas_x_size_pos_hints_update(Ecore_Evas *ee)
+{
+   ecore_x_icccm_size_pos_hints_set(ee->prop.window,
+                                    ee->prop.request_pos /*request_pos */,
+                                    ECORE_X_GRAVITY_NW /* gravity */,
+                                    ee->prop.min.w /* min_w */,
+                                    ee->prop.min.h /* min_h */,
+                                    ee->prop.max.w /* max_w */,
+                                    ee->prop.max.h /* max_h */,
+                                    ee->prop.base.w /* base_w */,
+                                    ee->prop.base.h /* base_h */,
+                                    ee->prop.step.w /* step_x */,
+                                    ee->prop.step.h /* step_y */,
+                                    0 /* min_aspect */,
+                                    0 /* max_aspect */);
+}
+
+/* FIXME, should be in idler */
+static void
+_ecore_evas_x_state_update(Ecore_Evas *ee)
+{
+   Ecore_X_Window_State state[10];
+   int num = 0;
+
+   /*
+   if (bd->client.netwm.state.modal)
+     state[num++] = ECORE_X_WINDOW_STATE_MODAL;
+   */
+   if (ee->engine.x.state.sticky)
+     state[num++] = ECORE_X_WINDOW_STATE_STICKY;
+   /*
+   if (bd->client.netwm.state.maximized_v)
+     state[num++] = ECORE_X_WINDOW_STATE_MAXIMIZED_VERT;
+   if (bd->client.netwm.state.maximized_h)
+     state[num++] = ECORE_X_WINDOW_STATE_MAXIMIZED_HORZ;
+   if (bd->client.netwm.state.shaded)
+     state[num++] = ECORE_X_WINDOW_STATE_SHADED;
+   if (bd->client.netwm.state.skip_taskbar)
+     state[num++] = ECORE_X_WINDOW_STATE_SKIP_TASKBAR;
+   if (bd->client.netwm.state.skip_pager)
+     state[num++] = ECORE_X_WINDOW_STATE_SKIP_PAGER;
+   if (bd->client.netwm.state.hidden)
+     state[num++] = ECORE_X_WINDOW_STATE_HIDDEN;
+   */
+   if (ee->engine.x.state.fullscreen)
+     state[num++] = ECORE_X_WINDOW_STATE_FULLSCREEN;
+   if (ee->engine.x.state.above)
+     state[num++] = ECORE_X_WINDOW_STATE_ABOVE;
+   if (ee->engine.x.state.below)
+     state[num++] = ECORE_X_WINDOW_STATE_BELOW;
+
+   ecore_x_netwm_window_state_set(ee->prop.window, state, num);
+}
+
+static void
+_ecore_evas_x_layer_update(Ecore_Evas *ee)
+{
+   if (ee->should_be_visible)
+     {
+        /* We need to send a netwm request to the wm */
+        /* FIXME: Do we have to remove old state before adding new? */
+        if (ee->prop.layer < 3)
+          {
+             if (ee->engine.x.state.above)
+               {
+                  ee->engine.x.state.above = 0;
+                  ecore_x_netwm_state_request_send(ee->prop.window,
+                                                   ee->engine.x.win_root,
+                                                   ECORE_X_WINDOW_STATE_ABOVE, -1, 0);
+               }
+             if (!ee->engine.x.state.below)
+               {
+                  ee->engine.x.state.below = 1;
+                  ecore_x_netwm_state_request_send(ee->prop.window,
+                                                   ee->engine.x.win_root,
+                                                   ECORE_X_WINDOW_STATE_BELOW, -1, 1);
+               }
+          }
+        else if (ee->prop.layer > 5)
+          {
+             if (ee->engine.x.state.below)
+               {
+                  ee->engine.x.state.below = 0;
+                  ecore_x_netwm_state_request_send(ee->prop.window,
+                                                   ee->engine.x.win_root,
+                                                   ECORE_X_WINDOW_STATE_BELOW, -1, 0);
+               }
+             if (!ee->engine.x.state.above)
+               {
+                  ee->engine.x.state.above = 1;
+                  ecore_x_netwm_state_request_send(ee->prop.window,
+                                                   ee->engine.x.win_root,
+                                                   ECORE_X_WINDOW_STATE_ABOVE, -1, 1);
+               }
+          }
+        else
+          {
+             if (ee->engine.x.state.below)
+               {
+                  ee->engine.x.state.below = 0;
+                  ecore_x_netwm_state_request_send(ee->prop.window,
+                                                   ee->engine.x.win_root,
+                                                   ECORE_X_WINDOW_STATE_BELOW, -1, 0);
+               }
+             if (ee->engine.x.state.above)
+               {
+                  ee->engine.x.state.above = 0;
+                  ecore_x_netwm_state_request_send(ee->prop.window,
+                                                   ee->engine.x.win_root,
+                                                   ECORE_X_WINDOW_STATE_ABOVE, -1, 0);
+               }
+          }
+     }
+   else
+     {
+        /* Just set the state */
+        if (ee->prop.layer < 3)
+          {
+             if ((ee->engine.x.state.above) || (!ee->engine.x.state.below))
+               {
+                  ee->engine.x.state.above = 0;
+                  ee->engine.x.state.below = 1;
+                  _ecore_evas_x_state_update(ee);
+               }
+          }
+        else if (ee->prop.layer > 5)
+          {
+             if ((!ee->engine.x.state.above) || (ee->engine.x.state.below))
+               {
+                  ee->engine.x.state.above = 1;
+                  ee->engine.x.state.below = 0;
+                  _ecore_evas_x_state_update(ee);
+               }
+          }
+        else
+          {
+             if ((ee->engine.x.state.above) || (ee->engine.x.state.below))
+               {
+                  ee->engine.x.state.above = 0;
+                  ee->engine.x.state.below = 0;
+                  _ecore_evas_x_state_update(ee);
+               }
+          }
+     }
+   /* FIXME: Set gnome layer */
+}
+
+static int
+_ecore_evas_x_init(void)
+{
+   _ecore_evas_init_count++;
+   if (_ecore_evas_init_count > 1) return _ecore_evas_init_count;
+   ecore_evas_event_handlers[0] =
+     ecore_event_handler_add(ECORE_X_EVENT_MOUSE_IN,
+                             _ecore_evas_x_event_mouse_in, NULL);
+   ecore_evas_event_handlers[1] =
+     ecore_event_handler_add(ECORE_X_EVENT_MOUSE_OUT,
+                             _ecore_evas_x_event_mouse_out, NULL);
+   ecore_evas_event_handlers[2] =
+     ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_IN,
+                             _ecore_evas_x_event_window_focus_in, NULL);
+   ecore_evas_event_handlers[3] =
+     ecore_event_handler_add(ECORE_X_EVENT_WINDOW_FOCUS_OUT,
+                             _ecore_evas_x_event_window_focus_out, NULL);
+   ecore_evas_event_handlers[4] =
+     ecore_event_handler_add(ECORE_X_EVENT_WINDOW_DAMAGE,
+                             _ecore_evas_x_event_window_damage, NULL);
+   ecore_evas_event_handlers[5] =
+     ecore_event_handler_add(ECORE_X_EVENT_WINDOW_DESTROY,
+                             _ecore_evas_x_event_window_destroy, NULL);
+   ecore_evas_event_handlers[6] =
+     ecore_event_handler_add(ECORE_X_EVENT_WINDOW_CONFIGURE,
+                             _ecore_evas_x_event_window_configure, NULL);
+   ecore_evas_event_handlers[7] =
+     ecore_event_handler_add(ECORE_X_EVENT_WINDOW_DELETE_REQUEST,
+                             _ecore_evas_x_event_window_delete_request, NULL);
+   ecore_evas_event_handlers[8] =
+     ecore_event_handler_add(ECORE_X_EVENT_WINDOW_SHOW,
+                             _ecore_evas_x_event_window_show, NULL);
+   ecore_evas_event_handlers[9] =
+     ecore_event_handler_add(ECORE_X_EVENT_WINDOW_HIDE,
+                             _ecore_evas_x_event_window_hide, NULL);
+   ecore_evas_event_handlers[10] =
+     ecore_event_handler_add(ECORE_X_EVENT_WINDOW_PROPERTY,
+                             _ecore_evas_x_event_property_change, NULL);
+   ecore_evas_event_handlers[11] =
+     ecore_event_handler_add(ECORE_X_EVENT_WINDOW_VISIBILITY_CHANGE,
+                             _ecore_evas_x_event_visibility_change, NULL);
+   ecore_evas_event_handlers[12] =
+     ecore_event_handler_add(ECORE_X_EVENT_CLIENT_MESSAGE,
+                             _ecore_evas_x_event_client_message, NULL);
+   ecore_event_evas_init();
+   return _ecore_evas_init_count;
+}
+
+static void
+_ecore_evas_x_free(Ecore_Evas *ee)
+{
+   _ecore_evas_x_group_leader_unset(ee);
+   _ecore_evas_x_sync_set(ee);
+   if (ee->engine.x.win_shaped_input)
+     ecore_x_window_free(ee->engine.x.win_shaped_input);
+   ecore_x_window_free(ee->prop.window);
+   if (ee->engine.x.pmap) ecore_x_pixmap_free(ee->engine.x.pmap);
+   if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+   if (ee->engine.x.gc) ecore_x_gc_free(ee->engine.x.gc);
+   if (ee->engine.x.damages) ecore_x_xregion_free(ee->engine.x.damages);
+   ee->engine.x.pmap = 0;
+   ee->engine.x.mask = 0;
+   ee->engine.x.gc = 0;
+   ee->engine.x.damages = NULL;
+   ecore_event_window_unregister(ee->prop.window);
+   while (ee->engine.x.win_extra)
+     {
+        Ecore_X_Window *winp;
+
+        winp = ee->engine.x.win_extra->data;
+        ee->engine.x.win_extra =
+          eina_list_remove_list(ee->engine.x.win_extra, ee->engine.x.win_extra);
+        ecore_event_window_unregister(*winp);
+        free(winp);
+     }
+   _ecore_evas_x_shutdown();
+   ecore_x_shutdown();
+}
+
+static void
+_ecore_evas_x_callback_delete_request_set(Ecore_Evas *ee, void (*func) (Ecore_Evas *ee))
+{
+   ee->func.fn_delete_request = func;
+   _ecore_evas_x_protocols_set(ee);
+   _ecore_evas_x_sync_set(ee);
+}
+
+static void
+_ecore_evas_x_move(Ecore_Evas *ee, int x, int y)
+{
+   ee->req.x = x;
+   ee->req.y = y;
+   if (ee->engine.x.direct_resize)
+     {
+        if (!ee->engine.x.managed)
+          {
+             if ((x != ee->x) || (y != ee->y))
+               {
+                  ee->x = x;
+                  ee->y = y;
+                  ecore_x_window_move(ee->prop.window, x, y);
+                  if (!ee->should_be_visible)
+                    {
+                       /* We need to request pos */
+                       ee->prop.request_pos = 1;
+                       _ecore_evas_x_size_pos_hints_update(ee);
+                    }
+                  if (ee->func.fn_move) ee->func.fn_move(ee);
+               }
+          }
+     }
+   else
+     {
+        if (((ee->x != x) || (ee->y != y)) ||
+            (ee->engine.x.configure_coming))
+          {
+             ee->engine.x.configure_coming = 1;
+             if (!ee->engine.x.managed)
+               {
+                  ee->x = x;
+                  ee->y = y;
+               }
+             ecore_x_window_move(ee->prop.window, x, y);
+          }
+        if (!ee->should_be_visible)
+          {
+             /* We need to request pos */
+             ee->prop.request_pos = 1;
+             _ecore_evas_x_size_pos_hints_update(ee);
+          }
+     }
+}
+
+static void
+_ecore_evas_x_managed_move(Ecore_Evas *ee, int x, int y)
+{
+   ee->req.x = x;
+   ee->req.y = y;
+   if (ee->engine.x.direct_resize)
+     {
+        ee->engine.x.managed = 1;
+        if ((x != ee->x) || (y != ee->y))
+          {
+             ee->x = x;
+             ee->y = y;
+             if (ee->func.fn_move) ee->func.fn_move(ee);
+          }
+     }
+}
+
+static void
+_ecore_evas_x_resize(Ecore_Evas *ee, int w, int h)
+{
+   ee->req.w = w;
+   ee->req.h = h;
+   if (ee->engine.x.direct_resize)
+     {
+        if ((ee->w != w) || (ee->h != h))
+          {
+             ee->w = w;
+             ee->h = h;
+             ecore_x_window_resize(ee->prop.window, w, h);
+             if ((ee->rotation == 90) || (ee->rotation == 270))
+               {
+                  evas_output_size_set(ee->evas, ee->h, ee->w);
+                  evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+               }
+             else
+               {
+                  evas_output_size_set(ee->evas, ee->w, ee->h);
+                  evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+               }
+             if (ee->prop.avoid_damage)
+               {
+                  int pdam;
+
+                  pdam = ecore_evas_avoid_damage_get(ee);
+                  ecore_evas_avoid_damage_set(ee, 0);
+                  ecore_evas_avoid_damage_set(ee, pdam);
+               }
+             if ((ee->shaped) || (ee->alpha))
+               _ecore_evas_x_resize_shape(ee);
+             if (ee->func.fn_resize) ee->func.fn_resize(ee);
+          }
+     }
+   else if (((ee->w != w) || (ee->h != h)) || 
+            (ee->engine.x.configure_coming))
+     {
+        ee->engine.x.configure_coming = 1;
+        ecore_x_window_resize(ee->prop.window, w, h);
+     }
+}
+
+static void
+_ecore_evas_x_move_resize(Ecore_Evas *ee, int x, int y, int w, int h)
+{
+   ee->req.x = x;
+   ee->req.y = y;
+   ee->req.w = w;
+   ee->req.h = h;
+   if (ee->engine.x.direct_resize)
+     {
+        if ((ee->w != w) || (ee->h != h) || (x != ee->x) || (y != ee->y))
+          {
+             int change_size = 0, change_pos = 0;
+
+             if ((ee->w != w) || (ee->h != h)) change_size = 1;
+             if (!ee->engine.x.managed)
+               {
+                  if ((x != ee->x) || (y != ee->y)) change_pos = 1;
+               }
+             ecore_x_window_move_resize(ee->prop.window, x, y, w, h);
+             if (!ee->engine.x.managed)
+               {
+                  ee->x = x;
+                  ee->y = y;
+               }
+             ee->w = w;
+             ee->h = h;
+             if ((ee->rotation == 90) || (ee->rotation == 270))
+               {
+                  evas_output_size_set(ee->evas, ee->h, ee->w);
+                  evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+               }
+             else
+               {
+                  evas_output_size_set(ee->evas, ee->w, ee->h);
+                  evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+               }
+             if (ee->prop.avoid_damage)
+               {
+                  int pdam;
+
+                  pdam = ecore_evas_avoid_damage_get(ee);
+                  ecore_evas_avoid_damage_set(ee, 0);
+                  ecore_evas_avoid_damage_set(ee, pdam);
+               }
+             if ((ee->shaped) || (ee->alpha))
+               _ecore_evas_x_resize_shape(ee);
+             if (change_pos)
+               {
+                  if (ee->func.fn_move) ee->func.fn_move(ee);
+               }
+             if (change_size)
+               {
+                  if (ee->func.fn_resize) ee->func.fn_resize(ee);
+               }
+          }
+     }
+   else if (((ee->w != w) || (ee->h != h) || (ee->x != x) || (ee->y != y)) || 
+            (ee->engine.x.configure_coming))
+     {
+        ee->engine.x.configure_coming = 1;
+        ecore_x_window_move_resize(ee->prop.window, x, y, w, h);
+        if (!ee->engine.x.managed)
+          {
+             ee->x = x;
+             ee->y = y;
+          }
+     }
+}
+
+static void
+_ecore_evas_x_rotation_set_internal(Ecore_Evas *ee, int rotation, int resize,
+                                    Evas_Engine_Info *einfo)
+{
+   int rot_dif;
+
+   rot_dif = ee->rotation - rotation;
+   if (rot_dif < 0) rot_dif = -rot_dif;
+
+   if (rot_dif != 180)
+     {
+        int minw, minh, maxw, maxh, basew, baseh, stepw, steph;
+
+        if (!evas_engine_info_set(ee->evas, einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+
+        if (!resize)
+          {
+             ee->engine.x.configure_coming = 1;
+             if (!ee->prop.fullscreen)
+               {
+                  ecore_x_window_resize(ee->prop.window, ee->req.h, ee->req.w);
+                  ee->expecting_resize.w = ee->h;
+                  ee->expecting_resize.h = ee->w;
+               }
+             else
+               {
+                  int w, h;
+
+                  ecore_x_window_size_get(ee->prop.window, &w, &h);
+                  ecore_x_window_resize(ee->prop.window, h, w);
+                  if ((rotation == 0) || (rotation == 180))
+                    {
+                       evas_output_size_set(ee->evas, ee->req.w, ee->req.h);
+                       evas_output_viewport_set(ee->evas, 0, 0, ee->req.w, ee->req.h);
+                    }
+                  else
+                    {
+                       evas_output_size_set(ee->evas, ee->req.h, ee->req.w);
+                       evas_output_viewport_set(ee->evas, 0, 0, ee->req.h, ee->req.w);
+                    }
+                  if (ee->func.fn_resize) ee->func.fn_resize(ee);
+               }
+             if ((ee->rotation == 90) || (ee->rotation == 270))
+               evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.h, ee->req.w);
+             else
+               evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.w, ee->req.h);
+          }
+        else
+          {
+             /* int w, h; */
+
+             /* ecore_x_window_size_get(ee->prop.window, &w, &h); */
+             if ((rotation == 0) || (rotation == 180))
+               {
+                  evas_output_size_set(ee->evas, ee->w, ee->h);
+                  evas_output_viewport_set(ee->evas, 0, 0, ee->w, ee->h);
+               }
+             else
+               {
+                  evas_output_size_set(ee->evas, ee->h, ee->w);
+                  evas_output_viewport_set(ee->evas, 0, 0, ee->h, ee->w);
+               }
+             if (ee->func.fn_resize) ee->func.fn_resize(ee);
+             if ((ee->rotation == 90) || (ee->rotation == 270))
+               evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
+             else
+               evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+          }
+        ecore_evas_size_min_get(ee, &minw, &minh);
+        ecore_evas_size_max_get(ee, &maxw, &maxh);
+        ecore_evas_size_base_get(ee, &basew, &baseh);
+        ecore_evas_size_step_get(ee, &stepw, &steph);
+        ee->rotation = rotation;
+        ecore_evas_size_min_set(ee, minh, minw);
+        ecore_evas_size_max_set(ee, maxh, maxw);
+        ecore_evas_size_base_set(ee, baseh, basew);
+        ecore_evas_size_step_set(ee, steph, stepw);
+        _ecore_evas_mouse_move_process(ee, ee->mouse.x, ee->mouse.y,
+                                       ecore_x_current_time_get());
+     }
+   else
+     {
+        if (!evas_engine_info_set(ee->evas, einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+        ee->rotation = rotation;
+        _ecore_evas_mouse_move_process(ee, ee->mouse.x, ee->mouse.y,
+                                       ecore_x_current_time_get());
+        if (ee->func.fn_resize) ee->func.fn_resize(ee);
+
+        if ((ee->rotation == 90) || (ee->rotation == 270))
+          evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
+        else
+          evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+     }
+}
+
+static void
+_ecore_evas_x_rotation_set(Ecore_Evas *ee, int rotation, int resize)
+{
+   if (ee->rotation == rotation) return;
+   if (!strcmp(ee->driver, "opengl_x11"))
+     {
+#ifdef BUILD_ECORE_EVAS_OPENGL_X11
+        Evas_Engine_Info_GL_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
+        if (!einfo) return;
+        einfo->info.rotation = rotation;
+        _ecore_evas_x_rotation_set_internal(ee, rotation, resize,
+                                            (Evas_Engine_Info *)einfo);
+#endif /* BUILD_ECORE_EVAS_OPENGL_X11 */
+     }
+   else if (!strcmp(ee->driver, "software_x11"))
+     {
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+        Evas_Engine_Info_Software_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
+        if (!einfo) return;
+        einfo->info.rotation = rotation;
+        _ecore_evas_x_rotation_set_internal(ee, rotation, resize,
+                                            (Evas_Engine_Info *)einfo);
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
+     }
+   else if (!strcmp(ee->driver,  "software_16_x11"))
+     {
+#if BUILD_ECORE_EVAS_SOFTWARE_16_X11
+        Evas_Engine_Info_Software_16_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_16_X11 *)evas_engine_info_get(ee->evas);
+        if (!einfo) return;
+        einfo->info.rotation = rotation;
+        _ecore_evas_x_rotation_set_internal(ee, rotation, resize,
+                                            (Evas_Engine_Info *)einfo);
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_16_X11 */
+     }
+   else if (!strcmp(ee->driver,  "software_8_x11"))
+     {
+#if BUILD_ECORE_EVAS_SOFTWARE_8_X11
+        Evas_Engine_Info_Software_8_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_8_X11 *)evas_engine_info_get(ee->evas);
+        if (!einfo) return;
+        einfo->info.rotation = rotation;
+        _ecore_evas_x_rotation_set_internal(ee, rotation, resize,
+                                            (Evas_Engine_Info *)einfo);
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_8_X11 */
+     }
+}
+
+static void
+_ecore_evas_x_shaped_set(Ecore_Evas *ee, int shaped)
+{
+   if ((ee->shaped == shaped)) return;
+   if (!strcmp(ee->driver, "opengl_x11")) return;
+   if (!strcmp(ee->driver, "software_x11"))
+     {
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+        Evas_Engine_Info_Software_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
+        ee->shaped = shaped;
+        if (einfo)
+          {
+             if (ee->shaped)
+               {
+                  unsigned int foreground;
+                  Ecore_X_GC gc;
+
+                  if (!ee->engine.x.mask)
+                    ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, 1);
+                  foreground = 0;
+                  gc = ecore_x_gc_new(ee->engine.x.mask,
+                                      ECORE_X_GC_VALUE_MASK_FOREGROUND,
+                                      &foreground);
+                  ecore_x_drawable_rectangle_fill(ee->engine.x.mask, gc,
+                                                  0, 0, ee->w, ee->h);
+                  ecore_x_gc_free(gc);
+                  einfo->info.mask = ee->engine.x.mask;
+                  if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+                    {
+                       ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                    }
+                  evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+                  ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
+               }
+             else
+               {
+                  if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+                  ee->engine.x.mask = 0;
+                  einfo->info.mask = 0;
+                  if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+                    {
+                       ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                    }
+                  ecore_x_window_shape_mask_set(ee->prop.window, 0);
+                  ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
+               }
+          }
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
+     }
+   else if (!strcmp(ee->driver, "software_16_x11"))
+     {
+#if BUILD_ECORE_EVAS_SOFTWARE_16_X11
+# if 0 /* XXX no shaped window support for software_16_x11 */
+        Evas_Engine_Info_Software_16_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_16_X11 *)evas_engine_info_get(ee->evas);
+        ee->shaped = shaped;
+        if (einfo)
+          {
+             if (ee->shaped)
+               {
+                  ee->engine.x.mask =
+                    ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, 1);
+                  einfo->info.mask = ee->engine.x.mask;
+                  if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+                    {
+                       ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                    }
+                  evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+               }
+             else
+               {
+                  if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+                  ee->engine.x.mask = 0;
+                  einfo->info.mask = 0;
+                  if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+                    {
+                       ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                    }
+                  ecore_x_window_shape_mask_set(ee->prop.window, 0);
+               }
+          }
+# endif /* XXX no shaped window support for software_16_x11 */
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_16_X11 */
+     }
+   if (!strcmp(ee->driver, "software_8_x11"))
+     {
+#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
+        Evas_Engine_Info_Software_8_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_8_X11 *)evas_engine_info_get(ee->evas);
+        ee->shaped = shaped;
+        if (einfo)
+          {
+             if (ee->shaped)
+               {
+                  unsigned int foreground;
+                  Ecore_X_GC gc;
+
+                  if (!ee->engine.x.mask)
+                    ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, 1);
+                  foreground = 0;
+                  gc = ecore_x_gc_new(ee->engine.x.mask,
+                                      ECORE_X_GC_VALUE_MASK_FOREGROUND,
+                                      &foreground);
+                  ecore_x_drawable_rectangle_fill(ee->engine.x.mask, gc,
+                                                  0, 0, ee->w, ee->h);
+                  ecore_x_gc_free(gc);
+                  einfo->info.mask = ee->engine.x.mask;
+                  if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+                    {
+                       ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                    }
+                  evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+                  ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
+               }
+             else
+               {
+                  if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+                  ee->engine.x.mask = 0;
+                  einfo->info.mask = 0;
+                  if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+                    {
+                       ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                    }
+                  ecore_x_window_shape_mask_set(ee->prop.window, 0);
+                  ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
+               }
+          }
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_8_X11 */
+     }
+}
+
+/* FIXME, round trip */
+static void
+_ecore_evas_x_alpha_set(Ecore_Evas *ee, int alpha)
+{
+   Ecore_X_Window_Attributes att;
+   char *id = NULL;
+
+   if ((ee->alpha == alpha)) return;
+
+   if (!strcmp(ee->driver, "software_x11"))
+     {
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+        Evas_Engine_Info_Software_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
+        if (!einfo) return;
+
+        if (!ecore_x_composite_query()) return;
+
+        ee->shaped = 0;
+        ee->alpha = alpha;
+        ecore_x_window_free(ee->prop.window);
+        ecore_event_window_unregister(ee->prop.window);
+        if (ee->alpha)
+          {
+             if (ee->prop.override)
+               ee->prop.window = ecore_x_window_override_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             else
+               ee->prop.window = ecore_x_window_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             if (!ee->engine.x.mask)
+               ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->req.w, ee->req.h, 1);
+          }
+        else
+          {
+             if (ee->prop.override)
+               ee->prop.window = ecore_x_window_override_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             else
+               ee->prop.window = ecore_x_window_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+             ee->engine.x.mask = 0;
+             ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
+          }
+
+        einfo->info.destination_alpha = alpha;
+
+        ecore_x_window_attributes_get(ee->prop.window, &att);
+        einfo->info.visual = att.visual;
+        einfo->info.colormap = att.colormap;
+        einfo->info.depth = att.depth;
+
+//        if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+//        ee->engine.x.mask = 0;
+        einfo->info.mask = ee->engine.x.mask;
+        einfo->info.drawable = ee->prop.window;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+        evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.w, ee->req.h);
+        ecore_x_window_shape_mask_set(ee->prop.window, 0);
+        ecore_x_input_multi_select(ee->prop.window);
+        ecore_event_window_register(ee->prop.window, ee, ee->evas,
+                                    (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                                    (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                                    (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                                    (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+        if (ee->prop.borderless)
+          ecore_x_mwm_borderless_set(ee->prop.window, ee->prop.borderless);
+        if (ee->visible) ecore_x_window_show(ee->prop.window);
+        if (ee->prop.focused) ecore_x_window_focus(ee->prop.window);
+        if (ee->prop.title)
+          {
+             ecore_x_icccm_title_set(ee->prop.window, ee->prop.title);
+             ecore_x_netwm_name_set(ee->prop.window, ee->prop.title);
+          }
+        ecore_x_icccm_hints_set(ee->prop.window,
+                                1 /* accepts_focus */,
+                                ECORE_X_WINDOW_STATE_HINT_NORMAL /* initial_state */,
+                                0 /* icon_pixmap */,
+                                0 /* icon_mask */,
+                                0 /* icon_window */,
+                                0 /* window_group */,
+                                0 /* is_urgent */);
+        _ecore_evas_x_group_leader_update(ee);
+        ecore_x_window_defaults_set(ee->prop.window);
+        _ecore_evas_x_protocols_set(ee);
+        _ecore_evas_x_sync_set(ee);
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
+        if ((id = getenv("DESKTOP_STARTUP_ID")))
+          {
+             ecore_x_netwm_startup_id_set(ee->prop.window, id);
+             /* NB: on linux this may simply empty the env as opposed to completely
+              * unset it to being empty - unsure as solartis libc crashes looking
+              * for the '=' char */
+             //        putenv((char*)"DESKTOP_STARTUP_ID=");
+          }
+     }
+   else if (!strcmp(ee->driver, "opengl_x11"))
+     {
+#ifdef BUILD_ECORE_EVAS_OPENGL_X11
+        Evas_Engine_Info_GL_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
+        if (!einfo) return;
+
+        if (!ecore_x_composite_query()) return;
+
+        ee->shaped = 0;
+        ee->alpha = alpha;
+        ecore_x_window_free(ee->prop.window);
+        ecore_event_window_unregister(ee->prop.window);
+        ee->prop.window = 0;
+
+        einfo->info.destination_alpha = alpha;
+
+        if (ee->engine.x.win_root != 0)
+          {
+             /* FIXME: round trip in ecore_x_window_argb_get */
+             if (ecore_x_window_argb_get(ee->engine.x.win_root))
+               {
+                  ee->prop.window =
+                    _ecore_evas_x_gl_window_new(ee, ee->engine.x.win_root,
+                                                ee->req.x, ee->req.y,
+                                                ee->req.w, ee->req.h,
+                                                ee->prop.override, 1, NULL);
+               }
+             else
+               {
+                  ee->prop.window =
+                    _ecore_evas_x_gl_window_new(ee, ee->engine.x.win_root,
+                                                ee->req.x, ee->req.y,
+                                                ee->req.w, ee->req.h,
+                                                ee->prop.override, ee->alpha,
+                                                NULL);
+               }
+          }
+        else
+          {
+             ee->prop.window =
+               _ecore_evas_x_gl_window_new(ee, ee->engine.x.win_root,
+                                           ee->req.x, ee->req.y,
+                                           ee->req.w, ee->req.h,
+                                           ee->prop.override, ee->alpha, NULL);
+          }
+
+        if (!ee->prop.window) return;
+/*
+        if (ee->alpha)
+          {
+             if (ee->prop.override)
+               ee->prop.window = ecore_x_window_override_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             else
+               ee->prop.window = ecore_x_window_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             if (!ee->engine.x.mask)
+               ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->req.w, ee->req.h, 1);
+          }
+        else
+          {
+             if (ee->prop.override)
+               ee->prop.window = ecore_x_window_override_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             else
+               ee->prop.window = ecore_x_window_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+             ee->engine.x.mask = 0;
+             ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
+          }
+ */
+
+        ecore_x_window_attributes_get(ee->prop.window, &att);
+        einfo->info.visual = att.visual;
+        einfo->info.colormap = att.colormap;
+        einfo->info.depth = att.depth;
+
+//        if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+//        ee->engine.x.mask = 0;
+//        einfo->info.mask = ee->engine.x.mask;
+        einfo->info.drawable = ee->prop.window;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+        evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.w, ee->req.h);
+//        ecore_x_window_shape_mask_set(ee->prop.window, 0);
+        ecore_x_input_multi_select(ee->prop.window);
+        ecore_event_window_register(ee->prop.window, ee, ee->evas,
+                                    (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                                    (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                                    (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                                    (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+        if (ee->prop.borderless)
+          ecore_x_mwm_borderless_set(ee->prop.window, ee->prop.borderless);
+        if (ee->visible) ecore_x_window_show(ee->prop.window);
+        if (ee->prop.focused) ecore_x_window_focus(ee->prop.window);
+        if (ee->prop.title)
+          {
+             ecore_x_icccm_title_set(ee->prop.window, ee->prop.title);
+             ecore_x_netwm_name_set(ee->prop.window, ee->prop.title);
+          }
+        ecore_x_icccm_hints_set(ee->prop.window,
+                                1 /* accepts_focus */,
+                                ECORE_X_WINDOW_STATE_HINT_NORMAL /* initial_state */,
+                                0 /* icon_pixmap */,
+                                0 /* icon_mask */,
+                                0 /* icon_window */,
+                                0 /* window_group */,
+                                0 /* is_urgent */);
+        _ecore_evas_x_group_leader_update(ee);
+        ecore_x_window_defaults_set(ee->prop.window);
+        _ecore_evas_x_protocols_set(ee);
+        _ecore_evas_x_sync_set(ee);
+#endif /* BUILD_ECORE_EVAS_OPENGL_X11 */
+        if ((id = getenv("DESKTOP_STARTUP_ID")))
+          {
+             ecore_x_netwm_startup_id_set(ee->prop.window, id);
+             /* NB: on linux this may simply empty the env as opposed to completely
+              * unset it to being empty - unsure as solartis libc crashes looking
+              * for the '=' char */
+             //        putenv((char*)"DESKTOP_STARTUP_ID=");
+          }
+     }
+   else if (!strcmp(ee->driver, "software_16_x11"))
+     {
+#if BUILD_ECORE_EVAS_SOFTWARE_16_X11
+        Evas_Engine_Info_Software_16_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_16_X11 *)evas_engine_info_get(ee->evas);
+        if (!einfo) return;
+
+        ee->shaped = 0;
+        ee->alpha = alpha;
+        ecore_x_window_free(ee->prop.window);
+        ecore_event_window_unregister(ee->prop.window);
+        if (ee->alpha)
+          {
+             if (ee->prop.override)
+               ee->prop.window = ecore_x_window_override_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             else
+               ee->prop.window = ecore_x_window_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             if (!ee->engine.x.mask)
+               ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->req.w, ee->req.h, 1);
+          }
+        else
+          {
+             if (ee->prop.override)
+               ee->prop.window = ecore_x_window_override_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             else
+               ee->prop.window = ecore_x_window_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+             ee->engine.x.mask = 0;
+             ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
+          }
+
+# if 0 /* XXX no alpha window support for software_16_x11 */
+        einfo->info.destination_alpha = alpha;
+# endif /* XXX no alpha window support for software_16_x11 */
+
+# if 0 /* XXX no shaped window support for software_16_x11 */
+//        if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+//        ee->engine.x.mask = 0;
+        einfo->info.mask = ee->engine.x.mask;
+# endif /* XXX no shaped window support for software_16_x11 */
+
+        einfo->info.drawable = ee->prop.window;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+        evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.w, ee->req.h);
+        ecore_x_window_shape_mask_set(ee->prop.window, 0);
+        ecore_x_input_multi_select(ee->prop.window);
+        ecore_event_window_register(ee->prop.window, ee, ee->evas,
+                                    (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                                    (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                                    (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                                    (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+        if (ee->prop.borderless)
+          ecore_x_mwm_borderless_set(ee->prop.window, ee->prop.borderless);
+        if (ee->visible) ecore_x_window_show(ee->prop.window);
+        if (ee->prop.focused) ecore_x_window_focus(ee->prop.window);
+        if (ee->prop.title)
+          {
+             ecore_x_icccm_title_set(ee->prop.window, ee->prop.title);
+             ecore_x_netwm_name_set(ee->prop.window, ee->prop.title);
+          }
+        ecore_x_icccm_hints_set(ee->prop.window,
+                                1 /* accepts_focus */,
+                                ECORE_X_WINDOW_STATE_HINT_NORMAL /* initial_state */,
+                                0 /* icon_pixmap */,
+                                0 /* icon_mask */,
+                                0 /* icon_window */,
+                                0 /* window_group */,
+                                0 /* is_urgent */);
+        _ecore_evas_x_group_leader_update(ee);
+        ecore_x_window_defaults_set(ee->prop.window);
+        _ecore_evas_x_protocols_set(ee);
+        _ecore_evas_x_sync_set(ee);
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_16_X11 */
+        if ((id = getenv("DESKTOP_STARTUP_ID")))
+          {
+             ecore_x_netwm_startup_id_set(ee->prop.window, id);
+             /* NB: on linux this may simply empty the env as opposed to completely
+              * unset it to being empty - unsure as solartis libc crashes looking
+              * for the '=' char */
+             //        putenv((char*)"DESKTOP_STARTUP_ID=");
+          }
+     }
+   else if (!strcmp(ee->driver, "software_8_x11"))
+     {
+#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
+        Evas_Engine_Info_Software_8_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_8_X11 *)evas_engine_info_get(ee->evas);
+        if (!einfo) return;
+
+        ee->shaped = 0;
+        ee->alpha = alpha;
+        ecore_x_window_free(ee->prop.window);
+        ecore_event_window_unregister(ee->prop.window);
+        if (ee->alpha)
+          {
+             if (ee->prop.override)
+               ee->prop.window = ecore_x_window_override_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             else
+               ee->prop.window = ecore_x_window_argb_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             if (!ee->engine.x.mask)
+               ee->engine.x.mask = ecore_x_pixmap_new(ee->prop.window, ee->req.w, ee->req.h, 1);
+          }
+        else
+          {
+             if (ee->prop.override)
+               ee->prop.window = ecore_x_window_override_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             else
+               ee->prop.window = ecore_x_window_new(ee->engine.x.win_root, ee->req.x, ee->req.y, ee->req.w, ee->req.h);
+             if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+             ee->engine.x.mask = 0;
+             ecore_x_window_shape_input_mask_set(ee->prop.window, 0);
+          }
+
+        einfo->info.destination_alpha = alpha;
+
+        ecore_x_window_attributes_get(ee->prop.window, &att);
+        einfo->info.visual = att.visual;
+        einfo->info.colormap = att.colormap;
+        einfo->info.depth = att.depth;
+
+//        if (ee->engine.x.mask) ecore_x_pixmap_free(ee->engine.x.mask);
+//        ee->engine.x.mask = 0;
+        einfo->info.mask = ee->engine.x.mask;
+        einfo->info.drawable = ee->prop.window;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+        evas_damage_rectangle_add(ee->evas, 0, 0, ee->req.w, ee->req.h);
+        ecore_x_window_shape_mask_set(ee->prop.window, 0);
+        ecore_x_input_multi_select(ee->prop.window);
+        ecore_event_window_register(ee->prop.window, ee, ee->evas,
+                                    (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                                    (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                                    (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                                    (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+        if (ee->prop.borderless)
+          ecore_x_mwm_borderless_set(ee->prop.window, ee->prop.borderless);
+        if (ee->visible) ecore_x_window_show(ee->prop.window);
+        if (ee->prop.focused) ecore_x_window_focus(ee->prop.window);
+        if (ee->prop.title)
+          {
+             ecore_x_icccm_title_set(ee->prop.window, ee->prop.title);
+             ecore_x_netwm_name_set(ee->prop.window, ee->prop.title);
+          }
+        ecore_x_icccm_hints_set(ee->prop.window,
+                                1 /* accepts_focus */,
+                                ECORE_X_WINDOW_STATE_HINT_NORMAL /* initial_state */,
+                                0 /* icon_pixmap */,
+                                0 /* icon_mask */,
+                                0 /* icon_window */,
+                                0 /* window_group */,
+                                0 /* is_urgent */);
+        _ecore_evas_x_group_leader_update(ee);
+        ecore_x_window_defaults_set(ee->prop.window);
+        _ecore_evas_x_protocols_set(ee);
+        _ecore_evas_x_sync_set(ee);
+
+        if ((id = getenv("DESKTOP_STARTUP_ID")))
+          {
+             ecore_x_netwm_startup_id_set(ee->prop.window, id);
+             /* NB: on linux this may simply empty the env as opposed to completely
+              * unset it to being empty - unsure as solartis libc crashes looking
+              * for the '=' char */
+             //        putenv((char*)"DESKTOP_STARTUP_ID=");
+          }
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_8_X11 */
+     }
+}
+
+static void
+_ecore_evas_x_transparent_set(Ecore_Evas *ee, int transparent)
+{
+   if ((ee->transparent == transparent)) return;
+
+   if (!strcmp(ee->driver, "software_x11"))
+     {
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+        Evas_Engine_Info_Software_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
+        if (!einfo) return;
+
+        ee->transparent = transparent;
+        einfo->info.destination_alpha = transparent;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+        evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+#endif
+     }
+}
+#endif /* BUILD_ECORE_EVAS_X11 */
+
+#ifdef BUILD_ECORE_EVAS_X11
+static void
+_ecore_evas_x_show(Ecore_Evas *ee)
+{
+   ee->should_be_visible = 1;
+   if (ee->prop.avoid_damage)
+     _ecore_evas_x_render(ee);
+   _ecore_evas_x_sync_set(ee);
+   ecore_x_window_show(ee->prop.window);
+   if (ee->prop.fullscreen)
+     ecore_x_window_focus(ee->prop.window);
+}
+
+static void
+_ecore_evas_x_hide(Ecore_Evas *ee)
+{
+   ecore_x_window_hide(ee->prop.window);
+   ee->should_be_visible = 0;
+   _ecore_evas_x_sync_set(ee);
+}
+
+static void
+_ecore_evas_x_raise(Ecore_Evas *ee)
+{
+   ecore_x_window_raise(ee->prop.window);
+}
+
+static void
+_ecore_evas_x_lower(Ecore_Evas *ee)
+{
+   ecore_x_window_lower(ee->prop.window);
+}
+
+static void
+_ecore_evas_x_activate(Ecore_Evas *ee)
+{
+   ecore_x_netwm_client_active_request(ee->engine.x.win_root,
+                                       ee->prop.window, 2, 0);
+}
+
+static void
+_ecore_evas_x_title_set(Ecore_Evas *ee, const char *t)
+{
+   if (ee->prop.title) free(ee->prop.title);
+   ee->prop.title = NULL;
+   if (t) ee->prop.title = strdup(t);
+   ecore_x_icccm_title_set(ee->prop.window, ee->prop.title);
+   ecore_x_netwm_name_set(ee->prop.window, ee->prop.title);
+}
+
+static void
+_ecore_evas_x_name_class_set(Ecore_Evas *ee, const char *n, const char *c)
+{
+   if (ee->prop.name) free(ee->prop.name);
+   if (ee->prop.clas) free(ee->prop.clas);
+   ee->prop.name = NULL;
+   ee->prop.clas = NULL;
+   if (n) ee->prop.name = strdup(n);
+   if (c) ee->prop.clas = strdup(c);
+   ecore_x_icccm_name_class_set(ee->prop.window, ee->prop.name, ee->prop.clas);
+}
+
+static void
+_ecore_evas_x_size_min_set(Ecore_Evas *ee, int w, int h)
+{
+   if (w < 0) w = 0;
+   if (h < 0) h = 0;
+   if ((ee->prop.min.w == w) && (ee->prop.min.h == h)) return;
+   ee->prop.min.w = w;
+   ee->prop.min.h = h;
+   _ecore_evas_x_size_pos_hints_update(ee);
+}
+
+static void
+_ecore_evas_x_size_max_set(Ecore_Evas *ee, int w, int h)
+{
+   if (w < 0) w = 0;
+   if (h < 0) h = 0;
+   if ((ee->prop.max.w == w) && (ee->prop.max.h == h)) return;
+   ee->prop.max.w = w;
+   ee->prop.max.h = h;
+   _ecore_evas_x_size_pos_hints_update(ee);
+}
+
+static void
+_ecore_evas_x_size_base_set(Ecore_Evas *ee, int w, int h)
+{
+   if (w < 0) w = 0;
+   if (h < 0) h = 0;
+   if ((ee->prop.base.w == w) && (ee->prop.base.h == h)) return;
+   ee->prop.base.w = w;
+   ee->prop.base.h = h;
+   _ecore_evas_x_size_pos_hints_update(ee);
+}
+
+static void
+_ecore_evas_x_size_step_set(Ecore_Evas *ee, int w, int h)
+{
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   if ((ee->prop.step.w == w) && (ee->prop.step.h == h)) return;
+   ee->prop.step.w = w;
+   ee->prop.step.h = h;
+   _ecore_evas_x_size_pos_hints_update(ee);
+}
+
+static void
+_ecore_evas_object_cursor_del(void *data, Evas *e __UNUSED__, Evas_Object *obj __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee;
+
+   ee = data;
+   if (ee) ee->prop.cursor.object = NULL;
+}
+
+static void
+_ecore_evas_x_object_cursor_set(Ecore_Evas *ee, Evas_Object *obj, int layer, int hot_x, int hot_y)
+{
+   int x, y;
+
+   if (ee->prop.cursor.object) evas_object_del(ee->prop.cursor.object);
+
+   if (!obj)
+     {
+        ee->prop.cursor.object = NULL;
+        ee->prop.cursor.layer = 0;
+        ee->prop.cursor.hot.x = 0;
+        ee->prop.cursor.hot.y = 0;
+        ecore_x_window_cursor_show(ee->prop.window, 1);
+        return;
+     }
+
+   ee->prop.cursor.object = obj;
+   ee->prop.cursor.layer = layer;
+   ee->prop.cursor.hot.x = hot_x;
+   ee->prop.cursor.hot.y = hot_y;
+
+   ecore_x_window_cursor_show(ee->prop.window, 0);
+
+   evas_pointer_output_xy_get(ee->evas, &x, &y);
+   evas_object_layer_set(ee->prop.cursor.object, ee->prop.cursor.layer);
+   evas_object_move(ee->prop.cursor.object,
+                    x - ee->prop.cursor.hot.x,
+                    y - ee->prop.cursor.hot.y);
+   evas_object_pass_events_set(ee->prop.cursor.object, 1);
+   if (evas_pointer_inside_get(ee->evas))
+     evas_object_show(ee->prop.cursor.object);
+
+   evas_object_event_callback_add(obj, EVAS_CALLBACK_DEL, _ecore_evas_object_cursor_del, ee);
+}
+
+/*
+ * @param ee
+ * @param layer If < 3, @a ee will be put below all other windows.
+ *              If > 5, @a ee will be "always-on-top"
+ *              If = 4, @a ee will be put in the default layer.
+ *              Acceptable values range from 1 to 255 (0 reserved for
+ *              desktop windows)
+ */
+static void
+_ecore_evas_x_layer_set(Ecore_Evas *ee, int layer)
+{
+   if (ee->prop.layer == layer) return;
+
+   /* FIXME: Should this logic be here? */
+   if (layer < 1)
+     layer = 1;
+   else if (layer > 255)
+     layer = 255;
+
+   ee->prop.layer = layer;
+   _ecore_evas_x_layer_update(ee);
+}
+
+static void
+_ecore_evas_x_focus_set(Ecore_Evas *ee, int on __UNUSED__)
+{
+   ecore_x_window_focus(ee->prop.window);
+}
+
+static void
+_ecore_evas_x_iconified_set(Ecore_Evas *ee, int on)
+{
+   if (ee->prop.iconified == on) return;
+   ee->prop.iconified = on;
+   if (on)
+     {
+        ecore_x_icccm_hints_set(ee->prop.window,
+                                1 /* accepts_focus */,
+                                ECORE_X_WINDOW_STATE_HINT_ICONIC /* initial_state */,
+                                0 /* icon_pixmap */,
+                                0 /* icon_mask */,
+                                0 /* icon_window */,
+                                0 /* window_group */,
+                                0 /* is_urgent */);
+        ecore_x_icccm_iconic_request_send(ee->prop.window, ee->engine.x.win_root);
+     }
+   else
+     {
+        ecore_x_icccm_hints_set(ee->prop.window,
+                                1 /* accepts_focus */,
+                                ECORE_X_WINDOW_STATE_HINT_NORMAL /* initial_state */,
+                                0 /* icon_pixmap */,
+                                0 /* icon_mask */,
+                                0 /* icon_window */,
+                                0 /* window_group */,
+                                0 /* is_urgent */);
+        ecore_evas_show(ee);
+     }
+}
+
+static void
+_ecore_evas_x_borderless_set(Ecore_Evas *ee, int on)
+{
+   if (ee->prop.borderless == on) return;
+   ee->prop.borderless = on;
+   ecore_x_mwm_borderless_set(ee->prop.window, ee->prop.borderless);
+}
+
+/* FIXME: This function changes the initial state of the ee
+ * whilest the iconic function changes the current state! */
+static void
+_ecore_evas_x_withdrawn_set(Ecore_Evas *ee, int withdrawn)
+{
+   Ecore_X_Window_State_Hint hint;
+
+   if (ee->prop.withdrawn == withdrawn) return;
+
+   ee->prop.withdrawn = withdrawn;
+   if (withdrawn)
+     hint = ECORE_X_WINDOW_STATE_HINT_WITHDRAWN;
+   else
+     hint = ECORE_X_WINDOW_STATE_HINT_NORMAL;
+
+   ecore_x_icccm_hints_set(ee->prop.window,
+                           1 /* accepts_focus */,
+                           hint /* initial_state */,
+                           0 /* icon_pixmap */,
+                           0 /* icon_mask */,
+                           0 /* icon_window */,
+                           0 /* window_group */,
+                           0 /* is_urgent */);
+}
+
+static void
+_ecore_evas_x_sticky_set(Ecore_Evas *ee, int sticky)
+{
+   if (ee->prop.sticky == sticky) return;
+
+   /* We dont want to set prop.sticky here as it will cause
+    * the sticky callback not to get called. Its set on the
+    * property change event.
+    * ee->prop.sticky = sticky;
+    */
+   ee->engine.x.state.sticky = sticky;
+   if (ee->should_be_visible)
+     ecore_x_netwm_state_request_send(ee->prop.window, ee->engine.x.win_root,
+                                      ECORE_X_WINDOW_STATE_STICKY, -1, sticky);
+   else
+     _ecore_evas_x_state_update(ee);
+}
+
+static void
+_ecore_evas_x_ignore_events_set(Ecore_Evas *ee, int ignore)
+{
+   if (ee->ignore_events == ignore) return;
+
+   ee->ignore_events = ignore;
+   if (ee->prop.window)
+     ecore_x_window_ignore_set(ee->prop.window, ignore);
+}
+
+/*
+static void
+_ecore_evas_x_reinit_win(Ecore_Evas *ee)
+{
+   if (!strcmp(ee->driver, "software_x11"))
+     {
+#ifdef BUILD_ECORE_EVAS_X11
+        Evas_Engine_Info_Software_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
+        if (einfo)
+          {
+             einfo->info.drawable = ee->prop.window;
+             evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo);
+          }
+#endif
+     }
+   else if (!strcmp(ee->driver, "opengl_x11"))
+     {
+#ifdef BUILD_ECORE_EVAS_OPENGL_X11
+        Evas_Engine_Info_GL_X11 *einfo;
+
+        einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
+        if (einfo)
+          {
+             einfo->info.drawable = ee->prop.window;
+             evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo);
+          }
+#endif
+     }
+}
+*/
+
+static void
+_ecore_evas_x_override_set(Ecore_Evas *ee, int on)
+{
+   if (ee->prop.override == on) return;
+   if (ee->should_be_visible) ecore_x_window_hide(ee->prop.window);
+   ecore_x_window_override_set(ee->prop.window, on);
+   if (ee->should_be_visible) ecore_x_window_show(ee->prop.window);
+   if (ee->prop.focused) ecore_x_window_focus(ee->prop.window);
+   ee->prop.override = on;
+}
+
+static void
+_ecore_evas_x_fullscreen_set(Ecore_Evas *ee, int on)
+{
+   if (ee->prop.fullscreen == on) return;
+
+   /* FIXME: Detect if WM is EWMH compliant and handle properly if not,
+    * i.e. reposition, resize, and change borderless hint */
+   ee->engine.x.state.fullscreen = on;
+   if (ee->should_be_visible)
+     ecore_x_netwm_state_request_send(ee->prop.window, ee->engine.x.win_root,
+                                      ECORE_X_WINDOW_STATE_FULLSCREEN, -1, on);
+   else
+     _ecore_evas_x_state_update(ee);
+}
+
+static void
+_ecore_evas_x_avoid_damage_set(Ecore_Evas *ee, int on)
+{
+   if (ee->prop.avoid_damage == on) return;
+   if (!strcmp(ee->driver, "opengl_x11")) return;
+
+   if (!strcmp(ee->driver, "software_x11"))
+     {
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+        Evas_Engine_Info_Software_X11 *einfo;
+
+        ee->prop.avoid_damage = on;
+        einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
+        if (einfo)
+          {
+             if (ee->prop.avoid_damage)
+               {
+                  ee->engine.x.pmap = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, einfo->info.depth);
+                  ee->engine.x.gc = ecore_x_gc_new(ee->engine.x.pmap, 0, NULL);
+                  einfo->info.drawable = ee->engine.x.pmap;
+                  if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+                    {
+                       ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                    }
+                  if ((ee->rotation == 90) || (ee->rotation == 270))
+                    evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
+                  else
+                    evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+                  if (ee->prop.avoid_damage == ECORE_EVAS_AVOID_DAMAGE_BUILT_IN)
+                    {
+                       ee->engine.x.using_bg_pixmap = 1;
+                       ecore_x_window_pixmap_set(ee->prop.window, ee->engine.x.pmap);
+                       ecore_x_window_area_expose(ee->prop.window, 0, 0, ee->w, ee->h);
+                    }
+                  if (ee->engine.x.direct_resize)
+                    {
+                       /* Turn this off for now
+                          ee->engine.x.using_bg_pixmap = 1;
+                          ecore_x_window_pixmap_set(ee->prop.window, ee->engine.x.pmap);
+                       */
+                    }
+               }
+             else
+               {
+                  if (ee->engine.x.pmap) ecore_x_pixmap_free(ee->engine.x.pmap);
+                  if (ee->engine.x.gc) ecore_x_gc_free(ee->engine.x.gc);
+                  if (ee->engine.x.using_bg_pixmap)
+                    {
+                       ecore_x_window_pixmap_set(ee->prop.window, 0);
+                       ee->engine.x.using_bg_pixmap = 0;
+                       ecore_x_window_area_expose(ee->prop.window, 0, 0, ee->w, ee->h);
+                    }
+                  ee->engine.x.pmap = 0;
+                  ee->engine.x.gc = 0;
+                  einfo->info.drawable = ee->prop.window;
+                  if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+                    {
+                       ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                    }
+               }
+          }
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_X11 */
+     }
+   else if (!strcmp(ee->driver, "software_16_x11"))
+     {
+#if BUILD_ECORE_EVAS_SOFTWARE_16_X11
+        Evas_Engine_Info_Software_16_X11 *einfo;
+
+        ee->prop.avoid_damage = on;
+        einfo = (Evas_Engine_Info_Software_16_X11 *)evas_engine_info_get(ee->evas);
+        if (einfo)
+          {
+             if (ee->prop.avoid_damage)
+               {
+                  ee->engine.x.pmap = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, 16);
+                  ee->engine.x.gc = ecore_x_gc_new(ee->engine.x.pmap, 0, NULL);
+                  einfo->info.drawable = ee->engine.x.pmap;
+                  if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+                    {
+                       ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                    }
+                  if ((ee->rotation == 90) || (ee->rotation == 270))
+                    evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
+                  else
+                    evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+                  if (ee->engine.x.direct_resize)
+                    {
+                       /* Turn this off for now
+                          ee->engine.x.using_bg_pixmap = 1;
+                          ecore_x_window_pixmap_set(ee->prop.window, ee->engine.x.pmap);
+                       */
+                    }
+               }
+             else
+               {
+                  if (ee->engine.x.pmap) ecore_x_pixmap_free(ee->engine.x.pmap);
+                  if (ee->engine.x.gc) ecore_x_gc_free(ee->engine.x.gc);
+                  if (ee->engine.x.using_bg_pixmap)
+                    {
+                       ecore_x_window_pixmap_set(ee->prop.window, 0);
+                       ee->engine.x.using_bg_pixmap = 0;
+                    }
+                  ee->engine.x.pmap = 0;
+                  ee->engine.x.gc = 0;
+                  einfo->info.drawable = ee->prop.window;
+                  if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+                    {
+                       ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                    }
+               }
+          }
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_16_X11 */
+     }
+   else if (!strcmp(ee->driver, "software_8_x11"))
+     {
+#if BUILD_ECORE_EVAS_SOFTWARE_8_X11
+        Evas_Engine_Info_Software_8_X11 *einfo;
+
+        ee->prop.avoid_damage = on;
+        einfo = (Evas_Engine_Info_Software_8_X11 *)evas_engine_info_get(ee->evas);
+        if (einfo)
+          {
+             if (ee->prop.avoid_damage)
+               {
+                  ee->engine.x.pmap = ecore_x_pixmap_new(ee->prop.window, ee->w, ee->h, einfo->info.depth);
+                  ee->engine.x.gc = ecore_x_gc_new(ee->engine.x.pmap, 0, NULL);
+                  einfo->info.drawable = ee->engine.x.pmap;
+                  if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+                    {
+                       ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                    }
+                  if ((ee->rotation == 90) || (ee->rotation == 270))
+                    evas_damage_rectangle_add(ee->evas, 0, 0, ee->h, ee->w);
+                  else
+                    evas_damage_rectangle_add(ee->evas, 0, 0, ee->w, ee->h);
+                  if (ee->prop.avoid_damage == ECORE_EVAS_AVOID_DAMAGE_BUILT_IN)
+                    {
+                       ee->engine.x.using_bg_pixmap = 1;
+                       ecore_x_window_pixmap_set(ee->prop.window, ee->engine.x.pmap);
+                       ecore_x_window_area_expose(ee->prop.window, 0, 0, ee->w, ee->h);
+                    }
+                  if (ee->engine.x.direct_resize)
+                    {
+                       /* Turn this off for now
+                          ee->engine.x.using_bg_pixmap = 1;
+                          ecore_x_window_pixmap_set(ee->prop.window, ee->engine.x.pmap);
+                       */
+                    }
+               }
+             else
+               {
+                  if (ee->engine.x.pmap) ecore_x_pixmap_free(ee->engine.x.pmap);
+                  if (ee->engine.x.gc) ecore_x_gc_free(ee->engine.x.gc);
+                  if (ee->engine.x.using_bg_pixmap)
+                    {
+                       ecore_x_window_pixmap_set(ee->prop.window, 0);
+                       ee->engine.x.using_bg_pixmap = 0;
+                       ecore_x_window_area_expose(ee->prop.window, 0, 0, ee->w, ee->h);
+                    }
+                  ee->engine.x.pmap = 0;
+                  ee->engine.x.gc = 0;
+                  einfo->info.drawable = ee->prop.window;
+                  if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+                    {
+                       ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+                    }
+               }
+          }
+#endif /* BUILD_ECORE_EVAS_SOFTWARE_8_X11 */
+     }
+}
+
+static void
+_ecore_evas_x_screen_geometry_get(const Ecore_Evas *ee __UNUSED__, int *x, int *y, int *w, int *h)
+{
+   if (x) *x = 0;
+   if (y) *y = 0;
+   ecore_x_screen_size_get(ecore_x_default_screen_get(), w, h);
+}
+
+int
+_ecore_evas_x_shutdown(void)
+{
+   _ecore_evas_init_count--;
+   if (_ecore_evas_init_count == 0)
+     {
+        unsigned int i;
+
+        for (i = 0; i < sizeof(ecore_evas_event_handlers) / sizeof(Ecore_Event_Handler*); i++)
+          {
+             if (ecore_evas_event_handlers[i])
+               ecore_event_handler_del(ecore_evas_event_handlers[i]);
+          }
+        ecore_event_evas_shutdown();
+     }
+   if (_ecore_evas_init_count < 0) _ecore_evas_init_count = 0;
+   return _ecore_evas_init_count;
+}
+
+static Ecore_Evas_Engine_Func _ecore_x_engine_func =
+{
+   _ecore_evas_x_free,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     _ecore_evas_x_callback_delete_request_set,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     NULL,
+     _ecore_evas_x_move,
+     _ecore_evas_x_managed_move,
+     _ecore_evas_x_resize,
+     _ecore_evas_x_move_resize,
+     _ecore_evas_x_rotation_set,
+     _ecore_evas_x_shaped_set,
+     _ecore_evas_x_show,
+     _ecore_evas_x_hide,
+     _ecore_evas_x_raise,
+     _ecore_evas_x_lower,
+     _ecore_evas_x_activate,
+     _ecore_evas_x_title_set,
+     _ecore_evas_x_name_class_set,
+     _ecore_evas_x_size_min_set,
+     _ecore_evas_x_size_max_set,
+     _ecore_evas_x_size_base_set,
+     _ecore_evas_x_size_step_set,
+     _ecore_evas_x_object_cursor_set,
+     _ecore_evas_x_layer_set,
+     _ecore_evas_x_focus_set,
+     _ecore_evas_x_iconified_set,
+     _ecore_evas_x_borderless_set,
+     _ecore_evas_x_override_set,
+     NULL,
+     _ecore_evas_x_fullscreen_set,
+     _ecore_evas_x_avoid_damage_set,
+     _ecore_evas_x_withdrawn_set,
+     _ecore_evas_x_sticky_set,
+     _ecore_evas_x_ignore_events_set,
+     _ecore_evas_x_alpha_set,
+     _ecore_evas_x_transparent_set,
+
+     NULL, // render
+     _ecore_evas_x_screen_geometry_get
+};
+#endif /* BUILD_ECORE_EVAS_X11 */
+
+/*
+ * FIXME: there are some round trips. Especially, we can split
+ * ecore_x_init in 2 functions and suppress some round trips.
+ */
+
+#if defined (BUILD_ECORE_EVAS_SOFTWARE_X11) || defined (BUILD_ECORE_EVAS_OPENGL_X11) || defined (BUILD_ECORE_EVAS_SOFTWARE_16_X11) || defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
+static void
+_ecore_evas_x_flush_pre(void *data, Evas *e __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+
+   if (ee->no_comp_sync) return;
+   if (!_ecore_evas_app_comp_sync) return;
+   if (ee->engine.x.sync_counter)
+     {
+        if (ee->engine.x.sync_began)
+          {
+             ee->engine.x.sync_val++;
+             if (!ee->engine.x.sync_cancel)
+               {
+                  if (!ee->semi_sync)
+                     ecore_x_sync_counter_val_wait(ee->engine.x.sync_counter,
+                                                   ee->engine.x.sync_val);
+               }
+          }
+     }
+}
+
+static void
+_ecore_evas_x_flush_post(void *data, Evas *e __UNUSED__, void *event_info __UNUSED__)
+{
+   Ecore_Evas *ee = data;
+
+   if ((!ee->no_comp_sync) && (_ecore_evas_app_comp_sync))
+     {
+        if (ee->engine.x.sync_counter)
+          {
+             if (ee->engine.x.sync_began)
+               {
+                  if (!ee->engine.x.sync_cancel)
+                    {
+                       ecore_x_e_comp_sync_draw_size_done_send
+                          (ee->engine.x.win_root, ee->prop.window, ee->w, ee->h);
+                    }
+               }
+          }
+     }
+   if (ee->engine.x.netwm_sync_set)
+     {
+        ecore_x_sync_counter_2_set(ee->engine.x.netwm_sync_counter,
+                                   ee->engine.x.netwm_sync_val_hi,
+                                   ee->engine.x.netwm_sync_val_lo);
+        ee->engine.x.netwm_sync_set = 0;
+     }
+}
+#endif
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+EAPI Ecore_Evas *
+ecore_evas_software_x11_new(const char *disp_name, Ecore_X_Window parent,
+                            int x, int y, int w, int h)
+{
+   Evas_Engine_Info_Software_X11 *einfo;
+   Ecore_Evas *ee;
+   int argb = 0, rmethod;
+   static int redraw_debug = -1;
+   char *id = NULL;
+
+   rmethod = evas_render_method_lookup("software_x11");
+   if (!rmethod) return NULL;
+   if (!ecore_x_init(disp_name)) return NULL;
+   ee = calloc(1, sizeof(Ecore_Evas));
+   if (!ee) return NULL;
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+   _ecore_evas_x_init();
+
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_x_engine_func;
+
+   ee->driver = "software_x11";
+   if (disp_name) ee->name = strdup(disp_name);
+
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   ee->x = x;
+   ee->y = y;
+   ee->w = w;
+   ee->h = h;
+   ee->req.x = ee->x;
+   ee->req.y = ee->y;
+   ee->req.w = ee->w;
+   ee->req.h = ee->h;
+
+   ee->prop.max.w = 32767;
+   ee->prop.max.h = 32767;
+   ee->prop.layer = 4;
+   ee->prop.request_pos = 0;
+   ee->prop.sticky = 0;
+   ee->engine.x.state.sticky = 0;
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_PRE,
+                           _ecore_evas_x_flush_pre, ee);
+   evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_POST,
+                           _ecore_evas_x_flush_post, ee);
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_method_set(ee->evas, rmethod);
+   evas_output_size_set(ee->evas, w, h);
+   evas_output_viewport_set(ee->evas, 0, 0, w, h);
+
+   ee->engine.x.win_root = parent;
+   ee->engine.x.screen_num = 0;
+
+   if (parent != 0)
+     {
+        ee->engine.x.screen_num = 1; /* FIXME: get real scren # */
+       /* FIXME: round trip in ecore_x_window_argb_get */
+        if (ecore_x_window_argb_get(parent))
+          {
+             ee->prop.window = ecore_x_window_argb_new(parent, x, y, w, h);
+             argb = 1;
+          }
+        else
+          ee->prop.window = ecore_x_window_new(parent, x, y, w, h);
+     }
+   else
+     ee->prop.window = ecore_x_window_new(parent, x, y, w, h);
+   if ((id = getenv("DESKTOP_STARTUP_ID")))
+     {
+        ecore_x_netwm_startup_id_set(ee->prop.window, id);
+        /* NB: on linux this may simply empty the env as opposed to completely
+         * unset it to being empty - unsure as solartis libc crashes looking
+         * for the '=' char */
+//        putenv((char*)"DESKTOP_STARTUP_ID=");
+     }
+   einfo = (Evas_Engine_Info_Software_X11 *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        Ecore_X_Screen *screen;
+
+        /* FIXME: this is inefficient as its 1 or more round trips */
+        screen = ecore_x_default_screen_get();
+        if (ecore_x_screen_count_get() > 1)
+          {
+             Ecore_X_Window *roots;
+             int num, i;
+
+             num = 0;
+             roots = ecore_x_window_root_list(&num);
+             if (roots)
+               {
+                  Ecore_X_Window root;
+
+                  root = ecore_x_window_root_get(parent);
+                  for (i = 0; i < num; i++)
+                    {
+                       if (root == roots[i])
+                         {
+                            screen = ecore_x_screen_get(i);
+                            break;
+                         }
+                    }
+                  free(roots);
+               }
+          }
+
+        einfo->info.destination_alpha = argb;
+
+        if (redraw_debug < 0)
+          {
+             if (getenv("REDRAW_DEBUG"))
+               redraw_debug = atoi(getenv("REDRAW_DEBUG"));
+             else
+               redraw_debug = 0;
+          }
+
+# ifdef BUILD_ECORE_EVAS_SOFTWARE_XCB
+        einfo->info.backend = EVAS_ENGINE_INFO_SOFTWARE_X11_BACKEND_XCB;
+        einfo->info.connection = ecore_x_connection_get();
+        einfo->info.screen = screen;
+# else
+        einfo->info.backend = EVAS_ENGINE_INFO_SOFTWARE_X11_BACKEND_XLIB;
+        einfo->info.connection = ecore_x_display_get();
+        einfo->info.screen = NULL;
+# endif
+        einfo->info.drawable = ee->prop.window;
+
+# ifdef EVAS_FRAME_QUEUING
+          {
+             char *render_mode;
+
+             render_mode = getenv("EVAS_RENDER_MODE");
+             if ((render_mode) && (!strcmp(render_mode, "non-blocking")))
+               einfo->render_mode = EVAS_RENDER_MODE_NONBLOCKING;
+          }
+# endif
+
+        if (argb)
+          {
+             Ecore_X_Window_Attributes at;
+
+             ecore_x_window_attributes_get(ee->prop.window, &at);
+             einfo->info.visual = at.visual;
+             einfo->info.colormap = at.colormap;
+             einfo->info.depth = at.depth;
+             einfo->info.destination_alpha = 1;
+          }
+        else
+          {
+             einfo->info.visual =
+               ecore_x_default_visual_get(einfo->info.connection, screen);
+             einfo->info.colormap =
+               ecore_x_default_colormap_get(einfo->info.connection, screen);
+             einfo->info.depth =
+               ecore_x_default_depth_get(einfo->info.connection, screen);
+             einfo->info.destination_alpha = 0;
+          }
+
+        einfo->info.rotation = 0;
+        einfo->info.debug = redraw_debug;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+             ecore_evas_free(ee);
+             return NULL;
+          }
+     }
+
+   ecore_x_icccm_hints_set(ee->prop.window,
+                           1 /* accepts_focus */,
+                           ECORE_X_WINDOW_STATE_HINT_NORMAL /* initial_state */,
+                           0 /* icon_pixmap */,
+                           0 /* icon_mask */,
+                           0 /* icon_window */,
+                           0 /* window_group */,
+                           0 /* is_urgent */);
+   _ecore_evas_x_group_leader_set(ee);
+   ecore_x_window_defaults_set(ee->prop.window);
+   _ecore_evas_x_protocols_set(ee);
+   _ecore_evas_x_sync_set(ee);
+
+   ee->engine.func->fn_render = _ecore_evas_x_render;
+   _ecore_evas_register(ee);
+   ecore_x_input_multi_select(ee->prop.window);
+   ecore_event_window_register(ee->prop.window, ee, ee->evas,
+                               (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                               (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                               (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                               (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+   return ee;
+}
+#else
+EAPI Ecore_Evas *
+ecore_evas_software_x11_new(const char *disp_name __UNUSED__, Ecore_X_Window parent __UNUSED__,
+                            int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
+{
+   return NULL;
+}
+#endif
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+EAPI Ecore_X_Window
+ecore_evas_software_x11_window_get(const Ecore_Evas *ee)
+{
+   return (Ecore_X_Window) ecore_evas_window_get(ee);
+}
+#else
+EAPI Ecore_X_Window
+ecore_evas_software_x11_window_get(const Ecore_Evas *ee __UNUSED__)
+{
+   return 0;
+}
+#endif
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+EAPI void
+ecore_evas_software_x11_direct_resize_set(Ecore_Evas *ee, Eina_Bool on)
+{
+   ee->engine.x.direct_resize = on;
+   if (ee->prop.avoid_damage)
+     {
+        if (ee->engine.x.direct_resize)
+          {
+/* turn this off for now
+             ee->engine.x.using_bg_pixmap = 1;
+             ecore_x_window_pixmap_set(ee->prop.window, ee->engine.x.pmap);
+ */
+          }
+        else
+          {
+/* turn this off too- bg pixmap is controlled by avoid damage directly
+             ee->engine.x.using_bg_pixmap = 0;
+             ecore_x_window_pixmap_set(ee->prop.window, 0);
+             ecore_x_window_area_expose(ee->prop.window, 0, 0, ee->w, ee->h);
+ */
+          }
+     }
+}
+#else
+EAPI void
+ecore_evas_software_x11_direct_resize_set(Ecore_Evas *ee __UNUSED__, Eina_Bool on __UNUSED__)
+{
+}
+#endif
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+EAPI Eina_Bool
+ecore_evas_software_x11_direct_resize_get(const Ecore_Evas *ee)
+{
+   return ee->engine.x.direct_resize;
+}
+#else
+EAPI Eina_Bool
+ecore_evas_software_x11_direct_resize_get(const Ecore_Evas *ee __UNUSED__)
+{
+   return 0;
+}
+#endif
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#ifdef BUILD_ECORE_EVAS_SOFTWARE_X11
+EAPI void
+ecore_evas_software_x11_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win)
+{
+   Ecore_X_Window *winp;
+
+   winp = malloc(sizeof(Ecore_X_Window));
+   if (winp)
+     {
+        *winp = win;
+        ee->engine.x.win_extra = eina_list_append(ee->engine.x.win_extra, winp);
+        ecore_x_input_multi_select(win);
+        ecore_event_window_register(win, ee, ee->evas,
+                                    (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                                    (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                                    (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                                    (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+     }
+}
+#else
+EAPI void
+ecore_evas_software_x11_extra_event_window_add(Ecore_Evas *ee __UNUSED__, Ecore_X_Window win __UNUSED__)
+{
+}
+#endif
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#ifdef BUILD_ECORE_EVAS_OPENGL_X11
+EAPI Ecore_Evas *
+ecore_evas_gl_x11_new(const char *disp_name, Ecore_X_Window parent,
+                      int x, int y, int w, int h)
+{
+   return ecore_evas_gl_x11_options_new(disp_name, parent, x, y, w, h, NULL);
+}
+
+EAPI Ecore_Evas *
+ecore_evas_gl_x11_options_new(const char *disp_name, Ecore_X_Window parent,
+                              int x, int y, int w, int h, const int *opt)
+{
+   Ecore_Evas *ee;
+   int rmethod;
+   char *id = NULL;
+
+   rmethod = evas_render_method_lookup("gl_x11");
+   if (!rmethod) return NULL;
+   if (!ecore_x_init(disp_name)) return NULL;
+   ee = calloc(1, sizeof(Ecore_Evas));
+   if (!ee) return NULL;
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+   _ecore_evas_x_init();
+
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_x_engine_func;
+
+   ee->driver = "opengl_x11";
+   if (!getenv("ECORE_EVAS_COMP_NOSEMISYNC"))
+      ee->semi_sync = 1; // gl engine doesn't need to sync - its whole swaps
+//   ee->no_comp_sync = 1; // gl engine doesn't need to sync - its whole swaps
+   if (disp_name) ee->name = strdup(disp_name);
+
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   ee->x = x;
+   ee->y = y;
+   ee->w = w;
+   ee->h = h;
+   ee->req.x = ee->x;
+   ee->req.y = ee->y;
+   ee->req.w = ee->w;
+   ee->req.h = ee->h;
+
+   ee->prop.max.w = 32767;
+   ee->prop.max.h = 32767;
+   ee->prop.layer = 4;
+   ee->prop.request_pos = 0;
+   ee->prop.sticky = 0;
+   ee->engine.x.state.sticky = 0;
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_PRE, _ecore_evas_x_flush_pre, ee);
+   evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_POST, _ecore_evas_x_flush_post, ee);
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_method_set(ee->evas, rmethod);
+   evas_output_size_set(ee->evas, w, h);
+   evas_output_viewport_set(ee->evas, 0, 0, w, h);
+
+   if (parent == 0) parent = DefaultRootWindow(ecore_x_display_get());
+   ee->engine.x.win_root = parent;
+
+   if (ee->engine.x.win_root != 0)
+     {
+        ee->engine.x.screen_num = 1; /* FIXME: get real scren # */
+       /* FIXME: round trip in ecore_x_window_argb_get */
+        if (ecore_x_window_argb_get(ee->engine.x.win_root))
+          {
+             ee->prop.window = _ecore_evas_x_gl_window_new
+               (ee, ee->engine.x.win_root, x, y, w, h, 0, 1, opt);
+          }
+        else
+          ee->prop.window = _ecore_evas_x_gl_window_new
+          (ee, ee->engine.x.win_root, x, y, w, h, 0, 0, opt);
+     }
+   else
+     ee->prop.window = _ecore_evas_x_gl_window_new
+     (ee, ee->engine.x.win_root, x, y, w, h, 0, 0, opt);
+   if (!ee->prop.window)
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        ecore_evas_free(ee);
+        return NULL;
+     }
+   if ((id = getenv("DESKTOP_STARTUP_ID")))
+     {
+        ecore_x_netwm_startup_id_set(ee->prop.window, id);
+        /* NB: on linux this may simply empty the env as opposed to completely
+         * unset it to being empty - unsure as solartis libc crashes looking
+         * for the '=' char */
+//        putenv((char*)"DESKTOP_STARTUP_ID=");
+     }
+
+   ecore_x_icccm_hints_set(ee->prop.window,
+                           1 /* accepts_focus */,
+                           ECORE_X_WINDOW_STATE_HINT_NORMAL /* initial_state */,
+                           0 /* icon_pixmap */,
+                           0 /* icon_mask */,
+                           0 /* icon_window */,
+                           0 /* window_group */,
+                           0 /* is_urgent */);
+   _ecore_evas_x_group_leader_set(ee);
+   ecore_x_window_defaults_set(ee->prop.window);
+   _ecore_evas_x_protocols_set(ee);
+   _ecore_evas_x_sync_set(ee);
+
+   ee->engine.func->fn_render = _ecore_evas_x_render;
+   _ecore_evas_register(ee);
+   ecore_x_input_multi_select(ee->prop.window);
+   ecore_event_window_register(ee->prop.window, ee, ee->evas,
+                               (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                               (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                               (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                               (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+
+   return ee;
+}
+#else
+EAPI Ecore_Evas *
+ecore_evas_gl_x11_new(const char *disp_name __UNUSED__, Ecore_X_Window parent __UNUSED__,
+                      int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
+{
+   return NULL;
+}
+EAPI Ecore_Evas *
+ecore_evas_gl_x11_options_new(const char *disp_name __UNUSED__, Ecore_X_Window parent __UNUSED__,
+                              int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__, const int *opt __UNUSED__)
+{
+   return NULL;
+}
+#endif /* ! BUILD_ECORE_EVAS_OPENGL_X11 */
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#ifdef BUILD_ECORE_EVAS_OPENGL_X11
+EAPI Ecore_X_Window
+ecore_evas_gl_x11_window_get(const Ecore_Evas *ee)
+{
+   return (Ecore_X_Window) ecore_evas_window_get(ee);
+}
+#else
+EAPI Ecore_X_Window
+ecore_evas_gl_x11_window_get(const Ecore_Evas *ee __UNUSED__)
+{
+   return 0;
+}
+#endif /* ! BUILD_ECORE_EVAS_OPENGL_X11 */
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#ifdef BUILD_ECORE_EVAS_OPENGL_X11
+EAPI void
+ecore_evas_gl_x11_direct_resize_set(Ecore_Evas *ee, Eina_Bool on)
+{
+   ee->engine.x.direct_resize = on;
+}
+#else
+EAPI void
+ecore_evas_gl_x11_direct_resize_set(Ecore_Evas *ee __UNUSED__, Eina_Bool on __UNUSED__)
+{
+}
+#endif /* ! BUILD_ECORE_EVAS_OPENGL_X11 */
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#ifdef BUILD_ECORE_EVAS_OPENGL_X11
+EAPI Eina_Bool
+ecore_evas_gl_x11_direct_resize_get(const Ecore_Evas *ee)
+{
+   return ee->engine.x.direct_resize;
+}
+#else
+EAPI Eina_Bool
+ecore_evas_gl_x11_direct_resize_get(const Ecore_Evas *ee __UNUSED__)
+{
+   return 0;
+}
+#endif /* ! BUILD_ECORE_EVAS_OPENGL_X11 */
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#ifdef BUILD_ECORE_EVAS_OPENGL_X11
+EAPI void
+ecore_evas_gl_x11_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win)
+{
+   ecore_evas_software_x11_extra_event_window_add(ee, win);
+}
+#else
+EAPI void
+ecore_evas_gl_x11_extra_event_window_add(Ecore_Evas *ee __UNUSED__, Ecore_X_Window win __UNUSED__)
+{
+}
+#endif /* ! BUILD_ECORE_EVAS_OPENGL_X11 */
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#ifdef BUILD_ECORE_EVAS_OPENGL_X11
+EAPI void
+ecore_evas_gl_x11_pre_post_swap_callback_set(const Ecore_Evas *ee, void *data, void (*pre_cb) (void *data, Evas *e), void (*post_cb) (void *data, Evas *e))
+{
+   Evas_Engine_Info_GL_X11 *einfo;
+
+   if (!(!strcmp(ee->driver, "opengl_x11"))) return;
+
+   einfo = (Evas_Engine_Info_GL_X11 *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        einfo->callback.pre_swap = pre_cb;
+        einfo->callback.post_swap = post_cb;
+        einfo->callback.data = data;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() for engine '%s' failed.", ee->driver);
+          }
+     }
+}
+#else
+EAPI void
+ecore_evas_gl_x11_pre_post_swap_callback_set(const Ecore_Evas *ee __UNUSED__, void *data __UNUSED__, void (*pre_cb) (void *data, Evas *e) __UNUSED__, void (*post_cb) (void *data, Evas *e) __UNUSED__)
+{
+   return;
+}
+#endif /* ! BUILD_ECORE_EVAS_OPENGL_X11 */
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed or maybe removed rather?
+ */
+EAPI Ecore_Evas *
+ecore_evas_xrender_x11_new(const char *disp_name __UNUSED__, Ecore_X_Window parent __UNUSED__,
+                           int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
+{
+   return NULL;
+}
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed or maybe removed rather?
+ */
+EAPI Ecore_X_Window
+ecore_evas_xrender_x11_window_get(const Ecore_Evas *ee __UNUSED__)
+{
+   return 0;
+}
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+EAPI void
+ecore_evas_xrender_x11_direct_resize_set(Ecore_Evas *ee __UNUSED__, Eina_Bool on __UNUSED__)
+{
+}
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+EAPI Eina_Bool
+ecore_evas_xrender_x11_direct_resize_get(const Ecore_Evas *ee __UNUSED__)
+{
+   return 0;
+}
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+EAPI void
+ecore_evas_xrender_x11_extra_event_window_add(Ecore_Evas *ee __UNUSED__, Ecore_X_Window win __UNUSED__)
+{
+}
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#if BUILD_ECORE_EVAS_SOFTWARE_16_X11
+EAPI Ecore_Evas *
+ecore_evas_software_x11_16_new(const char *disp_name, Ecore_X_Window parent,
+                               int x, int y, int w, int h)
+{
+   Evas_Engine_Info_Software_16_X11 *einfo;
+   Ecore_Evas *ee;
+   int rmethod;
+   static int redraw_debug = -1;
+
+   rmethod = evas_render_method_lookup("software_16_x11");
+   if (!rmethod) return NULL;
+   if (!ecore_x_init(disp_name)) return NULL;
+   ee = calloc(1, sizeof(Ecore_Evas));
+   if (!ee) return NULL;
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+   _ecore_evas_x_init();
+
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_x_engine_func;
+
+   ee->driver = "software_16_x11";
+   if (disp_name) ee->name = strdup(disp_name);
+
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   ee->x = x;
+   ee->y = y;
+   ee->w = w;
+   ee->h = h;
+   ee->req.x = ee->x;
+   ee->req.y = ee->y;
+   ee->req.w = ee->w;
+   ee->req.h = ee->h;
+
+   ee->prop.max.w = 32767;
+   ee->prop.max.h = 32767;
+   ee->prop.layer = 4;
+   ee->prop.request_pos = 0;
+   ee->prop.sticky = 0;
+   ee->engine.x.state.sticky = 0;
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_PRE, _ecore_evas_x_flush_pre, ee);
+   evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_POST, _ecore_evas_x_flush_post, ee);
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_method_set(ee->evas, rmethod);
+   evas_output_size_set(ee->evas, w, h);
+   evas_output_viewport_set(ee->evas, 0, 0, w, h);
+
+   ee->engine.x.win_root = parent;
+   if (parent != 0)
+     {
+       /* FIXME: round trip in ecore_x_window_argb_get */
+        if (ecore_x_window_argb_get(parent))
+          {
+             ee->prop.window = ecore_x_window_argb_new(parent, x, y, w, h);
+          }
+        else
+          ee->prop.window = ecore_x_window_new(parent, x, y, w, h);
+     }
+   else
+     ee->prop.window = ecore_x_window_new(parent, x, y, w, h);
+   if (getenv("DESKTOP_STARTUP_ID"))
+     {
+        ecore_x_netwm_startup_id_set(ee->prop.window,
+                                     getenv("DESKTOP_STARTUP_ID"));
+        /* NB: on linux this may simply empty the env as opposed to completely
+         * unset it to being empty - unsure as solartis libc crashes looking
+         * for the '=' char */
+//        putenv((char*)"DESKTOP_STARTUP_ID=");
+     }
+   einfo = (Evas_Engine_Info_Software_16_X11 *)evas_engine_info_get(ee->evas);
+
+   if (einfo)
+     {
+        if (ScreenCount(ecore_x_display_get()) > 1)
+          {
+             Ecore_X_Window *roots;
+             int num, i;
+
+             num = 0;
+             roots = ecore_x_window_root_list(&num);
+             if (roots)
+               {
+                  XWindowAttributes at;
+
+                  if (XGetWindowAttributes(ecore_x_display_get(),
+                                           parent, &at))
+                    {
+                       for (i = 0; i < num; i++)
+                         {
+                            if (at.root == roots[i])
+                              break;
+                         }
+                    }
+                  free(roots);
+               }
+          }
+
+        if (redraw_debug < 0)
+          {
+             if (getenv("REDRAW_DEBUG"))
+               redraw_debug = atoi(getenv("REDRAW_DEBUG"));
+             else
+               redraw_debug = 0;
+          }
+        einfo->info.display  = ecore_x_display_get();
+        einfo->info.drawable = ee->prop.window;
+
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+             ecore_evas_free(ee);
+             return NULL;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        ecore_evas_free(ee);
+        return NULL;
+     }
+
+   ecore_x_icccm_hints_set(ee->prop.window,
+                           1 /* accepts_focus */,
+                           ECORE_X_WINDOW_STATE_HINT_NORMAL /* initial_state */,
+                           0 /* icon_pixmap */,
+                           0 /* icon_mask */,
+                           0 /* icon_window */,
+                           0 /* window_group */,
+                           0 /* is_urgent */);
+   _ecore_evas_x_group_leader_set(ee);
+   ecore_x_window_defaults_set(ee->prop.window);
+   _ecore_evas_x_protocols_set(ee);
+   _ecore_evas_x_sync_set(ee);
+
+   ee->engine.func->fn_render = _ecore_evas_x_render;
+   _ecore_evas_register(ee);
+   ecore_x_input_multi_select(ee->prop.window);
+   ecore_event_window_register(ee->prop.window, ee, ee->evas,
+                               (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                               (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                               (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                               (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+   return ee;
+}
+#else
+EAPI Ecore_Evas *
+ecore_evas_software_x11_16_new(const char *disp_name __UNUSED__, Ecore_X_Window parent __UNUSED__,
+                               int x __UNUSED__, int y __UNUSED__, int w __UNUSED__, int h __UNUSED__)
+{
+   return NULL;
+}
+#endif /* ! BUILD_ECORE_EVAS_SOFTWARE_16_X11 */
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#if BUILD_ECORE_EVAS_SOFTWARE_16_X11
+EAPI Ecore_X_Window
+ecore_evas_software_x11_16_window_get(const Ecore_Evas *ee)
+{
+   return (Ecore_X_Window) ecore_evas_window_get(ee);
+}
+#else
+EAPI Ecore_X_Window
+ecore_evas_software_x11_16_window_get(const Ecore_Evas *ee __UNUSED__)
+{
+   return 0;
+}
+#endif /* ! BUILD_ECORE_EVAS_SOFTWARE_16_X11 */
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#if BUILD_ECORE_EVAS_SOFTWARE_16_X11
+EAPI void
+ecore_evas_software_x11_16_direct_resize_set(Ecore_Evas *ee, Eina_Bool on)
+{
+   ee->engine.x.direct_resize = on;
+   if (ee->prop.avoid_damage)
+     {
+        if (ee->engine.x.direct_resize)
+          {
+/* turn this off for now
+             ee->engine.x.using_bg_pixmap = 1;
+             ecore_x_window_pixmap_set(ee->prop.window, ee->engine.x.pmap);
+ */
+          }
+        else
+          {
+/* turn this off too- bg pixmap is controlled by avoid damage directly
+             ee->engine.x.using_bg_pixmap = 0;
+             ecore_x_window_pixmap_set(ee->prop.window, 0);
+             ecore_x_window_area_expose(ee->prop.window, 0, 0, ee->w, ee->h);
+ */
+          }
+     }
+}
+#else
+EAPI void
+ecore_evas_software_x11_16_direct_resize_set(Ecore_Evas *ee __UNUSED__, Eina_Bool on __UNUSED__)
+{
+}
+#endif /* ! BUILD_ECORE_EVAS_SOFTWARE_16_X11 */
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#if BUILD_ECORE_EVAS_SOFTWARE_16_X11
+EAPI Eina_Bool
+ecore_evas_software_x11_16_direct_resize_get(const Ecore_Evas *ee)
+{
+   return ee->engine.x.direct_resize;
+}
+#else
+EAPI Eina_Bool
+ecore_evas_software_x11_16_direct_resize_get(const Ecore_Evas *ee __UNUSED__)
+{
+   return 0;
+}
+#endif /* ! BUILD_ECORE_EVAS_SOFTWARE_16_X11 */
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+#if BUILD_ECORE_EVAS_SOFTWARE_16_X11
+EAPI void
+ecore_evas_software_x11_16_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win)
+{
+   Ecore_X_Window *winp;
+
+   winp = malloc(sizeof(Ecore_X_Window));
+   if (winp)
+     {
+        *winp = win;
+        ee->engine.x.win_extra = eina_list_append(ee->engine.x.win_extra, winp);
+        ecore_x_input_multi_select(win);
+        ecore_event_window_register(win, ee, ee->evas,
+                                    (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                                    (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                                    (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                                    (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+     }
+}
+#else
+EAPI void
+ecore_evas_software_x11_16_extra_event_window_add(Ecore_Evas *ee __UNUSED__, Ecore_X_Window win __UNUSED__)
+{
+}
+#endif /* ! BUILD_ECORE_EVAS_SOFTWARE_16_X11 */
+
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+EAPI Ecore_Evas *
+ecore_evas_software_x11_8_new(const char *disp_name, Ecore_X_Window parent,
+                              int x, int y, int w, int h)
+{
+#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
+   Evas_Engine_Info_Software_8_X11 *einfo;
+   Ecore_Evas *ee;
+   int argb = 0;
+   int rmethod;
+   static int redraw_debug = -1;
+
+   rmethod = evas_render_method_lookup("software_8_x11");
+   if (!rmethod) return NULL;
+   if (!ecore_x_init(disp_name)) return NULL;
+   ee = calloc(1, sizeof(Ecore_Evas));
+   if (!ee) return NULL;
+
+   ECORE_MAGIC_SET(ee, ECORE_MAGIC_EVAS);
+
+   _ecore_evas_x_init();
+
+   ee->engine.func = (Ecore_Evas_Engine_Func *)&_ecore_x_engine_func;
+
+   ee->driver = "software_8_x11";
+   if (disp_name) ee->name = strdup(disp_name);
+
+   if (w < 1) w = 1;
+   if (h < 1) h = 1;
+   ee->x = x;
+   ee->y = y;
+   ee->w = w;
+   ee->h = h;
+   ee->req.x = ee->x;
+   ee->req.y = ee->y;
+   ee->req.w = ee->w;
+   ee->req.h = ee->h;
+
+   ee->prop.max.w = 32767;
+   ee->prop.max.h = 32767;
+   ee->prop.layer = 4;
+   ee->prop.request_pos = 0;
+   ee->prop.sticky = 0;
+   ee->engine.x.state.sticky = 0;
+
+   /* init evas here */
+   ee->evas = evas_new();
+   evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_PRE, _ecore_evas_x_flush_pre, ee);
+   evas_event_callback_add(ee->evas, EVAS_CALLBACK_RENDER_FLUSH_POST, _ecore_evas_x_flush_post, ee);
+   evas_data_attach_set(ee->evas, ee);
+   evas_output_method_set(ee->evas, rmethod);
+   evas_output_size_set(ee->evas, w, h);
+   evas_output_viewport_set(ee->evas, 0, 0, w, h);
+
+   ee->engine.x.win_root = parent;
+   //   if (parent != 0)
+   //     {
+   //       /* FIXME: round trip in ecore_x_window_argb_get */
+   //        if (ecore_x_window_argb_get(parent))
+   //          {
+   //             ee->engine.x.win = ecore_x_window_argb_new(parent, x, y, w, h);
+   //             argb = 1;
+   //          }
+   //        else
+   //          ee->engine.x.win = ecore_x_window_new(parent, x, y, w, h);
+   //     }
+   //   else
+   ee->prop.window = ecore_x_window_new(parent, x, y, w, h);
+   if (getenv("DESKTOP_STARTUP_ID"))
+     {
+        ecore_x_netwm_startup_id_set(ee->prop.window,
+              getenv("DESKTOP_STARTUP_ID"));
+        /* NB: on linux this may simply empty the env as opposed to completely
+         * unset it to being empty - unsure as solartis libc crashes looking
+         * for the '=' char */
+        //        putenv((char*)"DESKTOP_STARTUP_ID=");
+     }
+   einfo = (Evas_Engine_Info_Software_8_X11 *)evas_engine_info_get(ee->evas);
+   if (einfo)
+     {
+        xcb_screen_iterator_t iter;
+        xcb_screen_t         *screen;
+
+        /* FIXME: this is inefficient as its a round trip */
+        //einfo->info.backend = 1;
+        screen = ecore_x_default_screen_get();
+        iter = xcb_setup_roots_iterator (xcb_get_setup (ecore_x_connection_get()));
+        if (iter.rem > 1)
+          {
+             xcb_get_geometry_cookie_t cookie;
+             xcb_get_geometry_reply_t *reply;
+             Ecore_X_Window           *roots;
+             int                       num;
+             uint8_t                   i;
+
+             num = 0;
+             cookie = xcb_get_geometry_unchecked(ecore_x_connection_get(), parent);
+             roots = ecore_x_window_root_list(&num);
+             if (roots)
+               {
+                  reply = xcb_get_geometry_reply(ecore_x_connection_get(), cookie, NULL);
+
+                  if (reply)
+                    {
+                       for (i = 0; i < num; xcb_screen_next (&iter), i++)
+                         {
+                            if (reply->root == roots[i])
+                              {
+                                 screen = iter.data;
+                                 break;
+                              }
+                         }
+                       free(reply);
+                    }
+                  free(roots);
+               }
+             else
+               {
+                  reply = xcb_get_geometry_reply(ecore_x_connection_get(), cookie, NULL);
+                  if (reply) free(reply);
+               }
+          }
+
+        if (redraw_debug < 0)
+          {
+             if (getenv("REDRAW_DEBUG"))
+               redraw_debug = atoi(getenv("REDRAW_DEBUG"));
+             else
+               redraw_debug = 0;
+          }
+        einfo->info.connection = ecore_x_connection_get();
+        einfo->info.screen = screen;
+        einfo->info.drawable = ee->prop.window;
+        if (argb)
+          {
+             /* FIXME: round trip */
+             xcb_get_geometry_cookie_t          cookie_geom;
+             xcb_get_window_attributes_cookie_t cookie_attr;
+             xcb_get_geometry_reply_t          *reply_geom;
+             xcb_get_window_attributes_reply_t *reply_attr;
+
+             cookie_geom = xcb_get_geometry_unchecked(ecore_x_connection_get(), ee->prop.window);
+             cookie_attr = xcb_get_window_attributes_unchecked(ecore_x_connection_get(), ee->prop.window);
+
+             reply_geom = xcb_get_geometry_reply(ecore_x_connection_get(), cookie_geom, NULL);
+             reply_attr = xcb_get_window_attributes_reply(ecore_x_connection_get(), cookie_attr, NULL);
+             if (reply_attr && reply_geom)
+               {
+                  einfo->info.visual   = xcb_visualtype_get(ecore_x_default_screen_get(), reply_attr->visual);
+                  einfo->info.colormap = reply_attr->colormap;
+                  einfo->info.depth    = reply_geom->depth;
+                  einfo->info.destination_alpha = 1;
+                  free(reply_geom);
+                  free(reply_attr);
+               }
+          }
+        else
+          {
+             xcb_screen_t *screen;
+
+             screen = ecore_x_default_screen_get();
+             einfo->info.visual   = xcb_visualtype_get(screen, screen->root_visual);
+             einfo->info.colormap = screen->default_colormap;
+             einfo->info.depth    = screen->root_depth;
+             einfo->info.destination_alpha = 0;
+          }
+        einfo->info.rotation = 0;
+        einfo->info.debug    = redraw_debug;
+        if (!evas_engine_info_set(ee->evas, (Evas_Engine_Info *)einfo))
+          {
+             ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+             ecore_evas_free(ee);
+             return NULL;
+          }
+     }
+   else
+     {
+        ERR("evas_engine_info_set() init engine '%s' failed.", ee->driver);
+        ecore_evas_free(ee);
+        return NULL;
+     }
+
+   ecore_x_icccm_hints_set(ee->prop.window,
+                           1 /* accepts_focus */,
+                           ECORE_X_WINDOW_STATE_HINT_NORMAL /* initial_state */,
+                           0 /* icon_pixmap */,
+                           0 /* icon_mask */,
+                           0 /* icon_window */,
+                           0 /* window_group */,
+                           0 /* is_urgent */);
+   _ecore_evas_x_group_leader_set(ee);
+   ecore_x_window_defaults_set(ee->prop.window);
+   _ecore_evas_x_protocols_set(ee);
+   _ecore_evas_x_sync_set(ee);
+
+   ee->engine.func->fn_render = _ecore_evas_x_render;
+   _ecore_evas_register(ee);
+   ecore_x_input_multi_select(ee->prop.window);
+   ecore_event_window_register(ee->prop.window, ee, ee->evas,
+                               (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                               (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                               (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                               (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+
+   return ee;
+#else
+   return NULL;
+   (void)(disp_name);
+   (void)(parent);
+   (void)(x);
+   (void)(y);
+   (void)(w);
+   (void)(h);
+#endif /* ! BUILD_ECORE_EVAS_SOFTWARE_8_X11 */
+}
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+EAPI Ecore_X_Window
+ecore_evas_software_x11_8_window_get(const Ecore_Evas *ee)
+{
+#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
+   return (Ecore_X_Window) ecore_evas_window_get(ee);
+#else
+   return 0;
+   (void)(ee);
+#endif
+}
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+EAPI Ecore_X_Window
+ecore_evas_software_x11_8_subwindow_get(const Ecore_Evas *ee)
+{
+#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
+   return (Ecore_X_Window) ecore_evas_window_get(ee);
+#else
+   return 0;
+   (void)(ee);
+#endif
+}
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+EAPI void
+ecore_evas_software_x11_8_direct_resize_set(Ecore_Evas *ee, Eina_Bool on)
+{
+#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
+   ee->engine.x.direct_resize = on;
+   if (ee->prop.avoid_damage)
+     {
+        if (ee->engine.x.direct_resize)
+          {
+             /* turn this off for now
+                ee->engine.x.using_bg_pixmap = 1;
+                ecore_x_window_pixmap_set(ee->engine.x.win, ee->engine.x.pmap);
+                */
+          }
+        else
+          {
+             /* turn this off too- bg pixmap is controlled by avoid damage directly
+                ee->engine.x.using_bg_pixmap = 0;
+                ecore_x_window_pixmap_set(ee->engine.x.win, 0);
+                ecore_x_window_area_expose(ee->engine.x.win, 0, 0, ee->w, ee->h);
+                */
+          }
+     }
+#else
+   return;
+   (void)(ee);
+   (void)(on);
+#endif
+}
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+EAPI Eina_Bool
+ecore_evas_software_x11_8_direct_resize_get(const Ecore_Evas *ee)
+{
+#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
+   return ee->engine.x.direct_resize;
+#else
+   return 0;
+   (void)(ee);
+#endif
+}
+
+/**
+ * To be documented.
+ *
+ * FIXME: To be fixed.
+ */
+EAPI void
+ecore_evas_software_x11_8_extra_event_window_add(Ecore_Evas *ee, Ecore_X_Window win)
+{
+#if defined (BUILD_ECORE_EVAS_SOFTWARE_8_X11)
+   Ecore_X_Window *winp;
+
+   winp = malloc(sizeof(Ecore_X_Window));
+   if (winp)
+     {
+        *winp = win;
+        ee->engine.x.win_extra = eina_list_append(ee->engine.x.win_extra, winp);
+        ecore_x_input_multi_select(win);
+        ecore_event_window_register(win, ee, ee->evas,
+                                    (Ecore_Event_Mouse_Move_Cb)_ecore_evas_mouse_move_process,
+                                    (Ecore_Event_Multi_Move_Cb)_ecore_evas_mouse_multi_move_process,
+                                    (Ecore_Event_Multi_Down_Cb)_ecore_evas_mouse_multi_down_process,
+                                    (Ecore_Event_Multi_Up_Cb)_ecore_evas_mouse_multi_up_process);
+     }
+#else
+   return;
+   (void)(ee);
+   (void)(win);
+#endif
+}
+
+EAPI void
+ecore_evas_x11_leader_set(Ecore_Evas *ee, Ecore_X_Window win)
+{
+#ifdef BUILD_ECORE_EVAS_X11
+   _ecore_evas_x_group_leader_unset(ee);
+   ee->engine.x.leader = win;
+   _ecore_evas_x_group_leader_update(ee);
+#else
+   return;
+   ee = NULL;
+   win = 0;
+#endif
+}
+
+EAPI Ecore_X_Window
+ecore_evas_x11_leader_get(Ecore_Evas *ee)
+{
+#ifdef BUILD_ECORE_EVAS_X11
+   return ee->engine.x.leader;
+#else
+   return 0;
+   ee = NULL;
+#endif
+}
+
+EAPI void
+ecore_evas_x11_leader_default_set(Ecore_Evas *ee)
+{
+#ifdef BUILD_ECORE_EVAS_X11
+   _ecore_evas_x_group_leader_unset(ee);
+   _ecore_evas_x_group_leader_set(ee);
+#else
+   return;
+   ee = NULL;
+#endif
+}
+
+#ifdef BUILD_ECORE_EVAS_X11
+static Eina_Bool
+_ecore_evas_x11_convert_rectangle_with_angle(Ecore_Evas *ee, Ecore_X_Rectangle *dst_rect, Ecore_X_Rectangle *src_rect)
+{
+   if ((!src_rect) || (!dst_rect)) return 0;
+
+   if (ee->rotation == 0)
+     {
+        dst_rect->x = src_rect->x;
+        dst_rect->y = src_rect->y;
+        dst_rect->width = src_rect->width;
+        dst_rect->height = src_rect->height;
+     }
+   else if (ee->rotation == 90)
+     {
+        dst_rect->x = src_rect->y;
+        dst_rect->y = ee->req.h - src_rect->x - src_rect->width;
+        dst_rect->width = src_rect->height;
+        dst_rect->height = src_rect->width;
+     }
+   else if (ee->rotation == 180)
+     {
+        dst_rect->x = ee->req.w - src_rect->x - src_rect->width;
+        dst_rect->y = ee->req.h - src_rect->y - src_rect->height;
+        dst_rect->width = src_rect->width;
+        dst_rect->height = src_rect->height;
+     }
+   else if (ee->rotation == 270)
+     {
+        dst_rect->x = ee->req.w - src_rect->y - src_rect->height;
+        dst_rect->y = src_rect->x;
+        dst_rect->width = src_rect->height;
+        dst_rect->height = src_rect->width;
+     }
+   else
+     {
+        return 0;
+     }
+
+   return 1;
+}
+#endif
+
+EAPI void
+ecore_evas_x11_shape_input_rectangle_set(Ecore_Evas *ee, int x, int y, int w, int h)
+{
+#ifdef BUILD_ECORE_EVAS_X11
+   Eina_Bool ret;
+   Ecore_X_Rectangle src_rect;
+   Ecore_X_Rectangle dst_rect;
+
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_x11_shape_input_rectangle_set");
+        return;
+     }
+
+   src_rect.x = x;
+   src_rect.y = y;
+   src_rect.width = w;
+   src_rect.height = h;
+
+   dst_rect.x = 0;
+   dst_rect.y = 0;
+   dst_rect.width = 0;
+   dst_rect.height = 0;
+
+   ret = _ecore_evas_x11_convert_rectangle_with_angle(ee, &dst_rect, &src_rect);
+
+   if (!ee->engine.x.win_shaped_input)
+      ee->engine.x.win_shaped_input = ecore_x_window_override_new(ee->engine.x.win_root,
+                                                                  0, 0, 1, 1);
+
+   if (ret)
+      ecore_x_window_shape_input_rectangle_set(ee->engine.x.win_shaped_input,
+                                               dst_rect.x, dst_rect.y,
+                                               dst_rect.width, dst_rect.height);
+#else
+   return;
+   ee = NULL;
+   x = 0;
+   y = 0;
+   w = 0;
+   h = 0;
+#endif
+}
+
+EAPI void
+ecore_evas_x11_shape_input_rectangle_add(Ecore_Evas *ee, int x, int y, int w, int h)
+{
+#ifdef BUILD_ECORE_EVAS_X11
+   Eina_Bool ret;
+   Ecore_X_Rectangle src_rect;
+   Ecore_X_Rectangle dst_rect;
+
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_x11_shape_input_rectangle_add");
+        return;
+     }
+
+   src_rect.x = x;
+   src_rect.y = y;
+   src_rect.width = w;
+   src_rect.height = h;
+
+   dst_rect.x = 0;
+   dst_rect.y = 0;
+   dst_rect.width = 0;
+   dst_rect.height = 0;
+
+   ret = _ecore_evas_x11_convert_rectangle_with_angle(ee, &dst_rect, &src_rect);
+
+   if (!ee->engine.x.win_shaped_input)
+      ee->engine.x.win_shaped_input = ecore_x_window_override_new(ee->engine.x.win_root,
+                                                                  0, 0, 1, 1);
+
+   if (ret)
+      ecore_x_window_shape_input_rectangle_add(ee->engine.x.win_shaped_input,
+                                               dst_rect.x, dst_rect.y,
+                                               dst_rect.width, dst_rect.height);
+#else
+   return;
+   ee = NULL;
+   x = 0;
+   y = 0;
+   w = 0;
+   h = 0;
+#endif
+}
+
+EAPI void
+ecore_evas_x11_shape_input_rectangle_subtract(Ecore_Evas *ee, int x, int y, int w, int h)
+{
+#ifdef BUILD_ECORE_EVAS_X11
+   Eina_Bool ret;
+   Ecore_X_Rectangle src_rect;
+   Ecore_X_Rectangle dst_rect;
+
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_x11_shape_input_rectangle_subtract");
+        return;
+     }
+
+   src_rect.x = x;
+   src_rect.y = y;
+   src_rect.width = w;
+   src_rect.height = h;
+
+   dst_rect.x = 0;
+   dst_rect.y = 0;
+   dst_rect.width = 0;
+   dst_rect.height = 0;
+
+   ret = _ecore_evas_x11_convert_rectangle_with_angle(ee, &dst_rect, &src_rect);
+
+   if (!ee->engine.x.win_shaped_input)
+      ee->engine.x.win_shaped_input = ecore_x_window_override_new(ee->engine.x.win_root,
+                                                                  0, 0, 1, 1);
+
+   if (ret)
+      ecore_x_window_shape_input_rectangle_subtract(ee->engine.x.win_shaped_input,
+                                                    dst_rect.x, dst_rect.y,
+                                                    dst_rect.width, dst_rect.height);
+#else
+   return;
+   ee = NULL;
+   x = 0;
+   y = 0;
+   w = 0;
+   h = 0;
+#endif
+}
+
+EAPI void
+ecore_evas_x11_shape_input_empty(Ecore_Evas *ee)
+{
+#ifdef BUILD_ECORE_EVAS_X11
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_x11_shape_input_empty");
+        return;
+     }
+
+   if (!ee->engine.x.win_shaped_input)
+      ee->engine.x.win_shaped_input = ecore_x_window_override_new(ee->engine.x.win_root, 0, 0, 1, 1);
+
+   ecore_x_window_shape_input_rectangle_set(ee->engine.x.win_shaped_input, 0, 0, 0, 0);
+#else
+   return;
+   ee = NULL;
+#endif
+}
+
+EAPI void
+ecore_evas_x11_shape_input_reset(Ecore_Evas *ee)
+{
+#ifdef BUILD_ECORE_EVAS_X11
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_x11_shape_input_reset");
+        return;
+     }
+
+   if (!ee->engine.x.win_shaped_input)
+      ee->engine.x.win_shaped_input = ecore_x_window_override_new(ee->engine.x.win_root, 0, 0, 1, 1);
+
+   ecore_x_window_shape_input_rectangle_set(ee->engine.x.win_shaped_input, 0, 0, 65535, 65535);
+#else
+   return;
+   ee = NULL;
+#endif
+}
+
+EAPI void
+ecore_evas_x11_shape_input_apply(Ecore_Evas *ee)
+{
+#ifdef BUILD_ECORE_EVAS_X11
+   if (!ECORE_MAGIC_CHECK(ee, ECORE_MAGIC_EVAS))
+     {
+        ECORE_MAGIC_FAIL(ee, ECORE_MAGIC_EVAS,
+                         "ecore_evas_x11_shape_input_apply");
+        return;
+     }
+
+   if (!ee->engine.x.win_shaped_input) return;
+
+   ecore_x_window_shape_input_window_set(ee->prop.window, ee->engine.x.win_shaped_input);
+#else
+   return;
+   ee = NULL;
+#endif
+}