Eet_Data_Descriptor *eet;
Eet_Data_Descriptor_Class eetc;
- EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eetc, Efl_Gfx_Gradient_Stop);
+ EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eetc, Evas_Vg_Gradient_Stop);
eet = eet_data_descriptor_stream_new(&eetc);
- EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Efl_Gfx_Gradient_Stop, "offset", offset, EET_T_DOUBLE);
- EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Efl_Gfx_Gradient_Stop, "r", r, EET_T_INT);
- EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Efl_Gfx_Gradient_Stop, "g", g, EET_T_INT);
- EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Efl_Gfx_Gradient_Stop, "b", b, EET_T_INT);
- EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Efl_Gfx_Gradient_Stop, "a", a, EET_T_INT);
+ EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Evas_Vg_Gradient_Stop, "offset", offset, EET_T_DOUBLE);
+ EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Evas_Vg_Gradient_Stop, "r", r, EET_T_INT);
+ EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Evas_Vg_Gradient_Stop, "g", g, EET_T_INT);
+ EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Evas_Vg_Gradient_Stop, "b", b, EET_T_INT);
+ EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Evas_Vg_Gradient_Stop, "a", a, EET_T_INT);
return eet;
}
eet = eet_data_descriptor_stream_new(&eetc);
eet_gradient = _eet_for_style_gradient();
- EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eetc_dash, Efl_Gfx_Dash);
+ EET_EINA_STREAM_DATA_DESCRIPTOR_CLASS_SET(&eetc_dash, Evas_Vg_Dash);
eet_dash = eet_data_descriptor_stream_new(&eetc_dash);
- EET_DATA_DESCRIPTOR_ADD_BASIC(eet_dash, Efl_Gfx_Dash, "length", length, EET_T_DOUBLE);
- EET_DATA_DESCRIPTOR_ADD_BASIC(eet_dash, Efl_Gfx_Dash, "gap", gap, EET_T_DOUBLE);
+ EET_DATA_DESCRIPTOR_ADD_BASIC(eet_dash, Evas_Vg_Dash, "length", length, EET_T_DOUBLE);
+ EET_DATA_DESCRIPTOR_ADD_BASIC(eet_dash, Evas_Vg_Dash, "gap", gap, EET_T_DOUBLE);
EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Svg_Style_Property, "r", r, EET_T_INT);
EET_DATA_DESCRIPTOR_ADD_BASIC(eet, Svg_Style_Property, "g", g, EET_T_INT);
static void
_svg_style_gradient_free(Svg_Style_Gradient *grad)
{
- Efl_Gfx_Gradient_Stop *stop;
+ Evas_Vg_Gradient_Stop *stop;
if (!grad) return;
_apply_gradient_property(Svg_Style_Gradient *g, Efl_VG *vg, Efl_VG *parent, Vg_File_Data *vg_data, int fill_opacity)
{
Efl_VG *grad_obj = NULL;
- Efl_Gfx_Gradient_Stop *stops, *stop;
+ Evas_Vg_Gradient_Stop *stops, *stop;
int stop_count = 0, i = 0;
Eina_List *l;
Eina_Matrix3 m; //for bbox translation
//TODO: apply actual sizes (imporve bounds_get function?)...
//for example with figures and paths
+
+#ifndef HAVE_THORVG
if (!g->user_space)
efl_gfx_path_bounds_get(vg, &r);
else
r.w = vg_data->view_box.w;
r.h = vg_data->view_box.h;
}
+#else
+ //TODO: in thorvg mode we are not able to use efl_gfx_api, and evas
+ //module don't provide nothing similar. Probably we have to get
+ //path here and calcluate path bounds internally
+ r.w = vg_data->view_box.w;
+ r.h = vg_data->view_box.h;
+#endif
if (g->type == SVG_LINEAR_GRADIENT)
{
- grad_obj = efl_add(EFL_CANVAS_VG_GRADIENT_LINEAR_CLASS, parent);
+ grad_obj = evas_vg_gradient_linear_add(parent);
if (g->use_percentage)
{
NULL, NULL, NULL);
}
- efl_gfx_gradient_linear_start_set(grad_obj, g->linear->x1, g->linear->y1);
- efl_gfx_gradient_linear_end_set(grad_obj, g->linear->x2, g->linear->y2);
+ evas_vg_gradient_linear_start_set(grad_obj, g->linear->x1, g->linear->y1);
+ evas_vg_gradient_linear_end_set(grad_obj, g->linear->x2, g->linear->y2);
}
else if (g->type == SVG_RADIAL_GRADIENT)
{
g->radial->fx = g->radial->fx * r.w + r.x;
g->radial->fy = g->radial->fy * r.h + r.y;
}
- grad_obj = efl_add(EFL_CANVAS_VG_GRADIENT_RADIAL_CLASS, parent);
- efl_gfx_gradient_radial_center_set(grad_obj, g->radial->cx, g->radial->cy);
- efl_gfx_gradient_radial_radius_set(grad_obj, g->radial->r);
- efl_gfx_gradient_radial_focal_set(grad_obj, g->radial->fx, g->radial->fy);
+
+ grad_obj = evas_vg_gradient_radial_add(parent);
+
+ evas_vg_gradient_radial_center_set(grad_obj, g->radial->cx, g->radial->cy);
+ evas_vg_gradient_radial_radius_set(grad_obj, g->radial->r);
+ evas_vg_gradient_radial_focal_set(grad_obj, g->radial->fx, g->radial->fy);
/* in case of objectBoundingBox it need proper scaling */
if (!g->user_space)
scale_reversed_X = ((double) r.w) / r.h;
}
+ grad_geom.x = vg_data->view_box.x;
+ grad_geom.y = vg_data->view_box.y;
+ grad_geom.w = vg_data->view_box.w;
+ grad_geom.h = vg_data->view_box.h;
+
+#ifndef HAVE_THORVG
efl_gfx_path_bounds_get(grad_obj, &grad_geom);
+#endif
double cy = ((double) grad_geom.h) * 0.5 + grad_geom.y;
double cy_scaled = (((double) grad_geom.h) * 0.5) * scale_reversed_Y;
}
// apply common prperty
- efl_gfx_gradient_spread_set(grad_obj, g->spread);
+ evas_vg_gradient_spread_set(grad_obj, g->spread);
// update the stops
stop_count = eina_list_count(g->stops);
{
double opacity;
double fopacity = ((double) fill_opacity) / 255; //fill opacity if any exists.
- stops = calloc(stop_count, sizeof(Efl_Gfx_Gradient_Stop));
+ stops = calloc(stop_count, sizeof(Evas_Vg_Gradient_Stop));
i = 0;
+
EINA_LIST_FOREACH(g->stops, l, stop)
{
// Use premultiplied color
stops[i].offset = stop->offset;
i++;
}
- efl_gfx_gradient_stop_set(grad_obj, stops, stop_count);
+ evas_vg_gradient_stop_set(grad_obj, stops, stop_count);
free(stops);
}
+
return grad_obj;
}
// apply the transformation
if (node->transform) efl_canvas_vg_node_transformation_set(vg, node->transform);
- if (node->type != SVG_NODE_DOC && !node->display) efl_gfx_entity_visible_set(vg, EINA_FALSE);
+ if (node->type != SVG_NODE_DOC && !node->display) evas_vg_node_visible_set(vg, EINA_FALSE);
if (node->type == SVG_NODE_DOC) return;
{
// apply the current style color
float fa = ((float) style->fill.opacity / 255);
- efl_gfx_color_set(vg, ((float) style->r) * fa, ((float) style->g) * fa, ((float) style->b) * fa,
+ evas_vg_node_color_set(vg, ((float) style->r) * fa, ((float) style->g) * fa, ((float) style->b) * fa,
style->fill.opacity);
}
else
{
// apply the fill color
float fa = ((float) style->fill.opacity / 255);
- efl_gfx_color_set(vg, ((float) style->fill.paint.r) * fa, ((float) style->fill.paint.g) * fa,
+ evas_vg_node_color_set(vg, ((float) style->fill.paint.r) * fa, ((float) style->fill.paint.g) * fa,
((float) style->fill.paint.b) * fa, style->fill.opacity);
}
if (style->opacity < 255)
{
int r, g, b, a;
- efl_gfx_color_get(vg, &r, &g, &b, &a);
+ evas_vg_node_color_get(vg, &r, &g, &b, &a);
float fa = ((float) style->opacity / 255);
- efl_gfx_color_set(vg, ((float) r) * fa, ((float) g) * fa, ((float) b) * fa, ((float) a) * fa);
+ evas_vg_node_color_set(vg, ((float) r) * fa, ((float) g) * fa, ((float) b) * fa, ((float) a) * fa);
}
if (node->type == SVG_NODE_G || node->type == SVG_NODE_CLIP_PATH) return;
// apply the fill style property
+#ifndef HAVE_THORVG
+ //TODO: not supported by evas api?
efl_gfx_shape_fill_rule_set(vg, style->fill.fill_rule);
- efl_gfx_shape_stroke_width_set(vg, style->stroke.width);
- efl_gfx_shape_stroke_cap_set(vg, style->stroke.cap);
- efl_gfx_shape_stroke_join_set(vg, style->stroke.join);
- efl_gfx_shape_stroke_scale_set(vg, style->stroke.scale);
+#endif
+ evas_vg_shape_stroke_width_set(vg, style->stroke.width);
+ evas_vg_shape_stroke_cap_set(vg, style->stroke.cap);
+ evas_vg_shape_stroke_join_set(vg, style->stroke.join);
+ evas_vg_shape_stroke_scale_set(vg, style->stroke.scale);
+
if (style->stroke.dash && style->stroke.dash_count > 0)
- efl_gfx_shape_stroke_dash_set(vg, style->stroke.dash, style->stroke.dash_count);
+ evas_vg_shape_stroke_dash_set(vg, style->stroke.dash, style->stroke.dash_count);
// if stroke property is NULL then do nothing
if (style->stroke.paint.none)
else if (style->stroke.paint.cur_color)
{
// apply the current style color
- efl_gfx_shape_stroke_color_set(vg, style->r, style->g,
+ evas_vg_shape_stroke_color_set(vg, style->r, style->g,
style->b, style->stroke.opacity);
}
else
{
// apply the stroke color
- efl_gfx_shape_stroke_color_set(vg, style->stroke.paint.r, style->stroke.paint.g,
+ evas_vg_shape_stroke_color_set(vg, style->stroke.paint.r, style->stroke.paint.g,
style->stroke.paint.b, style->stroke.opacity);
}
if (style->opacity < 255)
{
int r, g, b, a;
- efl_gfx_shape_stroke_color_get(vg, &r, &g, &b, &a);
+ evas_vg_shape_stroke_color_get(vg, &r, &g, &b, &a);
float fa = ((float) style->opacity / 255);
- efl_gfx_shape_stroke_color_set(vg, ((float) r) * fa, ((float) g) * fa, ((float) b) * fa, ((float) a) * fa);
+ evas_vg_shape_stroke_color_set(vg, ((float) r) * fa, ((float) g) * fa, ((float) b) * fa, ((float) a) * fa);
}
}
if (size < 2) return;
- efl_gfx_path_append_move_to(vg, array[0], array[1]);
+ evas_vg_shape_append_move_to(vg, array[0], array[1]);
for (i=2; i < size; i+=2)
- efl_gfx_path_append_line_to(vg, array[i], array[i+1]);
+ evas_vg_shape_append_line_to(vg, array[i], array[i+1]);
if (polygon)
- efl_gfx_path_append_close(vg);
+ evas_vg_shape_append_close(vg);
}
static Efl_VG *
{
Efl_VG *vg = vg_common_create_vg_node_helper(child, comp_vg_container, vg_data);
// clippath does not require color blending. That's why we keep 255 opacity.
- efl_gfx_color_set(vg, 255, 255, 255, 255);
+ evas_vg_node_color_set(vg, 255, 255, 255, 255);
}
// Composition matte alpha
+ //TODO: not supported yet.
efl_canvas_vg_node_comp_method_set(comp_parent, comp_vg_container, EFL_GFX_VG_COMPOSITE_METHOD_MATTE_ALPHA);
parent = comp_parent; // replace parent
break;
case SVG_NODE_PATH:
vg = efl_add(EFL_CANVAS_VG_SHAPE_CLASS, parent);
- efl_gfx_path_append_svg_path(vg, node->node.path.path);
+ evas_vg_shape_append_svg_path(vg, node->node.path.path);
break;
case SVG_NODE_POLYGON:
vg = efl_add(EFL_CANVAS_VG_SHAPE_CLASS, parent);
break;
case SVG_NODE_ELLIPSE:
vg = efl_add(EFL_CANVAS_VG_SHAPE_CLASS, parent);
- efl_gfx_path_append_arc(vg, node->node.ellipse.cx - node->node.ellipse.rx,
+ evas_vg_shape_append_arc(vg, node->node.ellipse.cx - node->node.ellipse.rx,
node->node.ellipse.cy - node->node.ellipse.ry,
2*node->node.ellipse.rx, 2*node->node.ellipse.ry, 0, 360);
- efl_gfx_path_append_close(vg);
+ evas_vg_shape_append_close(vg);
break;
case SVG_NODE_CIRCLE:
vg = efl_add(EFL_CANVAS_VG_SHAPE_CLASS, parent);
- efl_gfx_path_append_circle(vg, node->node.circle.cx, node->node.circle.cy, node->node.circle.r);
+ evas_vg_shape_append_circle(vg, node->node.circle.cx, node->node.circle.cy, node->node.circle.r);
break;
case SVG_NODE_RECT:
vg = efl_add(EFL_CANVAS_VG_SHAPE_CLASS, parent);
- efl_gfx_path_append_rect(vg, node->node.rect.x, node->node.rect.y, node->node.rect.w, node->node.rect.h,
+ evas_vg_shape_append_rect(vg, node->node.rect.x, node->node.rect.y, node->node.rect.w, node->node.rect.h,
node->node.rect.rx, node->node.rect.ry);
break;
case SVG_NODE_LINE:
vg = efl_add(EFL_CANVAS_VG_SHAPE_CLASS, parent);
- efl_gfx_path_append_move_to(vg, node->node.line.x1, node->node.line.y1);
- efl_gfx_path_append_line_to(vg, node->node.line.x2, node->node.line.y2);
+ evas_vg_shape_append_move_to(vg, node->node.line.x1, node->node.line.y1);
+ evas_vg_shape_append_line_to(vg, node->node.line.x2, node->node.line.y2);
break;
case SVG_NODE_CUSTOME_COMMAND:
vg = efl_add(EFL_CANVAS_VG_SHAPE_CLASS, parent);
- efl_gfx_path_set(vg, node->node.command.commands, node->node.command.points);
+ evas_vg_shape_path_set(vg, node->node.command.commands, node->node.command.points);
break;
default:
break;
// default stroke width is 1
node->style->stroke.width = 1;
// default line cap is butt
- node->style->stroke.cap = EFL_GFX_CAP_BUTT;
+ node->style->stroke.cap = EVAS_VG_CAP_BUTT;
// default line join is miter
- node->style->stroke.join = EFL_GFX_JOIN_MITER;
+ node->style->stroke.join = EVAS_VG_JOIN_MITER;
node->style->stroke.scale = 1.0;
node->style->opacity = 255;
static Svg_Style_Gradient*
_create_gradient_node(Efl_VG *vg)
{
- const Efl_Gfx_Gradient_Stop *stops = NULL;
- Efl_Gfx_Gradient_Stop *new_stop;
+ const Evas_Vg_Gradient_Stop *stops = NULL;
+ Evas_Vg_Gradient_Stop *new_stop;
+
unsigned int count = 0, i;
Svg_Style_Gradient *grad = calloc(1, sizeof(Svg_Style_Gradient));
EINA_SAFETY_ON_NULL_RETURN_VAL(grad, NULL);
- grad->spread = efl_gfx_gradient_spread_get(vg);
- efl_gfx_gradient_stop_get(vg, &stops, &count);
+ grad->spread = evas_vg_gradient_spread_get(vg);
+ evas_vg_gradient_stop_get(vg, &stops, &count);
+
for (i = 0; i < count; i++)
{
- new_stop = calloc(1, sizeof(Efl_Gfx_Gradient_Stop));
+ new_stop = calloc(1, sizeof(Evas_Vg_Gradient_Stop));
if (!new_stop) goto oom_error;
- memcpy(new_stop, stops, sizeof(Efl_Gfx_Gradient_Stop));
+ memcpy(new_stop, stops, sizeof(Evas_Vg_Gradient_Stop));
grad->stops = eina_list_append(grad->stops, new_stop);
stops++;
}
+
if (efl_isa(vg, EFL_CANVAS_VG_GRADIENT_LINEAR_CLASS))
{
grad->type = SVG_LINEAR_GRADIENT;
grad->linear = calloc(1, sizeof(Svg_Linear_Gradient));
if (!grad->linear) goto oom_error;
- efl_gfx_gradient_linear_start_get(vg, &grad->linear->x1, &grad->linear->y1);
- efl_gfx_gradient_linear_end_get(vg, &grad->linear->x2, &grad->linear->y2);
+
+ evas_vg_gradient_linear_start_get(vg, &grad->linear->x1, &grad->linear->y1);
+ evas_vg_gradient_linear_end_get(vg, &grad->linear->x2, &grad->linear->y2);
}
else
{
grad->type = SVG_RADIAL_GRADIENT;
grad->radial = calloc(1, sizeof(Svg_Radial_Gradient));
if (!grad->radial) goto oom_error;
- efl_gfx_gradient_radial_center_get(vg, &grad->radial->cx, &grad->radial->cy);
- efl_gfx_gradient_radial_focal_get(vg, &grad->radial->fx, &grad->radial->fy);
- grad->radial->r = efl_gfx_gradient_radial_radius_get(vg);
+ evas_vg_gradient_radial_center_get(vg, &grad->radial->cx, &grad->radial->cy);
+ evas_vg_gradient_radial_focal_get(vg, &grad->radial->fx, &grad->radial->fy);
+ grad->radial->r = evas_vg_gradient_radial_radius_get(vg);
}
+
grad->use_percentage = EINA_FALSE;
return grad;
node->id = eina_stringshare_add(id);
}
- node->display = efl_gfx_entity_visible_get(vg);
+ node->display = evas_vg_node_visible_get(vg);
if (node->type == SVG_NODE_G) return;
// apply the fill style property
+#ifndef HAVE_THORVG
+ //TODO: fill rule api missing in evas
style->fill.fill_rule = efl_gfx_shape_fill_rule_get(vg);
+#endif
style->fill.paint.none = EINA_FALSE;
+
if (efl_canvas_vg_shape_fill_get(vg))
{
// if the fill has gradient then apply.
}
else
{
- efl_gfx_color_get(vg, &style->fill.paint.r, &style->fill.paint.g,
+ evas_vg_node_color_get(vg, &style->fill.paint.r, &style->fill.paint.g,
&style->fill.paint.b, &style->fill.opacity);
}
else
{
// apply the stroke color
- efl_gfx_shape_stroke_color_get(vg, &style->stroke.paint.r, &style->stroke.paint.g,
+ evas_vg_shape_stroke_color_get(vg, &style->stroke.paint.r, &style->stroke.paint.g,
&style->stroke.paint.b, &style->stroke.opacity);
}
- style->stroke.width = efl_gfx_shape_stroke_width_get(vg);
- style->stroke.cap = efl_gfx_shape_stroke_cap_get(vg);
- style->stroke.join = efl_gfx_shape_stroke_join_get(vg);
- style->stroke.scale = efl_gfx_shape_stroke_scale_get(vg);
+ style->stroke.width = evas_vg_shape_stroke_width_get(vg);
+ style->stroke.cap = evas_vg_shape_stroke_cap_get(vg);
+ style->stroke.join = evas_vg_shape_stroke_join_get(vg);
+ style->stroke.scale = evas_vg_shape_stroke_scale_get(vg);
}
static void
Eina_Iterator *it;
Efl_VG *child;
Svg_Node *svg_node;
- const Efl_Gfx_Path_Command *commands;
+ const Evas_Vg_Path_Command *commands;
unsigned int points_count, commands_count;
const double *points;
else if (efl_isa(vg, EFL_CANVAS_VG_SHAPE_CLASS))
{
svg_node = _create_node(parent, SVG_NODE_CUSTOME_COMMAND);
- efl_gfx_path_get(vg, &commands, &points);
- efl_gfx_path_length_get(vg, &commands_count, &points_count);
+ evas_vg_shape_path_get(vg, &commands, &points);
+ evas_vg_shape_path_length_get(vg, &commands_count, &points_count);
svg_node->node.command.commands_count = commands_count;
svg_node->node.command.points_count = points_count;
svg_node->node.command.points = calloc(points_count, sizeof(double));
- svg_node->node.command.commands = calloc(commands_count, sizeof(Efl_Gfx_Path_Command));
- memcpy(svg_node->node.command.commands, commands, sizeof (Efl_Gfx_Path_Command) * commands_count);
+ svg_node->node.command.commands = calloc(commands_count, sizeof(Evas_Vg_Path_Command));
+ memcpy(svg_node->node.command.commands, commands, sizeof (Evas_Vg_Path_Command) * commands_count);
memcpy(svg_node->node.command.points, points, sizeof (double) * points_count);
_apply_svg_property(svg_node, vg);
}