2015-04-03 07:12:59 -07:00
|
|
|
#include "evas_common_private.h"
|
|
|
|
#include "evas_private.h"
|
|
|
|
|
|
|
|
#include "evas_vg_private.h"
|
|
|
|
|
2018-02-20 12:24:09 -08:00
|
|
|
#define MY_CLASS EFL_CANVAS_VG_CONTAINER_CLASS
|
2015-04-03 07:12:59 -07:00
|
|
|
|
2018-06-12 02:59:37 -07:00
|
|
|
static void
|
|
|
|
_invalidate_cb(void *data EINA_UNUSED, const Efl_Event *event)
|
|
|
|
{
|
|
|
|
Efl_Canvas_Vg_Container_Data *pd;
|
|
|
|
Eina_List *l;
|
|
|
|
Efl_VG* child;
|
|
|
|
|
|
|
|
pd = efl_data_scope_get(event->object, MY_CLASS);
|
|
|
|
|
|
|
|
/* Clean up all the references by copying.
|
|
|
|
If the container is copied, it copies its children as well.
|
|
|
|
Since evas_vg_node is duplicated using efl_add_ref(),
|
|
|
|
we definitely call efl_unref() after that. */
|
|
|
|
EINA_LIST_FOREACH(pd->children, l, child)
|
|
|
|
efl_unref(child);
|
|
|
|
}
|
|
|
|
|
2019-01-27 23:53:42 -08:00
|
|
|
static void
|
|
|
|
_draw_mask(Evas_Object_Protected_Data *obj, Efl_VG *node,
|
|
|
|
Ector_Surface *ector, void *engine, void *output,
|
|
|
|
void *context)
|
|
|
|
{
|
|
|
|
if (!efl_gfx_entity_visible_get(node)) return;
|
|
|
|
|
|
|
|
if (efl_isa(node, EFL_CANVAS_VG_CONTAINER_CLASS))
|
|
|
|
{
|
|
|
|
Efl_Canvas_Vg_Container_Data *cd =
|
|
|
|
efl_data_scope_get(node, EFL_CANVAS_VG_CONTAINER_CLASS);
|
|
|
|
|
|
|
|
//Draw Mask Image.
|
|
|
|
Efl_VG *child;
|
|
|
|
Eina_List *l;
|
|
|
|
EINA_LIST_FOREACH(cd->children, l, child)
|
|
|
|
_draw_mask(obj, child, ector, engine, output, context);
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
|
|
|
Efl_Canvas_Vg_Node_Data *nd = efl_data_scope_get(node, EFL_CANVAS_VG_NODE_CLASS);
|
|
|
|
ENFN->ector_renderer_draw(engine, output, context, nd->renderer, NULL, EINA_FALSE);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-12-07 02:38:48 -08:00
|
|
|
static Ector_Buffer *
|
|
|
|
_prepare_mask(Evas_Object_Protected_Data *obj, //vector object
|
|
|
|
Efl_Canvas_Vg_Node* mask_obj,
|
2019-01-27 23:53:42 -08:00
|
|
|
void *engine, void *output, void *context,
|
2018-12-07 02:38:48 -08:00
|
|
|
Ector_Surface *surface,
|
|
|
|
Eina_Matrix3 *ptransform,
|
|
|
|
Ector_Buffer *mask,
|
|
|
|
int mask_op)
|
|
|
|
{
|
|
|
|
Efl_Canvas_Vg_Container_Data *pd = efl_data_scope_get(mask_obj, MY_CLASS);
|
|
|
|
Efl_Canvas_Vg_Node_Data *nd =
|
|
|
|
efl_data_scope_get(mask_obj, EFL_CANVAS_VG_NODE_CLASS);
|
|
|
|
if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return pd->mask.buffer;
|
|
|
|
|
|
|
|
//1. Mask Size
|
|
|
|
Eina_Rect mbound;
|
|
|
|
mbound.x = 0;
|
|
|
|
mbound.y = 0;
|
|
|
|
mbound.w = obj->cur->geometry.w;
|
|
|
|
mbound.h = obj->cur->geometry.h;
|
|
|
|
|
|
|
|
// efl_gfx_path_bounds_get(mask, &mbound);
|
|
|
|
|
|
|
|
//2. Reusable ector buffer?
|
|
|
|
if (!pd->mask.buffer || (pd->mask.bound.w != mbound.w) ||
|
|
|
|
(pd->mask.bound.h != mbound.h))
|
|
|
|
{
|
|
|
|
if (pd->mask.pixels) free(pd->mask.pixels);
|
|
|
|
if (pd->mask.buffer) efl_unref(pd->mask.buffer);
|
|
|
|
pd->mask.pixels = calloc(sizeof(uint32_t), mbound.w * mbound.h);
|
|
|
|
pd->mask.buffer = ENFN->ector_buffer_new(ENC, obj->layer->evas->evas,
|
|
|
|
mbound.w, mbound.h,
|
|
|
|
EFL_GFX_COLORSPACE_ARGB8888,
|
|
|
|
ECTOR_BUFFER_FLAG_DRAWABLE |
|
|
|
|
ECTOR_BUFFER_FLAG_CPU_READABLE |
|
|
|
|
ECTOR_BUFFER_FLAG_CPU_WRITABLE);
|
|
|
|
ector_buffer_pixels_set(pd->mask.buffer, pd->mask.pixels,
|
|
|
|
mbound.w, mbound.h, 0,
|
|
|
|
EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE);
|
|
|
|
pd->mask.bound.w = mbound.w;
|
|
|
|
pd->mask.bound.h = mbound.h;
|
|
|
|
pd->mask.vg_pd = obj;
|
|
|
|
}
|
2019-01-09 21:15:07 -08:00
|
|
|
else
|
|
|
|
{
|
|
|
|
if (pd->mask.pixels)
|
|
|
|
memset(pd->mask.pixels, 0x0, sizeof(uint32_t) * mbound.w * mbound.h);
|
|
|
|
}
|
2018-12-07 02:38:48 -08:00
|
|
|
|
|
|
|
pd->mask.bound.x = mbound.x;
|
|
|
|
pd->mask.bound.y = mbound.y;
|
|
|
|
|
|
|
|
if (!pd->mask.buffer) ERR("Mask Buffer is invalid");
|
|
|
|
|
2019-01-27 23:53:42 -08:00
|
|
|
//3. Prepare Drawing shapes.
|
|
|
|
_evas_vg_render_pre(obj, mask_obj,
|
|
|
|
engine, output, context,
|
|
|
|
surface,
|
|
|
|
ptransform, mask, mask_op);
|
2018-12-07 02:38:48 -08:00
|
|
|
|
2019-01-27 23:53:42 -08:00
|
|
|
//4. Generating Mask Image.
|
|
|
|
ector_buffer_pixels_set(surface, pd->mask.pixels, mbound.w, mbound.h, 0,
|
|
|
|
EFL_GFX_COLORSPACE_ARGB8888, EINA_TRUE);
|
|
|
|
ector_surface_reference_point_set(surface, -mbound.x, -mbound.y);
|
|
|
|
_draw_mask(obj, mask_obj, surface, engine, output, context);
|
2018-12-07 02:38:48 -08:00
|
|
|
|
|
|
|
return pd->mask.buffer;
|
|
|
|
}
|
|
|
|
|
2015-04-03 07:22:58 -07:00
|
|
|
static void
|
2018-12-07 02:38:48 -08:00
|
|
|
_efl_canvas_vg_container_render_pre(Evas_Object_Protected_Data *vg_pd,
|
|
|
|
Efl_VG *obj EINA_UNUSED,
|
|
|
|
Efl_Canvas_Vg_Node_Data *nd,
|
2019-01-27 23:53:42 -08:00
|
|
|
void *engine, void *output, void *context,
|
2018-12-07 02:38:48 -08:00
|
|
|
Ector_Surface *surface,
|
|
|
|
Eina_Matrix3 *ptransform,
|
|
|
|
Ector_Buffer *mask,
|
|
|
|
int mask_op,
|
|
|
|
void *data)
|
2015-04-03 07:22:58 -07:00
|
|
|
{
|
2018-04-04 04:38:34 -07:00
|
|
|
Efl_Canvas_Vg_Container_Data *pd = data;
|
2015-04-03 07:22:58 -07:00
|
|
|
Eina_List *l;
|
2018-12-07 02:38:48 -08:00
|
|
|
Efl_VG *child;
|
2016-05-19 01:55:06 -07:00
|
|
|
Efl_Gfx_Change_Flag flag;
|
2015-04-03 07:30:42 -07:00
|
|
|
|
2018-11-14 04:50:50 -08:00
|
|
|
if (nd->flags == EFL_GFX_CHANGE_FLAG_NONE) return;
|
2016-05-19 01:55:06 -07:00
|
|
|
|
|
|
|
flag = nd->flags;
|
|
|
|
nd->flags = EFL_GFX_CHANGE_FLAG_NONE;
|
2015-04-03 07:30:42 -07:00
|
|
|
|
2018-12-07 02:38:48 -08:00
|
|
|
EFL_CANVAS_VG_COMPUTE_MATRIX(ctransform, ptransform, nd);
|
|
|
|
|
|
|
|
//Container may have mask source.
|
|
|
|
if (pd->mask_src)
|
|
|
|
{
|
2019-01-27 23:53:42 -08:00
|
|
|
mask = _prepare_mask(vg_pd, pd->mask_src,
|
|
|
|
engine, output, context, surface,
|
|
|
|
ptransform, mask, mask_op);
|
2018-12-07 02:38:48 -08:00
|
|
|
mask_op = pd->mask.option;
|
|
|
|
}
|
2015-04-03 07:22:58 -07:00
|
|
|
|
|
|
|
EINA_LIST_FOREACH(pd->children, l, child)
|
2016-05-19 01:55:06 -07:00
|
|
|
{
|
2018-12-07 02:38:48 -08:00
|
|
|
//Don't need to update mask nodes.
|
|
|
|
if (efl_isa(child, MY_CLASS))
|
|
|
|
{
|
|
|
|
Efl_Canvas_Vg_Container_Data *child_cd =
|
|
|
|
efl_data_scope_get(child, MY_CLASS);
|
|
|
|
if (child_cd->mask.target) continue;
|
|
|
|
}
|
|
|
|
|
2018-11-14 04:50:50 -08:00
|
|
|
//Skip Gradients. they will be updated by Shape.
|
|
|
|
if (efl_isa(child, EFL_CANVAS_VG_GRADIENT_CLASS))
|
|
|
|
continue;
|
|
|
|
|
2018-12-07 02:38:48 -08:00
|
|
|
Efl_Canvas_Vg_Node_Data *child_nd =
|
|
|
|
efl_data_scope_get(child, EFL_CANVAS_VG_NODE_CLASS);
|
|
|
|
|
2016-05-19 01:55:06 -07:00
|
|
|
if (flag & EFL_GFX_CHANGE_FLAG_MATRIX)
|
2018-12-07 02:38:48 -08:00
|
|
|
child_nd->flags |= EFL_GFX_CHANGE_FLAG_MATRIX;
|
|
|
|
|
2019-01-27 23:53:42 -08:00
|
|
|
_evas_vg_render_pre(vg_pd, child,
|
|
|
|
engine, output, context, surface,
|
|
|
|
ctransform, mask, mask_op);
|
2016-05-19 01:55:06 -07:00
|
|
|
}
|
2015-04-03 07:22:58 -07:00
|
|
|
}
|
|
|
|
|
2015-05-19 03:41:27 -07:00
|
|
|
static Eo *
|
2018-02-20 12:24:09 -08:00
|
|
|
_efl_canvas_vg_container_efl_object_constructor(Eo *obj,
|
2018-04-04 04:38:34 -07:00
|
|
|
Efl_Canvas_Vg_Container_Data *pd)
|
2015-04-03 07:12:59 -07:00
|
|
|
{
|
2018-04-04 04:38:34 -07:00
|
|
|
Efl_Canvas_Vg_Node_Data *nd;
|
2015-04-03 07:22:58 -07:00
|
|
|
|
2015-06-05 01:54:13 -07:00
|
|
|
pd->names = eina_hash_stringshared_new(NULL);
|
|
|
|
|
2016-08-15 06:44:41 -07:00
|
|
|
obj = efl_constructor(efl_super(obj, MY_CLASS));
|
2015-04-03 07:22:58 -07:00
|
|
|
|
2018-02-20 12:24:09 -08:00
|
|
|
nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
|
|
|
|
nd->render_pre = _efl_canvas_vg_container_render_pre;
|
2015-04-03 07:22:58 -07:00
|
|
|
nd->data = pd;
|
2016-05-19 01:55:06 -07:00
|
|
|
nd->flags = EFL_GFX_CHANGE_FLAG_ALL;
|
2015-05-19 03:41:27 -07:00
|
|
|
|
|
|
|
return obj;
|
2015-04-03 07:22:58 -07:00
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
2018-02-20 12:24:09 -08:00
|
|
|
_efl_canvas_vg_container_efl_object_destructor(Eo *obj,
|
2018-12-07 02:38:48 -08:00
|
|
|
Efl_Canvas_Vg_Container_Data *pd)
|
2015-04-03 07:22:58 -07:00
|
|
|
{
|
2018-12-07 02:38:48 -08:00
|
|
|
//Destroy mask surface
|
|
|
|
if (pd->mask.buffer) efl_unref(pd->mask.buffer);
|
|
|
|
if (pd->mask.pixels) free(pd->mask.pixels);
|
|
|
|
|
|
|
|
efl_unref(pd->mask_src);
|
|
|
|
eina_list_free(pd->mask.target);
|
2015-06-05 01:54:13 -07:00
|
|
|
eina_hash_free(pd->names);
|
2018-12-07 02:38:48 -08:00
|
|
|
|
|
|
|
efl_destructor(efl_super(obj, MY_CLASS));
|
2015-04-03 07:12:59 -07:00
|
|
|
}
|
|
|
|
|
2015-04-03 07:38:07 -07:00
|
|
|
static void
|
2018-04-17 11:09:44 -07:00
|
|
|
_efl_canvas_vg_container_efl_gfx_path_bounds_get(const Eo *obj EINA_UNUSED,
|
2018-12-07 02:38:48 -08:00
|
|
|
Efl_Canvas_Vg_Container_Data *pd,
|
|
|
|
Eina_Rect *r)
|
2015-04-03 07:12:59 -07:00
|
|
|
{
|
2017-09-13 19:59:44 -07:00
|
|
|
Eina_Rect s;
|
2015-04-03 07:13:12 -07:00
|
|
|
Eina_Bool first = EINA_TRUE;
|
|
|
|
Eina_List *l;
|
|
|
|
Eo *child;
|
|
|
|
|
2017-09-13 19:59:44 -07:00
|
|
|
EINA_RECT_SET(s, -1, -1, 0, 0);
|
2015-04-03 07:13:12 -07:00
|
|
|
|
|
|
|
EINA_LIST_FOREACH(pd->children, l, child)
|
|
|
|
{
|
|
|
|
if (first)
|
|
|
|
{
|
2018-02-12 13:58:57 -08:00
|
|
|
efl_gfx_path_bounds_get(child, r);
|
2015-04-03 07:13:12 -07:00
|
|
|
first = EINA_FALSE;
|
|
|
|
}
|
|
|
|
else
|
|
|
|
{
|
2018-02-12 13:58:57 -08:00
|
|
|
efl_gfx_path_bounds_get(child, &s);
|
2017-09-13 19:59:44 -07:00
|
|
|
eina_rectangle_union(&r->rect, &s.rect);
|
2015-04-03 07:13:12 -07:00
|
|
|
}
|
|
|
|
}
|
2015-04-03 07:12:59 -07:00
|
|
|
}
|
|
|
|
|
2016-05-11 05:13:27 -07:00
|
|
|
static Efl_VG *
|
2018-04-04 04:38:34 -07:00
|
|
|
_efl_canvas_vg_container_child_get(Eo *obj EINA_UNUSED, Efl_Canvas_Vg_Container_Data *pd, const char *name)
|
2015-06-05 01:54:13 -07:00
|
|
|
{
|
|
|
|
const char *tmp = eina_stringshare_add(name);
|
2016-05-11 05:13:27 -07:00
|
|
|
Efl_VG *r;
|
2015-06-05 01:54:13 -07:00
|
|
|
|
|
|
|
r = eina_hash_find(pd->names, tmp);
|
|
|
|
eina_stringshare_del(tmp);
|
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
|
|
|
static Eina_Iterator *
|
2018-04-04 04:38:34 -07:00
|
|
|
_efl_canvas_vg_container_children_get(Eo *obj EINA_UNUSED, Efl_Canvas_Vg_Container_Data *pd)
|
2015-06-05 01:54:13 -07:00
|
|
|
{
|
|
|
|
return eina_list_iterator_new(pd->children);
|
|
|
|
}
|
|
|
|
|
2015-06-16 07:28:19 -07:00
|
|
|
static Eina_Bool
|
2018-06-14 03:51:13 -07:00
|
|
|
_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)
|
2015-06-16 07:28:19 -07:00
|
|
|
{
|
2016-05-19 01:39:44 -07:00
|
|
|
Eina_Iterator *from_it, *to_it;
|
|
|
|
Eina_List *l;
|
|
|
|
Eina_Bool r, res = EINA_TRUE;
|
|
|
|
Eo *from_child, *to_child, *child;
|
|
|
|
|
2018-06-14 03:51:13 -07:00
|
|
|
//Check if both objects have same type
|
|
|
|
if (!(efl_isa(from, MY_CLASS) && efl_isa(to, MY_CLASS)))
|
2016-05-19 01:39:44 -07:00
|
|
|
return EINA_FALSE;
|
2015-06-16 07:28:19 -07:00
|
|
|
|
2018-06-14 03:51:13 -07:00
|
|
|
//Interpolates this nodes
|
|
|
|
r = efl_gfx_path_interpolate(efl_super(obj, MY_CLASS), from, to, pos_map);
|
2015-06-16 07:28:19 -07:00
|
|
|
if (!r) return EINA_FALSE;
|
|
|
|
|
2018-02-20 12:24:09 -08:00
|
|
|
from_it = efl_canvas_vg_container_children_get((Efl_VG *)from);
|
|
|
|
to_it = efl_canvas_vg_container_children_get((Efl_VG *)to);
|
2018-06-14 03:51:13 -07:00
|
|
|
|
|
|
|
//Interpolates children
|
2016-05-19 01:39:44 -07:00
|
|
|
EINA_LIST_FOREACH (pd->children, l, child)
|
2015-06-16 07:28:19 -07:00
|
|
|
{
|
2016-05-19 01:39:44 -07:00
|
|
|
res &= eina_iterator_next(from_it, (void **)&from_child);
|
|
|
|
res &= eina_iterator_next(to_it, (void **)&to_child);
|
2016-08-15 06:44:41 -07:00
|
|
|
if (!res && (efl_class_get(from_child) != efl_class_get(to_child) ||
|
|
|
|
(efl_class_get(child) != efl_class_get(from_child))))
|
2016-05-19 01:39:44 -07:00
|
|
|
{
|
|
|
|
r = EINA_FALSE;
|
|
|
|
break;
|
|
|
|
}
|
2018-06-14 03:51:13 -07:00
|
|
|
r = efl_gfx_path_interpolate(child, from_child, to_child, pos_map);
|
|
|
|
if (!r) break;
|
2015-06-16 07:28:19 -07:00
|
|
|
}
|
2018-06-14 03:51:13 -07:00
|
|
|
|
2018-12-07 02:38:48 -08:00
|
|
|
//Interpolates Mask
|
|
|
|
Efl_Canvas_Vg_Container_Data *fromd = efl_data_scope_get(from, MY_CLASS);
|
|
|
|
Efl_Canvas_Vg_Container_Data *tod = efl_data_scope_get(to, MY_CLASS);
|
|
|
|
|
|
|
|
if (fromd->mask_src && tod->mask_src && pd->mask_src)
|
|
|
|
{
|
|
|
|
if (!efl_gfx_path_interpolate(pd->mask_src,
|
|
|
|
fromd->mask_src, tod->mask_src, pos_map))
|
|
|
|
return EINA_FALSE;
|
|
|
|
}
|
|
|
|
|
2016-05-19 01:39:44 -07:00
|
|
|
eina_iterator_free(from_it);
|
|
|
|
eina_iterator_free(to_it);
|
2015-06-16 07:28:19 -07:00
|
|
|
|
|
|
|
return r;
|
|
|
|
}
|
|
|
|
|
2018-12-07 02:38:48 -08:00
|
|
|
static void
|
|
|
|
_efl_canvas_vg_container_efl_canvas_vg_node_mask_set(Eo *obj,
|
|
|
|
Efl_Canvas_Vg_Container_Data *pd,
|
|
|
|
Efl_Canvas_Vg_Node *mask,
|
|
|
|
int op)
|
|
|
|
{
|
|
|
|
if (pd->mask_src == mask) return;
|
|
|
|
|
|
|
|
EINA_SAFETY_ON_FALSE_RETURN(efl_isa(mask, MY_CLASS));
|
|
|
|
|
|
|
|
if (pd->mask_src)
|
|
|
|
{
|
|
|
|
Efl_Canvas_Vg_Container_Data *pd2 =
|
|
|
|
efl_data_scope_get(pd->mask_src, MY_CLASS);
|
|
|
|
pd2->mask.target = eina_list_remove(pd2->mask.target, obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (mask)
|
|
|
|
{
|
|
|
|
Efl_Canvas_Vg_Container_Data *pd2 = efl_data_scope_get(mask, MY_CLASS);
|
|
|
|
pd2->mask.target = eina_list_append(pd2->mask.target, obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
pd->mask.option = op;
|
|
|
|
efl_replace(&pd->mask_src, mask);
|
2018-12-19 21:42:38 -08:00
|
|
|
efl_canvas_vg_node_change(obj);
|
|
|
|
}
|
|
|
|
|
|
|
|
static void
|
|
|
|
_efl_canvas_vg_container_efl_object_parent_set(Eo *obj,
|
2019-01-08 02:58:57 -08:00
|
|
|
Efl_Canvas_Vg_Container_Data *cd EINA_UNUSED,
|
2018-12-19 21:42:38 -08:00
|
|
|
Eo *parent)
|
|
|
|
{
|
|
|
|
efl_parent_set(efl_super(obj, MY_CLASS), parent);
|
|
|
|
|
|
|
|
Efl_Canvas_Vg_Node_Data *nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
|
|
|
|
efl_canvas_vg_container_vg_obj_update(obj, nd);
|
2018-12-07 02:38:48 -08:00
|
|
|
}
|
|
|
|
|
2017-11-07 22:49:37 -08:00
|
|
|
EOLIAN static Efl_VG *
|
2018-06-11 00:23:28 -07:00
|
|
|
_efl_canvas_vg_container_efl_duplicate_duplicate(const Eo *obj,
|
|
|
|
Efl_Canvas_Vg_Container_Data *pd)
|
2015-06-19 02:26:46 -07:00
|
|
|
{
|
|
|
|
Eina_List *l;
|
2017-11-07 22:49:37 -08:00
|
|
|
Efl_VG *child;
|
2018-06-11 00:23:28 -07:00
|
|
|
Efl_VG *container;
|
2015-06-19 02:26:46 -07:00
|
|
|
|
2018-06-11 00:23:28 -07:00
|
|
|
container = efl_duplicate(efl_super(obj, MY_CLASS));
|
2018-06-12 02:59:37 -07:00
|
|
|
efl_event_callback_add(container, EFL_EVENT_INVALIDATE, _invalidate_cb, NULL);
|
2018-06-11 00:23:28 -07:00
|
|
|
efl_parent_set(container, efl_parent_get(obj));
|
|
|
|
|
2018-12-07 02:38:48 -08:00
|
|
|
//Copy Mask
|
|
|
|
if (pd->mask_src)
|
|
|
|
{
|
|
|
|
Eo * mask_src = efl_duplicate(pd->mask_src);
|
|
|
|
efl_parent_set(mask_src, container);
|
|
|
|
efl_canvas_vg_node_mask_set(container, mask_src, pd->mask.option);
|
|
|
|
}
|
|
|
|
|
2018-06-11 00:23:28 -07:00
|
|
|
//Copy Children
|
2017-11-07 22:49:37 -08:00
|
|
|
EINA_LIST_FOREACH(pd->children, l, child)
|
2015-06-19 02:26:46 -07:00
|
|
|
{
|
2018-06-11 00:23:28 -07:00
|
|
|
Efl_VG *eo = efl_duplicate(child);
|
|
|
|
efl_parent_set(eo, container);
|
2015-06-19 02:26:46 -07:00
|
|
|
}
|
2018-06-11 00:23:28 -07:00
|
|
|
|
|
|
|
return container;
|
2015-06-19 02:26:46 -07:00
|
|
|
}
|
|
|
|
|
2018-12-19 21:42:38 -08:00
|
|
|
void
|
|
|
|
efl_canvas_vg_container_vg_obj_update(Efl_VG *obj, Efl_Canvas_Vg_Node_Data *nd)
|
|
|
|
{
|
|
|
|
if (!obj) return;
|
|
|
|
|
|
|
|
Efl_Canvas_Vg_Container_Data *cd = efl_data_scope_get(obj, MY_CLASS);
|
|
|
|
if (!cd) return;
|
|
|
|
|
|
|
|
Eina_List *l;
|
|
|
|
Efl_VG* child;
|
|
|
|
|
|
|
|
EINA_LIST_FOREACH(cd->children, l, child)
|
|
|
|
{
|
|
|
|
Efl_Canvas_Vg_Node_Data *child_nd =
|
|
|
|
efl_data_scope_get(child, EFL_CANVAS_VG_NODE_CLASS);
|
|
|
|
|
|
|
|
if (child_nd->vg_obj == nd->vg_obj) continue;
|
|
|
|
|
|
|
|
child_nd->vg_obj = nd->vg_obj;
|
|
|
|
child_nd->vd = nd->vd;
|
|
|
|
|
|
|
|
if (efl_isa(child, MY_CLASS))
|
|
|
|
efl_canvas_vg_container_vg_obj_update(child, child_nd);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-04-03 07:34:00 -07:00
|
|
|
EAPI Efl_VG*
|
|
|
|
evas_vg_container_add(Efl_VG *parent)
|
|
|
|
{
|
2018-06-18 16:35:46 -07:00
|
|
|
/* Warn it because the usage has been changed.
|
|
|
|
We can remove this message after v1.21. */
|
|
|
|
if (!parent) CRI("Efl_VG Container doesn't allow null parent!");
|
2018-06-11 00:23:28 -07:00
|
|
|
return efl_add(MY_CLASS, parent);
|
2015-04-03 07:34:00 -07:00
|
|
|
}
|
|
|
|
|
2018-02-20 12:24:09 -08:00
|
|
|
#include "efl_canvas_vg_container.eo.c"
|