timer23
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

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

This commit is contained in:
Tom Hacohen 2016-05-11 13:13:27 +01:00
parent 70b5f3875e
commit d64f2fdd43
19 changed files with 193 additions and 193 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/Makefile_Evas.am
View File

@ -26,7 +26,7 @@ evas_eolian_pub_files = \
lib/evas/canvas/evas_canvas3d_scene.eo\
lib/evas/canvas/evas_canvas3d_object.eo \
lib/evas/canvas/evas_vg.eo \
lib/evas/canvas/efl_vg_base.eo \
lib/evas/canvas/efl_vg.eo \
lib/evas/canvas/efl_vg_container.eo \
lib/evas/canvas/efl_vg_shape.eo \
lib/evas/canvas/efl_vg_root_node.eo \

2
src/lib/evas/Evas_Eo.h
View File

@ -293,7 +293,7 @@ typedef void (Evas_Canvas3D_Surface_Func)(Evas_Real *out_x,
* @}
*/
#include "canvas/efl_vg_base.eo.h"
#include "canvas/efl_vg.eo.h"
#include "canvas/efl_vg_container.eo.h"
#include "canvas/efl_vg_shape.eo.h"
#include "canvas/efl_vg_gradient.eo.h"

2
src/lib/evas/Evas_Legacy.h
View File

@ -1905,7 +1905,7 @@ EAPI void evas_vg_node_raise(Eo *obj);
*/
EAPI void evas_vg_node_lower(Eo *obj);
#include "canvas/efl_vg_base.eo.legacy.h"
#include "canvas/efl_vg.eo.legacy.h"
/**
*

10
src/lib/evas/canvas/efl_vg_base.eo → src/lib/evas/canvas/efl_vg.eo
View File

@ -1,6 +1,6 @@
import eina_types;
abstract Efl.VG.Base (Eo.Base, Efl.Gfx, Efl.Gfx.Stack)
abstract Efl.VG (Eo.Base, Efl.Gfx, Efl.Gfx.Stack)
{
eo_prefix: efl_vg;
legacy_prefix: evas_vg_node;
@ -68,7 +68,7 @@ abstract Efl.VG.Base (Eo.Base, Efl.Gfx, Efl.Gfx.Stack)
get {
}
values {
m: Efl.VG.Base *;
m: Efl.VG *;
}
}
/* quality {
@ -94,14 +94,14 @@ abstract Efl.VG.Base (Eo.Base, Efl.Gfx, Efl.Gfx.Stack)
interpolate {
return: bool;
params {
@in from: const(Efl.VG.Base)*;
@in to: const(Efl.VG.Base)*;
@in from: const(Efl.VG)*;
@in to: const(Efl.VG)*;
@in pos_map: double;
}
}
dup {
params {
@in from: const(Efl.VG.Base)*;
@in from: const(Efl.VG)*;
}
}
}

12
src/lib/evas/canvas/efl_vg_container.eo
View File

@ -1,4 +1,4 @@
class Efl.VG.Container (Efl.VG.Base)
class Efl.VG.Container (Efl.VG)
{
legacy_prefix: evas_vg_container;
methods {
@ -6,17 +6,17 @@ class Efl.VG.Container (Efl.VG.Base)
params {
@in name: const(char)*;
}
return: Efl.VG.Base *;
return: Efl.VG *;
}
children_get {
return: free(own(iterator<Efl.VG.Base *>*), eina_iterator_free) @warn_unused;
return: free(own(iterator<Efl.VG *>*), eina_iterator_free) @warn_unused;
}
}
implements {
Eo.Base.constructor;
Eo.Base.destructor;
Efl.VG.Base.bounds_get;
Efl.VG.Base.interpolate;
Efl.VG.Base.dup;
Efl.VG.bounds_get;
Efl.VG.interpolate;
Efl.VG.dup;
}
}

6
src/lib/evas/canvas/efl_vg_gradient.eo
View File

@ -1,4 +1,4 @@
abstract Efl.VG.Gradient (Efl.VG.Base, Efl.Gfx.Gradient)
abstract Efl.VG.Gradient (Efl.VG, Efl.Gfx.Gradient)
{
legacy_prefix: evas_vg_gradient;
implements {
@ -6,7 +6,7 @@ abstract Efl.VG.Gradient (Efl.VG.Base, Efl.Gfx.Gradient)
Efl.Gfx.Gradient.stop.get;
Efl.Gfx.Gradient.spread.set;
Efl.Gfx.Gradient.spread.get;
Efl.VG.Base.interpolate;
Efl.VG.Base.dup;
Efl.VG.interpolate;
Efl.VG.dup;
}
}

6
src/lib/evas/canvas/efl_vg_gradient_linear.eo
View File

@ -6,9 +6,9 @@ class Efl.VG.Gradient_Linear (Efl.VG.Gradient, Efl.Gfx.Gradient.Linear)
Efl.Gfx.Gradient.Linear.start.get;
Efl.Gfx.Gradient.Linear.end.set;
Efl.Gfx.Gradient.Linear.end.get;
Efl.VG.Base.bounds_get;
Efl.VG.Base.interpolate;
Efl.VG.Base.dup;
Efl.VG.bounds_get;
Efl.VG.interpolate;
Efl.VG.dup;
Eo.Base.constructor;
Eo.Base.destructor;
}

6
src/lib/evas/canvas/efl_vg_gradient_radial.eo
View File

@ -8,9 +8,9 @@ class Efl.VG.Gradient_Radial (Efl.VG.Gradient, Efl.Gfx.Gradient.Radial)
Efl.Gfx.Gradient.Radial.radius.get;
Efl.Gfx.Gradient.Radial.focal.set;
Efl.Gfx.Gradient.Radial.focal.get;
Efl.VG.Base.bounds_get;
Efl.VG.Base.interpolate;
Efl.VG.Base.dup;
Efl.VG.bounds_get;
Efl.VG.interpolate;
Efl.VG.dup;
Eo.Base.constructor;
Eo.Base.destructor;
}

14
src/lib/evas/canvas/efl_vg_shape.eo
View File

@ -1,4 +1,4 @@
class Efl.VG.Shape (Efl.VG.Base, Efl.Gfx.Shape)
class Efl.VG.Shape (Efl.VG, Efl.Gfx.Shape)
{
legacy_prefix: evas_vg_shape;
methods {
@ -8,7 +8,7 @@ class Efl.VG.Shape (Efl.VG.Base, Efl.Gfx.Shape)
get {
}
values {
f: Efl.VG.Base *;
f: Efl.VG *;
}
}
@property stroke_fill {
@ -17,7 +17,7 @@ class Efl.VG.Shape (Efl.VG.Base, Efl.Gfx.Shape)
get {
}
values {
f: Efl.VG.Base *;
f: Efl.VG *;
}
}
@property stroke_marker {
@ -26,16 +26,16 @@ class Efl.VG.Shape (Efl.VG.Base, Efl.Gfx.Shape)
get {
}
values {
m: Efl.VG.Base *;
m: Efl.VG *;
}
}
}
implements {
Efl.Gfx.color_part.set;
Efl.Gfx.color_part.get;
Efl.VG.Base.bounds_get;
Efl.VG.Base.interpolate;
Efl.VG.Base.dup;
Efl.VG.bounds_get;
Efl.VG.interpolate;
Efl.VG.dup;
Eo.Base.constructor;
Eo.Base.destructor;
}

8
src/lib/evas/canvas/evas_object_vg.c
View File

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

2
src/lib/evas/canvas/evas_vg.eo
View File

@ -14,7 +14,7 @@ class Evas.VG (Evas.Object, Efl.Gfx.Fill, Efl.Gfx.View)
@since 1.14]]
}
values {
container: Eo.Base *; [[Root node of the VG canvas.]] /* FIXME: Should be Efl.VG.Base */
container: Eo.Base *; [[Root node of the VG canvas.]] /* FIXME: Should be Efl.VG */
}
}
}

20
src/lib/evas/canvas/evas_vg_container.c
View File

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

12
src/lib/evas/canvas/evas_vg_gradient.c
View File

@ -21,7 +21,7 @@ _efl_vg_gradient_efl_gfx_gradient_stop_set(Eo *obj EINA_UNUSED,
memcpy(pd->colors, colors, length * sizeof(Efl_Gfx_Gradient_Stop));
pd->colors_count = length;
_efl_vg_base_changed(obj);
_efl_vg_changed(obj);
}
static void
@ -41,7 +41,7 @@ _efl_vg_gradient_efl_gfx_gradient_spread_set(Eo *obj EINA_UNUSED,
{
pd->s = s;
_efl_vg_base_changed(obj);
_efl_vg_changed(obj);
}
static Efl_Gfx_Gradient_Spread
@ -52,9 +52,9 @@ _efl_vg_gradient_efl_gfx_gradient_spread_get(Eo *obj EINA_UNUSED,
}
static Eina_Bool
_efl_vg_gradient_efl_vg_base_interpolate(Eo *obj,
_efl_vg_gradient_efl_vg_interpolate(Eo *obj,
Efl_VG_Gradient_Data *pd,
const Efl_VG_Base *from, const Efl_VG_Base *to,
const Efl_VG *from, const Efl_VG *to,
double pos_map)
{
Efl_VG_Gradient_Data *fromd, *tod;
@ -95,9 +95,9 @@ _efl_vg_gradient_efl_vg_base_interpolate(Eo *obj,
}
static void
_efl_vg_gradient_efl_vg_base_dup(Eo *obj,
_efl_vg_gradient_efl_vg_dup(Eo *obj,
Efl_VG_Gradient_Data *pd EINA_UNUSED,
const Efl_VG_Base *from)
const Efl_VG *from)
{
Efl_VG_Gradient_Data *fromd;

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

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

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

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

186
src/lib/evas/canvas/evas_vg_node.c
View File

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

14
src/lib/evas/canvas/evas_vg_private.h
View File

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

12
src/lib/evas/canvas/evas_vg_root_node.c
View File

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

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

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