enlightenment/efl
enlightenment
/
efl
8
7
Fork 14
Code Issues 13 Pull Requests 1 Projects Releases Wiki Activity

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

This commit is contained in:
Tom Hacohen 2016-05-11 12:57:06 +01:00
parent 1c0ec6788f
commit 28a2d34ae2
68 changed files with 550 additions and 550 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

30
src/Makefile_Ector.am
View File

@ -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 += \

30
src/lib/ector/Makefile.am
View File

@ -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 += \

6
src/lib/ector/cairo/ector_cairo_private.h
View File

@ -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;

4
src/lib/ector/cairo/ector_cairo_software_surface.c
View File

@ -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;
}

2
src/lib/ector/cairo/ector_cairo_software_surface.eo
View File

@ -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;
}

10
src/lib/ector/cairo/ector_cairo_surface.c
View File

@ -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)
{

6
src/lib/ector/cairo/ector_cairo_surface.eo
View File

@ -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;
}

14
src/lib/ector/cairo/ector_renderer_cairo.c
View File

@ -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);

10
src/lib/ector/cairo/ector_renderer_cairo.eo
View File

@ -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;

54
src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.c
View File

@ -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;
}

10
src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.eo
View File

@ -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;

54
src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.c
View File

@ -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;
}

10
src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.eo
View File

@ -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;

24
src/lib/ector/cairo/ector_renderer_cairo_shape.c
View File

@ -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;

10
src/lib/ector/cairo/ector_renderer_cairo_shape.eo
View File

@ -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;

40
src/lib/ector/ector_buffer.c Normal file
View File

@ -0,0 +1,40 @@
#ifdef HAVE_CONFIG_H
# include "config.h"
#else
# define EFL_BETA_API_SUPPORT
#endif
#include <Eo.h>
#include "ector_private.h"
#include "ector_buffer.eo.h"
EOLIAN static Efl_Gfx_Colorspace
_ector_buffer_cspace_get(Eo *obj EINA_UNUSED, Ector_Buffer_Data *pd)
{
return pd->cspace;
}
EOLIAN static void
_ector_buffer_border_get(Eo *obj EINA_UNUSED, Ector_Buffer_Data *pd EINA_UNUSED, int *l, int *r, int *t, int *b)
{
if (l) *l = pd->l;
if (r) *r = pd->r;
if (t) *t = pd->t;
if (b) *b = pd->b;
}
EOLIAN static void
_ector_buffer_size_get(Eo *obj EINA_UNUSED, Ector_Buffer_Data *pd, int *w, int *h)
{
if (w) *w = pd->w;
if (h) *h = pd->h;
}
EOLIAN static Ector_Buffer_Flag
_ector_buffer_flags_get(Eo *obj EINA_UNUSED, Ector_Buffer_Data *pd EINA_UNUSED)
{
return ECTOR_BUFFER_FLAG_NONE;
}
#include "ector_buffer.eo.c"
#include "ector_surface.eo.c"

2
src/lib/ector/ector_generic_buffer.eo → src/lib/ector/ector_buffer.eo
View File

@ -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

12
src/lib/ector/ector_buffer.h
View File

@ -3,20 +3,20 @@
#include <Ector.h>
#include "ector_generic_buffer.eo.h"
#include "ector_buffer.eo.h"
#include "software/ector_software_buffer_base.eo.h"
/**
* @typedef Ector_Buffer
* A generic pixel buffer type (2D). May be readable or writeable or both.
*/
typedef Ector_Generic_Buffer Ector_Buffer;
typedef Ector_Buffer Ector_Buffer;
typedef struct _Ector_Generic_Buffer_Data Ector_Generic_Buffer_Data;
typedef struct _Ector_Buffer_Data Ector_Buffer_Data;
typedef struct _Ector_Software_Buffer_Base_Data Ector_Software_Buffer_Base_Data;
typedef struct _Ector_GL_Buffer_Base_Data Ector_GL_Buffer_Base_Data;
struct _Ector_Generic_Buffer_Data
struct _Ector_Buffer_Data
{
Ector_Buffer *eo;
unsigned int w, h;
@ -27,7 +27,7 @@ struct _Ector_Generic_Buffer_Data
struct _Ector_Software_Buffer_Base_Data
{
Ector_Generic_Buffer_Data *generic;
Ector_Buffer_Data *generic;
union {
unsigned int *u32;
unsigned char *u8;
@ -43,7 +43,7 @@ struct _Ector_Software_Buffer_Base_Data
struct _Ector_GL_Buffer_Base_Data
{
Ector_Generic_Buffer_Data *generic;
Ector_Buffer_Data *generic;
int texid;
int fboid;
struct {

40
src/lib/ector/ector_generic_buffer.c
View File

@ -1,40 +0,0 @@
#ifdef HAVE_CONFIG_H
# include "config.h"
#else
# define EFL_BETA_API_SUPPORT
#endif
#include <Eo.h>
#include "ector_private.h"
#include "ector_generic_buffer.eo.h"
EOLIAN static Efl_Gfx_Colorspace
_ector_generic_buffer_cspace_get(Eo *obj EINA_UNUSED, Ector_Generic_Buffer_Data *pd)
{
return pd->cspace;
}
EOLIAN static void
_ector_generic_buffer_border_get(Eo *obj EINA_UNUSED, Ector_Generic_Buffer_Data *pd EINA_UNUSED, int *l, int *r, int *t, int *b)
{
if (l) *l = pd->l;
if (r) *r = pd->r;
if (t) *t = pd->t;
if (b) *b = pd->b;
}
EOLIAN static void
_ector_generic_buffer_size_get(Eo *obj EINA_UNUSED, Ector_Generic_Buffer_Data *pd, int *w, int *h)
{
if (w) *w = pd->w;
if (h) *h = pd->h;
}
EOLIAN static Ector_Buffer_Flag
_ector_generic_buffer_flags_get(Eo *obj EINA_UNUSED, Ector_Generic_Buffer_Data *pd EINA_UNUSED)
{
return ECTOR_BUFFER_FLAG_NONE;
}
#include "ector_generic_buffer.eo.c"
#include "ector_generic_surface.eo.c"

26
src/lib/ector/ector_private.h
View File

@ -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 {

70
src/lib/ector/ector_renderer_generic_base.c → src/lib/ector/ector_renderer.c
View File

@ -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"

6
src/lib/ector/ector_renderer_generic_base.eo → src/lib/ector/ector_renderer.eo
View File

@ -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 {

12
src/lib/ector/ector_renderer.h
View File

@ -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

55
src/lib/ector/ector_renderer_buffer.c Normal file
View File

@ -0,0 +1,55 @@
#ifdef HAVE_CONFIG_H
# include "config.h"
#else
# define EFL_BETA_API_SUPPORT
#endif
#include <Eo.h>
#include "ector_private.h"
#include "ector_renderer_buffer.eo.h"
#define MY_CLASS ECTOR_RENDERER_BUFFER_MIXIN
EOLIAN static void
_ector_renderer_buffer_efl_gfx_fill_fill_get(Eo *obj EINA_UNUSED, Ector_Renderer_Buffer_Data *pd, int *x, int *y, int *w, int *h)
{
if (x) *x = pd->fill.x;
if (y) *y = pd->fill.y;
if (w) *w = pd->fill.w;
if (h) *h = pd->fill.h;
}
EOLIAN static void
_ector_renderer_buffer_efl_gfx_fill_fill_set(Eo *obj EINA_UNUSED, Ector_Renderer_Buffer_Data *pd, int x, int y, int w, int h)
{
if (w < 0) w = 0;
if (h < 0) h = 0;
pd->fill.x = x;
pd->fill.y = y;
pd->fill.w = w;
pd->fill.h = h;
}
EOLIAN static void
_ector_renderer_buffer_buffer_set(Eo *obj EINA_UNUSED, Ector_Renderer_Buffer_Data *pd, Ector_Buffer *buf)
{
_eo_xrefplace(&pd->eo_buffer, buf, obj);
}
EOLIAN static Ector_Buffer *
_ector_renderer_buffer_buffer_get(Eo *obj EINA_UNUSED, Ector_Renderer_Buffer_Data *pd)
{
return pd->eo_buffer;
}
EOLIAN static Eo_Base *
_ector_renderer_buffer_eo_base_constructor(Eo *obj, Ector_Renderer_Buffer_Data *pd EINA_UNUSED)
{
Eo_Base *ret;
ret = eo_constructor(eo_super(obj, MY_CLASS));
return ret;
}
#include "ector_renderer_buffer.eo.c"

4
src/lib/ector/ector_renderer_generic_buffer.eo → src/lib/ector/ector_renderer_buffer.eo
View File

@ -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*;
}
}
}

55
src/lib/ector/ector_renderer_generic_buffer.c
View File

@ -1,55 +0,0 @@
#ifdef HAVE_CONFIG_H
# include "config.h"
#else
# define EFL_BETA_API_SUPPORT
#endif
#include <Eo.h>
#include "ector_private.h"
#include "ector_renderer_generic_buffer.eo.h"
#define MY_CLASS ECTOR_RENDERER_GENERIC_BUFFER_MIXIN
EOLIAN static void
_ector_renderer_generic_buffer_efl_gfx_fill_fill_get(Eo *obj EINA_UNUSED, Ector_Renderer_Generic_Buffer_Data *pd, int *x, int *y, int *w, int *h)
{
if (x) *x = pd->fill.x;
if (y) *y = pd->fill.y;
if (w) *w = pd->fill.w;
if (h) *h = pd->fill.h;
}
EOLIAN static void
_ector_renderer_generic_buffer_efl_gfx_fill_fill_set(Eo *obj EINA_UNUSED, Ector_Renderer_Generic_Buffer_Data *pd, int x, int y, int w, int h)
{
if (w < 0) w = 0;
if (h < 0) h = 0;
pd->fill.x = x;
pd->fill.y = y;
pd->fill.w = w;
pd->fill.h = h;
}
EOLIAN static void
_ector_renderer_generic_buffer_buffer_set(Eo *obj EINA_UNUSED, Ector_Renderer_Generic_Buffer_Data *pd, Ector_Generic_Buffer *buf)
{
_eo_xrefplace(&pd->eo_buffer, buf, obj);
}
EOLIAN static Ector_Generic_Buffer *
_ector_renderer_generic_buffer_buffer_get(Eo *obj EINA_UNUSED, Ector_Renderer_Generic_Buffer_Data *pd)
{
return pd->eo_buffer;
}
EOLIAN static Eo_Base *
_ector_renderer_generic_buffer_eo_base_constructor(Eo *obj, Ector_Renderer_Generic_Buffer_Data *pd EINA_UNUSED)
{
Eo_Base *ret;
ret = eo_constructor(eo_super(obj, MY_CLASS));
return ret;
}
#include "ector_renderer_generic_buffer.eo.c"

55
src/lib/ector/ector_renderer_generic_shape.c
View File

@ -1,55 +0,0 @@
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <Eina.h>
#include <Ector.h>
#include "ector_private.h"
static void
_ector_renderer_generic_shape_fill_set(Eo *obj EINA_UNUSED,
Ector_Renderer_Generic_Shape_Data *pd,
const Ector_Renderer *r)
{
_eo_refplace(&pd->fill, r);
}
static const Ector_Renderer *
_ector_renderer_generic_shape_fill_get(Eo *obj EINA_UNUSED,
Ector_Renderer_Generic_Shape_Data *pd)
{
return pd->fill;
}
static void
_ector_renderer_generic_shape_stroke_fill_set(Eo *obj EINA_UNUSED,
Ector_Renderer_Generic_Shape_Data *pd,
const Ector_Renderer *r)
{
_eo_refplace(&pd->stroke.fill, r);
}
static const Ector_Renderer *
_ector_renderer_generic_shape_stroke_fill_get(Eo *obj EINA_UNUSED,
Ector_Renderer_Generic_Shape_Data *pd)
{
return pd->stroke.fill;
}
static void
_ector_renderer_generic_shape_stroke_marker_set(Eo *obj EINA_UNUSED,
Ector_Renderer_Generic_Shape_Data *pd,
const Ector_Renderer *r)
{
_eo_refplace(&pd->stroke.marker, r);
}
static const Ector_Renderer *
_ector_renderer_generic_shape_stroke_marker_get(Eo *obj EINA_UNUSED,
Ector_Renderer_Generic_Shape_Data *pd)
{
return pd->stroke.marker;
}
#include "ector_renderer_generic_shape.eo.c"

18
src/lib/ector/ector_renderer_generic_gradient.c → src/lib/ector/ector_renderer_gradient.c
View File

@ -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"

2
src/lib/ector/ector_renderer_generic_gradient.eo → src/lib/ector/ector_renderer_gradient.eo
View File

@ -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;

18
src/lib/ector/ector_renderer_generic_gradient_linear.c → src/lib/ector/ector_renderer_gradient_linear.c
View File

@ -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"

2
src/lib/ector/ector_renderer_generic_gradient_linear.eo → src/lib/ector/ector_renderer_gradient_linear.eo
View File

@ -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;

26
src/lib/ector/ector_renderer_generic_gradient_radial.c → src/lib/ector/ector_renderer_gradient_radial.c
View File

@ -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"

2
src/lib/ector/ector_renderer_generic_gradient_radial.eo → src/lib/ector/ector_renderer_gradient_radial.eo
View File

@ -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;

55
src/lib/ector/ector_renderer_shape.c Normal file
View File

@ -0,0 +1,55 @@
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif
#include <Eina.h>
#include <Ector.h>
#include "ector_private.h"
static void
_ector_renderer_shape_fill_set(Eo *obj EINA_UNUSED,
Ector_Renderer_Shape_Data *pd,
const Ector_Renderer *r)
{
_eo_refplace(&pd->fill, r);
}
static const Ector_Renderer *
_ector_renderer_shape_fill_get(Eo *obj EINA_UNUSED,
Ector_Renderer_Shape_Data *pd)
{
return pd->fill;
}
static void
_ector_renderer_shape_stroke_fill_set(Eo *obj EINA_UNUSED,
Ector_Renderer_Shape_Data *pd,
const Ector_Renderer *r)
{
_eo_refplace(&pd->stroke.fill, r);
}
static const Ector_Renderer *
_ector_renderer_shape_stroke_fill_get(Eo *obj EINA_UNUSED,
Ector_Renderer_Shape_Data *pd)
{
return pd->stroke.fill;
}
static void
_ector_renderer_shape_stroke_marker_set(Eo *obj EINA_UNUSED,
Ector_Renderer_Shape_Data *pd,
const Ector_Renderer *r)
{
_eo_refplace(&pd->stroke.marker, r);
}
static const Ector_Renderer *
_ector_renderer_shape_stroke_marker_get(Eo *obj EINA_UNUSED,
Ector_Renderer_Shape_Data *pd)
{
return pd->stroke.marker;
}
#include "ector_renderer_shape.eo.c"

10
src/lib/ector/ector_renderer_generic_shape.eo → src/lib/ector/ector_renderer_shape.eo
View File

@ -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) *;
}
}
}

2
src/lib/ector/ector_generic_surface.eo → src/lib/ector/ector_surface.eo
View File

@ -1,4 +1,4 @@
mixin Ector.Generic.Surface (Ector.Generic.Buffer)
mixin Ector.Surface (Ector.Buffer)
{
[[Surface interface for Ector]]

2
src/lib/ector/ector_surface.h
View File

@ -2,6 +2,6 @@
#define ECTOR_SURFACE_H
#include "ector_buffer.h"
#include "ector_generic_surface.eo.h"
#include "ector_surface.eo.h"
#endif

2
src/lib/ector/gl/ector_gl_buffer_base.eo
View File

@ -1,4 +1,4 @@
mixin Ector.GL.Buffer.Base (Ector.Generic.Buffer)
mixin Ector.GL.Buffer.Base (Ector.Buffer)
{
legacy_prefix: null;
methods {

10
src/lib/ector/gl/ector_gl_surface.c
View File

@ -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)
{

6
src/lib/ector/gl/ector_gl_surface.eo
View File

@ -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;
}

8
src/lib/ector/gl/ector_renderer_gl.c
View File

@ -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;
}

6
src/lib/ector/gl/ector_renderer_gl.eo
View File

@ -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;
}

22
src/lib/ector/gl/ector_renderer_gl_gradient_linear.c
View File

@ -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;
}

10
src/lib/ector/gl/ector_renderer_gl_gradient_linear.eo
View File

@ -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;

22
src/lib/ector/gl/ector_renderer_gl_gradient_radial.c
View File

@ -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;
}

10
src/lib/ector/gl/ector_renderer_gl_gradient_radial.eo
View File

@ -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;

16
src/lib/ector/gl/ector_renderer_gl_shape.c
View File

@ -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);

10
src/lib/ector/gl/ector_renderer_gl_shape.eo
View File

@ -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;

2
src/lib/ector/software/ector_renderer_software.eo
View File

@ -1,4 +1,4 @@
class Ector.Renderer.Software (Ector.Renderer.Generic.Base)
class Ector.Renderer.Software (Ector.Renderer)
{
legacy_prefix: null;
data: null;

10
src/lib/ector/software/ector_renderer_software_buffer.c
View File

@ -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;

8
src/lib/ector/software/ector_renderer_software_buffer.eo
View File

@ -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;
}

20
src/lib/ector/software/ector_renderer_software_gradient_linear.c
View File

@ -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;
}

8
src/lib/ector/software/ector_renderer_software_gradient_linear.eo
View File

@ -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;

20
src/lib/ector/software/ector_renderer_software_gradient_radial.c
View File

@ -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;
}

8
src/lib/ector/software/ector_renderer_software_gradient_radial.eo
View File

@ -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;

14
src/lib/ector/software/ector_renderer_software_shape.c
View File

@ -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;

8
src/lib/ector/software/ector_renderer_software_shape.eo
View File

@ -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;

20
src/lib/ector/software/ector_software_buffer.c
View File

@ -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;
}

14
src/lib/ector/software/ector_software_buffer_base.eo
View File

@ -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;
}
}

6
src/lib/ector/software/ector_software_private.h
View File

@ -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;

12
src/lib/ector/software/ector_software_surface.c
View File

@ -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)
{

6
src/lib/ector/software/ector_software_surface.eo
View File

@ -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;
}

2
src/lib/evas/canvas/evas_vg_gradient_linear.c
View File

@ -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);

2
src/lib/evas/canvas/evas_vg_gradient_radial.c
View File

@ -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);

2
src/lib/evas/canvas/evas_vg_shape.c
View File

@ -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);

2
src/lib/evas/filters/evas_filter_private.h
View File

@ -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)

16
src/modules/evas/engines/gl_generic/evas_ector_gl_image_buffer.c
View File

@ -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;
}

10
src/modules/evas/engines/gl_generic/evas_ector_gl_image_buffer.eo
View File

@ -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;
}
}