evas vg: code refactoring.

make code clean and neat, no logic changes.

use macro to reduce lines.
rename ambiguous internal variables.
remove unused variables.

Change-Id: I87da2c10689d6f8e28d8a3b94d899090134e4dfe

diff --git a/src/lib/evas/canvas/efl_canvas_vg_gradient.c b/src/lib/evas/canvas/efl_canvas_vg_gradient.c
index 888c478..313753e 100644 (file)
--- a/src/lib/evas/canvas/efl_canvas_vg_gradient.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_gradient.c
@@ -39,9 +39,9 @@ _efl_canvas_vg_gradient_efl_gfx_gradient_stop_get(const Eo *obj EINA_UNUSED,
 static void
 _efl_canvas_vg_gradient_efl_gfx_gradient_spread_set(Eo *obj EINA_UNUSED,
                                                   Efl_Canvas_Vg_Gradient_Data *pd,
-                                                  Efl_Gfx_Gradient_Spread s)
+                                                  Efl_Gfx_Gradient_Spread spread)
 {
-   pd->s = s;
+   pd->spread = spread;
 
    _efl_canvas_vg_node_changed(obj);
 }
@@ -50,7 +50,7 @@ static Efl_Gfx_Gradient_Spread
 _efl_canvas_vg_gradient_efl_gfx_gradient_spread_get(const Eo *obj EINA_UNUSED,
                                                   Efl_Canvas_Vg_Gradient_Data *pd)
 {
-   return pd->s;
+   return pd->spread;
 }
 
 static Eina_Bool
@@ -113,7 +113,7 @@ _efl_canvas_vg_gradient_efl_duplicate_duplicate(const Eo *obj, Efl_Canvas_Vg_Gra
 
    cn = efl_duplicate(efl_super(obj, MY_CLASS));
    efl_gfx_gradient_stop_set(cn, pd->colors, pd->colors_count);
-   efl_gfx_gradient_spread_set(cn, pd->s);
+   efl_gfx_gradient_spread_set(cn, pd->spread);
    return cn;
 }
 

diff --git a/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c b/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c
index f56d6ff..fa35d29 100644 (file)
--- a/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_gradient_linear.c
@@ -87,7 +87,7 @@ _efl_canvas_vg_gradient_linear_render_pre(Evas_Object_Protected_Data *vg_pd EINA
    ector_renderer_color_set(nd->renderer, nd->r, nd->g, nd->b, nd->a);
    ector_renderer_visibility_set(nd->renderer, nd->visibility);
    efl_gfx_gradient_stop_set(nd->renderer, gd->colors, gd->colors_count);
-   efl_gfx_gradient_spread_set(nd->renderer, gd->s);
+   efl_gfx_gradient_spread_set(nd->renderer, gd->spread);
    efl_gfx_gradient_linear_start_set(nd->renderer, pd->start.x, pd->start.y);
    efl_gfx_gradient_linear_end_set(nd->renderer, pd->end.x, pd->end.y);
    ector_renderer_prepare(nd->renderer);

diff --git a/src/lib/evas/canvas/efl_canvas_vg_gradient_radial.c b/src/lib/evas/canvas/efl_canvas_vg_gradient_radial.c
index 9760c63..9ff537e 100644 (file)
--- a/src/lib/evas/canvas/efl_canvas_vg_gradient_radial.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_gradient_radial.c
@@ -103,7 +103,7 @@ _efl_canvas_vg_gradient_radial_render_pre(Evas_Object_Protected_Data *vg_pd EINA
    ector_renderer_color_set(nd->renderer, nd->r, nd->g, nd->b, nd->a);
    ector_renderer_visibility_set(nd->renderer, nd->visibility);
    efl_gfx_gradient_stop_set(nd->renderer, gd->colors, gd->colors_count);
-   efl_gfx_gradient_spread_set(nd->renderer, gd->s);
+   efl_gfx_gradient_spread_set(nd->renderer, gd->spread);
    efl_gfx_gradient_radial_center_set(nd->renderer, pd->center.x, pd->center.y);
    efl_gfx_gradient_radial_focal_set(nd->renderer, pd->focal.x, pd->focal.y);
    efl_gfx_gradient_radial_radius_set(nd->renderer, pd->radius);

diff --git a/src/lib/evas/canvas/efl_canvas_vg_object.c b/src/lib/evas/canvas/efl_canvas_vg_object.c
index 6b2e1a8..956b633 100644 (file)
--- a/src/lib/evas/canvas/efl_canvas_vg_object.c
+++ b/src/lib/evas/canvas/efl_canvas_vg_object.c
@@ -139,12 +139,14 @@ _efl_canvas_vg_object_root_node_get(const Eo *obj, Efl_Canvas_Vg_Object_Data *pd
 }
 
 EOLIAN static void
-_efl_canvas_vg_object_root_node_set(Eo *obj, Efl_Canvas_Vg_Object_Data *pd, Efl_VG *root_node)
+_efl_canvas_vg_object_root_node_set(Eo *eo_obj, Efl_Canvas_Vg_Object_Data *pd, Efl_VG *root_node)
 {
    // if the same root is already set
    if (pd->user_entry && pd->user_entry->root == root_node)
      return;
 
+   Evas_Object_Protected_Data *obj = efl_data_scope_get(eo_obj, EFL_CANVAS_OBJECT_CLASS);
+
    // check if a file has been already set
    if (pd->vg_entry)
      {
@@ -167,28 +169,25 @@ _efl_canvas_vg_object_root_node_set(Eo *obj, Efl_Canvas_Vg_Object_Data *pd, Efl_
                   return;
                }
           }
-
         pd->user_entry->w = pd->user_entry->h = 0;
         pd->user_entry->root = root_node;
 
         // set the parent so that vg canvas can render it.
         efl_parent_set(pd->user_entry->root, pd->root);
 
-        efl_canvas_vg_node_root_set(root_node, obj);
+        efl_canvas_vg_node_root_set(root_node, eo_obj);
      }
    else if (pd->user_entry)
      {
         // drop any surface cache attached to it.
-        Evas_Object_Protected_Data *eobj = efl_data_scope_get(obj, EFL_CANVAS_OBJECT_CLASS);
-        eobj->layer->evas->engine.func->ector_surface_cache_drop(_evas_engine_context(eobj->layer->evas),
-                                                                 pd->user_entry->root);
+        ENFN->ector_surface_cache_drop(_evas_engine_context(obj->layer->evas), pd->user_entry->root);
         free(pd->user_entry);
         pd->user_entry = NULL;
      }
 
    // force a redraw
    pd->changed = EINA_TRUE;
-   evas_object_change(obj, efl_data_scope_get(obj, EFL_CANVAS_OBJECT_CLASS));
+   evas_object_change(eo_obj, obj);
 }
 
 EOLIAN static void
@@ -562,9 +561,7 @@ _render_to_buffer(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Object_Data *pd
    //create a buffer
    if (!buffer)
      {
-        buffer = obj->layer->evas->engine.func->ector_surface_create(engine,
-                                                                     w, h,
-                                                                     &error);
+        buffer = ENFN->ector_surface_create(engine, w, h, &error);
         if (error) return NULL;
         buffer_created = EINA_TRUE;
      }
@@ -591,7 +588,7 @@ _render_to_buffer(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Object_Data *pd
 
    //caching buffer only for first and last frames.
    if (buffer_created && cacheable)
-     obj->layer->evas->engine.func->ector_surface_cache_set(engine, key, buffer);
+     ENFN->ector_surface_cache_set(engine, key, buffer);
 
    return buffer;
 }
@@ -606,7 +603,7 @@ _render_buffer_to_screen(Evas_Object_Protected_Data *obj,
    Eina_Bool async_unref;
 
    //Draw the buffer as image to canvas
-   async_unref = obj->layer->evas->engine.func->image_draw(engine, output, context, surface,
+   async_unref = ENFN->image_draw(engine, output, context, surface,
                                                            buffer,
                                                            0, 0, w, h,
                                                            x, y, w, h,
@@ -619,8 +616,7 @@ _render_buffer_to_screen(Evas_Object_Protected_Data *obj,
      }
 
    //TODO: Reuse buffer if size is same?
-   if (!cacheable)
-     obj->layer->evas->engine.func->ector_surface_destroy(engine, buffer);
+   if (!cacheable) ENFN->ector_surface_destroy(engine, buffer);
 }
 
 static void
@@ -645,14 +641,14 @@ _cache_vg_entry_render(Evas_Object_Protected_Data *obj,
    root = evas_cache_vg_tree_get(vg_entry, pd->frame_index);
    if (!root) return;
 
-   void *buffer = obj->layer->evas->engine.func->ector_surface_cache_get(engine, root);
+   void *buffer = ENFN->ector_surface_cache_get(engine, root);
 
    if (!buffer)
      buffer = _render_to_buffer(obj, pd, engine, root, w, h, root, NULL,
                                 do_async, cacheable);
    else
      //cache reference was increased when we get the cache.
-     obj->layer->evas->engine.func->ector_surface_cache_drop(engine, root);
+     ENFN->ector_surface_cache_drop(engine, root);
 
    _render_buffer_to_screen(obj,
                             engine, output, context, surface,
@@ -674,13 +670,13 @@ _user_vg_entry_render(Evas_Object_Protected_Data *obj,
    if ((user_entry->w != w ) ||
        (user_entry->h != h))
      {
-         obj->layer->evas->engine.func->ector_surface_cache_drop(engine, user_entry->root);
+         ENFN->ector_surface_cache_drop(engine, user_entry->root);
          user_entry->w = w;
          user_entry->h = h;
      }
 
    //if the buffer is not created yet
-   void *buffer = obj->layer->evas->engine.func->ector_surface_cache_get(engine, user_entry->root);
+   void *buffer = ENFN->ector_surface_cache_get(engine, user_entry->root);
 
    if (!buffer)
      {
@@ -700,7 +696,7 @@ _user_vg_entry_render(Evas_Object_Protected_Data *obj,
                                      buffer,
                                      do_async, EINA_FALSE);
         //cache reference was increased when we get the cache.
-        obj->layer->evas->engine.func->ector_surface_cache_drop(engine, user_entry->root);
+        ENFN->ector_surface_cache_drop(engine, user_entry->root);
      }
 
    _render_buffer_to_screen(obj,
@@ -720,18 +716,14 @@ _efl_canvas_vg_object_render(Evas_Object *eo_obj EINA_UNUSED,
    Efl_Canvas_Vg_Object_Data *pd = type_private_data;
 
    /* render object to surface with context, and offxet by x,y */
-   obj->layer->evas->engine.func->context_color_set(engine, context,
-                                                    255, 255, 255, 255);
-   obj->layer->evas->engine.func->context_multiplier_set(engine,
-                                                         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_anti_alias_set(engine, context,
-                                                         obj->cur->anti_alias);
-   obj->layer->evas->engine.func->context_render_op_set(engine, context,
-                                                        obj->cur->render_op);
+   ENFN->context_color_set(engine, context, 255, 255, 255, 255);
+   ENFN->context_multiplier_set(engine, context,
+                                obj->cur->cache.clip.r,
+                                obj->cur->cache.clip.g,
+                                obj->cur->cache.clip.b,
+                                obj->cur->cache.clip.a);
+   ENFN->context_anti_alias_set(engine, context, obj->cur->anti_alias);
+   ENFN->context_render_op_set(engine, context, obj->cur->render_op);
 
    //Cache surface?
    Eina_Bool cacheable = EINA_FALSE;

diff --git a/src/lib/evas/canvas/evas_vg_private.h b/src/lib/evas/canvas/evas_vg_private.h
index 3899e74..6d40214 100644 (file)
--- a/src/lib/evas/canvas/evas_vg_private.h
+++ b/src/lib/evas/canvas/evas_vg_private.h
@@ -40,7 +40,6 @@ typedef struct _Vg_User_Entry
 
 struct _Efl_Canvas_Vg_Object_Data
 {
-   void                      *engine_data;
    Efl_VG                    *root;
    Vg_Cache_Entry            *vg_entry;
    Vg_User_Entry             *user_entry; //holds the user set vg tree
@@ -107,7 +106,7 @@ struct _Efl_Canvas_Vg_Gradient_Data
    Efl_Gfx_Gradient_Stop *colors;
    unsigned int colors_count;
 
-   Efl_Gfx_Gradient_Spread s;
+   Efl_Gfx_Gradient_Spread spread;
 };
 
 struct _Efl_Canvas_Vg_Interpolation