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

efl_vg: namespace moves 

efl.vg -> efl.canvas.vg.node
efl.vg.* -> efl.canvas.vg.*

ref T6714
This commit is contained in:
Mike Blumenkrantz 2018-02-20 15:24:09 -05:00
parent 4959286c29
commit 7eb0375c0e
21 changed files with 358 additions and 357 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

12
src/Makefile_Evas.am
View File

@ -20,12 +20,12 @@ evas_canvas_eolian_pub_files = \
lib/evas/canvas/evas_canvas3d_scene.eo\
lib/evas/canvas/evas_canvas3d_object.eo \
lib/evas/canvas/efl_canvas_vg.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_gradient.eo \
lib/evas/canvas/efl_vg_gradient_radial.eo \
lib/evas/canvas/efl_vg_gradient_linear.eo \
lib/evas/canvas/efl_canvas_vg_node.eo \
lib/evas/canvas/efl_canvas_vg_container.eo \
lib/evas/canvas/efl_canvas_vg_shape.eo \
lib/evas/canvas/efl_canvas_vg_gradient.eo \
lib/evas/canvas/efl_canvas_vg_gradient_radial.eo \
lib/evas/canvas/efl_canvas_vg_gradient_linear.eo \
lib/evas/canvas/efl_canvas_image.eo \
lib/evas/canvas/efl_canvas_snapshot.eo \
lib/evas/canvas/efl_canvas_proxy.eo \

1
src/lib/evas/Evas_Common.h
View File

@ -175,7 +175,6 @@ typedef Efl_Canvas_Object Evas_Object;
/* These defines are used in H files generated by Eolian to avoid
* redefinition of types */
#define _EFL_CANVAS_OBJECT_EO_CLASS_TYPE
#define _EFL_VG_EO_CLASS_TYPE
/**
* Type of abstract VG node

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

@ -302,12 +302,12 @@ typedef void (Evas_Canvas3D_Surface_Func)(Evas_Real *out_x,
* @}
*/
#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"
#include "canvas/efl_vg_gradient_linear.eo.h"
#include "canvas/efl_vg_gradient_radial.eo.h"
#include "canvas/efl_canvas_vg_node.eo.h"
#include "canvas/efl_canvas_vg_container.eo.h"
#include "canvas/efl_canvas_vg_shape.eo.h"
#include "canvas/efl_canvas_vg_gradient.eo.h"
#include "canvas/efl_canvas_vg_gradient_linear.eo.h"
#include "canvas/efl_canvas_vg_gradient_radial.eo.h"
#endif /* EFL_BETA_API_SUPPORT */
#ifdef EFL_EO_API_SUPPORT

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

@ -3589,6 +3589,8 @@ EAPI Evas_Object *evas_object_rectangle_add(Evas *e) EINA_WARN_UNUSED_RESULT EIN
#ifdef EFL_BETA_API_SUPPORT
typedef Eo Efl_Canvas_VG_Node;
/**
* Creates a new vector object on the given Evas @p e canvas.
*
@ -3605,7 +3607,7 @@ EAPI Evas_Object *evas_object_rectangle_add(Evas *e) EINA_WARN_UNUSED_RESULT EIN
EAPI Evas_Object *evas_object_vg_add(Evas *e) EINA_WARN_UNUSED_RESULT EINA_ARG_NONNULL(1) EINA_MALLOC;
#include "canvas/efl_canvas_vg.eo.legacy.h"
#include "canvas/efl_vg_container.eo.legacy.h"
#include "canvas/efl_canvas_vg_container.eo.legacy.h"
/**
* Creates a new vector shape object \.
*
@ -3798,7 +3800,7 @@ EAPI void evas_vg_node_raise(Eo *obj);
*/
EAPI void evas_vg_node_lower(Eo *obj);
#include "canvas/efl_vg.eo.legacy.h"
#include "canvas/efl_canvas_vg_node.eo.legacy.h"
/**
*
@ -4241,7 +4243,7 @@ EAPI void evas_vg_shape_stroke_fill_set(Eo *obj, Efl_VG *f);
*/
EAPI Efl_VG* evas_vg_shape_stroke_fill_get(const Eo *obj);
#include "canvas/efl_vg_shape.eo.legacy.h"
#include "canvas/efl_canvas_vg_shape.eo.legacy.h"
/**
*
@ -4285,7 +4287,7 @@ EAPI void evas_vg_gradient_spread_set(Eo *obj, Efl_Gfx_Gradient_Spread s);
*/
EAPI Efl_Gfx_Gradient_Spread evas_vg_gradient_spread_get(Eo *obj);
#include "canvas/efl_vg_gradient.eo.legacy.h"
#include "canvas/efl_canvas_vg_gradient.eo.legacy.h"
/**
* Creates a new linear gradient object \.
@ -4336,7 +4338,7 @@ EAPI void evas_vg_gradient_linear_end_set(Eo *obj, double x, double y);
*/
EAPI void evas_vg_gradient_linear_end_get(Eo *obj, double *x, double *y);
#include "canvas/efl_vg_gradient_linear.eo.legacy.h"
#include "canvas/efl_canvas_vg_gradient_linear.eo.legacy.h"
/**
* Creates a new radial gradient object \.
@ -4404,7 +4406,7 @@ EAPI void evas_vg_gradient_radial_focal_set(Eo *obj, double x, double y);
*/
EAPI void evas_vg_gradient_radial_focal_get(Eo *obj, double *x, double *y);
#include "canvas/efl_vg_gradient_radial.eo.legacy.h"
#include "canvas/efl_canvas_vg_gradient_radial.eo.legacy.h"
#endif

16
src/lib/evas/canvas/efl_canvas_vg.c
View File

@ -107,7 +107,7 @@ _update_vgtree_viewport(Eo *obj, Efl_Canvas_Vg_Data *pd)
eina_matrix3_translate(&m, -pd->viewbox.x, -pd->viewbox.y);
}
efl_vg_transformation_set(pd->root, &m);
efl_canvas_vg_node_transformation_set(pd->root, &m);
}
static void
@ -212,7 +212,7 @@ _efl_canvas_vg_viewbox_set(Eo *obj, Efl_Canvas_Vg_Data *pd, Eina_Rect viewbox)
pd->viewbox = EINA_RECT_EMPTY();
eina_matrix3_identity(&m);
efl_vg_transformation_set(pd->root, &m);
efl_canvas_vg_node_transformation_set(pd->root, &m);
// un register the resize callback
efl_event_callback_del(obj, EFL_GFX_EVENT_RESIZE, _evas_vg_resize, pd);
}
@ -339,7 +339,7 @@ _efl_canvas_vg_efl_object_constructor(Eo *eo_obj, Efl_Canvas_Vg_Data *pd)
obj->type = o_type;
/* root node */
pd->root = efl_add(EFL_VG_CONTAINER_CLASS, NULL);
pd->root = efl_add(EFL_CANVAS_VG_CONTAINER_CLASS, NULL);
eina_array_step_set(&pd->cleanup, sizeof(pd->cleanup), 8);
@ -365,13 +365,13 @@ _evas_vg_render(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Data *vd,
void *engine, void *output, void *context, void *surface, Efl_VG *n,
Eina_Array *clips, Eina_Bool do_async)
{
if (efl_isa(n, EFL_VG_CONTAINER_CLASS))
if (efl_isa(n, EFL_CANVAS_VG_CONTAINER_CLASS))
{
Efl_VG_Container_Data *vc;
Efl_Canvas_VG_Container_Data *vc;
Efl_VG *child;
Eina_List *l;
vc = efl_data_scope_get(n, EFL_VG_CONTAINER_CLASS);
vc = efl_data_scope_get(n, EFL_CANVAS_VG_CONTAINER_CLASS);
EINA_LIST_FOREACH(vc->children, l, child)
_evas_vg_render(obj, vd,
@ -380,9 +380,9 @@ _evas_vg_render(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Data *vd,
}
else
{
Efl_VG_Data *nd;
Efl_Canvas_VG_Node_Data *nd;
nd = efl_data_scope_get(n, EFL_VG_CLASS);
nd = efl_data_scope_get(n, EFL_CANVAS_VG_NODE_CLASS);
obj->layer->evas->engine.func->ector_renderer_draw(engine, output, context, surface, nd->renderer, clips, do_async);

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

@ -65,7 +65,7 @@ class Efl.Canvas.Vg (Efl.Canvas.Object, Efl.File)
It takes the ownership of the root node. ]]
}
values {
root: Efl.VG; [[Root node of the VG canvas.]]
root: Efl.Canvas.VG.Node; [[Root node of the VG canvas.]]
}
}
}

6
src/lib/evas/canvas/efl_vg_container.eo → src/lib/evas/canvas/efl_canvas_vg_container.eo
View File

@ -1,4 +1,4 @@
class Efl.VG.Container (Efl.VG)
class Efl.Canvas.VG.Container (Efl.Canvas.VG.Node)
{
[[Efl vector graphics container class]]
legacy_prefix: evas_vg_container;
@ -8,11 +8,11 @@ class Efl.VG.Container (Efl.VG)
params {
@in name: string; [[Child node name]]
}
return: Efl.VG; [[Child object]]
return: Efl.Canvas.VG.Node; [[Child object]]
}
children_get {
[[Get all children of container]]
return: iterator<Efl.VG> @owned @warn_unused; [[Iterator to children]]
return: iterator<Efl.Canvas.VG.Node> @owned @warn_unused; [[Iterator to children]]
}
}
implements {

2
src/lib/evas/canvas/efl_vg_gradient.eo → src/lib/evas/canvas/efl_canvas_vg_gradient.eo
View File

@ -1,4 +1,4 @@
abstract Efl.VG.Gradient (Efl.VG, Efl.Gfx.Gradient)
abstract Efl.Canvas.VG.Gradient (Efl.Canvas.VG.Node, Efl.Gfx.Gradient)
{
[[Efl vectopr graphics gradient abstract class]]
legacy_prefix: evas_vg_gradient;

2
src/lib/evas/canvas/efl_vg_gradient_linear.eo → src/lib/evas/canvas/efl_canvas_vg_gradient_linear.eo
View File

@ -1,4 +1,4 @@
class Efl.VG.Gradient.Linear (Efl.VG.Gradient, Efl.Gfx.Gradient.Linear)
class Efl.Canvas.VG.Gradient.Linear (Efl.Canvas.VG.Gradient, Efl.Gfx.Gradient.Linear)
{
[[Efl vector graphics gradient linear class]]
legacy_prefix: evas_vg_gradient_linear;

2
src/lib/evas/canvas/efl_vg_gradient_radial.eo → src/lib/evas/canvas/efl_canvas_vg_gradient_radial.eo
View File

@ -1,4 +1,4 @@
class Efl.VG.Gradient.Radial (Efl.VG.Gradient, Efl.Gfx.Gradient.Radial)
class Efl.Canvas.VG.Gradient.Radial (Efl.Canvas.VG.Gradient, Efl.Gfx.Gradient.Radial)
{
[[Efl vector graphics gradient radial class]]
legacy_prefix: evas_vg_gradient_radial;

6
src/lib/evas/canvas/efl_vg.eo → src/lib/evas/canvas/efl_canvas_vg_node.eo
View File

@ -1,9 +1,9 @@
import eina_types;
abstract Efl.VG (Efl.Object, Efl.Gfx, Efl.Gfx.Color, Efl.Gfx.Stack, Efl.Duplicate, Efl.Gfx.Path)
abstract Efl.Canvas.VG.Node (Efl.Object, Efl.Gfx, Efl.Gfx.Color, Efl.Gfx.Stack, Efl.Duplicate, Efl.Gfx.Path)
{
[[Efl vector graphics abstract class]]
eo_prefix: efl_vg;
eo_prefix: efl_canvas_vg_node;
legacy_prefix: evas_vg_node;
methods {
@property transformation {
@ -48,7 +48,7 @@ abstract Efl.VG (Efl.Object, Efl.Gfx, Efl.Gfx.Color, Efl.Gfx.Stack, Efl.Duplicat
get {
}
values {
m: Efl.VG; [[Object mask]]
m: Efl.Canvas.VG.Node; [[Object mask]]
}
}
/* quality {

8
src/lib/evas/canvas/efl_vg_shape.eo → src/lib/evas/canvas/efl_canvas_vg_shape.eo
View File

@ -1,4 +1,4 @@
class Efl.VG.Shape (Efl.VG, Efl.Gfx.Shape)
class Efl.Canvas.VG.Shape (Efl.Canvas.VG.Node, Efl.Gfx.Shape)
{
[[Efl vector graphics shape class]]
legacy_prefix: evas_vg_shape;
@ -10,7 +10,7 @@ class Efl.VG.Shape (Efl.VG, Efl.Gfx.Shape)
get {
}
values {
f: Efl.VG; [[Fill object]]
f: Efl.Canvas.VG.Node; [[Fill object]]
}
}
@property stroke_fill {
@ -20,7 +20,7 @@ class Efl.VG.Shape (Efl.VG, Efl.Gfx.Shape)
get {
}
values {
f: Efl.VG; [[Stroke fill object]]
f: Efl.Canvas.VG.Node; [[Stroke fill object]]
}
}
@property stroke_marker {
@ -30,7 +30,7 @@ class Efl.VG.Shape (Efl.VG, Efl.Gfx.Shape)
get {
}
values {
m: Efl.VG; [[Stroke marker object]]
m: Efl.Canvas.VG.Node; [[Stroke marker object]]
}
}
}

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

@ -3,19 +3,19 @@
#include "evas_vg_private.h"
#define MY_CLASS EFL_VG_CONTAINER_CLASS
#define MY_CLASS EFL_CANVAS_VG_CONTAINER_CLASS
static void
_efl_vg_container_render_pre(Eo *obj EINA_UNUSED,
_efl_canvas_vg_container_render_pre(Eo *obj EINA_UNUSED,
Eina_Matrix3 *parent,
Ector_Surface *s,
void *data,
Efl_VG_Data *nd)
Efl_Canvas_VG_Node_Data *nd)
{
Efl_VG_Container_Data *pd = data;
Efl_Canvas_VG_Container_Data *pd = data;
Eina_List *l;
Eo *child;
Efl_VG_Data *child_nd;
Efl_Canvas_VG_Node_Data *child_nd;
Efl_Gfx_Change_Flag flag;
if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return ;
@ -23,13 +23,13 @@ _efl_vg_container_render_pre(Eo *obj EINA_UNUSED,
flag = nd->flags;
nd->flags = EFL_GFX_CHANGE_FLAG_NONE;
EFL_VG_COMPUTE_MATRIX(current, parent, nd);
EFL_CANVAS_VG_COMPUTE_MATRIX(current, parent, nd);
EINA_LIST_FOREACH(pd->children, l, child)
{
if (flag & EFL_GFX_CHANGE_FLAG_MATRIX)
{
child_nd = efl_data_scope_get(child, EFL_VG_CLASS);
child_nd = efl_data_scope_get(child, EFL_CANVAS_VG_NODE_CLASS);
child_nd->flags |= EFL_GFX_CHANGE_FLAG_MATRIX;
}
_evas_vg_render_pre(child, s, current);
@ -37,17 +37,17 @@ _efl_vg_container_render_pre(Eo *obj EINA_UNUSED,
}
static Eo *
_efl_vg_container_efl_object_constructor(Eo *obj,
Efl_VG_Container_Data *pd)
_efl_canvas_vg_container_efl_object_constructor(Eo *obj,
Efl_Canvas_VG_Container_Data *pd)
{
Efl_VG_Data *nd;
Efl_Canvas_VG_Node_Data *nd;
pd->names = eina_hash_stringshared_new(NULL);
obj = efl_constructor(efl_super(obj, MY_CLASS));
nd = efl_data_scope_get(obj, EFL_VG_CLASS);
nd->render_pre = _efl_vg_container_render_pre;
nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
nd->render_pre = _efl_canvas_vg_container_render_pre;
nd->data = pd;
nd->flags = EFL_GFX_CHANGE_FLAG_ALL;
@ -55,8 +55,8 @@ _efl_vg_container_efl_object_constructor(Eo *obj,
}
static void
_efl_vg_container_efl_object_destructor(Eo *obj,
Efl_VG_Container_Data *pd EINA_UNUSED)
_efl_canvas_vg_container_efl_object_destructor(Eo *obj,
Efl_Canvas_VG_Container_Data *pd EINA_UNUSED)
{
efl_destructor(efl_super(obj, MY_CLASS));
@ -65,8 +65,8 @@ _efl_vg_container_efl_object_destructor(Eo *obj,
}
static void
_efl_vg_container_efl_gfx_path_bounds_get(Eo *obj EINA_UNUSED,
Efl_VG_Container_Data *pd,
_efl_canvas_vg_container_efl_gfx_path_bounds_get(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Container_Data *pd,
Eina_Rect *r)
{
Eina_Rect s;
@ -92,7 +92,7 @@ _efl_vg_container_efl_gfx_path_bounds_get(Eo *obj EINA_UNUSED,
}
static Efl_VG *
_efl_vg_container_child_get(Eo *obj EINA_UNUSED, Efl_VG_Container_Data *pd, const char *name)
_efl_canvas_vg_container_child_get(Eo *obj EINA_UNUSED, Efl_Canvas_VG_Container_Data *pd, const char *name)
{
const char *tmp = eina_stringshare_add(name);
Efl_VG *r;
@ -104,14 +104,14 @@ _efl_vg_container_child_get(Eo *obj EINA_UNUSED, Efl_VG_Container_Data *pd, cons
}
static Eina_Iterator *
_efl_vg_container_children_get(Eo *obj EINA_UNUSED, Efl_VG_Container_Data *pd)
_efl_canvas_vg_container_children_get(Eo *obj EINA_UNUSED, Efl_Canvas_VG_Container_Data *pd)
{
return eina_list_iterator_new(pd->children);
}
static Eina_Bool
_efl_vg_container_efl_gfx_path_interpolate(Eo *obj,
Efl_VG_Container_Data *pd,
_efl_canvas_vg_container_efl_gfx_path_interpolate(Eo *obj,
Efl_Canvas_VG_Container_Data *pd,
const Efl_VG *from, const Efl_VG *to,
double pos_map)
{
@ -121,16 +121,16 @@ _efl_vg_container_efl_gfx_path_interpolate(Eo *obj,
Eo *from_child, *to_child, *child;
//1. check if both the object are containers
if (!(efl_isa(from, EFL_VG_CONTAINER_CLASS) &&
efl_isa(to, EFL_VG_CONTAINER_CLASS)))
if (!(efl_isa(from, EFL_CANVAS_VG_CONTAINER_CLASS) &&
efl_isa(to, EFL_CANVAS_VG_CONTAINER_CLASS)))
return EINA_FALSE;
r = efl_gfx_path_interpolate(efl_super(obj, EFL_VG_CONTAINER_CLASS), from, to, pos_map);
r = efl_gfx_path_interpolate(efl_super(obj, EFL_CANVAS_VG_CONTAINER_CLASS), from, to, pos_map);
if (!r) return EINA_FALSE;
from_it = efl_vg_container_children_get((Efl_VG *)from);
to_it = efl_vg_container_children_get((Efl_VG *)to);
from_it = efl_canvas_vg_container_children_get((Efl_VG *)from);
to_it = efl_canvas_vg_container_children_get((Efl_VG *)to);
EINA_LIST_FOREACH (pd->children, l, child)
{
res &= eina_iterator_next(from_it, (void **)&from_child);
@ -152,7 +152,7 @@ _efl_vg_container_efl_gfx_path_interpolate(Eo *obj,
}
EOLIAN static Efl_VG *
_efl_vg_container_efl_duplicate_duplicate(const Eo *obj, Efl_VG_Container_Data *pd)
_efl_canvas_vg_container_efl_duplicate_duplicate(const Eo *obj, Efl_Canvas_VG_Container_Data *pd)
{
Eina_List *l;
Efl_VG *child;
@ -170,7 +170,7 @@ _efl_vg_container_efl_duplicate_duplicate(const Eo *obj, Efl_VG_Container_Data *
EAPI Efl_VG*
evas_vg_container_add(Efl_VG *parent)
{
return efl_add(EFL_VG_CONTAINER_CLASS, parent);
return efl_add(EFL_CANVAS_VG_CONTAINER_CLASS, parent);
}
#include "efl_vg_container.eo.c"
#include "efl_canvas_vg_container.eo.c"

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

@ -5,11 +5,11 @@
#include <strings.h>
#define MY_CLASS EFL_VG_GRADIENT_CLASS
#define MY_CLASS EFL_CANVAS_VG_GRADIENT_CLASS
static void
_efl_vg_gradient_efl_gfx_gradient_stop_set(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Data *pd,
_efl_canvas_vg_gradient_efl_gfx_gradient_stop_set(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Data *pd,
const Efl_Gfx_Gradient_Stop *colors,
unsigned int length)
{
@ -23,12 +23,12 @@ _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_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static void
_efl_vg_gradient_efl_gfx_gradient_stop_get(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Data *pd,
_efl_canvas_vg_gradient_efl_gfx_gradient_stop_get(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Data *pd,
const Efl_Gfx_Gradient_Stop **colors,
unsigned int *length)
{
@ -37,38 +37,38 @@ _efl_vg_gradient_efl_gfx_gradient_stop_get(Eo *obj EINA_UNUSED,
}
static void
_efl_vg_gradient_efl_gfx_gradient_spread_set(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Data *pd,
_efl_canvas_vg_gradient_efl_gfx_gradient_spread_set(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Data *pd,
Efl_Gfx_Gradient_Spread s)
{
pd->s = s;
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static Efl_Gfx_Gradient_Spread
_efl_vg_gradient_efl_gfx_gradient_spread_get(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Data *pd)
_efl_canvas_vg_gradient_efl_gfx_gradient_spread_get(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Data *pd)
{
return pd->s;
}
static Eina_Bool
_efl_vg_gradient_efl_gfx_path_interpolate(Eo *obj,
Efl_VG_Gradient_Data *pd,
_efl_canvas_vg_gradient_efl_gfx_path_interpolate(Eo *obj,
Efl_Canvas_VG_Gradient_Data *pd,
const Efl_VG *from, const Efl_VG *to,
double pos_map)
{
Efl_VG_Gradient_Data *fromd, *tod;
Efl_Canvas_VG_Gradient_Data *fromd, *tod;
Efl_Gfx_Gradient_Stop *colors;
unsigned int i;
double from_map;
Eina_Bool r;
r = efl_gfx_path_interpolate(efl_super(obj, EFL_VG_GRADIENT_CLASS), from, to, pos_map);
r = efl_gfx_path_interpolate(efl_super(obj, EFL_CANVAS_VG_GRADIENT_CLASS), from, to, pos_map);
fromd = efl_data_scope_get(from, EFL_VG_GRADIENT_CLASS);
tod = efl_data_scope_get(to, EFL_VG_GRADIENT_CLASS);
fromd = efl_data_scope_get(from, EFL_CANVAS_VG_GRADIENT_CLASS);
tod = efl_data_scope_get(to, EFL_CANVAS_VG_GRADIENT_CLASS);
from_map = 1.0 - pos_map;
if (!r) return EINA_FALSE;
@ -97,7 +97,7 @@ _efl_vg_gradient_efl_gfx_path_interpolate(Eo *obj,
}
EOLIAN static Efl_VG *
_efl_vg_gradient_efl_duplicate_duplicate(const Eo *obj, Efl_VG_Gradient_Data *pd)
_efl_canvas_vg_gradient_efl_duplicate_duplicate(const Eo *obj, Efl_Canvas_VG_Gradient_Data *pd)
{
Efl_VG *cn = NULL;
@ -132,4 +132,4 @@ evas_vg_gradient_spread_get(Eo *obj)
return efl_gfx_gradient_spread_get(obj);
}
#include "efl_vg_gradient.eo.c"
#include "efl_canvas_vg_gradient.eo.c"

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

@ -5,10 +5,10 @@
#include <strings.h>
#define MY_CLASS EFL_VG_GRADIENT_LINEAR_CLASS
#define MY_CLASS EFL_CANVAS_VG_GRADIENT_LINEAR_CLASS
typedef struct _Efl_VG_Gradient_Linear_Data Efl_VG_Gradient_Linear_Data;
struct _Efl_VG_Gradient_Linear_Data
typedef struct _Efl_Canvas_VG_Gradient_Linear_Data Efl_Canvas_VG_Gradient_Linear_Data;
struct _Efl_Canvas_VG_Gradient_Linear_Data
{
struct {
double x, y;
@ -16,19 +16,19 @@ struct _Efl_VG_Gradient_Linear_Data
};
static void
_efl_vg_gradient_linear_efl_gfx_gradient_linear_start_set(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Linear_Data *pd,
_efl_canvas_vg_gradient_linear_efl_gfx_gradient_linear_start_set(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Linear_Data *pd,
double x, double y)
{
pd->start.x = x;
pd->start.y = y;
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static void
_efl_vg_gradient_linear_efl_gfx_gradient_linear_start_get(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Linear_Data *pd,
_efl_canvas_vg_gradient_linear_efl_gfx_gradient_linear_start_get(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Linear_Data *pd,
double *x, double *y)
{
if (x) *x = pd->start.x;
@ -36,19 +36,19 @@ _efl_vg_gradient_linear_efl_gfx_gradient_linear_start_get(Eo *obj EINA_UNUSED,
}
static void
_efl_vg_gradient_linear_efl_gfx_gradient_linear_end_set(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Linear_Data *pd,
_efl_canvas_vg_gradient_linear_efl_gfx_gradient_linear_end_set(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Linear_Data *pd,
double x, double y)
{
pd->end.x = x;
pd->end.y = y;
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static void
_efl_vg_gradient_linear_efl_gfx_gradient_linear_end_get(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Linear_Data *pd,
_efl_canvas_vg_gradient_linear_efl_gfx_gradient_linear_end_get(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Linear_Data *pd,
double *x, double *y)
{
if (x) *x = pd->end.x;
@ -56,21 +56,21 @@ _efl_vg_gradient_linear_efl_gfx_gradient_linear_end_get(Eo *obj EINA_UNUSED,
}
static void
_efl_vg_gradient_linear_render_pre(Eo *obj,
_efl_canvas_vg_gradient_linear_render_pre(Eo *obj,
Eina_Matrix3 *parent,
Ector_Surface *s,
void *data,
Efl_VG_Data *nd)
Efl_Canvas_VG_Node_Data *nd)
{
Efl_VG_Gradient_Linear_Data *pd = data;
Efl_VG_Gradient_Data *gd;
Efl_Canvas_VG_Gradient_Linear_Data *pd = data;
Efl_Canvas_VG_Gradient_Data *gd;
if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return ;
nd->flags = EFL_GFX_CHANGE_FLAG_NONE;
gd = efl_data_scope_get(obj, EFL_VG_GRADIENT_CLASS);
EFL_VG_COMPUTE_MATRIX(current, parent, nd);
gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
EFL_CANVAS_VG_COMPUTE_MATRIX(current, parent, nd);
if (!nd->renderer)
{
@ -91,53 +91,53 @@ _efl_vg_gradient_linear_render_pre(Eo *obj,
}
static Eo *
_efl_vg_gradient_linear_efl_object_constructor(Eo *obj,
Efl_VG_Gradient_Linear_Data *pd)
_efl_canvas_vg_gradient_linear_efl_object_constructor(Eo *obj,
Efl_Canvas_VG_Gradient_Linear_Data *pd)
{
Efl_VG_Data *nd;
Efl_Canvas_VG_Node_Data *nd;
obj = efl_constructor(efl_super(obj, MY_CLASS));
nd = efl_data_scope_get(obj, EFL_VG_CLASS);
nd->render_pre = _efl_vg_gradient_linear_render_pre;
nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
nd->render_pre = _efl_canvas_vg_gradient_linear_render_pre;
nd->data = pd;
return obj;
}
static void
_efl_vg_gradient_linear_efl_object_destructor(Eo *obj, Efl_VG_Gradient_Linear_Data *pd EINA_UNUSED)
_efl_canvas_vg_gradient_linear_efl_object_destructor(Eo *obj, Efl_Canvas_VG_Gradient_Linear_Data *pd EINA_UNUSED)
{
efl_destructor(efl_super(obj, MY_CLASS));
}
static void
_efl_vg_gradient_linear_efl_gfx_path_bounds_get(Eo *obj, Efl_VG_Gradient_Linear_Data *pd, Eina_Rect *r)
_efl_canvas_vg_gradient_linear_efl_gfx_path_bounds_get(Eo *obj, Efl_Canvas_VG_Gradient_Linear_Data *pd, Eina_Rect *r)
{
Efl_VG_Data *nd;
Efl_Canvas_VG_Node_Data *nd;
nd = efl_data_scope_get(obj, EFL_VG_CLASS);
nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_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_gfx_path_interpolate(Eo *obj,
Efl_VG_Gradient_Linear_Data *pd,
_efl_canvas_vg_gradient_linear_efl_gfx_path_interpolate(Eo *obj,
Efl_Canvas_VG_Gradient_Linear_Data *pd,
const Efl_VG *from, const Efl_VG *to,
double pos_map)
{
Efl_VG_Gradient_Linear_Data *fromd, *tod;
Efl_Canvas_VG_Gradient_Linear_Data *fromd, *tod;
double from_map;
Eina_Bool r;
r = efl_gfx_path_interpolate(efl_super(obj, EFL_VG_GRADIENT_LINEAR_CLASS), from, to, pos_map);
r = efl_gfx_path_interpolate(efl_super(obj, EFL_CANVAS_VG_GRADIENT_LINEAR_CLASS), from, to, pos_map);
if (!r) return EINA_FALSE;
fromd = efl_data_scope_get(from, EFL_VG_GRADIENT_LINEAR_CLASS);
tod = efl_data_scope_get(to, EFL_VG_GRADIENT_LINEAR_CLASS);
fromd = efl_data_scope_get(from, EFL_CANVAS_VG_GRADIENT_LINEAR_CLASS);
tod = efl_data_scope_get(to, EFL_CANVAS_VG_GRADIENT_LINEAR_CLASS);
from_map = 1.0 - pos_map;
#define INTP(Pd, From, To, Member, From_Map, Pos_Map) \
@ -154,7 +154,7 @@ _efl_vg_gradient_linear_efl_gfx_path_interpolate(Eo *obj,
}
EOLIAN static Efl_VG *
_efl_vg_gradient_linear_efl_duplicate_duplicate(const Eo *obj, Efl_VG_Gradient_Linear_Data *pd)
_efl_canvas_vg_gradient_linear_efl_duplicate_duplicate(const Eo *obj, Efl_Canvas_VG_Gradient_Linear_Data *pd)
{
Efl_VG *cn = NULL;
@ -191,7 +191,7 @@ evas_vg_gradient_linear_end_get(Eo *obj, double *x, double *y)
EAPI Efl_VG*
evas_vg_gradient_linear_add(Efl_VG *parent)
{
return efl_add(EFL_VG_GRADIENT_LINEAR_CLASS, parent);
return efl_add(EFL_CANVAS_VG_GRADIENT_LINEAR_CLASS, parent);
}
#include "efl_vg_gradient_linear.eo.c"
#include "efl_canvas_vg_gradient_linear.eo.c"

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

@ -3,10 +3,10 @@
#include "evas_vg_private.h"
#define MY_CLASS EFL_VG_GRADIENT_RADIAL_CLASS
#define MY_CLASS EFL_CANVAS_VG_GRADIENT_RADIAL_CLASS
typedef struct _Efl_VG_Gradient_Radial_Data Efl_VG_Gradient_Radial_Data;
struct _Efl_VG_Gradient_Radial_Data
typedef struct _Efl_Canvas_VG_Gradient_Radial_Data Efl_Canvas_VG_Gradient_Radial_Data;
struct _Efl_Canvas_VG_Gradient_Radial_Data
{
struct {
double x, y;
@ -15,19 +15,19 @@ struct _Efl_VG_Gradient_Radial_Data
};
static void
_efl_vg_gradient_radial_efl_gfx_gradient_radial_center_set(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Radial_Data *pd,
_efl_canvas_vg_gradient_radial_efl_gfx_gradient_radial_center_set(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Radial_Data *pd,
double x, double y)
{
pd->center.x = x;
pd->center.y = y;
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static void
_efl_vg_gradient_radial_efl_gfx_gradient_radial_center_get(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Radial_Data *pd,
_efl_canvas_vg_gradient_radial_efl_gfx_gradient_radial_center_get(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Radial_Data *pd,
double *x, double *y)
{
if (x) *x = pd->center.x;
@ -35,36 +35,36 @@ _efl_vg_gradient_radial_efl_gfx_gradient_radial_center_get(Eo *obj EINA_UNUSED,
}
static void
_efl_vg_gradient_radial_efl_gfx_gradient_radial_radius_set(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Radial_Data *pd,
_efl_canvas_vg_gradient_radial_efl_gfx_gradient_radial_radius_set(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Radial_Data *pd,
double r)
{
pd->radius = r;
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static double
_efl_vg_gradient_radial_efl_gfx_gradient_radial_radius_get(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Radial_Data *pd)
_efl_canvas_vg_gradient_radial_efl_gfx_gradient_radial_radius_get(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Radial_Data *pd)
{
return pd->radius;
}
static void
_efl_vg_gradient_radial_efl_gfx_gradient_radial_focal_set(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Radial_Data *pd,
_efl_canvas_vg_gradient_radial_efl_gfx_gradient_radial_focal_set(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Radial_Data *pd,
double x, double y)
{
pd->focal.x = x;
pd->focal.y = y;
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static void
_efl_vg_gradient_radial_efl_gfx_gradient_radial_focal_get(Eo *obj EINA_UNUSED,
Efl_VG_Gradient_Radial_Data *pd,
_efl_canvas_vg_gradient_radial_efl_gfx_gradient_radial_focal_get(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Gradient_Radial_Data *pd,
double *x, double *y)
{
if (x) *x = pd->focal.x;
@ -72,21 +72,21 @@ _efl_vg_gradient_radial_efl_gfx_gradient_radial_focal_get(Eo *obj EINA_UNUSED,
}
static void
_efl_vg_gradient_radial_render_pre(Eo *obj,
_efl_canvas_vg_gradient_radial_render_pre(Eo *obj,
Eina_Matrix3 *parent,
Ector_Surface *s,
void *data,
Efl_VG_Data *nd)
Efl_Canvas_VG_Node_Data *nd)
{
Efl_VG_Gradient_Radial_Data *pd = data;
Efl_VG_Gradient_Data *gd;
Efl_Canvas_VG_Gradient_Radial_Data *pd = data;
Efl_Canvas_VG_Gradient_Data *gd;
if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return ;
nd->flags = EFL_GFX_CHANGE_FLAG_NONE;
gd = efl_data_scope_get(obj, EFL_VG_GRADIENT_CLASS);
EFL_VG_COMPUTE_MATRIX(current, parent, nd);
gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
EFL_CANVAS_VG_COMPUTE_MATRIX(current, parent, nd);
if (!nd->renderer)
{
@ -108,32 +108,32 @@ _efl_vg_gradient_radial_render_pre(Eo *obj,
}
static Eo *
_efl_vg_gradient_radial_efl_object_constructor(Eo *obj, Efl_VG_Gradient_Radial_Data *pd)
_efl_canvas_vg_gradient_radial_efl_object_constructor(Eo *obj, Efl_Canvas_VG_Gradient_Radial_Data *pd)
{
Efl_VG_Data *nd;
Efl_Canvas_VG_Node_Data *nd;
obj = efl_constructor(efl_super(obj, MY_CLASS));
nd = efl_data_scope_get(obj, EFL_VG_CLASS);
nd->render_pre = _efl_vg_gradient_radial_render_pre;
nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
nd->render_pre = _efl_canvas_vg_gradient_radial_render_pre;
nd->data = pd;
return obj;
}
static void
_efl_vg_gradient_radial_efl_object_destructor(Eo *obj,
Efl_VG_Gradient_Radial_Data *pd EINA_UNUSED)
_efl_canvas_vg_gradient_radial_efl_object_destructor(Eo *obj,
Efl_Canvas_VG_Gradient_Radial_Data *pd EINA_UNUSED)
{
efl_destructor(efl_super(obj, MY_CLASS));
}
static void
_efl_vg_gradient_radial_efl_gfx_path_bounds_get(Eo *obj, Efl_VG_Gradient_Radial_Data *pd, Eina_Rect *r)
_efl_canvas_vg_gradient_radial_efl_gfx_path_bounds_get(Eo *obj, Efl_Canvas_VG_Gradient_Radial_Data *pd, Eina_Rect *r)
{
Efl_VG_Data *nd;
Efl_Canvas_VG_Node_Data *nd;
nd = efl_data_scope_get(obj, EFL_VG_CLASS);
nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
EINA_RECTANGLE_SET(r,
nd->x + pd->center.x - pd->radius,
nd->y + pd->center.y - pd->radius,
@ -141,21 +141,21 @@ _efl_vg_gradient_radial_efl_gfx_path_bounds_get(Eo *obj, Efl_VG_Gradient_Radial_
}
static Eina_Bool
_efl_vg_gradient_radial_efl_gfx_path_interpolate(Eo *obj,
Efl_VG_Gradient_Radial_Data *pd,
_efl_canvas_vg_gradient_radial_efl_gfx_path_interpolate(Eo *obj,
Efl_Canvas_VG_Gradient_Radial_Data *pd,
const Efl_VG *from, const Efl_VG *to,
double pos_map)
{
Efl_VG_Gradient_Radial_Data *fromd, *tod;
Efl_Canvas_VG_Gradient_Radial_Data *fromd, *tod;
double from_map;
Eina_Bool r;
r = efl_gfx_path_interpolate(efl_super(obj, EFL_VG_GRADIENT_RADIAL_CLASS), from, to, pos_map);
r = efl_gfx_path_interpolate(efl_super(obj, EFL_CANVAS_VG_GRADIENT_RADIAL_CLASS), from, to, pos_map);
if (!r) return EINA_FALSE;
fromd = efl_data_scope_get(from, EFL_VG_GRADIENT_RADIAL_CLASS);
tod = efl_data_scope_get(to, EFL_VG_GRADIENT_RADIAL_CLASS);
fromd = efl_data_scope_get(from, EFL_CANVAS_VG_GRADIENT_RADIAL_CLASS);
tod = efl_data_scope_get(to, EFL_CANVAS_VG_GRADIENT_RADIAL_CLASS);
from_map = 1.0 - pos_map;
#define INTP(Pd, From, To, Member, From_Map, Pos_Map) \
@ -174,7 +174,7 @@ _efl_vg_gradient_radial_efl_gfx_path_interpolate(Eo *obj,
EOLIAN static Efl_VG *
_efl_vg_gradient_radial_efl_duplicate_duplicate(const Eo *obj, Efl_VG_Gradient_Radial_Data *pd)
_efl_canvas_vg_gradient_radial_efl_duplicate_duplicate(const Eo *obj, Efl_Canvas_VG_Gradient_Radial_Data *pd)
{
Efl_VG *cn = NULL;
@ -225,7 +225,7 @@ evas_vg_gradient_radial_focal_get(Eo *obj, double *x, double *y)
EAPI Efl_VG*
evas_vg_gradient_radial_add(Efl_VG *parent)
{
return efl_add(EFL_VG_GRADIENT_RADIAL_CLASS, parent);
return efl_add(EFL_CANVAS_VG_GRADIENT_RADIAL_CLASS, parent);
}
#include "efl_vg_gradient_radial.eo.c"
#include "efl_canvas_vg_gradient_radial.eo.c"

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

@ -6,9 +6,9 @@
#include <string.h>
#include <math.h>
#define MY_CLASS EFL_VG_CLASS
#define MY_CLASS EFL_CANVAS_VG_NODE_CLASS
static const Efl_VG_Interpolation interpolation_identity = {
static const Efl_Canvas_VG_Interpolation interpolation_identity = {
{ 0, 0, 0, 1 },
{ 0, 0, 0, 1 },
{ 0, 0, 0 },
@ -17,9 +17,9 @@ static const Efl_VG_Interpolation interpolation_identity = {
};
static void
_efl_vg_property_changed(void *data, const Efl_Event *event EINA_UNUSED)
_efl_canvas_vg_node_property_changed(void *data, const Efl_Event *event EINA_UNUSED)
{
Efl_VG_Data *pd = data;
Efl_Canvas_VG_Node_Data *pd = data;
Eo *parent;
if (!pd->flags) pd->flags = EFL_GFX_CHANGE_FLAG_ALL;
@ -29,8 +29,8 @@ _efl_vg_property_changed(void *data, const Efl_Event *event EINA_UNUSED)
}
static void
_efl_vg_transformation_set(Eo *obj,
Efl_VG_Data *pd,
_efl_canvas_vg_node_transformation_set(Eo *obj,
Efl_Canvas_VG_Node_Data *pd,
const Eina_Matrix3 *m)
{
if (pd->intp)
@ -55,29 +55,29 @@ _efl_vg_transformation_set(Eo *obj,
}
pd->flags |= EFL_GFX_CHANGE_FLAG_MATRIX;
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
const Eina_Matrix3 *
_efl_vg_transformation_get(Eo *obj EINA_UNUSED, Efl_VG_Data *pd)
_efl_canvas_vg_node_transformation_get(Eo *obj EINA_UNUSED, Efl_Canvas_VG_Node_Data *pd)
{
return pd->m;
}
static void
_efl_vg_origin_set(Eo *obj,
Efl_VG_Data *pd,
_efl_canvas_vg_node_origin_set(Eo *obj,
Efl_Canvas_VG_Node_Data *pd,
double x, double y)
{
pd->x = x;
pd->y = y;
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static void
_efl_vg_origin_get(Eo *obj EINA_UNUSED,
Efl_VG_Data *pd,
_efl_canvas_vg_node_origin_get(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Node_Data *pd,
double *x, double *y)
{
if (x) *x = pd->x;
@ -85,41 +85,41 @@ _efl_vg_origin_get(Eo *obj EINA_UNUSED,
}
static void
_efl_vg_efl_gfx_position_set(Eo *obj EINA_UNUSED, Efl_VG_Data *pd, Eina_Position2D pos)
_efl_canvas_vg_node_efl_gfx_position_set(Eo *obj EINA_UNUSED, Efl_Canvas_VG_Node_Data *pd, Eina_Position2D pos)
{
pd->x = (double) pos.x;
pd->y = (double) pos.y;
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static Eina_Position2D
_efl_vg_efl_gfx_position_get(Eo *obj EINA_UNUSED, Efl_VG_Data *pd)
_efl_canvas_vg_node_efl_gfx_position_get(Eo *obj EINA_UNUSED, Efl_Canvas_VG_Node_Data *pd)
{
// NOTE: This casts double to int!
return EINA_POSITION2D(pd->x, pd->y);
}
static void
_efl_vg_efl_gfx_visible_set(Eo *obj EINA_UNUSED,
Efl_VG_Data *pd, Eina_Bool v)
_efl_canvas_vg_node_efl_gfx_visible_set(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Node_Data *pd, Eina_Bool v)
{
pd->visibility = v;
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static Eina_Bool
_efl_vg_efl_gfx_visible_get(Eo *obj EINA_UNUSED,
Efl_VG_Data *pd)
_efl_canvas_vg_node_efl_gfx_visible_get(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Node_Data *pd)
{
return pd->visibility;
}
static void
_efl_vg_efl_gfx_color_color_set(Eo *obj EINA_UNUSED,
Efl_VG_Data *pd,
_efl_canvas_vg_node_efl_gfx_color_color_set(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Node_Data *pd,
int r, int g, int b, int a)
{
if (r > 255) r = 255;
@ -151,12 +151,12 @@ _efl_vg_efl_gfx_color_color_set(Eo *obj EINA_UNUSED,
pd->b = b;
pd->a = a;
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static void
_efl_vg_efl_gfx_color_color_get(Eo *obj EINA_UNUSED,
Efl_VG_Data *pd,
_efl_canvas_vg_node_efl_gfx_color_color_get(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Node_Data *pd,
int *r, int *g, int *b, int *a)
{
if (r) *r = pd->r;
@ -166,8 +166,8 @@ _efl_vg_efl_gfx_color_color_get(Eo *obj EINA_UNUSED,
}
static void
_efl_vg_mask_set(Eo *obj EINA_UNUSED,
Efl_VG_Data *pd,
_efl_canvas_vg_node_mask_set(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Node_Data *pd,
Efl_VG *r)
{
Efl_VG *tmp = pd->mask;
@ -175,17 +175,17 @@ _efl_vg_mask_set(Eo *obj EINA_UNUSED,
pd->mask = efl_ref(r);
efl_unref(tmp);
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static Efl_VG*
_efl_vg_mask_get(Eo *obj EINA_UNUSED, Efl_VG_Data *pd)
_efl_canvas_vg_node_mask_get(Eo *obj EINA_UNUSED, Efl_Canvas_VG_Node_Data *pd)
{
return pd->mask;
}
static Eina_Size2D
_efl_vg_efl_gfx_size_get(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
_efl_canvas_vg_node_efl_gfx_size_get(Eo *obj, Efl_Canvas_VG_Node_Data *pd EINA_UNUSED)
{
Eina_Rect r;
@ -194,7 +194,7 @@ _efl_vg_efl_gfx_size_get(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
}
EOLIAN static Eina_Rect
_efl_vg_efl_gfx_geometry_get(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
_efl_canvas_vg_node_efl_gfx_geometry_get(Eo *obj, Efl_Canvas_VG_Node_Data *pd EINA_UNUSED)
{
Eina_Rect r;
r.pos = efl_gfx_position_get(obj);
@ -204,19 +204,19 @@ _efl_vg_efl_gfx_geometry_get(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
// Parent should be a container otherwise dismissing the stacking operation
static Eina_Bool
_efl_vg_parent_checked_get(Eo *obj,
_efl_canvas_vg_node_parent_checked_get(Eo *obj,
Eo **parent,
Efl_VG_Container_Data **cd)
Efl_Canvas_VG_Container_Data **cd)
{
*cd = NULL;
*parent = efl_parent_get(obj);
if (efl_isa(*parent, EFL_VG_CONTAINER_CLASS))
if (efl_isa(*parent, EFL_CANVAS_VG_CONTAINER_CLASS))
{
*cd = efl_data_scope_get(*parent, EFL_VG_CONTAINER_CLASS);
*cd = efl_data_scope_get(*parent, EFL_CANVAS_VG_CONTAINER_CLASS);
if (!*cd)
{
ERR("Can't get EFL_VG_CONTAINER_CLASS data.");
ERR("Can't get EFL_CANVAS_VG_CONTAINER_CLASS data.");
goto on_error;
}
}
@ -239,20 +239,20 @@ _efl_vg_parent_checked_get(Eo *obj,
}
static Eo *
_efl_vg_efl_object_constructor(Eo *obj,
Efl_VG_Data *pd)
_efl_canvas_vg_node_efl_object_constructor(Eo *obj,
Efl_Canvas_VG_Node_Data *pd)
{
Efl_VG_Container_Data *cd = NULL;
Efl_Canvas_VG_Container_Data *cd = NULL;
Eo *parent;
obj = efl_constructor(efl_super(obj, MY_CLASS));
if (!_efl_vg_parent_checked_get(obj, &parent, &cd)) {
if (!_efl_canvas_vg_node_parent_checked_get(obj, &parent, &cd)) {
ERR("Failed");
return NULL;
}
efl_event_callback_add(obj, EFL_GFX_PATH_EVENT_CHANGED, _efl_vg_property_changed, pd);
efl_event_callback_add(obj, EFL_GFX_PATH_EVENT_CHANGED, _efl_canvas_vg_node_property_changed, pd);
pd->flags = EFL_GFX_CHANGE_FLAG_ALL;
pd->changed = EINA_TRUE;
@ -260,7 +260,7 @@ _efl_vg_efl_object_constructor(Eo *obj,
}
static void
_efl_vg_efl_object_destructor(Eo *obj, Efl_VG_Data *pd)
_efl_canvas_vg_node_efl_object_destructor(Eo *obj, Efl_Canvas_VG_Node_Data *pd)
{
if (pd->m)
{
@ -283,7 +283,7 @@ _efl_vg_efl_object_destructor(Eo *obj, Efl_VG_Data *pd)
}
static void
_efl_vg_name_insert(Eo *obj, Efl_VG_Container_Data *cd)
_efl_canvas_vg_node_name_insert(Eo *obj, Efl_Canvas_VG_Container_Data *cd)
{
Eo *set;
const char *name = efl_name_get(efl_super(obj, MY_CLASS));
@ -304,37 +304,37 @@ _efl_vg_name_insert(Eo *obj, Efl_VG_Container_Data *cd)
}
static void
_efl_vg_efl_object_name_set(Eo *obj, Efl_VG_Data *pd EINA_UNUSED, const char *name)
_efl_canvas_vg_node_efl_object_name_set(Eo *obj, Efl_Canvas_VG_Node_Data *pd EINA_UNUSED, const char *name)
{
Efl_VG_Container_Data *cd = NULL;
Efl_Canvas_VG_Container_Data *cd = NULL;
Eo *parent = NULL;
const char *pname = efl_name_get(obj);
if (_efl_vg_parent_checked_get(obj, &parent, &cd))
if (_efl_canvas_vg_node_parent_checked_get(obj, &parent, &cd))
{
if (pname) eina_hash_del(cd->names, pname, obj);
}
efl_name_set(efl_super(obj, MY_CLASS), name);
if (cd) _efl_vg_name_insert(obj, cd);
if (cd) _efl_canvas_vg_node_name_insert(obj, cd);
}
static void
_efl_vg_efl_object_parent_set(Eo *obj,
Efl_VG_Data *pd EINA_UNUSED,
_efl_canvas_vg_node_efl_object_parent_set(Eo *obj,
Efl_Canvas_VG_Node_Data *pd EINA_UNUSED,
Eo *parent)
{
Efl_VG_Container_Data *cd = NULL;
Efl_VG_Container_Data *old_cd = NULL;
Efl_Canvas_VG_Container_Data *cd = NULL;
Efl_Canvas_VG_Container_Data *old_cd = NULL;
Eo *old_parent;
if (efl_isa(parent, EFL_VG_CONTAINER_CLASS))
if (efl_isa(parent, EFL_CANVAS_VG_CONTAINER_CLASS))
{
cd = efl_data_scope_get(parent, EFL_VG_CONTAINER_CLASS);
cd = efl_data_scope_get(parent, EFL_CANVAS_VG_CONTAINER_CLASS);
if (!cd)
{
ERR("Can't get EFL_VG_CONTAINER_CLASS data from %p.", parent);
ERR("Can't get EFL_CANVAS_VG_CONTAINER_CLASS data from %p.", parent);
goto on_error;
}
}
@ -344,7 +344,7 @@ _efl_vg_efl_object_parent_set(Eo *obj,
goto on_error;
}
if (!_efl_vg_parent_checked_get(obj, &old_parent, &old_cd))
if (!_efl_canvas_vg_node_parent_checked_get(obj, &old_parent, &old_cd))
{
ERR("Can't check the old parent of %p.", obj);
goto on_error;
@ -363,12 +363,12 @@ _efl_vg_efl_object_parent_set(Eo *obj,
{
cd->children = eina_list_append(cd->children, obj);
_efl_vg_name_insert(obj, cd);
_efl_canvas_vg_node_name_insert(obj, cd);
}
_efl_vg_changed(old_parent);
_efl_vg_changed(obj);
_efl_vg_changed(parent);
_efl_canvas_vg_node_changed(old_parent);
_efl_canvas_vg_node_changed(obj);
_efl_canvas_vg_node_changed(parent);
return ;
@ -377,15 +377,15 @@ _efl_vg_efl_object_parent_set(Eo *obj,
}
static void
_efl_vg_efl_gfx_stack_raise(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
_efl_canvas_vg_node_efl_gfx_stack_raise(Eo *obj, Efl_Canvas_VG_Node_Data *pd EINA_UNUSED)
{
Efl_VG_Container_Data *cd;
Efl_Canvas_VG_Container_Data *cd;
Eina_List *lookup, *next;
Eo *parent;
parent = efl_parent_get(obj);
if (!efl_isa(parent, EFL_VG_CONTAINER_CLASS)) goto on_error;
cd = efl_data_scope_get(parent, EFL_VG_CONTAINER_CLASS);
if (!efl_isa(parent, EFL_CANVAS_VG_CONTAINER_CLASS)) goto on_error;
cd = efl_data_scope_get(parent, EFL_CANVAS_VG_CONTAINER_CLASS);
// FIXME: this could become slow with to much object
lookup = eina_list_data_find_list(cd->children, obj);
@ -397,7 +397,7 @@ _efl_vg_efl_gfx_stack_raise(Eo *obj, Efl_VG_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_changed(parent);
_efl_canvas_vg_node_changed(parent);
return ;
on_error:
@ -405,17 +405,17 @@ _efl_vg_efl_gfx_stack_raise(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
}
static void
_efl_vg_efl_gfx_stack_stack_above(Eo *obj,
Efl_VG_Data *pd EINA_UNUSED,
_efl_canvas_vg_node_efl_gfx_stack_stack_above(Eo *obj,
Efl_Canvas_VG_Node_Data *pd EINA_UNUSED,
Efl_Gfx_Stack *above)
{
Efl_VG_Container_Data *cd;
Efl_Canvas_VG_Container_Data *cd;
Eina_List *lookup, *ref;
Eo *parent;
parent = efl_parent_get(obj);
if (!efl_isa(parent, EFL_VG_CONTAINER_CLASS)) goto on_error;
cd = efl_data_scope_get(parent, EFL_VG_CONTAINER_CLASS);
if (!efl_isa(parent, EFL_CANVAS_VG_CONTAINER_CLASS)) goto on_error;
cd = efl_data_scope_get(parent, EFL_CANVAS_VG_CONTAINER_CLASS);
// FIXME: this could become slow with to much object
lookup = eina_list_data_find_list(cd->children, obj);
@ -427,7 +427,7 @@ _efl_vg_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_changed(parent);
_efl_canvas_vg_node_changed(parent);
return ;
on_error:
@ -435,17 +435,17 @@ _efl_vg_efl_gfx_stack_stack_above(Eo *obj,
}
static void
_efl_vg_efl_gfx_stack_stack_below(Eo *obj,
Efl_VG_Data *pd EINA_UNUSED,
_efl_canvas_vg_node_efl_gfx_stack_stack_below(Eo *obj,
Efl_Canvas_VG_Node_Data *pd EINA_UNUSED,
Efl_Gfx_Stack *below)
{
Efl_VG_Container_Data *cd;
Efl_Canvas_VG_Container_Data *cd;
Eina_List *lookup, *ref;
Eo *parent;
parent = efl_parent_get(obj);
if (!efl_isa(parent, EFL_VG_CONTAINER_CLASS)) goto on_error;
cd = efl_data_scope_get(parent, EFL_VG_CONTAINER_CLASS);
if (!efl_isa(parent, EFL_CANVAS_VG_CONTAINER_CLASS)) goto on_error;
cd = efl_data_scope_get(parent, EFL_CANVAS_VG_CONTAINER_CLASS);
// FIXME: this could become slow with to much object
lookup = eina_list_data_find_list(cd->children, obj);
@ -457,7 +457,7 @@ _efl_vg_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_changed(parent);
_efl_canvas_vg_node_changed(parent);
return ;
on_error:
@ -465,15 +465,15 @@ _efl_vg_efl_gfx_stack_stack_below(Eo *obj,
}
static void
_efl_vg_efl_gfx_stack_lower(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
_efl_canvas_vg_node_efl_gfx_stack_lower(Eo *obj, Efl_Canvas_VG_Node_Data *pd EINA_UNUSED)
{
Efl_VG_Container_Data *cd;
Efl_Canvas_VG_Container_Data *cd;
Eina_List *lookup, *prev;
Eo *parent;
parent = efl_parent_get(obj);
if (!efl_isa(parent, EFL_VG_CONTAINER_CLASS)) goto on_error;
cd = efl_data_scope_get(parent, EFL_VG_CONTAINER_CLASS);
if (!efl_isa(parent, EFL_CANVAS_VG_CONTAINER_CLASS)) goto on_error;
cd = efl_data_scope_get(parent, EFL_CANVAS_VG_CONTAINER_CLASS);
// FIXME: this could become slow with to much object
lookup = eina_list_data_find_list(cd->children, obj);
@ -485,7 +485,7 @@ _efl_vg_efl_gfx_stack_lower(Eo *obj, Efl_VG_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_changed(parent);
_efl_canvas_vg_node_changed(parent);
return ;
on_error:
@ -493,18 +493,18 @@ _efl_vg_efl_gfx_stack_lower(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
}
static Eo *
_efl_vg_root_parent_get(Eo *obj)
_efl_canvas_vg_node_root_parent_get(Eo *obj)
{
Eo *parent;
parent = efl_parent_get(obj);
if (!parent) return obj;
return _efl_vg_root_parent_get(parent);
return _efl_canvas_vg_node_root_parent_get(parent);
}
static void
_efl_vg_walk_down_at(Eo *root, Eina_Array *a, Eina_Rectangle *r)
_efl_canvas_vg_node_walk_down_at(Eo *root, Eina_Array *a, Eina_Rectangle *r)
{
Eina_Rect bounds;
@ -513,31 +513,31 @@ _efl_vg_walk_down_at(Eo *root, Eina_Array *a, Eina_Rectangle *r)
eina_array_push(a, root);
if (efl_isa(root, EFL_VG_CONTAINER_CLASS))
if (efl_isa(root, EFL_CANVAS_VG_CONTAINER_CLASS))
{
Efl_VG_Container_Data *cd;
Efl_Canvas_VG_Container_Data *cd;
Eina_List *l;
Eo *child;
cd = efl_data_scope_get(root, EFL_VG_CONTAINER_CLASS);
cd = efl_data_scope_get(root, EFL_CANVAS_VG_CONTAINER_CLASS);
EINA_LIST_FOREACH(cd->children, l, child)
_efl_vg_walk_down_at(child, a, r);
_efl_canvas_vg_node_walk_down_at(child, a, r);
}
}
static void
_efl_vg_object_at(Eo *obj, Eina_Array *a, Eina_Rectangle *r)
_efl_canvas_vg_node_object_at(Eo *obj, Eina_Array *a, Eina_Rectangle *r)
{
Eo *root;
root = _efl_vg_root_parent_get(obj);
root = _efl_canvas_vg_node_root_parent_get(obj);
if (!root) return ;
_efl_vg_walk_down_at(root, a, r);
_efl_canvas_vg_node_walk_down_at(root, a, r);
}
static Efl_Gfx_Stack *
_efl_vg_efl_gfx_stack_below_get(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
_efl_canvas_vg_node_efl_gfx_stack_below_get(Eo *obj, Efl_Canvas_VG_Node_Data *pd EINA_UNUSED)
{
Eina_Rect r;
Eina_Array a;
@ -550,7 +550,7 @@ _efl_vg_efl_gfx_stack_below_get(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
eina_array_step_set(&a, sizeof (Eina_Array), 8);
_efl_vg_object_at(obj, &a, &r.rect);
_efl_canvas_vg_node_object_at(obj, &a, &r.rect);
EINA_ARRAY_ITER_NEXT(&a, i, current, iterator)
if (current == obj)
@ -567,7 +567,7 @@ _efl_vg_efl_gfx_stack_below_get(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
}
static Efl_Gfx_Stack *
_efl_vg_efl_gfx_stack_above_get(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
_efl_canvas_vg_node_efl_gfx_stack_above_get(Eo *obj, Efl_Canvas_VG_Node_Data *pd EINA_UNUSED)
{
Eina_Rect r;
Eina_Array a;
@ -580,7 +580,7 @@ _efl_vg_efl_gfx_stack_above_get(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
eina_array_step_set(&a, sizeof (Eina_Array), 8);
_efl_vg_object_at(obj, &a, &r.rect);
_efl_canvas_vg_node_object_at(obj, &a, &r.rect);
EINA_ARRAY_ITER_NEXT(&a, i, current, iterator)
if (current == obj)
@ -595,15 +595,15 @@ _efl_vg_efl_gfx_stack_above_get(Eo *obj, Efl_VG_Data *pd EINA_UNUSED)
return above;
}
static Efl_VG_Interpolation *
_efl_vg_interpolation_get(Efl_VG_Data *pd)
static Efl_Canvas_VG_Interpolation *
_efl_canvas_vg_node_interpolation_get(Efl_Canvas_VG_Node_Data *pd)
{
Eina_Matrix4 m;
if (!pd->m) return NULL;
if (pd->intp) return pd->intp;
pd->intp = calloc(1, sizeof (Efl_VG_Interpolation));
pd->intp = calloc(1, sizeof (Efl_Canvas_VG_Interpolation));
if (!pd->intp) return NULL;
eina_matrix3_matrix4_to(&m, pd->m);
@ -623,7 +623,7 @@ _efl_vg_interpolation_get(Efl_VG_Data *pd)
}
static inline void
_efl_vg_interpolate_point(Eina_Point_3D *d,
_efl_canvas_vg_node_interpolate_point(Eina_Point_3D *d,
const Eina_Point_3D *a, const Eina_Point_3D *b,
double pos_map, double from_map)
{
@ -633,16 +633,16 @@ _efl_vg_interpolate_point(Eina_Point_3D *d,
}
static Eina_Bool
_efl_vg_efl_gfx_path_interpolate(Eo *obj,
Efl_VG_Data *pd, const Efl_VG *from, const Efl_VG *to,
_efl_canvas_vg_node_efl_gfx_path_interpolate(Eo *obj,
Efl_Canvas_VG_Node_Data *pd, const Efl_VG *from, const Efl_VG *to,
double pos_map)
{
Efl_VG_Data *fromd, *tod;
Efl_Canvas_VG_Node_Data *fromd, *tod;
double from_map;
Eina_Bool r = EINA_TRUE;
fromd = efl_data_scope_get(from, EFL_VG_CLASS);
tod = efl_data_scope_get(to, EFL_VG_CLASS);
fromd = efl_data_scope_get(from, EFL_CANVAS_VG_NODE_CLASS);
tod = efl_data_scope_get(to, EFL_CANVAS_VG_NODE_CLASS);
from_map = 1.0 - pos_map;
efl_del(pd->renderer);
@ -653,25 +653,25 @@ _efl_vg_efl_gfx_path_interpolate(Eo *obj,
if (!pd->m) pd->m = malloc(sizeof (Eina_Matrix3));
if (pd->m)
{
const Efl_VG_Interpolation *fi, *ti;
Efl_VG_Interpolation result;
const Efl_Canvas_VG_Interpolation *fi, *ti;
Efl_Canvas_VG_Interpolation result;
Eina_Matrix4 m;
fi = _efl_vg_interpolation_get(fromd);
fi = _efl_canvas_vg_node_interpolation_get(fromd);
if (!fi) fi = &interpolation_identity;
ti = _efl_vg_interpolation_get(tod);
ti = _efl_canvas_vg_node_interpolation_get(tod);
if (!ti) ti = &interpolation_identity;
eina_quaternion_slerp(&result.rotation,
&fi->rotation, &ti->rotation,
pos_map);
_efl_vg_interpolate_point(&result.translation,
_efl_canvas_vg_node_interpolate_point(&result.translation,
&fi->translation, &ti->translation,
pos_map, from_map);
_efl_vg_interpolate_point(&result.scale,
_efl_canvas_vg_node_interpolate_point(&result.scale,
&fi->scale, &ti->scale,
pos_map, from_map);
_efl_vg_interpolate_point(&result.skew,
_efl_canvas_vg_node_interpolate_point(&result.skew,
&fi->skew, &ti->skew,
pos_map, from_map);
@ -705,16 +705,16 @@ _efl_vg_efl_gfx_path_interpolate(Eo *obj,
r &= efl_gfx_path_interpolate(pd->mask, fromd->mask, tod->mask, pos_map);
}
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
return r;
}
EOLIAN static Efl_VG *
_efl_vg_efl_duplicate_duplicate(const Eo *obj, Efl_VG_Data *pd)
_efl_canvas_vg_node_efl_duplicate_duplicate(const Eo *obj, Efl_Canvas_VG_Node_Data *pd)
{
Efl_VG *cn;
Efl_VG_Data *cd;
Efl_Canvas_VG_Node_Data *cd;
cn = efl_add(efl_class_get(obj), NULL);
cd = efl_data_scope_get(cn, MY_CLASS);
@ -807,4 +807,4 @@ evas_vg_node_lower(Eo *obj)
efl_gfx_stack_lower(obj);
}
#include "efl_vg.eo.c"
#include "efl_canvas_vg_node.eo.c"

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

@ -3,10 +3,10 @@
#include <Ector.h>
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;
typedef struct _Efl_Canvas_VG_Node_Data Efl_Canvas_VG_Node_Data;
typedef struct _Efl_Canvas_VG_Container_Data Efl_Canvas_VG_Container_Data;
typedef struct _Efl_Canvas_VG_Gradient_Data Efl_Canvas_VG_Gradient_Data;
typedef struct _Efl_Canvas_VG_Interpolation Efl_Canvas_VG_Interpolation;
typedef struct _Efl_Canvas_Vg_Data Efl_Canvas_Vg_Data;
@ -54,15 +54,15 @@ struct _Efl_Canvas_Vg_Data
Eina_Bool changed;
};
struct _Efl_VG_Data
struct _Efl_Canvas_VG_Node_Data
{
Eina_Matrix3 *m;
Efl_VG_Interpolation *intp;
Efl_Canvas_VG_Interpolation *intp;
Efl_VG *mask;
Efl_Canvas_VG_Node *mask;
Ector_Renderer *renderer;
void (*render_pre)(Eo *obj, Eina_Matrix3 *parent, Ector_Surface *s, void *data, Efl_VG_Data *nd);
void (*render_pre)(Eo *obj, Eina_Matrix3 *parent, Ector_Surface *s, void *data, Efl_Canvas_VG_Node_Data *nd);
void *data;
double x, y;
@ -73,14 +73,14 @@ struct _Efl_VG_Data
Eina_Bool changed : 1;
};
struct _Efl_VG_Container_Data
struct _Efl_Canvas_VG_Container_Data
{
Eina_List *children;
Eina_Hash *names;
};
struct _Efl_VG_Gradient_Data
struct _Efl_Canvas_VG_Gradient_Data
{
// FIXME: Later on we should deduplicate it somehow (Using Ector ?).
Efl_Gfx_Gradient_Stop *colors;
@ -89,7 +89,7 @@ struct _Efl_VG_Gradient_Data
Efl_Gfx_Gradient_Spread s;
};
struct _Efl_VG_Interpolation
struct _Efl_Canvas_VG_Interpolation
{
Eina_Quaternion rotation;
Eina_Quaternion perspective;
@ -108,14 +108,14 @@ Vg_File_Data * evas_cache_vg_file_info(const char *file, const char
Eina_Bool evas_vg_save_to_file(Vg_File_Data *evg_data, const char *file, const char *key, const char *flags);
static inline Efl_VG_Data *
static inline Efl_Canvas_VG_Node_Data *
_evas_vg_render_pre(Efl_VG *child, Ector_Surface *s, Eina_Matrix3 *m)
{
Efl_VG_Data *child_nd = NULL;
Efl_Canvas_VG_Node_Data *child_nd = NULL;
// FIXME: Prevent infinite loop
if (child)
child_nd = efl_data_scope_get(child, EFL_VG_CLASS);
child_nd = efl_data_scope_get(child, EFL_CANVAS_VG_NODE_CLASS);
if (child_nd)
child_nd->render_pre(child, m, s, child_nd->data, child_nd);
@ -123,7 +123,7 @@ _evas_vg_render_pre(Efl_VG *child, Ector_Surface *s, Eina_Matrix3 *m)
}
static inline void
_efl_vg_changed(Eo *obj)
_efl_canvas_vg_node_changed(Eo *obj)
{
Efl_Gfx_Path_Change_Event ev = { EFL_GFX_CHANGE_FLAG_FILL };
efl_event_callback_call(obj, EFL_GFX_PATH_EVENT_CHANGED, &ev);
@ -147,7 +147,7 @@ _efl_vg_clean_object(Eo **obj)
*obj = NULL;
}
#define EFL_VG_COMPUTE_MATRIX(Current, Parent, Nd) \
#define EFL_CANVAS_VG_COMPUTE_MATRIX(Current, Parent, Nd) \
Eina_Matrix3 *Current = Nd->m; \
Eina_Matrix3 _matrix_tmp; \
\

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

@ -3,95 +3,95 @@
#include "evas_vg_private.h"
#define MY_CLASS EFL_VG_SHAPE_CLASS
#define MY_CLASS EFL_CANVAS_VG_SHAPE_CLASS
typedef struct _Efl_VG_Shape_Data Efl_VG_Shape_Data;
struct _Efl_VG_Shape_Data
typedef struct _Efl_Canvas_VG_Shape_Data Efl_Canvas_VG_Shape_Data;
struct _Efl_Canvas_VG_Shape_Data
{
Efl_VG *fill;
Efl_Canvas_VG_Node *fill;
struct {
Efl_VG *fill;
Efl_VG *marker;
Efl_Canvas_VG_Node *fill;
Efl_Canvas_VG_Node *marker;
} stroke;
};
// FIXME: Use the renderer bounding box when it has been created instead of an estimation
static void
_efl_vg_shape_fill_set(Eo *obj EINA_UNUSED,
Efl_VG_Shape_Data *pd,
Efl_VG *f)
_efl_canvas_vg_shape_fill_set(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Shape_Data *pd,
Efl_Canvas_VG_Node *f)
{
Efl_VG *tmp = pd->fill;
Efl_Canvas_VG_Node *tmp = pd->fill;
pd->fill = efl_ref(f);
efl_unref(tmp);
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static Efl_VG *
_efl_vg_shape_fill_get(Eo *obj EINA_UNUSED, Efl_VG_Shape_Data *pd)
static Efl_Canvas_VG_Node *
_efl_canvas_vg_shape_fill_get(Eo *obj EINA_UNUSED, Efl_Canvas_VG_Shape_Data *pd)
{
return pd->fill;
}
static void
_efl_vg_shape_stroke_fill_set(Eo *obj EINA_UNUSED,
Efl_VG_Shape_Data *pd,
Efl_VG *f)
_efl_canvas_vg_shape_stroke_fill_set(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Shape_Data *pd,
Efl_Canvas_VG_Node *f)
{
Efl_VG *tmp = pd->fill;
Efl_Canvas_VG_Node *tmp = pd->fill;
pd->stroke.fill = efl_ref(f);
efl_unref(tmp);
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static Efl_VG *
_efl_vg_shape_stroke_fill_get(Eo *obj EINA_UNUSED,
Efl_VG_Shape_Data *pd)
static Efl_Canvas_VG_Node *
_efl_canvas_vg_shape_stroke_fill_get(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Shape_Data *pd)
{
return pd->stroke.fill;
}
static void
_efl_vg_shape_stroke_marker_set(Eo *obj EINA_UNUSED,
Efl_VG_Shape_Data *pd,
Efl_VG_Shape *m)
_efl_canvas_vg_shape_stroke_marker_set(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Shape_Data *pd,
Efl_Canvas_VG_Shape *m)
{
Efl_VG *tmp = pd->stroke.marker;
Efl_Canvas_VG_Node *tmp = pd->stroke.marker;
pd->stroke.marker = efl_ref(m);
efl_unref(tmp);
_efl_vg_changed(obj);
_efl_canvas_vg_node_changed(obj);
}
static Efl_VG_Shape *
_efl_vg_shape_stroke_marker_get(Eo *obj EINA_UNUSED,
Efl_VG_Shape_Data *pd)
static Efl_Canvas_VG_Shape *
_efl_canvas_vg_shape_stroke_marker_get(Eo *obj EINA_UNUSED,
Efl_Canvas_VG_Shape_Data *pd)
{
return pd->stroke.marker;
}
static void
_efl_vg_shape_render_pre(Eo *obj EINA_UNUSED,
_efl_canvas_vg_shape_render_pre(Eo *obj EINA_UNUSED,
Eina_Matrix3 *parent,
Ector_Surface *s,
void *data,
Efl_VG_Data *nd)
Efl_Canvas_VG_Node_Data *nd)
{
Efl_VG_Shape_Data *pd = data;
Efl_VG_Data *fill, *stroke_fill, *stroke_marker, *mask;
Efl_Canvas_VG_Shape_Data *pd = data;
Efl_Canvas_VG_Node_Data *fill, *stroke_fill, *stroke_marker, *mask;
if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return ;
nd->flags = EFL_GFX_CHANGE_FLAG_NONE;
EFL_VG_COMPUTE_MATRIX(current, parent, nd);
EFL_CANVAS_VG_COMPUTE_MATRIX(current, parent, nd);
fill = _evas_vg_render_pre(pd->fill, s, current);
stroke_fill = _evas_vg_render_pre(pd->stroke.fill, s, current);
@ -118,9 +118,9 @@ _efl_vg_shape_render_pre(Eo *obj EINA_UNUSED,
}
static Eo *
_efl_vg_shape_efl_object_constructor(Eo *obj, Efl_VG_Shape_Data *pd)
_efl_canvas_vg_shape_efl_object_constructor(Eo *obj, Efl_Canvas_VG_Shape_Data *pd)
{
Efl_VG_Data *nd;
Efl_Canvas_VG_Node_Data *nd;
obj = efl_constructor(efl_super(obj, MY_CLASS));
@ -129,31 +129,31 @@ _efl_vg_shape_efl_object_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 = efl_data_scope_get(obj, EFL_VG_CLASS);
nd->render_pre = _efl_vg_shape_render_pre;
nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
nd->render_pre = _efl_canvas_vg_shape_render_pre;
nd->data = pd;
return obj;
}
static void
_efl_vg_shape_efl_object_destructor(Eo *obj, Efl_VG_Shape_Data *pd EINA_UNUSED)
_efl_canvas_vg_shape_efl_object_destructor(Eo *obj, Efl_Canvas_VG_Shape_Data *pd EINA_UNUSED)
{
efl_gfx_path_reset(obj);
efl_destructor(efl_super(obj, MY_CLASS));
}
static Eina_Bool
_efl_vg_shape_efl_gfx_path_interpolate(Eo *obj,
Efl_VG_Shape_Data *pd,
const Efl_VG *from, const Efl_VG *to,
_efl_canvas_vg_shape_efl_gfx_path_interpolate(Eo *obj,
Efl_Canvas_VG_Shape_Data *pd,
const Efl_Canvas_VG_Node *from, const Efl_Canvas_VG_Node *to,
double pos_map)
{
Efl_VG_Shape_Data *fromd, *tod;
Efl_Canvas_VG_Shape_Data *fromd, *tod;
Eina_Bool r;
fromd = efl_data_scope_get(from, EFL_VG_SHAPE_CLASS);
tod = efl_data_scope_get(to, EFL_VG_SHAPE_CLASS);
fromd = efl_data_scope_get(from, EFL_CANVAS_VG_SHAPE_CLASS);
tod = efl_data_scope_get(to, EFL_CANVAS_VG_SHAPE_CLASS);
r = efl_gfx_path_interpolate(efl_super(obj, MY_CLASS), from, to, pos_map);
@ -176,11 +176,11 @@ _efl_vg_shape_efl_gfx_path_interpolate(Eo *obj,
}
EOLIAN static Efl_VG *
_efl_vg_shape_efl_duplicate_duplicate(const Eo *obj, Efl_VG_Shape_Data *pd)
EOLIAN static Efl_Canvas_VG_Node *
_efl_canvas_vg_shape_efl_duplicate_duplicate(const Eo *obj, Efl_Canvas_VG_Shape_Data *pd)
{
Efl_VG *cn = NULL;
Efl_VG_Shape_Data *cd = NULL;
Efl_Canvas_VG_Node *cn = NULL;
Efl_Canvas_VG_Shape_Data *cd = NULL;
cn = efl_duplicate(efl_super(obj, MY_CLASS));
cd = efl_data_scope_get(cn, MY_CLASS);
@ -405,10 +405,10 @@ evas_vg_shape_equal_commands(Eo *obj, const Eo *with)
return efl_gfx_path_equal_commands(obj, with);
}
EAPI Efl_VG*
evas_vg_shape_add(Efl_VG *parent)
EAPI Efl_Canvas_VG_Node*
evas_vg_shape_add(Efl_Canvas_VG_Node *parent)
{
return efl_add(EFL_VG_SHAPE_CLASS, parent);
return efl_add(EFL_CANVAS_VG_SHAPE_CLASS, parent);
}
#include "efl_vg_shape.eo.c"
#include "efl_canvas_vg_shape.eo.c"

2
src/lib/evas/vg/evas_vg_cache.c
View File

@ -262,7 +262,7 @@ _apply_transformation(Efl_VG *root, double w, double h, Vg_File_Data *vg_data)
eina_matrix3_scale(&m, sx, sy);
eina_matrix3_translate(&m, -vg_data->view_box.x, -vg_data->view_box.y);
}
evas_vg_node_transformation_set(root, &m);
efl_canvas_vg_node_transformation_set(root, &m);
}
static Efl_VG *

8
src/static_libs/vg_common/vg_common.c
View File

@ -630,7 +630,7 @@ _apply_gradient_property(Svg_Style_Gradient *g, Efl_VG *vg, Vg_File_Data *vg_dat
eina_matrix3_scale(&m, scale_X, scale_Y);
eina_matrix3_translate(&m, cx_scaled - cx, cy_scaled - cy);
efl_vg_transformation_set(grad_obj, &m);
efl_canvas_vg_node_transformation_set(grad_obj, &m);
}
}
else
@ -894,7 +894,7 @@ _create_gradient_node(Efl_VG *vg)
grad->stops = eina_list_append(grad->stops, new_stop);
stops++;
}
if (efl_isa(vg, EFL_VG_GRADIENT_LINEAR_CLASS))
if (efl_isa(vg, EFL_CANVAS_VG_GRADIENT_LINEAR_CLASS))
{
grad->type = SVG_LINEAR_GRADIENT;
grad->linear = calloc(1, sizeof(Svg_Linear_Gradient));
@ -982,12 +982,12 @@ vg_common_create_svg_node_helper(Efl_VG *vg, Svg_Node *parent)
unsigned int points_count, commands_count;
const double *points;
if (efl_isa(vg, EFL_VG_CONTAINER_CLASS))
if (efl_isa(vg, EFL_CANVAS_VG_CONTAINER_CLASS))
{
svg_node = _create_node(parent, SVG_NODE_G);
_apply_svg_property(svg_node, vg);
// apply property
it = efl_vg_container_children_get(vg);
it = efl_canvas_vg_container_children_get(vg);
EINA_ITERATOR_FOREACH(it, child)
{
vg_common_create_svg_node_helper(child, svg_node);