kimcinoo
/
efl
forked from enlightenment/efl
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
efl/src/modules/evas/vg_loaders/svg/evas_vg_load_svg.c

2693 lines
75 KiB
C
Raw Blame History

#include "vg_common.h"
static int _evas_vg_loader_svg_log_dom = -1;
#ifdef ERR
# undef ERR
#endif
#define ERR(...) EINA_LOG_DOM_ERR(_evas_vg_loader_svg_log_dom, __VA_ARGS__)
#ifdef INF
# undef INF
#endif
#define INF(...) EINA_LOG_DOM_INFO(_evas_vg_loader_svg_log_dom, __VA_ARGS__)
/* Global struct for working global cases during the parse */
typedef struct _Evas_SVG_Parser Evas_SVG_Parser;
struct _Evas_SVG_Parser {
struct {
int x, y, width, height;
} global;
struct {
Eina_Bool fx_parsed;
Eina_Bool fy_parsed;
} gradient;
Svg_Node *node;
Svg_Style_Gradient *style_grad;
Efl_Gfx_Gradient_Stop *grad_stop;
};
typedef struct _Evas_SVG_Loader Evas_SVG_Loader;
struct _Evas_SVG_Loader
{
Eina_Array *stack;
Svg_Node *doc;
Svg_Node *def;
Eina_List *gradients;
Svg_Style_Gradient *latest_gradient; //for stops
Evas_SVG_Parser *svg_parse;
int level;
Eina_Bool result:1;
};
typedef Svg_Node *(*Factory_Method)(Evas_SVG_Loader *loader, Svg_Node *parent, const char *buf, unsigned buflen);
typedef Svg_Style_Gradient *(*Gradient_Factory_Method)(Evas_SVG_Loader *loader, const char *buf, unsigned buflen);
/* length type to recalculate %, pt, pc, mm, cm etc*/
typedef enum {
SVG_PARSER_LENGTH_VERTICAL,
SVG_PARSER_LENGTH_HORIZONTAL,
/* in case of, for example, radius of radial gradient */
SVG_PARSER_LENGTH_OTHER
} SVG_Parser_Length_Type;
char *
_skip_space(const char *str, const char *end)
{
while (((end != NULL && str < end) || (end == NULL && *str != '\0')) && isspace(*str))
++str;
return (char *)str;
}
static inline Eina_Stringshare *
_copy_id(const char* str)
{
if (str == NULL) return NULL;
return eina_stringshare_add(str);
}
static const char *
_skipcomma(const char *content)
{
content = _skip_space(content, NULL);
if (*content == ',') return content + 1;
return content;
}
static inline Eina_Bool
_parse_number(const char **content, double *number)
{
char *end = NULL;
*number = eina_convert_strtod_c(*content, &end);
// if the start of string is not number
if ((*content) == end) return EINA_FALSE;
//skip comma if any
*content = _skipcomma(end);
return EINA_TRUE;
}
/**
* According to https://www.w3.org/TR/SVG/coords.html#Units
*
* TODO
* Since this documentation is not obvious, more clean recalculation with dpi
* is required, but for now default w3 constants would be used
*/
static inline double
_to_double(Evas_SVG_Parser *svg_parse, const char *str, SVG_Parser_Length_Type type)
{
double parsed_value = eina_convert_strtod_c(str, NULL);
if (strstr(str, "cm"))
parsed_value = parsed_value * 35.43307;
else if (strstr(str, "mm"))
parsed_value = parsed_value * 3.543307;
else if (strstr(str, "pt"))
parsed_value = parsed_value * 1.25;
else if (strstr(str, "pc"))
parsed_value = parsed_value * 15;
else if (strstr(str, "in"))
parsed_value = parsed_value * 90;
else if (strstr(str, "%"))
{
if (type == SVG_PARSER_LENGTH_VERTICAL)
parsed_value = (parsed_value / 100.0) * svg_parse->global.height;
else if (type == SVG_PARSER_LENGTH_HORIZONTAL)
parsed_value = (parsed_value / 100.0) * svg_parse->global.width;
else // if other then it's radius
{
double max = svg_parse->global.width;
if (max < svg_parse->global.height) max = svg_parse->global.height;
parsed_value = (parsed_value / 100.0) * max;
}
}
//TODO: implement 'em', 'ex' attributes
return parsed_value;
}
/**
* Turn gradient variables into percentages
*/
static inline double
_gradient_to_double(Evas_SVG_Parser *svg_parse, const char *str, SVG_Parser_Length_Type type)
{
char *end = NULL;
double parsed_value = eina_convert_strtod_c(str, &end);
double max = 1;
/**
* That is according to Units in here
*
* https://www.w3.org/TR/2015/WD-SVG2-20150915/coords.html
*/
if (type == SVG_PARSER_LENGTH_VERTICAL)
max = svg_parse->global.height;
else if (type == SVG_PARSER_LENGTH_HORIZONTAL)
max = svg_parse->global.width;
else if (type == SVG_PARSER_LENGTH_OTHER)
max = sqrt(pow(svg_parse->global.height, 2) +
pow(svg_parse->global.width, 2)) / sqrt(2.0);
if (strstr(str, "%"))
parsed_value = parsed_value / 100.0;
else if (strstr(str, "cm"))
parsed_value = parsed_value * 35.43307;
else if (strstr(str, "mm"))
parsed_value = parsed_value * 3.543307;
else if (strstr(str, "pt"))
parsed_value = parsed_value * 1.25;
else if (strstr(str, "pc"))
parsed_value = parsed_value * 15;
else if (strstr(str, "in"))
parsed_value = parsed_value * 90;
//TODO: implement 'em', 'ex' attributes
/* Transform into global percentage */
parsed_value = parsed_value / max;
return parsed_value;
}
static inline double
_to_offset(const char *str)
{
char *end = NULL;
double parsed_value = eina_convert_strtod_c(str, &end);
if (strstr(str, "%"))
parsed_value = parsed_value / 100.0;
return parsed_value;
}
static inline int
_to_opacity(const char *str)
{
char *end = NULL;
int a = 0;
double opacity = eina_convert_strtod_c(str, &end);
if (end && (*end == '\0'))
a = lrint(opacity * 255);
return a;
}
#define _PARSE_TAG(Type, Short_Name, Tags_Array, Default) \
static Type _to_##Short_Name(const char *str) \
{ \
unsigned int i; \
\
for (i = 0; i < sizeof (Tags_Array) / sizeof (Tags_Array[0]); i++) \
if (!strcmp(str, Tags_Array[i].tag)) \
return Tags_Array[i].Short_Name; \
return Default; \
}
/* parse the line cap used during stroking a path.
* Value: butt | round | square | inherit
* Initial: butt
* https://www.w3.org/TR/SVG/painting.html
*/
static struct {
Efl_Gfx_Cap line_cap;
const char *tag;
} line_cap_tags[] = {
{ EFL_GFX_CAP_BUTT, "butt" },
{ EFL_GFX_CAP_ROUND, "round" },
{ EFL_GFX_CAP_SQUARE, "square" }
};
_PARSE_TAG(Efl_Gfx_Cap, line_cap, line_cap_tags, EFL_GFX_CAP_LAST);
/* parse the line join used during stroking a path.
* Value: miter | round | bevel | inherit
* Initial: miter
* https://www.w3.org/TR/SVG/painting.html
*/
static struct {
Efl_Gfx_Join line_join;
const char *tag;
} line_join_tags[] = {
{ EFL_GFX_JOIN_MITER, "miter" },
{ EFL_GFX_JOIN_ROUND, "round" },
{ EFL_GFX_JOIN_BEVEL, "bevel" }
};
_PARSE_TAG(Efl_Gfx_Join, line_join, line_join_tags, EFL_GFX_JOIN_LAST);
/* parse the fill rule used during filling a path.
* Value: nonzero | evenodd | inherit
* Initial: nonzero
* https://www.w3.org/TR/SVG/painting.html
*/
static struct {
Efl_Gfx_Fill_Rule fill_rule;
const char *tag;
} fill_rule_tags[] = {
{ EFL_GFX_FILL_RULE_ODD_EVEN, "evenodd" }
};
_PARSE_TAG(Efl_Gfx_Fill_Rule, fill_rule, fill_rule_tags, EFL_GFX_FILL_RULE_WINDING);
/* parse the dash pattern used during stroking a path.
* Value: none | <dasharray> | inherit
* Initial: none
* https://www.w3.org/TR/SVG/painting.html
*/
static inline void
_parse_dash_array(const char *str, Efl_Gfx_Dash** dash, int *length)
{
// It is assumed that the length of the dasharray string is 255 or less.
double tmp[255];
char *end = NULL;
int leni, gapi, count = 0, index = 0;
while (*str)
{
// skip white space, comma
str = _skipcomma(str);
tmp[count++] = eina_convert_strtod_c(str, &end);
str = _skipcomma(end);
}
if (count & 0x1)
{ // odd case.
*length = count;
*dash = calloc(*length, sizeof(Efl_Gfx_Dash));
while (index < count)
{
leni = (2 * index) % count;
gapi = (2 * index + 1) % count;
(*dash)[index].length = tmp[leni];
(*dash)[index].gap = tmp[gapi];
index++;
}
}
else
{ // even case
*length = count/2;
*dash = calloc(*length, sizeof(Efl_Gfx_Dash));
while (index < *length)
{
(*dash)[index].length = tmp[2 * index];
(*dash)[index].gap = tmp[2 * index + 1];
index++;
}
}
}
static Eina_Stringshare *
_id_from_url(const char *url)
{
char tmp[50];
int i = 0;
url = _skip_space(url, NULL);
if ((*url) == '(')
{
++url;
url = _skip_space(url, NULL);
}
if ((*url) == '#')
++url;
while ((*url) != ')')
{
tmp[i++] = *url;
++url;
}
tmp[i] = '\0';
return eina_stringshare_add(tmp);
}
static unsigned char
_color_parser(const char *value, char **end)
{
double r;
r = eina_convert_strtod_c(value, end);
*end = _skip_space(*end, NULL);
if (**end == '%')
r = 255 * r / 100;
*end = _skip_space(*end, NULL);
if (r < 0 || r > 255)
{
*end = NULL;
return 0;
}
return lrint(r);
}
static const struct {
const char *name;
unsigned int value;
} colors[] = {
{ "aliceblue", 0xfff0f8ff },
{ "antiquewhite", 0xfffaebd7 },
{ "aqua", 0xff00ffff },
{ "aquamarine", 0xff7fffd4 },
{ "azure", 0xfff0ffff },
{ "beige", 0xfff5f5dc },
{ "bisque", 0xffffe4c4 },
{ "black", 0xff000000 },
{ "blanchedalmond", 0xffffebcd },
{ "blue", 0xff0000ff },
{ "blueviolet", 0xff8a2be2 },
{ "brown", 0xffa52a2a },
{ "burlywood", 0xffdeb887 },
{ "cadetblue", 0xff5f9ea0 },
{ "chartreuse", 0xff7fff00 },
{ "chocolate", 0xffd2691e },
{ "coral", 0xffff7f50 },
{ "cornflowerblue", 0xff6495ed },
{ "cornsilk", 0xfffff8dc },
{ "crimson", 0xffdc143c },
{ "cyan", 0xff00ffff },
{ "darkblue", 0xff00008b },
{ "darkcyan", 0xff008b8b },
{ "darkgoldenrod", 0xffb8860b },
{ "darkgray", 0xffa9a9a9 },
{ "darkgrey", 0xffa9a9a9 },
{ "darkgreen", 0xff006400 },
{ "darkkhaki", 0xffbdb76b },
{ "darkmagenta", 0xff8b008b },
{ "darkolivegreen", 0xff556b2f },
{ "darkorange", 0xffff8c00 },
{ "darkorchid", 0xff9932cc },
{ "darkred", 0xff8b0000 },
{ "darksalmon", 0xffe9967a },
{ "darkseagreen", 0xff8fbc8f },
{ "darkslateblue", 0xff483d8b },
{ "darkslategray", 0xff2f4f4f },
{ "darkslategrey", 0xff2f4f4f },
{ "darkturquoise", 0xff00ced1 },
{ "darkviolet", 0xff9400d3 },
{ "deeppink", 0xffff1493 },
{ "deepskyblue", 0xff00bfff },
{ "dimgray", 0xff696969 },
{ "dimgrey", 0xff696969 },
{ "dodgerblue", 0xff1e90ff },
{ "firebrick", 0xffb22222 },
{ "floralwhite", 0xfffffaf0 },
{ "forestgreen", 0xff228b22 },
{ "fuchsia", 0xffff00ff },
{ "gainsboro", 0xffdcdcdc },
{ "ghostwhite", 0xfff8f8ff },
{ "gold", 0xffffd700 },
{ "goldenrod", 0xffdaa520 },
{ "gray", 0xff808080 },
{ "grey", 0xff808080 },
{ "green", 0xff008000 },
{ "greenyellow", 0xffadff2f },
{ "honeydew", 0xfff0fff0 },
{ "hotpink", 0xffff69b4 },
{ "indianred", 0xffcd5c5c },
{ "indigo", 0xff4b0082 },
{ "ivory", 0xfffffff0 },
{ "khaki", 0xfff0e68c },
{ "lavender", 0xffe6e6fa },
{ "lavenderblush", 0xfffff0f5 },
{ "lawngreen", 0xff7cfc00 },
{ "lemonchiffon", 0xfffffacd },
{ "lightblue", 0xffadd8e6 },
{ "lightcoral", 0xfff08080 },
{ "lightcyan", 0xffe0ffff },
{ "lightgoldenrodyellow", 0xfffafad2 },
{ "lightgray", 0xffd3d3d3 },
{ "lightgrey", 0xffd3d3d3 },
{ "lightgreen", 0xff90ee90 },
{ "lightpink", 0xffffb6c1 },
{ "lightsalmon", 0xffffa07a },
{ "lightseagreen", 0xff20b2aa },
{ "lightskyblue", 0xff87cefa },
{ "lightslategray", 0xff778899 },
{ "lightslategrey", 0xff778899 },
{ "lightsteelblue", 0xffb0c4de },
{ "lightyellow", 0xffffffe0 },
{ "lime", 0xff00ff00 },
{ "limegreen", 0xff32cd32 },
{ "linen", 0xfffaf0e6 },
{ "magenta", 0xffff00ff },
{ "maroon", 0xff800000 },
{ "mediumaquamarine", 0xff66cdaa },
{ "mediumblue", 0xff0000cd },
{ "mediumorchid", 0xffba55d3 },
{ "mediumpurple", 0xff9370d8 },
{ "mediumseagreen", 0xff3cb371 },
{ "mediumslateblue", 0xff7b68ee },
{ "mediumspringgreen", 0xff00fa9a },
{ "mediumturquoise", 0xff48d1cc },
{ "mediumvioletred", 0xffc71585 },
{ "midnightblue", 0xff191970 },
{ "mintcream", 0xfff5fffa },
{ "mistyrose", 0xffffe4e1 },
{ "moccasin", 0xffffe4b5 },
{ "navajowhite", 0xffffdead },
{ "navy", 0xff000080 },
{ "oldlace", 0xfffdf5e6 },
{ "olive", 0xff808000 },
{ "olivedrab", 0xff6b8e23 },
{ "orange", 0xffffa500 },
{ "orangered", 0xffff4500 },
{ "orchid", 0xffda70d6 },
{ "palegoldenrod", 0xffeee8aa },
{ "palegreen", 0xff98fb98 },
{ "paleturquoise", 0xffafeeee },
{ "palevioletred", 0xffd87093 },
{ "papayawhip", 0xffffefd5 },
{ "peachpuff", 0xffffdab9 },
{ "peru", 0xffcd853f },
{ "pink", 0xffffc0cb },
{ "plum", 0xffdda0dd },
{ "powderblue", 0xffb0e0e6 },
{ "purple", 0xff800080 },
{ "red", 0xffff0000 },
{ "rosybrown", 0xffbc8f8f },
{ "royalblue", 0xff4169e1 },
{ "saddlebrown", 0xff8b4513 },
{ "salmon", 0xfffa8072 },
{ "sandybrown", 0xfff4a460 },
{ "seagreen", 0xff2e8b57 },
{ "seashell", 0xfffff5ee },
{ "sienna", 0xffa0522d },
{ "silver", 0xffc0c0c0 },
{ "skyblue", 0xff87ceeb },
{ "slateblue", 0xff6a5acd },
{ "slategray", 0xff708090 },
{ "slategrey", 0xff708090 },
{ "snow", 0xfffffafa },
{ "springgreen", 0xff00ff7f },
{ "steelblue", 0xff4682b4 },
{ "tan", 0xffd2b48c },
{ "teal", 0xff008080 },
{ "thistle", 0xffd8bfd8 },
{ "tomato", 0xffff6347 },
{ "turquoise", 0xff40e0d0 },
{ "violet", 0xffee82ee },
{ "wheat", 0xfff5deb3 },
{ "white", 0xffffffff },
{ "whitesmoke", 0xfff5f5f5 },
{ "yellow", 0xffffff00 },
{ "yellowgreen", 0xff9acd32 }
};
static inline void
_to_color(const char *str, int *r, int *g, int *b, Eina_Stringshare** ref)
{
unsigned int i, len = strlen(str);
char *red, *green, *blue;
unsigned char tr, tg, tb;
if (len == 4 && str[0] == '#')
{
// case for "#456" should be interprete as "#445566"
if (isxdigit(str[1]) &&
isxdigit(str[2]) &&
isxdigit(str[3]))
{
char tmp[3] = { '\0', '\0', '\0' };
tmp[0] = str[1]; tmp[1] = str[1]; *r = strtol(tmp, NULL, 16);
tmp[0] = str[2]; tmp[1] = str[2]; *g = strtol(tmp, NULL, 16);
tmp[0] = str[3]; tmp[1] = str[3]; *b = strtol(tmp, NULL, 16);
}
}
else if (len == 7 && str[0] == '#')
{
if (isxdigit(str[1]) &&
isxdigit(str[2]) &&
isxdigit(str[3]) &&
isxdigit(str[4]) &&
isxdigit(str[5]) &&
isxdigit(str[6]))
{
char tmp[3] = { '\0', '\0', '\0' };
tmp[0] = str[1]; tmp[1] = str[2]; *r = strtol(tmp, NULL, 16);
tmp[0] = str[3]; tmp[1] = str[4]; *g = strtol(tmp, NULL, 16);
tmp[0] = str[5]; tmp[1] = str[6]; *b = strtol(tmp, NULL, 16);
}
}
else if (len >= 10 &&
(str[0] == 'r' || str[0] == 'R') &&
(str[1] == 'g' || str[1] == 'G') &&
(str[2] == 'b' || str[2] == 'B') &&
str[3] == '(' &&
str[len - 1] == ')')
{
tr = _color_parser(str + 4, &red);
if (red && *red == ',')
{
tg = _color_parser(red + 1, &green);
if (green && *green == ',')
{
tb = _color_parser(green + 1, &blue);
if (blue && blue[0] == ')' && blue[1] == '\0')
{
*r = tr; *g = tg; *b = tb;
}
}
}
}
else if (len >= 3 && !strncmp(str, "url",3))
{
*ref = _id_from_url(str+3);
}
else
{
//handle named color
for (i = 0; i < (sizeof (colors) / sizeof (colors[0])); i++)
if (!strcasecmp(colors[i].name, str))
{
*r = R_VAL(&(colors[i].value));
*g = G_VAL(&(colors[i].value));
*b = B_VAL(&(colors[i].value));
}
}
}
static inline char *
parse_numbers_array(char *str, double *points, int *pt_count)
{
int count = 0;
char *end = NULL;
str = _skip_space(str, NULL);
while (isdigit(*str) ||
*str == '-' ||
*str == '+' ||
*str == '.')
{
points[count++] = eina_convert_strtod_c(str, &end);
str = end;
str = _skip_space(str, NULL);
if (*str == ',')
++str;
//eat the rest of space
str = _skip_space(str, NULL);
}
*pt_count = count;
return str;
}
typedef enum _Matrix_State
{
SVG_MATRIX_UNKNOWN,
SVG_MATRIX_MATRIX,
SVG_MATRIX_TRANSLATE,
SVG_MATRIX_ROTATE,
SVG_MATRIX_SCALE,
SVG_MATRIX_SKEWX,
SVG_MATRIX_SKEWY
} Matrix_State;
#define MATRIX_DEF(Name, Value) \
{ #Name, sizeof (#Name), Value}
static const struct {
const char *tag;
int sz;
Matrix_State state;
} matrix_tags[] = {
MATRIX_DEF(matrix, SVG_MATRIX_MATRIX),
MATRIX_DEF(translate, SVG_MATRIX_TRANSLATE),
MATRIX_DEF(rotate, SVG_MATRIX_ROTATE),
MATRIX_DEF(scale, SVG_MATRIX_SCALE),
MATRIX_DEF(skewX, SVG_MATRIX_SKEWX),
MATRIX_DEF(skewY, SVG_MATRIX_SKEWY)
};
/* parse transform attribute
* https://www.w3.org/TR/SVG/coords.html#TransformAttribute
*/
static Eina_Matrix3 *
_parse_transformation_matrix(const char *value)
{
unsigned int i;
double points[8];
int pt_count = 0;
double sx, sy;
Matrix_State state = SVG_MATRIX_UNKNOWN;
Eina_Matrix3 *matrix = calloc(1, sizeof(Eina_Matrix3));
char *str = (char *)value;
char *end = str + strlen(str);
eina_matrix3_identity(matrix);
while (str < end)
{
if (isspace(*str) || (*str == ','))
{
++str;
continue;
}
for (i = 0; i < sizeof (matrix_tags) / sizeof(matrix_tags[0]); i++)
if (!strncmp(matrix_tags[i].tag, str, matrix_tags[i].sz -1))
{
state = matrix_tags[i].state;
str += (matrix_tags[i].sz -1);
}
if ( state == SVG_MATRIX_UNKNOWN)
goto error;
str = _skip_space(str, end);
if (*str != '(')
goto error;
++str;
str = parse_numbers_array(str, points, &pt_count);
if (*str != ')')
goto error;
++str;
if (state == SVG_MATRIX_MATRIX)
{
Eina_Matrix3 tmp;
if (pt_count != 6) goto error;
eina_matrix3_identity(&tmp);
eina_matrix3_values_set(&tmp,
points[0], points[2], points[4],
points[1], points[3], points[5],
0, 0, 1);
eina_matrix3_compose(matrix, &tmp, matrix);
}
else if (state == SVG_MATRIX_TRANSLATE)
{
if (pt_count == 1)
eina_matrix3_translate(matrix, points[0], 0);
else if (pt_count == 2)
eina_matrix3_translate(matrix, points[0], points[1]);
else
goto error;
}
else if (state == SVG_MATRIX_ROTATE)
{
//Transform to signed.
points[0] = fmod(points[0], 360);
if (points[0] < 0) points[0] += 360;
if (pt_count == 1)
{
eina_matrix3_rotate(matrix, points[0] * (M_PI/180.0));
}
else if (pt_count == 3)
{
eina_matrix3_translate(matrix, points[1], points[2]);
eina_matrix3_rotate(matrix, points[0] * (M_PI/180.0));
eina_matrix3_translate(matrix, -points[1], -points[2]);
}
else
{
goto error;
}
}
else if (state == SVG_MATRIX_SCALE)
{
if (pt_count < 1 || pt_count > 2) goto error;
sx = points[0];
sy = sx;
if (pt_count == 2)
sy = points[1];
eina_matrix3_scale(matrix, sx, sy);
}
}
error:
return matrix;
}
#define LENGTH_DEF(Name, Value) \
{ #Name, sizeof (#Name), Value}
static const struct {
const char *tag;
int sz;
Svg_Length_Type type;
} length_tags[] = {
LENGTH_DEF(%, SVG_LT_PERCENT),
LENGTH_DEF(px, SVG_LT_PX),
LENGTH_DEF(pc, SVG_LT_PC),
LENGTH_DEF(pt, SVG_LT_PT),
LENGTH_DEF(mm, SVG_LT_MM),
LENGTH_DEF(cm, SVG_LT_CM),
LENGTH_DEF(in, SVG_LT_IN)
};
static double
parse_length(const char *str, Svg_Length_Type *type)
{
unsigned int i;
double value;
int sz = strlen(str);
*type = SVG_LT_PX;
for (i = 0; i < sizeof (length_tags) / sizeof(length_tags[0]); i++)
if (length_tags[i].sz - 1 == sz && !strncmp(length_tags[i].tag, str, sz))
{
*type = length_tags[i].type;
}
value = eina_convert_strtod_c(str, NULL);
return value;
}
static Eina_Bool _parse_style_attr(void *data, const char *key, const char *value);
static Eina_Bool _attr_style_node(void *data, const char *str);
static Eina_Bool
_attr_parse_svg_node(void *data, const char *key, const char *value)
{
Evas_SVG_Loader *loader = data;
Svg_Node *node = loader->svg_parse->node;
Svg_Doc_Node *doc = &(node->node.doc);
Svg_Length_Type type;
// @TODO handle length unit.
if (!strcmp(key, "width"))
{
doc->width = parse_length(value, &type);
}
else if (!strcmp(key, "height"))
{
doc->height = parse_length(value, &type);
}
else if (!strcmp(key, "viewBox"))
{
if (_parse_number(&value, &doc->vx))
{
if (_parse_number(&value, &doc->vy))
{
if (_parse_number(&value, &doc->vw))
{
_parse_number(&value, &doc->vh);
loader->svg_parse->global.height = doc->vh;
}
loader->svg_parse->global.width = doc->vw;
}
loader->svg_parse->global.y = doc->vy;
}
loader->svg_parse->global.x = doc->vx;
}
else if (!strcmp(key, "preserveAspectRatio"))
{
if (!strcmp(value, "none"))
doc->preserve_aspect = EINA_FALSE;
}
else if (!strcmp(key, "style"))
{
_attr_style_node(loader, value);
}
else
{
_parse_style_attr(loader, key, value);
}
return EINA_TRUE;
}
//https://www.w3.org/TR/SVGTiny12/painting.html#SpecifyingPaint
static void
_handle_paint_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Paint* paint, const char *value)
{
if (!strcmp(value, "none"))
{
// no paint property
paint->none = EINA_TRUE;
return;
}
paint->none = EINA_FALSE;
if (!strcmp(value, "currentColor"))
{
paint->cur_color = EINA_TRUE;
return;
}
_to_color(value, &paint->r, &paint->g, &paint->b, &paint->url);
}
static void
_handle_color_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
Svg_Style_Property *style = node->style;
_to_color(value, &style->r, &style->g, &style->b, NULL);
}
static void
_handle_fill_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
Svg_Style_Property *style = node->style;
style->fill.flags |= SVG_FILL_FLAGS_PAINT;
_handle_paint_attr(loader, &style->fill.paint, value);
}
static void
_handle_stroke_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
Svg_Style_Property *style = node->style;
style->stroke.flags |= SVG_STROKE_FLAGS_PAINT;
_handle_paint_attr(loader, &style->stroke.paint, value);
}
static void
_handle_stroke_opacity_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
node->style->stroke.flags |= SVG_STROKE_FLAGS_OPACITY;
node->style->stroke.opacity = _to_opacity(value);
}
static void
_handle_stroke_dasharray_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
node->style->stroke.flags |= SVG_STROKE_FLAGS_DASH;
_parse_dash_array(value, &node->style->stroke.dash, &node->style->stroke.dash_count);
}
static void
_handle_stroke_width_attr(Evas_SVG_Loader *loader, Svg_Node* node, const char *value)
{
node->style->stroke.flags |= SVG_STROKE_FLAGS_WIDTH;
node->style->stroke.width = _to_double(loader->svg_parse, value, SVG_PARSER_LENGTH_HORIZONTAL);
}
static void
_handle_stroke_linecap_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
node->style->stroke.flags |= SVG_STROKE_FLAGS_CAP;
node->style->stroke.cap = _to_line_cap(value);
}
static void
_handle_stroke_linejoin_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
node->style->stroke.flags |= SVG_STROKE_FLAGS_JOIN;
node->style->stroke.join = _to_line_join(value);
}
static void
_handle_fill_rule_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
node->style->fill.flags |= SVG_FILL_FLAGS_FILL_RULE;
node->style->fill.fill_rule = _to_fill_rule(value);
}
static void
_handle_opacity_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
node->style->opacity = _to_opacity(value);
}
static void
_handle_fill_opacity_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
node->style->fill.flags |= SVG_FILL_FLAGS_OPACITY;
node->style->fill.opacity = _to_opacity(value);
}
static void
_handle_transform_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
node->transform = _parse_transformation_matrix(value);
}
static void _handle_clip_path_attr(Evas_SVG_Loader* loader EINA_UNUSED, Svg_Node* node, const char* value)
{
Svg_Style_Property* style = node->style;
style->comp.flags |= SVG_COMPOSITE_FLAGS_CLIP_PATH;
int len = strlen(value);
if (len >= 3 && !strncmp(value, "url", 3)) style->comp.url = _id_from_url((const char*)(value + 3));
}
static void
_handle_display_attr(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node* node, const char *value)
{
//TODO : The display attribute can have various values as well as "none".
// The default is "inline" which means visible and "none" means invisible.
// Depending on the type of node, additional functionality may be required.
// refer to https://developer.mozilla.org/en-US/docs/Web/SVG/Attribute/display
if (!strcmp(value, "none")) node->display = EINA_FALSE;
else node->display = EINA_TRUE;
}
typedef void (*Style_Method)(Evas_SVG_Loader *loader, Svg_Node *node, const char *value);
#define STYLE_DEF(Name, Name1) \
{ #Name, sizeof (#Name), _handle_##Name1##_attr}
static const struct {
const char *tag;
int sz;
Style_Method tag_handler;;
} style_tags[] = {
STYLE_DEF(color, color),
STYLE_DEF(fill, fill),
STYLE_DEF(fill-rule, fill_rule),
STYLE_DEF(fill-opacity, fill_opacity),
STYLE_DEF(opacity, opacity),
STYLE_DEF(stroke, stroke),
STYLE_DEF(stroke-width, stroke_width),
STYLE_DEF(stroke-linejoin, stroke_linejoin),
STYLE_DEF(stroke-linecap, stroke_linecap),
STYLE_DEF(stroke-opacity, stroke_opacity),
STYLE_DEF(stroke-dasharray, stroke_dasharray),
STYLE_DEF(transform, transform),
STYLE_DEF(display, display)
};
static Eina_Bool
_parse_style_attr(void *data, const char *key, const char *value)
{
Evas_SVG_Loader *loader = data;
Svg_Node* node = loader->svg_parse->node;
unsigned int i;
int sz;
// trim the white space
key = _skip_space(key, NULL);
value = _skip_space(value, NULL);
sz = strlen(key);
for (i = 0; i < sizeof (style_tags) / sizeof(style_tags[0]); i++)
if (style_tags[i].sz - 1 == sz && !strncmp(style_tags[i].tag, key, sz))
{
style_tags[i].tag_handler(loader, node, value);
return EINA_TRUE;
}
return EINA_TRUE;
}
static Eina_Bool
_attr_style_node(void *data, const char *str)
{
eina_simple_xml_attribute_w3c_parse(str,
_parse_style_attr, data);
return EINA_TRUE;
}
/* parse g node
* https://www.w3.org/TR/SVG/struct.html#Groups
*/
static Eina_Bool
_attr_parse_g_node(void *data, const char *key, const char *value)
{
Evas_SVG_Loader *loader = data;
Svg_Node* node = loader->svg_parse->node;
if (!strcmp(key, "style"))
{
return _attr_style_node(loader, value);
}
else if (!strcmp(key, "transform"))
{
node->transform = _parse_transformation_matrix(value);
}
else if (!strcmp(key, "clip-path"))
{
_handle_clip_path_attr(loader, node, value);
}
else if (!strcmp(key, "id"))
{
node->id = _copy_id(value);
}
else
{
_parse_style_attr(loader, key, value);
}
return EINA_TRUE;
}
/* parse clipPath node
* https://www.w3.org/TR/SVG/struct.html#Groups
*/
static Eina_Bool _attr_parse_clip_path_node(void* data, const char* key, const char* value)
{
Evas_SVG_Loader *loader = data;
Svg_Node* node = loader->svg_parse->node;
if (!strcmp(key, "style"))
{
return _attr_style_node(loader, value);
}
else if (!strcmp(key, "transform"))
{
node->transform = _parse_transformation_matrix(value);
}
else if (!strcmp(key, "clip-path"))
{
_handle_clip_path_attr(loader, node, value);
}
else if (!strcmp(key, "id"))
{
node->id = _copy_id(value);
}
else
{
_parse_style_attr(loader, key, value);
}
return EINA_TRUE;
}
static Svg_Node *
_create_node(Svg_Node *parent, Svg_Node_Type type)
{
Svg_Node *node = calloc(1, sizeof(Svg_Node));
// default fill property
node->style = calloc(1, sizeof(Svg_Style_Property));
// update the default value of stroke and fill
//https://www.w3.org/TR/SVGTiny12/painting.html#SpecifyingPaint
// default fill color is black
//node->style->fill.paint.r = 0;
//node->style->fill.paint.g = 0;
//node->style->fill.paint.b = 0;
node->style->fill.paint.none = EINA_FALSE;
// default fill opacity is 1
node->style->fill.opacity = 255;
node->style->opacity = 255;
// default fill rule is nonzero
node->style->fill.fill_rule = EFL_GFX_FILL_RULE_WINDING;
// default stroke is none
node->style->stroke.paint.none = EINA_TRUE;
// default stroke opacity is 1
node->style->stroke.opacity = 255;
// default stroke width is 1
node->style->stroke.width = 1;
// default line cap is butt
node->style->stroke.cap = EFL_GFX_CAP_BUTT;
// default line join is miter
node->style->stroke.join = EFL_GFX_JOIN_MITER;
node->style->stroke.scale = 1.0;
// default display is true("inline").
node->display = EINA_TRUE;
node->parent = parent;
node->type = type;
node->child = NULL;
if (parent)
parent->child = eina_list_append(parent->child, node);
return node;
}
static Svg_Node *
_create_defs_node(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node *parent EINA_UNUSED, const char *buf EINA_UNUSED, unsigned buflen EINA_UNUSED)
{
Svg_Node *node = _create_node(NULL, SVG_NODE_DEFS);
eina_simple_xml_attributes_parse(buf, buflen,
NULL, node);
return node;
}
static Svg_Node *
_create_g_node(Evas_SVG_Loader *loader, Svg_Node *parent, const char *buf, unsigned buflen)
{
loader->svg_parse->node = _create_node(parent, SVG_NODE_G);
eina_simple_xml_attributes_parse(buf, buflen,
_attr_parse_g_node, loader);
return loader->svg_parse->node;
}
static Svg_Node *
_create_svg_node(Evas_SVG_Loader *loader, Svg_Node *parent, const char *buf, unsigned buflen)
{
loader->svg_parse->node = _create_node(parent, SVG_NODE_DOC);
Svg_Doc_Node *doc = &(loader->svg_parse->node->node.doc);
doc->preserve_aspect = EINA_TRUE;
eina_simple_xml_attributes_parse(buf, buflen,
_attr_parse_svg_node, loader);
return loader->svg_parse->node;
}
static Svg_Node *
_create_switch_node(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node *parent EINA_UNUSED, const char *buf EINA_UNUSED, unsigned buflen EINA_UNUSED)
{
return NULL;
}
static Svg_Node *
_create_mask_node(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node *parent EINA_UNUSED, const char *buf EINA_UNUSED, unsigned buflen EINA_UNUSED)
{
Svg_Node *node = _create_node(NULL, SVG_NODE_UNKNOWN);
node->display = EINA_FALSE;
return node;
}
static Svg_Node *
_create_clipPath_node(Evas_SVG_Loader *loader EINA_UNUSED, Svg_Node *parent EINA_UNUSED, const char *buf EINA_UNUSED, unsigned buflen EINA_UNUSED)
{
loader->svg_parse->node = _create_node(parent, SVG_NODE_CLIP_PATH);
eina_simple_xml_attributes_parse(buf, buflen,
_attr_parse_clip_path_node, loader);
return loader->svg_parse->node;
}
static Eina_Bool
_attr_parse_path_node(void *data, const char *key, const char *value)
{
Evas_SVG_Loader *loader = data;
Svg_Node* node = loader->svg_parse->node;
Svg_Path_Node *path = &(node->node.path);
if (!strcmp(key, "d"))
{
path->path = eina_stringshare_add(value);
}
else if (!strcmp(key, "style"))
{
_attr_style_node(loader, value);
}
else if (!strcmp(key, "clip-path"))
{
_handle_clip_path_attr(loader, node, value);
}
else if (!strcmp(key, "id"))
{
node->id = _copy_id(value);
}
else
{
_parse_style_attr(loader, key, value);
}
return EINA_TRUE;
}
static Svg_Node *
_create_path_node(Evas_SVG_Loader *loader, Svg_Node *parent, const char *buf, unsigned buflen)
{
loader->svg_parse->node = _create_node(parent, SVG_NODE_PATH);
eina_simple_xml_attributes_parse(buf, buflen,
_attr_parse_path_node, loader);
return loader->svg_parse->node;
}
#define CIRCLE_DEF(Name, Field, Type) \
{ #Name, Type, sizeof (#Name), offsetof(Svg_Circle_Node, Field)}
static const struct {
const char *tag;
SVG_Parser_Length_Type type;
int sz;
size_t offset;
} circle_tags[] = {
CIRCLE_DEF(cx, cx, SVG_PARSER_LENGTH_HORIZONTAL),
CIRCLE_DEF(cy, cy, SVG_PARSER_LENGTH_VERTICAL),
CIRCLE_DEF(r, r, SVG_PARSER_LENGTH_OTHER)
};
/* parse the attributes for a circle element.
* https://www.w3.org/TR/SVG/shapes.html#CircleElement
*/
static Eina_Bool
_attr_parse_circle_node(void *data, const char *key, const char *value)
{
Evas_SVG_Loader *loader = data;
Svg_Node* node = loader->svg_parse->node;
Svg_Circle_Node *circle = &(node->node.circle);
unsigned int i;
unsigned char *array;
int sz = strlen(key);
array = (unsigned char*) circle;
for (i = 0; i < sizeof (circle_tags) / sizeof(circle_tags[0]); i++)
if (circle_tags[i].sz - 1 == sz && !strncmp(circle_tags[i].tag, key, sz))
{
*((double*) (array + circle_tags[i].offset)) =
_to_double(loader->svg_parse, value, circle_tags[i].type);
return EINA_TRUE;
}
if (!strcmp(key, "style"))
{
_attr_style_node(loader, value);
}
else if (!strcmp(key, "clip-path"))
{
_handle_clip_path_attr(loader, node, value);
}
else if (!strcmp(key, "id"))
{
node->id = _copy_id(value);
}
else
{
_parse_style_attr(loader, key, value);
}
return EINA_TRUE;
}
static Svg_Node *
_create_circle_node(Evas_SVG_Loader *loader, Svg_Node *parent, const char *buf, unsigned buflen)
{
loader->svg_parse->node = _create_node(parent, SVG_NODE_CIRCLE);
eina_simple_xml_attributes_parse(buf, buflen,
_attr_parse_circle_node, loader);
return loader->svg_parse->node;
}
#define ELLIPSE_DEF(Name, Field, Type) \
{ #Name, Type, sizeof (#Name), offsetof(Svg_Ellipse_Node, Field)}
static const struct {
const char *tag;
SVG_Parser_Length_Type type;
int sz;
size_t offset;
} ellipse_tags[] = {
ELLIPSE_DEF(cx,cx, SVG_PARSER_LENGTH_HORIZONTAL),
ELLIPSE_DEF(cy,cy, SVG_PARSER_LENGTH_VERTICAL),
ELLIPSE_DEF(rx,rx, SVG_PARSER_LENGTH_HORIZONTAL),
ELLIPSE_DEF(ry,ry, SVG_PARSER_LENGTH_VERTICAL)
};
/* parse the attributes for an ellipse element.
* https://www.w3.org/TR/SVG/shapes.html#EllipseElement
*/
static Eina_Bool
_attr_parse_ellipse_node(void *data, const char *key, const char *value)
{
Evas_SVG_Loader *loader = data;
Svg_Node* node = loader->svg_parse->node;
Svg_Ellipse_Node *ellipse = &(node->node.ellipse);
unsigned int i;
unsigned char *array;
int sz = strlen(key);
array = (unsigned char*) ellipse;
for (i = 0; i < sizeof (ellipse_tags) / sizeof(ellipse_tags[0]); i++)
if (ellipse_tags[i].sz - 1 == sz && !strncmp(ellipse_tags[i].tag, key, sz))
{
*((double*) (array + ellipse_tags[i].offset)) =
_to_double(loader->svg_parse, value, ellipse_tags[i].type);
return EINA_TRUE;
}
if (!strcmp(key, "id"))
{
node->id = _copy_id(value);
}
else if (!strcmp(key, "clip-path"))
{
_handle_clip_path_attr(loader, node, value);
}
else if (!strcmp(key, "style"))
{
_attr_style_node(loader, value);
}
else
{
_parse_style_attr(loader, key, value);
}
return EINA_TRUE;
}
static Svg_Node *
_create_ellipse_node(Evas_SVG_Loader *loader, Svg_Node *parent, const char *buf, unsigned buflen)
{
loader->svg_parse->node = _create_node(parent, SVG_NODE_ELLIPSE);
eina_simple_xml_attributes_parse(buf, buflen,
_attr_parse_ellipse_node, loader);
return loader->svg_parse->node;
}
static void
_attr_parse_polygon_points(const char *str, double **points, int *point_count)
{
double tmp[50];
int tmp_count=0;
int count = 0;
double num;
double *point_array = NULL, *tmp_array;
while (_parse_number(&str, &num))
{
tmp[tmp_count++] = num;
if (tmp_count == 50)
{
tmp_array = realloc(point_array, (count + tmp_count) * sizeof(double));
if (!tmp_array) goto error_alloc;
point_array = tmp_array;
memcpy(&point_array[count], tmp, tmp_count * sizeof(double));
count += tmp_count;
tmp_count = 0;
}
}
if (tmp_count > 0)
{
tmp_array = realloc(point_array, (count + tmp_count) * sizeof(double));
if (!tmp_array) goto error_alloc;
point_array = tmp_array;
memcpy(&point_array[count], tmp, tmp_count * sizeof(double));
count += tmp_count;
}
*point_count = count;
*points = point_array;
return;
error_alloc:
ERR("allocation for point array failed. out of memory");
abort();
}
/* parse the attributes for a polygon element.
* https://www.w3.org/TR/SVG/shapes.html#PolylineElement
*/
static Eina_Bool
_attr_parse_polygon_node(void *data, const char *key, const char *value)
{
Evas_SVG_Loader *loader = data;
Svg_Node *node = loader->svg_parse->node;
Svg_Polygon_Node *polygon = NULL;
if (node->type == SVG_NODE_POLYGON)
polygon = &(node->node.polygon);
else
polygon = &(node->node.polyline);
if (!strcmp(key, "points"))
{
_attr_parse_polygon_points(value, &polygon->points, &polygon->points_count);
}
else if (!strcmp(key, "style"))
{
_attr_style_node(loader, value);
}
else if (!strcmp(key, "clip-path"))
{
_handle_clip_path_attr(loader, node, value);
}
else if (!strcmp(key, "id"))
{
node->id = _copy_id(value);
}
else
{
_parse_style_attr(loader, key, value);
}
return EINA_TRUE;
}
static Svg_Node *
_create_polygon_node(Evas_SVG_Loader *loader, Svg_Node *parent, const char *buf, unsigned buflen)
{
loader->svg_parse->node = _create_node(parent, SVG_NODE_POLYGON);
eina_simple_xml_attributes_parse(buf, buflen,
_attr_parse_polygon_node, loader);
return loader->svg_parse->node;
}
static Svg_Node *
_create_polyline_node(Evas_SVG_Loader *loader, Svg_Node *parent, const char *buf, unsigned buflen)
{
loader->svg_parse->node = _create_node(parent, SVG_NODE_POLYLINE);
eina_simple_xml_attributes_parse(buf, buflen,
_attr_parse_polygon_node, loader);
return loader->svg_parse->node;
}
#define RECT_DEF(Name, Field, Type) \
{ #Name, Type, sizeof (#Name), offsetof(Svg_Rect_Node, Field)}
static const struct {
const char *tag;
SVG_Parser_Length_Type type;
int sz;
size_t offset;
} rect_tags[] = {
RECT_DEF(x,x, SVG_PARSER_LENGTH_HORIZONTAL),
RECT_DEF(y, y, SVG_PARSER_LENGTH_VERTICAL),
RECT_DEF(width, w, SVG_PARSER_LENGTH_HORIZONTAL),
RECT_DEF(height, h, SVG_PARSER_LENGTH_VERTICAL),
RECT_DEF(rx, rx, SVG_PARSER_LENGTH_HORIZONTAL),
RECT_DEF(ry, ry, SVG_PARSER_LENGTH_VERTICAL)
};
/* parse the attributes for a rect element.
* https://www.w3.org/TR/SVG/shapes.html#RectElement
*/
static Eina_Bool
_attr_parse_rect_node(void *data, const char *key, const char *value)
{
Evas_SVG_Loader *loader = data;
Svg_Node *node = loader->svg_parse->node;
Svg_Rect_Node *rect = & (node->node.rect);
unsigned int i;
unsigned char *array;
int sz = strlen(key);
array = (unsigned char*) rect;
for (i = 0; i < sizeof (rect_tags) / sizeof(rect_tags[0]); i++)
if (rect_tags[i].sz - 1 == sz && !strncmp(rect_tags[i].tag, key, sz))
{
*((double*) (array + rect_tags[i].offset)) = _to_double(loader->svg_parse, value, rect_tags[i].type);
//Case if only rx or ry is declared
if (!strncmp(rect_tags[i].tag, "rx", sz)) rect->has_rx = EINA_TRUE;
if (!strncmp(rect_tags[i].tag, "ry", sz)) rect->has_ry = EINA_TRUE;
if (!EINA_DBL_EQ(rect->rx, 0) && EINA_DBL_EQ(rect->ry, 0) && rect->has_rx && !rect->has_ry) rect->ry = rect->rx;
if (!EINA_DBL_EQ(rect->ry, 0) && EINA_DBL_EQ(rect->rx, 0) && !rect->has_rx && rect->has_ry) rect->rx = rect->ry;
return EINA_TRUE;
}
if (!strcmp(key, "id"))
{
node->id = _copy_id(value);
}
else if (!strcmp(key, "style"))
{
_attr_style_node(loader, value);
}
else if (!strcmp(key, "clip-path"))
{
_handle_clip_path_attr(loader, node, value);
}
else
{
_parse_style_attr(loader, key, value);
}
return EINA_TRUE;
}
static Svg_Node *
_create_rect_node(Evas_SVG_Loader *loader, Svg_Node *parent, const char *buf, unsigned buflen)
{
loader->svg_parse->node = _create_node(parent, SVG_NODE_RECT);
if (loader->svg_parse->node) {
loader->svg_parse->node->node.rect.has_rx = loader->svg_parse->node->node.rect.has_ry = EINA_FALSE;
}
eina_simple_xml_attributes_parse(buf, buflen,
_attr_parse_rect_node, loader);
return loader->svg_parse->node;
}
#define LINE_DEF(Name, Field, Type) \
{ #Name, Type, sizeof (#Name), offsetof(Svg_Line_Node, Field)}
static const struct {
const char *tag;
SVG_Parser_Length_Type type;
int sz;
size_t offset;
} line_tags[] = {
LINE_DEF(x1, x1, SVG_PARSER_LENGTH_HORIZONTAL),
LINE_DEF(y1, y1, SVG_PARSER_LENGTH_VERTICAL),
LINE_DEF(x2, x2, SVG_PARSER_LENGTH_HORIZONTAL),
LINE_DEF(y2, y2, SVG_PARSER_LENGTH_VERTICAL)
};
/* parse the attributes for a rect element.
* https://www.w3.org/TR/SVG/shapes.html#LineElement
*/
static Eina_Bool
_attr_parse_line_node(void *data, const char *key, const char *value)
{
Evas_SVG_Loader *loader = data;
Svg_Node *node = loader->svg_parse->node;
Svg_Line_Node *line = & (node->node.line);
unsigned int i;
unsigned char *array;
int sz = strlen(key);
array = (unsigned char*) line;
for (i = 0; i < sizeof (line_tags) / sizeof(line_tags[0]); i++)
if (line_tags[i].sz - 1 == sz && !strncmp(line_tags[i].tag, key, sz))
{
*((double*) (array + line_tags[i].offset)) = _to_double(loader->svg_parse, value, line_tags[i].type);
return EINA_TRUE;
}
if (!strcmp(key, "id"))
{
node->id = _copy_id(value);
}
else if (!strcmp(key, "style"))
{
_attr_style_node(loader, value);
}
else if (!strcmp(key, "clip-path"))
{
_handle_clip_path_attr(loader, node, value);
}
else
{
_parse_style_attr(loader, key, value);
}
return EINA_TRUE;
}
static Svg_Node *
_create_line_node(Evas_SVG_Loader *loader, Svg_Node *parent, const char *buf, unsigned buflen)
{
loader->svg_parse->node = _create_node(parent, SVG_NODE_LINE);
eina_simple_xml_attributes_parse(buf, buflen,
_attr_parse_line_node, loader);
return loader->svg_parse->node;
}
static Eina_Stringshare *
_id_from_href(const char *href)
{
href = _skip_space(href, NULL);
if ((*href) == '#')
href++;
return eina_stringshare_add(href);
}
static Svg_Node*
_get_defs_node(Svg_Node *node)
{
if (!node) return NULL;
while (node->parent != NULL)
{
node = node->parent;
}
if (node->type == SVG_NODE_DOC)
return node->node.doc.defs;
return NULL;
}
static Svg_Node*
_find_child_by_id(Svg_Node *node, const char *id)
{
Eina_List *l;
Svg_Node *child;
if (!node) return NULL;
EINA_LIST_FOREACH(node->child, l, child)
{
if ((child->id != NULL) && !strcmp(child->id, id))
return child;
}
return NULL;
}
static Svg_Node* _find_node_by_id(Svg_Node *node, const char* id)
{
Svg_Node *child, *result = NULL;
Eina_List *l;
if ((node->id) && !strcmp(node->id, id)) return node;
EINA_LIST_FOREACH(node->child, l, child)
{
result = _find_node_by_id(child, id);
if (result) break;
}
return result;
}
static Eina_List *
_clone_grad_stops(Eina_List *from)
{
Efl_Gfx_Gradient_Stop *stop;
Eina_List *l;
Eina_List *res = NULL;
EINA_LIST_FOREACH(from, l, stop)
{
Efl_Gfx_Gradient_Stop *new_stop;
new_stop = calloc(1, sizeof(Efl_Gfx_Gradient_Stop));
memcpy(new_stop, stop, sizeof(Efl_Gfx_Gradient_Stop));
res = eina_list_append(res, new_stop);
}
return res;
}
static Svg_Style_Gradient *
_clone_gradient(Svg_Style_Gradient *from)
{
Svg_Style_Gradient *grad;
if (!from) return NULL;
grad= calloc(1, sizeof(Svg_Style_Gradient));
grad->type = from->type;
grad->id = _copy_id(from->id);
grad->ref = _copy_id(from->ref);
grad->spread = from->spread;
grad->use_percentage = from->use_percentage;
grad->user_space = from->user_space;
if (from->transform)
{
grad->transform = calloc(1, sizeof(Eina_Matrix3));
eina_matrix3_copy(grad->transform, from->transform);
}
grad->stops = _clone_grad_stops(from->stops);
if (grad->type == SVG_LINEAR_GRADIENT)
{
grad->linear = calloc(1, sizeof(Svg_Linear_Gradient));
memcpy(grad->linear, from->linear, sizeof(Svg_Linear_Gradient));
}
else if (grad->type == SVG_RADIAL_GRADIENT)
{
grad->radial = calloc(1, sizeof(Svg_Radial_Gradient));
memcpy(grad->radial, from->radial, sizeof(Svg_Radial_Gradient));
}
return grad;
}
static void
_copy_attribute(Svg_Node *to, Svg_Node *from)
{
// copy matrix attribute
if (from->transform)
{
to->transform = calloc(1, sizeof(Eina_Matrix3));
eina_matrix3_copy(to->transform, from->transform);
}
// copy style attribute;
memcpy(to->style, from->style, sizeof(Svg_Style_Property));
// copy node attribute
switch (from->type)
{
case SVG_NODE_CIRCLE:
to->node.circle.cx = from->node.circle.cx;
to->node.circle.cy = from->node.circle.cy;
to->node.circle.r = from->node.circle.r;
break;
case SVG_NODE_ELLIPSE:
to->node.ellipse.cx = from->node.ellipse.cx;
to->node.ellipse.cy = from->node.ellipse.cy;
to->node.ellipse.rx = from->node.ellipse.rx;
to->node.ellipse.ry = from->node.ellipse.ry;
break;
case SVG_NODE_RECT:
to->node.rect.x = from->node.rect.x;
to->node.rect.y = from->node.rect.y;
to->node.rect.w = from->node.rect.w;
to->node.rect.h = from->node.rect.h;
to->node.rect.rx = from->node.rect.rx;
to->node.rect.ry = from->node.rect.ry;
to->node.rect.has_rx = from->node.rect.has_rx;
to->node.rect.has_ry = from->node.rect.has_ry;
break;
case SVG_NODE_LINE:
to->node.line.x1 = from->node.line.x1;
to->node.line.y1 = from->node.line.y1;
to->node.line.x2 = from->node.line.x2;
to->node.line.y2 = from->node.line.y2;
break;
case SVG_NODE_PATH:
to->node.path.path = eina_stringshare_add(from->node.path.path);
break;
case SVG_NODE_POLYGON:
to->node.polygon.points_count = from->node.polygon.points_count;
to->node.polygon.points = malloc(to->node.polygon.points_count * sizeof(double));
memcpy(to->node.polygon.points, from->node.polygon.points, to->node.polygon.points_count * sizeof(double));
break;
case SVG_NODE_POLYLINE:
to->node.polyline.points_count = from->node.polyline.points_count;
to->node.polyline.points = malloc(to->node.polyline.points_count * sizeof(double));
memcpy(to->node.polyline.points, from->node.polyline.points, to->node.polyline.points_count * sizeof(double));
break;
default:
break;
}
}
static void
_clone_node(Svg_Node *from, Svg_Node *parent)
{
Svg_Node *new_node;
Eina_List *l;
Svg_Node *child;
if (!from) return;
new_node = _create_node(parent, from->type);
_copy_attribute(new_node, from);
EINA_LIST_FOREACH(from->child, l, child)
{
_clone_node(child, new_node);
}
}
static Eina_Bool
_attr_parse_use_node(void *data, const char *key, const char *value)
{
Evas_SVG_Loader *loader = data;
Svg_Node *defs, *node_from, *node = loader->svg_parse->node;
Eina_Stringshare *id;
if (!strcmp(key, "xlink:href"))
{
id = _id_from_href(value);
defs = _get_defs_node(node);
node_from = _find_child_by_id(defs, id);
_clone_node(node_from, node);
eina_stringshare_del(id);
}
else if (!strcmp(key, "clip-path"))
{
_handle_clip_path_attr(loader, node, value);
}
else
{
_attr_parse_g_node(data, key, value);
}
return EINA_TRUE;
}
static Svg_Node *
_create_use_node(Evas_SVG_Loader *loader, Svg_Node *parent, const char *buf, unsigned buflen)
{
loader->svg_parse->node = _create_node(parent, SVG_NODE_G);
eina_simple_xml_attributes_parse(buf, buflen,
_attr_parse_use_node, loader);
return loader->svg_parse->node;
}
#define TAG_DEF(Name) \
{ #Name, sizeof (#Name), _create_##Name##_node }
//TODO: implement 'text' primitive
static const struct {
const char *tag;
int sz;
Factory_Method tag_handler;
} graphics_tags[] = {
TAG_DEF(use),
TAG_DEF(circle),
TAG_DEF(ellipse),
TAG_DEF(path),
TAG_DEF(polygon),
TAG_DEF(rect),
TAG_DEF(polyline),
TAG_DEF(line),
};
static const struct {
const char *tag;
int sz;
Factory_Method tag_handler;
} group_tags[] = {
TAG_DEF(defs),
TAG_DEF(g),
TAG_DEF(svg),
TAG_DEF(switch),
TAG_DEF(mask),
TAG_DEF(clipPath)
};
#define FIND_FACTORY(Short_Name, Tags_Array) \
static Factory_Method \
_find_##Short_Name##_factory(const char *name) \
{ \
unsigned int i; \
int sz = strlen(name); \
\
for (i = 0; i < sizeof (Tags_Array) / sizeof(Tags_Array[0]); i++) \
if (Tags_Array[i].sz - 1 == sz && !strncmp(Tags_Array[i].tag, name, sz)) \
{ \
return Tags_Array[i].tag_handler; \
} \
return NULL; \
}
FIND_FACTORY(group, group_tags);
FIND_FACTORY(graphics, graphics_tags);
Efl_Gfx_Gradient_Spread
_parse_spread_value(const char *value)
{
Efl_Gfx_Gradient_Spread spread = EFL_GFX_GRADIENT_SPREAD_PAD;
if (!strcmp(value, "reflect"))
{
spread = EFL_GFX_GRADIENT_SPREAD_REFLECT;
}
else if (!strcmp(value, "repeat"))
{
spread = EFL_GFX_GRADIENT_SPREAD_REPEAT;
}
return spread;
}
static void
_handle_radial_cx_attr(Evas_SVG_Loader *loader, Svg_Radial_Gradient* radial, const char *value)
{
radial->cx = _gradient_to_double(loader->svg_parse, value, SVG_PARSER_LENGTH_HORIZONTAL);
if (!loader->svg_parse->gradient.fx_parsed)
radial->fx = radial->cx;
}
static void
_handle_radial_cy_attr(Evas_SVG_Loader *loader, Svg_Radial_Gradient* radial, const char *value)
{
radial->cy = _gradient_to_double(loader->svg_parse, value, SVG_PARSER_LENGTH_VERTICAL);
if (!loader->svg_parse->gradient.fy_parsed)
radial->fy = radial->cy;
}
static void
_handle_radial_fx_attr(Evas_SVG_Loader *loader, Svg_Radial_Gradient* radial, const char *value)
{
radial->fx = _gradient_to_double(loader->svg_parse, value, SVG_PARSER_LENGTH_HORIZONTAL);
loader->svg_parse->gradient.fx_parsed = EINA_TRUE;
}
static void
_handle_radial_fy_attr(Evas_SVG_Loader *loader, Svg_Radial_Gradient* radial, const char *value)
{
radial->fy = _gradient_to_double(loader->svg_parse, value, SVG_PARSER_LENGTH_VERTICAL);
loader->svg_parse->gradient.fy_parsed = EINA_TRUE;
}
static void
_handle_radial_r_attr(Evas_SVG_Loader *loader, Svg_Radial_Gradient* radial, const char *value)
{
radial->r = _gradient_to_double(loader->svg_parse, value, SVG_PARSER_LENGTH_OTHER);
}
static void
_recalc_radial_cx_attr(Evas_SVG_Loader *loader, Svg_Radial_Gradient* radial, Eina_Bool user_space)
{
if (!user_space)
{
radial->cx = radial->cx * loader->svg_parse->global.width;
}
}
static void
_recalc_radial_cy_attr(Evas_SVG_Loader *loader, Svg_Radial_Gradient* radial, Eina_Bool user_space)
{
if (!user_space)
{
radial->cy = radial->cy * loader->svg_parse->global.height;
}
}
static void
_recalc_radial_fx_attr(Evas_SVG_Loader *loader, Svg_Radial_Gradient* radial, Eina_Bool user_space)
{
if (!user_space)
{
radial->fx = radial->fx * loader->svg_parse->global.width;
}
}
static void
_recalc_radial_fy_attr(Evas_SVG_Loader *loader, Svg_Radial_Gradient* radial, Eina_Bool user_space)
{
if (!user_space)
{
radial->fy = radial->fy * loader->svg_parse->global.height;
}
}
static void
_recalc_radial_r_attr(Evas_SVG_Loader *loader, Svg_Radial_Gradient* radial, Eina_Bool user_space)
{
if (!user_space)
{
radial->r = radial->r * (sqrt(pow(loader->svg_parse->global.height, 2) + pow(loader->svg_parse->global.width, 2)) / sqrt(2.0));
}
}
typedef void (*Radial_Method)(Evas_SVG_Loader *loader, Svg_Radial_Gradient *radial, const char *value);
typedef void (*Radial_Method_Recalc)(Evas_SVG_Loader *loader, Svg_Radial_Gradient *radial, Eina_Bool user_space);
#define RADIAL_DEF(Name) \
{ #Name, sizeof (#Name), _handle_radial_##Name##_attr, _recalc_radial_##Name##_attr}
static const struct {
const char *tag;
int sz;
Radial_Method tag_handler;;
Radial_Method_Recalc tag_recalc;
} radial_tags[] = {
RADIAL_DEF(cx),
RADIAL_DEF(cy),
RADIAL_DEF(fx),
RADIAL_DEF(fy),
RADIAL_DEF(r)
};
static Eina_Bool
_attr_parse_radial_gradient_node(void *data, const char *key, const char *value)
{
Evas_SVG_Loader *loader = data;
Svg_Style_Gradient *grad = loader->svg_parse->style_grad;
Svg_Radial_Gradient *radial = grad->radial;
unsigned int i;
int sz = strlen(key);
for (i = 0; i < sizeof (radial_tags) / sizeof(radial_tags[0]); i++)
if (radial_tags[i].sz - 1 == sz && !strncmp(radial_tags[i].tag, key, sz))
{
radial_tags[i].tag_handler(loader, radial, value);
return EINA_TRUE;
}
if (!strcmp(key, "id"))
{
grad->id = _copy_id(value);
}
else if (!strcmp(key, "spreadMethod"))
{
grad->spread = _parse_spread_value(value);
}
else if (!strcmp(key, "xlink:href"))
{
grad->ref = _id_from_href(value);
}
else if (!strcmp(key, "gradientUnits") && !strcmp(value, "userSpaceOnUse"))
{
grad->user_space = EINA_TRUE;
}
return EINA_TRUE;
}
static Svg_Style_Gradient *
_create_radialGradient(Evas_SVG_Loader *loader, const char *buf, unsigned buflen)
{
unsigned int i = 0;
Svg_Style_Gradient *grad = calloc(1, sizeof(Svg_Style_Gradient));
loader->svg_parse->style_grad = grad;
grad->type = SVG_RADIAL_GRADIENT;
grad->user_space = EINA_FALSE;
grad->radial = calloc(1, sizeof(Svg_Radial_Gradient));
/**
* Default values of gradient
*/
grad->radial->cx = 0.5;
grad->radial->cy = 0.5;
grad->radial->fx = 0.5;
grad->radial->fy = 0.5;
grad->radial->r = 0.5;
loader->svg_parse->gradient.fx_parsed = EINA_FALSE;
loader->svg_parse->gradient.fy_parsed = EINA_FALSE;
eina_simple_xml_attributes_parse(buf, buflen,
_attr_parse_radial_gradient_node, loader);
for (i = 0; i < sizeof (radial_tags) / sizeof(radial_tags[0]); i++)
radial_tags[i].tag_recalc(loader, grad->radial, grad->user_space);
grad->use_percentage = EINA_TRUE;
return loader->svg_parse->style_grad;
}
static Eina_Bool
_attr_parse_stops(void *data, const char *key, const char *value)
{
Evas_SVG_Loader *loader = data;
Efl_Gfx_Gradient_Stop *stop = loader->svg_parse->grad_stop;
if (!strcmp(key, "offset"))
{
stop->offset = _to_offset(value);
}
else if (!strcmp(key, "stop-opacity"))
{
stop->a = _to_opacity(value);
}
else if (!strcmp(key, "stop-color"))
{
_to_color(value, &stop->r, &stop->g, &stop->b, NULL);
}
else if (!strcmp(key, "style"))
{
eina_simple_xml_attribute_w3c_parse(value,
_attr_parse_stops, data);
}
return EINA_TRUE;
}
static void
_handle_linear_x1_attr(Evas_SVG_Loader *loader, Svg_Linear_Gradient* linear, const char *value)
{
linear->x1 = _gradient_to_double(loader->svg_parse, value, SVG_PARSER_LENGTH_HORIZONTAL);
}
static void
_handle_linear_y1_attr(Evas_SVG_Loader *loader, Svg_Linear_Gradient* linear, const char *value)
{
linear->y1 = _gradient_to_double(loader->svg_parse, value, SVG_PARSER_LENGTH_VERTICAL);
}
static void
_handle_linear_x2_attr(Evas_SVG_Loader *loader, Svg_Linear_Gradient* linear, const char *value)
{
linear->x2 = _gradient_to_double(loader->svg_parse, value, SVG_PARSER_LENGTH_HORIZONTAL);
}
static void
_handle_linear_y2_attr(Evas_SVG_Loader *loader, Svg_Linear_Gradient* linear, const char *value)
{
linear->y2 = _gradient_to_double(loader->svg_parse, value, SVG_PARSER_LENGTH_VERTICAL);
}
static void
_recalc_linear_x1_attr(Evas_SVG_Loader *loader, Svg_Linear_Gradient* linear, Eina_Bool user_space)
{
if (!user_space)
{
linear->x1 = linear->x1 * loader->svg_parse->global.width;
}
}
static void
_recalc_linear_y1_attr(Evas_SVG_Loader *loader, Svg_Linear_Gradient* linear, Eina_Bool user_space)
{
if (!user_space)
{
linear->y1 = linear->y1 * loader->svg_parse->global.height;
}
}
static void
_recalc_linear_x2_attr(Evas_SVG_Loader *loader, Svg_Linear_Gradient* linear, Eina_Bool user_space)
{
if (!user_space)
{
linear->x2 = linear->x2 * loader->svg_parse->global.width;
}
}
static void
_recalc_linear_y2_attr(Evas_SVG_Loader *loader, Svg_Linear_Gradient* linear, Eina_Bool user_space)
{
if (!user_space)
{
linear->y2 = linear->y2 * loader->svg_parse->global.height;
}
}
typedef void (*Linear_Method)(Evas_SVG_Loader *loader, Svg_Linear_Gradient *linear, const char *value);
typedef void (*Linear_Method_Recalc)(Evas_SVG_Loader *loader, Svg_Linear_Gradient *linear, Eina_Bool user_space);
#define LINEAR_DEF(Name) \
{ #Name, sizeof (#Name), _handle_linear_##Name##_attr, _recalc_linear_##Name##_attr}
static const struct {
const char *tag;
int sz;
Linear_Method tag_handler;
Linear_Method_Recalc tag_recalc;
} linear_tags[] = {
LINEAR_DEF(x1),
LINEAR_DEF(y1),
LINEAR_DEF(x2),
LINEAR_DEF(y2)
};
static Eina_Bool
_attr_parse_linear_gradient_node(void *data, const char *key, const char *value)
{
Evas_SVG_Loader *loader = data;
Svg_Style_Gradient *grad = loader->svg_parse->style_grad;
Svg_Linear_Gradient *linear = grad->linear;
unsigned int i;
int sz = strlen(key);
for (i = 0; i < sizeof (linear_tags) / sizeof(linear_tags[0]); i++)
if (linear_tags[i].sz - 1 == sz && !strncmp(linear_tags[i].tag, key, sz))
{
linear_tags[i].tag_handler(loader, linear, value);
return EINA_TRUE;
}
if (!strcmp(key, "id"))
{
grad->id = _copy_id(value);
}
else if (!strcmp(key, "spreadMethod"))
{
grad->spread = _parse_spread_value(value);
}
else if (!strcmp(key, "xlink:href"))
{
grad->ref = _id_from_href(value);
}
else if (!strcmp(key, "gradientUnits") && !strcmp(value, "userSpaceOnUse"))
{
grad->user_space = EINA_TRUE;
}
else if (!strcmp(key, "gradientTransform"))
{
grad->transform = _parse_transformation_matrix(value);
}
return EINA_TRUE;
}
static Svg_Style_Gradient *
_create_linearGradient(Evas_SVG_Loader *loader, const char *buf, unsigned buflen)
{
Svg_Style_Gradient *grad = calloc(1, sizeof(Svg_Style_Gradient));
loader->svg_parse->style_grad = grad;
unsigned int i;
grad->type = SVG_LINEAR_GRADIENT;
grad->user_space = EINA_FALSE;
grad->linear = calloc(1, sizeof(Svg_Linear_Gradient));
/**
* Default value of x2 is 100%
*/
grad->linear->x2 = 1;
eina_simple_xml_attributes_parse(buf, buflen,
_attr_parse_linear_gradient_node, loader);
for (i = 0; i < sizeof (linear_tags) / sizeof(linear_tags[0]); i++)
linear_tags[i].tag_recalc(loader, grad->linear, grad->user_space);
grad->use_percentage = EINA_TRUE;
return loader->svg_parse->style_grad;
}
#define GRADIENT_DEF(Name) \
{ #Name, sizeof (#Name), _create_##Name }
/**
* For all Gradients lengths would be calculated into percentages related to
* canvas width and height.
*
* if user then recalculate actual pixels into percentages
*/
static const struct {
const char *tag;
int sz;
Gradient_Factory_Method tag_handler;
} gradient_tags[] = {
GRADIENT_DEF(linearGradient),
GRADIENT_DEF(radialGradient)
};
static Gradient_Factory_Method
_find_gradient_factory(const char *name)
{
unsigned int i;
int sz = strlen(name);
for (i = 0; i < sizeof (gradient_tags) / sizeof(gradient_tags[0]); i++)
if (gradient_tags[i].sz - 1 == sz && !strncmp(gradient_tags[i].tag, name, sz))
{
return gradient_tags[i].tag_handler;
}
return NULL;
}
static Svg_Node*
_get_parent_node_from_loader(Evas_SVG_Loader *loader)
{
if (eina_array_count(loader->stack) > 0)
return eina_array_data_get(loader->stack, eina_array_count(loader->stack) - 1);
else
return loader->doc;
}
static void
_evas_svg_loader_xml_open_parser(Evas_SVG_Loader *loader,
const char *content, unsigned int length, Eina_Bool empty)
{
const char *attrs = NULL;
int attrs_length = 0;
int sz = length;
char tag_name[20] = "";
Factory_Method method;
Gradient_Factory_Method gradient_method;
Svg_Node *node = NULL, *parent;
loader->level++;
attrs = eina_simple_xml_tag_attributes_find(content, length);
if (!attrs)
{
// parse the empty tag
attrs = content;
while ((attrs != NULL) && *attrs != '>')
attrs++;
}
if (attrs)
{
// find out the tag name starting from content till sz length
sz = attrs - content;
attrs_length = length - sz;
while ((sz > 0) && (isspace(content[sz - 1])))
sz--;
if ((unsigned int)sz >= sizeof(tag_name)) return;
strncpy(tag_name, content, sz);
tag_name[sz] = '\0';
}
if ((method = _find_group_factory(tag_name)))
{
//group
if (!loader->doc)
{
if (strcmp(tag_name, "svg"))
return; // Not a valid svg document
node = method(loader, NULL, attrs, attrs_length);
loader->doc = node;
}
else
{
if (!strcmp(tag_name, "svg")) return; //Already loadded <svg>(SvgNodeType::Doc) tag
parent = _get_parent_node_from_loader(loader);
node = method(loader, parent, attrs, attrs_length);
}
if (node->type == SVG_NODE_DEFS)
{
loader->doc->node.doc.defs = node;
loader->def = node;
if (!empty) eina_array_push(loader->stack, node);
}
else eina_array_push(loader->stack, node);
}
else if ((method = _find_graphics_factory(tag_name)))
{
parent = _get_parent_node_from_loader(loader);
node = method(loader, parent, attrs, attrs_length);
}
else if ((gradient_method = _find_gradient_factory(tag_name)))
{
Svg_Style_Gradient *gradient;
gradient = gradient_method(loader, attrs, attrs_length);
/*FIXME: The current parsing structure does not distinguish end tags.
There is no way to know if the currently parsed gradient is in defs.
If a gradient is declared outside of defs after defs is set, it is included in the gradients of defs.
But finally, the loader has a gradient style list regardless of defs.
This is only to support this when multiple gradients are declared, even if no defs are declared.
refer to: https://developer.mozilla.org/en-US/docs/Web/SVG/Element/defs */
if (loader->doc->node.doc.defs)
{
loader->def->node.defs.gradients = eina_list_append(loader->def->node.defs.gradients, gradient);
}
else
{
loader->gradients = eina_list_append(loader->gradients, gradient);
}
loader->latest_gradient = gradient;
}
else if (!strcmp(tag_name, "stop"))
{
Efl_Gfx_Gradient_Stop *stop = calloc(1, sizeof(Efl_Gfx_Gradient_Stop));
loader->svg_parse->grad_stop = stop;
/* default value for opacity */
stop->a = 255;
eina_simple_xml_attributes_parse(attrs, attrs_length,
_attr_parse_stops, loader);
if (loader->latest_gradient)
{
loader->latest_gradient->stops = eina_list_append(loader->latest_gradient->stops, stop);
}
}
}
#define POP_TAG(Tag) \
{ #Tag, sizeof (#Tag) }
static const struct {
const char *tag;
size_t sz;
} pop_array[] = {
POP_TAG(g),
POP_TAG(svg),
POP_TAG(defs),
POP_TAG(mask),
POP_TAG(clipPath)
};
static void
_evas_svg_loader_xml_close_parser(Evas_SVG_Loader *loader,
const char *content,
unsigned int length EINA_UNUSED)
{
unsigned int i;
content = _skip_space(content, NULL);
for (i = 0; i < sizeof (pop_array) / sizeof (pop_array[0]); i++)
if (!strncmp(content, pop_array[i].tag, pop_array[i].sz - 1))
{
eina_array_pop(loader->stack);
break ;
}
loader->level--;
}
static Eina_Bool
_evas_svg_loader_parser(void *data, Eina_Simple_XML_Type type,
const char *content,
unsigned int offset EINA_UNUSED, unsigned int length)
{
Evas_SVG_Loader *loader = data;
switch (type)
{
case EINA_SIMPLE_XML_OPEN:
_evas_svg_loader_xml_open_parser(loader, content, length, EINA_FALSE);
break;
case EINA_SIMPLE_XML_OPEN_EMPTY:
_evas_svg_loader_xml_open_parser(loader, content, length, EINA_TRUE);
break;
case EINA_SIMPLE_XML_CLOSE:
_evas_svg_loader_xml_close_parser(loader, content, length);
break;
case EINA_SIMPLE_XML_DATA:
case EINA_SIMPLE_XML_CDATA:
case EINA_SIMPLE_XML_DOCTYPE_CHILD:
break;
case EINA_SIMPLE_XML_IGNORED:
case EINA_SIMPLE_XML_COMMENT:
case EINA_SIMPLE_XML_DOCTYPE:
break;
default:
break;
}
return EINA_TRUE;
}
static void
_inherit_style(Svg_Style_Property *child, Svg_Style_Property *parent)
{
if (parent == NULL)
return;
// inherit the property of parent if not present in child.
// fill
if (!(child->fill.flags & SVG_FILL_FLAGS_PAINT))
{
child->fill.paint.r = parent->fill.paint.r;
child->fill.paint.g = parent->fill.paint.g;
child->fill.paint.b = parent->fill.paint.b;
child->fill.paint.none = parent->fill.paint.none;
child->fill.paint.cur_color = parent->fill.paint.cur_color;
child->fill.paint.url = _copy_id(parent->fill.paint.url);
}
if (!(child->fill.flags & SVG_FILL_FLAGS_OPACITY))
{
child->fill.opacity = parent->fill.opacity;
}
if (!(child->fill.flags & SVG_FILL_FLAGS_FILL_RULE))
{
child->fill.fill_rule = parent->fill.fill_rule;
}
// stroke
if (!(child->stroke.flags & SVG_STROKE_FLAGS_PAINT))
{
child->stroke.paint.r = parent->stroke.paint.r;
child->stroke.paint.g = parent->stroke.paint.g;
child->stroke.paint.b = parent->stroke.paint.b;
child->stroke.paint.none = parent->stroke.paint.none;
child->stroke.paint.cur_color = parent->stroke.paint.cur_color;
child->stroke.paint.url = _copy_id(parent->stroke.paint.url);
}
if (!(child->stroke.flags & SVG_STROKE_FLAGS_OPACITY))
{
child->stroke.opacity = parent->stroke.opacity;
}
if (!(child->stroke.flags & SVG_STROKE_FLAGS_WIDTH))
{
child->stroke.width = parent->stroke.width;
}
if (!(child->stroke.flags & SVG_STROKE_FLAGS_CAP))
{
child->stroke.cap = parent->stroke.cap;
}
if (!(child->stroke.flags & SVG_STROKE_FLAGS_JOIN))
{
child->stroke.join = parent->stroke.join;
}
if (!(child->stroke.flags & SVG_STROKE_FLAGS_DASH))
{
int i = 0;
int count = parent->stroke.dash_count;
if (count > 0)
{
if (child->stroke.dash) free(child->stroke.dash);
child->stroke.dash = calloc(count, sizeof(Efl_Gfx_Dash));
child->stroke.dash_count = count;
for (i = 0; i < count; i++)
{
child->stroke.dash[i].length = parent->stroke.dash[i].length;
child->stroke.dash[i].gap = parent->stroke.dash[i].gap;
}
}
}
}
void
_update_style(Svg_Node *node, Svg_Style_Property *parent_style)
{
Eina_List *l;
Svg_Node *child;
_inherit_style(node->style, parent_style);
EINA_LIST_FOREACH(node->child, l, child)
{
_update_style(child, node->style);
}
}
static Svg_Style_Gradient*
_dup_gradient(Eina_List *grad_list, const char *id)
{
Svg_Style_Gradient *grad;
Svg_Style_Gradient *result = NULL;
Eina_List *l;
EINA_LIST_FOREACH(grad_list, l, grad)
{
if (!strcmp(grad->id, id))
{
result = _clone_gradient(grad);
break;
}
}
if (result && result->ref)
{
EINA_LIST_FOREACH(grad_list, l, grad)
{
if (!strcmp(grad->id, result->ref))
{
if (!result->stops)
{
result->stops = _clone_grad_stops(grad->stops);
}
//TODO properly inherit other property
break;
}
}
}
return result;
}
void
_update_gradient(Svg_Node *node, Eina_List *grad_list)
{
Eina_List *l;
Svg_Node *child;
if (node->child)
{
EINA_LIST_FOREACH(node->child, l, child)
{
_update_gradient(child, grad_list);
}
}
else
{
if (node->style->fill.paint.url)
{
node->style->fill.paint.gradient = _dup_gradient(grad_list, node->style->fill.paint.url);
}
else if (node->style->stroke.paint.url)
{
node->style->stroke.paint.gradient = _dup_gradient(grad_list, node->style->stroke.paint.url);
}
}
}
static void _update_composite(Svg_Node* node, Svg_Node* root)
{
Svg_Node *child;
Eina_List *l;
if (node->style->comp.url && !node->style->comp.node) {
Svg_Node *findResult = _find_node_by_id(root, node->style->comp.url);
if (findResult) node->style->comp.node = findResult;
}
EINA_LIST_FOREACH(node->child, l, child)
{
_update_composite(child, root);
}
}
static Eina_Bool
evas_vg_load_file_data_svg(Vg_File_Data *vfd EINA_UNUSED)
{
return EINA_TRUE;
}
static Eina_Bool
evas_vg_load_file_close_svg(Vg_File_Data *vfd)
{
if (vfd->root) efl_unref(vfd->root);
free(vfd);
return EINA_TRUE;
}
static Vg_File_Data*
evas_vg_load_file_open_svg(Eina_File *file,
const char *key EINA_UNUSED,
int *error EINA_UNUSED)
{
Evas_SVG_Loader loader = {
NULL, NULL, NULL, NULL, NULL, 0, EINA_FALSE
};
const char *content;
unsigned int length;
Svg_Node *defs;
loader.svg_parse = calloc(1, sizeof(Evas_SVG_Parser));
length = eina_file_size_get(file);
content = eina_file_map_all(file, EINA_FILE_SEQUENTIAL);
if (content)
{
loader.stack = eina_array_new(8);
eina_simple_xml_parse(content, length, EINA_TRUE,
_evas_svg_loader_parser, &loader);
eina_array_free(loader.stack);
eina_file_map_free(file, (void*) content);
}
if (loader.doc)
{
_update_style(loader.doc, NULL);
defs = loader.doc->node.doc.defs;
if (defs)
_update_gradient(loader.doc, defs->node.defs.gradients);
if (loader.gradients)
{
Eina_List* gradient_list = loader.gradients;
_update_gradient(loader.doc, gradient_list);
eina_list_free(gradient_list);
}
_update_composite(loader.doc, loader.doc);
if (defs) _update_composite(loader.doc, defs);
*error = EVAS_LOAD_ERROR_NONE;
}
else
{
*error = EVAS_LOAD_ERROR_GENERIC;
}
free(loader.svg_parse);
Vg_File_Data* result = vg_common_svg_create_vg_node(loader.doc);
vg_common_svg_node_free(loader.doc);
return result;
}
static Evas_Vg_Load_Func evas_vg_load_svg_func =
{
evas_vg_load_file_open_svg,
evas_vg_load_file_close_svg,
evas_vg_load_file_data_svg,
};
static int
module_open(Evas_Module *em)
{
if (!em) return 0;
em->functions = (void *)(&evas_vg_load_svg_func);
_evas_vg_loader_svg_log_dom = eina_log_domain_register
("vg-load-svg", EVAS_DEFAULT_LOG_COLOR);
if (_evas_vg_loader_svg_log_dom < 0)
{
EINA_LOG_ERR("Can not create a module log domain.");
return 0;
}
return 1;
}
static void
module_close(Evas_Module *em EINA_UNUSED)
{
if (_evas_vg_loader_svg_log_dom >= 0)
{
eina_log_domain_unregister(_evas_vg_loader_svg_log_dom);
_evas_vg_loader_svg_log_dom = -1;
}
}
static Evas_Module_Api evas_modapi =
{
EVAS_MODULE_API_VERSION,
"svg",
"none",
{
module_open,
module_close
}
};
EVAS_MODULE_DEFINE(EVAS_MODULE_TYPE_VG_LOADER, vg_loader, svg);
#ifndef EVAS_STATIC_BUILD_VG_SVG
EVAS_EINA_MODULE_DEFINE(vg_loader, svg);
#endif
Reference in New Issue View Git Blame Copy Permalink