Efl vg: Remove the no longer needed .Base hack.

diff --git a/src/Makefile_Evas.am b/src/Makefile_Evas.am
index f9b6dda..d3efc57 100644 (file)
--- a/src/Makefile_Evas.am
+++ b/src/Makefile_Evas.am
@@ -26,7 +26,7 @@ evas_eolian_pub_files = \
        lib/evas/canvas/evas_canvas3d_scene.eo\
        lib/evas/canvas/evas_canvas3d_object.eo \
        lib/evas/canvas/evas_vg.eo \
-       lib/evas/canvas/efl_vg_base.eo \
+       lib/evas/canvas/efl_vg.eo \
        lib/evas/canvas/efl_vg_container.eo \
        lib/evas/canvas/efl_vg_shape.eo \
        lib/evas/canvas/efl_vg_root_node.eo \

diff --git a/src/lib/evas/Evas_Eo.h b/src/lib/evas/Evas_Eo.h
index 76c5264..948a07d 100644 (file)
--- a/src/lib/evas/Evas_Eo.h
+++ b/src/lib/evas/Evas_Eo.h
@@ -293,7 +293,7 @@ typedef void (Evas_Canvas3D_Surface_Func)(Evas_Real *out_x,
  * @}
  */
 
-#include "canvas/efl_vg_base.eo.h"
+#include "canvas/efl_vg.eo.h"
 #include "canvas/efl_vg_container.eo.h"
 #include "canvas/efl_vg_shape.eo.h"
 #include "canvas/efl_vg_gradient.eo.h"

diff --git a/src/lib/evas/Evas_Legacy.h b/src/lib/evas/Evas_Legacy.h
index 15b74a0..24297eb 100644 (file)
--- a/src/lib/evas/Evas_Legacy.h
+++ b/src/lib/evas/Evas_Legacy.h
@@ -1905,7 +1905,7 @@ EAPI void evas_vg_node_raise(Eo *obj);
  */
 EAPI void evas_vg_node_lower(Eo *obj);
 
-#include "canvas/efl_vg_base.eo.legacy.h"
+#include "canvas/efl_vg.eo.legacy.h"
 
 /**
  *

diff --git a/src/lib/evas/canvas/efl_vg_base.eo b/src/lib/evas/canvas/efl_vg.eo
similarity index 93%
rename from src/lib/evas/canvas/efl_vg_base.eo
rename to src/lib/evas/canvas/efl_vg.eo
index 85c0e2b..48d0e66 100644 (file)
--- a/src/lib/evas/canvas/efl_vg_base.eo
+++ b/src/lib/evas/canvas/efl_vg.eo
@@ -1,6 +1,6 @@
 import eina_types;
 
-abstract Efl.VG.Base (Eo.Base, Efl.Gfx, Efl.Gfx.Stack)
+abstract Efl.VG (Eo.Base, Efl.Gfx, Efl.Gfx.Stack)
 {
    eo_prefix: efl_vg;
    legacy_prefix: evas_vg_node;
@@ -68,7 +68,7 @@ abstract Efl.VG.Base (Eo.Base, Efl.Gfx, Efl.Gfx.Stack)
          get {
          }
          values {
-            m: Efl.VG.Base *;
+            m: Efl.VG *;
          }
       }
 /*      quality {
@@ -94,14 +94,14 @@ abstract Efl.VG.Base (Eo.Base, Efl.Gfx, Efl.Gfx.Stack)
       interpolate {
         return: bool;
         params {
-          @in from: const(Efl.VG.Base)*;
-          @in to: const(Efl.VG.Base)*;
+          @in from: const(Efl.VG)*;
+          @in to: const(Efl.VG)*;
           @in pos_map: double;
         }
       }
       dup {
         params {
-          @in from: const(Efl.VG.Base)*;
+          @in from: const(Efl.VG)*;
         }
       }
    }

diff --git a/src/lib/evas/canvas/efl_vg_container.eo b/src/lib/evas/canvas/efl_vg_container.eo
index 21bb5e7..3723ebd 100644 (file)
--- a/src/lib/evas/canvas/efl_vg_container.eo
+++ b/src/lib/evas/canvas/efl_vg_container.eo
@@ -1,4 +1,4 @@
-class Efl.VG.Container (Efl.VG.Base)
+class Efl.VG.Container (Efl.VG)
 {
    legacy_prefix: evas_vg_container;
    methods {
@@ -6,17 +6,17 @@ class Efl.VG.Container (Efl.VG.Base)
          params {
             @in name: const(char)*;
          }
-         return: Efl.VG.Base *;
+         return: Efl.VG *;
       }
       children_get {
-         return: free(own(iterator<Efl.VG.Base *>*), eina_iterator_free) @warn_unused;
+         return: free(own(iterator<Efl.VG *>*), eina_iterator_free) @warn_unused;
       }
    }
    implements {
       Eo.Base.constructor;
       Eo.Base.destructor;
-      Efl.VG.Base.bounds_get;
-      Efl.VG.Base.interpolate;
-      Efl.VG.Base.dup;
+      Efl.VG.bounds_get;
+      Efl.VG.interpolate;
+      Efl.VG.dup;
    }
 }

diff --git a/src/lib/evas/canvas/efl_vg_gradient.eo b/src/lib/evas/canvas/efl_vg_gradient.eo
index 6b717fa..01a210a 100644 (file)
--- a/src/lib/evas/canvas/efl_vg_gradient.eo
+++ b/src/lib/evas/canvas/efl_vg_gradient.eo
@@ -1,4 +1,4 @@
-abstract Efl.VG.Gradient (Efl.VG.Base, Efl.Gfx.Gradient)
+abstract Efl.VG.Gradient (Efl.VG, Efl.Gfx.Gradient)
 {
    legacy_prefix: evas_vg_gradient;
    implements {
@@ -6,7 +6,7 @@ abstract Efl.VG.Gradient (Efl.VG.Base, Efl.Gfx.Gradient)
       Efl.Gfx.Gradient.stop.get;
       Efl.Gfx.Gradient.spread.set;
       Efl.Gfx.Gradient.spread.get;
-      Efl.VG.Base.interpolate;
-      Efl.VG.Base.dup;
+      Efl.VG.interpolate;
+      Efl.VG.dup;
    }
 }

diff --git a/src/lib/evas/canvas/efl_vg_gradient_linear.eo b/src/lib/evas/canvas/efl_vg_gradient_linear.eo
index 381ddb6..3376267 100644 (file)
--- a/src/lib/evas/canvas/efl_vg_gradient_linear.eo
+++ b/src/lib/evas/canvas/efl_vg_gradient_linear.eo
@@ -6,9 +6,9 @@ class Efl.VG.Gradient_Linear (Efl.VG.Gradient, Efl.Gfx.Gradient.Linear)
       Efl.Gfx.Gradient.Linear.start.get;
       Efl.Gfx.Gradient.Linear.end.set;
       Efl.Gfx.Gradient.Linear.end.get;
-      Efl.VG.Base.bounds_get;
-      Efl.VG.Base.interpolate;
-      Efl.VG.Base.dup;
+      Efl.VG.bounds_get;
+      Efl.VG.interpolate;
+      Efl.VG.dup;
       Eo.Base.constructor;
       Eo.Base.destructor;
    }

diff --git a/src/lib/evas/canvas/efl_vg_gradient_radial.eo b/src/lib/evas/canvas/efl_vg_gradient_radial.eo
index 860c4f7..b41a4b0 100644 (file)
--- a/src/lib/evas/canvas/efl_vg_gradient_radial.eo
+++ b/src/lib/evas/canvas/efl_vg_gradient_radial.eo
@@ -8,9 +8,9 @@ class Efl.VG.Gradient_Radial (Efl.VG.Gradient, Efl.Gfx.Gradient.Radial)
       Efl.Gfx.Gradient.Radial.radius.get;
       Efl.Gfx.Gradient.Radial.focal.set;
       Efl.Gfx.Gradient.Radial.focal.get;     
-      Efl.VG.Base.bounds_get;
-      Efl.VG.Base.interpolate;
-      Efl.VG.Base.dup;
+      Efl.VG.bounds_get;
+      Efl.VG.interpolate;
+      Efl.VG.dup;
       Eo.Base.constructor;
       Eo.Base.destructor;
    }

diff --git a/src/lib/evas/canvas/efl_vg_shape.eo b/src/lib/evas/canvas/efl_vg_shape.eo
index bee31b0..ed74089 100644 (file)
--- a/src/lib/evas/canvas/efl_vg_shape.eo
+++ b/src/lib/evas/canvas/efl_vg_shape.eo
@@ -1,4 +1,4 @@
-class Efl.VG.Shape (Efl.VG.Base, Efl.Gfx.Shape)
+class Efl.VG.Shape (Efl.VG, Efl.Gfx.Shape)
 {
    legacy_prefix: evas_vg_shape;
    methods {
@@ -8,7 +8,7 @@ class Efl.VG.Shape (Efl.VG.Base, Efl.Gfx.Shape)
         get {
         }
         values {
-           f: Efl.VG.Base *;
+           f: Efl.VG *;
         }
       }
       @property stroke_fill {
@@ -17,7 +17,7 @@ class Efl.VG.Shape (Efl.VG.Base, Efl.Gfx.Shape)
         get {
         }
         values {
-           f: Efl.VG.Base *;
+           f: Efl.VG *;
         }
       }
       @property stroke_marker {
@@ -26,16 +26,16 @@ class Efl.VG.Shape (Efl.VG.Base, Efl.Gfx.Shape)
         get {
         }
         values {
-           m: Efl.VG.Base *;
+           m: Efl.VG *;
         }
       }
    }
    implements {
       Efl.Gfx.color_part.set;
       Efl.Gfx.color_part.get;
-      Efl.VG.Base.bounds_get;
-      Efl.VG.Base.interpolate;
-      Efl.VG.Base.dup;
+      Efl.VG.bounds_get;
+      Efl.VG.interpolate;
+      Efl.VG.dup;
       Eo.Base.constructor;
       Eo.Base.destructor;
    }

diff --git a/src/lib/evas/canvas/evas_object_vg.c b/src/lib/evas/canvas/evas_object_vg.c
index 0446511..74c72fd 100644 (file)
--- a/src/lib/evas/canvas/evas_object_vg.c
+++ b/src/lib/evas/canvas/evas_object_vg.c
@@ -163,9 +163,9 @@ _evas_vg_render(Evas_Object_Protected_Data *obj, Evas_VG_Data *vd,
      }
    else
      {
-        Efl_VG_Base_Data *nd;
+        Efl_VG_Data *nd;
 
-        nd = eo_data_scope_get(n, EFL_VG_BASE_CLASS);
+        nd = eo_data_scope_get(n, EFL_VG_CLASS);
 
         obj->layer->evas->engine.func->ector_renderer_draw(output, context, surface, vd->engine_data, nd->renderer, clips, do_async);
 
@@ -228,7 +228,7 @@ evas_object_vg_render_pre(Evas_Object *eo_obj,
                           void *type_private_data)
 {
    Evas_VG_Data *vd = type_private_data;
-   Efl_VG_Base_Data *rnd;
+   Efl_VG_Data *rnd;
    int is_v, was_v;
    Ector_Surface *s;
 
@@ -264,7 +264,7 @@ evas_object_vg_render_pre(Evas_Object *eo_obj,
 
    // FIXME: for now the walking Evas_VG_Node tree doesn't trigger any damage
    // So just forcing it here if necessary
-   rnd = eo_data_scope_get(vd->root, EFL_VG_BASE_CLASS);
+   rnd = eo_data_scope_get(vd->root, EFL_VG_CLASS);
 
    // Once the destructor has been called, root node will be zero
    // and a full redraw is still necessary.

diff --git a/src/lib/evas/canvas/evas_vg.eo b/src/lib/evas/canvas/evas_vg.eo
index 53aa19f..96caa45 100644 (file)
--- a/src/lib/evas/canvas/evas_vg.eo
+++ b/src/lib/evas/canvas/evas_vg.eo
@@ -14,7 +14,7 @@ class Evas.VG (Evas.Object, Efl.Gfx.Fill, Efl.Gfx.View)
               @since 1.14]]
          }
          values {
-            container: Eo.Base *; [[Root node of the VG canvas.]] /* FIXME: Should be Efl.VG.Base */
+            container: Eo.Base *; [[Root node of the VG canvas.]] /* FIXME: Should be Efl.VG */
          }
       }
    }

diff --git a/src/lib/evas/canvas/evas_vg_container.c b/src/lib/evas/canvas/evas_vg_container.c
index c7ca580..a805902 100644 (file)
--- a/src/lib/evas/canvas/evas_vg_container.c
+++ b/src/lib/evas/canvas/evas_vg_container.c
@@ -10,7 +10,7 @@ _efl_vg_container_render_pre(Eo *obj EINA_UNUSED,
                              Eina_Matrix3 *parent,
                              Ector_Surface *s,
                              void *data,
-                             Efl_VG_Base_Data *nd)
+                             Efl_VG_Data *nd)
 {
    Efl_VG_Container_Data *pd = data;
    Eina_List *l;
@@ -29,13 +29,13 @@ static Eo *
 _efl_vg_container_eo_base_constructor(Eo *obj,
                                       Efl_VG_Container_Data *pd)
 {
-   Efl_VG_Base_Data *nd;
+   Efl_VG_Data *nd;
 
    pd->names = eina_hash_stringshared_new(NULL);
 
    obj = eo_constructor(eo_super(obj, MY_CLASS));
 
-   nd = eo_data_scope_get(obj, EFL_VG_BASE_CLASS);
+   nd = eo_data_scope_get(obj, EFL_VG_CLASS);
    nd->render_pre = _efl_vg_container_render_pre;
    nd->data = pd;
 
@@ -53,7 +53,7 @@ _efl_vg_container_eo_base_destructor(Eo *obj,
 }
 
 static void
-_efl_vg_container_efl_vg_base_bounds_get(Eo *obj EINA_UNUSED,
+_efl_vg_container_efl_vg_bounds_get(Eo *obj EINA_UNUSED,
                                         Efl_VG_Container_Data *pd,
                                         Eina_Rectangle *r)
 {
@@ -79,11 +79,11 @@ _efl_vg_container_efl_vg_base_bounds_get(Eo *obj EINA_UNUSED,
      }
 }
 
-static Efl_VG_Base *
+static Efl_VG *
 _efl_vg_container_child_get(Eo *obj EINA_UNUSED, Efl_VG_Container_Data *pd, const char *name)
 {
    const char *tmp = eina_stringshare_add(name);
-   Efl_VG_Base *r;
+   Efl_VG *r;
 
    r = eina_hash_find(pd->names, tmp);
    eina_stringshare_del(tmp);
@@ -98,9 +98,9 @@ _efl_vg_container_children_get(Eo *obj EINA_UNUSED, Efl_VG_Container_Data *pd)
 }
 
 static Eina_Bool
-_efl_vg_container_efl_vg_base_interpolate(Eo *obj,
+_efl_vg_container_efl_vg_interpolate(Eo *obj,
                                           Efl_VG_Container_Data *pd,
-                                          const Efl_VG_Base *from, const Efl_VG_Base *to,
+                                          const Efl_VG *from, const Efl_VG *to,
                                           double pos_map)
 {
    Efl_VG_Container_Data *fd;
@@ -136,9 +136,9 @@ _efl_vg_container_efl_vg_base_interpolate(Eo *obj,
 }
 
 static void
-_efl_vg_container_efl_vg_base_dup(Eo *obj,
+_efl_vg_container_efl_vg_dup(Eo *obj,
                                   Efl_VG_Container_Data *pd,
-                                  const Efl_VG_Base *from)
+                                  const Efl_VG *from)
 {
    Efl_VG_Container_Data *fromd;
    Eina_List *l;

diff --git a/src/lib/evas/canvas/evas_vg_gradient.c b/src/lib/evas/canvas/evas_vg_gradient.c
index db7eedb..492bafb 100644 (file)
--- a/src/lib/evas/canvas/evas_vg_gradient.c
+++ b/src/lib/evas/canvas/evas_vg_gradient.c
@@ -21,7 +21,7 @@ _efl_vg_gradient_efl_gfx_gradient_stop_set(Eo *obj EINA_UNUSED,
    memcpy(pd->colors, colors, length * sizeof(Efl_Gfx_Gradient_Stop));
    pd->colors_count = length;
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 static void
@@ -41,7 +41,7 @@ _efl_vg_gradient_efl_gfx_gradient_spread_set(Eo *obj EINA_UNUSED,
 {
    pd->s = s;
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 static Efl_Gfx_Gradient_Spread
@@ -52,9 +52,9 @@ _efl_vg_gradient_efl_gfx_gradient_spread_get(Eo *obj EINA_UNUSED,
 }
 
 static Eina_Bool
-_efl_vg_gradient_efl_vg_base_interpolate(Eo *obj,
+_efl_vg_gradient_efl_vg_interpolate(Eo *obj,
                                          Efl_VG_Gradient_Data *pd,
-                                         const Efl_VG_Base *from, const Efl_VG_Base *to,
+                                         const Efl_VG *from, const Efl_VG *to,
                                          double pos_map)
 {
    Efl_VG_Gradient_Data *fromd, *tod;
@@ -95,9 +95,9 @@ _efl_vg_gradient_efl_vg_base_interpolate(Eo *obj,
 }
 
 static void
-_efl_vg_gradient_efl_vg_base_dup(Eo *obj,
+_efl_vg_gradient_efl_vg_dup(Eo *obj,
                                  Efl_VG_Gradient_Data *pd EINA_UNUSED,
-                                 const Efl_VG_Base *from)
+                                 const Efl_VG *from)
 {
    Efl_VG_Gradient_Data *fromd;
 

diff --git a/src/lib/evas/canvas/evas_vg_gradient_linear.c b/src/lib/evas/canvas/evas_vg_gradient_linear.c
index 6fd12b2..5aa2607 100644 (file)
--- a/src/lib/evas/canvas/evas_vg_gradient_linear.c
+++ b/src/lib/evas/canvas/evas_vg_gradient_linear.c
@@ -23,7 +23,7 @@ _efl_vg_gradient_linear_efl_gfx_gradient_linear_start_set(Eo *obj EINA_UNUSED,
    pd->start.x = x;
    pd->start.y = y;
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 static void
@@ -43,7 +43,7 @@ _efl_vg_gradient_linear_efl_gfx_gradient_linear_end_set(Eo *obj EINA_UNUSED,
    pd->end.x = x;
    pd->end.y = y;
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 static void
@@ -60,7 +60,7 @@ _efl_vg_gradient_linear_render_pre(Eo *obj,
                                    Eina_Matrix3 *parent,
                                    Ector_Surface *s,
                                    void *data,
-                                   Efl_VG_Base_Data *nd)
+                                   Efl_VG_Data *nd)
 {
    Efl_VG_Gradient_Linear_Data *pd = data;
    Efl_VG_Gradient_Data *gd;
@@ -91,11 +91,11 @@ static Eo *
 _efl_vg_gradient_linear_eo_base_constructor(Eo *obj,
                                             Efl_VG_Gradient_Linear_Data *pd)
 {
-   Efl_VG_Base_Data *nd;
+   Efl_VG_Data *nd;
 
    obj = eo_constructor(eo_super(obj, MY_CLASS));
 
-   nd = eo_data_scope_get(obj, EFL_VG_BASE_CLASS);
+   nd = eo_data_scope_get(obj, EFL_VG_CLASS);
    nd->render_pre = _efl_vg_gradient_linear_render_pre;
    nd->data = pd;
 
@@ -109,20 +109,20 @@ _efl_vg_gradient_linear_eo_base_destructor(Eo *obj, Efl_VG_Gradient_Linear_Data
 }
 
 static void
-_efl_vg_gradient_linear_efl_vg_base_bounds_get(Eo *obj, Efl_VG_Gradient_Linear_Data *pd, Eina_Rectangle *r)
+_efl_vg_gradient_linear_efl_vg_bounds_get(Eo *obj, Efl_VG_Gradient_Linear_Data *pd, Eina_Rectangle *r)
 {
-   Efl_VG_Base_Data *nd;
+   Efl_VG_Data *nd;
 
-   nd = eo_data_scope_get(obj, EFL_VG_BASE_CLASS);
+   nd = eo_data_scope_get(obj, EFL_VG_CLASS);
    EINA_RECTANGLE_SET(r,
                       nd->x + pd->start.x, nd->y + pd->start.y,
                       pd->end.x - pd->start.x, pd->end.y - pd->start.x);
 }
 
 static Eina_Bool
-_efl_vg_gradient_linear_efl_vg_base_interpolate(Eo *obj,
+_efl_vg_gradient_linear_efl_vg_interpolate(Eo *obj,
                                                 Efl_VG_Gradient_Linear_Data *pd,
-                                                const Efl_VG_Base *from, const Efl_VG_Base *to,
+                                                const Efl_VG *from, const Efl_VG *to,
                                                 double pos_map)
 {
    Efl_VG_Gradient_Linear_Data *fromd, *tod;
@@ -151,9 +151,9 @@ _efl_vg_gradient_linear_efl_vg_base_interpolate(Eo *obj,
 }
 
 static void
-_efl_vg_gradient_linear_efl_vg_base_dup(Eo *obj,
+_efl_vg_gradient_linear_efl_vg_dup(Eo *obj,
                                         Efl_VG_Gradient_Linear_Data *pd EINA_UNUSED,
-                                        const Efl_VG_Base *from)
+                                        const Efl_VG *from)
 {
    Efl_VG_Gradient_Linear_Data *fromd;
 

diff --git a/src/lib/evas/canvas/evas_vg_gradient_radial.c b/src/lib/evas/canvas/evas_vg_gradient_radial.c
index 21cd703..c36150a 100644 (file)
--- a/src/lib/evas/canvas/evas_vg_gradient_radial.c
+++ b/src/lib/evas/canvas/evas_vg_gradient_radial.c
@@ -22,7 +22,7 @@ _efl_vg_gradient_radial_efl_gfx_gradient_radial_center_set(Eo *obj EINA_UNUSED,
    pd->center.x = x;
    pd->center.y = y;
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 static void
@@ -41,7 +41,7 @@ _efl_vg_gradient_radial_efl_gfx_gradient_radial_radius_set(Eo *obj EINA_UNUSED,
 {
    pd->radius = r;
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 static double
@@ -59,7 +59,7 @@ _efl_vg_gradient_radial_efl_gfx_gradient_radial_focal_set(Eo *obj EINA_UNUSED,
    pd->focal.x = x;
    pd->focal.y = y;
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 static void
@@ -76,7 +76,7 @@ _efl_vg_gradient_radial_render_pre(Eo *obj,
                                     Eina_Matrix3 *parent,
                                     Ector_Surface *s,
                                     void *data,
-                                    Efl_VG_Base_Data *nd)
+                                    Efl_VG_Data *nd)
 {
    Efl_VG_Gradient_Radial_Data *pd = data;
    Efl_VG_Gradient_Data *gd;
@@ -107,11 +107,11 @@ _efl_vg_gradient_radial_render_pre(Eo *obj,
 static Eo *
 _efl_vg_gradient_radial_eo_base_constructor(Eo *obj, Efl_VG_Gradient_Radial_Data *pd)
 {
-   Efl_VG_Base_Data *nd;
+   Efl_VG_Data *nd;
 
    obj = eo_constructor(eo_super(obj, MY_CLASS));
 
-   nd = eo_data_scope_get(obj, EFL_VG_BASE_CLASS);
+   nd = eo_data_scope_get(obj, EFL_VG_CLASS);
    nd->render_pre = _efl_vg_gradient_radial_render_pre;
    nd->data = pd;
 
@@ -126,11 +126,11 @@ _efl_vg_gradient_radial_eo_base_destructor(Eo *obj,
 }
 
 static void
-_efl_vg_gradient_radial_efl_vg_base_bounds_get(Eo *obj, Efl_VG_Gradient_Radial_Data *pd, Eina_Rectangle *r)
+_efl_vg_gradient_radial_efl_vg_bounds_get(Eo *obj, Efl_VG_Gradient_Radial_Data *pd, Eina_Rectangle *r)
 {
-   Efl_VG_Base_Data *nd;
+   Efl_VG_Data *nd;
 
-   nd = eo_data_scope_get(obj, EFL_VG_BASE_CLASS);
+   nd = eo_data_scope_get(obj, EFL_VG_CLASS);
    EINA_RECTANGLE_SET(r,
                       nd->x + pd->center.x - pd->radius,
                       nd->y + pd->center.y - pd->radius,
@@ -138,9 +138,9 @@ _efl_vg_gradient_radial_efl_vg_base_bounds_get(Eo *obj, Efl_VG_Gradient_Radial_D
 }
 
 static Eina_Bool
-_efl_vg_gradient_radial_efl_vg_base_interpolate(Eo *obj,
+_efl_vg_gradient_radial_efl_vg_interpolate(Eo *obj,
                                                 Efl_VG_Gradient_Radial_Data *pd,
-                                                const Efl_VG_Base *from, const Efl_VG_Base *to,
+                                                const Efl_VG *from, const Efl_VG *to,
                                                 double pos_map)
 {
    Efl_VG_Gradient_Radial_Data *fromd, *tod;
@@ -170,9 +170,9 @@ _efl_vg_gradient_radial_efl_vg_base_interpolate(Eo *obj,
 }
 
 static void
-_efl_vg_gradient_radial_efl_vg_base_dup(Eo *obj,
+_efl_vg_gradient_radial_efl_vg_dup(Eo *obj,
                                         Efl_VG_Gradient_Radial_Data *pd EINA_UNUSED,
-                                        const Efl_VG_Base *from)
+                                        const Efl_VG *from)
 {
    Efl_VG_Gradient_Radial_Data *fromd;
 

diff --git a/src/lib/evas/canvas/evas_vg_node.c b/src/lib/evas/canvas/evas_vg_node.c
index c120cf7..1a0cdcb 100644 (file)
--- a/src/lib/evas/canvas/evas_vg_node.c
+++ b/src/lib/evas/canvas/evas_vg_node.c
@@ -7,7 +7,7 @@
 #include <string.h>
 #include <math.h>
 
-#define MY_CLASS EFL_VG_BASE_CLASS
+#define MY_CLASS EFL_VG_CLASS
 
 static const Efl_VG_Interpolation interpolation_identity = {
   { 0, 0, 0, 1 },
@@ -18,9 +18,9 @@ static const Efl_VG_Interpolation interpolation_identity = {
 };
 
 static Eina_Bool
-_efl_vg_base_property_changed(void *data, const Eo_Event *event)
+_efl_vg_property_changed(void *data, const Eo_Event *event)
 {
-   Efl_VG_Base_Data *pd = data;
+   Efl_VG_Data *pd = data;
    Eo *parent;
 
    if (pd->changed) return EINA_TRUE;
@@ -32,8 +32,8 @@ _efl_vg_base_property_changed(void *data, const Eo_Event *event)
 }
 
 static void
-_efl_vg_base_transformation_set(Eo *obj,
-                                Efl_VG_Base_Data *pd,
+_efl_vg_transformation_set(Eo *obj,
+                                Efl_VG_Data *pd,
                                 const Eina_Matrix3 *m)
 {
    if (pd->intp)
@@ -57,29 +57,29 @@ _efl_vg_base_transformation_set(Eo *obj,
         pd->m = NULL;
      }
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 const Eina_Matrix3 *
-_efl_vg_base_transformation_get(Eo *obj EINA_UNUSED, Efl_VG_Base_Data *pd)
+_efl_vg_transformation_get(Eo *obj EINA_UNUSED, Efl_VG_Data *pd)
 {
    return pd->m;
 }
 
 static void
-_efl_vg_base_origin_set(Eo *obj,
-                        Efl_VG_Base_Data *pd,
+_efl_vg_origin_set(Eo *obj,
+                        Efl_VG_Data *pd,
                         double x, double y)
 {
    pd->x = x;
    pd->y = y;
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 static void
-_efl_vg_base_origin_get(Eo *obj EINA_UNUSED,
-                        Efl_VG_Base_Data *pd,
+_efl_vg_origin_get(Eo *obj EINA_UNUSED,
+                        Efl_VG_Data *pd,
                         double *x, double *y)
 {
    if (x) *x = pd->x;
@@ -87,19 +87,19 @@ _efl_vg_base_origin_get(Eo *obj EINA_UNUSED,
 }
 
 static void
-_efl_vg_base_efl_gfx_position_set(Eo *obj EINA_UNUSED,
-                                       Efl_VG_Base_Data *pd,
+_efl_vg_efl_gfx_position_set(Eo *obj EINA_UNUSED,
+                                       Efl_VG_Data *pd,
                                        int x, int y)
 {
    pd->x = lrint(x);
    pd->y = lrint(y);
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 static void
-_efl_vg_base_efl_gfx_position_get(Eo *obj EINA_UNUSED,
-                                       Efl_VG_Base_Data *pd,
+_efl_vg_efl_gfx_position_get(Eo *obj EINA_UNUSED,
+                                       Efl_VG_Data *pd,
                                        int *x, int *y)
 {
    if (x) *x = pd->x;
@@ -107,25 +107,25 @@ _efl_vg_base_efl_gfx_position_get(Eo *obj EINA_UNUSED,
 }
 
 static void
-_efl_vg_base_efl_gfx_visible_set(Eo *obj EINA_UNUSED,
-                                      Efl_VG_Base_Data *pd, Eina_Bool v)
+_efl_vg_efl_gfx_visible_set(Eo *obj EINA_UNUSED,
+                                      Efl_VG_Data *pd, Eina_Bool v)
 {
    pd->visibility = v;
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 
 static Eina_Bool
-_efl_vg_base_efl_gfx_visible_get(Eo *obj EINA_UNUSED,
-                                      Efl_VG_Base_Data *pd)
+_efl_vg_efl_gfx_visible_get(Eo *obj EINA_UNUSED,
+                                      Efl_VG_Data *pd)
 {
    return pd->visibility;
 }
 
 static void
-_efl_vg_base_efl_gfx_color_set(Eo *obj EINA_UNUSED,
-                                    Efl_VG_Base_Data *pd,
+_efl_vg_efl_gfx_color_set(Eo *obj EINA_UNUSED,
+                                    Efl_VG_Data *pd,
                                     int r, int g, int b, int a)
 {
    if (r > 255) r = 255; if (r < 0) r = 0;
@@ -153,23 +153,23 @@ _efl_vg_base_efl_gfx_color_set(Eo *obj EINA_UNUSED,
    pd->b = b;
    pd->a = a;
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 static Eina_Bool
-_efl_vg_base_efl_gfx_color_part_set(Eo *obj, Efl_VG_Base_Data *pd,
+_efl_vg_efl_gfx_color_part_set(Eo *obj, Efl_VG_Data *pd,
                                          const char *part,
                                          int r, int g, int b, int a)
 {
    if (part) return EINA_FALSE;
 
-   _efl_vg_base_efl_gfx_color_set(obj, pd, r, g, b, a);
+   _efl_vg_efl_gfx_color_set(obj, pd, r, g, b, a);
    return EINA_TRUE;
 }
 
 static void
-_efl_vg_base_efl_gfx_color_get(Eo *obj EINA_UNUSED,
-                                    Efl_VG_Base_Data *pd,
+_efl_vg_efl_gfx_color_get(Eo *obj EINA_UNUSED,
+                                    Efl_VG_Data *pd,
                                     int *r, int *g, int *b, int *a)
 {
    if (r) *r = pd->r;
@@ -179,38 +179,38 @@ _efl_vg_base_efl_gfx_color_get(Eo *obj EINA_UNUSED,
 }
 
 static Eina_Bool
-_efl_vg_base_efl_gfx_color_part_get(Eo *obj, Efl_VG_Base_Data *pd,
+_efl_vg_efl_gfx_color_part_get(Eo *obj, Efl_VG_Data *pd,
                                          const char *part,
                                          int *r, int *g, int *b, int *a)
 {
    if (part) return EINA_FALSE;
 
-   _efl_vg_base_efl_gfx_color_get(obj, pd, r, g, b, a);
+   _efl_vg_efl_gfx_color_get(obj, pd, r, g, b, a);
    return EINA_TRUE;
 }
 
 static void
-_efl_vg_base_mask_set(Eo *obj EINA_UNUSED,
-                       Efl_VG_Base_Data *pd,
-                       Efl_VG_Base *r)
+_efl_vg_mask_set(Eo *obj EINA_UNUSED,
+                       Efl_VG_Data *pd,
+                       Efl_VG *r)
 {
-   Efl_VG_Base *tmp = pd->mask;
+   Efl_VG *tmp = pd->mask;
 
    pd->mask = eo_ref(r);
    eo_unref(tmp);
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
-static Efl_VG_Base*
-_efl_vg_base_mask_get(Eo *obj EINA_UNUSED, Efl_VG_Base_Data *pd)
+static Efl_VG*
+_efl_vg_mask_get(Eo *obj EINA_UNUSED, Efl_VG_Data *pd)
 {
    return pd->mask;
 }
 
 static void
-_efl_vg_base_efl_gfx_size_get(Eo *obj,
-                                   Efl_VG_Base_Data *pd EINA_UNUSED,
+_efl_vg_efl_gfx_size_get(Eo *obj,
+                                   Efl_VG_Data *pd EINA_UNUSED,
                                    int *w, int *h)
 {
    Eina_Rectangle r = { 0, 0, 0, 0 };
@@ -222,7 +222,7 @@ _efl_vg_base_efl_gfx_size_get(Eo *obj,
 
 // Parent should be a container otherwise dismissing the stacking operation
 static Eina_Bool
-_efl_vg_base_parent_checked_get(Eo *obj,
+_efl_vg_parent_checked_get(Eo *obj,
                                 Eo **parent,
                                 Efl_VG_Container_Data **cd)
 {
@@ -257,27 +257,27 @@ _efl_vg_base_parent_checked_get(Eo *obj,
 }
 
 static Eo *
-_efl_vg_base_eo_base_constructor(Eo *obj,
-                                 Efl_VG_Base_Data *pd)
+_efl_vg_eo_base_constructor(Eo *obj,
+                                 Efl_VG_Data *pd)
 {
    Efl_VG_Container_Data *cd = NULL;
    Eo *parent;
 
    obj = eo_constructor(eo_super(obj, MY_CLASS));
 
-   if (!_efl_vg_base_parent_checked_get(obj, &parent, &cd)) {
+   if (!_efl_vg_parent_checked_get(obj, &parent, &cd)) {
         ERR("Failed");
         return NULL;
    }
 
-   eo_event_callback_add(obj, EFL_GFX_CHANGED, _efl_vg_base_property_changed, pd);
+   eo_event_callback_add(obj, EFL_GFX_CHANGED, _efl_vg_property_changed, pd);
    pd->changed = EINA_TRUE;
 
    return obj;
 }
 
 static void
-_efl_vg_base_eo_base_destructor(Eo *obj, Efl_VG_Base_Data *pd)
+_efl_vg_eo_base_destructor(Eo *obj, Efl_VG_Data *pd)
 {
    if (pd->m)
      {
@@ -300,7 +300,7 @@ _efl_vg_base_eo_base_destructor(Eo *obj, Efl_VG_Base_Data *pd)
 }
 
 static void
-_efl_vg_base_name_insert(Eo *obj, Efl_VG_Base_Data *pd, Efl_VG_Container_Data *cd)
+_efl_vg_name_insert(Eo *obj, Efl_VG_Data *pd, Efl_VG_Container_Data *cd)
 {
    Eo *set;
 
@@ -321,30 +321,30 @@ _efl_vg_base_name_insert(Eo *obj, Efl_VG_Base_Data *pd, Efl_VG_Container_Data *c
 }
 
 static void
-_efl_vg_base_name_set(Eo *obj, Efl_VG_Base_Data *pd, const char *name)
+_efl_vg_name_set(Eo *obj, Efl_VG_Data *pd, const char *name)
 {
    Efl_VG_Container_Data *cd = NULL;
    Eo *parent = NULL;
 
-   if (_efl_vg_base_parent_checked_get(obj, &parent, &cd))
+   if (_efl_vg_parent_checked_get(obj, &parent, &cd))
      {
         if (pd->name) eina_hash_del(cd->names, pd->name, obj);
      }
 
    eina_stringshare_replace(&pd->name, name);
 
-   if (cd) _efl_vg_base_name_insert(obj, pd, cd);
+   if (cd) _efl_vg_name_insert(obj, pd, cd);
 }
 
 static const char *
-_efl_vg_base_name_get(Eo *obj EINA_UNUSED, Efl_VG_Base_Data *pd)
+_efl_vg_name_get(Eo *obj EINA_UNUSED, Efl_VG_Data *pd)
 {
    return pd->name;
 }
 
 static void
-_efl_vg_base_eo_base_parent_set(Eo *obj,
-                                Efl_VG_Base_Data *pd EINA_UNUSED,
+_efl_vg_eo_base_parent_set(Eo *obj,
+                                Efl_VG_Data *pd EINA_UNUSED,
                                 Eo *parent)
 {
    Efl_VG_Container_Data *cd = NULL;
@@ -366,7 +366,7 @@ _efl_vg_base_eo_base_parent_set(Eo *obj,
         goto on_error;
      }
 
-   if (!_efl_vg_base_parent_checked_get(obj, &old_parent, &old_cd))
+   if (!_efl_vg_parent_checked_get(obj, &old_parent, &old_cd))
      {
         ERR("Can't check the old parent of %p.", obj);
         goto on_error;
@@ -385,12 +385,12 @@ _efl_vg_base_eo_base_parent_set(Eo *obj,
      {
         cd->children = eina_list_append(cd->children, obj);
 
-        _efl_vg_base_name_insert(obj, pd, cd);
+        _efl_vg_name_insert(obj, pd, cd);
      }
 
-   _efl_vg_base_changed(old_parent);
-   _efl_vg_base_changed(obj);
-   _efl_vg_base_changed(parent);
+   _efl_vg_changed(old_parent);
+   _efl_vg_changed(obj);
+   _efl_vg_changed(parent);
 
    return ;
 
@@ -399,7 +399,7 @@ _efl_vg_base_eo_base_parent_set(Eo *obj,
 }
 
 static void
-_efl_vg_base_efl_gfx_stack_raise(Eo *obj, Efl_VG_Base_Data *pd EINA_UNUSED)
+_efl_vg_efl_gfx_stack_raise(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
 {
    Efl_VG_Container_Data *cd;
    Eina_List *lookup, *next;
@@ -419,7 +419,7 @@ _efl_vg_base_efl_gfx_stack_raise(Eo *obj, Efl_VG_Base_Data *pd EINA_UNUSED)
    cd->children = eina_list_remove_list(cd->children, lookup);
    cd->children = eina_list_append_relative_list(cd->children, obj, next);
 
-   _efl_vg_base_changed(parent);
+   _efl_vg_changed(parent);
    return ;
 
  on_error:
@@ -427,8 +427,8 @@ _efl_vg_base_efl_gfx_stack_raise(Eo *obj, Efl_VG_Base_Data *pd EINA_UNUSED)
 }
 
 static void
-_efl_vg_base_efl_gfx_stack_stack_above(Eo *obj,
-                                       Efl_VG_Base_Data *pd EINA_UNUSED,
+_efl_vg_efl_gfx_stack_stack_above(Eo *obj,
+                                       Efl_VG_Data *pd EINA_UNUSED,
                                        Efl_Gfx_Stack *above)
 {
    Efl_VG_Container_Data *cd;
@@ -449,7 +449,7 @@ _efl_vg_base_efl_gfx_stack_stack_above(Eo *obj,
    cd->children = eina_list_remove_list(cd->children, lookup);
    cd->children = eina_list_append_relative_list(cd->children, obj, ref);
 
-   _efl_vg_base_changed(parent);
+   _efl_vg_changed(parent);
    return ;
 
  on_error:
@@ -457,8 +457,8 @@ _efl_vg_base_efl_gfx_stack_stack_above(Eo *obj,
 }
 
 static void
-_efl_vg_base_efl_gfx_stack_stack_below(Eo *obj,
-                                       Efl_VG_Base_Data *pd EINA_UNUSED,
+_efl_vg_efl_gfx_stack_stack_below(Eo *obj,
+                                       Efl_VG_Data *pd EINA_UNUSED,
                                        Efl_Gfx_Stack *below)
 {
    Efl_VG_Container_Data *cd;
@@ -479,7 +479,7 @@ _efl_vg_base_efl_gfx_stack_stack_below(Eo *obj,
    cd->children = eina_list_remove_list(cd->children, lookup);
    cd->children = eina_list_prepend_relative_list(cd->children, obj, ref);
 
-   _efl_vg_base_changed(parent);
+   _efl_vg_changed(parent);
    return ;
 
  on_error:
@@ -487,7 +487,7 @@ _efl_vg_base_efl_gfx_stack_stack_below(Eo *obj,
 }
 
 static void
-_efl_vg_base_efl_gfx_stack_lower(Eo *obj, Efl_VG_Base_Data *pd EINA_UNUSED)
+_efl_vg_efl_gfx_stack_lower(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
 {
    Efl_VG_Container_Data *cd;
    Eina_List *lookup, *prev;
@@ -507,7 +507,7 @@ _efl_vg_base_efl_gfx_stack_lower(Eo *obj, Efl_VG_Base_Data *pd EINA_UNUSED)
    cd->children = eina_list_remove_list(cd->children, lookup);
    cd->children = eina_list_prepend_relative_list(cd->children, obj, prev);
 
-   _efl_vg_base_changed(parent);
+   _efl_vg_changed(parent);
    return ;
 
  on_error:
@@ -515,7 +515,7 @@ _efl_vg_base_efl_gfx_stack_lower(Eo *obj, Efl_VG_Base_Data *pd EINA_UNUSED)
 }
 
 static Eo *
-_efl_vg_base_root_parent_get(Eo *obj)
+_efl_vg_root_parent_get(Eo *obj)
 {
    Eo *parent;
 
@@ -525,11 +525,11 @@ _efl_vg_base_root_parent_get(Eo *obj)
    parent = eo_parent_get(obj);
 
    if (!parent) return NULL;
-   return _efl_vg_base_root_parent_get(parent);
+   return _efl_vg_root_parent_get(parent);
 }
 
 static void
-_efl_vg_base_walk_down_at(Eo *root, Eina_Array *a, Eina_Rectangle *r)
+_efl_vg_walk_down_at(Eo *root, Eina_Array *a, Eina_Rectangle *r)
 {
    Eina_Rectangle bounds;
 
@@ -546,23 +546,23 @@ _efl_vg_base_walk_down_at(Eo *root, Eina_Array *a, Eina_Rectangle *r)
 
         cd = eo_data_scope_get(root, EFL_VG_CONTAINER_CLASS);
         EINA_LIST_FOREACH(cd->children, l, child)
-          _efl_vg_base_walk_down_at(child, a, r);
+          _efl_vg_walk_down_at(child, a, r);
      }
 }
 
 static void
-_efl_vg_base_object_at(Eo *obj, Eina_Array *a, Eina_Rectangle *r)
+_efl_vg_object_at(Eo *obj, Eina_Array *a, Eina_Rectangle *r)
 {
    Eo *root;
 
-   root = _efl_vg_base_root_parent_get(obj);
+   root = _efl_vg_root_parent_get(obj);
    if (!root) return ;
 
-   _efl_vg_base_walk_down_at(root, a, r);
+   _efl_vg_walk_down_at(root, a, r);
 }
 
 static Efl_Gfx_Stack *
-_efl_vg_base_efl_gfx_stack_below_get(Eo *obj, Efl_VG_Base_Data *pd EINA_UNUSED)
+_efl_vg_efl_gfx_stack_below_get(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
 {
    Eina_Rectangle r;
    Eina_Array a;
@@ -575,7 +575,7 @@ _efl_vg_base_efl_gfx_stack_below_get(Eo *obj, Efl_VG_Base_Data *pd EINA_UNUSED)
 
    eina_array_step_set(&a, sizeof (Eina_Array), 8);
 
-   _efl_vg_base_object_at(obj, &a, &r);
+   _efl_vg_object_at(obj, &a, &r);
 
    EINA_ARRAY_ITER_NEXT(&a, i, current, iterator)
      if (current == obj)
@@ -592,7 +592,7 @@ _efl_vg_base_efl_gfx_stack_below_get(Eo *obj, Efl_VG_Base_Data *pd EINA_UNUSED)
 }
 
 static Efl_Gfx_Stack *
-_efl_vg_base_efl_gfx_stack_above_get(Eo *obj, Efl_VG_Base_Data *pd EINA_UNUSED)
+_efl_vg_efl_gfx_stack_above_get(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
 {
    Eina_Rectangle r;
    Eina_Array a;
@@ -605,7 +605,7 @@ _efl_vg_base_efl_gfx_stack_above_get(Eo *obj, Efl_VG_Base_Data *pd EINA_UNUSED)
 
    eina_array_step_set(&a, sizeof (Eina_Array), 8);
 
-   _efl_vg_base_object_at(obj, &a, &r);
+   _efl_vg_object_at(obj, &a, &r);
 
    EINA_ARRAY_ITER_NEXT(&a, i, current, iterator)
      if (current == obj)
@@ -621,7 +621,7 @@ _efl_vg_base_efl_gfx_stack_above_get(Eo *obj, Efl_VG_Base_Data *pd EINA_UNUSED)
 }
 
 static Efl_VG_Interpolation *
-_efl_vg_interpolation_get(Efl_VG_Base_Data *pd)
+_efl_vg_interpolation_get(Efl_VG_Data *pd)
 {
    Eina_Matrix4 m;
 
@@ -658,16 +658,16 @@ _efl_vg_interpolate_point(Eina_Point_3D *d,
 }
 
 static Eina_Bool
-_efl_vg_base_interpolate(Eo *obj,
-                         Efl_VG_Base_Data *pd, const Efl_VG_Base *from, const Efl_VG_Base *to,
+_efl_vg_interpolate(Eo *obj,
+                         Efl_VG_Data *pd, const Efl_VG *from, const Efl_VG *to,
                          double pos_map)
 {
-   Efl_VG_Base_Data *fromd, *tod;
+   Efl_VG_Data *fromd, *tod;
    double from_map;
    Eina_Bool r = EINA_TRUE;
 
-   fromd = eo_data_scope_get(from, EFL_VG_BASE_CLASS);
-   tod = eo_data_scope_get(to, EFL_VG_BASE_CLASS);
+   fromd = eo_data_scope_get(from, EFL_VG_CLASS);
+   tod = eo_data_scope_get(to, EFL_VG_CLASS);
    from_map = 1.0 - pos_map;
 
    eo_del(pd->renderer);
@@ -730,27 +730,27 @@ _efl_vg_base_interpolate(Eo *obj,
         r &= efl_vg_interpolate(pd->mask, fromd->mask, tod->mask, pos_map);
      }
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 
    return r;
 }
 
 static void
-_efl_vg_base_dup(Eo *obj, Efl_VG_Base_Data *pd, const Efl_VG_Base *from)
+_efl_vg_dup(Eo *obj, Efl_VG_Data *pd, const Efl_VG *from)
 {
    Efl_VG_Container_Data *cd = NULL;
-   Efl_VG_Base_Data *fromd;
+   Efl_VG_Data *fromd;
    Eo *parent = NULL;
 
-   fromd = eo_data_scope_get(from, EFL_VG_BASE_CLASS);
+   fromd = eo_data_scope_get(from, EFL_VG_CLASS);
    if (pd->name != fromd->name)
      {
         eina_stringshare_del(pd->name);
         pd->name = eina_stringshare_ref(fromd->name);
      }
 
-   _efl_vg_base_parent_checked_get(obj, &parent, &cd);
-   if (cd) _efl_vg_base_name_insert(obj, pd, cd);
+   _efl_vg_parent_checked_get(obj, &parent, &cd);
+   if (cd) _efl_vg_name_insert(obj, pd, cd);
 
    if (pd->intp)
      {
@@ -789,7 +789,7 @@ _efl_vg_base_dup(Eo *obj, Efl_VG_Base_Data *pd, const Efl_VG_Base *from)
    pd->a = fromd->a;
    pd->visibility = fromd->visibility;
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 EAPI Eina_Bool
@@ -854,4 +854,4 @@ evas_vg_node_lower(Eo *obj)
    efl_gfx_stack_lower(obj);
 }
 
-#include "efl_vg_base.eo.c"
+#include "efl_vg.eo.c"

diff --git a/src/lib/evas/canvas/evas_vg_private.h b/src/lib/evas/canvas/evas_vg_private.h
index ca0389d..fca6680 100644 (file)
--- a/src/lib/evas/canvas/evas_vg_private.h
+++ b/src/lib/evas/canvas/evas_vg_private.h
@@ -3,7 +3,7 @@
 
 #include <Ector.h>
 
-typedef struct _Efl_VG_Base_Data Efl_VG_Base_Data;
+typedef struct _Efl_VG_Data Efl_VG_Data;
 typedef struct _Efl_VG_Container_Data Efl_VG_Container_Data;
 typedef struct _Efl_VG_Gradient_Data Efl_VG_Gradient_Data;
 typedef struct _Efl_VG_Interpolation Efl_VG_Interpolation;
@@ -22,7 +22,7 @@ struct _Evas_VG_Data
    Eina_Array cleanup;
 };
 
-struct _Efl_VG_Base_Data
+struct _Efl_VG_Data
 {
    const char *name;
 
@@ -32,7 +32,7 @@ struct _Efl_VG_Base_Data
    Efl_VG *mask;
    Ector_Renderer *renderer;
 
-   void (*render_pre)(Eo *obj, Eina_Matrix3 *parent, Ector_Surface *s, void *data, Efl_VG_Base_Data *nd);
+   void (*render_pre)(Eo *obj, Eina_Matrix3 *parent, Ector_Surface *s, void *data, Efl_VG_Data *nd);
    void *data;
 
    double x, y;
@@ -67,14 +67,14 @@ struct _Efl_VG_Interpolation
    Eina_Point_3D skew;
 };
 
-static inline Efl_VG_Base_Data *
+static inline Efl_VG_Data *
 _evas_vg_render_pre(Efl_VG *child, Ector_Surface *s, Eina_Matrix3 *m)
 {
-   Efl_VG_Base_Data *child_nd = NULL;
+   Efl_VG_Data *child_nd = NULL;
 
    // FIXME: Prevent infinite loop
    if (child)
-     child_nd = eo_data_scope_get(child, EFL_VG_BASE_CLASS);
+     child_nd = eo_data_scope_get(child, EFL_VG_CLASS);
    if (child_nd)
      child_nd->render_pre(child, m, s, child_nd->data, child_nd);
 
@@ -82,7 +82,7 @@ _evas_vg_render_pre(Efl_VG *child, Ector_Surface *s, Eina_Matrix3 *m)
 }
 
 static inline void
-_efl_vg_base_changed(Eo *obj)
+_efl_vg_changed(Eo *obj)
 {
    eo_event_callback_call(obj, EFL_GFX_CHANGED, NULL);
 }

diff --git a/src/lib/evas/canvas/evas_vg_root_node.c b/src/lib/evas/canvas/evas_vg_root_node.c
index 23ee194..9dc38d8 100644 (file)
--- a/src/lib/evas/canvas/evas_vg_root_node.c
+++ b/src/lib/evas/canvas/evas_vg_root_node.c
@@ -20,7 +20,7 @@ _evas_vg_root_node_render_pre(Eo *obj EINA_UNUSED,
                               Eina_Matrix3 *parent,
                               Ector_Surface *s,
                               void *data,
-                              Efl_VG_Base_Data *nd)
+                              Efl_VG_Data *nd)
 {
    Efl_VG_Container_Data *pd = data;
    Eina_List *l;
@@ -36,7 +36,7 @@ static Eina_Bool
 _evas_vg_root_node_changed(void *data, const Eo_Event *event)
 {
    Efl_VG_Root_Node_Data *pd = data;
-   Efl_VG_Base_Data *bd = eo_data_scope_get(event->obj, EFL_VG_BASE_CLASS);
+   Efl_VG_Data *bd = eo_data_scope_get(event->obj, EFL_VG_CLASS);
 
    if (bd->changed) return EINA_TRUE;
    bd->changed = EINA_TRUE;
@@ -51,7 +51,7 @@ _efl_vg_root_node_eo_base_parent_set(Eo *obj,
                                      Eo *parent)
 {
    // Nice little hack, jump over parent parent_set in Efl_VG_Root
-   eo_parent_set(eo_super(obj, EFL_VG_BASE_CLASS), parent);
+   eo_parent_set(eo_super(obj, EFL_VG_CLASS), parent);
    if (parent && !eo_isa(parent, EVAS_VG_CLASS))
      {
         ERR("Parent of VG_ROOT_NODE must be a VG_CLASS");
@@ -68,7 +68,7 @@ _efl_vg_root_node_eo_base_constructor(Eo *obj,
                                       Efl_VG_Root_Node_Data *pd)
 {
    Efl_VG_Container_Data *cd;
-   Efl_VG_Base_Data *nd;
+   Efl_VG_Data *nd;
    Eo *parent;
 
    // We are copying here the code of the vg container to make it possible to
@@ -78,7 +78,7 @@ _efl_vg_root_node_eo_base_constructor(Eo *obj,
    cd->names = eina_hash_stringshared_new(NULL);
 
    // Nice little hack, jump over parent constructor in Efl_VG_Root
-   obj = eo_constructor(eo_super(obj, EFL_VG_BASE_CLASS));
+   obj = eo_constructor(eo_super(obj, EFL_VG_CLASS));
    parent = eo_parent_get(obj);
    efl_vg_name_set(obj, "root");
    if (!eo_isa(parent, EVAS_VG_CLASS)) {
@@ -86,7 +86,7 @@ _efl_vg_root_node_eo_base_constructor(Eo *obj,
         return NULL;
    }
 
-   nd = eo_data_scope_get(obj, EFL_VG_BASE_CLASS);
+   nd = eo_data_scope_get(obj, EFL_VG_CLASS);
    nd->render_pre = _evas_vg_root_node_render_pre;
    nd->data = cd;
 

diff --git a/src/lib/evas/canvas/evas_vg_shape.c b/src/lib/evas/canvas/evas_vg_shape.c
index 527006a..80e4e03 100644 (file)
--- a/src/lib/evas/canvas/evas_vg_shape.c
+++ b/src/lib/evas/canvas/evas_vg_shape.c
@@ -17,7 +17,7 @@ struct _Efl_VG_Shape_Data
 };
 
 static void
-_efl_vg_shape_efl_vg_base_bounds_get(Eo *obj,
+_efl_vg_shape_efl_vg_bounds_get(Eo *obj,
                                     Efl_VG_Shape_Data *pd EINA_UNUSED,
                                     Eina_Rectangle *r)
 {
@@ -35,7 +35,7 @@ _efl_vg_shape_fill_set(Eo *obj EINA_UNUSED,
    pd->fill = eo_ref(f);
    eo_unref(tmp);
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 static Efl_VG *
@@ -90,7 +90,7 @@ _efl_vg_shape_stroke_fill_set(Eo *obj EINA_UNUSED,
    pd->stroke.fill = eo_ref(f);
    eo_unref(tmp);
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 static Efl_VG *
@@ -110,7 +110,7 @@ _efl_vg_shape_stroke_marker_set(Eo *obj EINA_UNUSED,
    pd->stroke.marker = eo_ref(m);
    eo_unref(tmp);
 
-   _efl_vg_base_changed(obj);
+   _efl_vg_changed(obj);
 }
 
 static Efl_VG_Shape *
@@ -125,10 +125,10 @@ _efl_vg_shape_render_pre(Eo *obj EINA_UNUSED,
                          Eina_Matrix3 *parent,
                          Ector_Surface *s,
                          void *data,
-                         Efl_VG_Base_Data *nd)
+                         Efl_VG_Data *nd)
 {
    Efl_VG_Shape_Data *pd = data;
-   Efl_VG_Base_Data *fill, *stroke_fill, *stroke_marker, *mask;
+   Efl_VG_Data *fill, *stroke_fill, *stroke_marker, *mask;
    double xn = nd->x, yn = nd->y ;
 
    if (!nd->changed) return ;
@@ -163,7 +163,7 @@ _efl_vg_shape_render_pre(Eo *obj EINA_UNUSED,
 static Eo *
 _efl_vg_shape_eo_base_constructor(Eo *obj, Efl_VG_Shape_Data *pd)
 {
-   Efl_VG_Base_Data *nd;
+   Efl_VG_Data *nd;
 
    obj = eo_constructor(eo_super(obj, MY_CLASS));
 
@@ -172,7 +172,7 @@ _efl_vg_shape_eo_base_constructor(Eo *obj, Efl_VG_Shape_Data *pd)
    efl_gfx_shape_stroke_cap_set(obj, EFL_GFX_CAP_BUTT);
    efl_gfx_shape_stroke_join_set(obj, EFL_GFX_JOIN_MITER);
 
-   nd = eo_data_scope_get(obj, EFL_VG_BASE_CLASS);
+   nd = eo_data_scope_get(obj, EFL_VG_CLASS);
    nd->render_pre = _efl_vg_shape_render_pre;
    nd->data = pd;
 
@@ -186,9 +186,9 @@ _efl_vg_shape_eo_base_destructor(Eo *obj, Efl_VG_Shape_Data *pd EINA_UNUSED)
 }
 
 static Eina_Bool
-_efl_vg_shape_efl_vg_base_interpolate(Eo *obj,
+_efl_vg_shape_efl_vg_interpolate(Eo *obj,
                                       Efl_VG_Shape_Data *pd,
-                                      const Efl_VG_Base *from, const Efl_VG_Base *to,
+                                      const Efl_VG *from, const Efl_VG *to,
                                       double pos_map)
 {
    Efl_VG_Shape_Data *fromd, *tod;
@@ -218,7 +218,7 @@ _efl_vg_shape_efl_vg_base_interpolate(Eo *obj,
 }
 
 static void
-_efl_vg_shape_efl_vg_base_dup(Eo *obj, Efl_VG_Shape_Data *pd EINA_UNUSED, const Efl_VG_Base *from)
+_efl_vg_shape_efl_vg_dup(Eo *obj, Efl_VG_Shape_Data *pd EINA_UNUSED, const Efl_VG *from)
 {
    Efl_VG_Shape_Data *fromd;
    Eo *parent;