summaryrefslogtreecommitdiff
path: root/src/lib
diff options
context:
space:
mode:
authorHermet Park <hermetpark@gmail.com>2019-09-11 13:12:08 +0900
committerHermet Park <hermetpark@gmail.com>2019-09-11 13:14:56 +0900
commitdc0056ca936fc014aaf7949ef9fa3cf41c2d6964 (patch)
tree0c94ad95e2a263b3e58653882aa9b1d051dae6a0 /src/lib
parent3d50083f41c2e5dc087ff98ea3af104c70002546 (diff)
ector: removed cairo backend.
For reducing maintainability burden, We drop supporting cairo backend. The default backend is to software implementation from now. It's well maintained so far and works good.x
Diffstat (limited to 'src/lib')
-rw-r--r--src/lib/ector/Ector.h2
-rw-r--r--src/lib/ector/cairo/Ector_Cairo.h55
-rw-r--r--src/lib/ector/cairo/ector_cairo_private.h95
-rw-r--r--src/lib/ector/cairo/ector_cairo_software_surface.c120
-rw-r--r--src/lib/ector/cairo/ector_cairo_software_surface.eo14
-rw-r--r--src/lib/ector/cairo/ector_cairo_surface.c146
-rw-r--r--src/lib/ector/cairo/ector_cairo_surface.eo35
-rw-r--r--src/lib/ector/cairo/ector_renderer_cairo.c229
-rw-r--r--src/lib/ector/cairo/ector_renderer_cairo.eo21
-rw-r--r--src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.c197
-rw-r--r--src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.eo15
-rw-r--r--src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.c220
-rw-r--r--src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.eo15
-rw-r--r--src/lib/ector/cairo/ector_renderer_cairo_shape.c331
-rw-r--r--src/lib/ector/cairo/ector_renderer_cairo_shape.eo16
-rw-r--r--src/lib/ector/cairo/meson.build39
-rw-r--r--src/lib/ector/gl/Ector_GL.h2
-rw-r--r--src/lib/ector/meson.build1
-rw-r--r--src/lib/ector/software/ector_software_buffer.c2
19 files changed, 2 insertions, 1553 deletions
diff --git a/src/lib/ector/Ector.h b/src/lib/ector/Ector.h
index 01a71d6e6e..961a42c150 100644
--- a/src/lib/ector/Ector.h
+++ b/src/lib/ector/Ector.h
@@ -52,7 +52,7 @@ extern "C" {
52 * 52 *
53 * Ector is a retained mode drawing library designed to work 53 * Ector is a retained mode drawing library designed to work
54 * for and with a scenegraph such as Evas, which supports several 54 * for and with a scenegraph such as Evas, which supports several
55 * types of rendering surface including software, cairo, and gl. 55 * types of rendering surface including software and gl.
56 * 56 *
57 * @section ector_main_compiling How to compile the library 57 * @section ector_main_compiling How to compile the library
58 * 58 *
diff --git a/src/lib/ector/cairo/Ector_Cairo.h b/src/lib/ector/cairo/Ector_Cairo.h
deleted file mode 100644
index 99eeafac9a..0000000000
--- a/src/lib/ector/cairo/Ector_Cairo.h
+++ /dev/null
@@ -1,55 +0,0 @@
1#ifndef ECTOR_CAIRO_H_
2# define ECTOR_CAIRO_H_
3
4#include <Ector.h>
5
6#ifdef EAPI
7# undef EAPI
8#endif
9
10#ifdef _WIN32
11# ifdef EFL_BUILD
12# ifdef DLL_EXPORT
13# define EAPI __declspec(dllexport)
14# else
15# define EAPI
16# endif
17# else
18# define EAPI __declspec(dllimport)
19# endif
20#else
21# ifdef __GNUC__
22# if __GNUC__ >= 4
23# define EAPI __attribute__ ((visibility("default")))
24# else
25# define EAPI
26# endif
27# else
28# define EAPI
29# endif
30#endif
31
32#ifdef EFL_BETA_API_SUPPORT
33
34#ifndef _ECTOR_CAIRO_SURFACE_EO_CLASS_TYPE
35#define _ECTOR_CAIRO_SURFACE_EO_CLASS_TYPE
36
37typedef Eo Ector_Cairo_Surface;
38
39#endif
40
41typedef struct _cairo_t cairo_t;
42
43#include "cairo/ector_cairo_surface.eo.h"
44#include "cairo/ector_cairo_software_surface.eo.h"
45#include "cairo/ector_renderer_cairo.eo.h"
46#include "cairo/ector_renderer_cairo_shape.eo.h"
47#include "cairo/ector_renderer_cairo_gradient_linear.eo.h"
48#include "cairo/ector_renderer_cairo_gradient_radial.eo.h"
49
50#endif
51
52#undef EAPI
53#define EAPI
54
55#endif
diff --git a/src/lib/ector/cairo/ector_cairo_private.h b/src/lib/ector/cairo/ector_cairo_private.h
deleted file mode 100644
index a7a6d7661f..0000000000
--- a/src/lib/ector/cairo/ector_cairo_private.h
+++ /dev/null
@@ -1,95 +0,0 @@
1#ifndef ECTOR_CAIRO_PRIVATE_H_
2# define ECTOR_CAIRO_PRIVATE_H_
3
4#include "draw.h"
5
6typedef void cairo_pattern_t;
7
8typedef struct {
9 double xx; double yx;
10 double xy; double yy;
11 double x0; double y0;
12} cairo_matrix_t;
13
14typedef struct _Ector_Cairo_Surface_Data Ector_Cairo_Surface_Data;
15typedef struct _Ector_Renderer_Cairo_Data Ector_Renderer_Cairo_Data;
16
17struct _Ector_Cairo_Surface_Data
18{
19 cairo_t *cairo;
20 struct {
21 double x, y;
22 } current;
23};
24
25struct _Ector_Renderer_Cairo_Data
26{
27 Ector_Cairo_Surface_Data *parent;
28 Ector_Renderer_Data *generic;
29
30 cairo_matrix_t *m;
31};
32
33typedef enum _cairo_extend {
34 CAIRO_EXTEND_NONE,
35 CAIRO_EXTEND_REPEAT,
36 CAIRO_EXTEND_REFLECT,
37 CAIRO_EXTEND_PAD
38} cairo_extend_t;
39
40static inline cairo_extend_t
41_ector_cairo_extent_get(Efl_Gfx_Gradient_Spread s)
42{
43 switch (s)
44 {
45 case EFL_GFX_GRADIENT_SPREAD_PAD:
46 return CAIRO_EXTEND_PAD;
47 case EFL_GFX_GRADIENT_SPREAD_REFLECT:
48 return CAIRO_EXTEND_REFLECT;
49 case EFL_GFX_GRADIENT_SPREAD_REPEAT:
50 return CAIRO_EXTEND_REPEAT;
51 default:
52 return CAIRO_EXTEND_NONE;
53 }
54}
55
56#define CHECK_CAIRO(Parent) (!(Parent && Parent->cairo))
57
58#define USE(Obj, Sym, Error) \
59 if (!Sym) Sym = _ector_cairo_symbol_get(Obj, #Sym); \
60 if (!Sym) return Error;
61
62static inline void *
63_ector_cairo_symbol_get(Ector_Renderer_Data *base,
64 const char *name)
65{
66 void *sym;
67
68 sym = ector_cairo_surface_symbol_get(base->surface, name);
69 return sym;
70}
71
72extern void (*cairo_pattern_add_color_stop_rgba)(cairo_pattern_t *pattern, double offset,
73 double red, double green, double blue, double alpha);
74
75static inline void
76_ector_renderer_cairo_gradient_prepare(cairo_pattern_t *pat,
77 Ector_Renderer_Gradient_Data *src,
78 unsigned int mul_col)
79{
80 unsigned int i;
81
82 for (i = 0; i < src->colors_count; i++)
83 {
84 int r,g,b,a;
85
86 r = ((src->colors[i].r * R_VAL(&mul_col)) >> 8);
87 g = ((src->colors[i].g * G_VAL(&mul_col)) >> 8);
88 b = ((src->colors[i].b * B_VAL(&mul_col)) >> 8);
89 a = ((src->colors[i].a * A_VAL(&mul_col)) >> 8);
90 ector_color_argb_unpremul(a, &r, &g, &b);
91 cairo_pattern_add_color_stop_rgba(pat, src->colors[i].offset, r/255.0, g/255.0, b/255.0, a/255.0);
92 }
93}
94
95#endif
diff --git a/src/lib/ector/cairo/ector_cairo_software_surface.c b/src/lib/ector/cairo/ector_cairo_software_surface.c
deleted file mode 100644
index 96bf1c1081..0000000000
--- a/src/lib/ector/cairo/ector_cairo_software_surface.c
+++ /dev/null
@@ -1,120 +0,0 @@
1#ifdef HAVE_CONFIG_H
2#include "config.h" /* so that EAPI in Evas.h is correctly defined */
3#endif
4
5#include "Ector_Cairo.h"
6#include "ector_private.h"
7#include <software/Ector_Software.h>
8#include "ector_cairo_software_surface.eo.h"
9
10#define MY_CLASS ECTOR_CAIRO_SOFTWARE_SURFACE_CLASS
11
12#define USE(Obj, Sym, Error) \
13 if (!Sym) Sym = _ector_cairo_symbol_get(Obj, #Sym); \
14 if (!Sym) return Error;
15
16static inline void *
17_ector_cairo_symbol_get(Eo *ector_surface, const char *name)
18{
19 void *sym;
20
21 sym = ector_cairo_surface_symbol_get(ector_surface, name);
22 return sym;
23}
24
25typedef struct _cairo_surface_t cairo_surface_t;
26typedef enum {
27 CAIRO_FORMAT_INVALID = -1,
28 CAIRO_FORMAT_ARGB32 = 0,
29 CAIRO_FORMAT_RGB24 = 1,
30 CAIRO_FORMAT_A8 = 2,
31 CAIRO_FORMAT_A1 = 3,
32 CAIRO_FORMAT_RGB16_565 = 4,
33 CAIRO_FORMAT_RGB30 = 5
34} cairo_format_t;
35
36static cairo_surface_t *(*cairo_image_surface_create_for_data)(unsigned char *data,
37 cairo_format_t format,
38 int width,
39 int height,
40 int stride) = NULL;
41static void (*cairo_surface_destroy)(cairo_surface_t *surface) = NULL;
42static cairo_t *(*cairo_create)(cairo_surface_t *target) = NULL;
43static void (*cairo_destroy)(cairo_t *cr) = NULL;
44
45typedef struct _Ector_Cairo_Software_Surface_Data Ector_Cairo_Software_Surface_Data;
46struct _Ector_Cairo_Software_Surface_Data
47{
48 cairo_surface_t *surface;
49 Ector_Software_Buffer_Base_Data *base;
50};
51
52EOLIAN static Eina_Bool
53_ector_cairo_software_surface_ector_buffer_pixels_set(Eo *obj, Ector_Cairo_Software_Surface_Data *pd,
54 void *pixels, int width, int height, int stride,
55 Efl_Gfx_Colorspace cspace, Eina_Bool writable)
56{
57 cairo_t *ctx = NULL;
58 Eina_Bool ok = EINA_FALSE;
59
60 if ((cspace != EFL_GFX_COLORSPACE_ARGB8888) || !writable)
61 {
62 ERR("Unsupported surface type!");
63 return EINA_FALSE;
64 }
65
66 USE(obj, cairo_image_surface_create_for_data, EINA_FALSE);
67 USE(obj, cairo_surface_destroy, EINA_FALSE);
68 USE(obj, cairo_create, EINA_FALSE);
69 USE(obj, cairo_destroy, EINA_FALSE);
70
71 if (pd->surface)
72 cairo_surface_destroy(pd->surface);
73 pd->surface = NULL;
74
75 ok = ector_buffer_pixels_set(efl_super(obj, MY_CLASS), pixels, width, height, stride, cspace, writable);
76
77 if (ok && pixels)
78 {
79 pd->surface = cairo_image_surface_create_for_data(pixels,
80 CAIRO_FORMAT_ARGB32,
81 width, height, pd->base->stride);
82 if (!pd->surface) goto end;
83
84 ctx = cairo_create(pd->surface);
85 }
86
87 end:
88 /* evas_common_cpu_end_opt(); // do we need this? */
89 ector_cairo_surface_context_set(obj, ctx);
90 return ok;
91}
92
93void
94_ector_cairo_software_surface_surface_get(Eo *obj EINA_UNUSED, Ector_Cairo_Software_Surface_Data *pd, void **pixels, unsigned int *width, unsigned int *height)
95{
96 if (pixels) *pixels = pd->base->pixels.u8;
97 if (width) *width = pd->base->generic->w;
98 if (height) *height = pd->base->generic->h;
99}
100
101static Efl_Object *
102_ector_cairo_software_surface_efl_object_constructor(Eo *obj, Ector_Cairo_Software_Surface_Data *pd)
103{
104 obj = efl_constructor(efl_super(obj, MY_CLASS));
105
106 if (!obj) return NULL;
107 pd->base = efl_data_ref(obj, ECTOR_SOFTWARE_BUFFER_BASE_MIXIN);
108 pd->base->generic = efl_data_ref(obj, ECTOR_BUFFER_MIXIN);
109 pd->base->generic->eo = obj;
110 return obj;
111}
112
113EOLIAN static void
114_ector_cairo_software_surface_efl_object_destructor(Eo *obj, Ector_Cairo_Software_Surface_Data *pd)
115{
116 efl_data_unref(obj, pd->base);
117 efl_destructor(efl_super(obj, MY_CLASS));
118}
119
120#include "ector_cairo_software_surface.eo.c"
diff --git a/src/lib/ector/cairo/ector_cairo_software_surface.eo b/src/lib/ector/cairo/ector_cairo_software_surface.eo
deleted file mode 100644
index 9cd23e5cf5..0000000000
--- a/src/lib/ector/cairo/ector_cairo_software_surface.eo
+++ /dev/null
@@ -1,14 +0,0 @@
1class @beta Ector.Cairo.Software.Surface extends Ector.Cairo.Surface implements Ector.Software.Buffer.Base
2{
3 [[Ector surface on a cairo software backend
4
5 Used to render ector content into a cairo software backend.
6 ]]
7 c_prefix: ector_cairo_software_surface;
8 methods {}
9 implements {
10 Ector.Buffer.pixels_set;
11 Efl.Object.constructor;
12 Efl.Object.destructor;
13 }
14}
diff --git a/src/lib/ector/cairo/ector_cairo_surface.c b/src/lib/ector/cairo/ector_cairo_surface.c
deleted file mode 100644
index 28d904499e..0000000000
--- a/src/lib/ector/cairo/ector_cairo_surface.c
+++ /dev/null
@@ -1,146 +0,0 @@
1#ifdef HAVE_CONFIG_H
2# include "config.h"
3#endif
4
5#include <Eina.h>
6#include <Ector.h>
7#include <cairo/Ector_Cairo.h>
8
9#include "ector_private.h"
10#include "ector_cairo_private.h"
11
12static unsigned int _cairo_count = 0;
13static Eina_Module *_cairo_so = NULL;
14
15static void *
16_ector_cairo_surface_symbol_get(Eo *obj EINA_UNUSED,
17 Ector_Cairo_Surface_Data *pd EINA_UNUSED,
18 const char *name)
19{
20 if (!_cairo_so)
21 {
22#define LOAD(x) \
23 if (!_cairo_so) \
24 { \
25 _cairo_so = eina_module_new(x); \
26 if (_cairo_so && \
27 !eina_module_load(_cairo_so)) \
28 { \
29 eina_module_free(_cairo_so); \
30 _cairo_so = NULL; \
31 } \
32 }
33#if defined(_WIN32) || defined(__CYGWIN__)
34 LOAD("libcairo-2.dll");
35 LOAD("libcairo.dll");
36#elif defined(__APPLE__) && defined(__MACH__)
37 LOAD("libcairo.dylib");
38 LOAD("libcairo.so");
39#else
40 LOAD("libcairo.so");
41#endif
42
43#undef LOAD
44 }
45
46 if (!_cairo_so)
47 {
48 ERR("Couldn't find cairo library. Please make sure that your system can locate it.");
49 return NULL;
50 }
51
52 return eina_module_symbol_get(_cairo_so, name);
53}
54
55#undef USE
56#define USE(Obj, Sym, Error) \
57 if (!Sym) Sym = _ector_cairo_surface_symbol_get(Obj, NULL, #Sym); \
58 if (!Sym) return Error;
59
60static Ector_Renderer *
61_ector_cairo_surface_ector_surface_renderer_factory_new(Eo *obj,
62 Ector_Cairo_Surface_Data *pd EINA_UNUSED,
63 const Efl_Class *type)
64{
65 if (type == ECTOR_RENDERER_SHAPE_MIXIN)
66 return efl_add_ref(ECTOR_RENDERER_CAIRO_SHAPE_CLASS, NULL, ector_renderer_surface_set(efl_added, obj));
67 else if (type == ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN)
68 return efl_add_ref(ECTOR_RENDERER_CAIRO_GRADIENT_LINEAR_CLASS, NULL, ector_renderer_surface_set(efl_added, obj));
69 else if (type == ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN)
70 return efl_add_ref(ECTOR_RENDERER_CAIRO_GRADIENT_RADIAL_CLASS, NULL, ector_renderer_surface_set(efl_added, obj));
71
72 ERR("Couldn't find class for type: %s\n", efl_class_name_get(type));
73 return NULL;
74}
75
76typedef struct _cairo_surface_t cairo_surface_t;
77
78static void (*cairo_destroy)(cairo_t *cr) = NULL;
79static cairo_surface_t *(*cairo_image_surface_create)(int format,
80 int width,
81 int height) = NULL;
82static cairo_t *(*cairo_create)(cairo_surface_t *target) = NULL;
83
84static cairo_surface_t *internal = NULL;
85
86static void
87_ector_cairo_surface_context_set(Eo *obj EINA_UNUSED,
88 Ector_Cairo_Surface_Data *pd,
89 cairo_t *ctx)
90{
91 if (pd->cairo) cairo_destroy(pd->cairo);
92 if (!ctx)
93 {
94 if (!internal) internal = cairo_image_surface_create(0, 1, 1);
95 ctx = cairo_create(internal);
96 }
97 pd->current.x = pd->current.y = 0;
98 pd->cairo = ctx;
99}
100
101static cairo_t *
102_ector_cairo_surface_context_get(const Eo *obj EINA_UNUSED,
103 Ector_Cairo_Surface_Data *pd)
104{
105 return pd->cairo;
106}
107
108static void
109_ector_cairo_surface_ector_surface_reference_point_set(Eo *obj EINA_UNUSED,
110 Ector_Cairo_Surface_Data *pd,
111 int x, int y)
112{
113 pd->current.x = x;
114 pd->current.y = y;
115}
116
117static Eo *
118_ector_cairo_surface_efl_object_constructor(Eo *obj,
119 Ector_Cairo_Surface_Data *pd)
120{
121 USE(obj, cairo_destroy, NULL);
122 USE(obj, cairo_image_surface_create, NULL);
123 USE(obj, cairo_create, NULL);
124
125 obj = efl_constructor(efl_super(obj, ECTOR_CAIRO_SURFACE_CLASS));
126 if (!obj) return NULL;
127
128 _cairo_count++;
129
130 _ector_cairo_surface_context_set(obj, pd, NULL);
131
132 return obj;
133}
134
135static void
136_ector_cairo_surface_efl_object_destructor(Eo *obj EINA_UNUSED,
137 Ector_Cairo_Surface_Data *pd EINA_UNUSED)
138{
139 efl_destructor(efl_super(obj, ECTOR_CAIRO_SURFACE_CLASS));
140
141 if (--_cairo_count) return ;
142 if (_cairo_so) eina_module_free(_cairo_so);
143 _cairo_so = NULL;
144}
145
146#include "ector_cairo_surface.eo.c"
diff --git a/src/lib/ector/cairo/ector_cairo_surface.eo b/src/lib/ector/cairo/ector_cairo_surface.eo
deleted file mode 100644
index dabd214147..0000000000
--- a/src/lib/ector/cairo/ector_cairo_surface.eo
+++ /dev/null
@@ -1,35 +0,0 @@
1struct @extern cairo_t; [[cairo_t type]]
2
3class @beta Ector.Cairo.Surface extends Efl.Object implements Ector.Surface
4{
5 [[Ector surface on a cairo backend
6
7 Used to render ector content into a cairo backend.
8 ]]
9 c_prefix: ector_cairo_surface;
10 methods {
11 @property context {
12 [[Cairo context]]
13 set {
14 }
15 get {
16 }
17 values {
18 ctx: ptr(cairo_t); [[Cairo context]]
19 }
20 }
21 symbol_get {
22 [[Lookup symbal name in cairo lib]]
23 return: void_ptr @no_unused; [[Pointer to cairo lib with this symbol]]
24 params {
25 @in name: string; [[Symbol name]]
26 }
27 }
28 }
29 implements {
30 Ector.Surface.renderer_factory_new;
31 Ector.Surface.reference_point { set; }
32 Efl.Object.destructor;
33 Efl.Object.constructor;
34 }
35}
diff --git a/src/lib/ector/cairo/ector_renderer_cairo.c b/src/lib/ector/cairo/ector_renderer_cairo.c
deleted file mode 100644
index ddcca419d8..0000000000
--- a/src/lib/ector/cairo/ector_renderer_cairo.c
+++ /dev/null
@@ -1,229 +0,0 @@
1#ifdef HAVE_CONFIG_H
2# include "config.h"
3#endif
4
5#include <math.h>
6#include <float.h>
7
8#include <Eina.h>
9#include <Ector.h>
10#include <cairo/Ector_Cairo.h>
11
12#include "ector_private.h"
13#include "ector_cairo_private.h"
14
15typedef enum {
16 CAIRO_OPERATOR_CLEAR,
17
18 CAIRO_OPERATOR_SOURCE,
19 CAIRO_OPERATOR_OVER,
20 CAIRO_OPERATOR_IN,
21 CAIRO_OPERATOR_OUT,
22 CAIRO_OPERATOR_ATOP,
23
24 CAIRO_OPERATOR_DEST,
25 CAIRO_OPERATOR_DEST_OVER,
26 CAIRO_OPERATOR_DEST_IN,
27 CAIRO_OPERATOR_DEST_OUT,
28 CAIRO_OPERATOR_DEST_ATOP,
29
30 CAIRO_OPERATOR_XOR,
31 CAIRO_OPERATOR_ADD,
32 CAIRO_OPERATOR_SATURATE,
33
34 CAIRO_OPERATOR_MULTIPLY,
35 CAIRO_OPERATOR_SCREEN,
36 CAIRO_OPERATOR_OVERLAY,
37 CAIRO_OPERATOR_DARKEN,
38 CAIRO_OPERATOR_LIGHTEN,
39 CAIRO_OPERATOR_COLOR_DODGE,
40 CAIRO_OPERATOR_COLOR_BURN,
41 CAIRO_OPERATOR_HARD_LIGHT,
42 CAIRO_OPERATOR_SOFT_LIGHT,
43 CAIRO_OPERATOR_DIFFERENCE,
44 CAIRO_OPERATOR_EXCLUSION,
45 CAIRO_OPERATOR_HSL_HUE,
46 CAIRO_OPERATOR_HSL_SATURATION,
47 CAIRO_OPERATOR_HSL_COLOR,
48 CAIRO_OPERATOR_HSL_LUMINOSITY
49} cairo_operator_t;
50
51static void (*cairo_translate)(cairo_t *cr, double tx, double ty) = NULL;
52static void (*cairo_matrix_init)(cairo_matrix_t *matrix,
53 double xx, double yx,
54 double xy, double yy,
55 double x0, double y0) = NULL;
56static void (*cairo_transform)(cairo_t *cr, const cairo_matrix_t *matrix) = NULL;
57static void (*cairo_set_source_rgba)(cairo_t *cr,
58 double red, double green, double blue,
59 double alpha) = NULL;
60static void (*cairo_set_operator)(cairo_t *cr, cairo_operator_t op) = NULL;
61static void (*cairo_matrix_init_identity)(cairo_matrix_t *matrix) = NULL;
62
63static void (*cairo_new_path)(cairo_t *cr) = NULL;
64static void (*cairo_rectangle)(cairo_t *cr, double x, double y, double width, double height) = NULL;
65static void (*cairo_clip)(cairo_t *cr) = NULL;
66static void (*cairo_device_to_user)(cairo_t *cr, double *x, double *y) = NULL;
67
68// This routine is shared for all gradient types to use
69void (*cairo_pattern_add_color_stop_rgba)(cairo_pattern_t *pattern, double offset,
70 double red, double green, double blue, double alpha) = NULL;
71
72static cairo_matrix_t identity;
73
74// Cairo needs unpremultiplied color, so force unpremul here
75void
76_ector_renderer_cairo_ector_renderer_color_set(Eo *obj EINA_UNUSED,
77 Ector_Renderer_Cairo_Data *pd,
78 int r, int g, int b, int a)
79{
80 pd->generic->color.r = r;
81 pd->generic->color.g = g;
82 pd->generic->color.b = b;
83 pd->generic->color.a = a;
84}
85
86void
87_ector_renderer_cairo_ector_renderer_color_get(const Eo *obj EINA_UNUSED,
88 Ector_Renderer_Cairo_Data *pd,
89 int *r, int *g, int *b, int *a)
90{
91 if (r) *r = pd->generic->color.r;
92 if (g) *g = pd->generic->color.g;
93 if (b) *b = pd->generic->color.b;
94 if (a) *a = pd->generic->color.a;
95}
96
97static Eina_Bool
98_ector_renderer_cairo_ector_renderer_prepare(Eo *obj, Ector_Renderer_Cairo_Data *pd)
99{
100 if (!pd->parent)
101 {
102 pd->parent = efl_data_xref(pd->generic->surface, ECTOR_CAIRO_SURFACE_CLASS, obj);
103 }
104 if (pd->generic->m)
105 {
106 if (!pd->m) pd->m = malloc(sizeof (cairo_matrix_t));
107 cairo_matrix_init(pd->m,
108 pd->generic->m->xx, pd->generic->m->yx,
109 pd->generic->m->xy, pd->generic->m->yy,
110 pd->generic->m->xz, pd->generic->m->yz);
111 }
112 else
113 {
114 free(pd->m);
115 pd->m = NULL;
116 }
117
118 return EINA_TRUE;
119}
120
121static Eina_Bool
122_ector_renderer_cairo_ector_renderer_draw(Eo *obj EINA_UNUSED,
123 Ector_Renderer_Cairo_Data *pd,
124 Efl_Gfx_Render_Op op,
125 Eina_Array *clips EINA_UNUSED,
126 unsigned int mul_col)
127{
128 int r, g, b, a;
129 cairo_operator_t cop;
130 double cx, cy;
131
132 switch (op)
133 {
134 case EFL_GFX_RENDER_OP_BLEND:
135 cop = CAIRO_OPERATOR_OVER;
136 break;
137 case EFL_GFX_RENDER_OP_COPY:
138 default:
139 cop = CAIRO_OPERATOR_SOURCE;
140 break;
141 }
142
143 r = ((pd->generic->color.r * R_VAL(&mul_col)) >> 8);
144 g = ((pd->generic->color.g * G_VAL(&mul_col)) >> 8);
145 b = ((pd->generic->color.b * B_VAL(&mul_col)) >> 8);
146 a = ((pd->generic->color.a * A_VAL(&mul_col)) >> 8);
147 ector_color_argb_unpremul(a, &r, &g, &b);
148
149 cairo_set_operator(pd->parent->cairo, cop);
150
151 if (clips)
152 {
153 int clip_count = eina_array_count(clips);
154 int i=0;
155 for (; i < clip_count ; i++)
156 {
157 Eina_Rectangle *clip = (Eina_Rectangle *)eina_array_data_get(clips, i);
158 double x = (double)clip->x;
159 double y = (double)clip->y;
160
161 cairo_new_path(pd->parent->cairo);
162 cairo_device_to_user(pd->parent->cairo, &x, &y);
163 cairo_rectangle(pd->parent->cairo, x, y, clip->w, clip->h);
164 }
165 cairo_clip(pd->parent->cairo);
166 }
167
168 cairo_transform(pd->parent->cairo, &identity);
169 cx = pd->generic->origin.x + pd->parent->current.x;
170 cy = pd->generic->origin.y + pd->parent->current.y;
171
172 cairo_translate(pd->parent->cairo, cx, cy);
173
174 if (pd->m) cairo_transform(pd->parent->cairo, pd->m);
175 else cairo_transform(pd->parent->cairo, &identity);
176
177 cairo_set_source_rgba(pd->parent->cairo, r/255.0, g/255.0, b/255.0, a/255.0);
178
179 return EINA_TRUE;
180}
181
182static Eo *
183_ector_renderer_cairo_efl_object_constructor(Eo *obj, Ector_Renderer_Cairo_Data *pd EINA_UNUSED)
184{
185 obj = efl_constructor(efl_super(obj, ECTOR_RENDERER_CAIRO_CLASS));
186 if (!obj) return NULL;
187
188 pd->generic = efl_data_xref(obj, ECTOR_RENDERER_CLASS, obj);
189
190 return obj;
191}
192
193static Efl_Object *
194_ector_renderer_cairo_efl_object_finalize(Eo *obj, Ector_Renderer_Cairo_Data *pd)
195{
196 obj = efl_finalize(efl_super(obj, ECTOR_RENDERER_CAIRO_CLASS));
197 if (!obj) return NULL;
198
199 USE(pd->generic, cairo_matrix_init, NULL);
200 USE(pd->generic, cairo_translate, NULL);
201 USE(pd->generic, cairo_set_source_rgba, NULL);
202 USE(pd->generic, cairo_transform, NULL);
203 USE(pd->generic, cairo_set_operator, NULL);
204 USE(pd->generic, cairo_new_path, NULL);
205 USE(pd->generic, cairo_rectangle, NULL);
206 USE(pd->generic, cairo_clip, NULL);
207 USE(pd->generic, cairo_device_to_user, NULL);
208 USE(pd->generic, cairo_matrix_init_identity, NULL);
209
210 cairo_matrix_init_identity(&identity);
211
212 return obj;
213}
214
215static void
216_ector_renderer_cairo_efl_object_destructor(Eo *obj, Ector_Renderer_Cairo_Data *pd)
217{
218 Ector_Renderer_Data *base;
219
220 base = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS);
221 efl_data_xunref(base->surface, pd->parent, obj);
222 efl_data_xunref(obj, pd->generic, obj);
223
224 free(pd->m);
225
226 efl_destructor(efl_super(obj, ECTOR_RENDERER_CAIRO_CLASS));
227}
228
229#include "ector_renderer_cairo.eo.c"
diff --git a/src/lib/ector/cairo/ector_renderer_cairo.eo b/src/lib/ector/cairo/ector_renderer_cairo.eo
deleted file mode 100644
index 3f100b1ef1..0000000000
--- a/src/lib/ector/cairo/ector_renderer_cairo.eo
+++ /dev/null
@@ -1,21 +0,0 @@
1abstract @beta Ector.Renderer.Cairo extends Ector.Renderer
2{
3 [[Ector cairo renderer abstract class]]
4 methods {
5 op_fill @pure_virtual {
6 [[Fill operation]]
7 return: bool; [[$true on success, $false otherwise]]
8 params {
9 @in mul_col: uint; [[Premultiplied color]]
10 }
11 }
12 }
13 implements {
14 Ector.Renderer.prepare;
15 Ector.Renderer.draw;
16 Ector.Renderer.color { get; set; }
17 Efl.Object.constructor;
18 Efl.Object.finalize;
19 Efl.Object.destructor;
20 }
21}
diff --git a/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.c b/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.c
deleted file mode 100644
index 598e625a8c..0000000000
--- a/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.c
+++ /dev/null
@@ -1,197 +0,0 @@
1#ifdef HAVE_CONFIG_H
2# include "config.h"
3#endif
4
5#include <Eina.h>
6#include <Ector.h>
7#include <cairo/Ector_Cairo.h>
8
9#include "ector_private.h"
10#include "ector_cairo_private.h"
11
12static cairo_pattern_t *(*cairo_pattern_create_linear)(double x0, double y0,
13 double x1, double y1) = NULL;
14static void (*cairo_set_source)(cairo_t *cr, cairo_pattern_t *source) = NULL;
15static void (*cairo_fill)(cairo_t *cr) = NULL;
16static void (*cairo_rectangle)(cairo_t *cr,
17 double x, double y,
18 double width, double height) = NULL;
19static void (*cairo_pattern_destroy)(cairo_pattern_t *pattern) = NULL;
20
21static void (*cairo_pattern_set_extend)(cairo_pattern_t *pattern, cairo_extend_t extend) = NULL;
22
23typedef struct _Ector_Renderer_Cairo_Gradient_Linear_Data Ector_Renderer_Cairo_Gradient_Linear_Data;
24struct _Ector_Renderer_Cairo_Gradient_Linear_Data
25{
26 Ector_Cairo_Surface_Data *parent;
27};
28
29static cairo_pattern_t *
30_ector_renderer_cairo_gradient_linear_prepare(Eo *obj EINA_UNUSED,
31 Ector_Renderer_Gradient_Linear_Data *gld,
32 Ector_Renderer_Gradient_Data *gd,
33 unsigned int mul_col)
34{
35 cairo_pattern_t *pat;
36
37 pat = cairo_pattern_create_linear(gld->start.x, gld->start.y,
38 gld->end.x, gld->end.y);
39 if (!pat) return NULL;
40 _ector_renderer_cairo_gradient_prepare(pat, gd, mul_col);
41
42 cairo_pattern_set_extend(pat, _ector_cairo_extent_get(gd->s));
43
44 return pat;
45}
46
47static Eina_Bool
48_ector_renderer_cairo_gradient_linear_ector_renderer_prepare(Eo *obj,
49 Ector_Renderer_Cairo_Gradient_Linear_Data *pd)
50{
51 ector_renderer_prepare(efl_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_LINEAR_CLASS));
52
53 if (!pd->parent)
54 {
55 Ector_Renderer_Data *base;
56
57 base = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS);
58 pd->parent = efl_data_xref(base->surface, ECTOR_CAIRO_SURFACE_CLASS, obj);
59 }
60
61 return EINA_FALSE;
62}
63
64static Eina_Bool
65_ector_renderer_cairo_gradient_linear_ector_renderer_draw(Eo *obj,
66 Ector_Renderer_Cairo_Gradient_Linear_Data *pd,
67 Efl_Gfx_Render_Op op, Eina_Array *clips, unsigned int mul_col)
68{
69 Ector_Renderer_Gradient_Linear_Data *gld;
70 Ector_Renderer_Gradient_Data *gd;
71 cairo_pattern_t *pat;
72
73 // FIXME: don't ignore clipping !
74 gld = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN);
75 gd = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_MIXIN);
76 if (!gd || !gld) return EINA_FALSE;
77
78 pat = _ector_renderer_cairo_gradient_linear_prepare(obj, gld, gd, mul_col);
79 if (!pat) return EINA_FALSE;
80
81 ector_renderer_draw(efl_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_LINEAR_CLASS), op, clips, mul_col);
82
83 cairo_rectangle(pd->parent->cairo, gld->start.x, gld->start.y,
84 gld->end.x - gld->start.x,
85 gld->end.y - gld->start.y);
86 cairo_set_source(pd->parent->cairo, pat);
87 cairo_fill(pd->parent->cairo);
88 cairo_pattern_destroy(pat);
89
90 return EINA_TRUE;
91}
92
93static Eina_Bool
94_ector_renderer_cairo_gradient_linear_ector_renderer_cairo_op_fill(Eo *obj,
95 Ector_Renderer_Cairo_Gradient_Linear_Data *pd,
96 unsigned int mul_col)
97{
98 Ector_Renderer_Gradient_Linear_Data *gld;
99 Ector_Renderer_Gradient_Data *gd;
100 cairo_pattern_t *pat;
101
102 gld = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN);
103 gd = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_MIXIN);
104 if (!gd || !gld) return EINA_FALSE;
105
106 pat = _ector_renderer_cairo_gradient_linear_prepare(obj, gld, gd, mul_col);
107 if (!pat) return EINA_FALSE;
108
109 cairo_set_source(pd->parent->cairo, pat);
110 cairo_pattern_destroy(pat);
111
112 return EINA_TRUE;
113}
114
115static void
116_ector_renderer_cairo_gradient_linear_efl_gfx_path_bounds_get(const Eo *obj,
117 Ector_Renderer_Cairo_Gradient_Linear_Data *pd EINA_UNUSED,
118 Eina_Rect *r)
119{
120 Ector_Renderer_Gradient_Linear_Data *gld;
121 Ector_Renderer_Cairo_Data *bd;
122
123 gld = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN);
124 bd = efl_data_scope_get(obj, ECTOR_RENDERER_CAIRO_CLASS);
125 EINA_RECTANGLE_SET(r,
126 bd->generic->origin.x + gld->start.x,
127 bd->generic->origin.y + gld->start.y,
128 gld->end.x - gld->start.x,
129 gld->end.y - gld->start.y);
130}
131
132static Efl_Object *
133_ector_renderer_cairo_gradient_linear_efl_object_finalize(Eo *obj, Ector_Renderer_Cairo_Gradient_Linear_Data *pd EINA_UNUSED)
134{
135 Ector_Renderer_Data *base;
136
137 obj = efl_finalize(efl_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_LINEAR_CLASS));
138 if (!obj) return NULL;
139
140 base = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS);
141
142 USE(base, cairo_set_source, NULL);
143 USE(base, cairo_pattern_destroy, NULL);
144 USE(base, cairo_rectangle, NULL);
145 USE(base, cairo_fill, NULL);
146 USE(base, cairo_pattern_destroy, NULL);
147 USE(base, cairo_set_source, NULL);
148 USE(base, cairo_pattern_set_extend, NULL);
149 USE(base, cairo_pattern_create_linear, NULL);
150 USE(base, cairo_pattern_add_color_stop_rgba, NULL);
151
152 return obj;
153}
154
155static void
156_ector_renderer_cairo_gradient_linear_efl_object_destructor(Eo *obj,
157 Ector_Renderer_Cairo_Gradient_Linear_Data *pd)
158{
159 Ector_Renderer_Data *base;
160
161 base = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS);
162 efl_data_xunref(base->surface, pd->parent, obj);
163
164 efl_destructor(efl_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_LINEAR_CLASS));
165}
166
167static void
168_ector_renderer_cairo_gradient_linear_efl_gfx_gradient_stop_set(Eo *obj,
169 Ector_Renderer_Cairo_Gradient_Linear_Data *pd EINA_UNUSED,
170 const Efl_Gfx_Gradient_Stop *colors,
171 unsigned int length)
172{
173 efl_gfx_gradient_stop_set(efl_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_LINEAR_CLASS), colors, length);
174}
175
176static unsigned int
177_ector_renderer_cairo_gradient_linear_ector_renderer_crc_get(const Eo *obj, Ector_Renderer_Cairo_Gradient_Linear_Data *pd EINA_UNUSED)
178{
179 Ector_Renderer_Gradient_Linear_Data *gld;
180 Ector_Renderer_Gradient_Data *gd;
181 unsigned int crc;
182
183 crc = ector_renderer_crc_get(efl_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_LINEAR_CLASS));
184
185 gld = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_LINEAR_MIXIN);
186 gd = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_MIXIN);
187 if (!gd || !gld) return crc;
188
189 crc = eina_crc((void*) gd->s, sizeof (Efl_Gfx_Gradient_Spread), crc, EINA_FALSE);
190 if (gd->colors_count)
191 crc = eina_crc((void*) gd->colors, sizeof (Efl_Gfx_Gradient_Stop) * gd->colors_count, crc, EINA_FALSE);
192 crc = eina_crc((void*) gld, sizeof (Ector_Renderer_Gradient_Linear_Data), crc, EINA_FALSE);
193
194 return crc;
195}
196
197#include "ector_renderer_cairo_gradient_linear.eo.c"
diff --git a/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.eo b/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.eo
deleted file mode 100644
index c6f2c4fe8d..0000000000
--- a/src/lib/ector/cairo/ector_renderer_cairo_gradient_linear.eo
+++ /dev/null
@@ -1,15 +0,0 @@
1class @beta Ector.Renderer.Cairo.Gradient.Linear extends Ector.Renderer.Cairo implements Ector.Renderer.Gradient, Ector.Renderer.Gradient.Linear, Efl.Gfx.Path
2{
3 [[Ector cairo renderer gradient linear]]
4 c_prefix: ector_renderer_cairo_gradient_linear;
5 implements {
6 Ector.Renderer.prepare;
7 Ector.Renderer.draw;
8 Efl.Gfx.Path.bounds_get;
9 Ector.Renderer.crc { get; }
10 Ector.Renderer.Cairo.op_fill;
11 Efl.Object.finalize;
12 Efl.Object.destructor;
13 Efl.Gfx.Gradient.stop { set; }
14 }
15}
diff --git a/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.c b/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.c
deleted file mode 100644
index bb5add0373..0000000000
--- a/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.c
+++ /dev/null
@@ -1,220 +0,0 @@
1#ifdef HAVE_CONFIG_H
2# include "config.h"
3#endif
4
5#include <Eina.h>
6#include <Ector.h>
7#include <cairo/Ector_Cairo.h>
8
9#include "ector_private.h"
10#include "ector_cairo_private.h"
11
12static cairo_pattern_t *(*cairo_pattern_create_radial)(double cx0, double cy0,
13 double radius0,
14 double cx1, double cy1,
15 double radius1) = NULL;
16static void (*cairo_set_source)(cairo_t *cr, cairo_pattern_t *source) = NULL;
17static void (*cairo_fill)(cairo_t *cr) = NULL;
18static void (*cairo_arc)(cairo_t *cr,
19 double xc, double yc,
20 double radius,
21 double angle1, double angle2) = NULL;
22static void (*cairo_pattern_destroy)(cairo_pattern_t *pattern) = NULL;
23
24static void (*cairo_pattern_set_extend)(cairo_pattern_t *pattern, cairo_extend_t extend) = NULL;
25static void (*cairo_pattern_set_matrix)(cairo_t *cr, cairo_matrix_t *matrix) = NULL;
26static void (*cairo_matrix_init)(cairo_matrix_t *matrix,
27 double xx, double yx,
28 double xy, double yy,
29 double x0, double y0) = NULL;
30
31// FIXME: as long as it is not possible to directly access the parent structure
32// this will be duplicated from the linear gradient renderer
33typedef struct _Ector_Renderer_Cairo_Gradient_Radial_Data Ector_Renderer_Cairo_Gradient_Radial_Data;
34struct _Ector_Renderer_Cairo_Gradient_Radial_Data
35{
36 Ector_Cairo_Surface_Data *parent;
37};
38
39static Eina_Bool
40_ector_renderer_cairo_gradient_radial_ector_renderer_prepare(Eo *obj, Ector_Renderer_Cairo_Gradient_Radial_Data *pd)
41{
42 ector_renderer_prepare(efl_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_RADIAL_CLASS));
43
44 if (!pd->parent)
45 {
46 Ector_Renderer_Data *base;
47
48 base = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS);
49 pd->parent = efl_data_xref(base->surface, ECTOR_CAIRO_SURFACE_CLASS, obj);
50 }
51
52 return EINA_FALSE;
53}
54
55static cairo_pattern_t *
56_ector_renderer_cairo_gradient_radial_prepare(Eo *obj,
57 Ector_Renderer_Gradient_Radial_Data *grd,
58 Ector_Renderer_Gradient_Data *gd,
59 unsigned int mul_col)
60{
61 Ector_Renderer_Data *pd = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS);
62 cairo_pattern_t *pat;
63 cairo_matrix_t pd_m;
64
65 pat = cairo_pattern_create_radial(grd->focal.x, grd->focal.y, 0,
66 grd->radial.x, grd->radial.y, grd->radius);
67 if (!pat) return NULL;
68
69 _ector_renderer_cairo_gradient_prepare(pat, gd, mul_col);
70
71 cairo_pattern_set_extend(pat, _ector_cairo_extent_get(gd->s));
72
73 if (pd->m)
74 {
75 cairo_matrix_init(&pd_m,
76 pd->m->xx, pd->m->yx,
77 pd->m->xy, pd->m->yy,
78 pd->m->xz, pd->m->yz);
79 cairo_pattern_set_matrix(pat, &pd_m);
80 }
81
82 return pat;
83}
84
85// Clearly duplicated and should be in a common place...
86static Eina_Bool
87_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)
88{
89 Ector_Renderer_Gradient_Radial_Data *grd;
90 Ector_Renderer_Gradient_Data *gd;
91 cairo_pattern_t *pat;
92
93 // FIXME: Handle clipping and generally make it work :-)
94 grd = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN);
95 gd = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_MIXIN);
96 if (!grd || !gd) return EINA_FALSE;
97
98 pat = _ector_renderer_cairo_gradient_radial_prepare(obj, grd, gd, mul_col);
99 if (!pat) return EINA_FALSE;
100
101 ector_renderer_draw(efl_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_RADIAL_CLASS), op, clips, mul_col);
102
103 cairo_arc(pd->parent->cairo,
104 grd->radial.x, grd->radial.y,
105 grd->radius,
106 0, 2 * M_PI);
107 cairo_set_source(pd->parent->cairo, pat);
108 cairo_fill(pd->parent->cairo);
109 cairo_pattern_destroy(pat);
110
111 return EINA_TRUE;
112}
113
114// Clearly duplicated and should be in a common place...
115static Eina_Bool
116_ector_renderer_cairo_gradient_radial_ector_renderer_cairo_op_fill(Eo *obj,
117 Ector_Renderer_Cairo_Gradient_Radial_Data *pd,
118 unsigned int mul_col)
119{
120 Ector_Renderer_Gradient_Radial_Data *grd;
121 Ector_Renderer_Gradient_Data *gd;
122 cairo_pattern_t *pat;
123
124 grd = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN);
125 gd = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_MIXIN);
126 if (!grd || !gd) return EINA_FALSE;
127
128 pat = _ector_renderer_cairo_gradient_radial_prepare(obj, grd, gd, mul_col);
129 if (!pat) return EINA_FALSE;
130
131 cairo_set_source(pd->parent->cairo, pat);
132 cairo_pattern_destroy(pat);
133
134 return EINA_TRUE;
135}
136
137static void
138_ector_renderer_cairo_gradient_radial_efl_gfx_path_bounds_get(const Eo *obj EINA_UNUSED,
139 Ector_Renderer_Cairo_Gradient_Radial_Data *pd EINA_UNUSED,
140 Eina_Rect *r)
141{
142 Ector_Renderer_Gradient_Radial_Data *gld;
143 Ector_Renderer_Cairo_Data *bd;
144
145 gld = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN);
146 bd = efl_data_scope_get(obj, ECTOR_RENDERER_CAIRO_CLASS);
147 EINA_RECTANGLE_SET(r,
148 bd->generic->origin.x + gld->radial.x - gld->radius,
149 bd->generic->origin.y + gld->radial.y - gld->radius,
150 gld->radius * 2, gld->radius * 2);
151}
152
153static Efl_Object *
154_ector_renderer_cairo_gradient_radial_efl_object_finalize(Eo *obj, Ector_Renderer_Cairo_Gradient_Radial_Data *pd EINA_UNUSED)
155{
156 Ector_Renderer_Data *base;
157
158 obj = efl_finalize(efl_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_RADIAL_CLASS));
159 if (!obj) return NULL;
160
161 base = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS);
162
163 USE(base, cairo_set_source, NULL);
164 USE(base, cairo_pattern_destroy, NULL);
165 USE(base, cairo_arc, NULL);
166 USE(base, cairo_fill, NULL);
167 USE(base, cairo_matrix_init, NULL);
168 USE(base, cairo_set_source, NULL);
169 USE(base, cairo_pattern_destroy, NULL);
170 USE(base, cairo_pattern_set_extend, NULL);
171 USE(base, cairo_pattern_set_matrix, NULL);
172 USE(base, cairo_pattern_create_radial, NULL);
173 USE(base, cairo_pattern_add_color_stop_rgba, NULL);
174
175 return obj;
176}
177
178static void
179_ector_renderer_cairo_gradient_radial_efl_object_destructor(Eo *obj,
180 Ector_Renderer_Cairo_Gradient_Radial_Data *pd)
181{
182 Ector_Renderer_Data *base;
183
184 base = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS);
185 efl_data_xunref(base->surface, pd->parent, obj);
186
187 efl_destructor(efl_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_RADIAL_CLASS));
188}
189
190static void
191_ector_renderer_cairo_gradient_radial_efl_gfx_gradient_stop_set(Eo *obj,
192 Ector_Renderer_Cairo_Gradient_Radial_Data *pd EINA_UNUSED,
193 const Efl_Gfx_Gradient_Stop *colors,
194 unsigned int length)
195{
196 efl_gfx_gradient_stop_set(efl_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_RADIAL_CLASS), colors, length);
197}
198
199static unsigned int
200_ector_renderer_cairo_gradient_radial_ector_renderer_crc_get(const Eo *obj, Ector_Renderer_Cairo_Gradient_Radial_Data *pd EINA_UNUSED)
201{
202 Ector_Renderer_Gradient_Radial_Data *grd;
203 Ector_Renderer_Gradient_Data *gd;
204 unsigned int crc;
205
206 crc = ector_renderer_crc_get(efl_super(obj, ECTOR_RENDERER_CAIRO_GRADIENT_RADIAL_CLASS));
207
208 grd = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_RADIAL_MIXIN);
209 gd = efl_data_scope_get(obj, ECTOR_RENDERER_GRADIENT_MIXIN);
210 if (!grd || !gd) return crc;
211
212 crc = eina_crc((void*) gd->s, sizeof (Efl_Gfx_Gradient_Spread), crc, EINA_FALSE);
213 if (gd->colors_count)
214 crc = eina_crc((void*) gd->colors, sizeof (Efl_Gfx_Gradient_Stop) * gd->colors_count, crc, EINA_FALSE);
215 crc = eina_crc((void*) grd, sizeof (Ector_Renderer_Gradient_Radial_Data), crc, EINA_FALSE);
216
217 return crc;
218}
219
220#include "ector_renderer_cairo_gradient_radial.eo.c"
diff --git a/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.eo b/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.eo
deleted file mode 100644
index bdf0059b3c..0000000000
--- a/src/lib/ector/cairo/ector_renderer_cairo_gradient_radial.eo
+++ /dev/null
@@ -1,15 +0,0 @@
1class @beta Ector.Renderer.Cairo.Gradient.Radial extends Ector.Renderer.Cairo implements Ector.Renderer.Gradient, Ector.Renderer.Gradient.Radial, Efl.Gfx.Path
2{
3 [[Ector cairo renderer gradient radial]]
4 c_prefix: ector_renderer_cairo_gradient_radial;
5 implements {
6 Ector.Renderer.prepare;
7 Ector.Renderer.draw;
8 Efl.Gfx.Path.bounds_get;
9 Ector.Renderer.crc { get; }
10 Ector.Renderer.Cairo.op_fill;
11 Efl.Object.destructor;
12 Efl.Object.finalize;
13 Efl.Gfx.Gradient.stop { set; }
14 }
15}
diff --git a/src/lib/ector/cairo/ector_renderer_cairo_shape.c b/src/lib/ector/cairo/ector_renderer_cairo_shape.c
deleted file mode 100644
index 87fe2a0778..0000000000
--- a/src/lib/ector/cairo/ector_renderer_cairo_shape.c
+++ /dev/null
@@ -1,331 +0,0 @@
1#ifdef HAVE_CONFIG_H
2# include "config.h"
3#endif
4
5#include <math.h>
6#include <float.h>
7
8#include <Eina.h>
9#include <Ector.h>
10#include <cairo/Ector_Cairo.h>
11
12#include "ector_private.h"
13#include "ector_cairo_private.h"
14
15typedef struct _cairo_path_t cairo_path_t;
16
17typedef enum _cairo_line_cap {
18 CAIRO_LINE_CAP_BUTT,
19 CAIRO_LINE_CAP_ROUND,
20 CAIRO_LINE_CAP_SQUARE
21} cairo_line_cap_t;
22
23typedef enum _cairo_line_join {
24 CAIRO_LINE_JOIN_MITER,
25 CAIRO_LINE_JOIN_ROUND,
26 CAIRO_LINE_JOIN_BEVEL
27} cairo_line_join_t;
28
29typedef enum _cairo_fill_rule {
30 CAIRO_FILL_RULE_WINDING,
31 CAIRO_FILL_RULE_EVEN_ODD
32} cairo_fill_rule_t;
33
34static void (*cairo_move_to)(cairo_t *cr, double x, double y) = NULL;
35static void (*cairo_line_to)(cairo_t *cr, double x, double y) = NULL;
36static void (*cairo_curve_to)(cairo_t *cr,
37 double x1, double y1,
38 double x2, double y2,
39 double x3, double y3) = NULL;
40static void (*cairo_close_path)(cairo_t *cr) = NULL;
41
42static void (*cairo_fill)(cairo_t *cr) = NULL;
43static void (*cairo_fill_preserve)(cairo_t *cr) = NULL;
44static void (*cairo_stroke)(cairo_t *cr) = NULL;
45
46static void (*cairo_set_source_rgba)(cairo_t *cr,
47 double red, double green,
48 double blue, double alpha) = NULL;
49
50
51static cairo_path_t *(*cairo_copy_path)(cairo_t *cr) = NULL;
52static void (*cairo_path_destroy)(cairo_path_t *path) = NULL;
53static void (*cairo_new_path)(cairo_t *cr) = NULL;
54static void (*cairo_append_path)(cairo_t *cr, const cairo_path_t *path) = NULL;
55
56static void (*cairo_set_line_width)(cairo_t *cr, double width) = NULL;
57static void (*cairo_set_line_cap)(cairo_t *cr, cairo_line_cap_t line_cap) = NULL;
58static void (*cairo_set_line_join)(cairo_t *cr, cairo_line_join_t line_join) = NULL;
59
60static void (*cairo_save)(cairo_t *cr) = NULL;
61static void (*cairo_restore)(cairo_t *cr) = NULL;
62
63static void (*cairo_set_dash) (cairo_t *cr, const double *dashes, int num_dashes, double offset) = NULL;
64static void (*cairo_set_fill_rule) (cairo_t *cr, cairo_fill_rule_t fill_rule);
65
66typedef struct _Ector_Renderer_Cairo_Shape_Data Ector_Renderer_Cairo_Shape_Data;
67struct _Ector_Renderer_Cairo_Shape_Data
68{
69 Efl_Gfx_Shape_Public *public_shape;
70
71 Ector_Cairo_Surface_Data *parent;
72 Ector_Renderer_Shape_Data *shape;
73 Ector_Renderer_Data *base;
74
75 cairo_path_t *path;
76};
77
78EOLIAN static void
79_ector_renderer_cairo_shape_efl_gfx_path_commit(Eo *obj EINA_UNUSED,
80 Ector_Renderer_Cairo_Shape_Data *pd)
81{
82 if (pd->path)
83 {
84 cairo_path_destroy(pd->path);
85 pd->path = NULL;
86 }
87}
88
89static Eina_Bool
90_ector_renderer_cairo_shape_ector_renderer_prepare(Eo *obj, Ector_Renderer_Cairo_Shape_Data *pd)
91{
92 const Efl_Gfx_Path_Command *cmds = NULL;
93 const double *pts = NULL;
94
95 ector_renderer_prepare(efl_super(obj, ECTOR_RENDERER_CAIRO_SHAPE_CLASS));
96
97 // shouldn't this be moved to the cairo base object?
98 if (!pd->parent)
99 {
100 Ector_Renderer_Data *base;
101
102 base = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS);
103 pd->parent = efl_data_xref(base->surface, ECTOR_CAIRO_SURFACE_CLASS, obj);
104 }
105
106 efl_gfx_path_get(obj, &cmds, &pts);
107 if (!pd->path && cmds)
108 {
109 cairo_new_path(pd->parent->cairo);
110
111 for (; *cmds != EFL_GFX_PATH_COMMAND_TYPE_END; cmds++)
112 {
113 switch (*cmds)
114 {
115 case EFL_GFX_PATH_COMMAND_TYPE_MOVE_TO:
116 cairo_move_to(pd->parent->cairo, pts[0], pts[1]);
117
118 pts += 2;
119 break;
120 case EFL_GFX_PATH_COMMAND_TYPE_LINE_TO:
121 cairo_line_to(pd->parent->cairo, pts[0], pts[1]);
122
123 pts += 2;
124 break;
125 case EFL_GFX_PATH_COMMAND_TYPE_CUBIC_TO:
126
127 cairo_curve_to(pd->parent->cairo,
128 pts[0], pts[1], pts[2], pts[3], // control points
129 pts[4], pts[5]); // destination point
130
131 pts += 6;
132 break;
133 case EFL_GFX_PATH_COMMAND_TYPE_CLOSE:
134 cairo_close_path(pd->parent->cairo);
135 break;
136 case EFL_GFX_PATH_COMMAND_TYPE_LAST:
137 case EFL_GFX_PATH_COMMAND_TYPE_END:
138 break;
139 }
140 }
141
142 pd->path = cairo_copy_path(pd->parent->cairo);
143 }
144
145 return EINA_TRUE;
146}
147
148static Eina_Bool
149_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)
150{
151 int r, g, b, a;
152 unsigned i;
153 Efl_Gfx_Fill_Rule fill_rule;
154
155 if (pd->path == NULL) return EINA_FALSE;
156
157 cairo_save(pd->parent->cairo);
158
159 ector_renderer_draw(efl_super(obj, ECTOR_RENDERER_CAIRO_SHAPE_CLASS), op, clips, mul_col);
160
161 cairo_new_path(pd->parent->cairo);
162 cairo_append_path(pd->parent->cairo, pd->path);
163
164 fill_rule = efl_gfx_shape_fill_rule_get(obj);
165 if (fill_rule == EFL_GFX_FILL_RULE_ODD_EVEN)
166 cairo_set_fill_rule(pd->parent->cairo, CAIRO_FILL_RULE_EVEN_ODD);
167 else
168 cairo_set_fill_rule(pd->parent->cairo, CAIRO_FILL_RULE_WINDING);
169
170 if (pd->shape->fill)
171 ector_renderer_cairo_op_fill(pd->shape->fill, mul_col);
172
173 if (pd->shape->stroke.fill || pd->public_shape->stroke.color.a > 0)
174 {
175 cairo_fill_preserve(pd->parent->cairo);
176
177 if (pd->shape->stroke.fill)
178 ector_renderer_cairo_op_fill(pd->shape->stroke.fill, mul_col);
179 else
180 {
181 r = (((pd->public_shape->stroke.color.r * R_VAL(&mul_col)) + 0xff) >> 8);
182 g = (((pd->public_shape->stroke.color.g * G_VAL(&mul_col)) + 0xff) >> 8);
183 b = (((pd->public_shape->stroke.color.b * B_VAL(&mul_col)) + 0xff) >> 8);
184 a = (((pd->public_shape->stroke.color.a * A_VAL(&mul_col)) + 0xff) >> 8);
185 ector_color_argb_unpremul(a, &r, &g, &b);
186 cairo_set_source_rgba(pd->parent->cairo, r/255.0, g/255.0, b/255.0, a/255.0);
187 if (pd->public_shape->stroke.dash)
188 {
189 double *dashinfo;
190
191 dashinfo = (double *) malloc(2 * pd->public_shape->stroke.dash_length * sizeof(double));
192 for (i = 0; i < pd->public_shape->stroke.dash_length; i++)
193 {
194 dashinfo[i*2] = pd->public_shape->stroke.dash[i].length;
195 dashinfo[i*2 + 1] = pd->public_shape->stroke.dash[i].gap;
196 }
197 cairo_set_dash(pd->parent->cairo, dashinfo, pd->public_shape->stroke.dash_length * 2, 0);
198 free(dashinfo);
199 }
200 }
201
202 // Set dash, cap and join
203 cairo_set_line_width(pd->parent->cairo, (pd->public_shape->stroke.width * pd->public_shape->stroke.scale));
204 cairo_set_line_cap(pd->parent->cairo, (cairo_line_cap_t) pd->public_shape->stroke.cap);
205 cairo_set_line_join(pd->parent->cairo, (cairo_line_join_t) pd->public_shape->stroke.join);
206 cairo_stroke(pd->parent->cairo);
207 }
208 else
209 {
210 cairo_fill(pd->parent->cairo);
211 }
212
213 cairo_restore(pd->parent->cairo);
214 return EINA_TRUE;
215}
216
217static Eina_Bool
218_ector_renderer_cairo_shape_ector_renderer_cairo_op_fill(Eo *obj EINA_UNUSED,
219 Ector_Renderer_Cairo_Shape_Data *pd EINA_UNUSED,
220 unsigned int mul_col EINA_UNUSED)
221{
222 // FIXME: let's find out how to fill a shape with a shape later.
223 // I need to read SVG specification and see how to map that with cairo.
224 ERR("fill with shape not implemented\n");
225 return EINA_FALSE;
226}
227
228static void
229_ector_renderer_cairo_shape_efl_gfx_path_bounds_get(const Eo *obj,
230 Ector_Renderer_Cairo_Shape_Data *pd EINA_UNUSED,
231 Eina_Rect *r)
232{
233 Ector_Renderer_Cairo_Data *bd;
234
235 // FIXME: It should be possible to ask cairo about this
236 efl_gfx_path_bounds_get(obj, r);
237
238 bd = efl_data_scope_get(obj, ECTOR_RENDERER_CAIRO_CLASS);
239 r->x += bd->generic->origin.x;
240 r->y += bd->generic->origin.y;
241}
242
243Eo *
244_ector_renderer_cairo_shape_efl_object_constructor(Eo *obj, Ector_Renderer_Cairo_Shape_Data *pd)
245{
246 obj = efl_constructor(efl_super(obj, ECTOR_RENDERER_CAIRO_SHAPE_CLASS));
247
248 if (!obj) return NULL;
249
250 pd->public_shape = efl_data_xref(obj, EFL_GFX_SHAPE_MIXIN, obj);
251 pd->shape = efl_data_xref(obj, ECTOR_RENDERER_SHAPE_MIXIN, obj);
252 pd->base = efl_data_xref(obj, ECTOR_RENDERER_CLASS, obj);
253
254 return obj;
255}
256
257static Efl_Object *
258_ector_renderer_cairo_shape_efl_object_finalize(Eo *obj, Ector_Renderer_Cairo_Shape_Data *pd)
259{
260 obj = efl_finalize(efl_super(obj, ECTOR_RENDERER_CAIRO_SHAPE_CLASS));
261 if (!obj) return NULL;
262
263 USE(pd->base, cairo_path_destroy, NULL);
264 USE(pd->base, cairo_restore, NULL);
265 USE(pd->base, cairo_fill, NULL);
266 USE(pd->base, cairo_set_dash, NULL);
267 USE(pd->base, cairo_fill_preserve, NULL);
268 USE(pd->base, cairo_set_source_rgba, NULL);
269 USE(pd->base, cairo_stroke, NULL);
270 USE(pd->base, cairo_set_line_width, NULL);
271 USE(pd->base, cairo_set_line_cap, NULL);
272 USE(pd->base, cairo_set_line_join, NULL);
273 USE(pd->base, cairo_new_path, NULL);
274 USE(pd->base, cairo_append_path, NULL);
275 USE(pd->base, cairo_save, NULL);
276 USE(pd->base, cairo_copy_path, NULL);
277 USE(pd->base, cairo_close_path, NULL);
278 USE(pd->base, cairo_curve_to, NULL);
279 USE(pd->base, cairo_line_to, NULL);
280 USE(pd->base, cairo_move_to, NULL);
281 USE(pd->base, cairo_set_fill_rule, NULL);
282
283 return obj;
284}
285
286void
287_ector_renderer_cairo_shape_efl_object_destructor(Eo *obj, Ector_Renderer_Cairo_Shape_Data *pd)
288{
289 Ector_Renderer_Data *base;
290
291 // FIXME: As base class destructor can't call destructor of mixin class.
292 // Call explicit API to free shape data.
293 efl_gfx_path_reset(obj);
294
295 base = efl_data_scope_get(obj, ECTOR_RENDERER_CLASS);
296 efl_data_xunref(base->surface, pd->parent, obj);
297
298 efl_data_xunref(obj, pd->shape, obj);
299 efl_data_xunref(obj, pd->base, obj);
300
301 efl_destructor(efl_super(obj, ECTOR_RENDERER_CAIRO_SHAPE_CLASS));
302
303 if (pd->path) cairo_path_destroy(pd->path);
304}
305
306unsigned int
307_ector_renderer_cairo_shape_ector_renderer_crc_get(const Eo *obj,
308 Ector_Renderer_Cairo_Shape_Data *pd)
309{
310 unsigned int crc;
311
312 crc = ector_renderer_crc_get(efl_super(obj, ECTOR_RENDERER_CAIRO_SHAPE_CLASS));
313
314 crc = eina_crc((void*) &pd->shape->stroke.marker, sizeof (pd->shape->stroke.marker), crc, EINA_FALSE);
315 crc = eina_crc((void*) &pd->public_shape->stroke.scale, sizeof (pd->public_shape->stroke.scale) * 3, crc, EINA_FALSE); // scale, width, centered
316 crc = eina_crc((void*) &pd->public_shape->stroke.color, sizeof (pd->public_shape->stroke.color), crc, EINA_FALSE);
317 crc = eina_crc((void*) &pd->public_shape->stroke.cap, sizeof (pd->public_shape->stroke.cap), crc, EINA_FALSE);
318 crc = eina_crc((void*) &pd->public_shape->stroke.join, sizeof (pd->public_shape->stroke.join), crc, EINA_FALSE);
319
320 if (pd->shape->fill) crc = _renderer_crc_get(pd->shape->fill, crc);
321 if (pd->shape->stroke.fill) crc = _renderer_crc_get(pd->shape->stroke.fill, crc);
322 if (pd->shape->stroke.marker) crc = _renderer_crc_get(pd->shape->stroke.marker, crc);
323 if (pd->public_shape->stroke.dash_length)
324 {
325 crc = eina_crc((void*) pd->public_shape->stroke.dash, sizeof (Efl_Gfx_Dash) * pd->public_shape->stroke.dash_length, crc, EINA_FALSE);
326 }
327
328 return crc;
329}
330
331#include "ector_renderer_cairo_shape.eo.c"
diff --git a/src/lib/ector/cairo/ector_renderer_cairo_shape.eo b/src/lib/ector/cairo/ector_renderer_cairo_shape.eo
deleted file mode 100644
index b2d41c6842..0000000000
--- a/src/lib/ector/cairo/ector_renderer_cairo_shape.eo
+++ /dev/null
@@ -1,16 +0,0 @@
1class @beta Ector.Renderer.Cairo.Shape extends Ector.Renderer.Cairo implements Ector.Renderer.Shape, Efl.Gfx.Path
2{
3 [[Ector cairo renderer shape class]]
4 c_prefix: ector_renderer_cairo_shape;
5 implements {
6 Ector.Renderer.prepare;
7 Ector.Renderer.draw;
8 Efl.Gfx.Path.bounds_get;
9 Efl.Gfx.Path.commit;
10 Ector.Renderer.crc { get; }
11 Ector.Renderer.Cairo.op_fill;
12 Efl.Object.constructor;
13 Efl.Object.finalize;
14 Efl.Object.destructor;
15 }
16}
diff --git a/src/lib/ector/cairo/meson.build b/src/lib/ector/cairo/meson.build
deleted file mode 100644
index 094aedb3e6..0000000000
--- a/src/lib/ector/cairo/meson.build
+++ /dev/null
@@ -1,39 +0,0 @@
1
2ector_src += files([
3 'ector_renderer_cairo_gradient_linear.c',
4 'ector_renderer_cairo_gradient_radial.c',
5 'ector_renderer_cairo_shape.c',
6 'ector_renderer_cairo.c',
7 'ector_cairo_software_surface.c',
8 'ector_cairo_surface.c'
9])
10
11pub_eo_files = [
12 'ector_cairo_surface.eo',
13 'ector_cairo_software_surface.eo',
14 'ector_renderer_cairo.eo',
15 'ector_renderer_cairo_shape.eo',
16 'ector_renderer_cairo_gradient_linear.eo',
17 'ector_renderer_cairo_gradient_radial.eo'
18]
19
20foreach eo_file : pub_eo_files
21 pub_eo_file_target += custom_target('eolian_gen_' + eo_file,
22 input : eo_file,
23 output : [eo_file + '.h'],
24 depfile : eo_file + '.d',
25 install : false,
26 install_dir : dir_package_include,
27 command : eolian_gen + [ '-I', meson.current_source_dir(), eolian_include_directories,
28 '-o', 'h:' + join_paths(meson.current_build_dir(), eo_file + '.h'),
29 '-o', 'c:' + join_paths(meson.current_build_dir(), eo_file + '.c'),
30 '-o', 'd:' + join_paths(meson.current_build_dir(), eo_file + '.d'),
31 '-gchd', '@INPUT@'])
32endforeach
33
34
35if get_option('install-eo-files')
36 install_data(pub_eo_files,
37 install_dir: join_paths(eolian_include_dir, package_version_name)
38 )
39endif
diff --git a/src/lib/ector/gl/Ector_GL.h b/src/lib/ector/gl/Ector_GL.h
index 131288a180..88b6c6bae1 100644
--- a/src/lib/ector/gl/Ector_GL.h
+++ b/src/lib/ector/gl/Ector_GL.h
@@ -34,8 +34,6 @@
34#ifndef _ECTOR_GL_SURFACE_EO_CLASS_TYPE 34#ifndef _ECTOR_GL_SURFACE_EO_CLASS_TYPE
35#define _ECTOR_GL_SURFACE_EO_CLASS_TYPE 35#define _ECTOR_GL_SURFACE_EO_CLASS_TYPE
36 36
37typedef Eo Ector_Cairo_Surface;
38
39#endif 37#endif
40 38
41typedef unsigned int GLuint; 39typedef unsigned int GLuint;
diff --git a/src/lib/ector/meson.build b/src/lib/ector/meson.build
index 5bedb7e82b..b0d33a1d42 100644
--- a/src/lib/ector/meson.build
+++ b/src/lib/ector/meson.build
@@ -50,7 +50,6 @@ endforeach
50 50
51eolian_include_directories += ['-I', meson.current_source_dir()] 51eolian_include_directories += ['-I', meson.current_source_dir()]
52 52
53subdir('cairo')
54subdir('gl') 53subdir('gl')
55 54
56pub_eo_types_files = [ 55pub_eo_types_files = [
diff --git a/src/lib/ector/software/ector_software_buffer.c b/src/lib/ector/software/ector_software_buffer.c
index 5a5c940f7f..df7fc27d1f 100644
--- a/src/lib/ector/software/ector_software_buffer.c
+++ b/src/lib/ector/software/ector_software_buffer.c
@@ -45,7 +45,7 @@ _pixels_gry8_to_argb_convert(uint32_t *dst, const uint8_t *src, int len)
45} 45}
46 46
47EOLIAN static void 47EOLIAN static void
48_ector_software_buffer_base_pixels_clear(Eo *obj, Ector_Software_Buffer_Base_Data *pd) 48_ector_software_buffer_base_pixels_clear(Eo *obj EINA_UNUSED, Ector_Software_Buffer_Base_Data *pd)
49{ 49{
50 if (!pd->pixels.u8) return; 50 if (!pd->pixels.u8) return;
51 51