Ector generic: Remove .Generic and .Base (hack no longer needed).

68 files changed, 551 insertions, 551 deletions

diff --git a/src/Makefile_Ector.am b/src/Makefile_Ector.am
index 63c8473bb9..ab0a404c6a 100644
--- a/src/Makefile_Ector.am
+++ b/src/Makefile_Ector.am
@@ -1,14 +1,14 @@
 
 ### Library
 ector_eolian_files_generic = \
-	lib/ector/ector_generic_surface.eo \
-	lib/ector/ector_generic_buffer.eo \
-	lib/ector/ector_renderer_generic_base.eo \
-	lib/ector/ector_renderer_generic_shape.eo \
-	lib/ector/ector_renderer_generic_buffer.eo \
-	lib/ector/ector_renderer_generic_gradient.eo \
-	lib/ector/ector_renderer_generic_gradient_radial.eo \
-	lib/ector/ector_renderer_generic_gradient_linear.eo
+	lib/ector/ector_surface.eo \
+	lib/ector/ector_buffer.eo \
+	lib/ector/ector_renderer.eo \
+	lib/ector/ector_renderer_shape.eo \
+	lib/ector/ector_renderer_buffer.eo \
+	lib/ector/ector_renderer_gradient.eo \
+	lib/ector/ector_renderer_gradient_radial.eo \
+	lib/ector/ector_renderer_gradient_linear.eo
 ector_eolian_generic_h = $(ector_eolian_files_generic:%.eo=%.eo.h)
 
 # Handle cairo backend
@@ -87,13 +87,13 @@ lib_LTLIBRARIES += lib/ector/libector.la
 lib_ector_libector_la_SOURCES = \
 lib/ector/ector_main.c \
 lib/ector/ector_gl_internal.h \
-lib/ector/ector_generic_buffer.c \
-lib/ector/ector_renderer_generic_shape.c \
-lib/ector/ector_renderer_generic_base.c \
-lib/ector/ector_renderer_generic_buffer.c \
-lib/ector/ector_renderer_generic_gradient.c \
-lib/ector/ector_renderer_generic_gradient_radial.c \
-lib/ector/ector_renderer_generic_gradient_linear.c
+lib/ector/ector_buffer.c \
+lib/ector/ector_renderer_shape.c \
+lib/ector/ector_renderer.c \
+lib/ector/ector_renderer_buffer.c \
+lib/ector/ector_renderer_gradient.c \
+lib/ector/ector_renderer_gradient_radial.c \
+lib/ector/ector_renderer_gradient_linear.c
 
 # And now the cairo backend
 lib_ector_libector_la_SOURCES += \
diff --git a/src/lib/ector/Makefile.am b/src/lib/ector/Makefile.am
index 2456f0dc2c..516170bea5 100644
--- a/src/lib/ector/Makefile.am
+++ b/src/lib/ector/Makefile.am
@@ -4,14 +4,14 @@ include ../../Makefile_Eolian_Subbuild_Helper.am
 
 ### Library
 ector_eolian_files_generic = \
-	ector_generic_surface.eo \
-	ector_generic_buffer.eo \
-	ector_renderer_generic_base.eo \
-	ector_renderer_generic_shape.eo \
-	ector_renderer_generic_buffer.eo \
-	ector_renderer_generic_gradient.eo \
-	ector_renderer_generic_gradient_radial.eo \
-	ector_renderer_generic_gradient_linear.eo
+	ector_surface.eo \
+	ector_buffer.eo \
+	ector_renderer.eo \
+	ector_renderer_shape.eo \
+	ector_renderer_buffer.eo \
+	ector_renderer_gradient.eo \
+	ector_renderer_gradient_radial.eo \
+	ector_renderer_gradient_linear.eo
 ector_eolian_generic_h = $(ector_eolian_files_generic:%.eo=%.eo.h)
 
 # Handle cairo backend
@@ -76,13 +76,13 @@ lib_LTLIBRARIES = libector.la
 libector_la_SOURCES = \
 ector_main.c \
 ector_gl_internal.h \
-ector_generic_buffer.c \
-ector_renderer_generic_shape.c \
-ector_renderer_generic_base.c \
-ector_renderer_generic_buffer.c \
-ector_renderer_generic_gradient.c \
-ector_renderer_generic_gradient_radial.c \
-ector_renderer_generic_gradient_linear.c
+ector_buffer.c \
+ector_renderer_shape.c \
+ector_renderer.c \
+ector_renderer_buffer.c \
+ector_renderer_gradient.c \
+ector_renderer_gradient_radial.c \
+ector_renderer_gradient_linear.c
 
 # And now the cairo backend
 libector_la_SOURCES += \
diff --git a/src/lib/ector/cairo/ector_cairo_private.h b/src/lib/ector/cairo/ector_cairo_private.h
index d8754351fd..a7a6d7661f 100644
--- a/src/lib/ector/cairo/ector_cairo_private.h
+++ b/src/lib/ector/cairo/ector_cairo_private.h
@@ -25,7 +25,7 @@ struct _Ector_Cairo_Surface_Data
 struct _Ector_Renderer_Cairo_Data
 {
    Ector_Cairo_Surface_Data *parent;
-   Ector_Renderer_Generic_Base_Data *generic;
+   Ector_Renderer_Data *generic;
 
    cairo_matrix_t *m;
 };
@@ -60,7 +60,7 @@ _ector_cairo_extent_get(Efl_Gfx_Gradient_Spread s)
   if (!Sym) return Error;
 
 static inline void *
-_ector_cairo_symbol_get(Ector_Renderer_Generic_Base_Data *base,
+_ector_cairo_symbol_get(Ector_Renderer_Data *base,
                         const char *name)
 {
    void *sym;
@@ -74,7 +74,7 @@ extern void (*cairo_pattern_add_color_stop_rgba)(cairo_pattern_t *pattern, doubl
 
 static inline void
 _ector_renderer_cairo_gradient_prepare(cairo_pattern_t *pat,
-                                       Ector_Renderer_Generic_Gradient_Data *src,
+                                       Ector_Renderer_Gradient_Data *src,
                                        unsigned int mul_col)
 {
    unsigned int i;
diff --git a/src/lib/ector/cairo/ector_cairo_software_surface.c b/src/lib/ector/cairo/ector_cairo_software_surface.c
index 2ce001e9f4..25bf3f86e6 100644
--- a/src/lib/ector/cairo/ector_cairo_software_surface.c
+++ b/src/lib/ector/cairo/ector_cairo_software_surface.c
@@ -50,7 +50,7 @@ struct _Ector_Cairo_Software_Surface_Data
 };
 
 EOLIAN static Eina_Bool
-_ector_cairo_software_surface_ector_generic_buffer_pixels_set(Eo *obj, Ector_Cairo_Software_Surface_Data *pd,
+_ector_cairo_software_surface_ector_buffer_pixels_set(Eo *obj, Ector_Cairo_Software_Surface_Data *pd,
                                                               void *pixels, int width, int height, int stride,
                                                               Efl_Gfx_Colorspace cspace, Eina_Bool writable,
                                                               unsigned char l, unsigned char r, unsigned char t, unsigned char b)
@@ -106,7 +106,7 @@ _ector_cairo_software_surface_eo_base_constructor(Eo *obj, Ector_Cairo_Software_
 
    if (!obj) return NULL;
    pd->base = eo_data_ref(obj, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN);
-   pd->base->generic = eo_data_ref(obj, ECTOR_GENERIC_BUFFER_MIXIN);
+   pd->base->generic = eo_data_ref(obj, ECTOR_BUFFER_MIXIN);
    pd->base->generic->eo = obj;
    return obj;
 }
diff --git a/src/lib/ector/cairo/ector_cairo_software_surface.eo b/src/lib/ector/cairo/ector_cairo_software_surface.eo
index 28df974d48..f835aa26d7 100644
--- a/src/lib/ector/cairo/ector_cairo_software_surface.eo
+++ b/src/lib/ector/cairo/ector_cairo_software_surface.eo
@@ -8,7 +8,7 @@ class Ector.Cairo_Software.Surface (Ector.Cairo.Surface, Ector.Software.Buffer.B
    legacy_prefix: null;
    methods {}
    implements {
-      Ector.Generic.Buffer.pixels_set;
+      Ector.Buffer.pixels_set;
       Eo.Base.constructor;
       Eo.Base.destructor;
    }
diff --git a/src/lib/ector/cairo/ector_cairo_surface.c b/src/lib/ector/cairo/ector_cairo_surface.c
index ae737e6d5a..540ce4e825 100644
--- a/src/lib/ector/cairo/ector_cairo_surface.c
+++ b/src/lib/ector/cairo/ector_cairo_surface.c
@@ -58,15 +58,15 @@ _ector_cairo_surface_symbol_get(Eo *obj EINA_UNUSED,
   if (!Sym) return Error;
 
 static Ector_Renderer *
-_ector_cairo_surface_ector_generic_surface_renderer_factory_new(Eo *obj,
+_ector_cairo_surface_ector_surface_renderer_factory_new(Eo *obj,
                                                                 Ector_Cairo_Surface_Data *pd EINA_UNUSED,
                                                                 const Eo_Class *type)
 {
-   if (type == ECTOR_RENDERER_GENERIC_SHAPE_MIXIN)
+   if (type == ECTOR_RENDERER_SHAPE_MIXIN)
      return eo_add(ECTOR_RENDERER_CAIRO_SHAPE_CLASS, NULL, ector_renderer_surface_set(eo_self, obj));
-   else if (type == ECTOR_RENDERER_GENERIC_GRADIENT_LINEAR_MIXIN)
+   else if (type == ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN)
      return eo_add(ECTOR_RENDERER_CAIRO_GRADIENT_LINEAR_CLASS, NULL, ector_renderer_surface_set(eo_self, obj));
-   else if (type == ECTOR_RENDERER_GENERIC_GRADIENT_RADIAL_MIXIN)
+   else if (type == ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN)
      return eo_add(ECTOR_RENDERER_CAIRO_GRADIENT_RADIAL_CLASS, NULL, ector_renderer_surface_set(eo_self, obj));
 
    ERR("Couldn't find class for type: %s\n", eo_class_name_get(type));
@@ -106,7 +106,7 @@ _ector_cairo_surface_context_get(Eo *obj EINA_UNUSED,
 }
 
 static void
-_ector_cairo_surface_ector_generic_surface_reference_point_set(Eo *obj EINA_UNUSED,
+_ector_cairo_surface_ector_surface_reference_point_set(Eo *obj EINA_UNUSED,
                                                                Ector_Cairo_Surface_Data *pd,
                                                                int x, int y)
 {
diff --git a/src/lib/ector/cairo/ector_cairo_surface.eo b/src/lib/ector/cairo/ector_cairo_surface.eo
index 95ca60b585..452db34b92 100644
--- a/src/lib/ector/cairo/ector_cairo_surface.eo
+++ b/src/lib/ector/cairo/ector_cairo_surface.eo
@@ -1,6 +1,6 @@
 type @extern cairo_t: void *;
 
-class Ector.Cairo.Surface (Eo.Base, Ector.Generic.Surface)
+class Ector.Cairo.Surface (Eo.Base, Ector.Surface)
 {
    [[Ector surface on a cairo backend
 
@@ -27,8 +27,8 @@ class Ector.Cairo.Surface (Eo.Base, Ector.Generic.Surface)
       }
    }
    implements {
-      Ector.Generic.Surface.renderer_factory_new;
-      Ector.Generic.Surface.reference_point.set;
+      Ector.Surface.renderer_factory_new;
+      Ector.Surface.reference_point.set;
       Eo.Base.destructor;
       Eo.Base.constructor;
    }
diff --git a/src/lib/ector/cairo/ector_renderer_cairo.c b/src/lib/ector/cairo/ector_renderer_cairo.c
index ee6e64b5a6..eca5d0cc4b 100644
--- a/src/lib/ector/cairo/ector_renderer_cairo.c
+++ b/src/lib/ector/cairo/ector_renderer_cairo.c
@@ -73,7 +73,7 @@ static cairo_matrix_t identity;
 
 // Cairo need unpremul color, so force unpremul here
 void
-_ector_renderer_cairo_ector_renderer_generic_base_color_set(Eo *obj EINA_UNUSED,
+_ector_renderer_cairo_ector_renderer_color_set(Eo *obj EINA_UNUSED,
                                                                  Ector_Renderer_Cairo_Data *pd,
                                                                  int r, int g, int b, int a)
 {
@@ -84,7 +84,7 @@ _ector_renderer_cairo_ector_renderer_generic_base_color_set(Eo *obj EINA_UNUSED,
 }
 
 void
-_ector_renderer_cairo_ector_renderer_generic_base_color_get(Eo *obj EINA_UNUSED,
+_ector_renderer_cairo_ector_renderer_color_get(Eo *obj EINA_UNUSED,
                                                                  Ector_Renderer_Cairo_Data *pd,
                                                                  int *r, int *g, int *b, int *a)
 {
@@ -95,7 +95,7 @@ _ector_renderer_cairo_ector_renderer_generic_base_color_get(Eo *obj EINA_UNUSED,
 }
 
 static Eina_Bool
-_ector_renderer_cairo_ector_renderer_generic_base_prepare(Eo *obj, Ector_Renderer_Cairo_Data *pd)
+_ector_renderer_cairo_ector_renderer_prepare(Eo *obj, Ector_Renderer_Cairo_Data *pd)
 {
    if (!pd->parent)
      {
@@ -119,7 +119,7 @@ _ector_renderer_cairo_ector_renderer_generic_base_prepare(Eo *obj, Ector_Rendere
 }
 
 static Eina_Bool
-_ector_renderer_cairo_ector_renderer_generic_base_draw(Eo *obj EINA_UNUSED,
+_ector_renderer_cairo_ector_renderer_draw(Eo *obj EINA_UNUSED,
                                                             Ector_Renderer_Cairo_Data *pd,
                                                             Efl_Gfx_Render_Op op,
                                                             Eina_Array *clips EINA_UNUSED,
@@ -185,7 +185,7 @@ _ector_renderer_cairo_eo_base_constructor(Eo *obj, Ector_Renderer_Cairo_Data *pd
    obj = eo_constructor(eo_super(obj, ECTOR_RENDERER_CAIRO_CLASS));
    if (!obj) return NULL;
 
-   pd->generic = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS, obj);
+   pd->generic = eo_data_xref(obj, ECTOR_RENDERER_CLASS, obj);
 
    return obj;
 }
@@ -215,9 +215,9 @@ _ector_renderer_cairo_eo_base_finalize(Eo *obj, Ector_Renderer_Cairo_Data *pd)
 static void
 _ector_renderer_cairo_eo_base_destructor(Eo *obj, Ector_Renderer_Cairo_Data *pd)
 {
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Data *base;
 
-   base = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS);
+   base = eo_data_scope_get(obj, ECTOR_RENDERER_CLASS);
    eo_data_xunref(base->surface, pd->parent, obj);
    eo_data_xunref(obj, pd->generic, obj);
 
diff --git a/src/lib/ector/cairo/ector_renderer_cairo.eo b/src/lib/ector/cairo/ector_renderer_cairo.eo
index 9da20ecbe3..56e3632c8e 100644
--- a/src/lib/ector/cairo/ector_renderer_cairo.eo
+++ b/src/lib/ector/cairo/ector_renderer_cairo.eo
@@ -1,4 +1,4 @@
-abstract Ector.Renderer.Cairo (Ector.Renderer.Generic.Base)
+abstract Ector.Renderer.Cairo (Ector.Renderer)
 {
    legacy_prefix: null;
    methods {
@@ -11,10 +11,10 @@ abstract Ector.Renderer.Cairo (Ector.Renderer.Generic.Base)
    }
    implements {
       @virtual .fill;
-      Ector.Renderer.Generic.Base.prepare;
-      Ector.Renderer.Generic.Base.draw;
-      Ector.Renderer.Generic.Base.color.set;
-      Ector.Renderer.Generic.Base.color.get;
+      Ector.Renderer.prepare;
+      Ector.Renderer.draw;
+      Ector.Renderer.color.set;
+      Ector.Renderer.color.get;
       Eo.Base.constructor;
       Eo.Base.finalize;
       Eo.Base.destructor;
diff --git a/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.c b/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.c
index 130c4b76bf..757d5c8af4 100644
--- a/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.c
+++ b/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.c
@@ -28,8 +28,8 @@ struct _Ector_Renderer_Cairo_Gradient_Linear_Data
 
 static cairo_pattern_t *
 _ector_renderer_cairo_gradient_linear_prepare(Eo *obj EINA_UNUSED,
-                                              Ector_Renderer_Generic_Gradient_Linear_Data *gld,
-                                              Ector_Renderer_Generic_Gradient_Data *gd,
+                                              Ector_Renderer_Gradient_Linear_Data *gld,
+                                              Ector_Renderer_Gradient_Data *gd,
                                               unsigned int mul_col)
 {
    cairo_pattern_t *pat;
@@ -45,16 +45,16 @@ _ector_renderer_cairo_gradient_linear_prepare(Eo *obj EINA_UNUSED,
 }
 
 static Eina_Bool
-_ector_renderer_cairo_gradient_linear_ector_renderer_generic_base_prepare(Eo *obj,
+_ector_renderer_cairo_gradient_linear_ector_renderer_prepare(Eo *obj,
                                                                           Ector_Renderer_Cairo_Gradient_Linear_Data *pd)
 {
    ector_renderer_prepare(eo_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_LINEAR_CLASS));
 
    if (!pd->parent)
      {
-        Ector_Renderer_Generic_Base_Data *base;
+        Ector_Renderer_Data *base;
 
-        base = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS);
+        base = eo_data_scope_get(obj, ECTOR_RENDERER_CLASS);
         pd->parent = eo_data_xref(base->surface, ECTOR_CAIRO_SURFACE_CLASS, obj);
      }
 
@@ -62,17 +62,17 @@ _ector_renderer_cairo_gradient_linear_ector_renderer_generic_base_prepare(Eo *ob
 }
 
 static Eina_Bool
-_ector_renderer_cairo_gradient_linear_ector_renderer_generic_base_draw(Eo *obj,
+_ector_renderer_cairo_gradient_linear_ector_renderer_draw(Eo *obj,
                                                                        Ector_Renderer_Cairo_Gradient_Linear_Data *pd,
                                                                        Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
 {
-   Ector_Renderer_Generic_Gradient_Linear_Data *gld;
-   Ector_Renderer_Generic_Gradient_Data *gd;
+   Ector_Renderer_Gradient_Linear_Data *gld;
+   Ector_Renderer_Gradient_Data *gd;
    cairo_pattern_t *pat;
 
    // FIXME: don't ignore clipping !
-   gld = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_LINEAR_MIXIN);
-   gd = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_MIXIN);
+   gld = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN);
+   gd = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_MIXIN);
    if (!gd || !gld) return EINA_FALSE;
 
    pat = _ector_renderer_cairo_gradient_linear_prepare(obj, gld, gd, mul_col);
@@ -95,12 +95,12 @@ _ector_renderer_cairo_gradient_linear_ector_renderer_cairo_fill(Eo *obj,
                                                                      Ector_Renderer_Cairo_Gradient_Linear_Data *pd,
                                                                      unsigned int mul_col)
 {
-   Ector_Renderer_Generic_Gradient_Linear_Data *gld;
-   Ector_Renderer_Generic_Gradient_Data *gd;
+   Ector_Renderer_Gradient_Linear_Data *gld;
+   Ector_Renderer_Gradient_Data *gd;
    cairo_pattern_t *pat;
 
-   gld = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_LINEAR_MIXIN);
-   gd = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_MIXIN);
+   gld = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN);
+   gd = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_MIXIN);
    if (!gd || !gld) return EINA_FALSE;
 
    pat = _ector_renderer_cairo_gradient_linear_prepare(obj, gld, gd, mul_col);
@@ -113,14 +113,14 @@ _ector_renderer_cairo_gradient_linear_ector_renderer_cairo_fill(Eo *obj,
 }
 
 static void
-_ector_renderer_cairo_gradient_linear_ector_renderer_generic_base_bounds_get(Eo *obj,
+_ector_renderer_cairo_gradient_linear_ector_renderer_bounds_get(Eo *obj,
                                                                              Ector_Renderer_Cairo_Gradient_Linear_Data *pd EINA_UNUSED,
                                                                              Eina_Rectangle *r)
 {
-   Ector_Renderer_Generic_Gradient_Linear_Data *gld;
+   Ector_Renderer_Gradient_Linear_Data *gld;
    Ector_Renderer_Cairo_Data *bd;
 
-   gld = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_RADIAL_MIXIN);
+   gld = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN);
    bd = eo_data_scope_get(obj, ECTOR_RENDERER_CAIRO_CLASS);
    EINA_RECTANGLE_SET(r,
                       bd->generic->origin.x + gld->start.x,
@@ -132,12 +132,12 @@ _ector_renderer_cairo_gradient_linear_ector_renderer_generic_base_bounds_get(Eo
 static Eo_Base *
 _ector_renderer_cairo_gradient_linear_eo_base_finalize(Eo *obj, Ector_Renderer_Cairo_Gradient_Linear_Data *pd EINA_UNUSED)
 {
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Data *base;
 
    obj = eo_finalize(eo_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_LINEAR_CLASS));
    if (!obj) return NULL;
 
-   base = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS);
+   base = eo_data_scope_get(obj, ECTOR_RENDERER_CLASS);
 
    USE(base, cairo_set_source, NULL);
    USE(base, cairo_pattern_destroy, NULL);
@@ -156,9 +156,9 @@ static void
 _ector_renderer_cairo_gradient_linear_eo_base_destructor(Eo *obj,
                                                          Ector_Renderer_Cairo_Gradient_Linear_Data *pd)
 {
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Data *base;
 
-   base = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS);
+   base = eo_data_scope_get(obj, ECTOR_RENDERER_CLASS);
    eo_data_xunref(base->surface, pd->parent, obj);
 
    eo_destructor(eo_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_LINEAR_CLASS));
@@ -174,22 +174,22 @@ _ector_renderer_cairo_gradient_linear_efl_gfx_gradient_stop_set(Eo *obj,
 }
 
 static unsigned int
-_ector_renderer_cairo_gradient_linear_ector_renderer_generic_base_crc_get(Eo *obj, Ector_Renderer_Cairo_Gradient_Linear_Data *pd EINA_UNUSED)
+_ector_renderer_cairo_gradient_linear_ector_renderer_crc_get(Eo *obj, Ector_Renderer_Cairo_Gradient_Linear_Data *pd EINA_UNUSED)
 {
-   Ector_Renderer_Generic_Gradient_Linear_Data *gld;
-   Ector_Renderer_Generic_Gradient_Data *gd;
+   Ector_Renderer_Gradient_Linear_Data *gld;
+   Ector_Renderer_Gradient_Data *gd;
    unsigned int crc;
 
    crc = ector_renderer_crc_get(eo_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_LINEAR_CLASS));
 
-   gld = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_LINEAR_MIXIN);
-   gd = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_MIXIN);
+   gld = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN);
+   gd = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_MIXIN);
    if (!gd || !gld) return crc;
 
    crc = eina_crc((void*) gd->s, sizeof (Efl_Gfx_Gradient_Spread), crc, EINA_FALSE);
    if (gd->colors_count)
      crc = eina_crc((void*) gd->colors, sizeof (Efl_Gfx_Gradient_Stop) * gd->colors_count, crc, EINA_FALSE);
-   crc = eina_crc((void*) gld, sizeof (Ector_Renderer_Generic_Gradient_Linear_Data), crc, EINA_FALSE);
+   crc = eina_crc((void*) gld, sizeof (Ector_Renderer_Gradient_Linear_Data), crc, EINA_FALSE);
 
    return crc;
 }
diff --git a/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.eo b/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.eo
index 8111ebed1c..3ecbd30c7c 100644
--- a/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.eo
+++ b/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.eo
@@ -1,12 +1,12 @@
-class Ector.Renderer.Cairo.Gradient_Linear (Ector.Renderer.Cairo, Ector.Renderer.Generic.Gradient, Ector.Renderer.Generic.Gradient_Linear)
+class Ector.Renderer.Cairo.Gradient_Linear (Ector.Renderer.Cairo, Ector.Renderer.Gradient, Ector.Renderer.Gradient_Linear)
 {
    eo_prefix: ector_renderer_cairo_gradient_linear;
    legacy_prefix: null;
    implements {
-      Ector.Renderer.Generic.Base.prepare;
-      Ector.Renderer.Generic.Base.draw;
-      Ector.Renderer.Generic.Base.bounds_get;
-      Ector.Renderer.Generic.Base.crc.get;
+      Ector.Renderer.prepare;
+      Ector.Renderer.draw;
+      Ector.Renderer.bounds_get;
+      Ector.Renderer.crc.get;
       Ector.Renderer.Cairo.fill;
       Eo.Base.finalize;
       Eo.Base.destructor;
diff --git a/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.c b/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.c
index 209630cd4e..97d0417fbd 100644
--- a/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.c
+++ b/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.c
@@ -32,15 +32,15 @@ struct _Ector_Renderer_Cairo_Gradient_Radial_Data
 };
 
 static Eina_Bool
-_ector_renderer_cairo_gradient_radial_ector_renderer_generic_base_prepare(Eo *obj, Ector_Renderer_Cairo_Gradient_Radial_Data *pd)
+_ector_renderer_cairo_gradient_radial_ector_renderer_prepare(Eo *obj, Ector_Renderer_Cairo_Gradient_Radial_Data *pd)
 {
    ector_renderer_prepare(eo_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_RADIAL_CLASS));
 
    if (!pd->parent)
      {
-        Ector_Renderer_Generic_Base_Data *base;
+        Ector_Renderer_Data *base;
 
-        base = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS);
+        base = eo_data_scope_get(obj, ECTOR_RENDERER_CLASS);
         pd->parent = eo_data_xref(base->surface, ECTOR_CAIRO_SURFACE_CLASS, obj);
      }
 
@@ -49,8 +49,8 @@ _ector_renderer_cairo_gradient_radial_ector_renderer_generic_base_prepare(Eo *ob
 
 static cairo_pattern_t *
 _ector_renderer_cairo_gradient_radial_prepare(Eo *obj EINA_UNUSED,
-                                              Ector_Renderer_Generic_Gradient_Radial_Data *grd,
-                                              Ector_Renderer_Generic_Gradient_Data *gd,
+                                              Ector_Renderer_Gradient_Radial_Data *grd,
+                                              Ector_Renderer_Gradient_Data *gd,
                                               unsigned int mul_col)
 {
    cairo_pattern_t *pat;
@@ -68,15 +68,15 @@ _ector_renderer_cairo_gradient_radial_prepare(Eo *obj EINA_UNUSED,
 
 // Clearly duplicated and should be in a common place...
 static Eina_Bool
-_ector_renderer_cairo_gradient_radial_ector_renderer_generic_base_draw(Eo *obj, Ector_Renderer_Cairo_Gradient_Radial_Data *pd, Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
+_ector_renderer_cairo_gradient_radial_ector_renderer_draw(Eo *obj, Ector_Renderer_Cairo_Gradient_Radial_Data *pd, Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
 {
-   Ector_Renderer_Generic_Gradient_Radial_Data *grd;
-   Ector_Renderer_Generic_Gradient_Data *gd;
+   Ector_Renderer_Gradient_Radial_Data *grd;
+   Ector_Renderer_Gradient_Data *gd;
    cairo_pattern_t *pat;
 
    // FIXME: Handle clipping and generally make it work :-)
-   grd = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_RADIAL_MIXIN);
-   gd = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_MIXIN);
+   grd = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN);
+   gd = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_MIXIN);
    if (!grd || !gd) return EINA_FALSE;
 
    pat = _ector_renderer_cairo_gradient_radial_prepare(obj, grd, gd, mul_col);
@@ -101,12 +101,12 @@ _ector_renderer_cairo_gradient_radial_ector_renderer_cairo_fill(Eo *obj,
                                                                      Ector_Renderer_Cairo_Gradient_Radial_Data *pd,
                                                                      unsigned int mul_col)
 {
-   Ector_Renderer_Generic_Gradient_Radial_Data *grd;
-   Ector_Renderer_Generic_Gradient_Data *gd;
+   Ector_Renderer_Gradient_Radial_Data *grd;
+   Ector_Renderer_Gradient_Data *gd;
    cairo_pattern_t *pat;
 
-   grd = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_RADIAL_MIXIN);
-   gd = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_MIXIN);
+   grd = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN);
+   gd = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_MIXIN);
    if (!grd || !gd) return EINA_FALSE;
 
    pat = _ector_renderer_cairo_gradient_radial_prepare(obj, grd, gd, mul_col);
@@ -119,14 +119,14 @@ _ector_renderer_cairo_gradient_radial_ector_renderer_cairo_fill(Eo *obj,
 }
 
 static void
-_ector_renderer_cairo_gradient_radial_ector_renderer_generic_base_bounds_get(Eo *obj EINA_UNUSED,
+_ector_renderer_cairo_gradient_radial_ector_renderer_bounds_get(Eo *obj EINA_UNUSED,
                                                                              Ector_Renderer_Cairo_Gradient_Radial_Data *pd EINA_UNUSED,
                                                                              Eina_Rectangle *r)
 {
-   Ector_Renderer_Generic_Gradient_Radial_Data *gld;
+   Ector_Renderer_Gradient_Radial_Data *gld;
    Ector_Renderer_Cairo_Data *bd;
 
-   gld = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_RADIAL_MIXIN);
+   gld = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN);
    bd = eo_data_scope_get(obj, ECTOR_RENDERER_CAIRO_CLASS);
    EINA_RECTANGLE_SET(r,
                       bd->generic->origin.x + gld->radial.x - gld->radius,
@@ -137,12 +137,12 @@ _ector_renderer_cairo_gradient_radial_ector_renderer_generic_base_bounds_get(Eo
 static Eo_Base *
 _ector_renderer_cairo_gradient_radial_eo_base_finalize(Eo *obj, Ector_Renderer_Cairo_Gradient_Radial_Data *pd EINA_UNUSED)
 {
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Data *base;
 
    obj = eo_finalize(eo_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_RADIAL_CLASS));
    if (!obj) return NULL;
 
-   base = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS);
+   base = eo_data_scope_get(obj, ECTOR_RENDERER_CLASS);
 
    USE(base, cairo_set_source, NULL);
    USE(base, cairo_pattern_destroy, NULL);
@@ -160,9 +160,9 @@ static void
 _ector_renderer_cairo_gradient_radial_eo_base_destructor(Eo *obj,
                                                          Ector_Renderer_Cairo_Gradient_Radial_Data *pd)
 {
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Data *base;
 
-   base = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS);
+   base = eo_data_scope_get(obj, ECTOR_RENDERER_CLASS);
    eo_data_xunref(base->surface, pd->parent, obj);
 
    eo_destructor(eo_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_RADIAL_CLASS));
@@ -178,22 +178,22 @@ _ector_renderer_cairo_gradient_radial_efl_gfx_gradient_stop_set(Eo *obj,
 }
 
 static unsigned int
-_ector_renderer_cairo_gradient_radial_ector_renderer_generic_base_crc_get(Eo *obj, Ector_Renderer_Cairo_Gradient_Radial_Data *pd EINA_UNUSED)
+_ector_renderer_cairo_gradient_radial_ector_renderer_crc_get(Eo *obj, Ector_Renderer_Cairo_Gradient_Radial_Data *pd EINA_UNUSED)
 {
-   Ector_Renderer_Generic_Gradient_Radial_Data *grd;
-   Ector_Renderer_Generic_Gradient_Data *gd;
+   Ector_Renderer_Gradient_Radial_Data *grd;
+   Ector_Renderer_Gradient_Data *gd;
    unsigned int crc;
 
    crc = ector_renderer_crc_get(eo_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_RADIAL_CLASS));
 
-   grd = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_RADIAL_MIXIN);
-   gd = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_GRADIENT_MIXIN);
+   grd = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN);
+   gd = eo_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_MIXIN);
    if (!grd || !gd) return crc;
 
    crc = eina_crc((void*) gd->s, sizeof (Efl_Gfx_Gradient_Spread), crc, EINA_FALSE);
    if (gd->colors_count)
      crc = eina_crc((void*) gd->colors, sizeof (Efl_Gfx_Gradient_Stop) * gd->colors_count, crc, EINA_FALSE);
-   crc = eina_crc((void*) grd, sizeof (Ector_Renderer_Generic_Gradient_Radial_Data), crc, EINA_FALSE);
+   crc = eina_crc((void*) grd, sizeof (Ector_Renderer_Gradient_Radial_Data), crc, EINA_FALSE);
 
    return crc;
 }
diff --git a/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.eo b/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.eo
index a4f2de3acb..a0d6f5e792 100644
--- a/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.eo
+++ b/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.eo
@@ -1,12 +1,12 @@
-class Ector.Renderer.Cairo.Gradient_Radial (Ector.Renderer.Cairo, Ector.Renderer.Generic.Gradient, Ector.Renderer.Generic.Gradient_Radial)
+class Ector.Renderer.Cairo.Gradient_Radial (Ector.Renderer.Cairo, Ector.Renderer.Gradient, Ector.Renderer.Gradient_Radial)
 {
    eo_prefix: ector_renderer_cairo_gradient_radial;
    legacy_prefix: null;
    implements {
-      Ector.Renderer.Generic.Base.prepare;
-      Ector.Renderer.Generic.Base.draw;
-      Ector.Renderer.Generic.Base.bounds_get;
-      Ector.Renderer.Generic.Base.crc.get;
+      Ector.Renderer.prepare;
+      Ector.Renderer.draw;
+      Ector.Renderer.bounds_get;
+      Ector.Renderer.crc.get;
       Ector.Renderer.Cairo.fill;
       Eo.Base.destructor;
       Eo.Base.finalize;
diff --git a/src/lib/ector/cairo/ector_renderer_cairo_shape.c b/src/lib/ector/cairo/ector_renderer_cairo_shape.c
index 66d2cca9f6..ba423a29fa 100644
--- a/src/lib/ector/cairo/ector_renderer_cairo_shape.c
+++ b/src/lib/ector/cairo/ector_renderer_cairo_shape.c
@@ -69,8 +69,8 @@ struct _Ector_Renderer_Cairo_Shape_Data
    Efl_Gfx_Shape_Public *public_shape;
 
    Ector_Cairo_Surface_Data *parent;
-   Ector_Renderer_Generic_Shape_Data *shape;
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Shape_Data *shape;
+   Ector_Renderer_Data *base;
 
    cairo_path_t *path;
 };
@@ -87,7 +87,7 @@ _ector_renderer_cairo_shape_path_changed(void *data, const Eo_Event *event EINA_
 }
 
 static Eina_Bool
-_ector_renderer_cairo_shape_ector_renderer_generic_base_prepare(Eo *obj, Ector_Renderer_Cairo_Shape_Data *pd)
+_ector_renderer_cairo_shape_ector_renderer_prepare(Eo *obj, Ector_Renderer_Cairo_Shape_Data *pd)
 {
    const Efl_Gfx_Path_Command *cmds = NULL;
    const double *pts = NULL;
@@ -104,9 +104,9 @@ _ector_renderer_cairo_shape_ector_renderer_generic_base_prepare(Eo *obj, Ector_R
    // shouldn't that be moved to the cairo base object
    if (!pd->parent)
      {
-        Ector_Renderer_Generic_Base_Data *base;
+        Ector_Renderer_Data *base;
 
-        base = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS);
+        base = eo_data_scope_get(obj, ECTOR_RENDERER_CLASS);
         pd->parent = eo_data_xref(base->surface, ECTOR_CAIRO_SURFACE_CLASS, obj);
      }
 
@@ -153,7 +153,7 @@ _ector_renderer_cairo_shape_ector_renderer_generic_base_prepare(Eo *obj, Ector_R
 }
 
 static Eina_Bool
-_ector_renderer_cairo_shape_ector_renderer_generic_base_draw(Eo *obj, Ector_Renderer_Cairo_Shape_Data *pd, Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
+_ector_renderer_cairo_shape_ector_renderer_draw(Eo *obj, Ector_Renderer_Cairo_Shape_Data *pd, Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
 {
    int r, g, b, a;
    unsigned i;
@@ -233,7 +233,7 @@ _ector_renderer_cairo_shape_ector_renderer_cairo_fill(Eo *obj EINA_UNUSED,
 }
 
 static void
-_ector_renderer_cairo_shape_ector_renderer_generic_base_bounds_get(Eo *obj,
+_ector_renderer_cairo_shape_ector_renderer_bounds_get(Eo *obj,
                                                                    Ector_Renderer_Cairo_Shape_Data *pd EINA_UNUSED,
                                                                    Eina_Rectangle *r)
 {
@@ -255,8 +255,8 @@ _ector_renderer_cairo_shape_eo_base_constructor(Eo *obj, Ector_Renderer_Cairo_Sh
    if (!obj) return NULL;
 
    pd->public_shape = eo_data_xref(obj, EFL_GFX_SHAPE_MIXIN, obj);
-   pd->shape = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_SHAPE_MIXIN, obj);
-   pd->base = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS, obj);
+   pd->shape = eo_data_xref(obj, ECTOR_RENDERER_SHAPE_MIXIN, obj);
+   pd->base = eo_data_xref(obj, ECTOR_RENDERER_CLASS, obj);
 
    eo_event_callback_add(obj, EFL_GFX_PATH_CHANGED, _ector_renderer_cairo_shape_path_changed, pd);
 
@@ -295,13 +295,13 @@ _ector_renderer_cairo_shape_eo_base_finalize(Eo *obj, Ector_Renderer_Cairo_Shape
 void
 _ector_renderer_cairo_shape_eo_base_destructor(Eo *obj, Ector_Renderer_Cairo_Shape_Data *pd)
 {
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Data *base;
 
    //FIXME, As base class  destructor can't call destructor of mixin class.
    // call explicit API to free shape data.
    efl_gfx_shape_reset(obj);
 
-   base = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS);
+   base = eo_data_scope_get(obj, ECTOR_RENDERER_CLASS);
    eo_data_xunref(base->surface, pd->parent, obj);
 
    eo_data_xunref(obj, pd->shape, obj);
@@ -313,7 +313,7 @@ _ector_renderer_cairo_shape_eo_base_destructor(Eo *obj, Ector_Renderer_Cairo_Sha
 }
 
 unsigned int
-_ector_renderer_cairo_shape_ector_renderer_generic_base_crc_get(Eo *obj,
+_ector_renderer_cairo_shape_ector_renderer_crc_get(Eo *obj,
                                                                 Ector_Renderer_Cairo_Shape_Data *pd)
 {
    unsigned int crc;
diff --git a/src/lib/ector/cairo/ector_renderer_cairo_shape.eo b/src/lib/ector/cairo/ector_renderer_cairo_shape.eo
index aeeb03007d..9d19fbf557 100644
--- a/src/lib/ector/cairo/ector_renderer_cairo_shape.eo
+++ b/src/lib/ector/cairo/ector_renderer_cairo_shape.eo
@@ -1,12 +1,12 @@
-class Ector.Renderer.Cairo.Shape (Ector.Renderer.Cairo, Ector.Renderer.Generic.Shape)
+class Ector.Renderer.Cairo.Shape (Ector.Renderer.Cairo, Ector.Renderer.Shape)
 {
    eo_prefix: ector_renderer_cairo_shape;
    legacy_prefix: null;
    implements {
-      Ector.Renderer.Generic.Base.prepare;
-      Ector.Renderer.Generic.Base.draw;
-      Ector.Renderer.Generic.Base.bounds_get;
-      Ector.Renderer.Generic.Base.crc.get;
+      Ector.Renderer.prepare;
+      Ector.Renderer.draw;
+      Ector.Renderer.bounds_get;
+      Ector.Renderer.crc.get;
       Ector.Renderer.Cairo.fill;
       Eo.Base.constructor;
       Eo.Base.finalize;
diff --git a/src/lib/ector/ector_buffer.c b/src/lib/ector/ector_buffer.c
new file mode 100644
index 0000000000..9fe9ed6930
--- /dev/null
+++ b/src/lib/ector/ector_buffer.c
@@ -0,0 +1,40 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#else
+# define EFL_BETA_API_SUPPORT
+#endif
+
+#include <Eo.h>
+#include "ector_private.h"
+#include "ector_buffer.eo.h"
+
+EOLIAN static Efl_Gfx_Colorspace
+_ector_buffer_cspace_get(Eo *obj EINA_UNUSED, Ector_Buffer_Data *pd)
+{
+   return pd->cspace;
+}
+
+EOLIAN static void
+_ector_buffer_border_get(Eo *obj EINA_UNUSED, Ector_Buffer_Data *pd EINA_UNUSED, int *l, int *r, int *t, int *b)
+{
+   if (l) *l = pd->l;
+   if (r) *r = pd->r;
+   if (t) *t = pd->t;
+   if (b) *b = pd->b;
+}
+
+EOLIAN static void
+_ector_buffer_size_get(Eo *obj EINA_UNUSED, Ector_Buffer_Data *pd, int *w, int *h)
+{
+   if (w) *w = pd->w;
+   if (h) *h = pd->h;
+}
+
+EOLIAN static Ector_Buffer_Flag
+_ector_buffer_flags_get(Eo *obj EINA_UNUSED, Ector_Buffer_Data *pd EINA_UNUSED)
+{
+   return ECTOR_BUFFER_FLAG_NONE;
+}
+
+#include "ector_buffer.eo.c"
+#include "ector_surface.eo.c"
diff --git a/src/lib/ector/ector_generic_buffer.eo b/src/lib/ector/ector_buffer.eo
index a1377a0d9a..13b14bde3a 100644
--- a/src/lib/ector/ector_generic_buffer.eo
+++ b/src/lib/ector/ector_buffer.eo
@@ -21,7 +21,7 @@ enum Ector.Buffer.Access_Flag {
    cow       = 0x4, [[Forces copy-on-write if already mapped as read-only. Requires write.]]
 }
 
-mixin Ector.Generic.Buffer
+mixin Ector.Buffer
 {
    [[2D pixel buffer interface for Ector
      @since 1.17
diff --git a/src/lib/ector/ector_buffer.h b/src/lib/ector/ector_buffer.h
index 0db6cc7d69..8a893f00c8 100644
--- a/src/lib/ector/ector_buffer.h
+++ b/src/lib/ector/ector_buffer.h
@@ -3,20 +3,20 @@
 
 #include <Ector.h>
 
-#include "ector_generic_buffer.eo.h"
+#include "ector_buffer.eo.h"
 #include "software/ector_software_buffer_base.eo.h"
 
 /**
  * @typedef Ector_Buffer
  * A generic pixel buffer type (2D). May be readable or writeable or both.
  */
-typedef Ector_Generic_Buffer Ector_Buffer;
+typedef Ector_Buffer Ector_Buffer;
 
-typedef struct _Ector_Generic_Buffer_Data Ector_Generic_Buffer_Data;
+typedef struct _Ector_Buffer_Data Ector_Buffer_Data;
 typedef struct _Ector_Software_Buffer_Base_Data Ector_Software_Buffer_Base_Data;
 typedef struct _Ector_GL_Buffer_Base_Data Ector_GL_Buffer_Base_Data;
 
-struct _Ector_Generic_Buffer_Data
+struct _Ector_Buffer_Data
 {
    Ector_Buffer       *eo;
    unsigned int        w, h;
@@ -27,7 +27,7 @@ struct _Ector_Generic_Buffer_Data
 
 struct _Ector_Software_Buffer_Base_Data
 {
-   Ector_Generic_Buffer_Data *generic;
+   Ector_Buffer_Data *generic;
    union {
       unsigned int     *u32;
       unsigned char    *u8;
@@ -43,7 +43,7 @@ struct _Ector_Software_Buffer_Base_Data
 
 struct _Ector_GL_Buffer_Base_Data
 {
-   Ector_Generic_Buffer_Data *generic;
+   Ector_Buffer_Data *generic;
    int texid;
    int fboid;
    struct {
diff --git a/src/lib/ector/ector_generic_buffer.c b/src/lib/ector/ector_generic_buffer.c
deleted file mode 100644
index 9c97ff8e91..0000000000
--- a/src/lib/ector/ector_generic_buffer.c
+++ /dev/null
@@ -1,40 +0,0 @@
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#else
-# define EFL_BETA_API_SUPPORT
-#endif
-
-#include <Eo.h>
-#include "ector_private.h"
-#include "ector_generic_buffer.eo.h"
-
-EOLIAN static Efl_Gfx_Colorspace
-_ector_generic_buffer_cspace_get(Eo *obj EINA_UNUSED, Ector_Generic_Buffer_Data *pd)
-{
-   return pd->cspace;
-}
-
-EOLIAN static void
-_ector_generic_buffer_border_get(Eo *obj EINA_UNUSED, Ector_Generic_Buffer_Data *pd EINA_UNUSED, int *l, int *r, int *t, int *b)
-{
-   if (l) *l = pd->l;
-   if (r) *r = pd->r;
-   if (t) *t = pd->t;
-   if (b) *b = pd->b;
-}
-
-EOLIAN static void
-_ector_generic_buffer_size_get(Eo *obj EINA_UNUSED, Ector_Generic_Buffer_Data *pd, int *w, int *h)
-{
-   if (w) *w = pd->w;
-   if (h) *h = pd->h;
-}
-
-EOLIAN static Ector_Buffer_Flag
-_ector_generic_buffer_flags_get(Eo *obj EINA_UNUSED, Ector_Generic_Buffer_Data *pd EINA_UNUSED)
-{
-   return ECTOR_BUFFER_FLAG_NONE;
-}
-
-#include "ector_generic_buffer.eo.c"
-#include "ector_generic_surface.eo.c"
diff --git a/src/lib/ector/ector_private.h b/src/lib/ector/ector_private.h
index 450a4ba941..6bda277326 100644
--- a/src/lib/ector/ector_private.h
+++ b/src/lib/ector/ector_private.h
@@ -60,16 +60,16 @@ _eo_xrefplace(Eo **d, Eo *s, const Eo *ref_obj)
    return *d;
 }
 
-typedef struct _Ector_Renderer_Generic_Base_Data Ector_Renderer_Generic_Base_Data;
-typedef struct _Ector_Renderer_Generic_Gradient_Data Ector_Renderer_Generic_Gradient_Data;
-typedef struct _Ector_Renderer_Generic_Gradient_Linear_Data Ector_Renderer_Generic_Gradient_Linear_Data;
-typedef struct _Ector_Renderer_Generic_Gradient_Radial_Data Ector_Renderer_Generic_Gradient_Radial_Data;
-typedef struct _Ector_Renderer_Generic_Shape_Data Ector_Renderer_Generic_Shape_Data;
-typedef struct _Ector_Renderer_Generic_Buffer_Data Ector_Renderer_Generic_Buffer_Data;
-
-struct _Ector_Renderer_Generic_Base_Data
+typedef struct _Ector_Renderer_Data Ector_Renderer_Data;
+typedef struct _Ector_Renderer_Gradient_Data Ector_Renderer_Gradient_Data;
+typedef struct _Ector_Renderer_Gradient_Linear_Data Ector_Renderer_Gradient_Linear_Data;
+typedef struct _Ector_Renderer_Gradient_Radial_Data Ector_Renderer_Gradient_Radial_Data;
+typedef struct _Ector_Renderer_Shape_Data Ector_Renderer_Shape_Data;
+typedef struct _Ector_Renderer_Buffer_Data Ector_Renderer_Buffer_Data;
+
+struct _Ector_Renderer_Data
 {
-   Ector_Generic_Surface *surface;
+   Ector_Surface *surface;
    Eina_Matrix3 *m;
 
    struct {
@@ -88,7 +88,7 @@ struct _Ector_Renderer_Generic_Base_Data
    Eina_Bool finalized : 1;
 };
 
-struct _Ector_Renderer_Generic_Gradient_Data
+struct _Ector_Renderer_Gradient_Data
 {
    Efl_Gfx_Gradient_Stop *colors;
    unsigned int colors_count;
@@ -96,14 +96,14 @@ struct _Ector_Renderer_Generic_Gradient_Data
    Efl_Gfx_Gradient_Spread s;
 };
 
-struct _Ector_Renderer_Generic_Gradient_Linear_Data
+struct _Ector_Renderer_Gradient_Linear_Data
 {
    struct {
       double x, y;
    } start, end;
 };
 
-struct _Ector_Renderer_Generic_Gradient_Radial_Data
+struct _Ector_Renderer_Gradient_Radial_Data
 {
    struct {
       double x, y;
@@ -111,7 +111,7 @@ struct _Ector_Renderer_Generic_Gradient_Radial_Data
    double radius;
 };
 
-struct _Ector_Renderer_Generic_Shape_Data
+struct _Ector_Renderer_Shape_Data
 {
    Ector_Renderer *fill;
    struct {
@@ -120,7 +120,7 @@ struct _Ector_Renderer_Generic_Shape_Data
    } stroke;
 };
 
-struct _Ector_Renderer_Generic_Buffer_Data
+struct _Ector_Renderer_Buffer_Data
 {
    Ector_Buffer *eo_buffer;
    struct {
diff --git a/src/lib/ector/ector_renderer_generic_base.c b/src/lib/ector/ector_renderer.c
index 085d945677..c3df0ff419 100644
--- a/src/lib/ector/ector_renderer_generic_base.c
+++ b/src/lib/ector/ector_renderer.c
@@ -7,10 +7,10 @@
 
 #include "ector_private.h"
 
-#define MY_CLASS ECTOR_RENDERER_GENERIC_BASE_CLASS
+#define MY_CLASS ECTOR_RENDERER_CLASS
 
 static void
-_ector_renderer_generic_base_eo_base_destructor(Eo *obj, Ector_Renderer_Generic_Base_Data *pd)
+_ector_renderer_eo_base_destructor(Eo *obj, Ector_Renderer_Data *pd)
 {
    if (pd->m) free(pd->m);
    eo_unref(pd->surface);
@@ -19,7 +19,7 @@ _ector_renderer_generic_base_eo_base_destructor(Eo *obj, Ector_Renderer_Generic_
 }
 
 static Eo_Base *
-_ector_renderer_generic_base_eo_base_finalize(Eo *obj, Ector_Renderer_Generic_Base_Data *pd)
+_ector_renderer_eo_base_finalize(Eo *obj, Ector_Renderer_Data *pd)
 {
    if (!pd->surface)
      {
@@ -30,14 +30,14 @@ _ector_renderer_generic_base_eo_base_finalize(Eo *obj, Ector_Renderer_Generic_Ba
    return eo_finalize(eo_super(obj, MY_CLASS));
 }
 
-static Ector_Generic_Surface *
-_ector_renderer_generic_base_surface_get(Eo *obj EINA_UNUSED, Ector_Renderer_Generic_Base_Data *pd)
+static Ector_Surface *
+_ector_renderer_surface_get(Eo *obj EINA_UNUSED, Ector_Renderer_Data *pd)
 {
    return pd->surface;
 }
 
 static void
-_ector_renderer_generic_base_surface_set(Eo *obj EINA_UNUSED, Ector_Renderer_Generic_Base_Data *pd, Ector_Generic_Surface *s)
+_ector_renderer_surface_set(Eo *obj EINA_UNUSED, Ector_Renderer_Data *pd, Ector_Surface *s)
 {
    if (pd->finalized)
      {
@@ -48,8 +48,8 @@ _ector_renderer_generic_base_surface_set(Eo *obj EINA_UNUSED, Ector_Renderer_Gen
 }
 
 static void
-_ector_renderer_generic_base_transformation_set(Eo *obj EINA_UNUSED,
-                                                Ector_Renderer_Generic_Base_Data *pd,
+_ector_renderer_transformation_set(Eo *obj EINA_UNUSED,
+                                                Ector_Renderer_Data *pd,
                                                 const Eina_Matrix3 *m)
 {
    if (!m)
@@ -67,15 +67,15 @@ _ector_renderer_generic_base_transformation_set(Eo *obj EINA_UNUSED,
 }
 
 static const Eina_Matrix3 *
-_ector_renderer_generic_base_transformation_get(Eo *obj EINA_UNUSED,
-                                                Ector_Renderer_Generic_Base_Data *pd)
+_ector_renderer_transformation_get(Eo *obj EINA_UNUSED,
+                                                Ector_Renderer_Data *pd)
 {
    return pd->m;
 }
 
 static void
-_ector_renderer_generic_base_origin_set(Eo *obj EINA_UNUSED,
-                                        Ector_Renderer_Generic_Base_Data *pd,
+_ector_renderer_origin_set(Eo *obj EINA_UNUSED,
+                                        Ector_Renderer_Data *pd,
                                         double x, double y)
 {
    pd->origin.x = x;
@@ -83,8 +83,8 @@ _ector_renderer_generic_base_origin_set(Eo *obj EINA_UNUSED,
 }
 
 static void
-_ector_renderer_generic_base_origin_get(Eo *obj EINA_UNUSED,
-                                        Ector_Renderer_Generic_Base_Data *pd,
+_ector_renderer_origin_get(Eo *obj EINA_UNUSED,
+                                        Ector_Renderer_Data *pd,
                                         double *x, double *y)
 {
    if (x) *x = pd->origin.x;
@@ -92,23 +92,23 @@ _ector_renderer_generic_base_origin_get(Eo *obj EINA_UNUSED,
 }
 
 static void
-_ector_renderer_generic_base_visibility_set(Eo *obj EINA_UNUSED,
-                                            Ector_Renderer_Generic_Base_Data *pd,
+_ector_renderer_visibility_set(Eo *obj EINA_UNUSED,
+                                            Ector_Renderer_Data *pd,
                                             Eina_Bool v)
 {
    pd->visibility = v;
 }
 
 static Eina_Bool
-_ector_renderer_generic_base_visibility_get(Eo *obj EINA_UNUSED,
-                                            Ector_Renderer_Generic_Base_Data *pd)
+_ector_renderer_visibility_get(Eo *obj EINA_UNUSED,
+                                            Ector_Renderer_Data *pd)
 {
    return pd->visibility;
 }
 
 static void
-_ector_renderer_generic_base_color_set(Eo *obj EINA_UNUSED,
-                                       Ector_Renderer_Generic_Base_Data *pd,
+_ector_renderer_color_set(Eo *obj EINA_UNUSED,
+                                       Ector_Renderer_Data *pd,
                                        int r, int g, int b, int a)
 {
    pd->color.r = r;
@@ -118,8 +118,8 @@ _ector_renderer_generic_base_color_set(Eo *obj EINA_UNUSED,
 }
 
 static void
-_ector_renderer_generic_base_color_get(Eo *obj EINA_UNUSED,
-                                       Ector_Renderer_Generic_Base_Data *pd,
+_ector_renderer_color_get(Eo *obj EINA_UNUSED,
+                                       Ector_Renderer_Data *pd,
                                        int *r, int *g, int *b, int *a)
 {
    if (r) *r = pd->color.r;
@@ -129,38 +129,38 @@ _ector_renderer_generic_base_color_get(Eo *obj EINA_UNUSED,
 }
 
 static void
-_ector_renderer_generic_base_mask_set(Eo *obj EINA_UNUSED,
-                                      Ector_Renderer_Generic_Base_Data *pd,
+_ector_renderer_mask_set(Eo *obj EINA_UNUSED,
+                                      Ector_Renderer_Data *pd,
                                       Ector_Renderer *r)
 {
    _eo_refplace(&pd->mask, r);
 }
 
 static Ector_Renderer *
-_ector_renderer_generic_base_mask_get(Eo *obj EINA_UNUSED,
-                                      Ector_Renderer_Generic_Base_Data *pd)
+_ector_renderer_mask_get(Eo *obj EINA_UNUSED,
+                                      Ector_Renderer_Data *pd)
 {
    return pd->mask;
 }
 
 static void
-_ector_renderer_generic_base_quality_set(Eo *obj EINA_UNUSED,
-                                         Ector_Renderer_Generic_Base_Data *pd,
+_ector_renderer_quality_set(Eo *obj EINA_UNUSED,
+                                         Ector_Renderer_Data *pd,
                                          Ector_Quality q)
 {
    pd->q = q;
 }
 
 static Ector_Quality
-_ector_renderer_generic_base_quality_get(Eo *obj EINA_UNUSED,
-                                         Ector_Renderer_Generic_Base_Data *pd)
+_ector_renderer_quality_get(Eo *obj EINA_UNUSED,
+                                         Ector_Renderer_Data *pd)
 {
    return pd->q;
 }
 
 static Eina_Bool
-_ector_renderer_generic_base_prepare(Eo *obj EINA_UNUSED,
-                                     Ector_Renderer_Generic_Base_Data *pd)
+_ector_renderer_prepare(Eo *obj EINA_UNUSED,
+                                     Ector_Renderer_Data *pd)
 {
    if (pd->mask)
      ector_renderer_prepare(pd->mask);
@@ -169,8 +169,8 @@ _ector_renderer_generic_base_prepare(Eo *obj EINA_UNUSED,
 }
 
 static unsigned int
-_ector_renderer_generic_base_crc_get(Eo *obj EINA_UNUSED,
-                                     Ector_Renderer_Generic_Base_Data *pd)
+_ector_renderer_crc_get(Eo *obj EINA_UNUSED,
+                                     Ector_Renderer_Data *pd)
 {
    unsigned int crc;
 
@@ -184,4 +184,4 @@ _ector_renderer_generic_base_crc_get(Eo *obj EINA_UNUSED,
    return crc;
 }
 
-#include "ector_renderer_generic_base.eo.c"
+#include "ector_renderer.eo.c"
diff --git a/src/lib/ector/ector_renderer_generic_base.eo b/src/lib/ector/ector_renderer.eo
index cdfa4a7961..9287e43e78 100644
--- a/src/lib/ector/ector_renderer_generic_base.eo
+++ b/src/lib/ector/ector_renderer.eo
@@ -9,7 +9,7 @@ enum Ector.Quality
    last, [[Sentinel]]
 }
 
-abstract Ector.Renderer.Generic.Base (Eo.Base)
+abstract Ector.Renderer (Eo.Base)
 {
    [[Ector renderer abstract interface]]
 
@@ -25,7 +25,7 @@ abstract Ector.Renderer.Generic.Base (Eo.Base)
 	    [[Get the surface associated to this renderer. Can not be set.]]
 	 }
 	 values {
-	    s: Ector.Generic.Surface *; [[Associated surface]]
+	    s: Ector.Surface *; [[Associated surface]]
 	 }
       }
       @property transformation {
@@ -86,7 +86,7 @@ abstract Ector.Renderer.Generic.Base (Eo.Base)
 	 get {
 	 }
 	 values {
-	    r: Ector.Renderer.Generic.Base *;
+	    r: Ector.Renderer *;
 	 }
       }
       @property quality {
diff --git a/src/lib/ector/ector_renderer.h b/src/lib/ector/ector_renderer.h
index 30b9bd2c2c..e2e2e65f58 100644
--- a/src/lib/ector/ector_renderer.h
+++ b/src/lib/ector/ector_renderer.h
@@ -1,11 +1,11 @@
 #ifndef ECTOR_RENDERER_H
 #define ECTOR_RENDERER_H
 
-#include "ector_renderer_generic_base.eo.h"
-#include "ector_renderer_generic_shape.eo.h"
-#include "ector_renderer_generic_buffer.eo.h"
-#include "ector_renderer_generic_gradient.eo.h"
-#include "ector_renderer_generic_gradient_linear.eo.h"
-#include "ector_renderer_generic_gradient_radial.eo.h"
+#include "ector_renderer.eo.h"
+#include "ector_renderer_shape.eo.h"
+#include "ector_renderer_buffer.eo.h"
+#include "ector_renderer_gradient.eo.h"
+#include "ector_renderer_gradient_linear.eo.h"
+#include "ector_renderer_gradient_radial.eo.h"
 
 #endif
diff --git a/src/lib/ector/ector_renderer_buffer.c b/src/lib/ector/ector_renderer_buffer.c
new file mode 100644
index 0000000000..4ba7287ee4
--- /dev/null
+++ b/src/lib/ector/ector_renderer_buffer.c
@@ -0,0 +1,55 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#else
+# define EFL_BETA_API_SUPPORT
+#endif
+
+#include <Eo.h>
+#include "ector_private.h"
+#include "ector_renderer_buffer.eo.h"
+
+#define MY_CLASS ECTOR_RENDERER_BUFFER_MIXIN
+
+EOLIAN static void
+_ector_renderer_buffer_efl_gfx_fill_fill_get(Eo *obj EINA_UNUSED, Ector_Renderer_Buffer_Data *pd, int *x, int *y, int *w, int *h)
+{
+   if (x) *x = pd->fill.x;
+   if (y) *y = pd->fill.y;
+   if (w) *w = pd->fill.w;
+   if (h) *h = pd->fill.h;
+}
+
+EOLIAN static void
+_ector_renderer_buffer_efl_gfx_fill_fill_set(Eo *obj EINA_UNUSED, Ector_Renderer_Buffer_Data *pd, int x, int y, int w, int h)
+{
+   if (w < 0) w = 0;
+   if (h < 0) h = 0;
+   pd->fill.x = x;
+   pd->fill.y = y;
+   pd->fill.w = w;
+   pd->fill.h = h;
+}
+
+EOLIAN static void
+_ector_renderer_buffer_buffer_set(Eo *obj EINA_UNUSED, Ector_Renderer_Buffer_Data *pd, Ector_Buffer *buf)
+{
+   _eo_xrefplace(&pd->eo_buffer, buf, obj);
+}
+
+EOLIAN static Ector_Buffer *
+_ector_renderer_buffer_buffer_get(Eo *obj EINA_UNUSED, Ector_Renderer_Buffer_Data *pd)
+{
+   return pd->eo_buffer;
+}
+
+EOLIAN static Eo_Base *
+_ector_renderer_buffer_eo_base_constructor(Eo *obj, Ector_Renderer_Buffer_Data *pd EINA_UNUSED)
+{
+   Eo_Base *ret;
+
+   ret = eo_constructor(eo_super(obj, MY_CLASS));
+
+   return ret;
+}
+
+#include "ector_renderer_buffer.eo.c"
diff --git a/src/lib/ector/ector_renderer_generic_buffer.eo b/src/lib/ector/ector_renderer_buffer.eo
index 85d361e41c..d11d42163d 100644
--- a/src/lib/ector/ector_renderer_generic_buffer.eo
+++ b/src/lib/ector/ector_renderer_buffer.eo
@@ -1,4 +1,4 @@
-mixin Ector.Renderer.Generic.Buffer (Ector.Renderer.Generic.Base, Efl.Gfx.Fill)
+mixin Ector.Renderer.Buffer (Ector.Renderer, Efl.Gfx.Fill)
 {
    [[Ector buffers have a default fill set to repeat]]
    eo_prefix: ector_renderer_buffer;
@@ -8,7 +8,7 @@ mixin Ector.Renderer.Generic.Buffer (Ector.Renderer.Generic.Base, Efl.Gfx.Fill)
 	 set { [[Sets the source buffer for this renderer, adds a ref]] }
 	 get { [[Return the current source, no ref change]] }
 	 values {
-	    buf: Ector.Generic.Buffer*;
+	    buf: Ector.Buffer*;
 	 }
       }
    }
diff --git a/src/lib/ector/ector_renderer_generic_buffer.c b/src/lib/ector/ector_renderer_generic_buffer.c
deleted file mode 100644
index d5755682b1..0000000000
--- a/src/lib/ector/ector_renderer_generic_buffer.c
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#else
-# define EFL_BETA_API_SUPPORT
-#endif
-
-#include <Eo.h>
-#include "ector_private.h"
-#include "ector_renderer_generic_buffer.eo.h"
-
-#define MY_CLASS ECTOR_RENDERER_GENERIC_BUFFER_MIXIN
-
-EOLIAN static void
-_ector_renderer_generic_buffer_efl_gfx_fill_fill_get(Eo *obj EINA_UNUSED, Ector_Renderer_Generic_Buffer_Data *pd, int *x, int *y, int *w, int *h)
-{
-   if (x) *x = pd->fill.x;
-   if (y) *y = pd->fill.y;
-   if (w) *w = pd->fill.w;
-   if (h) *h = pd->fill.h;
-}
-
-EOLIAN static void
-_ector_renderer_generic_buffer_efl_gfx_fill_fill_set(Eo *obj EINA_UNUSED, Ector_Renderer_Generic_Buffer_Data *pd, int x, int y, int w, int h)
-{
-   if (w < 0) w = 0;
-   if (h < 0) h = 0;
-   pd->fill.x = x;
-   pd->fill.y = y;
-   pd->fill.w = w;
-   pd->fill.h = h;
-}
-
-EOLIAN static void
-_ector_renderer_generic_buffer_buffer_set(Eo *obj EINA_UNUSED, Ector_Renderer_Generic_Buffer_Data *pd, Ector_Generic_Buffer *buf)
-{
-   _eo_xrefplace(&pd->eo_buffer, buf, obj);
-}
-
-EOLIAN static Ector_Generic_Buffer *
-_ector_renderer_generic_buffer_buffer_get(Eo *obj EINA_UNUSED, Ector_Renderer_Generic_Buffer_Data *pd)
-{
-   return pd->eo_buffer;
-}
-
-EOLIAN static Eo_Base *
-_ector_renderer_generic_buffer_eo_base_constructor(Eo *obj, Ector_Renderer_Generic_Buffer_Data *pd EINA_UNUSED)
-{
-   Eo_Base *ret;
-
-   ret = eo_constructor(eo_super(obj, MY_CLASS));
-
-   return ret;
-}
-
-#include "ector_renderer_generic_buffer.eo.c"
diff --git a/src/lib/ector/ector_renderer_generic_shape.c b/src/lib/ector/ector_renderer_generic_shape.c
deleted file mode 100644
index 76e67bbebe..0000000000
--- a/src/lib/ector/ector_renderer_generic_shape.c
+++ /dev/null
@@ -1,55 +0,0 @@
-#ifdef HAVE_CONFIG_H
-# include "config.h"
-#endif
-
-#include <Eina.h>
-#include <Ector.h>
-
-#include "ector_private.h"
-
-static void
-_ector_renderer_generic_shape_fill_set(Eo *obj EINA_UNUSED,
-                                       Ector_Renderer_Generic_Shape_Data *pd,
-                                       const Ector_Renderer *r)
-{
-   _eo_refplace(&pd->fill, r);
-}
-
-static const Ector_Renderer *
-_ector_renderer_generic_shape_fill_get(Eo *obj EINA_UNUSED,
-                                       Ector_Renderer_Generic_Shape_Data *pd)
-{
-   return pd->fill;
-}
-
-static void
-_ector_renderer_generic_shape_stroke_fill_set(Eo *obj EINA_UNUSED,
-                                              Ector_Renderer_Generic_Shape_Data *pd,
-                                              const Ector_Renderer *r)
-{
-   _eo_refplace(&pd->stroke.fill, r);
-}
-
-static const Ector_Renderer *
-_ector_renderer_generic_shape_stroke_fill_get(Eo *obj EINA_UNUSED,
-                                              Ector_Renderer_Generic_Shape_Data *pd)
-{
-   return pd->stroke.fill;
-}
-
-static void
-_ector_renderer_generic_shape_stroke_marker_set(Eo *obj EINA_UNUSED,
-                                                Ector_Renderer_Generic_Shape_Data *pd,
-                                                const Ector_Renderer *r)
-{
-   _eo_refplace(&pd->stroke.marker, r);
-}
-
-static const Ector_Renderer *
-_ector_renderer_generic_shape_stroke_marker_get(Eo *obj EINA_UNUSED,
-                                                Ector_Renderer_Generic_Shape_Data *pd)
-{
-   return pd->stroke.marker;
-}
-
-#include "ector_renderer_generic_shape.eo.c"
diff --git a/src/lib/ector/ector_renderer_generic_gradient.c b/src/lib/ector/ector_renderer_gradient.c
index e6e277e55f..aa1101be9d 100644
--- a/src/lib/ector/ector_renderer_generic_gradient.c
+++ b/src/lib/ector/ector_renderer_gradient.c
@@ -8,8 +8,8 @@
 #include "ector_private.h"
 
 static void
-_ector_renderer_generic_gradient_efl_gfx_gradient_stop_set(Eo *obj EINA_UNUSED,
-                                                                Ector_Renderer_Generic_Gradient_Data *pd,
+_ector_renderer_gradient_efl_gfx_gradient_stop_set(Eo *obj EINA_UNUSED,
+                                                                Ector_Renderer_Gradient_Data *pd,
                                                                 const Efl_Gfx_Gradient_Stop *colors,
                                                                 unsigned int length)
 {
@@ -25,8 +25,8 @@ _ector_renderer_generic_gradient_efl_gfx_gradient_stop_set(Eo *obj EINA_UNUSED,
 }
 
 static void
-_ector_renderer_generic_gradient_efl_gfx_gradient_stop_get(Eo *obj EINA_UNUSED,
-                                                                Ector_Renderer_Generic_Gradient_Data *pd,
+_ector_renderer_gradient_efl_gfx_gradient_stop_get(Eo *obj EINA_UNUSED,
+                                                                Ector_Renderer_Gradient_Data *pd,
                                                                 const Efl_Gfx_Gradient_Stop **colors,
                                                                 unsigned int *length)
 {
@@ -35,19 +35,19 @@ _ector_renderer_generic_gradient_efl_gfx_gradient_stop_get(Eo *obj EINA_UNUSED,
 }
 
 static void
-_ector_renderer_generic_gradient_efl_gfx_gradient_spread_set(Eo *obj EINA_UNUSED,
-                                                                  Ector_Renderer_Generic_Gradient_Data *pd,
+_ector_renderer_gradient_efl_gfx_gradient_spread_set(Eo *obj EINA_UNUSED,
+                                                                  Ector_Renderer_Gradient_Data *pd,
                                                                   Efl_Gfx_Gradient_Spread s)
 {
    pd->s = s;
 }
 
 static Efl_Gfx_Gradient_Spread
-_ector_renderer_generic_gradient_efl_gfx_gradient_spread_get(Eo *obj EINA_UNUSED,
-                                                                  Ector_Renderer_Generic_Gradient_Data *pd)
+_ector_renderer_gradient_efl_gfx_gradient_spread_get(Eo *obj EINA_UNUSED,
+                                                                  Ector_Renderer_Gradient_Data *pd)
 {
    return pd->s;
 }
 
 
-#include "ector_renderer_generic_gradient.eo.c"
+#include "ector_renderer_gradient.eo.c"
diff --git a/src/lib/ector/ector_renderer_generic_gradient.eo b/src/lib/ector/ector_renderer_gradient.eo
index 1ce3c8a8c2..a8688203c2 100644
--- a/src/lib/ector/ector_renderer_generic_gradient.eo
+++ b/src/lib/ector/ector_renderer_gradient.eo
@@ -1,4 +1,4 @@
-mixin Ector.Renderer.Generic.Gradient (Efl.Gfx.Gradient)
+mixin Ector.Renderer.Gradient (Efl.Gfx.Gradient)
 {
    eo_prefix: ector_renderer_gradient;
    legacy_prefix: null;
diff --git a/src/lib/ector/ector_renderer_generic_gradient_linear.c b/src/lib/ector/ector_renderer_gradient_linear.c
index 925fb53951..05c46d6a5a 100644
--- a/src/lib/ector/ector_renderer_generic_gradient_linear.c
+++ b/src/lib/ector/ector_renderer_gradient_linear.c
@@ -8,8 +8,8 @@
 #include "ector_private.h"
 
 static void
-_ector_renderer_generic_gradient_linear_efl_gfx_gradient_linear_start_set(Eo *obj EINA_UNUSED,
-                                                                          Ector_Renderer_Generic_Gradient_Linear_Data *pd,
+_ector_renderer_gradient_linear_efl_gfx_gradient_linear_start_set(Eo *obj EINA_UNUSED,
+                                                                          Ector_Renderer_Gradient_Linear_Data *pd,
                                                                           double x, double y)
 {
    pd->start.x = x;
@@ -17,8 +17,8 @@ _ector_renderer_generic_gradient_linear_efl_gfx_gradient_linear_start_set(Eo *ob
 }
 
 static void
-_ector_renderer_generic_gradient_linear_efl_gfx_gradient_linear_start_get(Eo *obj EINA_UNUSED,
-                                                                          Ector_Renderer_Generic_Gradient_Linear_Data *pd,
+_ector_renderer_gradient_linear_efl_gfx_gradient_linear_start_get(Eo *obj EINA_UNUSED,
+                                                                          Ector_Renderer_Gradient_Linear_Data *pd,
                                                                           double *x, double *y)
 {
    if (x) *x = pd->start.x;
@@ -26,8 +26,8 @@ _ector_renderer_generic_gradient_linear_efl_gfx_gradient_linear_start_get(Eo *ob
 }
 
 static void
-_ector_renderer_generic_gradient_linear_efl_gfx_gradient_linear_end_set(Eo *obj EINA_UNUSED,
-                                                                        Ector_Renderer_Generic_Gradient_Linear_Data *pd,
+_ector_renderer_gradient_linear_efl_gfx_gradient_linear_end_set(Eo *obj EINA_UNUSED,
+                                                                        Ector_Renderer_Gradient_Linear_Data *pd,
                                                                         double x, double y)
 {
    pd->end.x = x;
@@ -35,12 +35,12 @@ _ector_renderer_generic_gradient_linear_efl_gfx_gradient_linear_end_set(Eo *obj
 }
 
 static void
-_ector_renderer_generic_gradient_linear_efl_gfx_gradient_linear_end_get(Eo *obj EINA_UNUSED,
-                                                                        Ector_Renderer_Generic_Gradient_Linear_Data *pd,
+_ector_renderer_gradient_linear_efl_gfx_gradient_linear_end_get(Eo *obj EINA_UNUSED,
+                                                                        Ector_Renderer_Gradient_Linear_Data *pd,
                                                                         double *x, double *y)
 {
    if (x) *x = pd->end.x;
    if (y) *y = pd->end.y;
 }
 
-#include "ector_renderer_generic_gradient_linear.eo.c"
+#include "ector_renderer_gradient_linear.eo.c"
diff --git a/src/lib/ector/ector_renderer_generic_gradient_linear.eo b/src/lib/ector/ector_renderer_gradient_linear.eo
index 13ab2e6bfc..7778715765 100644
--- a/src/lib/ector/ector_renderer_generic_gradient_linear.eo
+++ b/src/lib/ector/ector_renderer_gradient_linear.eo
@@ -1,4 +1,4 @@
-mixin Ector.Renderer.Generic.Gradient_Linear (Efl.Gfx.Gradient.Linear)
+mixin Ector.Renderer.Gradient_Linear (Efl.Gfx.Gradient.Linear)
 {
    eo_prefix: ector_renderer_gradient_linear;
    legacy_prefix: null;
diff --git a/src/lib/ector/ector_renderer_generic_gradient_radial.c b/src/lib/ector/ector_renderer_gradient_radial.c
index 3c1782cf73..83d4aea624 100644
--- a/src/lib/ector/ector_renderer_generic_gradient_radial.c
+++ b/src/lib/ector/ector_renderer_gradient_radial.c
@@ -8,8 +8,8 @@
 #include "ector_private.h"
 
 static void
-_ector_renderer_generic_gradient_radial_efl_gfx_gradient_radial_center_set(Eo *obj EINA_UNUSED,
-                                                                           Ector_Renderer_Generic_Gradient_Radial_Data *pd,
+_ector_renderer_gradient_radial_efl_gfx_gradient_radial_center_set(Eo *obj EINA_UNUSED,
+                                                                           Ector_Renderer_Gradient_Radial_Data *pd,
                                                                            double x, double y)
 {
    pd->radial.x = x;
@@ -17,8 +17,8 @@ _ector_renderer_generic_gradient_radial_efl_gfx_gradient_radial_center_set(Eo *o
 }
 
 static void
-_ector_renderer_generic_gradient_radial_efl_gfx_gradient_radial_center_get(Eo *obj EINA_UNUSED,
-                                                                           Ector_Renderer_Generic_Gradient_Radial_Data *pd,
+_ector_renderer_gradient_radial_efl_gfx_gradient_radial_center_get(Eo *obj EINA_UNUSED,
+                                                                           Ector_Renderer_Gradient_Radial_Data *pd,
                                                                            double *x, double *y)
 {
    if (x) *x = pd->radial.x;
@@ -26,24 +26,24 @@ _ector_renderer_generic_gradient_radial_efl_gfx_gradient_radial_center_get(Eo *o
 }
 
 static void
-_ector_renderer_generic_gradient_radial_efl_gfx_gradient_radial_radius_set(Eo *obj EINA_UNUSED,
-                                                                           Ector_Renderer_Generic_Gradient_Radial_Data *pd,
+_ector_renderer_gradient_radial_efl_gfx_gradient_radial_radius_set(Eo *obj EINA_UNUSED,
+                                                                           Ector_Renderer_Gradient_Radial_Data *pd,
                                                                            double r)
 {
    pd->radius = r;
 }
 
 static double
-_ector_renderer_generic_gradient_radial_efl_gfx_gradient_radial_radius_get(Eo *obj EINA_UNUSED,
-                                                                           Ector_Renderer_Generic_Gradient_Radial_Data *pd)
+_ector_renderer_gradient_radial_efl_gfx_gradient_radial_radius_get(Eo *obj EINA_UNUSED,
+                                                                           Ector_Renderer_Gradient_Radial_Data *pd)
 {
    return pd->radius;
 }
 
 
 static void
-_ector_renderer_generic_gradient_radial_efl_gfx_gradient_radial_focal_set(Eo *obj EINA_UNUSED,
-                                                                          Ector_Renderer_Generic_Gradient_Radial_Data *pd,
+_ector_renderer_gradient_radial_efl_gfx_gradient_radial_focal_set(Eo *obj EINA_UNUSED,
+                                                                          Ector_Renderer_Gradient_Radial_Data *pd,
                                                                           double x, double y)
 {
    pd->focal.x = x;
@@ -51,12 +51,12 @@ _ector_renderer_generic_gradient_radial_efl_gfx_gradient_radial_focal_set(Eo *ob
 }
 
 static void
-_ector_renderer_generic_gradient_radial_efl_gfx_gradient_radial_focal_get(Eo *obj EINA_UNUSED,
-                                                                          Ector_Renderer_Generic_Gradient_Radial_Data *pd,
+_ector_renderer_gradient_radial_efl_gfx_gradient_radial_focal_get(Eo *obj EINA_UNUSED,
+                                                                          Ector_Renderer_Gradient_Radial_Data *pd,
                                                                           double *x, double *y)
 {
    if (x) *x = pd->focal.x;
    if (y) *y = pd->focal.y;
 }
 
-#include "ector_renderer_generic_gradient_radial.eo.c"
+#include "ector_renderer_gradient_radial.eo.c"
diff --git a/src/lib/ector/ector_renderer_generic_gradient_radial.eo b/src/lib/ector/ector_renderer_gradient_radial.eo
index cef25eb953..8fae6fe6ab 100644
--- a/src/lib/ector/ector_renderer_generic_gradient_radial.eo
+++ b/src/lib/ector/ector_renderer_gradient_radial.eo
@@ -1,4 +1,4 @@
-mixin Ector.Renderer.Generic.Gradient_Radial (Efl.Gfx.Gradient.Radial)
+mixin Ector.Renderer.Gradient_Radial (Efl.Gfx.Gradient.Radial)
 {
    eo_prefix: ector_renderer_gradient_radial;
    legacy_prefix: null;
diff --git a/src/lib/ector/ector_renderer_shape.c b/src/lib/ector/ector_renderer_shape.c
new file mode 100644
index 0000000000..ffdd0158a4
--- /dev/null
+++ b/src/lib/ector/ector_renderer_shape.c
@@ -0,0 +1,55 @@
+#ifdef HAVE_CONFIG_H
+# include "config.h"
+#endif
+
+#include <Eina.h>
+#include <Ector.h>
+
+#include "ector_private.h"
+
+static void
+_ector_renderer_shape_fill_set(Eo *obj EINA_UNUSED,
+                                       Ector_Renderer_Shape_Data *pd,
+                                       const Ector_Renderer *r)
+{
+   _eo_refplace(&pd->fill, r);
+}
+
+static const Ector_Renderer *
+_ector_renderer_shape_fill_get(Eo *obj EINA_UNUSED,
+                                       Ector_Renderer_Shape_Data *pd)
+{
+   return pd->fill;
+}
+
+static void
+_ector_renderer_shape_stroke_fill_set(Eo *obj EINA_UNUSED,
+                                              Ector_Renderer_Shape_Data *pd,
+                                              const Ector_Renderer *r)
+{
+   _eo_refplace(&pd->stroke.fill, r);
+}
+
+static const Ector_Renderer *
+_ector_renderer_shape_stroke_fill_get(Eo *obj EINA_UNUSED,
+                                              Ector_Renderer_Shape_Data *pd)
+{
+   return pd->stroke.fill;
+}
+
+static void
+_ector_renderer_shape_stroke_marker_set(Eo *obj EINA_UNUSED,
+                                                Ector_Renderer_Shape_Data *pd,
+                                                const Ector_Renderer *r)
+{
+   _eo_refplace(&pd->stroke.marker, r);
+}
+
+static const Ector_Renderer *
+_ector_renderer_shape_stroke_marker_get(Eo *obj EINA_UNUSED,
+                                                Ector_Renderer_Shape_Data *pd)
+{
+   return pd->stroke.marker;
+}
+
+#include "ector_renderer_shape.eo.c"
diff --git a/src/lib/ector/ector_renderer_generic_shape.eo b/src/lib/ector/ector_renderer_shape.eo
index 4362a88e09..62f6960821 100644
--- a/src/lib/ector/ector_renderer_generic_shape.eo
+++ b/src/lib/ector/ector_renderer_shape.eo
@@ -1,6 +1,6 @@
-import ector_renderer_generic_base;
+import ector_renderer;
 
-mixin Ector.Renderer.Generic.Shape (Efl.Gfx.Shape)
+mixin Ector.Renderer.Shape (Efl.Gfx.Shape)
 {
    eo_prefix: ector_renderer_shape;
    legacy_prefix: null;
@@ -11,7 +11,7 @@ mixin Ector.Renderer.Generic.Shape (Efl.Gfx.Shape)
 	 get {
 	 }
 	 values {
-	    r: const(Ector.Renderer.Generic.Base) *;
+	    r: const(Ector.Renderer) *;
 	 }
       }
       @property stroke_fill {
@@ -20,7 +20,7 @@ mixin Ector.Renderer.Generic.Shape (Efl.Gfx.Shape)
 	 get {
 	 }
 	 values {
-	    r: const(Ector.Renderer.Generic.Base) *;
+	    r: const(Ector.Renderer) *;
 	 }
       }
       @property stroke_marker {
@@ -29,7 +29,7 @@ mixin Ector.Renderer.Generic.Shape (Efl.Gfx.Shape)
 	 get {
 	 }
 	 values {
-	    r: const(Ector.Renderer.Generic.Base) *;
+	    r: const(Ector.Renderer) *;
 	 }
       }
    }
diff --git a/src/lib/ector/ector_generic_surface.eo b/src/lib/ector/ector_surface.eo
index db778b9c30..92eb68db73 100644
--- a/src/lib/ector/ector_generic_surface.eo
+++ b/src/lib/ector/ector_surface.eo
@@ -1,4 +1,4 @@
-mixin Ector.Generic.Surface (Ector.Generic.Buffer)
+mixin Ector.Surface (Ector.Buffer)
 {
    [[Surface interface for Ector]]
 
diff --git a/src/lib/ector/ector_surface.h b/src/lib/ector/ector_surface.h
index 98e4bf0b9c..4bb0c375f4 100644
--- a/src/lib/ector/ector_surface.h
+++ b/src/lib/ector/ector_surface.h
@@ -2,6 +2,6 @@
 #define ECTOR_SURFACE_H
 
 #include "ector_buffer.h"
-#include "ector_generic_surface.eo.h"
+#include "ector_surface.eo.h"
 
 #endif
diff --git a/src/lib/ector/gl/ector_gl_buffer_base.eo b/src/lib/ector/gl/ector_gl_buffer_base.eo
index 7016359cee..32882a4404 100644
--- a/src/lib/ector/gl/ector_gl_buffer_base.eo
+++ b/src/lib/ector/gl/ector_gl_buffer_base.eo
@@ -1,4 +1,4 @@
-mixin Ector.GL.Buffer.Base (Ector.Generic.Buffer)
+mixin Ector.GL.Buffer.Base (Ector.Buffer)
 {
    legacy_prefix: null;
    methods {
diff --git a/src/lib/ector/gl/ector_gl_surface.c b/src/lib/ector/gl/ector_gl_surface.c
index 9e8d73681d..a44f73916b 100644
--- a/src/lib/ector/gl/ector_gl_surface.c
+++ b/src/lib/ector/gl/ector_gl_surface.c
@@ -40,15 +40,15 @@ _shader_free(void *s)
 }
 
 static Ector_Renderer *
-_ector_gl_surface_ector_generic_surface_renderer_factory_new(Eo *obj,
+_ector_gl_surface_ector_surface_renderer_factory_new(Eo *obj,
                                                              Ector_GL_Surface_Data *pd EINA_UNUSED,
                                                              const Eo_Class *type)
 {
-   if (type == ECTOR_RENDERER_GENERIC_SHAPE_MIXIN)
+   if (type == ECTOR_RENDERER_SHAPE_MIXIN)
      return eo_add(ECTOR_RENDERER_GL_SHAPE_CLASS, NULL, ector_renderer_surface_set(eo_self, obj));
-   else if (type == ECTOR_RENDERER_GENERIC_GRADIENT_LINEAR_MIXIN)
+   else if (type == ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN)
      return eo_add(ECTOR_RENDERER_GL_GRADIENT_LINEAR_CLASS, NULL, ector_renderer_surface_set(eo_self, obj));
-   else if (type == ECTOR_RENDERER_GENERIC_GRADIENT_RADIAL_MIXIN)
+   else if (type == ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN)
      return eo_add(ECTOR_RENDERER_GL_GRADIENT_RADIAL_CLASS, NULL, ector_renderer_surface_set(eo_self, obj));
 
    ERR("Couldn't find class for type: %s\n", eo_class_name_get(type));
@@ -56,7 +56,7 @@ _ector_gl_surface_ector_generic_surface_renderer_factory_new(Eo *obj,
 }
 
 static void
-_ector_gl_surface_ector_generic_surface_reference_point_set(Eo *obj EINA_UNUSED,
+_ector_gl_surface_ector_surface_reference_point_set(Eo *obj EINA_UNUSED,
                                                             Ector_GL_Surface_Data *pd,
                                                             int x, int y)
 {
diff --git a/src/lib/ector/gl/ector_gl_surface.eo b/src/lib/ector/gl/ector_gl_surface.eo
index e3585cd64a..770f550e31 100644
--- a/src/lib/ector/gl/ector_gl_surface.eo
+++ b/src/lib/ector/gl/ector_gl_surface.eo
@@ -1,6 +1,6 @@
 import ector_types;
 
-class Ector.GL.Surface (Ector.GL.Buffer, Ector.Generic.Surface)
+class Ector.GL.Surface (Ector.GL.Buffer, Ector.Surface)
 {
    eo_prefix: ector_gl_surface;
    legacy_prefix: null;
@@ -29,8 +29,8 @@ class Ector.GL.Surface (Ector.GL.Buffer, Ector.Generic.Surface)
       }
    }
    implements {
-      Ector.Generic.Surface.renderer_factory_new;
-      Ector.Generic.Surface.reference_point.set;
+      Ector.Surface.renderer_factory_new;
+      Ector.Surface.reference_point.set;
       Eo.Base.destructor;
       Eo.Base.constructor;
    }
diff --git a/src/lib/ector/gl/ector_renderer_gl.c b/src/lib/ector/gl/ector_renderer_gl.c
index 0b2f43d181..b3b251ca7a 100644
--- a/src/lib/ector/gl/ector_renderer_gl.c
+++ b/src/lib/ector/gl/ector_renderer_gl.c
@@ -12,18 +12,18 @@
 typedef struct _Ector_Renderer_GL_Data Ector_Renderer_GL_Data;
 struct _Ector_Renderer_GL_Data
 {
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Data *base;
 };
 
 static Eina_Bool
-_ector_renderer_gl_ector_renderer_generic_base_prepare(Eo *obj EINA_UNUSED,
+_ector_renderer_gl_ector_renderer_prepare(Eo *obj EINA_UNUSED,
                                                             Ector_Renderer_GL_Data *pd EINA_UNUSED)
 {
    return EINA_TRUE;
 }
 
 static Eina_Bool
-_ector_renderer_gl_ector_renderer_generic_base_draw(Eo *obj EINA_UNUSED,
+_ector_renderer_gl_ector_renderer_draw(Eo *obj EINA_UNUSED,
                                                          Ector_Renderer_GL_Data *pd,
                                                          Efl_Gfx_Render_Op op,
                                                          Eina_Array *clips,
@@ -42,7 +42,7 @@ _ector_renderer_gl_eo_base_constructor(Eo *obj, Ector_Renderer_GL_Data *pd)
    obj = eo_constructor(eo_super(obj, ECTOR_RENDERER_GL_CLASS));
    if (!obj) return NULL;
 
-   pd->base = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS, obj);
+   pd->base = eo_data_xref(obj, ECTOR_RENDERER_CLASS, obj);
    return obj;
 }
 
diff --git a/src/lib/ector/gl/ector_renderer_gl.eo b/src/lib/ector/gl/ector_renderer_gl.eo
index 34d940b49f..f3ba2329b2 100644
--- a/src/lib/ector/gl/ector_renderer_gl.eo
+++ b/src/lib/ector/gl/ector_renderer_gl.eo
@@ -1,6 +1,6 @@
 import ector_types;
 
-abstract Ector.Renderer.GL (Ector.Renderer.Generic.Base)
+abstract Ector.Renderer.GL (Ector.Renderer)
 {
    legacy_prefix: null;
    methods {
@@ -16,8 +16,8 @@ abstract Ector.Renderer.GL (Ector.Renderer.Generic.Base)
    }
    implements {
       @virtual .fill;
-      Ector.Renderer.Generic.Base.prepare;
-      Ector.Renderer.Generic.Base.draw;
+      Ector.Renderer.prepare;
+      Ector.Renderer.draw;
       Eo.Base.constructor;
       Eo.Base.destructor;
    }
diff --git a/src/lib/ector/gl/ector_renderer_gl_gradient_linear.c b/src/lib/ector/gl/ector_renderer_gl_gradient_linear.c
index 17510b9f95..7aa2eeb90f 100644
--- a/src/lib/ector/gl/ector_renderer_gl_gradient_linear.c
+++ b/src/lib/ector/gl/ector_renderer_gl_gradient_linear.c
@@ -12,13 +12,13 @@
 typedef struct _Ector_Renderer_GL_Gradient_Linear_Data Ector_Renderer_GL_Gradient_Linear_Data;
 struct _Ector_Renderer_GL_Gradient_Linear_Data
 {
-   Ector_Renderer_Generic_Gradient_Linear_Data *linear;
-   Ector_Renderer_Generic_Gradient_Data *gradient;
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Gradient_Linear_Data *linear;
+   Ector_Renderer_Gradient_Data *gradient;
+   Ector_Renderer_Data *base;
 };
 
 static Eina_Bool
-_ector_renderer_gl_gradient_linear_ector_renderer_generic_base_prepare(Eo *obj,
+_ector_renderer_gl_gradient_linear_ector_renderer_prepare(Eo *obj,
                                                                        Ector_Renderer_GL_Gradient_Linear_Data *pd)
 {
    // FIXME: prepare something
@@ -29,7 +29,7 @@ _ector_renderer_gl_gradient_linear_ector_renderer_generic_base_prepare(Eo *obj,
 }
 
 static Eina_Bool
-_ector_renderer_gl_gradient_linear_ector_renderer_generic_base_draw(Eo *obj, Ector_Renderer_GL_Gradient_Linear_Data *pd, Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
+_ector_renderer_gl_gradient_linear_ector_renderer_draw(Eo *obj, Ector_Renderer_GL_Gradient_Linear_Data *pd, Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
 {
    ector_renderer_draw(eo_super(obj, ECTOR_RENDERER_GL_GRADIENT_LINEAR_CLASS), op, clips, mul_col);
 
@@ -40,7 +40,7 @@ _ector_renderer_gl_gradient_linear_ector_renderer_generic_base_draw(Eo *obj, Ect
 }
 
 static void
-_ector_renderer_gl_gradient_linear_ector_renderer_generic_base_bounds_get(Eo *obj EINA_UNUSED,
+_ector_renderer_gl_gradient_linear_ector_renderer_bounds_get(Eo *obj EINA_UNUSED,
                                                                           Ector_Renderer_GL_Gradient_Linear_Data *pd,
                                                                           Eina_Rectangle *r)
 {
@@ -73,9 +73,9 @@ _ector_renderer_gl_gradient_linear_eo_base_constructor(Eo *obj, Ector_Renderer_G
 
    if (!obj) return NULL;
 
-   pd->base = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS, obj);
-   pd->linear = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_GRADIENT_LINEAR_MIXIN, obj);
-   pd->gradient = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_GRADIENT_MIXIN, obj);
+   pd->base = eo_data_xref(obj, ECTOR_RENDERER_CLASS, obj);
+   pd->linear = eo_data_xref(obj, ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN, obj);
+   pd->gradient = eo_data_xref(obj, ECTOR_RENDERER_GRADIENT_MIXIN, obj);
 
    return obj;
 }
@@ -95,7 +95,7 @@ _ector_renderer_gl_gradient_linear_efl_gfx_gradient_stop_set(Eo *obj, Ector_Rend
 }
 
 static unsigned int
-_ector_renderer_gl_gradient_linear_ector_renderer_generic_base_crc_get(Eo *obj, Ector_Renderer_GL_Gradient_Linear_Data *pd)
+_ector_renderer_gl_gradient_linear_ector_renderer_crc_get(Eo *obj, Ector_Renderer_GL_Gradient_Linear_Data *pd)
 {
    unsigned int crc;
 
@@ -104,7 +104,7 @@ _ector_renderer_gl_gradient_linear_ector_renderer_generic_base_crc_get(Eo *obj,
    crc = eina_crc((void*) pd->gradient->s, sizeof (Efl_Gfx_Gradient_Spread), crc, EINA_FALSE);
    if (pd->gradient->colors_count)
      crc = eina_crc((void*) pd->gradient->colors, sizeof (Efl_Gfx_Gradient_Stop) * pd->gradient->colors_count, crc, EINA_FALSE);
-   crc = eina_crc((void*) pd->linear, sizeof (Ector_Renderer_Generic_Gradient_Linear_Data), crc, EINA_FALSE);
+   crc = eina_crc((void*) pd->linear, sizeof (Ector_Renderer_Gradient_Linear_Data), crc, EINA_FALSE);
 
    return crc;
 }
diff --git a/src/lib/ector/gl/ector_renderer_gl_gradient_linear.eo b/src/lib/ector/gl/ector_renderer_gl_gradient_linear.eo
index eda0d1a795..d7b9f71179 100644
--- a/src/lib/ector/gl/ector_renderer_gl_gradient_linear.eo
+++ b/src/lib/ector/gl/ector_renderer_gl_gradient_linear.eo
@@ -1,12 +1,12 @@
-class Ector.Renderer.GL.Gradient_Linear (Ector.Renderer.GL, Ector.Renderer.Generic.Gradient, Ector.Renderer.Generic.Gradient_Linear)
+class Ector.Renderer.GL.Gradient_Linear (Ector.Renderer.GL, Ector.Renderer.Gradient, Ector.Renderer.Gradient_Linear)
 {
    eo_prefix: ector_renderer_gl_gradient_linear;
    legacy_prefix: null;
    implements {
-      Ector.Renderer.Generic.Base.prepare;
-      Ector.Renderer.Generic.Base.draw;
-      Ector.Renderer.Generic.Base.bounds_get;
-      Ector.Renderer.Generic.Base.crc.get;
+      Ector.Renderer.prepare;
+      Ector.Renderer.draw;
+      Ector.Renderer.bounds_get;
+      Ector.Renderer.crc.get;
       Ector.Renderer.GL.fill;
       Eo.Base.constructor;
       Eo.Base.destructor;
diff --git a/src/lib/ector/gl/ector_renderer_gl_gradient_radial.c b/src/lib/ector/gl/ector_renderer_gl_gradient_radial.c
index 3716a84a8d..a16619c8a3 100644
--- a/src/lib/ector/gl/ector_renderer_gl_gradient_radial.c
+++ b/src/lib/ector/gl/ector_renderer_gl_gradient_radial.c
@@ -12,13 +12,13 @@
 typedef struct _Ector_Renderer_GL_Gradient_Radial_Data Ector_Renderer_GL_Gradient_Radial_Data;
 struct _Ector_Renderer_GL_Gradient_Radial_Data
 {
-   Ector_Renderer_Generic_Gradient_Radial_Data *radial;
-   Ector_Renderer_Generic_Gradient_Data *gradient;
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Gradient_Radial_Data *radial;
+   Ector_Renderer_Gradient_Data *gradient;
+   Ector_Renderer_Data *base;
 };
 
 static Eina_Bool
-_ector_renderer_gl_gradient_radial_ector_renderer_generic_base_prepare(Eo *obj, Ector_Renderer_GL_Gradient_Radial_Data *pd)
+_ector_renderer_gl_gradient_radial_ector_renderer_prepare(Eo *obj, Ector_Renderer_GL_Gradient_Radial_Data *pd)
 {
    // FIXME: prepare something
    (void) obj;
@@ -28,7 +28,7 @@ _ector_renderer_gl_gradient_radial_ector_renderer_generic_base_prepare(Eo *obj,
 }
 
 static Eina_Bool
-_ector_renderer_gl_gradient_radial_ector_renderer_generic_base_draw(Eo *obj, Ector_Renderer_GL_Gradient_Radial_Data *pd, Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
+_ector_renderer_gl_gradient_radial_ector_renderer_draw(Eo *obj, Ector_Renderer_GL_Gradient_Radial_Data *pd, Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
 {
    ector_renderer_draw(eo_super(obj, ECTOR_RENDERER_GL_GRADIENT_RADIAL_CLASS), op, clips, mul_col);
 
@@ -54,7 +54,7 @@ _ector_renderer_gl_gradient_radial_ector_renderer_gl_fill(Eo *obj, Ector_Rendere
 }
 
 static void
-_ector_renderer_gl_gradient_radial_ector_renderer_generic_base_bounds_get(Eo *obj EINA_UNUSED,
+_ector_renderer_gl_gradient_radial_ector_renderer_bounds_get(Eo *obj EINA_UNUSED,
                                                                           Ector_Renderer_GL_Gradient_Radial_Data *pd,
                                                                           Eina_Rectangle *r)
 {
@@ -65,7 +65,7 @@ _ector_renderer_gl_gradient_radial_ector_renderer_generic_base_bounds_get(Eo *ob
 }
 
 static unsigned int
-_ector_renderer_gl_gradient_radial_ector_renderer_generic_base_crc_get(Eo *obj, Ector_Renderer_GL_Gradient_Radial_Data *pd)
+_ector_renderer_gl_gradient_radial_ector_renderer_crc_get(Eo *obj, Ector_Renderer_GL_Gradient_Radial_Data *pd)
 {
    unsigned int crc;
 
@@ -74,7 +74,7 @@ _ector_renderer_gl_gradient_radial_ector_renderer_generic_base_crc_get(Eo *obj,
    crc = eina_crc((void*) pd->gradient->s, sizeof (Efl_Gfx_Gradient_Spread), crc, EINA_FALSE);
    if (pd->gradient->colors_count)
      crc = eina_crc((void*) pd->gradient->colors, sizeof (Efl_Gfx_Gradient_Stop) * pd->gradient->colors_count, crc, EINA_FALSE);
-   crc = eina_crc((void*) pd->radial, sizeof (Ector_Renderer_Generic_Gradient_Radial_Data), crc, EINA_FALSE);
+   crc = eina_crc((void*) pd->radial, sizeof (Ector_Renderer_Gradient_Radial_Data), crc, EINA_FALSE);
 
    return crc;
 }
@@ -86,9 +86,9 @@ _ector_renderer_gl_gradient_radial_eo_base_constructor(Eo *obj, Ector_Renderer_G
 
    if (!obj) return NULL;
 
-   pd->base = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS, obj);
-   pd->radial = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_GRADIENT_RADIAL_MIXIN, obj);
-   pd->gradient = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_GRADIENT_MIXIN, obj);
+   pd->base = eo_data_xref(obj, ECTOR_RENDERER_CLASS, obj);
+   pd->radial = eo_data_xref(obj, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN, obj);
+   pd->gradient = eo_data_xref(obj, ECTOR_RENDERER_GRADIENT_MIXIN, obj);
 
    return obj;
 }
diff --git a/src/lib/ector/gl/ector_renderer_gl_gradient_radial.eo b/src/lib/ector/gl/ector_renderer_gl_gradient_radial.eo
index d57a973807..be1f0f0ec2 100644
--- a/src/lib/ector/gl/ector_renderer_gl_gradient_radial.eo
+++ b/src/lib/ector/gl/ector_renderer_gl_gradient_radial.eo
@@ -1,12 +1,12 @@
-class Ector.Renderer.GL.Gradient_Radial (Ector.Renderer.GL, Ector.Renderer.Generic.Gradient, Ector.Renderer.Generic.Gradient_Radial)
+class Ector.Renderer.GL.Gradient_Radial (Ector.Renderer.GL, Ector.Renderer.Gradient, Ector.Renderer.Gradient_Radial)
 {
    eo_prefix: ector_renderer_gl_gradient_radial;
    legacy_prefix: null;
    implements {
-      Ector.Renderer.Generic.Base.prepare;
-      Ector.Renderer.Generic.Base.draw;
-      Ector.Renderer.Generic.Base.bounds_get;
-      Ector.Renderer.Generic.Base.crc.get;
+      Ector.Renderer.prepare;
+      Ector.Renderer.draw;
+      Ector.Renderer.bounds_get;
+      Ector.Renderer.crc.get;
       Ector.Renderer.GL.fill;
       Eo.Base.constructor;
       Eo.Base.destructor;
diff --git a/src/lib/ector/gl/ector_renderer_gl_shape.c b/src/lib/ector/gl/ector_renderer_gl_shape.c
index 4fcac48dd6..b6bd8efc26 100644
--- a/src/lib/ector/gl/ector_renderer_gl_shape.c
+++ b/src/lib/ector/gl/ector_renderer_gl_shape.c
@@ -14,8 +14,8 @@ struct _Ector_Renderer_GL_Shape_Data
 {
    Efl_Gfx_Shape_Public *public_shape;
 
-   Ector_Renderer_Generic_Shape_Data *shape;
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Shape_Data *shape;
+   Ector_Renderer_Data *base;
 
    GLshort *vertex;
 };
@@ -32,7 +32,7 @@ _ector_renderer_gl_shape_path_changed(void *data, const Eo_Event *event EINA_UNU
 }
 
 static Eina_Bool
-_ector_renderer_gl_shape_ector_renderer_generic_base_prepare(Eo *obj, Ector_Renderer_GL_Shape_Data *pd)
+_ector_renderer_gl_shape_ector_renderer_prepare(Eo *obj, Ector_Renderer_GL_Shape_Data *pd)
 {
    Eina_Rectangle bounding_box;
    Eina_Bool r;
@@ -70,7 +70,7 @@ _ector_renderer_gl_shape_ector_renderer_generic_base_prepare(Eo *obj, Ector_Rend
 }
 
 static Eina_Bool
-_ector_renderer_gl_shape_ector_renderer_generic_base_draw(Eo *obj, Ector_Renderer_GL_Shape_Data *pd, Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
+_ector_renderer_gl_shape_ector_renderer_draw(Eo *obj, Ector_Renderer_GL_Shape_Data *pd, Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
 {
    uint64_t flags = 0;
 
@@ -107,7 +107,7 @@ _ector_renderer_gl_shape_ector_renderer_gl_fill(Eo *obj EINA_UNUSED,
 }
 
 static void
-_ector_renderer_gl_shape_ector_renderer_generic_base_bounds_get(Eo *obj, Ector_Renderer_GL_Shape_Data *pd, Eina_Rectangle *r)
+_ector_renderer_gl_shape_ector_renderer_bounds_get(Eo *obj, Ector_Renderer_GL_Shape_Data *pd, Eina_Rectangle *r)
 {
    efl_gfx_shape_bounds_get(obj, r);
 
@@ -116,7 +116,7 @@ _ector_renderer_gl_shape_ector_renderer_generic_base_bounds_get(Eo *obj, Ector_R
 }
 
 static unsigned int
-_ector_renderer_gl_shape_ector_renderer_generic_base_crc_get(Eo *obj, Ector_Renderer_GL_Shape_Data *pd)
+_ector_renderer_gl_shape_ector_renderer_crc_get(Eo *obj, Ector_Renderer_GL_Shape_Data *pd)
 {
    unsigned int crc;
 
@@ -148,8 +148,8 @@ _ector_renderer_gl_shape_eo_base_constructor(Eo *obj, Ector_Renderer_GL_Shape_Da
    if (!obj) return NULL;
 
    pd->public_shape = eo_data_xref(obj, EFL_GFX_SHAPE_MIXIN, obj);
-   pd->shape = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_SHAPE_MIXIN, obj);
-   pd->base = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS, obj);
+   pd->shape = eo_data_xref(obj, ECTOR_RENDERER_SHAPE_MIXIN, obj);
+   pd->base = eo_data_xref(obj, ECTOR_RENDERER_CLASS, obj);
 
    eo_event_callback_add(obj, EFL_GFX_PATH_CHANGED, _ector_renderer_gl_shape_path_changed, pd);
 
diff --git a/src/lib/ector/gl/ector_renderer_gl_shape.eo b/src/lib/ector/gl/ector_renderer_gl_shape.eo
index ba75b51aa9..1c93022c3e 100644
--- a/src/lib/ector/gl/ector_renderer_gl_shape.eo
+++ b/src/lib/ector/gl/ector_renderer_gl_shape.eo
@@ -1,12 +1,12 @@
-class Ector.Renderer.GL.Shape (Ector.Renderer.GL, Ector.Renderer.Generic.Shape)
+class Ector.Renderer.GL.Shape (Ector.Renderer.GL, Ector.Renderer.Shape)
 {
    eo_prefix: ector_renderer_gl_shape;
    legacy_prefix: null;
    implements {
-      Ector.Renderer.Generic.Base.prepare;
-      Ector.Renderer.Generic.Base.draw;
-      Ector.Renderer.Generic.Base.bounds_get;
-      Ector.Renderer.Generic.Base.crc.get;
+      Ector.Renderer.prepare;
+      Ector.Renderer.draw;
+      Ector.Renderer.bounds_get;
+      Ector.Renderer.crc.get;
       Ector.Renderer.GL.fill;
       Eo.Base.constructor;
       Eo.Base.destructor;
diff --git a/src/lib/ector/software/ector_renderer_software.eo b/src/lib/ector/software/ector_renderer_software.eo
index fe8c02c712..aa9e46e993 100644
--- a/src/lib/ector/software/ector_renderer_software.eo
+++ b/src/lib/ector/software/ector_renderer_software.eo
@@ -1,4 +1,4 @@
-class Ector.Renderer.Software (Ector.Renderer.Generic.Base)
+class Ector.Renderer.Software (Ector.Renderer)
 {
    legacy_prefix: null;
    data: null;
diff --git a/src/lib/ector/software/ector_renderer_software_buffer.c b/src/lib/ector/software/ector_renderer_software_buffer.c
index f5af5a7cb3..e16ec6ee46 100644
--- a/src/lib/ector/software/ector_renderer_software_buffer.c
+++ b/src/lib/ector/software/ector_renderer_software_buffer.c
@@ -13,19 +13,19 @@
 
 typedef struct
 {
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Data *base;
    Software_Rasterizer *surface;
    Ector_Buffer *eo_buffer;
 } Ector_Renderer_Software_Buffer_Data;
 
 
 EOLIAN static void
-_ector_renderer_software_buffer_buffer_set(Eo *obj, Ector_Renderer_Software_Buffer_Data *pd, Ector_Generic_Buffer *buf)
+_ector_renderer_software_buffer_buffer_set(Eo *obj, Ector_Renderer_Software_Buffer_Data *pd, Ector_Buffer *buf)
 {
    _eo_xrefplace(&pd->eo_buffer, buf, obj);
 }
 
-EOLIAN static Ector_Generic_Buffer *
+EOLIAN static Ector_Buffer *
 _ector_renderer_software_buffer_buffer_get(Eo *obj EINA_UNUSED, Ector_Renderer_Software_Buffer_Data *pd)
 {
    return pd->eo_buffer;
@@ -40,7 +40,7 @@ _ector_renderer_software_buffer_ector_renderer_software_fill(Eo *obj, Ector_Rend
 }
 
 EOLIAN static Eina_Bool
-_ector_renderer_software_buffer_ector_renderer_generic_base_prepare(Eo *obj, Ector_Renderer_Software_Buffer_Data *pd)
+_ector_renderer_software_buffer_ector_renderer_prepare(Eo *obj, Ector_Renderer_Software_Buffer_Data *pd)
 {
    if (!pd->surface)
      pd->surface = eo_data_xref(pd->base->surface, ECTOR_SOFTWARE_SURFACE_CLASS, obj);
@@ -49,7 +49,7 @@ _ector_renderer_software_buffer_ector_renderer_generic_base_prepare(Eo *obj, Ect
 }
 
 EOLIAN static unsigned int
-_ector_renderer_software_buffer_ector_renderer_generic_base_crc_get(Eo *obj, Ector_Renderer_Software_Buffer_Data *pd)
+_ector_renderer_software_buffer_ector_renderer_crc_get(Eo *obj, Ector_Renderer_Software_Buffer_Data *pd)
 {
    Ector_Software_Buffer_Base_Data *buffer = eo_data_scope_get(pd->eo_buffer, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN);
    unsigned int crc;
diff --git a/src/lib/ector/software/ector_renderer_software_buffer.eo b/src/lib/ector/software/ector_renderer_software_buffer.eo
index 3a17c56df7..3595a3cb45 100644
--- a/src/lib/ector/software/ector_renderer_software_buffer.eo
+++ b/src/lib/ector/software/ector_renderer_software_buffer.eo
@@ -1,4 +1,4 @@
-class Ector.Renderer.Software.Buffer (Ector.Renderer.Software, Ector.Renderer.Generic.Buffer)
+class Ector.Renderer.Software.Buffer (Ector.Renderer.Software, Ector.Renderer.Buffer)
 {
    legacy_prefix: null;
    methods {
@@ -6,13 +6,13 @@ class Ector.Renderer.Software.Buffer (Ector.Renderer.Software, Ector.Renderer.Ge
          set {}
          get {}
          values {
-            buf: Ector.Generic.Buffer *;
+            buf: Ector.Buffer *;
          }
       }
    }
    implements {
-      Ector.Renderer.Generic.Base.prepare;
-      Ector.Renderer.Generic.Base.crc.get;
+      Ector.Renderer.prepare;
+      Ector.Renderer.crc.get;
       Ector.Renderer.Software.fill;
       Eo.Base.destructor;
    }
diff --git a/src/lib/ector/software/ector_renderer_software_gradient_linear.c b/src/lib/ector/software/ector_renderer_software_gradient_linear.c
index 9428366352..d5d5effc5e 100644
--- a/src/lib/ector/software/ector_renderer_software_gradient_linear.c
+++ b/src/lib/ector/software/ector_renderer_software_gradient_linear.c
@@ -10,14 +10,14 @@
 #include "ector_software_private.h"
 
 static Eina_Bool
-_ector_renderer_software_gradient_linear_ector_renderer_generic_base_prepare(Eo *obj,
+_ector_renderer_software_gradient_linear_ector_renderer_prepare(Eo *obj,
                                                                              Ector_Renderer_Software_Gradient_Data *pd)
 {
    if (!pd->surface)
      {
-        Ector_Renderer_Generic_Base_Data *base;
+        Ector_Renderer_Data *base;
 
-        base = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS);
+        base = eo_data_scope_get(obj, ECTOR_RENDERER_CLASS);
         pd->surface = eo_data_xref(base->surface, ECTOR_SOFTWARE_SURFACE_CLASS, obj);
      }
 
@@ -45,7 +45,7 @@ _ector_renderer_software_gradient_linear_ector_renderer_generic_base_prepare(Eo
 }
 
 static Eina_Bool
-_ector_renderer_software_gradient_linear_ector_renderer_generic_base_draw(Eo *obj EINA_UNUSED,
+_ector_renderer_software_gradient_linear_ector_renderer_draw(Eo *obj EINA_UNUSED,
                                                                           Ector_Renderer_Software_Gradient_Data *pd EINA_UNUSED,
                                                                           Efl_Gfx_Render_Op op EINA_UNUSED, Eina_Array *clips EINA_UNUSED,
                                                                           unsigned int mul_col EINA_UNUSED)
@@ -69,8 +69,8 @@ _ector_renderer_software_gradient_linear_eo_base_constructor(Eo *obj,
    obj = eo_constructor(eo_super(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_LINEAR_CLASS));
    if (!obj) return NULL;
 
-   pd->gd  = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_GRADIENT_MIXIN, obj);
-   pd->gld = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_GRADIENT_LINEAR_MIXIN, obj);
+   pd->gd  = eo_data_xref(obj, ECTOR_RENDERER_GRADIENT_MIXIN, obj);
+   pd->gld = eo_data_xref(obj, ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN, obj);
 
    return obj;
 }
@@ -79,11 +79,11 @@ static void
 _ector_renderer_software_gradient_linear_eo_base_destructor(Eo *obj,
                                                             Ector_Renderer_Software_Gradient_Data *pd)
 {
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Data *base;
 
    destroy_color_table(pd);
 
-   base = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS);
+   base = eo_data_scope_get(obj, ECTOR_RENDERER_CLASS);
    eo_data_xunref(base->surface, pd->surface, obj);
 
    eo_data_xunref(obj, pd->gd, obj);
@@ -101,7 +101,7 @@ _ector_renderer_software_gradient_linear_efl_gfx_gradient_stop_set(Eo *obj, Ecto
 }
 
 static unsigned int
-_ector_renderer_software_gradient_linear_ector_renderer_generic_base_crc_get(Eo *obj, Ector_Renderer_Software_Gradient_Data *pd)
+_ector_renderer_software_gradient_linear_ector_renderer_crc_get(Eo *obj, Ector_Renderer_Software_Gradient_Data *pd)
 {
    unsigned int crc;
 
@@ -110,7 +110,7 @@ _ector_renderer_software_gradient_linear_ector_renderer_generic_base_crc_get(Eo
    crc = eina_crc((void*) pd->gd->s, sizeof (Efl_Gfx_Gradient_Spread), crc, EINA_FALSE);
    if (pd->gd->colors_count)
      crc = eina_crc((void*) pd->gd->colors, sizeof (Efl_Gfx_Gradient_Stop) * pd->gd->colors_count, crc, EINA_FALSE);
-   crc = eina_crc((void*) pd->gld, sizeof (Ector_Renderer_Generic_Gradient_Linear_Data), crc, EINA_FALSE);
+   crc = eina_crc((void*) pd->gld, sizeof (Ector_Renderer_Gradient_Linear_Data), crc, EINA_FALSE);
 
    return crc;
 }
diff --git a/src/lib/ector/software/ector_renderer_software_gradient_linear.eo b/src/lib/ector/software/ector_renderer_software_gradient_linear.eo
index 1f52a4427f..799119d6d3 100644
--- a/src/lib/ector/software/ector_renderer_software_gradient_linear.eo
+++ b/src/lib/ector/software/ector_renderer_software_gradient_linear.eo
@@ -1,12 +1,12 @@
-class Ector.Renderer.Software.Gradient_Linear (Ector.Renderer.Software, Ector.Renderer.Generic.Gradient, Ector.Renderer.Generic.Gradient_Linear)
+class Ector.Renderer.Software.Gradient_Linear (Ector.Renderer.Software, Ector.Renderer.Gradient, Ector.Renderer.Gradient_Linear)
 {
    eo_prefix: ector_renderer_software_gradient_linear;
    legacy_prefix: null;
    data: Ector_Renderer_Software_Gradient_Data;
    implements {
-      Ector.Renderer.Generic.Base.prepare;
-      Ector.Renderer.Generic.Base.draw;
-      Ector.Renderer.Generic.Base.crc.get;
+      Ector.Renderer.prepare;
+      Ector.Renderer.draw;
+      Ector.Renderer.crc.get;
       Ector.Renderer.Software.fill;
       Eo.Base.constructor;
       Eo.Base.destructor;
diff --git a/src/lib/ector/software/ector_renderer_software_gradient_radial.c b/src/lib/ector/software/ector_renderer_software_gradient_radial.c
index 1d164e6b22..1154fea263 100644
--- a/src/lib/ector/software/ector_renderer_software_gradient_radial.c
+++ b/src/lib/ector/software/ector_renderer_software_gradient_radial.c
@@ -10,13 +10,13 @@
 #include "ector_software_private.h"
 
 static Eina_Bool
-_ector_renderer_software_gradient_radial_ector_renderer_generic_base_prepare(Eo *obj, Ector_Renderer_Software_Gradient_Data *pd)
+_ector_renderer_software_gradient_radial_ector_renderer_prepare(Eo *obj, Ector_Renderer_Software_Gradient_Data *pd)
 {
    if (!pd->surface)
      {
-        Ector_Renderer_Generic_Base_Data *base;
+        Ector_Renderer_Data *base;
 
-        base = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS);
+        base = eo_data_scope_get(obj, ECTOR_RENDERER_CLASS);
         pd->surface = eo_data_xref(base->surface, ECTOR_SOFTWARE_SURFACE_CLASS, obj);
      }
 
@@ -56,7 +56,7 @@ _ector_renderer_software_gradient_radial_ector_renderer_generic_base_prepare(Eo
 
 // Clearly duplicated and should be in a common place...
 static Eina_Bool
-_ector_renderer_software_gradient_radial_ector_renderer_generic_base_draw(Eo *obj EINA_UNUSED,
+_ector_renderer_software_gradient_radial_ector_renderer_draw(Eo *obj EINA_UNUSED,
                                                                           Ector_Renderer_Software_Gradient_Data *pd EINA_UNUSED,
                                                                           Efl_Gfx_Render_Op op EINA_UNUSED, Eina_Array *clips EINA_UNUSED,
                                                                           unsigned int mul_col EINA_UNUSED)
@@ -77,8 +77,8 @@ _ector_renderer_software_gradient_radial_eo_base_constructor(Eo *obj,
                                                              Ector_Renderer_Software_Gradient_Data *pd)
 {
    obj = eo_constructor(eo_super(obj, ECTOR_RENDERER_SOFTWARE_GRADIENT_RADIAL_CLASS));
-   pd->gd  = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_GRADIENT_MIXIN, obj);
-   pd->gld = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_GRADIENT_RADIAL_MIXIN, obj);
+   pd->gd  = eo_data_xref(obj, ECTOR_RENDERER_GRADIENT_MIXIN, obj);
+   pd->gld = eo_data_xref(obj, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN, obj);
 
    return obj;
 }
@@ -87,11 +87,11 @@ void
 _ector_renderer_software_gradient_radial_eo_base_destructor(Eo *obj,
                                                             Ector_Renderer_Software_Gradient_Data *pd)
 {
-   Ector_Renderer_Generic_Base_Data *base;
+   Ector_Renderer_Data *base;
 
    destroy_color_table(pd);
 
-   base = eo_data_scope_get(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS);
+   base = eo_data_scope_get(obj, ECTOR_RENDERER_CLASS);
    eo_data_xunref(base->surface, pd->surface, obj);
 
    eo_data_xunref(obj, pd->gd, obj);
@@ -109,7 +109,7 @@ _ector_renderer_software_gradient_radial_efl_gfx_gradient_stop_set(Eo *obj, Ecto
 }
 
 static unsigned int
-_ector_renderer_software_gradient_radial_ector_renderer_generic_base_crc_get(Eo *obj, Ector_Renderer_Software_Gradient_Data *pd)
+_ector_renderer_software_gradient_radial_ector_renderer_crc_get(Eo *obj, Ector_Renderer_Software_Gradient_Data *pd)
 {
    unsigned int crc;
 
@@ -118,7 +118,7 @@ _ector_renderer_software_gradient_radial_ector_renderer_generic_base_crc_get(Eo
    crc = eina_crc((void*) pd->gd->s, sizeof (Efl_Gfx_Gradient_Spread), crc, EINA_FALSE);
    if (pd->gd->colors_count)
      crc = eina_crc((void*) pd->gd->colors, sizeof (Efl_Gfx_Gradient_Stop) * pd->gd->colors_count, crc, EINA_FALSE);
-   crc = eina_crc((void*) pd->gld, sizeof (Ector_Renderer_Generic_Gradient_Radial_Data), crc, EINA_FALSE);
+   crc = eina_crc((void*) pd->gld, sizeof (Ector_Renderer_Gradient_Radial_Data), crc, EINA_FALSE);
 
    return crc;
 }
diff --git a/src/lib/ector/software/ector_renderer_software_gradient_radial.eo b/src/lib/ector/software/ector_renderer_software_gradient_radial.eo
index 6590a399cb..b3dc7730fd 100644
--- a/src/lib/ector/software/ector_renderer_software_gradient_radial.eo
+++ b/src/lib/ector/software/ector_renderer_software_gradient_radial.eo
@@ -1,12 +1,12 @@
-class Ector.Renderer.Software.Gradient_Radial (Ector.Renderer.Software, Ector.Renderer.Generic.Gradient, Ector.Renderer.Generic.Gradient_Radial)
+class Ector.Renderer.Software.Gradient_Radial (Ector.Renderer.Software, Ector.Renderer.Gradient, Ector.Renderer.Gradient_Radial)
 {
    eo_prefix: ector_renderer_software_gradient_radial;
    legacy_prefix: null;
    data: Ector_Renderer_Software_Gradient_Data;
    implements {
-      Ector.Renderer.Generic.Base.prepare;
-      Ector.Renderer.Generic.Base.draw;
-      Ector.Renderer.Generic.Base.crc.get;
+      Ector.Renderer.prepare;
+      Ector.Renderer.draw;
+      Ector.Renderer.crc.get;
       Ector.Renderer.Software.fill;
       Eo.Base.constructor;
       Eo.Base.destructor;
diff --git a/src/lib/ector/software/ector_renderer_software_shape.c b/src/lib/ector/software/ector_renderer_software_shape.c
index 78e98151e4..835e0ac4b8 100644
--- a/src/lib/ector/software/ector_renderer_software_shape.c
+++ b/src/lib/ector/software/ector_renderer_software_shape.c
@@ -18,8 +18,8 @@ struct _Ector_Renderer_Software_Shape_Data
    Efl_Gfx_Shape_Public                *public_shape;
 
    Ector_Software_Surface_Data         *surface;
-   Ector_Renderer_Generic_Shape_Data   *shape;
-   Ector_Renderer_Generic_Base_Data    *base;
+   Ector_Renderer_Shape_Data   *shape;
+   Ector_Renderer_Data    *base;
 
    Shape_Rle_Data                      *shape_data;
    Shape_Rle_Data                      *outline_data;
@@ -571,7 +571,7 @@ _update_rle(Eo *obj, Ector_Renderer_Software_Shape_Data *pd)
 }
 
 static Eina_Bool
-_ector_renderer_software_shape_ector_renderer_generic_base_prepare(Eo *obj,
+_ector_renderer_software_shape_ector_renderer_prepare(Eo *obj,
                                                                    Ector_Renderer_Software_Shape_Data *pd)
 {
    // FIXME: shouldn't that be part of the shape generic implementation ?
@@ -590,7 +590,7 @@ _ector_renderer_software_shape_ector_renderer_generic_base_prepare(Eo *obj,
 }
 
 static Eina_Bool
-_ector_renderer_software_shape_ector_renderer_generic_base_draw(Eo *obj,
+_ector_renderer_software_shape_ector_renderer_draw(Eo *obj,
                                                                 Ector_Renderer_Software_Shape_Data *pd,
                                                                 Efl_Gfx_Render_Op op, Eina_Array *clips,
                                                                 unsigned int mul_col)
@@ -700,8 +700,8 @@ _ector_renderer_software_shape_eo_base_constructor(Eo *obj, Ector_Renderer_Softw
    if (!obj) return NULL;
 
    pd->public_shape = eo_data_xref(obj, EFL_GFX_SHAPE_MIXIN, obj);
-   pd->shape = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_SHAPE_MIXIN, obj);
-   pd->base = eo_data_xref(obj, ECTOR_RENDERER_GENERIC_BASE_CLASS, obj);
+   pd->shape = eo_data_xref(obj, ECTOR_RENDERER_SHAPE_MIXIN, obj);
+   pd->base = eo_data_xref(obj, ECTOR_RENDERER_CLASS, obj);
    eo_event_callback_add(obj, EFL_GFX_PATH_CHANGED, _ector_renderer_software_shape_path_changed, pd);
 
    return obj;
@@ -725,7 +725,7 @@ _ector_renderer_software_shape_eo_base_destructor(Eo *obj, Ector_Renderer_Softwa
 
 
 unsigned int
-_ector_renderer_software_shape_ector_renderer_generic_base_crc_get(Eo *obj,
+_ector_renderer_software_shape_ector_renderer_crc_get(Eo *obj,
                                                                    Ector_Renderer_Software_Shape_Data *pd)
 {
    unsigned int crc;
diff --git a/src/lib/ector/software/ector_renderer_software_shape.eo b/src/lib/ector/software/ector_renderer_software_shape.eo
index e7a69aad82..bb0374b07b 100644
--- a/src/lib/ector/software/ector_renderer_software_shape.eo
+++ b/src/lib/ector/software/ector_renderer_software_shape.eo
@@ -1,12 +1,12 @@
-class Ector.Renderer.Software.Shape (Ector.Renderer.Software, Ector.Renderer.Generic.Shape)
+class Ector.Renderer.Software.Shape (Ector.Renderer.Software, Ector.Renderer.Shape)
 {
    eo_prefix: ector_renderer_software_shape;
    legacy_prefix: null;
    implements {
-      Ector.Renderer.Generic.Base.prepare;
-      Ector.Renderer.Generic.Base.draw;
+      Ector.Renderer.prepare;
+      Ector.Renderer.draw;
       Ector.Renderer.Software.fill;
-      Ector.Renderer.Generic.Base.crc.get;
+      Ector.Renderer.crc.get;
       Efl.Gfx.Shape.path.set;
       Eo.Base.constructor;
       Eo.Base.destructor;      
diff --git a/src/lib/ector/software/ector_software_buffer.c b/src/lib/ector/software/ector_software_buffer.c
index ecbac54373..65c21c993c 100644
--- a/src/lib/ector/software/ector_software_buffer.c
+++ b/src/lib/ector/software/ector_software_buffer.c
@@ -69,7 +69,7 @@ _ector_software_buffer_base_pixels_clear(Eo *obj, Ector_Software_Buffer_Base_Dat
         return;
      }
 
-   eo_event_callback_call(obj, ECTOR_GENERIC_BUFFER_EVENT_DETACHED, pd->pixels.u8);
+   eo_event_callback_call(obj, ECTOR_BUFFER_EVENT_DETACHED, pd->pixels.u8);
    if (!pd->nofree)
      {
         free(pd->pixels.u8);
@@ -79,7 +79,7 @@ _ector_software_buffer_base_pixels_clear(Eo *obj, Ector_Software_Buffer_Base_Dat
 }
 
 EOLIAN static Eina_Bool
-_ector_software_buffer_base_ector_generic_buffer_pixels_set(Eo *obj, Ector_Software_Buffer_Base_Data *pd,
+_ector_software_buffer_base_ector_buffer_pixels_set(Eo *obj, Ector_Software_Buffer_Base_Data *pd,
                                                             void *pixels, int width, int height, int stride,
                                                             Efl_Gfx_Colorspace cspace, Eina_Bool writable,
                                                             unsigned char l, unsigned char r,
@@ -152,7 +152,7 @@ _ector_software_buffer_base_ector_generic_buffer_pixels_set(Eo *obj, Ector_Softw
 }
 
 EOLIAN static void *
-_ector_software_buffer_base_ector_generic_buffer_map(Eo *obj EINA_UNUSED, Ector_Software_Buffer_Base_Data *pd,
+_ector_software_buffer_base_ector_buffer_map(Eo *obj EINA_UNUSED, Ector_Software_Buffer_Base_Data *pd,
                                                      unsigned int *length, Ector_Buffer_Access_Flag mode,
                                                      unsigned int x, unsigned int y, unsigned int w, unsigned int h,
                                                      Efl_Gfx_Colorspace cspace EINA_UNUSED, unsigned int *stride)
@@ -246,7 +246,7 @@ on_fail:
 }
 
 EOLIAN static void
-_ector_software_buffer_base_ector_generic_buffer_unmap(Eo *obj EINA_UNUSED, Ector_Software_Buffer_Base_Data *pd,
+_ector_software_buffer_base_ector_buffer_unmap(Eo *obj EINA_UNUSED, Ector_Software_Buffer_Base_Data *pd,
                                                        void *data, unsigned int length)
 {
    Ector_Software_Buffer_Map *map;
@@ -302,26 +302,26 @@ _ector_software_buffer_base_ector_generic_buffer_unmap(Eo *obj EINA_UNUSED, Ecto
 }
 
 EOLIAN static uint8_t *
-_ector_software_buffer_base_ector_generic_buffer_span_get(Eo *obj, Ector_Software_Buffer_Base_Data *pd,
+_ector_software_buffer_base_ector_buffer_span_get(Eo *obj, Ector_Software_Buffer_Base_Data *pd,
                                                           int x, int y, unsigned int w, Efl_Gfx_Colorspace cspace,
                                                           unsigned int *length)
 {
    // ector_buffer_map
-   return _ector_software_buffer_base_ector_generic_buffer_map
+   return _ector_software_buffer_base_ector_buffer_map
          (obj, pd, length, ECTOR_BUFFER_ACCESS_FLAG_READ, x, y, w, 1, cspace, NULL);
 }
 
 EOLIAN static void
-_ector_software_buffer_base_ector_generic_buffer_span_free(Eo *obj, Ector_Software_Buffer_Base_Data *pd,
+_ector_software_buffer_base_ector_buffer_span_free(Eo *obj, Ector_Software_Buffer_Base_Data *pd,
                                                            uint8_t *data)
 {
    // ector_buffer_unmap
-   return _ector_software_buffer_base_ector_generic_buffer_unmap
+   return _ector_software_buffer_base_ector_buffer_unmap
          (obj, pd, data, (unsigned int) -1);
 }
 
 EOLIAN static Ector_Buffer_Flag
-_ector_software_buffer_base_ector_generic_buffer_flags_get(Eo *obj EINA_UNUSED, Ector_Software_Buffer_Base_Data *pd)
+_ector_software_buffer_base_ector_buffer_flags_get(Eo *obj EINA_UNUSED, Ector_Software_Buffer_Base_Data *pd)
 {
    return ECTOR_BUFFER_FLAG_CPU_READABLE |
          ECTOR_BUFFER_FLAG_DRAWABLE |
@@ -338,7 +338,7 @@ _ector_software_buffer_eo_base_constructor(Eo *obj, void *data EINA_UNUSED)
    Ector_Software_Buffer_Base_Data *pd;
    obj = eo_constructor(eo_super(obj, MY_CLASS));
    pd = eo_data_scope_get(obj, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN);
-   pd->generic = eo_data_ref(obj, ECTOR_GENERIC_BUFFER_MIXIN);
+   pd->generic = eo_data_ref(obj, ECTOR_BUFFER_MIXIN);
    pd->generic->eo = obj;
    return obj;
 }
diff --git a/src/lib/ector/software/ector_software_buffer_base.eo b/src/lib/ector/software/ector_software_buffer_base.eo
index 2ada74dc83..aa38738e84 100644
--- a/src/lib/ector/software/ector_software_buffer_base.eo
+++ b/src/lib/ector/software/ector_software_buffer_base.eo
@@ -1,4 +1,4 @@
-mixin Ector.Software.Buffer.Base (Ector.Generic.Buffer)
+mixin Ector.Software.Buffer.Base (Ector.Buffer)
 {
    [[A buffer in Ector Software is a readable & optionally writable image]]
    eo_prefix: ector_software_buffer;
@@ -9,11 +9,11 @@ mixin Ector.Software.Buffer.Base (Ector.Generic.Buffer)
       }
    }
    implements {
-      Ector.Generic.Buffer.flags.get;
-      Ector.Generic.Buffer.pixels_set;
-      Ector.Generic.Buffer.span_get;
-      Ector.Generic.Buffer.span_free;
-      Ector.Generic.Buffer.map;
-      Ector.Generic.Buffer.unmap;
+      Ector.Buffer.flags.get;
+      Ector.Buffer.pixels_set;
+      Ector.Buffer.span_get;
+      Ector.Buffer.span_free;
+      Ector.Buffer.map;
+      Ector.Buffer.unmap;
    }
 }
diff --git a/src/lib/ector/software/ector_software_private.h b/src/lib/ector/software/ector_software_private.h
index e13342d02d..1aa151146e 100644
--- a/src/lib/ector/software/ector_software_private.h
+++ b/src/lib/ector/software/ector_software_private.h
@@ -25,10 +25,10 @@ typedef struct _Software_Gradient_Radial_Data
 typedef struct _Ector_Renderer_Software_Gradient_Data
 {
    Ector_Software_Surface_Data *surface;
-   Ector_Renderer_Generic_Gradient_Data *gd;
+   Ector_Renderer_Gradient_Data *gd;
    union {
-      Ector_Renderer_Generic_Gradient_Linear_Data *gld;
-      Ector_Renderer_Generic_Gradient_Radial_Data *grd;
+      Ector_Renderer_Gradient_Linear_Data *gld;
+      Ector_Renderer_Gradient_Radial_Data *grd;
    };
    union {
       Software_Gradient_Linear_Data linear;
diff --git a/src/lib/ector/software/ector_software_surface.c b/src/lib/ector/software/ector_software_surface.c
index f71375a72e..ab5fe90b7a 100644
--- a/src/lib/ector/software/ector_software_surface.c
+++ b/src/lib/ector/software/ector_software_surface.c
@@ -11,17 +11,17 @@
 #define MY_CLASS ECTOR_SOFTWARE_SURFACE_CLASS
 
 static Ector_Renderer *
-_ector_software_surface_ector_generic_surface_renderer_factory_new(Eo *obj,
+_ector_software_surface_ector_surface_renderer_factory_new(Eo *obj,
                                                                    Ector_Software_Surface_Data *pd EINA_UNUSED,
                                                                    const Eo_Class *type)
 {
-   if (type == ECTOR_RENDERER_GENERIC_SHAPE_MIXIN)
+   if (type == ECTOR_RENDERER_SHAPE_MIXIN)
      return eo_add(ECTOR_RENDERER_SOFTWARE_SHAPE_CLASS, NULL, ector_renderer_surface_set(eo_self, obj));
-   else if (type == ECTOR_RENDERER_GENERIC_GRADIENT_LINEAR_MIXIN)
+   else if (type == ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN)
      return eo_add(ECTOR_RENDERER_SOFTWARE_GRADIENT_LINEAR_CLASS, NULL, ector_renderer_surface_set(eo_self, obj));
-   else if (type == ECTOR_RENDERER_GENERIC_GRADIENT_RADIAL_MIXIN)
+   else if (type == ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN)
      return eo_add(ECTOR_RENDERER_SOFTWARE_GRADIENT_RADIAL_CLASS, NULL, ector_renderer_surface_set(eo_self, obj));
-   else if (type == ECTOR_RENDERER_GENERIC_BUFFER_MIXIN)
+   else if (type == ECTOR_RENDERER_BUFFER_MIXIN)
      return eo_add(ECTOR_RENDERER_SOFTWARE_BUFFER_CLASS, NULL, ector_renderer_surface_set(eo_self, obj));
    ERR("Couldn't find class for type: %s\n", eo_class_name_get(type));
    return NULL;
@@ -48,7 +48,7 @@ _ector_software_surface_eo_base_destructor(Eo *obj, Ector_Software_Surface_Data
 }
 
 static void
-_ector_software_surface_ector_generic_surface_reference_point_set(Eo *obj EINA_UNUSED,
+_ector_software_surface_ector_surface_reference_point_set(Eo *obj EINA_UNUSED,
                                                                   Ector_Software_Surface_Data *pd,
                                                                   int x, int y)
 {
diff --git a/src/lib/ector/software/ector_software_surface.eo b/src/lib/ector/software/ector_software_surface.eo
index 34507e6549..c01adca6bd 100644
--- a/src/lib/ector/software/ector_software_surface.eo
+++ b/src/lib/ector/software/ector_software_surface.eo
@@ -1,11 +1,11 @@
-class Ector.Software.Surface (Ector.Software.Buffer, Ector.Generic.Surface)
+class Ector.Software.Surface (Ector.Software.Buffer, Ector.Surface)
 {
    eo_prefix: ector_software_surface;
    legacy_prefix: null;
    methods {}
    implements {
-      Ector.Generic.Surface.renderer_factory_new;
-      Ector.Generic.Surface.reference_point.set;
+      Ector.Surface.renderer_factory_new;
+      Ector.Surface.reference_point.set;
       Eo.Base.destructor;
       Eo.Base.constructor;
    }
diff --git a/src/lib/evas/canvas/evas_vg_gradient_linear.c b/src/lib/evas/canvas/evas_vg_gradient_linear.c
index 471556f351..6fd12b2b6b 100644
--- a/src/lib/evas/canvas/evas_vg_gradient_linear.c
+++ b/src/lib/evas/canvas/evas_vg_gradient_linear.c
@@ -73,7 +73,7 @@ _efl_vg_gradient_linear_render_pre(Eo *obj,
 
    if (!nd->renderer)
      {
-        nd->renderer = ector_surface_renderer_factory_new(s, ECTOR_RENDERER_GENERIC_GRADIENT_LINEAR_MIXIN);
+        nd->renderer = ector_surface_renderer_factory_new(s, ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN);
      }
 
    ector_renderer_transformation_set(nd->renderer, current);
diff --git a/src/lib/evas/canvas/evas_vg_gradient_radial.c b/src/lib/evas/canvas/evas_vg_gradient_radial.c
index 91e5c6509d..21cd70308f 100644
--- a/src/lib/evas/canvas/evas_vg_gradient_radial.c
+++ b/src/lib/evas/canvas/evas_vg_gradient_radial.c
@@ -89,7 +89,7 @@ _efl_vg_gradient_radial_render_pre(Eo *obj,
 
    if (!nd->renderer)
      {
-        nd->renderer = ector_surface_renderer_factory_new(s, ECTOR_RENDERER_GENERIC_GRADIENT_RADIAL_MIXIN);
+        nd->renderer = ector_surface_renderer_factory_new(s, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN);
      }
 
    ector_renderer_transformation_set(nd->renderer, current);
diff --git a/src/lib/evas/canvas/evas_vg_shape.c b/src/lib/evas/canvas/evas_vg_shape.c
index 0651c8ced4..527006a3b1 100644
--- a/src/lib/evas/canvas/evas_vg_shape.c
+++ b/src/lib/evas/canvas/evas_vg_shape.c
@@ -145,7 +145,7 @@ _efl_vg_shape_render_pre(Eo *obj EINA_UNUSED,
 
    if (!nd->renderer)
      {
-        nd->renderer = ector_surface_renderer_factory_new(s, ECTOR_RENDERER_GENERIC_SHAPE_MIXIN);
+        nd->renderer = ector_surface_renderer_factory_new(s, ECTOR_RENDERER_SHAPE_MIXIN);
      }
 
    ector_renderer_transformation_set(nd->renderer, current);
diff --git a/src/lib/evas/filters/evas_filter_private.h b/src/lib/evas/filters/evas_filter_private.h
index c4aee71fc9..5ebc981a57 100644
--- a/src/lib/evas/filters/evas_filter_private.h
+++ b/src/lib/evas/filters/evas_filter_private.h
@@ -227,7 +227,7 @@ struct _Evas_Filter_Buffer
 
    Evas_Object *source;
    Eina_Stringshare *source_name;
-   Ector_Generic_Buffer *buffer;
+   Ector_Buffer *buffer;
    int w, h;
 
    Eina_Bool alpha_only : 1;  // 1 channel (A) instead of 4 (RGBA)
diff --git a/src/modules/evas/engines/gl_generic/evas_ector_gl_image_buffer.c b/src/modules/evas/engines/gl_generic/evas_ector_gl_image_buffer.c
index 09e6a08ef9..0c4271eef1 100644
--- a/src/modules/evas/engines/gl_generic/evas_ector_gl_image_buffer.c
+++ b/src/modules/evas/engines/gl_generic/evas_ector_gl_image_buffer.c
@@ -108,7 +108,7 @@ _evas_ector_gl_image_buffer_evas_ector_buffer_engine_image_get(Eo *obj EINA_UNUS
 }
 
 EOLIAN static Ector_Buffer_Flag
-_evas_ector_gl_image_buffer_ector_generic_buffer_flags_get(Eo *obj EINA_UNUSED,
+_evas_ector_gl_image_buffer_ector_buffer_flags_get(Eo *obj EINA_UNUSED,
                                                            Evas_Ector_GL_Image_Buffer_Data *pd)
 {
    Ector_Buffer_Flag flags;
@@ -129,7 +129,7 @@ _evas_ector_gl_image_buffer_ector_generic_buffer_flags_get(Eo *obj EINA_UNUSED,
 }
 
 EOLIAN static void *
-_evas_ector_gl_image_buffer_ector_generic_buffer_map(Eo *obj EINA_UNUSED, Evas_Ector_GL_Image_Buffer_Data *pd, unsigned int *length,
+_evas_ector_gl_image_buffer_ector_buffer_map(Eo *obj EINA_UNUSED, Evas_Ector_GL_Image_Buffer_Data *pd, unsigned int *length,
                                                      Ector_Buffer_Access_Flag mode,
                                                      unsigned int x, unsigned int y, unsigned int w, unsigned int h,
                                                      Efl_Gfx_Colorspace cspace, unsigned int *stride)
@@ -185,7 +185,7 @@ _evas_ector_gl_image_buffer_ector_generic_buffer_map(Eo *obj EINA_UNUSED, Evas_E
 }
 
 EOLIAN static void
-_evas_ector_gl_image_buffer_ector_generic_buffer_unmap(Eo *obj EINA_UNUSED, Evas_Ector_GL_Image_Buffer_Data *pd,
+_evas_ector_gl_image_buffer_ector_buffer_unmap(Eo *obj EINA_UNUSED, Evas_Ector_GL_Image_Buffer_Data *pd,
                                                        void *data, unsigned int length)
 {
    Evas_Public_Data *e = eo_data_scope_get(pd->evas, EVAS_CANVAS_CLASS);
@@ -213,19 +213,19 @@ _evas_ector_gl_image_buffer_ector_generic_buffer_unmap(Eo *obj EINA_UNUSED, Evas
 }
 
 EOLIAN static uint8_t *
-_evas_ector_gl_image_buffer_ector_generic_buffer_span_get(Eo *obj, Evas_Ector_GL_Image_Buffer_Data *pd, int x, int y, unsigned int w,
+_evas_ector_gl_image_buffer_ector_buffer_span_get(Eo *obj, Evas_Ector_GL_Image_Buffer_Data *pd, int x, int y, unsigned int w,
                                                           Efl_Gfx_Colorspace cspace, unsigned int *length)
 {
    // ector_buffer_map
-   return _evas_ector_gl_image_buffer_ector_generic_buffer_map
+   return _evas_ector_gl_image_buffer_ector_buffer_map
          (obj, pd, length, ECTOR_BUFFER_ACCESS_FLAG_READ, x, y, w, 1, cspace, NULL);
 }
 
 EOLIAN static void
-_evas_ector_gl_image_buffer_ector_generic_buffer_span_free(Eo *obj, Evas_Ector_GL_Image_Buffer_Data *pd, uint8_t *data)
+_evas_ector_gl_image_buffer_ector_buffer_span_free(Eo *obj, Evas_Ector_GL_Image_Buffer_Data *pd, uint8_t *data)
 {
    // ector_buffer_unmap
-   return _evas_ector_gl_image_buffer_ector_generic_buffer_unmap
+   return _evas_ector_gl_image_buffer_ector_buffer_unmap
          (obj, pd, data, (unsigned int) -1);
 }
 
@@ -235,7 +235,7 @@ _evas_ector_gl_image_buffer_eo_base_constructor(Eo *obj, Evas_Ector_GL_Image_Buf
 {
    obj = eo_constructor(eo_super(obj, MY_CLASS));
    pd->base = eo_data_ref(obj, ECTOR_GL_BUFFER_BASE_MIXIN);
-   pd->base->generic = eo_data_ref(obj, ECTOR_GENERIC_BUFFER_MIXIN);
+   pd->base->generic = eo_data_ref(obj, ECTOR_BUFFER_MIXIN);
    pd->base->generic->eo = obj;
    return obj;
 }
diff --git a/src/modules/evas/engines/gl_generic/evas_ector_gl_image_buffer.eo b/src/modules/evas/engines/gl_generic/evas_ector_gl_image_buffer.eo
index 2eede45d15..3ea2c65a31 100644
--- a/src/modules/evas/engines/gl_generic/evas_ector_gl_image_buffer.eo
+++ b/src/modules/evas/engines/gl_generic/evas_ector_gl_image_buffer.eo
@@ -8,10 +8,10 @@ class Evas.Ector.GL.Image.Buffer (Evas.Ector.GL.Buffer, Evas.Ector.Buffer)
       Eo.Base.destructor;
       Evas.Ector.Buffer.engine_image.set;
       Evas.Ector.Buffer.engine_image.get;
-      Ector.Generic.Buffer.flags.get;
-      Ector.Generic.Buffer.span_get;
-      Ector.Generic.Buffer.span_free;
-      Ector.Generic.Buffer.map;
-      Ector.Generic.Buffer.unmap;
+      Ector.Buffer.flags.get;
+      Ector.Buffer.span_get;
+      Ector.Buffer.span_free;
+      Ector.Buffer.map;
+      Ector.Buffer.unmap;
    }
 }