tvg_scene_clear(cd->scene);
- if (!nd->visibility)
- return;
+ if (!nd->visibility) return;
- if (nd->a < 255) tvg_paint_set_opacity(cd->scene, nd->a);
-
- if (scene != NULL)
- tvg_scene_push(scene, cd->scene);
- else if (scene == NULL && canvas != NULL)
- tvg_canvas_push(canvas, cd->scene);
+ tvg_paint_set_opacity(cd->scene, nd->a);
EFL_CANVAS_VG_COMPUTE_MATRIX(cTransform, pTransform, nd);
if (cnd && cnd->render_pre_tvg)
cnd->render_pre_tvg(obj, child, cnd, cTransform, canvas, cd->scene);
}
+
+ if (scene) tvg_scene_push(scene, cd->scene);
+ else if (canvas) tvg_canvas_push(canvas, cd->scene);
}
#endif
//Container may have composite target.
//FIXME : _prepare_comp() should only work in cases with matte or masking.
// This condition is valid because the masking use same type as matte.
+
+ //FIX_TVG: Missing tvg support composition????
#ifndef HAVE_THORVG
if (pd->comp_target &&
(pd->comp.method == EFL_GFX_VG_COMPOSITE_METHOD_MATTE_ALPHA ||
efl_unref(pd->comp.buffer);
}
#else
- tvg_scene_clear(pd->scene);
tvg_paint_del(pd->scene);
#endif
void
efl_canvas_vg_container_blend_buffer_clear(Efl_VG *obj EINA_UNUSED, Efl_Canvas_Vg_Container_Data *cd)
{
-#ifndef HAVE_THORV
+#ifndef HAVE_THORVG
if (!cd->blend.buffer) return;
if (cd->blend.pixels)
static void
_gradient_stop_set(Evas_Vg_Gradient *obj, const Efl_Gfx_Gradient_Stop *colors, unsigned int length)
{
- Tvg_Color_Stop *color_stops = NULL;
- Efl_Canvas_Vg_Gradient_Data *gd = NULL;
-
- unsigned int i = 0;
-
if (!obj) return;
- gd = efl_data_scope_get(obj, MY_CLASS);
- if (!gd || !gd->gradient) return;
+ Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, MY_CLASS);
+ if (!gd) return;
- color_stops = malloc(sizeof(Tvg_Color_Stop) * length);
- if (color_stops == NULL) return;
+ Tvg_Color_Stop *color_stops = malloc(sizeof(Tvg_Color_Stop) * length);
+ if (!color_stops) return;
+ unsigned int i = 0;
for (i = 0; i < length; ++i)
{
color_stops[i].offset = colors[i].offset;
static void
_gradient_stop_get(Evas_Vg_Gradient *obj, Efl_Gfx_Gradient_Stop **colors, unsigned int *length)
{
- Efl_Canvas_Vg_Gradient_Data *gd = NULL;
- gd = efl_data_scope_get(obj, MY_CLASS);
+ if (!obj || !colors || !length) return;
+
const Tvg_Color_Stop *stop = NULL;
uint32_t len = 0;
unsigned int i = 0;
- if (!obj || !colors || !length) return;
-
- gd = efl_data_scope_get(obj, MY_CLASS);
- if (!gd || !gd->gradient) return;
+ Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, MY_CLASS);
+ if (!gd) return;
tvg_gradient_get_color_stops(gd->gradient, &stop, &len);
*length = len;
_efl_canvas_vg_gradient_efl_duplicate_duplicate(const Eo *obj, Efl_Canvas_Vg_Gradient_Data *pd)
{
- Efl_VG *cn = NULL;
-
- cn = efl_duplicate(efl_super(obj, MY_CLASS));
+ Efl_VG *cn = efl_duplicate(efl_super(obj, MY_CLASS));
efl_gfx_gradient_stop_set(cn, pd->colors, pd->colors_count);
efl_gfx_gradient_spread_set(cn, pd->spread);
return cn;
evas_vg_gradient_spread_set(Evas_Vg_Gradient *obj, Evas_Vg_Gradient_Spread s)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Gradient_Data *gd = NULL;
if (!obj) return;
- gd = efl_data_scope_get(obj, MY_CLASS);
+ Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, MY_CLASS);
tvg_gradient_set_spread(gd->gradient, (Tvg_Stroke_Fill)s);
#else
efl_gfx_gradient_spread_set(obj, (Efl_Gfx_Gradient_Spread)s);
evas_vg_gradient_spread_get(Evas_Vg_Gradient *obj)
{
#ifdef HAVE_THORVG
- Tvg_Stroke_Fill fill = TVG_STROKE_FILL_PAD;
- Efl_Canvas_Vg_Gradient_Data *gd;
-
if (!obj) return EVAS_VG_GRADIENT_SPREAD_LAST;
- gd = efl_data_scope_get(obj, MY_CLASS);
+
+ Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, MY_CLASS);
if (!gd || !gd->gradient) return EVAS_VG_GRADIENT_SPREAD_LAST;
+ Tvg_Stroke_Fill fill = TVG_STROKE_FILL_PAD;
tvg_gradient_get_spread(gd->gradient, &fill);
return (Evas_Vg_Gradient_Spread)fill;
#else
Tvg_Paint *shape)
{
if (!gd || !shape) return;
+
+ //FIX_TVG: ignore the flag.... if nothing changed, do it needs to call again?
tvg_shape_set_linear_gradient(shape, gd->gradient);
}
#endif
static Eo *
_efl_canvas_vg_gradient_linear_efl_object_constructor(Eo *obj,
- Efl_Canvas_Vg_Gradient_Linear_Data *pd)
+ Efl_Canvas_Vg_Gradient_Linear_Data *pd)
{
Efl_Canvas_Vg_Node_Data *nd;
Efl_Canvas_Vg_Gradient_Data *gd;
gd->gradient_render_pre_tvg = _gradient_linear_render_pre_tvg;
gd->spread = EFL_GFX_GRADIENT_SPREAD_PAD;
gd->gradient = tvg_linear_gradient_new();
- gd->shape = NULL;
#endif
nd->data = pd;
evas_vg_gradient_linear_start_set(Evas_Vg_Gradient_Linear *obj, double x, double y)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Gradient_Data *gd = NULL;
- float x2 = 0.f, y2 = 0.f;
-
if (!obj) return;
- gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
- if (!gd || !gd->gradient) return;
+ Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
+ if (!gd) return;
+
+ float x2 = 0.f, y2 = 0.f;
tvg_linear_gradient_get(gd->gradient, NULL, NULL, &x2, &y2);
tvg_linear_gradient_set(gd->gradient, x, y, x2, y2);
evas_vg_gradient_linear_start_get(Evas_Vg_Gradient_Linear *obj, double *x, double *y)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Gradient_Data *gd = NULL;
- float x1 = 0.f, y1 = 0.f;
-
if (!obj) return;
- gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
- if (!gd || !gd->gradient) return;
+ Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
+ if (!gd) return;
+
+ float x1 = 0.f, y1 = 0.f;
tvg_linear_gradient_get(gd->gradient, &x1, &y1, NULL, NULL);
if (x) *x = x1;
if (y) *y = y1;
evas_vg_gradient_linear_end_set(Evas_Vg_Gradient_Linear *obj, double x, double y)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Gradient_Data *gd = NULL;
- float x1 = 0.f, y1 = 0.f;
-
if (!obj) return;
- gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
- if (!gd || !gd->gradient) return;
+ Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
+ if (!gd) return;
+
+ float x1 = 0.f, y1 = 0.f;
tvg_linear_gradient_get(gd->gradient, &x1, &y1, NULL, NULL);
tvg_linear_gradient_set(gd->gradient, x1, y1, x, y);
evas_vg_gradient_linear_end_get(Evas_Vg_Gradient_Linear *obj, double *x, double *y)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Gradient_Data *gd = NULL;
- float x2 = 0.f, y2 = 0.f;
-
if (!obj) return;
- gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
- if (!gd || !gd->gradient) return;
+ Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
+ if (!gd) return;
+
+ float x2 = 0.f, y2 = 0.f;
tvg_linear_gradient_get(gd->gradient, NULL, NULL, &x2, &y2);
if (x) *x = x2;
if (y) *y = y2;
gd->gradient_render_pre_tvg = _gradient_radial_render_pre_tvg;
gd->spread = EFL_GFX_GRADIENT_SPREAD_PAD;
gd->gradient = tvg_radial_gradient_new();
- gd->shape = NULL;
#endif
nd->data = pd;
evas_vg_gradient_radial_center_set(Evas_Vg_Gradient_Radial *obj, double x, double y)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Gradient_Data *gd = NULL;
- float r = 0.0f;
-
if (!obj) return;
- gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
- if (!gd || !gd->gradient) return;
+ Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
+ if (!gd) return;
+
+ float r = 0.0f;
tvg_radial_gradient_get(gd->gradient, NULL, NULL, &r);
tvg_radial_gradient_set(gd->gradient, x, y, r);
evas_vg_gradient_radial_center_get(Evas_Vg_Gradient_Radial *obj, double *x, double *y)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Gradient_Data *gd = NULL;
-
if (!obj) return;
- gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
- if (!gd || !gd->gradient) return;
+
+ Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
+ if (!gd) return;
float tx = 0.f, ty = 0.f;
tvg_radial_gradient_get(gd->gradient, &tx, &ty, NULL);
evas_vg_gradient_radial_radius_set(Evas_Vg_Gradient_Radial *obj, double r)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Gradient_Data *gd = NULL;
- float x = 0.0f, y = 0.0f;
-
if (!obj) return;
- gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
- if (!gd || !gd->gradient) return;
+ Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
+ if (!gd) return;
+
+ float x = 0.0f, y = 0.0f;
tvg_radial_gradient_get(gd->gradient, &x, &y, NULL);
tvg_radial_gradient_set(gd->gradient, x, y, r);
evas_vg_gradient_radial_radius_get(Evas_Vg_Gradient_Radial *obj)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Gradient_Data *gd = NULL;
- float r = 0.0f;
if (!obj) return 0.0;
- gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
- if (!gd || !gd->gradient) return 0.0;
+
+ Efl_Canvas_Vg_Gradient_Data *gd = efl_data_scope_get(obj, EFL_CANVAS_VG_GRADIENT_CLASS);
+ if (!gd) return 0.0;
+
+ float r = 0.0f;
tvg_radial_gradient_get(gd->gradient, NULL, NULL, &r);
return r;
#else
return efl_add(EFL_CANVAS_VG_GRADIENT_RADIAL_CLASS, parent);
}
-#include "efl_canvas_vg_gradient_radial.eo.c"
\ No newline at end of file
+#include "efl_canvas_vg_gradient_radial.eo.c"
#endif
#ifdef HAVE_THORVG
-void
-_convert_eina_to_tvg_mat_transpose(const Eina_Matrix3 *eina_mat, Tvg_Matrix *tvg_mat)
-{
- if (!eina_mat || !tvg_mat) return;
-
- tvg_mat->e11 = eina_mat->xx;
- tvg_mat->e21 = eina_mat->xy;
- tvg_mat->e31 = eina_mat->xz;
-
- tvg_mat->e12 = eina_mat->yx;
- tvg_mat->e22 = eina_mat->yy;
- tvg_mat->e32 = eina_mat->yz;
-
- tvg_mat->e13 = eina_mat->zx;
- tvg_mat->e23 = eina_mat->zy;
- tvg_mat->e33 = eina_mat->zz;
-}
static void
_efl_canvas_vg_image_render_pre_tvg(EINA_UNUSED Evas_Object_Protected_Data *vg_pd,
Efl_VG *obj,
tvg_paint_translate(pd->picture, nd->x, nd->y);
if (cTransform)
{
- _convert_eina_to_tvg_mat_transpose(cTransform, &trans_mat);
+ _convert_eina_to_tvg_mat(cTransform, &trans_mat);
trans_mat.e13 += nd->x;
trans_mat.e23 += nd->y;
tvg_paint_transform(pd->picture, &trans_mat);
efl_gfx_color_get(obj, NULL, NULL, NULL, &alpha);
EFL_CANVAS_VG_COMPUTE_ALPHA(c_r, c_g, c_b, c_a, alpha, nd);
- // TODO: apply color
+
+ //FIX_TVG: apply color
tvg_paint_set_opacity(pd->picture, alpha);
- if (scene)
- tvg_scene_push(scene, pd->picture);
- else if (canvas)
- tvg_canvas_push(canvas, pd->picture);
+ if (scene) tvg_scene_push(scene, pd->picture);
+ else if (canvas) tvg_canvas_push(canvas, pd->picture);
}
#endif
#ifndef HAVE_THORVG
nd->render_pre = _efl_canvas_vg_image_render_pre;
- efl_gfx_color_set(obj , 255, 255, 255, 255);
#else
nd->render_pre_tvg = _efl_canvas_vg_image_render_pre_tvg;
#endif
+ efl_gfx_color_set(obj , 255, 255, 255, 255);
+
return obj;
}
efl_unref(pd->buffer);
pd->buffer = NULL;
}
-#else
- if (pd->picture)
- {
- pd->picture = NULL;
- }
#endif
}
}
static void
-#ifdef HAVE_THORVG
-_efl_canvas_vg_node_efl_object_invalidate(Eo *obj, Efl_Canvas_Vg_Node_Data *pd EINA_UNUSED)
-#else
_efl_canvas_vg_node_efl_object_invalidate(Eo *obj, Efl_Canvas_Vg_Node_Data *pd)
-#endif
{
#ifndef HAVE_THORVG
if (pd->renderer)
pd->tvg_canvas_size.h = 0;
#endif
- pd->sync_render = EINA_FALSE;
eina_array_step_set(&pd->cleanup, sizeof(pd->cleanup), 8);
return eo_obj;
}
#ifdef HAVE_THORVG
static void
-_render_to_buffer_tvg(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Object_Data *pd,
+_render_to_tvg_buffer(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Object_Data *pd,
Efl_VG *root, int w EINA_UNUSED, int h EINA_UNUSED)
{
tvg_canvas_clear(pd->tvg_canvas, false);
if (!efl_isa(root, EFL_CANVAS_VG_GRADIENT_CLASS))
{
Efl_Canvas_Vg_Node_Data *nd = efl_data_scope_get(root, EFL_CANVAS_VG_NODE_CLASS);
- if (nd && nd->render_pre_tvg && pd)
- nd->render_pre_tvg(obj, root, nd, NULL, pd->tvg_canvas, NULL);
+ if (nd) nd->render_pre_tvg(obj, root, nd, NULL, pd->tvg_canvas, NULL);
}
tvg_canvas_update(pd->tvg_canvas);
if (tvg_canvas_draw(pd->tvg_canvas) == TVG_RESULT_SUCCESS)
- {
- tvg_canvas_sync(pd->tvg_canvas);
- }
+ tvg_canvas_sync(pd->tvg_canvas);
}
static void
_render_tvg_buffer_to_screen(Evas_Object_Protected_Data *obj, Efl_Canvas_Vg_Object_Data *pd,
- void *engine, void *output, void *context, void *surface,
- void *buffer, int x, int y, int w, int h, Eina_Bool do_async)
+ void *engine, void *output, void *context, void *surface,
+ void *buffer, int x, int y, int w, int h, Eina_Bool do_async)
{
- if (!obj || !pd || !buffer) return;
+ if (!buffer) return;
- if (!pd->im)
- {
- pd->im = ENFN->image_new_from_data(engine, w, h, buffer, 255,
- EVAS_COLORSPACE_ARGB8888);
- }
- else
- {
- pd->im = ENFN->image_data_put(engine, pd->im, buffer);
- }
+ //FIXE_TVG: Need to use the method original ector surface buffer (tbm or dynamic texture)
+ if (!pd->im) pd->im = ENFN->image_new_from_data(engine, w, h, buffer, 255, EVAS_COLORSPACE_ARGB8888);
+ else pd->im = ENFN->image_data_put(engine, pd->im, buffer);
ENFN->image_dirty_region(engine, pd->im, 0, 0, w, h);
+
+ //FIX_TVG: Check _render_buffer_to_screen(): async_unref variable.
ENFN->image_draw(engine, output, context, surface,
pd->im, 0, 0, w, h, x, y, w, h,
EINA_TRUE, do_async);
ENFN->context_render_op_set(engine, context, obj->cur->render_op);
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Node_Data *nd = NULL;
Eina_Size2D size;
- if (!pd || !pd->root) return;
- if (!obj || !obj->cur) return;
-
- nd = efl_data_scope_get(pd->root, EFL_CANVAS_VG_NODE_CLASS);
- if (!nd) return;
-
size.w = obj->cur->geometry.w;
size.h = obj->cur->geometry.h;
- if (size.w == 0 || size.h == 0) return;
-
+ //Reset canvas size
if (pd->tvg_canvas_size.w != size.w || pd->tvg_canvas_size.h != size.h)
{
pd->tvg_buffer = realloc(pd->tvg_buffer, size.w * size.h * sizeof(uint32_t));
ENFN->image_free(engine, pd->im);
pd->im = NULL;
}
-
- pd->changed = EINA_TRUE;
}
Vg_Cache_Entry *vg_entry = pd->vg_entry;
{
evas_cache_vg_entry_value_provider_update(vg_entry, efl_key_data_get(obj->object, "_vg_value_providers"));
+ //FIX_TVG: see _cache_vg_entry_render() how it handles the aspect ratio for optimal buffer size
if ((size.w != vg_entry->w) || (size.h != vg_entry->h))
{
vg_entry = evas_cache_vg_entry_resize(vg_entry, size.w, size.h);
Efl_VG *root = evas_cache_vg_tree_get(pd->vg_entry, pd->frame_idx);
if (!root) return;
- _render_to_buffer_tvg(obj, pd, root,
+ _render_to_tvg_buffer(obj, pd, root,
vg_entry->w,
vg_entry->h);
}
- if (pd->user_entry && pd->user_entry->root)
+ if (pd->user_entry)
{
- _render_to_buffer_tvg(obj, pd, pd->user_entry->root,
+ //FIX_TVG: see _user_vg_entry_render() how it handles the render region for optimal buffer size
+ _render_to_tvg_buffer(obj, pd, pd->user_entry->root,
obj->cur->geometry.w,
obj->cur->geometry.h);
}
#define MY_CLASS EFL_CANVAS_VG_SHAPE_CLASS
#ifdef HAVE_THORVG
-#include "evas_tvg_path_helpers.h"
+#include "evas_vg_path_helper.h"
#endif
#ifdef HAVE_THORVG
-#define SVG_PATH_NUM_LEN 7
#define DASH_PATTERN_EL_SIZE 2
-#define PTS_COUNT_LINE_MOVE 2
-#define PTS_COUNT_CUBIC 4
typedef enum
{
- EFL_TVG_PATH_CMD_TYPE_NO_BEZIER = 0, /**< For svg path commands other than listed below */
- EFL_TVG_PATH_CMD_TYPE_BEZIER_CUBIC, /**< For svg path commands S/s/C/c */
- EFL_TVG_PATH_CMD_TYPE_BEZIER_QUADRATIC /**< For svg path commands T/t/Q/q */
-} Efl_Tvg_Path_Cmd_Type;
-
-typedef struct _Tvg_Color Tvg_Color;
-struct _Tvg_Color
-{
- uint8_t r, g, b, a;
-};
+ PATH_CMD_TYPE_NO_BEZIER = 0, /**< For svg path commands other than listed below */
+ PATH_CMD_TYPE_BEZIER_CUBIC, /**< For svg path commands S/s/C/c */
+ PATH_CMD_TYPE_BEZIER_QUADRATIC /**< For svg path commands T/t/Q/q */
+} Path_Cmd_Type;
#endif
Tvg_Point curr_ctrl;
Tvg_Point curr;
Tvg_Point start;
- Efl_Tvg_Path_Cmd_Type cmd_prev;
+ Path_Cmd_Type cmd_prev;
//Storage for stroke's width passed in evas_vg_shape_stroke_width_set. Width variable is used to implement stroke
//scaling using scale * width
static Tvg_Paint*
_get_tvg_shape(Evas_Vg_Shape *obj)
{
- Efl_Canvas_Vg_Node_Data *nd = NULL;
- Efl_Canvas_Vg_Shape_Data *sd = NULL;
-
- nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
+ Efl_Canvas_Vg_Node_Data *nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
if (!nd) return NULL;
- sd = nd->data;
+ Efl_Canvas_Vg_Shape_Data *sd = nd->data;
if (!sd) return NULL;
return sd->shape;
static Efl_Canvas_Vg_Shape_Data*
_get_shape_data(Evas_Vg_Shape *obj)
{
- Efl_Canvas_Vg_Node_Data *nd = NULL;
-
- nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
+ Efl_Canvas_Vg_Node_Data *nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
if (!nd) return NULL;
return nd->data;
static void
_assign_current_point(Efl_Canvas_Vg_Shape_Data *sd, void *cmd EINA_UNUSED, double x, double y)
{
- if (!sd) return;
/* Assign current point of shape's svg path. If it's first append command
function additionally assign passed x,y as start point of shape's path */
sd->curr.x = x;
static void
_assign_current_ctrl_point(Efl_Canvas_Vg_Shape_Data *sd, double x, double y)
{
- if (!sd) return;
sd->curr_ctrl.x = x;
sd->curr_ctrl.y = y;
}
static void
-_assign_command(Efl_Canvas_Vg_Shape_Data *sd, Efl_Tvg_Path_Cmd_Type c_prev)
-{
- if (!sd) return;
- sd->cmd_prev = c_prev;
-}
-
-static void
_append_scubic_to(Evas_Vg_Shape *obj, double x, double y,
double ctrl_x1, double ctrl_y1)
{
sd = nd->data;
if (!sd) return;
- if (sd->cmd_prev == EFL_TVG_PATH_CMD_TYPE_BEZIER_CUBIC)
+ if (sd->cmd_prev == PATH_CMD_TYPE_BEZIER_CUBIC)
{
ctrl_x0 = 2 * sd->curr.x - sd->curr_ctrl.x;
ctrl_y0 = 2 * sd->curr.y - sd->curr_ctrl.y;
evas_vg_shape_append_cubic_to(obj, x, y, ctrl_x0, ctrl_y0, ctrl_x1, ctrl_y1);
_assign_current_ctrl_point(sd, ctrl_x, ctrl_y);
- _assign_command(sd, EFL_TVG_PATH_CMD_TYPE_BEZIER_QUADRATIC);
+ sd->cmd_prev = PATH_CMD_TYPE_BEZIER_QUADRATIC;
}
static void
sd = nd->data;
if (!sd) return;
- if (sd->cmd_prev == EFL_TVG_PATH_CMD_TYPE_BEZIER_QUADRATIC)
+ if (sd->cmd_prev == PATH_CMD_TYPE_BEZIER_QUADRATIC)
{
ctrl_x = 2 * sd->curr.x - sd->curr_ctrl.x;
ctrl_y = 2 * sd->curr.y - sd->curr_ctrl.y;
evas_vg_shape_append_cubic_to(obj, x, y, ctrl_x0, ctrl_y0, ctrl_x1, ctrl_y1);
_assign_current_ctrl_point(sd, ctrl_x, ctrl_y);
- _assign_command(sd, EFL_TVG_PATH_CMD_TYPE_BEZIER_QUADRATIC);
+ sd->cmd_prev = PATH_CMD_TYPE_BEZIER_QUADRATIC;
}
// code based on enesim/moonlight sources
var.sin_theta1 = sin_theta2;
}
_assign_current_ctrl_point(sd, ex, ey);
- _assign_command(sd, EFL_TVG_PATH_CMD_TYPE_NO_BEZIER);
+ sd->cmd_prev = PATH_CMD_TYPE_NO_BEZIER;
}
static void
const Evas_Vg_Shape *to,
double pos_map)
{
- Efl_Canvas_Vg_Shape_Data *sd = NULL;
- const Efl_Canvas_Vg_Shape_Data *sd_from = NULL;
- const Efl_Canvas_Vg_Shape_Data *sd_to = NULL;
- Efl_Canvas_Vg_Node_Data *nd = NULL;
- const Efl_Canvas_Vg_Node_Data *nd_from = NULL;
- const Efl_Canvas_Vg_Node_Data *nd_to = NULL;
+ if (!obj || !from || !to) return EINA_FALSE;
unsigned int i = 0;
int a = 0, r = 0, g = 0, b = 0;
Tvg_Stroke_Join join, join_to;
float width, width_to;
- if (!obj || !from || !to) return EINA_FALSE;
-
- nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
- nd_from = efl_data_scope_get(from, EFL_CANVAS_VG_NODE_CLASS);
- nd_to = efl_data_scope_get(to, EFL_CANVAS_VG_NODE_CLASS);
+ Efl_Canvas_Vg_Node_Data *nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
+ Efl_Canvas_Vg_Node_Data *nd_from = efl_data_scope_get(from, EFL_CANVAS_VG_NODE_CLASS);
+ Efl_Canvas_Vg_Node_Data *nd_to = efl_data_scope_get(to, EFL_CANVAS_VG_NODE_CLASS);
nd->x = _interpolate(nd_from->x, nd_to->x, pos_map);
nd->y = _interpolate(nd_from->y, nd_to->y, pos_map);
- sd = _get_shape_data(obj);
- sd_from = _get_shape_data((Evas_Vg_Shape*)from);
- sd_to = _get_shape_data((Evas_Vg_Shape*)to);
+ Efl_Canvas_Vg_Shape_Data *sd = _get_shape_data(obj);
+ Efl_Canvas_Vg_Shape_Data *sd_from = _get_shape_data(from);
+ Efl_Canvas_Vg_Shape_Data *sd_to = _get_shape_data(to);
- efl_gfx_color_get((const Eo*)from, &r, &g, &b, &a);
- efl_gfx_color_get((const Eo*)to, &to_r, &to_g, &to_b, &to_a);
+ efl_gfx_color_get(from, &r, &g, &b, &a);
+ efl_gfx_color_get(to, &to_r, &to_g, &to_b, &to_a);
a = _interpolate(a, to_a, pos_map);
r = _interpolate(r, to_r, pos_map);
if (dash && dash_to && dash_cnt > 0 && dash_cnt == dash_to_cnt)
{
for (i = 0; i < dash_cnt; ++i)
- {
- dash[i] = _interpolate(dash[i], dash_to[i], pos_map);
- }
+ dash[i] = _interpolate(dash[i], dash_to[i], pos_map);
}
tvg_shape_set_stroke_dash(sd->shape, dash, dash_cnt);
const Evas_Vg_Shape *to,
double pos_map)
{
- evas_vg_shape_reset(obj);
-
- Tvg_Paint *tvg_dest = NULL;
- Tvg_Paint *tvg_from = NULL;
- Tvg_Paint *tvg_to = NULL;
+ if (!obj || !from || !to) return EINA_FALSE;
Tvg_Path_Command *path_commands_from = NULL;
Tvg_Point *path_coords_from = NULL;
Tvg_Point *path_coords_dest = NULL;
unsigned int i = 0;
- if (!obj || !from || !to) return EINA_FALSE;
+ evas_vg_shape_reset(obj);
- tvg_dest = _get_tvg_shape(obj);
- tvg_from = _get_tvg_shape((Evas_Vg_Shape*)from);
- tvg_to = _get_tvg_shape((Evas_Vg_Shape*)to);
+ Tvg_Paint* tvg_dest = _get_tvg_shape(obj);
+ Tvg_Paint* tvg_from = _get_tvg_shape((Evas_Vg_Shape*)from);
+ Tvg_Paint* tvg_to = _get_tvg_shape((Evas_Vg_Shape*)to);
if (!tvg_dest || !tvg_from || !tvg_to) return EINA_FALSE;
_shape_properties_interpolate(obj, from, to, pos_map);
tvg_shape_append_path(tvg_dest, path_commands_from, cmds_count_from, path_coords_dest, pts_count_from);
free(path_coords_dest);
+
return EINA_TRUE;
}
#endif
#endif
#ifdef HAVE_THORVG
-void
-_convert_eina_to_tvg_mat(const Eina_Matrix3 *eina_mat, Tvg_Matrix *tvg_mat)
-{
- if (!eina_mat || !tvg_mat) return;
-
- tvg_mat->e11 = eina_mat->xx;
- tvg_mat->e12 = eina_mat->xy;
- tvg_mat->e13 = eina_mat->xz;
-
- tvg_mat->e21 = eina_mat->yx;
- tvg_mat->e22 = eina_mat->yy;
- tvg_mat->e23 = eina_mat->yz;
-
- tvg_mat->e31 = eina_mat->zx;
- tvg_mat->e32 = eina_mat->zy;
- tvg_mat->e33 = eina_mat->zz;
-}
-
static void
_efl_canvas_vg_shape_render_pre_tvg(EINA_UNUSED Evas_Object_Protected_Data *vg_pd,
Efl_VG *obj,
Eina_Matrix3 *pTransform,
void *canvas, void *scene)
{
+ if (!nd || !nd->data) return;
+
Efl_Canvas_Vg_Shape_Data *sd = NULL;
Tvg_Matrix trans_mat = { 0 };
-
int r = 0, g = 0, b = 0, a = 0;
- if (!nd || !nd->data) return;
nd->flags = EFL_GFX_CHANGE_FLAG_NONE;
sd = nd->data;
}
}
- if (scene)
- tvg_scene_push(scene, sd->shape);
- else if (canvas)
- tvg_canvas_push(canvas, sd->shape);
+ tvg_paint_set_opacity(sd->shape, nd->visibility ? 255 : 0);
- uint8_t opacity = nd->visibility ? 255 : 0;
- tvg_paint_set_opacity(sd->shape, opacity);
+ if (scene) tvg_scene_push(scene, sd->shape);
+ else if (canvas) tvg_canvas_push(canvas, sd->shape);
}
#endif
evas_vg_shape_stroke_scale_get(Evas_Vg_Shape *obj)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Shape_Data *sd = NULL;
-
- if (!obj) return 0.0;
+ if (!obj) return 0;
- sd = _get_shape_data(obj);
- if (!sd) return 0.0;
+ Efl_Canvas_Vg_Shape_Data *sd = _get_shape_data(obj);
+ if (!sd) return 0;
return sd->scale;
#else
evas_vg_shape_stroke_scale_set(Evas_Vg_Shape *obj, double s)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Shape_Data *sd = NULL;
if (!obj) return;
- sd = _get_shape_data(obj);
+ Efl_Canvas_Vg_Shape_Data *sd = _get_shape_data(obj);
if (!sd) return;
sd->scale = s;
evas_vg_shape_stroke_width_set(Evas_Vg_Shape *obj, double w)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Shape_Data *sd = NULL;
if (!obj) return;
- sd = _get_shape_data(obj);
+ Efl_Canvas_Vg_Shape_Data *sd = _get_shape_data(obj);
if (!sd) return;
sd->width = w;
evas_vg_shape_stroke_dash_get(Evas_Vg_Shape *obj, const Evas_Vg_Dash **dash, unsigned int *length)
{
#ifdef HAVE_THORVG
+ if (!dash || !length) return;
+
const float *dashPattern;
uint32_t cnt = 0;
-
- Evas_Vg_Dash *d = NULL;
-
unsigned int i = 0;
- if (!dash || !length) return;
tvg_shape_get_stroke_dash(_get_tvg_shape(obj), &dashPattern, &cnt);
if (!cnt) return;
- d = calloc(cnt / DASH_PATTERN_EL_SIZE, sizeof(Evas_Vg_Dash));
+ Evas_Vg_Dash *d = calloc(cnt / DASH_PATTERN_EL_SIZE, sizeof(Evas_Vg_Dash));
if (!d) return;
for (i = 0; i < cnt / DASH_PATTERN_EL_SIZE; ++i)
unsigned int pts_length = 0;
unsigned int i = 0, k = 0;
- Tvg_Path_Command *commands = NULL;
Tvg_Point *pts = NULL;
_get_path_length(op, &cmd_length, &pts_length);
- commands = malloc(sizeof(Tvg_Path_Command) * (cmd_length - 1));
+ Tvg_Path_Command* commands = malloc(sizeof(Tvg_Path_Command) * (cmd_length - 1));
if (!commands) return;
- pts = malloc(sizeof(Tvg_Point) * pts_length / 2);
+ Tvg_Point* pts = malloc(sizeof(Tvg_Point) * pts_length / 2);
if (!pts) return;
k = 0;
-
for (i = 0; i < pts_length; i += 2)
{
pts[k].x = points[i];
{
if (!op || !points) return;
#ifdef HAVE_THORVG
- Tvg_Paint *shape = NULL;
+ Evas_Vg_Path_Command *evas_cmds = NULL;
+ double *evas_pts = NULL;
+
+ Tvg_Paint *shape = _get_tvg_shape(obj);
const Tvg_Path_Command *tvg_cmds = NULL;
uint32_t cmds_len = 0;
+ tvg_shape_get_path_commands(shape, &tvg_cmds, &cmds_len);
const Tvg_Point *tvg_pts = NULL;
uint32_t pts_len = 0;
-
- unsigned int i = 0, j = 0;
-
- Evas_Vg_Path_Command *evas_cmds = NULL;
- double *evas_pts = NULL;
-
- shape = _get_tvg_shape(obj);
-
- tvg_shape_get_path_commands(shape, &tvg_cmds, &cmds_len);
tvg_shape_get_path_coords(shape, &tvg_pts, &pts_len);
if (!tvg_cmds || (cmds_len <= 0) || !tvg_pts || (pts_len <= 0))
return;
}
+ unsigned int i = 0, j = 0;
evas_cmds = (Evas_Vg_Path_Command*)malloc(sizeof(Evas_Vg_Path_Command) * (cmds_len + 1));
for (i = 0; i < cmds_len; ++i)
- {
- evas_cmds[i] = _get_evas_command(tvg_cmds[i]);
- }
+ evas_cmds[i] = _get_evas_command(tvg_cmds[i]);
evas_cmds[cmds_len] = EVAS_VG_PATH_COMMAND_END;
*op = evas_cmds;
evas_pts = (double*)malloc(sizeof(double) * pts_len * 2);
- i = 0;
for (i = 0; i < pts_len; ++i)
{
evas_vg_shape_current_get(Evas_Vg_Shape *obj, double *x, double *y)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Node_Data *nd = NULL;
- Efl_Canvas_Vg_Shape_Data *sd = NULL;
-
if (!obj) return;
- nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
+ Efl_Canvas_Vg_Node_Data *nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
if (!nd) return;
- sd = nd->data;
+ Efl_Canvas_Vg_Shape_Data *sd = nd->data;
if (!sd) return;
if (x) *x = sd->curr.x;
evas_vg_shape_current_ctrl_get(Evas_Vg_Shape *obj, double *x, double *y)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Node_Data *nd = NULL;
- Efl_Canvas_Vg_Shape_Data *sd = NULL;
-
if (!obj) return;
- nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
+ Efl_Canvas_Vg_Node_Data *nd = efl_data_scope_get(obj, EFL_CANVAS_VG_NODE_CLASS);
if (!nd) return;
- sd = nd->data;
+ Efl_Canva_Vg_Shape_Data *sd = nd->data;
if (!sd) return;
if (x) *x = sd->curr_ctrl.x;
evas_vg_shape_append_move_to(Evas_Vg_Shape *obj, double x, double y)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Shape_Data *sd = NULL;
-
if (!obj) return;
- sd = _get_shape_data(obj);
+
+ Efl_Canva_Vg_Shape_Data *sd = _get_shape_data(obj);
if (!sd || !sd->shape) return;
tvg_shape_move_to(sd->shape, x, y);
_assign_current_point(sd, NULL, x, y);
- _assign_command(sd, EFL_TVG_PATH_CMD_TYPE_NO_BEZIER);
+ sd->cmd_prev = PATH_CMD_TYPE_NO_BEZIER;
#else
efl_gfx_path_append_move_to(obj, x, y);
#endif
evas_vg_shape_append_line_to(Evas_Vg_Shape *obj, double x, double y)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Shape_Data *sd = NULL;
-
if (!obj) return;
- sd = _get_shape_data(obj);
+
+ Efl_Canvas_Vg_Shape_Data *sd = _get_shape_data(obj);
if (!sd || !sd->shape) return;
tvg_shape_line_to(sd->shape, x, y);
_assign_current_point(sd, NULL, x, y);
- _assign_command(sd, EFL_TVG_PATH_CMD_TYPE_NO_BEZIER);
+ sd->cmd_prev = PATH_CMD_TYPE_NO_BEZIER;
#else
efl_gfx_path_append_line_to(obj, x, y);
#endif
evas_vg_shape_append_cubic_to(Evas_Vg_Shape *obj, double x, double y, double ctrl_x0, double ctrl_y0, double ctrl_x1, double ctrl_y1)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Shape_Data *sd = NULL;
-
if (!obj) return;
- sd = _get_shape_data(obj);
+
+ Efl_Canvas_Vg_Shape_Data *sd = _get_shape_data(obj);
if (!sd || !sd->shape) return;
tvg_shape_cubic_to(sd->shape, ctrl_x0, ctrl_y0, ctrl_x1, ctrl_y1, x, y);
_assign_current_point(sd, NULL, x, y);
_assign_current_ctrl_point(sd, ctrl_x1, ctrl_y1);
- _assign_command(sd, EFL_TVG_PATH_CMD_TYPE_BEZIER_CUBIC);
+ sd->cmd_prev = PATH_CMD_TYPE_BEZIER_CUBIC;
#else
efl_gfx_path_append_cubic_to(obj, ctrl_x0, ctrl_y0, ctrl_x1, ctrl_y1, x, y);
#endif
#ifndef HAVE_THORVG
efl_gfx_path_append_arc(obj, x, y, w, h, start_angle, sweep_length);
#else
+ if (!obj) return;
+
+ Efl_Canvas_Vg_Shape_Data *sd = _get_shape_data(obj);
+ if (!sd || !sd->shape) return;
+
Efl_Canvas_Vg_Shape_Data *sd = NULL;
const Tvg_Path_Command *cmds = NULL;
uint32_t cmds_count = 0;
//FIX_TVG: we can revise this with tvg appendArc() way.
Point curve_start = _curves_for_arc(x, y, w, h, start_angle, sweep_length, pts, &point_count);
- if (!obj) return;
- sd = _get_shape_data(obj);
- if (!sd || !sd->shape) return;
-
tvg_shape_get_path_commands(sd->shape, &cmds, &cmds_count);
if (cmds_count && cmds[cmds_count - 1] != TVG_PATH_COMMAND_CLOSE)
{
evas_vg_shape_append_circle(Evas_Vg_Shape *obj, double x, double y, double radius)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Shape_Data *sd = NULL;
-
if (!obj) return;
- sd = _get_shape_data(obj);
+
+ Efl_Canva_Vg_Shape_Data *sd = _get_shape_data(obj);
if (!sd || !sd->shape) return;
tvg_shape_append_circle(sd->shape, x, y, radius, radius);
evas_vg_shape_append_ellipse(Evas_Vg_Shape *obj, double cx, double cy, double rx, double ry)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Shape_Data *sd = NULL;
-
if (!obj) return;
- sd = _get_shape_data(obj);
+
+ Efl_Canvas_Vg_Shape_Data *sd = _get_shape_data(obj);
if (!sd || !sd->shape) return;
+
tvg_shape_append_circle(sd->shape, cx, cy, rx, ry);
_assign_current_point(sd, NULL, cx, cy - ry);
#else
evas_vg_shape_append_rect(Evas_Vg_Shape *obj, double x, double y, double w, double h, double rx, double ry)
{
#ifdef HAVE_THORVG
- Efl_Canvas_Vg_Shape_Data *sd = NULL;
-
if (!obj) return;
- sd = _get_shape_data(obj);
+
+ Efl_Canvas_Vg_Shape_Data *sd = _get_shape_data(obj);
if (!sd || !sd->shape) return;
tvg_shape_append_rect(sd->shape, x, y, w, h, rx, ry);
evas_vg_shape_append_svg_path(Evas_Vg_Shape *obj, const char *svg_path_data)
{
#ifdef HAVE_THORVG
+ #define SVG_PATH_NUM_LEN 7
+
Efl_Canvas_Vg_Shape_Data *sd = _get_shape_data(obj);
- Efl_Tvg_Shape_Svg_Path svg_path = { 0 };
+ Shape_Svg_Path svg_path = { 0 };
double number_array[SVG_PATH_NUM_LEN] = {0};
int number_count = 0;
#define PATH_KAPPA 0.5522847498
-typedef struct _Efl_Tvg_Shape_Svg_Path Efl_Tvg_Shape_Svg_Path;
-typedef struct _Arc_To_Init_Variables Arc_To_Init_Variables;
-typedef struct _Point Point;
-
-struct _Efl_Tvg_Shape_Svg_Path {
+typedef struct _Shape_Svg_Path {
char *svg_path_data;
- Tvg_Path_Command *cmds;
+ Tvg_Path_Commtand *cmds;
Tvg_Point *pts;
uint32_t cmds_cnt;
uint32_t pts_cnt;
uint32_t cmds_reserved;
uint32_t pts_reserved;
-};
+} Shape_Svg_Path;
struct _Arc_To_Init_Variables {
double cx, cy;
double sin_phi_rx, sin_phi_ry;
double cos_theta1, sin_theta1;
int segments;
-};
+} Arc_To_Init_Variables;
-struct _Point {
+typedef struct _Point {
double x;
double y;
-};
+} Point;
static char *
_skipcomma(const char *content)
}
static Eina_Bool
-_svg_path_grow(Efl_Tvg_Shape_Svg_Path *svg_path, int command_length)
+_svg_path_grow(Shape_Svg_Path *svg_path, int command_length)
{
if (svg_path->pts_cnt + command_length > svg_path->pts_reserved)
{
}
static void
-_process_command(Efl_Tvg_Shape_Svg_Path *svg_path, char c, double *pts,
+_process_command(Shape_Svg_Path *svg_path, char c, double *pts,
int *number_array, double *cur_x, double *cur_y,
double *cur_ctl_x, double *cur_ctl_y,
double *start_x, double *start_y,
{
Eina_Matrix3 *m;
Efl_Canvas_Vg_Interpolation *intp;
-
-#ifndef HAVE_THORVG
- Ector_Renderer *renderer;
-#endif
-
Efl_VG *vg_obj;
Efl_Canvas_Vg_Object_Data *vd;
+#ifdef HAVE_THORVG
+ void (*render_pre_tvg)(Evas_Object_Protected_Data *vg_pd, Efl_VG *node, Efl_Canvas_Vg_Node_Data *nd, Eina_Matrix3 *ptransform, void *canvas, void *scene);
+#else
+ Ector_Renderer *renderer;
+
void (*render_pre)(Evas_Object_Protected_Data *vg_pd, Efl_VG *node,
Efl_Canvas_Vg_Node_Data *nd,
void *engine, void *output, void *contenxt, Ector_Surface *surface,
Eina_Matrix3 *ptransform, int opacity, Ector_Buffer *comp, Efl_Gfx_Vg_Composite_Method comp_method, void *data);
-
-#ifdef HAVE_THORVG
- void (*render_pre_tvg)(Evas_Object_Protected_Data *vg_pd, Efl_VG *node, Efl_Canvas_Vg_Node_Data *nd, Eina_Matrix3 *ptransform, void *canvas, void *scene);
- void (*render_tvg)(Evas_Object_Protected_Data *vg_pd, Efl_VG *node, Efl_Canvas_Vg_Node_Data *nd, void *canvas);
#endif
void *data;
//
#ifdef HAVE_THORVG
-void _convert_eina_to_tvg_mat(const Eina_Matrix3 *eina_mat, Tvg_Matrix *tvg_mat);
+static inline void
+_convert_eina_to_tvg_mat(const Eina_Matrix3 *eina_mat, Tvg_Matrix *tvg_mat)
+{
+ if (!eina_mat || !tvg_mat) return;
+
+ tvg_mat->e11 = eina_mat->xx;
+ tvg_mat->e12 = eina_mat->xy;
+ tvg_mat->e13 = eina_mat->xz;
+
+ tvg_mat->e21 = eina_mat->yx;
+ tvg_mat->e22 = eina_mat->yy;
+ tvg_mat->e23 = eina_mat->yz;
+
+ tvg_mat->e31 = eina_mat->zx;
+ tvg_mat->e32 = eina_mat->zy;
+ tvg_mat->e33 = eina_mat->zz;
+}
#endif
static inline void
vg_cache->ref--;
#ifdef HAVE_THORVG
- tvg_engine_term(TVG_ENGINE_SW | TVG_ENGINE_GL);
+ tvg_engine_term(TVG_ENGINE_SW);
#endif
if (vg_cache->ref > 0) return;
// apply the fill style property
#ifndef HAVE_THORVG
- //TODO: not supported by evas api?
+ //FIX_TVG: replace?
efl_gfx_shape_fill_rule_set(vg, style->fill.fill_rule);
#endif
evas_vg_shape_stroke_width_set(vg, style->stroke.width);
// apply the fill style property
#ifndef HAVE_THORVG
- //TODO: fill rule api missing in evas
+ //FIX_TVG:: replace?
style->fill.fill_rule = efl_gfx_shape_fill_rule_get(vg);
#endif
style->fill.paint.none = EINA_FALSE;
projects / platform / upstream / efl.git / commitdiff