From 28a2d34ae20885d229accd1c2e482e284be79afc Mon Sep 17 00:00:00 2001 From: Tom Hacohen Date: Wed, 11 May 2016 12:57:06 +0100 Subject: [PATCH] Ector generic: Remove .Generic and .Base (hack no longer needed). --- src/Makefile_Ector.am | 30 ++++---- src/lib/ector/Makefile.am | 30 ++++---- src/lib/ector/cairo/ector_cairo_private.h | 6 +- .../cairo/ector_cairo_software_surface.c | 4 +- .../cairo/ector_cairo_software_surface.eo | 2 +- src/lib/ector/cairo/ector_cairo_surface.c | 10 +-- src/lib/ector/cairo/ector_cairo_surface.eo | 6 +- src/lib/ector/cairo/ector_renderer_cairo.c | 14 ++-- src/lib/ector/cairo/ector_renderer_cairo.eo | 10 +-- .../ector_renderer_cairo_gradient_linear.c | 54 +++++++------- .../ector_renderer_cairo_gradient_linear.eo | 10 +-- .../ector_renderer_cairo_gradient_radial.c | 54 +++++++------- .../ector_renderer_cairo_gradient_radial.eo | 10 +-- .../ector/cairo/ector_renderer_cairo_shape.c | 24 +++---- .../ector/cairo/ector_renderer_cairo_shape.eo | 10 +-- src/lib/ector/ector_buffer.c | 40 +++++++++++ ...ctor_generic_buffer.eo => ector_buffer.eo} | 2 +- src/lib/ector/ector_buffer.h | 12 ++-- src/lib/ector/ector_generic_buffer.c | 40 ----------- src/lib/ector/ector_private.h | 26 +++---- ...nderer_generic_base.c => ector_renderer.c} | 70 +++++++++---------- ...erer_generic_base.eo => ector_renderer.eo} | 6 +- src/lib/ector/ector_renderer.h | 12 ++-- src/lib/ector/ector_renderer_buffer.c | 55 +++++++++++++++ ...ric_buffer.eo => ector_renderer_buffer.eo} | 4 +- src/lib/ector/ector_renderer_generic_buffer.c | 55 --------------- src/lib/ector/ector_renderer_generic_shape.c | 55 --------------- ...c_gradient.c => ector_renderer_gradient.c} | 18 ++--- ...gradient.eo => ector_renderer_gradient.eo} | 2 +- ...ear.c => ector_renderer_gradient_linear.c} | 18 ++--- ...r.eo => ector_renderer_gradient_linear.eo} | 2 +- ...ial.c => ector_renderer_gradient_radial.c} | 26 +++---- ...l.eo => ector_renderer_gradient_radial.eo} | 2 +- src/lib/ector/ector_renderer_shape.c | 55 +++++++++++++++ ...neric_shape.eo => ector_renderer_shape.eo} | 10 +-- ...or_generic_surface.eo => ector_surface.eo} | 2 +- src/lib/ector/ector_surface.h | 2 +- src/lib/ector/gl/ector_gl_buffer_base.eo | 2 +- src/lib/ector/gl/ector_gl_surface.c | 10 +-- src/lib/ector/gl/ector_gl_surface.eo | 6 +- src/lib/ector/gl/ector_renderer_gl.c | 8 +-- src/lib/ector/gl/ector_renderer_gl.eo | 6 +- .../gl/ector_renderer_gl_gradient_linear.c | 22 +++--- .../gl/ector_renderer_gl_gradient_linear.eo | 10 +-- .../gl/ector_renderer_gl_gradient_radial.c | 22 +++--- .../gl/ector_renderer_gl_gradient_radial.eo | 10 +-- src/lib/ector/gl/ector_renderer_gl_shape.c | 16 ++--- src/lib/ector/gl/ector_renderer_gl_shape.eo | 10 +-- .../ector/software/ector_renderer_software.eo | 2 +- .../software/ector_renderer_software_buffer.c | 10 +-- .../ector_renderer_software_buffer.eo | 8 +-- .../ector_renderer_software_gradient_linear.c | 20 +++--- ...ector_renderer_software_gradient_linear.eo | 8 +-- .../ector_renderer_software_gradient_radial.c | 20 +++--- ...ector_renderer_software_gradient_radial.eo | 8 +-- .../software/ector_renderer_software_shape.c | 14 ++-- .../software/ector_renderer_software_shape.eo | 8 +-- .../ector/software/ector_software_buffer.c | 20 +++--- .../software/ector_software_buffer_base.eo | 14 ++-- .../ector/software/ector_software_private.h | 6 +- .../ector/software/ector_software_surface.c | 12 ++-- .../ector/software/ector_software_surface.eo | 6 +- src/lib/evas/canvas/evas_vg_gradient_linear.c | 2 +- src/lib/evas/canvas/evas_vg_gradient_radial.c | 2 +- src/lib/evas/canvas/evas_vg_shape.c | 2 +- src/lib/evas/filters/evas_filter_private.h | 2 +- .../gl_generic/evas_ector_gl_image_buffer.c | 16 ++--- .../gl_generic/evas_ector_gl_image_buffer.eo | 10 +-- 68 files changed, 550 insertions(+), 550 deletions(-) create mode 100644 src/lib/ector/ector_buffer.c rename src/lib/ector/{ector_generic_buffer.eo => ector_buffer.eo} (99%) delete mode 100644 src/lib/ector/ector_generic_buffer.c rename src/lib/ector/{ector_renderer_generic_base.c => ector_renderer.c} (50%) rename src/lib/ector/{ector_renderer_generic_base.eo => ector_renderer.eo} (95%) create mode 100644 src/lib/ector/ector_renderer_buffer.c rename src/lib/ector/{ector_renderer_generic_buffer.eo => ector_renderer_buffer.eo} (78%) delete mode 100644 src/lib/ector/ector_renderer_generic_buffer.c delete mode 100644 src/lib/ector/ector_renderer_generic_shape.c rename src/lib/ector/{ector_renderer_generic_gradient.c => ector_renderer_gradient.c} (70%) rename src/lib/ector/{ector_renderer_generic_gradient.eo => ector_renderer_gradient.eo} (79%) rename src/lib/ector/{ector_renderer_generic_gradient_linear.c => ector_renderer_gradient_linear.c} (60%) rename src/lib/ector/{ector_renderer_generic_gradient_linear.eo => ector_renderer_gradient_linear.eo} (78%) rename src/lib/ector/{ector_renderer_generic_gradient_radial.c => ector_renderer_gradient_radial.c} (57%) rename src/lib/ector/{ector_renderer_generic_gradient_radial.eo => ector_renderer_gradient_radial.eo} (82%) create mode 100644 src/lib/ector/ector_renderer_shape.c rename src/lib/ector/{ector_renderer_generic_shape.eo => ector_renderer_shape.eo} (59%) rename src/lib/ector/{ector_generic_surface.eo => ector_surface.eo} (94%) 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 +#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 similarity index 99% rename from src/lib/ector/ector_generic_buffer.eo rename to 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 -#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 -#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; +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_Generic_Base_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 similarity index 50% rename from src/lib/ector/ector_renderer_generic_base.c rename to 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 similarity index 95% rename from src/lib/ector/ector_renderer_generic_base.eo rename to 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 +#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 similarity index 78% rename from src/lib/ector/ector_renderer_generic_buffer.eo rename to 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 -#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 -#include - -#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 similarity index 70% rename from src/lib/ector/ector_renderer_generic_gradient.c rename to 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 similarity index 79% rename from src/lib/ector/ector_renderer_generic_gradient.eo rename to 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 similarity index 60% rename from src/lib/ector/ector_renderer_generic_gradient_linear.c rename to 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 similarity index 78% rename from src/lib/ector/ector_renderer_generic_gradient_linear.eo rename to 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 similarity index 57% rename from src/lib/ector/ector_renderer_generic_gradient_radial.c rename to 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 similarity index 82% rename from src/lib/ector/ector_renderer_generic_gradient_radial.eo rename to 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 +#include + +#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 similarity index 59% rename from src/lib/ector/ector_renderer_generic_shape.eo rename to 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 similarity index 94% rename from src/lib/ector/ector_generic_surface.eo rename to 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; } }