Evas image: Use macros ENFN/ENDT to improve code readability

These macros replace some very repetitive code:
 - define ENFN obj->layer->evas->engine.func
 - define ENDT obj->layer->evas->engine.data.output

This commit includes lots of space changes as well.
This is a purely cosmetic commit.

diff --git a/src/lib/evas/canvas/evas_object_image.c b/src/lib/evas/canvas/evas_object_image.c
index 5530af4..99e7b8b 100644 (file)
--- a/src/lib/evas/canvas/evas_object_image.c
+++ b/src/lib/evas/canvas/evas_object_image.c
@@ -22,6 +22,10 @@
 
 #define VERBOSE_PROXY_ERROR 1
 
+/* save typing */
+#define ENFN obj->layer->evas->engine.func
+#define ENDT obj->layer->evas->engine.data.output
+
 /* private magic number for image objects */
 static const char o_type[] = "image";
 
@@ -294,9 +298,7 @@ _evas_object_image_cleanup(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj,
    if ((o->preloading) && (o->engine_data))
      {
         o->preloading = EINA_FALSE;
-        obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output,
-                                                                 o->engine_data,
-                                                                 eo_obj);
+        ENFN->image_data_preload_cancel(ENDT, o->engine_data, eo_obj);
      }
    if (o->cur->source) _proxy_unset(eo_obj, obj, o);
    if (o->cur->scene) _3d_unset(eo_obj, obj, o);
@@ -361,8 +363,7 @@ _evas_image_eo_base_constructor(Eo *eo_obj, Evas_Image_Data *o)
    o->prev = eina_cow_alloc(evas_object_image_state_cow);
    o->proxy_src_clip = EINA_TRUE;
 
-   cspace = obj->layer->evas->engine.func->image_colorspace_get(obj->layer->evas->engine.data.output,
-                                                                o->engine_data);
+   cspace = ENFN->image_colorspace_get(ENDT, o->engine_data);
 
    if (!o->cur->filter || (cspace != o->cur->cspace))
      {
@@ -459,9 +460,9 @@ _image_init_set(const Eina_File *f, const char *file, const char *key,
         if (o->preloading)
           {
              o->preloading = EINA_FALSE;
-             obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, eo_obj);
+             ENFN->image_data_preload_cancel(ENDT, o->engine_data, eo_obj);
           }
-        obj->layer->evas->engine.func->image_free(obj->layer->evas->engine.data.output, o->engine_data);
+        ENFN->image_free(ENDT, o->engine_data);
      }
    o->load_error = EVAS_LOAD_ERROR_NONE;
    lo->scale_down_by = o->load_opts->scale_down_by;
@@ -494,16 +495,16 @@ _image_done_set(Eo *eo_obj, Evas_Object_Protected_Data *obj, Evas_Image_Data *o)
         int w, h;
         int stride;
 
-        obj->layer->evas->engine.func->image_size_get(obj->layer->evas->engine.data.output, o->engine_data, &w, &h);
-        if (obj->layer->evas->engine.func->image_stride_get)
-          obj->layer->evas->engine.func->image_stride_get(obj->layer->evas->engine.data.output, o->engine_data, &stride);
+        ENFN->image_size_get(ENDT, o->engine_data, &w, &h);
+        if (ENFN->image_stride_get)
+          ENFN->image_stride_get(ENDT, o->engine_data, &stride);
         else
           stride = w * 4;
 
         EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write)
           {
-             state_write->has_alpha = obj->layer->evas->engine.func->image_alpha_get(obj->layer->evas->engine.data.output, o->engine_data);
-             state_write->cspace = obj->layer->evas->engine.func->image_colorspace_get(obj->layer->evas->engine.data.output, o->engine_data);
+             state_write->has_alpha = ENFN->image_alpha_get(ENDT, o->engine_data);
+             state_write->cspace = ENFN->image_colorspace_get(ENDT, o->engine_data);
 
              if ((o->cur->image.w != w) || (o->cur->image.h != h))
                resize_call = EINA_TRUE;
@@ -554,11 +555,7 @@ _evas_image_mmap_set(Eo *eo_obj, Evas_Image_Data *o, const Eina_File *f, const c
      }
 
    _image_init_set(f, NULL, key, eo_obj, obj, o, &lo);
-   o->engine_data = obj->layer->evas->engine.func->image_mmap(obj->layer->evas->engine.data.output,
-                                                             o->cur->u.f,
-                                                             o->cur->key,
-                                                             &o->load_error,
-                                                             &lo);
+   o->engine_data = ENFN->image_mmap(ENDT, o->cur->u.f, o->cur->key, &o->load_error, &lo);
    _image_done_set(eo_obj, obj, o);
 }
 
@@ -587,16 +584,10 @@ _evas_image_efl_file_file_set(Eo *eo_obj, Evas_Image_Data *o, const char *file,
    /*
     * WTF? why cancel a null image preload? this is just silly (tm)
     if (!o->engine_data)
-     obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output,
-                                                             o->engine_data,
-                                                             eo_obj);
+     ENFN->image_data_preload_cancel(ENDT, o->engine_data, eo_obj);
  */
    _image_init_set(NULL, file, key, eo_obj, obj, o, &lo);
-   o->engine_data = obj->layer->evas->engine.func->image_load(obj->layer->evas->engine.data.output,
-                                                              o->cur->u.file,
-                                                              o->cur->key,
-                                                              &o->load_error,
-                                                              &lo);
+   o->engine_data = ENFN->image_load(ENDT, o->cur->u.file, o->cur->key, &o->load_error, &lo);
    _image_done_set(eo_obj, obj, o);
 
    return EINA_TRUE;
@@ -795,11 +786,7 @@ _evas_image_scene_set(Eo *eo_obj, Evas_Image_Data *o, Evas_3D_Scene *scene)
    if (o->cur->scene == scene) return;
 
    _image_init_set(NULL, NULL, NULL, eo_obj, obj, o, &lo);
-   o->engine_data = obj->layer->evas->engine.func->image_load(obj->layer->evas->engine.data.output,
-                                                              o->cur->u.file,
-                                                              o->cur->key,
-                                                              &o->load_error,
-                                                              &lo);
+   o->engine_data = ENFN->image_load(ENDT, o->cur->u.file, o->cur->key, &o->load_error, &lo);
    _image_done_set(eo_obj, obj, o);
 
    if (scene) _3d_set(eo_obj, scene);
@@ -1002,26 +989,19 @@ _evas_image_size_set(Eo *eo_obj, Evas_Image_Data *o, int w, int h)
    EINA_COW_IMAGE_STATE_WRITE_END(o, state_write);
 
    if (o->engine_data)
-      o->engine_data = obj->layer->evas->engine.func->image_size_set(obj->layer->evas->engine.data.output, o->engine_data, w, h);
+      o->engine_data = ENFN->image_size_set(ENDT, o->engine_data, w, h);
    else
-      o->engine_data = obj->layer->evas->engine.func->image_new_from_copied_data
-      (obj->layer->evas->engine.data.output, w, h, NULL, o->cur->has_alpha,
-          o->cur->cspace);
+      o->engine_data = ENFN->image_new_from_copied_data
+        (ENDT, w, h, NULL, o->cur->has_alpha, o->cur->cspace);
 
    if (o->engine_data)
      {
-        if (obj->layer->evas->engine.func->image_scale_hint_set)
-           obj->layer->evas->engine.func->image_scale_hint_set
-           (obj->layer->evas->engine.data.output,
-               o->engine_data, o->scale_hint);
-        if (obj->layer->evas->engine.func->image_content_hint_set)
-           obj->layer->evas->engine.func->image_content_hint_set
-           (obj->layer->evas->engine.data.output,
-               o->engine_data, o->content_hint);
-        if (obj->layer->evas->engine.func->image_stride_get)
-           obj->layer->evas->engine.func->image_stride_get
-           (obj->layer->evas->engine.data.output,
-               o->engine_data, &stride);
+        if (ENFN->image_scale_hint_set)
+           ENFN->image_scale_hint_set(ENDT, o->engine_data, o->scale_hint);
+        if (ENFN->image_content_hint_set)
+           ENFN->image_content_hint_set(ENDT, o->engine_data, o->content_hint);
+        if (ENFN->image_stride_get)
+           ENFN->image_stride_get(ENDT, o->engine_data, &stride);
         else
            stride = w * 4;
      }
@@ -1033,9 +1013,7 @@ _evas_image_size_set(Eo *eo_obj, Evas_Image_Data *o, int w, int h)
 
 /* FIXME - in engine call above
    if (o->engine_data)
-     o->engine_data = obj->layer->evas->engine.func->image_alpha_set(obj->layer->evas->engine.data.output,
-                                                                    o->engine_data,
-                                                                    o->cur->has_alpha);
+     o->engine_data = ENFN->image_alpha_set(ENDT, o->engine_data, o->cur->has_alpha);
 */
         EINA_COW_WRITE_BEGIN(evas_object_image_state_cow, o->prev, Evas_Object_Image_State, prev_write)
           EVAS_OBJECT_IMAGE_FREE_FILE_AND_KEY(cur_write, prev_write);
@@ -1078,18 +1056,18 @@ _evas_image_data_convert(Eo *eo_obj, Evas_Image_Data *o, Evas_Colorspace to_cspa
    if ((o->preloading) && (o->engine_data))
      {
         o->preloading = EINA_FALSE;
-        obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output, o->engine_data, eo_obj);
+        ENFN->image_data_preload_cancel(ENDT, o->engine_data, eo_obj);
      }
    if (!o->engine_data) return NULL;
    if (o->video_surface)
      o->pixels->video.update_pixels(o->pixels->video.data, eo_obj, &o->pixels->video);
    if (o->cur->cspace == to_cspace) return NULL;
    data = NULL;
-   o->engine_data = obj->layer->evas->engine.func->image_data_get(obj->layer->evas->engine.data.output, o->engine_data, 0, &data, &o->load_error);
+   o->engine_data = ENFN->image_data_get(ENDT, o->engine_data, 0, &data, &o->load_error);
    result = evas_object_image_data_convert_internal(o, data, to_cspace);
    if (o->engine_data)
      {
-        o->engine_data = obj->layer->evas->engine.func->image_data_put(obj->layer->evas->engine.data.output, o->engine_data, data);
+        o->engine_data = ENFN->image_data_put(ENDT, o->engine_data, data);
      }
 
    return result;
@@ -1111,39 +1089,31 @@ _evas_image_data_set(Eo *eo_obj, Evas_Image_Data *o, void *data)
      {
         if (o->engine_data)
           {
-             o->engine_data =
-               obj->layer->evas->engine.func->image_data_put(obj->layer->evas->engine.data.output,
-                                                             o->engine_data,
-                                                             data);
+             o->engine_data = ENFN->image_data_put(ENDT, o->engine_data, data);
           }
         else
           {
-             o->engine_data =
-                obj->layer->evas->engine.func->image_new_from_data(obj->layer->evas->engine.data.output,
-                                                                  o->cur->image.w,
-                                                                  o->cur->image.h,
-                                                                  data,
-                                                                  o->cur->has_alpha,
-                                                                  o->cur->cspace);
+             o->engine_data = ENFN->image_new_from_data(ENDT,
+                                                        o->cur->image.w,
+                                                        o->cur->image.h,
+                                                        data,
+                                                        o->cur->has_alpha,
+                                                        o->cur->cspace);
           }
         if (o->engine_data)
           {
              int stride = 0;
 
-             if (obj->layer->evas->engine.func->image_scale_hint_set)
-                obj->layer->evas->engine.func->image_scale_hint_set
-                (obj->layer->evas->engine.data.output,
-                    o->engine_data, o->scale_hint);
-             if (obj->layer->evas->engine.func->image_content_hint_set)
-                obj->layer->evas->engine.func->image_content_hint_set
-                (obj->layer->evas->engine.data.output,
-                    o->engine_data, o->content_hint);
-             if (obj->layer->evas->engine.func->image_stride_get)
-                obj->layer->evas->engine.func->image_stride_get
-                (obj->layer->evas->engine.data.output,
-                    o->engine_data, &stride);
+             if (ENFN->image_scale_hint_set)
+               ENFN->image_scale_hint_set(ENDT, o->engine_data, o->scale_hint);
+
+             if (ENFN->image_content_hint_set)
+               ENFN->image_content_hint_set(ENDT, o->engine_data, o->content_hint);
+
+             if (ENFN->image_stride_get)
+               ENFN->image_stride_get(ENDT, o->engine_data, &stride);
              else
-                stride = o->cur->image.w * 4;
+               stride = o->cur->image.w * 4;
 
              if (o->cur->image.stride != stride)
                {
@@ -1157,7 +1127,7 @@ _evas_image_data_set(Eo *eo_obj, Evas_Image_Data *o, void *data)
    else
      {
         if (o->engine_data)
-          obj->layer->evas->engine.func->image_free(obj->layer->evas->engine.data.output, o->engine_data);
+          ENFN->image_free(ENDT, o->engine_data);
         o->load_error = EVAS_LOAD_ERROR_NONE;
         if ((o->cur->image.w != 0) || (o->cur->image.h != 0))
           resize_call = EINA_TRUE;
@@ -1174,9 +1144,7 @@ _evas_image_data_set(Eo *eo_obj, Evas_Image_Data *o, void *data)
      }
 /* FIXME - in engine call above
    if (o->engine_data)
-     o->engine_data = obj->layer->evas->engine.func->image_alpha_set(obj->layer->evas->engine.data.output,
-                                                                    o->engine_data,
-                                                                    o->cur->has_alpha);
+     o->engine_data = ENFN->image_alpha_set(ENDT, o->engine_data, o->cur->has_alpha);
 */
    if (o->pixels_checked_out > 0) o->pixels_checked_out--;
    if (p_data != o->engine_data)
@@ -1200,15 +1168,11 @@ _evas_image_data_get(Eo *eo_obj, Evas_Image_Data *_pd EINA_UNUSED, Eina_Bool for
    if (for_writing) evas_render_rendering_wait(obj->layer->evas);
 
    data = NULL;
-   if (obj->layer->evas->engine.func->image_scale_hint_set)
-      obj->layer->evas->engine.func->image_scale_hint_set
-      (obj->layer->evas->engine.data.output,
-          o->engine_data, o->scale_hint);
-   if (obj->layer->evas->engine.func->image_content_hint_set)
-      obj->layer->evas->engine.func->image_content_hint_set
-      (obj->layer->evas->engine.data.output,
-          o->engine_data, o->content_hint);
-   o->engine_data = obj->layer->evas->engine.func->image_data_get(obj->layer->evas->engine.data.output, o->engine_data, for_writing, &data, &o->load_error);
+   if (ENFN->image_scale_hint_set)
+     ENFN->image_scale_hint_set(ENDT, o->engine_data, o->scale_hint);
+   if (ENFN->image_content_hint_set)
+     ENFN->image_content_hint_set(ENDT, o->engine_data, o->content_hint);
+   o->engine_data = ENFN->image_data_get(ENDT, o->engine_data, for_writing, &data, &o->load_error);
 
    /* if we fail to get engine_data, we have to return NULL */
    if (!o->engine_data) return NULL;
@@ -1217,12 +1181,10 @@ _evas_image_data_get(Eo *eo_obj, Evas_Image_Data *_pd EINA_UNUSED, Eina_Bool for
      {
         int stride = 0;
 
-        if (obj->layer->evas->engine.func->image_stride_get)
-           obj->layer->evas->engine.func->image_stride_get
-           (obj->layer->evas->engine.data.output,
-               o->engine_data, &stride);
+        if (ENFN->image_stride_get)
+          ENFN->image_stride_get(ENDT, o->engine_data, &stride);
         else
-           stride = o->cur->image.w * 4;
+          stride = o->cur->image.w * 4;
 
         if (o->cur->image.stride != stride)
           {
@@ -1272,9 +1234,7 @@ _image_preload_internal(Eo *eo_obj, void *_pd, Eina_Bool cancel)
         if (o->preloading)
           {
              o->preloading = EINA_FALSE;
-             obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output,
-                                                                      o->engine_data,
-                                                                      eo_obj);
+             ENFN->image_data_preload_cancel(ENDT, o->engine_data, eo_obj);
           }
      }
    else
@@ -1282,9 +1242,7 @@ _image_preload_internal(Eo *eo_obj, void *_pd, Eina_Bool cancel)
         if (!o->preloading)
           {
              o->preloading = EINA_TRUE;
-             obj->layer->evas->engine.func->image_data_preload_request(obj->layer->evas->engine.data.output,
-                                                                       o->engine_data,
-                                                                       eo_obj);
+             ENFN->image_data_preload_request(ENDT, o->engine_data, eo_obj);
           }
      }
 }
@@ -1311,37 +1269,27 @@ _evas_image_data_copy_set(Eo *eo_obj, Evas_Image_Data *o, void *data)
    if ((o->cur->image.w <= 0) ||
        (o->cur->image.h <= 0)) return;
    if (o->engine_data)
-     obj->layer->evas->engine.func->image_free(obj->layer->evas->engine.data.output,
-                                               o->engine_data);
-   o->engine_data =
-     obj->layer->evas->engine.func->image_new_from_copied_data(obj->layer->evas->engine.data.output,
-                                                               o->cur->image.w,
-                                                               o->cur->image.h,
-                                                               data,
-                                                               o->cur->has_alpha,
-                                                               o->cur->cspace);
+     ENFN->image_free(ENDT, o->engine_data);
+   o->engine_data = ENFN->image_new_from_copied_data(ENDT,
+                                                     o->cur->image.w,
+                                                     o->cur->image.h,
+                                                     data,
+                                                     o->cur->has_alpha,
+                                                     o->cur->cspace);
    if (o->engine_data)
      {
         int stride = 0;
 
         o->engine_data =
-          obj->layer->evas->engine.func->image_alpha_set(obj->layer->evas->engine.data.output,
-                                                         o->engine_data,
-                                                         o->cur->has_alpha);
-        if (obj->layer->evas->engine.func->image_scale_hint_set)
-           obj->layer->evas->engine.func->image_scale_hint_set
-           (obj->layer->evas->engine.data.output,
-               o->engine_data, o->scale_hint);
-        if (obj->layer->evas->engine.func->image_content_hint_set)
-           obj->layer->evas->engine.func->image_content_hint_set
-           (obj->layer->evas->engine.data.output,
-               o->engine_data, o->content_hint);
-        if (obj->layer->evas->engine.func->image_stride_get)
-           obj->layer->evas->engine.func->image_stride_get
-           (obj->layer->evas->engine.data.output,
-               o->engine_data, &stride);
+          ENFN->image_alpha_set(ENDT, o->engine_data, o->cur->has_alpha);
+        if (ENFN->image_scale_hint_set)
+          ENFN->image_scale_hint_set(ENDT, o->engine_data, o->scale_hint);
+        if (ENFN->image_content_hint_set)
+          ENFN->image_content_hint_set(ENDT, o->engine_data, o->content_hint);
+        if (ENFN->image_stride_get)
+          ENFN->image_stride_get(ENDT, o->engine_data, &stride);
         else
-           stride = o->cur->image.w * 4;
+          stride = o->cur->image.w * 4;
 
         if (o->cur->image.stride != stride)
           {
@@ -1404,9 +1352,7 @@ _evas_image_alpha_set(Eo *eo_obj, Evas_Image_Data *o, Eina_Bool has_alpha)
    if ((o->preloading) && (o->engine_data))
      {
         o->preloading = EINA_FALSE;
-        obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output,
-                                                                 o->engine_data,
-                                                                 eo_obj);
+        ENFN->image_data_preload_cancel(ENDT, o->engine_data, eo_obj);
      }
    if (((has_alpha) && (o->cur->has_alpha)) ||
        ((!has_alpha) && (!o->cur->has_alpha)))
@@ -1421,24 +1367,16 @@ _evas_image_alpha_set(Eo *eo_obj, Evas_Image_Data *o, Eina_Bool has_alpha)
      {
         int stride = 0;
 
-        o->engine_data =
-          obj->layer->evas->engine.func->image_alpha_set(obj->layer->evas->engine.data.output,
-                                                         o->engine_data,
-                                                         o->cur->has_alpha);
-        if (obj->layer->evas->engine.func->image_scale_hint_set)
-           obj->layer->evas->engine.func->image_scale_hint_set
-           (obj->layer->evas->engine.data.output,
-               o->engine_data, o->scale_hint);
-        if (obj->layer->evas->engine.func->image_content_hint_set)
-           obj->layer->evas->engine.func->image_content_hint_set
-           (obj->layer->evas->engine.data.output,
-               o->engine_data, o->content_hint);
-        if (obj->layer->evas->engine.func->image_stride_get)
-           obj->layer->evas->engine.func->image_stride_get
-           (obj->layer->evas->engine.data.output,
-               o->engine_data, &stride);
+        o->engine_data = ENFN->image_alpha_set(ENDT, o->engine_data, o->cur->has_alpha);
+        if (ENFN->image_scale_hint_set)
+          ENFN->image_scale_hint_set(ENDT, o->engine_data, o->scale_hint);
+        if (ENFN->image_content_hint_set)
+          ENFN->image_content_hint_set (ENDT, o->engine_data, o->content_hint);
+        if (ENFN->image_stride_get)
+          ENFN->image_stride_get(ENDT, o->engine_data, &stride);
         else
-           stride = o->cur->image.w * 4;
+          stride = o->cur->image.w * 4;
+
         if (o->cur->image.stride != stride)
           {
              EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write)
@@ -1488,14 +1426,12 @@ _evas_image_reload(Eo *eo_obj, Evas_Image_Data *o)
    if ((o->preloading) && (o->engine_data))
      {
         o->preloading = EINA_FALSE;
-        obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output,
-                                                                 o->engine_data,
-                                                                 eo_obj);
+        ENFN->image_data_preload_cancel(ENDT, o->engine_data, eo_obj);
      }
    if ((!o->cur->u.file) ||
        (o->pixels_checked_out > 0)) return;
    if (o->engine_data)
-     o->engine_data = obj->layer->evas->engine.func->image_dirty_region(obj->layer->evas->engine.data.output, o->engine_data, 0, 0, o->cur->image.w, o->cur->image.h);
+     o->engine_data = ENFN->image_dirty_region(ENDT, o->engine_data, 0, 0, o->cur->image.w, o->cur->image.h);
    o->written = EINA_FALSE;
    evas_object_image_unload(eo_obj, 1);
    evas_object_inform_call_image_unloaded(eo_obj);
@@ -1521,7 +1457,7 @@ _evas_image_efl_file_save(Eo *eo_obj, Evas_Image_Data *o, const char *file, cons
    RGBA_Image *im;
    if (!o->engine_data) return 0;
    Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
-   o->engine_data = obj->layer->evas->engine.func->image_data_get(obj->layer->evas->engine.data.output, o->engine_data, 0, &data, &o->load_error);
+   o->engine_data = ENFN->image_data_get(ENDT, o->engine_data, 0, &data, &o->load_error);
    if (flags)
      {
         char *p, *pp;
@@ -1565,9 +1501,7 @@ _evas_image_efl_file_save(Eo *eo_obj, Evas_Image_Data *o, const char *file, cons
 
         evas_cache_image_drop(&im->cache_entry);
      }
-   o->engine_data = obj->layer->evas->engine.func->image_data_put(obj->layer->evas->engine.data.output,
-                                                                  o->engine_data,
-                                                                  data);
+   o->engine_data = ENFN->image_data_put(ENDT, o->engine_data, data);
 
    free(encoding);
    return ok;
@@ -1591,23 +1525,19 @@ _evas_image_pixels_import(Eo *eo_obj, Evas_Image_Data *o, Evas_Pixel_Import_Sour
                  DATA32 *image_pixels = NULL;
 
                  o->engine_data =
-                   obj->layer->evas->engine.func->image_data_get(obj->layer->evas->engine.data.output,
-                                                                 o->engine_data,
-                                                                 1,
-                                                                 &image_pixels,
-                                                                  &o->load_error);
+                    ENFN->image_data_get(ENDT,
+                                         o->engine_data,
+                                         1,
+                                         &image_pixels,
+                                         &o->load_error);
 /* FIXME: need to actualyl support this */
 /*               memcpy(image_pixels, pixels->rows, o->cur->image.w * o->cur->image.h * 4);*/
                  if (o->engine_data)
                    o->engine_data =
-                   obj->layer->evas->engine.func->image_data_put(obj->layer->evas->engine.data.output,
-                                                                 o->engine_data,
-                                                                 image_pixels);
-                 if (o->engine_data)
+                    ENFN->image_data_put(ENDT, o->engine_data, image_pixels);
+                  if (o->engine_data)
                    o->engine_data =
-                   obj->layer->evas->engine.func->image_alpha_set(obj->layer->evas->engine.data.output,
-                                                                  o->engine_data,
-                                                                  o->cur->has_alpha);
+                    ENFN->image_alpha_set(ENDT, o->engine_data, o->cur->has_alpha);
                  o->changed = EINA_TRUE;
                  evas_object_change(eo_obj, obj);
               }
@@ -1620,16 +1550,13 @@ _evas_image_pixels_import(Eo *eo_obj, Evas_Image_Data *o, Evas_Pixel_Import_Sour
                {
                   DATA32 *image_pixels = NULL;
 
-                  o->engine_data =
-                     obj->layer->evas->engine.func->image_data_get(obj->layer->evas->engine.data.output, o->engine_data, 1, &image_pixels,&o->load_error);
+                  o->engine_data = ENFN->image_data_get(ENDT, o->engine_data, 1, &image_pixels,&o->load_error);
                   if (image_pixels)
                     evas_common_convert_yuv_420p_601_rgba((DATA8 **) pixels->rows, (DATA8 *) image_pixels, o->cur->image.w, o->cur->image.h);
                   if (o->engine_data)
-                    o->engine_data =
-                       obj->layer->evas->engine.func->image_data_put(obj->layer->evas->engine.data.output, o->engine_data, image_pixels);
+                    o->engine_data = ENFN->image_data_put(ENDT, o->engine_data, image_pixels);
                   if (o->engine_data)
-                    o->engine_data =
-                       obj->layer->evas->engine.func->image_alpha_set(obj->layer->evas->engine.data.output, o->engine_data, o->cur->has_alpha);
+                    o->engine_data = ENFN->image_alpha_set(ENDT, o->engine_data, o->cur->has_alpha);
                   o->changed = EINA_TRUE;
                   evas_object_change(eo_obj, obj);
                }
@@ -1815,7 +1742,7 @@ _evas_image_colorspace_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Colorspace cspac
    EINA_COW_IMAGE_STATE_WRITE_END(o, state_write);
 
    if (o->engine_data)
-     obj->layer->evas->engine.func->image_colorspace_set(obj->layer->evas->engine.data.output, o->engine_data, cspace);
+     ENFN->image_colorspace_set(ENDT, o->engine_data, cspace);
 }
 
 EOLIAN static Evas_Colorspace
@@ -1936,23 +1863,21 @@ _evas_image_native_surface_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Native_Surfa
    evas_render_rendering_wait(obj->layer->evas);
 
    _evas_object_image_cleanup(eo_obj, obj, o);
-   if (!obj->layer->evas->engine.func->image_native_set) return;
+   if (!ENFN->image_native_set) return;
    if ((surf) &&
        ((surf->version < 2) ||
         (surf->version > EVAS_NATIVE_SURFACE_VERSION))) return;
-   o->engine_data = obj->layer->evas->engine.func->image_native_set(obj->layer->evas->engine.data.output, o->engine_data, surf);
+   o->engine_data = ENFN->image_native_set(ENDT, o->engine_data, surf);
 }
 
 EOLIAN static Evas_Native_Surface*
 _evas_image_native_surface_get(Eo *eo_obj, Evas_Image_Data *o)
 {
-   Evas_Native_Surface *surf;
-
+   Evas_Native_Surface *surf = NULL;
    Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
 
-   surf =
-      (!obj->layer->evas->engine.func->image_native_get ? NULL :
-         obj->layer->evas->engine.func->image_native_get(obj->layer->evas->engine.data.output, o->engine_data));
+   if (ENFN->image_native_get)
+     surf = ENFN->image_native_get(ENDT, o->engine_data);
 
    return surf;
 }
@@ -1967,16 +1892,12 @@ _evas_image_scale_hint_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Image_Scale_Hint
      {
         int stride = 0;
 
-        if (obj->layer->evas->engine.func->image_scale_hint_set)
-          obj->layer->evas->engine.func->image_scale_hint_set
-             (obj->layer->evas->engine.data.output,
-               o->engine_data, o->scale_hint);
-        if (obj->layer->evas->engine.func->image_stride_get)
-           obj->layer->evas->engine.func->image_stride_get
-           (obj->layer->evas->engine.data.output,
-               o->engine_data, &stride);
+        if (ENFN->image_scale_hint_set)
+          ENFN->image_scale_hint_set(ENFN->image_native_get, o->engine_data, o->scale_hint);
+        if (ENFN->image_stride_get)
+          ENFN->image_stride_get(ENFN->image_native_get, o->engine_data, &stride);
         else
-           stride = o->cur->image.w * 4;
+          stride = o->cur->image.w * 4;
 
         if (o->cur->image.stride != stride)
           {
@@ -2003,16 +1924,12 @@ _evas_image_content_hint_set(Eo *eo_obj, Evas_Image_Data *o, Evas_Image_Content_
      {
         int stride = 0;
 
-        if (obj->layer->evas->engine.func->image_content_hint_set)
-           obj->layer->evas->engine.func->image_content_hint_set
-           (obj->layer->evas->engine.data.output,
-               o->engine_data, o->content_hint);
-        if (obj->layer->evas->engine.func->image_stride_get)
-           obj->layer->evas->engine.func->image_stride_get
-           (obj->layer->evas->engine.data.output,
-               o->engine_data, &stride);
+        if (ENFN->image_content_hint_set)
+          ENFN->image_content_hint_set(ENFN->image_native_get, o->engine_data, o->content_hint);
+        if (ENFN->image_stride_get)
+          ENFN->image_stride_get(ENDT, o->engine_data, &stride);
         else
-           stride = o->cur->image.w * 4;
+          stride = o->cur->image.w * 4;
 
         if (o->cur->image.stride != stride)
           {
@@ -2049,9 +1966,7 @@ _evas_image_region_support_get(Eo *eo_obj, Evas_Image_Data *o)
    Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
 
    Eina_Bool region;
-   region =  obj->layer->evas->engine.func->image_can_region_get(
-      obj->layer->evas->engine.data.output,
-      o->engine_data);
+   region = ENFN->image_can_region_get(ENDT, o->engine_data);
 
    return region;
 }
@@ -2064,8 +1979,8 @@ _evas_image_efl_image_animated_get(Eo *eo_obj, Evas_Image_Data *o)
    Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
 
    animated =
-      obj->layer->evas->engine.func->image_animated_get ?
-      obj->layer->evas->engine.func->image_animated_get(obj->layer->evas->engine.data.output, o->engine_data) :
+      ENFN->image_animated_get ?
+      ENFN->image_animated_get(ENDT, o->engine_data) :
       EINA_FALSE;
 
    return animated;
@@ -2080,8 +1995,8 @@ _evas_image_animated_frame_count_get(Eo *eo_obj, Evas_Image_Data *o)
    if (!evas_object_image_animated_get(eo_obj)) return frame_count;
    Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
 
-   if (obj->layer->evas->engine.func->image_animated_frame_count_get)
-     frame_count = obj->layer->evas->engine.func->image_animated_frame_count_get(obj->layer->evas->engine.data.output, o->engine_data);
+   if (ENFN->image_animated_frame_count_get)
+     frame_count = ENFN->image_animated_frame_count_get(ENDT, o->engine_data);
 
    return frame_count;
 }
@@ -2095,8 +2010,8 @@ _evas_image_animated_loop_type_get(Eo *eo_obj, Evas_Image_Data *o)
    hint = EVAS_IMAGE_ANIMATED_HINT_NONE;
    if (!evas_object_image_animated_get(eo_obj)) return hint;
 
-   if (obj->layer->evas->engine.func->image_animated_loop_type_get)
-      hint = obj->layer->evas->engine.func->image_animated_loop_type_get(obj->layer->evas->engine.data.output, o->engine_data);
+   if (ENFN->image_animated_loop_type_get)
+      hint = ENFN->image_animated_loop_type_get(ENDT, o->engine_data);
 
    return hint;
 }
@@ -2111,8 +2026,8 @@ _evas_image_animated_loop_count_get(Eo *eo_obj, Evas_Image_Data *o)
    if (!evas_object_image_animated_get(eo_obj)) return loop_count;
 
    loop_count =
-      obj->layer->evas->engine.func->image_animated_loop_count_get ?
-      obj->layer->evas->engine.func->image_animated_loop_count_get(obj->layer->evas->engine.data.output, o->engine_data) :
+      ENFN->image_animated_loop_count_get ?
+      ENFN->image_animated_loop_count_get(ENDT, o->engine_data) :
       -1;
 
    return loop_count;
@@ -2127,13 +2042,13 @@ _evas_image_animated_frame_duration_get(Eo *eo_obj, Evas_Image_Data *o, int star
    double frame_duration;
    frame_duration = -1;
 
-   if (!obj->layer->evas->engine.func->image_animated_frame_count_get) return frame_duration;
+   if (!ENFN->image_animated_frame_count_get) return frame_duration;
 
-   frame_count = obj->layer->evas->engine.func->image_animated_frame_count_get(obj->layer->evas->engine.data.output, o->engine_data);
+   frame_count = ENFN->image_animated_frame_count_get(ENDT, o->engine_data);
 
    if ((start_frame + frame_num) > frame_count) return frame_duration;
-   if (obj->layer->evas->engine.func->image_animated_frame_duration_get)
-     frame_duration = obj->layer->evas->engine.func->image_animated_frame_duration_get(obj->layer->evas->engine.data.output, o->engine_data, start_frame, frame_num);
+   if (ENFN->image_animated_frame_duration_get)
+     frame_duration = ENFN->image_animated_frame_duration_get(ENDT, o->engine_data, start_frame, frame_num);
 
    return frame_duration;
 }
@@ -2155,9 +2070,9 @@ _evas_image_animated_frame_set(Eo *eo_obj, Evas_Image_Data *o, int frame_index)
    if ((frame_count > FRAME_MAX) || (frame_count < 0) || (frame_index > frame_count))
      return;
 
-   if (!obj->layer->evas->engine.func->image_animated_frame_set) return;
-   obj->layer->evas->engine.func->image_animated_frame_set(obj->layer->evas->engine.data.output, o->engine_data, frame_index);
-//   if (!obj->layer->evas->engine.func->image_animated_frame_set(obj->layer->evas->engine.data.output, o->engine_data, frame_index)) return;
+   if (!ENFN->image_animated_frame_set) return;
+   ENFN->image_animated_frame_set(ENDT, o->engine_data, frame_index);
+//   if (!ENFN->image_animated_frame_set(ENDT, o->engine_data, frame_index)) return;
 
    EINA_COW_WRITE_BEGIN(evas_object_image_state_cow, o->prev, Evas_Object_Image_State, prev_write)
      prev_write->frame = o->cur->frame;
@@ -2621,23 +2536,18 @@ evas_object_image_unload(Evas_Object *eo_obj, Eina_Bool dirty)
    if (dirty)
      {
         if (o->engine_data)
-           o->engine_data = obj->layer->evas->engine.func->image_dirty_region
-           (obj->layer->evas->engine.data.output,
-               o->engine_data,
-               0, 0,
-               o->cur->image.w, o->cur->image.h);
+           o->engine_data = ENFN->image_dirty_region(ENDT, o->engine_data,
+                                                     0, 0,
+                                                     o->cur->image.w, o->cur->image.h);
      }
    if (o->engine_data)
      {
         if (o->preloading)
           {
              o->preloading = EINA_FALSE;
-             obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output,
-                                                                      o->engine_data,
-                                                                      eo_obj);
+             ENFN->image_data_preload_cancel(ENDT, o->engine_data, eo_obj);
           }
-        obj->layer->evas->engine.func->image_free(obj->layer->evas->engine.data.output,
-                                                  o->engine_data);
+        ENFN->image_free(ENDT, o->engine_data);
      }
    o->engine_data = NULL;
    o->load_error = EVAS_LOAD_ERROR_NONE;
@@ -2681,15 +2591,15 @@ evas_object_image_load(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Eva
    lo.orientation = o->load_opts->orientation;
    lo.degree = 0;
    if (o->cur->mmaped_source)
-     o->engine_data = obj->layer->evas->engine.func->image_mmap
-       (obj->layer->evas->engine.data.output,
+     o->engine_data = ENFN->image_mmap
+       (ENDT,
         o->cur->u.f,
         o->cur->key,
         &o->load_error,
         &lo);
    else
-     o->engine_data = obj->layer->evas->engine.func->image_load
-       (obj->layer->evas->engine.data.output,
+     o->engine_data = ENFN->image_load
+       (ENDT,
         o->cur->u.file,
         o->cur->key,
         &o->load_error,
@@ -2701,24 +2611,16 @@ evas_object_image_load(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, Eva
         int stride = 0;
         Eina_Bool resize_call = EINA_FALSE;
 
-        obj->layer->evas->engine.func->image_size_get
-           (obj->layer->evas->engine.data.output,
-            o->engine_data, &w, &h);
-        if (obj->layer->evas->engine.func->image_stride_get)
-          obj->layer->evas->engine.func->image_stride_get
-             (obj->layer->evas->engine.data.output,
-              o->engine_data, &stride);
+        ENFN->image_size_get(ENDT, o->engine_data, &w, &h);
+        if (ENFN->image_stride_get)
+          ENFN->image_stride_get(ENDT, o->engine_data, &stride);
         else
           stride = w * 4;
 
         EINA_COW_IMAGE_STATE_WRITE_BEGIN(o, state_write)
           {
-             state_write->has_alpha = obj->layer->evas->engine.func->image_alpha_get
-               (obj->layer->evas->engine.data.output,
-                o->engine_data);
-             state_write->cspace = obj->layer->evas->engine.func->image_colorspace_get
-               (obj->layer->evas->engine.data.output,
-                o->engine_data);
+             state_write->has_alpha = ENFN->image_alpha_get(ENDT, o->engine_data);
+             state_write->cspace = ENFN->image_colorspace_get(ENDT, o->engine_data);
              if ((state_write->image.w != w) || (state_write->image.h != h))
                resize_call = EINA_TRUE;
              state_write->image.w = w;
@@ -2839,12 +2741,9 @@ evas_object_image_free(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj)
           if (o->preloading)
             {
               o->preloading = EINA_FALSE;
-              obj->layer->evas->engine.func->image_data_preload_cancel(obj->layer->evas->engine.data.output,
-                                                                       o->engine_data,
-                                                                       eo_obj);
+               ENFN->image_data_preload_cancel(ENDT, o->engine_data, eo_obj);
             }
-          obj->layer->evas->engine.func->image_free(obj->layer->evas->engine.data.output,
-                                                    o->engine_data);
+           ENFN->image_free(ENDT, o->engine_data);
         }
        if (o->video_surface)
         {
@@ -2873,11 +2772,11 @@ _draw_image(Evas_Object_Protected_Data *obj,
 {
    Eina_Bool async_unref;
 
-   async_unref = obj->layer->evas->engine.func->image_draw(data, context, surface,
-                                                           image, src_x, src_y,
-                                                           src_w, src_h, dst_x,
-                                                           dst_y, dst_w, dst_h,
-                                                           smooth, do_async);
+   async_unref = ENFN->image_draw(data, context, surface,
+                                  image, src_x, src_y,
+                                  src_w, src_h, dst_x,
+                                  dst_y, dst_w, dst_h,
+                                  smooth, do_async);
    if (do_async && async_unref)
      {
 #ifdef EVAS_CSERVE2
@@ -2899,10 +2798,10 @@ evas_draw_image_map_async_check(Evas_Object_Protected_Data *obj,
 {
    Eina_Bool async_unref;
 
-   async_unref = obj->layer->evas->engine.func->image_map_draw(data, context,
-                                                               surface, image, m,
-                                                               smooth, level,
-                                                               do_async);
+   async_unref = ENFN->image_map_draw(data, context,
+                                      surface, image, m,
+                                      smooth, level,
+                                      do_async);
    if (do_async && async_unref)
      {
 #ifdef EVAS_CSERVE2
@@ -2929,18 +2828,18 @@ evas_process_dirty_pixels(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj,
           {
              Evas_Coord x, y, w, h;
 
-             if (obj->layer->evas->engine.func->image_native_get)
+             if (ENFN->image_native_get)
                {
                   Evas_Native_Surface *ns;
-                  ns = obj->layer->evas->engine.func->image_native_get(obj->layer->evas->engine.data.output, o->engine_data);
+                  ns = ENFN->image_native_get(ENDT, o->engine_data);
                   if ( (ns) &&
                        (ns->type == EVAS_NATIVE_SURFACE_OPENGL) &&
                        (ns->data.opengl.texture_id) &&
                        (!ns->data.opengl.framebuffer_id) )
                     {
                        // Check if we can do direct rendering...
-                       if (obj->layer->evas->engine.func->gl_direct_override_get)
-                         obj->layer->evas->engine.func->gl_direct_override_get(output, &direct_override, &direct_force_off);
+                       if (ENFN->gl_direct_override_get)
+                         ENFN->gl_direct_override_get(output, &direct_override, &direct_force_off);
                        if ( (((obj->cur->geometry.w == o->cur->image.w) &&
                               (obj->cur->geometry.h == o->cur->image.h) &&
                               (obj->cur->color.r == 255) &&
@@ -2952,9 +2851,9 @@ evas_process_dirty_pixels(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj,
                             (!direct_force_off) )
                          {
 
-                            if (obj->layer->evas->engine.func->gl_get_pixels_set)
+                            if (ENFN->gl_get_pixels_set)
                               {
-                                 obj->layer->evas->engine.func->gl_get_pixels_set(output, o->pixels->func.get_pixels, o->pixels->func.get_pixels_data, eo_obj);
+                                 ENFN->gl_get_pixels_set(output, o->pixels->func.get_pixels, o->pixels->func.get_pixels_data, eo_obj);
                               }
 
                             o->direct_render = EINA_TRUE;
@@ -2967,8 +2866,8 @@ evas_process_dirty_pixels(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj,
                   if ( (ns) &&
                        (ns->type == EVAS_NATIVE_SURFACE_X11))
                     {
-                       if (obj->layer->evas->engine.func->context_flush)
-                         obj->layer->evas->engine.func->context_flush(output);
+                       if (ENFN->context_flush)
+                         ENFN->context_flush(output);
                     }
                }
 
@@ -2986,8 +2885,8 @@ evas_process_dirty_pixels(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj,
                    obj->cur->geometry.h == h))
                CRI("Evas_Image_Data geometry did change during pixels get callback !");
 
-             o->engine_data = obj->layer->evas->engine.func->image_dirty_region
-               (obj->layer->evas->engine.data.output, o->engine_data,
+             o->engine_data = ENFN->image_dirty_region
+               (ENDT, o->engine_data,
                 0, 0, o->cur->image.w, o->cur->image.h);
             if (o->engine_data != pixels)
               pixels = o->engine_data;
@@ -2999,7 +2898,7 @@ evas_process_dirty_pixels(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj,
         // Check if the it's not dirty but it has direct rendering
         if (o->direct_render)
           {
-             obj->layer->evas->engine.func->gl_get_pixels_set(output, o->pixels->func.get_pixels, o->pixels->func.get_pixels_data, eo_obj);
+             ENFN->gl_get_pixels_set(output, o->pixels->func.get_pixels, o->pixels->func.get_pixels_data, eo_obj);
           }
      }
 
@@ -3059,52 +2958,39 @@ evas_object_image_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, v
    if (o->video_visible)
      {
         /* Create a transparent rectangle */
-        obj->layer->evas->engine.func->context_color_set(output,
-                                                         context,
-                                                         0, 0, 0, 0);
-        obj->layer->evas->engine.func->context_multiplier_unset(output,
-                                                                context);
-        obj->layer->evas->engine.func->context_render_op_set(output, context,
-                                                             EVAS_RENDER_COPY);
-        obj->layer->evas->engine.func->rectangle_draw(output,
-                                                      context,
-                                                      surface,
-                                                      obj->cur->geometry.x + x,
-                                                      obj->cur->geometry.y + y,
-                                                      obj->cur->geometry.w,
-                                                      obj->cur->geometry.h,
-                                                      do_async);
+        ENFN->context_color_set(output, context, 0, 0, 0, 0);
+        ENFN->context_multiplier_unset(output, context);
+        ENFN->context_render_op_set(output, context, EVAS_RENDER_COPY);
+        ENFN->rectangle_draw(output, context, surface,
+                             obj->cur->geometry.x + x, obj->cur->geometry.y + y,
+                             obj->cur->geometry.w, obj->cur->geometry.h,
+                             do_async);
 
         return;
      }
 
-   obj->layer->evas->engine.func->context_color_set(output,
-                                                    context,
-                                                    255, 255, 255, 255);
+   ENFN->context_color_set(output, context, 255, 255, 255, 255);
 
    if ((obj->cur->cache.clip.r == 255) &&
        (obj->cur->cache.clip.g == 255) &&
        (obj->cur->cache.clip.b == 255) &&
        (obj->cur->cache.clip.a == 255))
      {
-        obj->layer->evas->engine.func->context_multiplier_unset(output,
-                                                                context);
+        ENFN->context_multiplier_unset(output, context);
      }
    else
-     obj->layer->evas->engine.func->context_multiplier_set(output,
-                                                           context,
-                                                           obj->cur->cache.clip.r,
-                                                           obj->cur->cache.clip.g,
-                                                           obj->cur->cache.clip.b,
-                                                           obj->cur->cache.clip.a);
+     ENFN->context_multiplier_set(output, context,
+                                  obj->cur->cache.clip.r,
+                                  obj->cur->cache.clip.g,
+                                  obj->cur->cache.clip.b,
+                                  obj->cur->cache.clip.a);
 
-   obj->layer->evas->engine.func->context_render_op_set(output, context,
-                                                        obj->cur->render_op);
+   ENFN->context_render_op_set(output, context, obj->cur->render_op);
 
    // Clear out the pixel get stuff..
-   if (obj->layer->evas->engine.func->gl_get_pixels_set)
+   if (ENFN->gl_get_pixels_set)
      {
-        obj->layer->evas->engine.func->gl_get_pixels_set(output, NULL, NULL, NULL);
+        ENFN->gl_get_pixels_set(output, NULL, NULL, NULL);
      }
 
    Evas_Object_Protected_Data *source =
@@ -3186,15 +3072,13 @@ evas_object_image_render(Evas_Object *eo_obj, Evas_Object_Protected_Data *obj, v
              int W, H, offx, offy;
 
 start_draw:
-             obj->layer->evas->engine.func->image_scale_hint_set(output,
-                                                                 pixels,
-                                                                 o->scale_hint);
+             ENFN->image_scale_hint_set(output, pixels, o->scale_hint);
              /* This is technically a bug here: If the value is recreated
               * (which is returned)it may be a new object, however exactly 0
               * of all the evas engines do this. */
-             obj->layer->evas->engine.func->image_border_set(output, pixels,
-                                                             o->cur->border.l, o->cur->border.r,
-                                                             o->cur->border.t, o->cur->border.b);
+             ENFN->image_border_set(output, pixels,
+                                    o->cur->border.l, o->cur->border.r,
+                                    o->cur->border.t, o->cur->border.b);
              idx = evas_object_image_figure_x_fill(eo_obj, obj, o->cur->fill.x, o->cur->fill.w, &idw);
              idy = evas_object_image_figure_y_fill(eo_obj, obj, o->cur->fill.y, o->cur->fill.h, &idh);
              if (idw < 1) idw = 1;
@@ -3256,7 +3140,7 @@ start_draw:
                        if (!redraw)
                          {
                             // Render this image only
-                            obj->layer->evas->engine.func->image_draw(output, context,
+                            ENFN->image_draw(output, context,
                                              surface, o->cur->filter->output,
                                              0, 0, W, H,
                                              offx, offy, W, H,
@@ -3282,10 +3166,10 @@ start_draw:
                   ok = evas_filter_context_buffers_allocate_all(filter, W, H);
                   if (!ok) goto state_write;
 
-                  if (obj->layer->evas->engine.func->gl_surface_read_pixels)
+                  if (ENFN->gl_surface_read_pixels)
                     {
                        // GL case: Create new surface, draw to it (OpenGL) and call glReadPixels
-                       surface = obj->layer->evas->engine.func->image_map_surface_new(output, W, H, EINA_TRUE);
+                       surface = ENFN->image_map_surface_new(output, W, H, EINA_TRUE);
                        input_stolen = EINA_FALSE;
                     }
                   else
@@ -3306,7 +3190,7 @@ state_write:
                     {
                        if (ok)
                          {
-                            context = obj->layer->evas->engine.func->context_new(output);
+                            context = ENFN->context_new(output);
                             clear = EINA_TRUE;
                             EINA_COW_IMAGE_FILTER_WRITE_BEGIN(state_write, fcow)
                               fcow->chain = pgm;
@@ -3339,11 +3223,11 @@ state_write:
 
                     if (clear)
                       {
-                         obj->layer->evas->engine.func->context_color_set(output, context, 0, 0, 0, 0);
-                         obj->layer->evas->engine.func->context_render_op_set(output, context, EVAS_RENDER_COPY);
-                         obj->layer->evas->engine.func->rectangle_draw(output, context, surface, 0, 0, W, H, EINA_FALSE);
-                         obj->layer->evas->engine.func->context_color_set(output, context, 255, 255, 255, 255);
-                         obj->layer->evas->engine.func->context_render_op_set(output, context, EVAS_RENDER_BLEND);
+                         ENFN->context_color_set(output, context, 0, 0, 0, 0);
+                         ENFN->context_render_op_set(output, context, EVAS_RENDER_COPY);
+                         ENFN->rectangle_draw(output, context, surface, 0, 0, W, H, EINA_FALSE);
+                         ENFN->context_color_set(output, context, 255, 255, 255, 255);
+                         ENFN->context_render_op_set(output, context, EVAS_RENDER_BLEND);
                       }
                }
 
@@ -3523,11 +3407,9 @@ state_write:
                                      (obj->cur->cache.clip.a == 255) &&
                                      (obj->cur->render_op == EVAS_RENDER_BLEND))
                                    {
-                                      obj->layer->evas->engine.func->context_render_op_set(output, context,
-                                                                                           EVAS_RENDER_COPY);
+                                      ENFN->context_render_op_set(output, context, EVAS_RENDER_COPY);
                                       _draw_image(obj, output, context, surface, pixels, inx, iny, inw, inh, outx, outy, outw, outh, o->cur->smooth_scale, do_async);
-                                      obj->layer->evas->engine.func->context_render_op_set(output, context,
-                                                                                           obj->cur->render_op);
+                                      ENFN->context_render_op_set(output, context, obj->cur->render_op);
                                    }
                                  else
                                    _draw_image(obj, output, context, surface, pixels, inx, iny, inw, inh, outx, outy, outw, outh, o->cur->smooth_scale, do_async);
@@ -3599,8 +3481,8 @@ state_write:
                         ok = evas_filter_run(filter);
 
                         if (!input_stolen)
-                          obj->layer->evas->engine.func->image_map_surface_free(output, surface);
-                        obj->layer->evas->engine.func->context_free(output, context);
+                          ENFN->image_map_surface_free(output, surface);
+                        ENFN->context_free(output, context);
 
                         if (!ok)
                           {
@@ -4177,7 +4059,7 @@ evas_object_image_is_inside(Evas_Object *eo_obj,
    Evas_Image_Data *o = type_private_data;
    int imagew, imageh, uvw, uvh;
    void *pixels;
-   Evas_Func *eng = obj->layer->evas->engine.func;
+   Evas_Func *eng = ENFN;
    int is_inside = 0;
 
    /* the following code is similar to evas_object_image_render(), but doesn't
@@ -4266,8 +4148,7 @@ evas_object_image_is_inside(Evas_Object *eo_obj,
              DATA32 *data = NULL;
              int err = 0;
 
-             im = obj->layer->evas->engine.func->image_data_get
-               (obj->layer->evas->engine.data.output, pixels, 0, &data, &err);
+             im = ENFN->image_data_get(ENDT, pixels, 0, &data, &err);
              if ((!im) || (!data) || (err))
                {
                   ERR("Couldn't get image pixels %p: im=%p, data=%p, err=%d",
@@ -4682,9 +4563,8 @@ _evas_object_image_preloading_check(Evas_Object *eo_obj)
 {
    Evas_Object_Protected_Data *obj = eo_data_scope_get(eo_obj, EVAS_OBJECT_CLASS);
    Evas_Image_Data *o = eo_data_scope_get(eo_obj, MY_CLASS);
-   if (obj->layer->evas->engine.func->image_load_error_get)
-      o->load_error = obj->layer->evas->engine.func->image_load_error_get
-      (obj->layer->evas->engine.data.output, o->engine_data);
+   if (ENFN->image_load_error_get)
+      o->load_error = ENFN->image_load_error_get(ENDT, o->engine_data);
 }
 
 Evas_Object *