1	// Copyright (C) 2022 The Qt Company Ltd.
2	// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
3
4	#include "qplatformdefs.h"
5
6	#include "qsvghandler_p.h"
7
8	#include "qsvgtinydocument_p.h"
9	#include "qsvgstructure_p.h"
10	#include "qsvggraphics_p.h"
11	#include "qsvgfilter_p.h"
12	#include "qsvgnode_p.h"
13	#include "qsvgfont_p.h"
14
15	#include "qpen.h"
16	#include "qpainterpath.h"
17	#include "qbrush.h"
18	#include "qcolor.h"
19	#include "qtextformat.h"
20	#include "qlist.h"
21	#include "qfileinfo.h"
22	#include "qfile.h"
23	#include "qdir.h"
24	#include "qdebug.h"
25	#include "qmath.h"
26	#include "qnumeric.h"
27	#include <qregularexpression.h>
28	#include "qtransform.h"
29	#include "qvarlengtharray.h"
30	#include "private/qmath_p.h"
31	#include "qimagereader.h"
32
33	#include "float.h"
34	#include <cmath>
35
36	QT_BEGIN_NAMESPACE
37
38	Q_LOGGING_CATEGORY(lcSvgHandler, "qt.svg")
39
40	static const char *qt_inherit_text = "inherit";
41	#define QT_INHERIT QLatin1String(qt_inherit_text)
42
43	static QByteArray prefixMessage(const QByteArray &msg, const QXmlStreamReader *r)
44	{
45	QByteArray result;
46	if (r) {
47	if (const QFile *file = qobject_cast<const QFile *>(object: r->device()))
48	result.append(a: QFile::encodeName(fileName: QDir::toNativeSeparators(pathName: file->fileName())));
49	else
50	result.append(QByteArrayLiteral("<input>"));
51	result.append(c: ':');
52	result.append(a: QByteArray::number(r->lineNumber()));
53	if (const qint64 column = r->columnNumber()) {
54	result.append(c: ':');
55	result.append(a: QByteArray::number(column));
56	}
57	result.append(QByteArrayLiteral(": "));
58	}
59	result.append(a: msg);
60	return result;
61	}
62
63	static inline QByteArray msgProblemParsing(const QString &localName, const QXmlStreamReader *r)
64	{
65	return prefixMessage(QByteArrayLiteral("Problem parsing ") + localName.toLocal8Bit(), r);
66	}
67
68	static inline QByteArray msgCouldNotResolveProperty(const QString &id, const QXmlStreamReader *r)
69	{
70	return prefixMessage(QByteArrayLiteral("Could not resolve property: ") + id.toLocal8Bit(), r);
71	}
72
73	// ======== duplicated from qcolor_p
74
75	static inline int qsvg_h2i(char hex, bool *ok = nullptr)
76	{
77	if (hex >= '0' && hex <= '9')
78	return hex - '0';
79	if (hex >= 'a' && hex <= 'f')
80	return hex - 'a' + 10;
81	if (hex >= 'A' && hex <= 'F')
82	return hex - 'A' + 10;
83	if (ok)
84	*ok = false;
85	return -1;
86	}
87
88	static inline int qsvg_hex2int(const char *s, bool *ok = nullptr)
89	{
90	return (qsvg_h2i(hex: s[0], ok) * 16) | qsvg_h2i(hex: s[1], ok);
91	}
92
93	static inline int qsvg_hex2int(char s, bool *ok = nullptr)
94	{
95	int h = qsvg_h2i(hex: s, ok);
96	return (h * 16) | h;
97	}
98
99	bool qsvg_get_hex_rgb(const char *name, QRgb *rgb)
100	{
101	if(name[0] != '#')
102	return false;
103	name++;
104	const size_t len = qstrlen(str: name);
105	int r, g, b;
106	bool ok = true;
107	if (len == 12) {
108	r = qsvg_hex2int(s: name, ok: &ok);
109	g = qsvg_hex2int(s: name + 4, ok: &ok);
110	b = qsvg_hex2int(s: name + 8, ok: &ok);
111	} else if (len == 9) {
112	r = qsvg_hex2int(s: name, ok: &ok);
113	g = qsvg_hex2int(s: name + 3, ok: &ok);
114	b = qsvg_hex2int(s: name + 6, ok: &ok);
115	} else if (len == 6) {
116	r = qsvg_hex2int(s: name, ok: &ok);
117	g = qsvg_hex2int(s: name + 2, ok: &ok);
118	b = qsvg_hex2int(s: name + 4, ok: &ok);
119	} else if (len == 3) {
120	r = qsvg_hex2int(s: name[0], ok: &ok);
121	g = qsvg_hex2int(s: name[1], ok: &ok);
122	b = qsvg_hex2int(s: name[2], ok: &ok);
123	} else {
124	r = g = b = -1;
125	}
126	if ((uint)r > 255 || (uint)g > 255 || (uint)b > 255 || !ok) {
127	*rgb = 0;
128	return false;
129	}
130	*rgb = qRgb(r, g ,b);
131	return true;
132	}
133
134	bool qsvg_get_hex_rgb(const QChar *str, int len, QRgb *rgb)
135	{
136	if (len > 13)
137	return false;
138	char tmp[16];
139	for(int i = 0; i < len; ++i)
140	tmp[i] = str[i].toLatin1();
141	tmp[len] = 0;
142	return qsvg_get_hex_rgb(name: tmp, rgb);
143	}
144
145	// ======== end of qcolor_p duplicate
146
147	static bool parsePathDataFast(QStringView data, QPainterPath &path, bool limitLength = true);
148
149	static inline QString someId(const QXmlStreamAttributes &attributes)
150	{
151	QString id = attributes.value(qualifiedName: QLatin1String("id")).toString();
152	if (id.isEmpty())
153	id = attributes.value(qualifiedName: QLatin1String("xml:id")).toString();
154	return id;
155	}
156
157	struct QSvgAttributes
158	{
159	QSvgAttributes(const QXmlStreamAttributes &xmlAttributes, QSvgHandler *handler);
160
161	QString id;
162
163	QStringView color;
164	QStringView colorOpacity;
165	QStringView fill;
166	QStringView fillRule;
167	QStringView fillOpacity;
168	QStringView stroke;
169	QStringView strokeDashArray;
170	QStringView strokeDashOffset;
171	QStringView strokeLineCap;
172	QStringView strokeLineJoin;
173	QStringView strokeMiterLimit;
174	QStringView strokeOpacity;
175	QStringView strokeWidth;
176	QStringView vectorEffect;
177	QStringView fontFamily;
178	QStringView fontSize;
179	QStringView fontStyle;
180	QStringView fontWeight;
181	QStringView fontVariant;
182	QStringView textAnchor;
183	QStringView transform;
184	QStringView visibility;
185	QStringView opacity;
186	QStringView compOp;
187	QStringView display;
188	QStringView offset;
189	QStringView stopColor;
190	QStringView stopOpacity;
191	QStringView imageRendering;
192	QStringView mask;
193	QStringView markerStart;
194	QStringView markerMid;
195	QStringView markerEnd;
196	QStringView filter;
197
198
199	#ifndef QT_NO_CSSPARSER
200	QList<QSvgCssAttribute> m_cssAttributes;
201	#endif
202	};
203
204	QSvgAttributes::QSvgAttributes(const QXmlStreamAttributes &xmlAttributes, QSvgHandler *handler)
205	{
206	for (int i = 0; i < xmlAttributes.size(); ++i) {
207	const QXmlStreamAttribute &attribute = xmlAttributes.at(i);
208	QStringView name = attribute.qualifiedName();
209	if (name.isEmpty())
210	continue;
211	QStringView value = attribute.value();
212
213	switch (name.at(n: 0).unicode()) {
214
215	case 'c':
216	if (name == QLatin1String("color"))
217	color = value;
218	else if (name == QLatin1String("color-opacity"))
219	colorOpacity = value;
220	else if (name == QLatin1String("comp-op"))
221	compOp = value;
222	break;
223
224	case 'd':
225	if (name == QLatin1String("display"))
226	display = value;
227	break;
228
229	case 'f':
230	if (name == QLatin1String("fill"))
231	fill = value;
232	else if (name == QLatin1String("fill-rule"))
233	fillRule = value;
234	else if (name == QLatin1String("fill-opacity"))
235	fillOpacity = value;
236	else if (name == QLatin1String("font-family"))
237	fontFamily = value;
238	else if (name == QLatin1String("font-size"))
239	fontSize = value;
240	else if (name == QLatin1String("font-style"))
241	fontStyle = value;
242	else if (name == QLatin1String("font-weight"))
243	fontWeight = value;
244	else if (name == QLatin1String("font-variant"))
245	fontVariant = value;
246	else if (name == QLatin1String("filter") &&
247	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly))
248	filter = value;
249	break;
250
251	case 'i':
252	if (name == QLatin1String("id"))
253	id = value.toString();
254	else if (name == QLatin1String("image-rendering"))
255	imageRendering = value;
256	break;
257
258	case 'm':
259	if (name == QLatin1String("mask") &&
260	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly))
261	mask = value;
262	if (name == QLatin1String("marker-start") &&
263	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly))
264	markerStart = value;
265	if (name == QLatin1String("marker-mid") &&
266	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly))
267	markerMid = value;
268	if (name == QLatin1String("marker-end") &&
269	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly))
270	markerEnd = value;
271	break;
272
273	case 'o':
274	if (name == QLatin1String("opacity"))
275	opacity = value;
276	if (name == QLatin1String("offset"))
277	offset = value;
278	break;
279
280	case 's':
281	if (name.size() > 5 && name.mid(pos: 1, n: 5) == QLatin1String("troke")) {
282	QStringView strokeRef = name.mid(pos: 6, n: name.size() - 6);
283	if (strokeRef.isEmpty())
284	stroke = value;
285	else if (strokeRef == QLatin1String("-dasharray"))
286	strokeDashArray = value;
287	else if (strokeRef == QLatin1String("-dashoffset"))
288	strokeDashOffset = value;
289	else if (strokeRef == QLatin1String("-linecap"))
290	strokeLineCap = value;
291	else if (strokeRef == QLatin1String("-linejoin"))
292	strokeLineJoin = value;
293	else if (strokeRef == QLatin1String("-miterlimit"))
294	strokeMiterLimit = value;
295	else if (strokeRef == QLatin1String("-opacity"))
296	strokeOpacity = value;
297	else if (strokeRef == QLatin1String("-width"))
298	strokeWidth = value;
299	} else if (name == QLatin1String("stop-color"))
300	stopColor = value;
301	else if (name == QLatin1String("stop-opacity"))
302	stopOpacity = value;
303	break;
304
305	case 't':
306	if (name == QLatin1String("text-anchor"))
307	textAnchor = value;
308	else if (name == QLatin1String("transform"))
309	transform = value;
310	break;
311
312	case 'v':
313	if (name == QLatin1String("vector-effect"))
314	vectorEffect = value;
315	else if (name == QLatin1String("visibility"))
316	visibility = value;
317	break;
318
319	case 'x':
320	if (name == QLatin1String("xml:id") && id.isEmpty())
321	id = value.toString();
322	break;
323
324	default:
325	break;
326	}
327	}
328
329	// If a style attribute is present, let its attribute settings override the plain attribute
330	// values. The spec seems to indicate that, and it is common behavior in svg renderers.
331	#ifndef QT_NO_CSSPARSER
332	QStringView style = xmlAttributes.value(qualifiedName: QLatin1String("style"));
333	if (!style.isEmpty()) {
334	handler->parseCSStoXMLAttrs(css: style.toString(), attributes: &m_cssAttributes);
335	for (int j = 0; j < m_cssAttributes.size(); ++j) {
336	const QSvgCssAttribute &attribute = m_cssAttributes.at(i: j);
337	QStringView name = attribute.name;
338	QStringView value = attribute.value;
339	if (name.isEmpty())
340	continue;
341
342	switch (name.at(n: 0).unicode()) {
343
344	case 'c':
345	if (name == QLatin1String("color"))
346	color = value;
347	else if (name == QLatin1String("color-opacity"))
348	colorOpacity = value;
349	else if (name == QLatin1String("comp-op"))
350	compOp = value;
351	break;
352
353	case 'd':
354	if (name == QLatin1String("display"))
355	display = value;
356	break;
357
358	case 'f':
359	if (name == QLatin1String("fill"))
360	fill = value;
361	else if (name == QLatin1String("fill-rule"))
362	fillRule = value;
363	else if (name == QLatin1String("fill-opacity"))
364	fillOpacity = value;
365	else if (name == QLatin1String("font-family"))
366	fontFamily = value;
367	else if (name == QLatin1String("font-size"))
368	fontSize = value;
369	else if (name == QLatin1String("font-style"))
370	fontStyle = value;
371	else if (name == QLatin1String("font-weight"))
372	fontWeight = value;
373	else if (name == QLatin1String("font-variant"))
374	fontVariant = value;
375	else if (name == QLatin1String("filter") &&
376	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly))
377	filter = value;
378	break;
379
380	case 'i':
381	if (name == QLatin1String("image-rendering"))
382	imageRendering = value;
383	break;
384
385	case 'm':
386	if (name == QLatin1String("mask") &&
387	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly))
388	mask = value;
389	if (name == QLatin1String("marker-start") &&
390	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly))
391	markerStart = value;
392	if (name == QLatin1String("marker-mid") &&
393	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly))
394	markerMid = value;
395	if (name == QLatin1String("marker-end") &&
396	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly))
397	markerEnd = value;
398	break;
399
400	case 'o':
401	if (name == QLatin1String("opacity"))
402	opacity = value;
403	else if (name == QLatin1String("offset"))
404	offset = value;
405	break;
406
407	case 's':
408	if (name.size() > 5 && name.mid(pos: 1, n: 5) == QLatin1String("troke")) {
409	QStringView strokeRef = name.mid(pos: 6, n: name.size() - 6);
410	if (strokeRef.isEmpty())
411	stroke = value;
412	else if (strokeRef == QLatin1String("-dasharray"))
413	strokeDashArray = value;
414	else if (strokeRef == QLatin1String("-dashoffset"))
415	strokeDashOffset = value;
416	else if (strokeRef == QLatin1String("-linecap"))
417	strokeLineCap = value;
418	else if (strokeRef == QLatin1String("-linejoin"))
419	strokeLineJoin = value;
420	else if (strokeRef == QLatin1String("-miterlimit"))
421	strokeMiterLimit = value;
422	else if (strokeRef == QLatin1String("-opacity"))
423	strokeOpacity = value;
424	else if (strokeRef == QLatin1String("-width"))
425	strokeWidth = value;
426	} else if (name == QLatin1String("stop-color"))
427	stopColor = value;
428	else if (name == QLatin1String("stop-opacity"))
429	stopOpacity = value;
430	break;
431
432	case 't':
433	if (name == QLatin1String("text-anchor"))
434	textAnchor = value;
435	else if (name == QLatin1String("transform"))
436	transform = value;
437	break;
438
439	case 'v':
440	if (name == QLatin1String("vector-effect"))
441	vectorEffect = value;
442	else if (name == QLatin1String("visibility"))
443	visibility = value;
444	break;
445
446	default:
447	break;
448	}
449	}
450	}
451	#else
452	Q_UNUSED(handler);
453	#endif // QT_NO_CSSPARSER
454	}
455
456	#ifndef QT_NO_CSSPARSER
457
458	class QSvgStyleSelector : public QCss::StyleSelector
459	{
460	public:
461	QSvgStyleSelector()
462	{
463	nameCaseSensitivity = Qt::CaseInsensitive;
464	}
465	virtual ~QSvgStyleSelector()
466	{
467	}
468
469	inline QString nodeToName(QSvgNode *node) const
470	{
471	return node->typeName();
472	}
473
474	inline QSvgNode *svgNode(NodePtr node) const
475	{
476	return (QSvgNode*)node.ptr;
477	}
478	inline QSvgStructureNode *nodeToStructure(QSvgNode *n) const
479	{
480	if (n &&
481	(n->type() == QSvgNode::Doc ||
482	n->type() == QSvgNode::Group ||
483	n->type() == QSvgNode::Defs ||
484	n->type() == QSvgNode::Switch)) {
485	return (QSvgStructureNode*)n;
486	}
487	return 0;
488	}
489
490	inline QSvgStructureNode *svgStructure(NodePtr node) const
491	{
492	QSvgNode *n = svgNode(node);
493	QSvgStructureNode *st = nodeToStructure(n);
494	return st;
495	}
496
497	bool nodeNameEquals(NodePtr node, const QString& nodeName) const override
498	{
499	QSvgNode *n = svgNode(node);
500	if (!n)
501	return false;
502	QString name = nodeToName(node: n);
503	return QString::compare(s1: name, s2: nodeName, cs: Qt::CaseInsensitive) == 0;
504	}
505	QString attributeValue(NodePtr node, const QCss::AttributeSelector &asel) const override
506	{
507	const QString &name = asel.name;
508	QSvgNode *n = svgNode(node);
509	if ((!n->nodeId().isEmpty() && (name == QLatin1String("id") ||
510	name == QLatin1String("xml:id"))))
511	return n->nodeId();
512	if (!n->xmlClass().isEmpty() && name == QLatin1String("class"))
513	return n->xmlClass();
514	return QString();
515	}
516	bool hasAttributes(NodePtr node) const override
517	{
518	QSvgNode *n = svgNode(node);
519	return (n &&
520	(!n->nodeId().isEmpty() || !n->xmlClass().isEmpty()));
521	}
522
523	QStringList nodeIds(NodePtr node) const override
524	{
525	QSvgNode *n = svgNode(node);
526	QString nid;
527	if (n)
528	nid = n->nodeId();
529	QStringList lst; lst.append(t: nid);
530	return lst;
531	}
532
533	QStringList nodeNames(NodePtr node) const override
534	{
535	QSvgNode *n = svgNode(node);
536	if (n)
537	return QStringList(nodeToName(node: n));
538	return QStringList();
539	}
540
541	bool isNullNode(NodePtr node) const override
542	{
543	return !node.ptr;
544	}
545
546	NodePtr parentNode(NodePtr node) const override
547	{
548	QSvgNode *n = svgNode(node);
549	NodePtr newNode;
550	newNode.ptr = 0;
551	newNode.id = 0;
552	if (n) {
553	QSvgNode *svgParent = n->parent();
554	if (svgParent) {
555	newNode.ptr = svgParent;
556	}
557	}
558	return newNode;
559	}
560	NodePtr previousSiblingNode(NodePtr node) const override
561	{
562	NodePtr newNode;
563	newNode.ptr = 0;
564	newNode.id = 0;
565
566	QSvgNode *n = svgNode(node);
567	if (!n)
568	return newNode;
569	QSvgStructureNode *svgParent = nodeToStructure(n: n->parent());
570
571	if (svgParent) {
572	newNode.ptr = svgParent->previousSiblingNode(n);
573	}
574	return newNode;
575	}
576	NodePtr duplicateNode(NodePtr node) const override
577	{
578	NodePtr n;
579	n.ptr = node.ptr;
580	n.id = node.id;
581	return n;
582	}
583	void freeNode(NodePtr node) const override
584	{
585	Q_UNUSED(node);
586	}
587	};
588
589	#endif // QT_NO_CSSPARSER
590
591	// '0' is 0x30 and '9' is 0x39
592	static inline bool isDigit(ushort ch)
593	{
594	static quint16 magic = 0x3ff;
595	return ((ch >> 4) == 3) && (magic >> (ch & 15));
596	}
597
598	static qreal toDouble(const QChar *&str)
599	{
600	const int maxLen = 255;//technically doubles can go til 308+ but whatever
601	char temp[maxLen+1];
602	int pos = 0;
603
604	if (*str == QLatin1Char('-')) {
605	temp[pos++] = '-';
606	++str;
607	} else if (*str == QLatin1Char('+')) {
608	++str;
609	}
610	while (isDigit(ch: str->unicode()) && pos < maxLen) {
611	temp[pos++] = str->toLatin1();
612	++str;
613	}
614	if (*str == QLatin1Char('.') && pos < maxLen) {
615	temp[pos++] = '.';
616	++str;
617	}
618	while (isDigit(ch: str->unicode()) && pos < maxLen) {
619	temp[pos++] = str->toLatin1();
620	++str;
621	}
622	bool exponent = false;
623	if ((*str == QLatin1Char('e') || *str == QLatin1Char('E')) && pos < maxLen) {
624	exponent = true;
625	temp[pos++] = 'e';
626	++str;
627	if ((*str == QLatin1Char('-') || *str == QLatin1Char('+')) && pos < maxLen) {
628	temp[pos++] = str->toLatin1();
629	++str;
630	}
631	while (isDigit(ch: str->unicode()) && pos < maxLen) {
632	temp[pos++] = str->toLatin1();
633	++str;
634	}
635	}
636
637	temp[pos] = '\0';
638
639	qreal val;
640	if (!exponent && pos < 10) {
641	int ival = 0;
642	const char *t = temp;
643	bool neg = false;
644	if(*t == '-') {
645	neg = true;
646	++t;
647	}
648	while(*t && *t != '.') {
649	ival *= 10;
650	ival += (*t) - '0';
651	++t;
652	}
653	if(*t == '.') {
654	++t;
655	int div = 1;
656	while(*t) {
657	ival *= 10;
658	ival += (*t) - '0';
659	div *= 10;
660	++t;
661	}
662	val = ((qreal)ival)/((qreal)div);
663	} else {
664	val = ival;
665	}
666	if (neg)
667	val = -val;
668	} else {
669	val = QByteArray::fromRawData(data: temp, size: pos).toDouble();
670	// Do not tolerate values too wild to be represented normally by floats
671	if (qFpClassify(val: float(val)) != FP_NORMAL)
672	val = 0;
673	}
674	return val;
675
676	}
677
678	static qreal toDouble(QStringView str, bool *ok = NULL)
679	{
680	const QChar *c = str.constData();
681	qreal res = (c == nullptr ? qreal{} : toDouble(str&: c));
682	if (ok)
683	*ok = (c == (str.constData() + str.size()));
684	return res;
685	}
686
687	static QList<qreal> parseNumbersList(const QChar *&str)
688	{
689	QList<qreal> points;
690	if (!str)
691	return points;
692	points.reserve(asize: 32);
693
694	while (str->isSpace())
695	++str;
696	while (isDigit(ch: str->unicode()) ||
697	*str == QLatin1Char('-') || *str == QLatin1Char('+') ||
698	*str == QLatin1Char('.')) {
699
700	points.append(t: toDouble(str));
701
702	while (str->isSpace())
703	++str;
704	if (*str == QLatin1Char(','))
705	++str;
706
707	//eat the rest of space
708	while (str->isSpace())
709	++str;
710	}
711
712	return points;
713	}
714
715	static inline void parseNumbersArray(const QChar *&str, QVarLengthArray<qreal, 8> &points,
716	const char *pattern = nullptr)
717	{
718	const size_t patternLen = qstrlen(str: pattern);
719	while (str->isSpace())
720	++str;
721	while (isDigit(ch: str->unicode()) ||
722	*str == QLatin1Char('-') || *str == QLatin1Char('+') ||
723	*str == QLatin1Char('.')) {
724
725	if (patternLen && pattern[points.size() % patternLen] == 'f') {
726	// flag expected, may only be 0 or 1
727	if (*str != QLatin1Char('0') && *str != QLatin1Char('1'))
728	return;
729	points.append(t: *str == QLatin1Char('0') ? 0.0 : 1.0);
730	++str;
731	} else {
732	points.append(t: toDouble(str));
733	}
734
735	while (str->isSpace())
736	++str;
737	if (*str == QLatin1Char(','))
738	++str;
739
740	//eat the rest of space
741	while (str->isSpace())
742	++str;
743	}
744	}
745
746	static QList<qreal> parsePercentageList(const QChar *&str)
747	{
748	QList<qreal> points;
749	if (!str)
750	return points;
751
752	while (str->isSpace())
753	++str;
754	while ((*str >= QLatin1Char('0') && *str <= QLatin1Char('9')) ||
755	*str == QLatin1Char('-') || *str == QLatin1Char('+') ||
756	*str == QLatin1Char('.')) {
757
758	points.append(t: toDouble(str));
759
760	while (str->isSpace())
761	++str;
762	if (*str == QLatin1Char('%'))
763	++str;
764	while (str->isSpace())
765	++str;
766	if (*str == QLatin1Char(','))
767	++str;
768
769	//eat the rest of space
770	while (str->isSpace())
771	++str;
772	}
773
774	return points;
775	}
776
777	static QString idFromUrl(const QString &url)
778	{
779	// The form is url(<IRI>), where IRI can be
780	// just an ID on #<id> form.
781	QString::const_iterator itr = url.constBegin();
782	QString::const_iterator end = url.constEnd();
783	QString id;
784	while (itr != end && (*itr).isSpace())
785	++itr;
786	if (itr != end && (*itr) == QLatin1Char('('))
787	++itr;
788	else
789	return QString();
790	while (itr != end && (*itr).isSpace())
791	++itr;
792	if (itr != end && (*itr) == QLatin1Char('#')) {
793	id += *itr;
794	++itr;
795	} else {
796	return QString();
797	}
798	while (itr != end && (*itr) != QLatin1Char(')')) {
799	id += *itr;
800	++itr;
801	}
802	if (itr == end || (*itr) != QLatin1Char(')'))
803	return QString();
804	return id;
805	}
806
807	/**
808	* returns true when successfully set the color. false signifies
809	* that the color should be inherited
810	*/
811	static bool resolveColor(QStringView colorStr, QColor &color, QSvgHandler *handler)
812	{
813	QStringView colorStrTr = colorStr.trimmed();
814	if (colorStrTr.isEmpty())
815	return false;
816
817	switch(colorStrTr.at(n: 0).unicode()) {
818
819	case '#':
820	{
821	// #rrggbb is very very common, so let's tackle it here
822	// rather than falling back to QColor
823	QRgb rgb;
824	bool ok = qsvg_get_hex_rgb(str: colorStrTr.constData(), len: colorStrTr.size(), rgb: &rgb);
825	if (ok)
826	color.setRgb(rgb);
827	return ok;
828	}
829	break;
830
831	case 'r':
832	{
833	// starts with "rgb(", ends with ")" and consists of at least 7 characters "rgb(,,)"
834	if (colorStrTr.size() >= 7 && colorStrTr.at(n: colorStrTr.size() - 1) == QLatin1Char(')')
835	&& colorStrTr.mid(pos: 0, n: 4) == QLatin1String("rgb(")) {
836	const QChar *s = colorStrTr.constData() + 4;
837	QList<qreal> compo = parseNumbersList(str&: s);
838	//1 means that it failed after reaching non-parsable
839	//character which is going to be "%"
840	if (compo.size() == 1) {
841	s = colorStrTr.constData() + 4;
842	compo = parsePercentageList(str&: s);
843	for (int i = 0; i < compo.size(); ++i)
844	compo[i] *= (qreal)2.55;
845	}
846
847	if (compo.size() == 3) {
848	color = QColor(int(compo[0]),
849	int(compo[1]),
850	int(compo[2]));
851	return true;
852	}
853	return false;
854	}
855	}
856	break;
857
858	case 'c':
859	if (colorStrTr == QLatin1String("currentColor")) {
860	color = handler->currentColor();
861	return true;
862	}
863	break;
864	case 'i':
865	if (colorStrTr == QT_INHERIT)
866	return false;
867	break;
868	default:
869	break;
870	}
871
872	color = QColor::fromString(name: colorStrTr.toString());
873	return color.isValid();
874	}
875
876	static bool constructColor(QStringView colorStr, QStringView opacity,
877	QColor &color, QSvgHandler *handler)
878	{
879	if (!resolveColor(colorStr, color, handler))
880	return false;
881	if (!opacity.isEmpty()) {
882	bool ok = true;
883	qreal op = qMin(a: qreal(1.0), b: qMax(a: qreal(0.0), b: toDouble(str: opacity, ok: &ok)));
884	if (!ok)
885	op = 1.0;
886	color.setAlphaF(op);
887	}
888	return true;
889	}
890
891	static qreal parseLength(QStringView str, QSvgHandler::LengthType *type,
892	QSvgHandler *handler, bool *ok = NULL)
893	{
894	QStringView numStr = str.trimmed();
895
896	if (numStr.isEmpty()) {
897	if (ok)
898	*ok = false;
899	*type = QSvgHandler::LT_OTHER;
900	return false;
901	}
902	if (numStr.endsWith(c: QLatin1Char('%'))) {
903	numStr.chop(n: 1);
904	*type = QSvgHandler::LT_PERCENT;
905	} else if (numStr.endsWith(s: QLatin1String("px"))) {
906	numStr.chop(n: 2);
907	*type = QSvgHandler::LT_PX;
908	} else if (numStr.endsWith(s: QLatin1String("pc"))) {
909	numStr.chop(n: 2);
910	*type = QSvgHandler::LT_PC;
911	} else if (numStr.endsWith(s: QLatin1String("pt"))) {
912	numStr.chop(n: 2);
913	*type = QSvgHandler::LT_PT;
914	} else if (numStr.endsWith(s: QLatin1String("mm"))) {
915	numStr.chop(n: 2);
916	*type = QSvgHandler::LT_MM;
917	} else if (numStr.endsWith(s: QLatin1String("cm"))) {
918	numStr.chop(n: 2);
919	*type = QSvgHandler::LT_CM;
920	} else if (numStr.endsWith(s: QLatin1String("in"))) {
921	numStr.chop(n: 2);
922	*type = QSvgHandler::LT_IN;
923	} else {
924	*type = handler->defaultCoordinateSystem();
925	//type = QSvgHandler::LT_OTHER;
926	}
927	qreal len = toDouble(str: numStr, ok);
928	//qDebug()<<"len is "<<len<<", from '"<<numStr << "'";
929	return len;
930	}
931
932	static inline qreal convertToNumber(QStringView str, QSvgHandler *handler, bool *ok = NULL)
933	{
934	QSvgHandler::LengthType type;
935	qreal num = parseLength(str: str.toString(), type: &type, handler, ok);
936	if (type == QSvgHandler::LT_PERCENT) {
937	num = num/100.0;
938	}
939	return num;
940	}
941
942	static bool createSvgGlyph(QSvgFont *font, const QXmlStreamAttributes &attributes)
943	{
944	QStringView uncStr = attributes.value(qualifiedName: QLatin1String("unicode"));
945	QStringView havStr = attributes.value(qualifiedName: QLatin1String("horiz-adv-x"));
946	QStringView pathStr = attributes.value(qualifiedName: QLatin1String("d"));
947
948	QChar unicode = (uncStr.isEmpty()) ? u'\0' : uncStr.at(n: 0);
949	qreal havx = (havStr.isEmpty()) ? -1 : toDouble(str: havStr);
950	QPainterPath path;
951	path.setFillRule(Qt::WindingFill);
952	parsePathDataFast(data: pathStr, path);
953
954	font->addGlyph(unicode, path, horizAdvX: havx);
955
956	return true;
957	}
958
959	// this should really be called convertToDefaultCoordinateSystem
960	// and convert when type != QSvgHandler::defaultCoordinateSystem
961	static qreal convertToPixels(qreal len, bool , QSvgHandler::LengthType type)
962	{
963
964	switch (type) {
965	case QSvgHandler::LT_PERCENT:
966	break;
967	case QSvgHandler::LT_PX:
968	break;
969	case QSvgHandler::LT_PC:
970	break;
971	case QSvgHandler::LT_PT:
972	return len * 1.25;
973	break;
974	case QSvgHandler::LT_MM:
975	return len * 3.543307;
976	break;
977	case QSvgHandler::LT_CM:
978	return len * 35.43307;
979	break;
980	case QSvgHandler::LT_IN:
981	return len * 90;
982	break;
983	case QSvgHandler::LT_OTHER:
984	break;
985	default:
986	break;
987	}
988	return len;
989	}
990
991	static void parseColor(QSvgNode *,
992	const QSvgAttributes &attributes,
993	QSvgHandler *handler)
994	{
995	QColor color;
996	if (constructColor(colorStr: attributes.color, opacity: attributes.colorOpacity, color, handler)) {
997	handler->popColor();
998	handler->pushColor(color);
999	}
1000	}
1001
1002	static QSvgStyleProperty *styleFromUrl(QSvgNode *node, const QString &url)
1003	{
1004	return node ? node->styleProperty(id: idFromUrl(url)) : 0;
1005	}
1006
1007	static void parseBrush(QSvgNode *node,
1008	const QSvgAttributes &attributes,
1009	QSvgHandler *handler)
1010	{
1011	if (!attributes.fill.isEmpty() || !attributes.fillRule.isEmpty() || !attributes.fillOpacity.isEmpty()) {
1012	QSvgFillStyle *prop = new QSvgFillStyle;
1013
1014	//fill-rule attribute handling
1015	if (!attributes.fillRule.isEmpty() && attributes.fillRule != QT_INHERIT) {
1016	if (attributes.fillRule == QLatin1String("evenodd"))
1017	prop->setFillRule(Qt::OddEvenFill);
1018	else if (attributes.fillRule == QLatin1String("nonzero"))
1019	prop->setFillRule(Qt::WindingFill);
1020	}
1021
1022	//fill-opacity attribute handling
1023	if (!attributes.fillOpacity.isEmpty() && attributes.fillOpacity != QT_INHERIT) {
1024	prop->setFillOpacity(qMin(a: qreal(1.0), b: qMax(a: qreal(0.0), b: toDouble(str: attributes.fillOpacity))));
1025	}
1026
1027	//fill attribute handling
1028	if ((!attributes.fill.isEmpty()) && (attributes.fill != QT_INHERIT) ) {
1029	if (attributes.fill.size() > 3 && attributes.fill.mid(pos: 0, n: 3) == QLatin1String("url")) {
1030	QString value = attributes.fill.mid(pos: 3, n: attributes.fill.size() - 3).toString();
1031	QSvgStyleProperty *style = styleFromUrl(node, url: value);
1032	if (style) {
1033	if (style->type() == QSvgStyleProperty::SOLID_COLOR || style->type() == QSvgStyleProperty::GRADIENT
1034	|| style->type() == QSvgStyleProperty::PATTERN)
1035	prop->setFillStyle(reinterpret_cast<QSvgPaintStyleProperty *>(style));
1036	} else {
1037	QString id = idFromUrl(url: value);
1038	prop->setPaintStyleId(id);
1039	prop->setPaintStyleResolved(false);
1040	}
1041	} else if (attributes.fill != QLatin1String("none")) {
1042	QColor color;
1043	if (resolveColor(colorStr: attributes.fill, color, handler))
1044	prop->setBrush(QBrush(color));
1045	} else {
1046	prop->setBrush(QBrush(Qt::NoBrush));
1047	}
1048	}
1049	node->appendStyleProperty(prop, id: attributes.id);
1050	}
1051	}
1052
1053
1054
1055	static QTransform parseTransformationMatrix(QStringView value)
1056	{
1057	if (value.isEmpty())
1058	return QTransform();
1059
1060	QTransform matrix;
1061	const QChar *str = value.constData();
1062	const QChar *end = str + value.size();
1063
1064	while (str < end) {
1065	if (str->isSpace() || *str == QLatin1Char(',')) {
1066	++str;
1067	continue;
1068	}
1069	enum State {
1070	Matrix,
1071	Translate,
1072	Rotate,
1073	Scale,
1074	SkewX,
1075	SkewY
1076	};
1077	State state = Matrix;
1078	if (*str == QLatin1Char('m')) { //matrix
1079	const char *ident = "atrix";
1080	for (int i = 0; i < 5; ++i)
1081	if (*(++str) != QLatin1Char(ident[i]))
1082	goto error;
1083	++str;
1084	state = Matrix;
1085	} else if (*str == QLatin1Char('t')) { //translate
1086	const char *ident = "ranslate";
1087	for (int i = 0; i < 8; ++i)
1088	if (*(++str) != QLatin1Char(ident[i]))
1089	goto error;
1090	++str;
1091	state = Translate;
1092	} else if (*str == QLatin1Char('r')) { //rotate
1093	const char *ident = "otate";
1094	for (int i = 0; i < 5; ++i)
1095	if (*(++str) != QLatin1Char(ident[i]))
1096	goto error;
1097	++str;
1098	state = Rotate;
1099	} else if (*str == QLatin1Char('s')) { //scale, skewX, skewY
1100	++str;
1101	if (*str == QLatin1Char('c')) {
1102	const char *ident = "ale";
1103	for (int i = 0; i < 3; ++i)
1104	if (*(++str) != QLatin1Char(ident[i]))
1105	goto error;
1106	++str;
1107	state = Scale;
1108	} else if (*str == QLatin1Char('k')) {
1109	if (*(++str) != QLatin1Char('e'))
1110	goto error;
1111	if (*(++str) != QLatin1Char('w'))
1112	goto error;
1113	++str;
1114	if (*str == QLatin1Char('X'))
1115	state = SkewX;
1116	else if (*str == QLatin1Char('Y'))
1117	state = SkewY;
1118	else
1119	goto error;
1120	++str;
1121	} else {
1122	goto error;
1123	}
1124	} else {
1125	goto error;
1126	}
1127
1128
1129	while (str < end && str->isSpace())
1130	++str;
1131	if (*str != QLatin1Char('('))
1132	goto error;
1133	++str;
1134	QVarLengthArray<qreal, 8> points;
1135	parseNumbersArray(str, points);
1136	if (*str != QLatin1Char(')'))
1137	goto error;
1138	++str;
1139
1140	if(state == Matrix) {
1141	if(points.size() != 6)
1142	goto error;
1143	matrix = QTransform(points[0], points[1],
1144	points[2], points[3],
1145	points[4], points[5]) * matrix;
1146	} else if (state == Translate) {
1147	if (points.size() == 1)
1148	matrix.translate(dx: points[0], dy: 0);
1149	else if (points.size() == 2)
1150	matrix.translate(dx: points[0], dy: points[1]);
1151	else
1152	goto error;
1153	} else if (state == Rotate) {
1154	if(points.size() == 1) {
1155	matrix.rotate(a: points[0]);
1156	} else if (points.size() == 3) {
1157	matrix.translate(dx: points[1], dy: points[2]);
1158	matrix.rotate(a: points[0]);
1159	matrix.translate(dx: -points[1], dy: -points[2]);
1160	} else {
1161	goto error;
1162	}
1163	} else if (state == Scale) {
1164	if (points.size() < 1 || points.size() > 2)
1165	goto error;
1166	qreal sx = points[0];
1167	qreal sy = sx;
1168	if(points.size() == 2)
1169	sy = points[1];
1170	matrix.scale(sx, sy);
1171	} else if (state == SkewX) {
1172	if (points.size() != 1)
1173	goto error;
1174	matrix.shear(sh: qTan(v: qDegreesToRadians(degrees: points[0])), sv: 0);
1175	} else if (state == SkewY) {
1176	if (points.size() != 1)
1177	goto error;
1178	matrix.shear(sh: 0, sv: qTan(v: qDegreesToRadians(degrees: points[0])));
1179	}
1180	}
1181	error:
1182	return matrix;
1183	}
1184
1185	static void parsePen(QSvgNode *node,
1186	const QSvgAttributes &attributes,
1187	QSvgHandler *handler)
1188	{
1189	//qDebug()<<"Node "<<node->type()<<", attrs are "<<value<<width;
1190
1191	if (!attributes.stroke.isEmpty() || !attributes.strokeDashArray.isEmpty() || !attributes.strokeDashOffset.isEmpty() || !attributes.strokeLineCap.isEmpty()
1192	|| !attributes.strokeLineJoin.isEmpty() || !attributes.strokeMiterLimit.isEmpty() || !attributes.strokeOpacity.isEmpty() || !attributes.strokeWidth.isEmpty()
1193	|| !attributes.vectorEffect.isEmpty()) {
1194
1195	QSvgStrokeStyle *prop = new QSvgStrokeStyle;
1196
1197	//stroke attribute handling
1198	if ((!attributes.stroke.isEmpty()) && (attributes.stroke != QT_INHERIT) ) {
1199	if (attributes.stroke.size() > 3 && attributes.stroke.mid(pos: 0, n: 3) == QLatin1String("url")) {
1200	QString value = attributes.stroke.mid(pos: 3, n: attributes.stroke.size() - 3).toString();
1201	QSvgStyleProperty *style = styleFromUrl(node, url: value);
1202	if (style) {
1203	if (style->type() == QSvgStyleProperty::SOLID_COLOR || style->type() == QSvgStyleProperty::GRADIENT
1204	|| style->type() == QSvgStyleProperty::PATTERN)
1205	prop->setStyle(reinterpret_cast<QSvgPaintStyleProperty *>(style));
1206	} else {
1207	QString id = idFromUrl(url: value);
1208	prop->setPaintStyleId(id);
1209	prop->setPaintStyleResolved(false);
1210	}
1211	} else if (attributes.stroke != QLatin1String("none")) {
1212	QColor color;
1213	if (resolveColor(colorStr: attributes.stroke, color, handler))
1214	prop->setStroke(QBrush(color));
1215	} else {
1216	prop->setStroke(QBrush(Qt::NoBrush));
1217	}
1218	}
1219
1220	//stroke-width handling
1221	if (!attributes.strokeWidth.isEmpty() && attributes.strokeWidth != QT_INHERIT) {
1222	QSvgHandler::LengthType lt;
1223	prop->setWidth(parseLength(str: attributes.strokeWidth, type: &lt, handler));
1224	}
1225
1226	//stroke-dasharray
1227	if (!attributes.strokeDashArray.isEmpty() && attributes.strokeDashArray != QT_INHERIT) {
1228	if (attributes.strokeDashArray == QLatin1String("none")) {
1229	prop->setDashArrayNone();
1230	} else {
1231	QString dashArray = attributes.strokeDashArray.toString();
1232	const QChar *s = dashArray.constData();
1233	QList<qreal> dashes = parseNumbersList(str&: s);
1234	bool allZeroes = true;
1235	for (qreal dash : dashes) {
1236	if (dash != 0.0) {
1237	allZeroes = false;
1238	break;
1239	}
1240	}
1241
1242	// if the stroke dash array contains only zeros,
1243	// force drawing of solid line.
1244	if (allZeroes == false) {
1245	// if the dash count is odd the dashes should be duplicated
1246	if ((dashes.size() & 1) != 0)
1247	dashes << QList<qreal>(dashes);
1248	prop->setDashArray(dashes);
1249	} else {
1250	prop->setDashArrayNone();
1251	}
1252	}
1253	}
1254
1255	//stroke-linejoin attribute handling
1256	if (!attributes.strokeLineJoin.isEmpty()) {
1257	if (attributes.strokeLineJoin == QLatin1String("miter"))
1258	prop->setLineJoin(Qt::SvgMiterJoin);
1259	else if (attributes.strokeLineJoin == QLatin1String("round"))
1260	prop->setLineJoin(Qt::RoundJoin);
1261	else if (attributes.strokeLineJoin == QLatin1String("bevel"))
1262	prop->setLineJoin(Qt::BevelJoin);
1263	}
1264
1265	//stroke-linecap attribute handling
1266	if (!attributes.strokeLineCap.isEmpty()) {
1267	if (attributes.strokeLineCap == QLatin1String("butt"))
1268	prop->setLineCap(Qt::FlatCap);
1269	else if (attributes.strokeLineCap == QLatin1String("round"))
1270	prop->setLineCap(Qt::RoundCap);
1271	else if (attributes.strokeLineCap == QLatin1String("square"))
1272	prop->setLineCap(Qt::SquareCap);
1273	}
1274
1275	//stroke-dashoffset attribute handling
1276	if (!attributes.strokeDashOffset.isEmpty() && attributes.strokeDashOffset != QT_INHERIT)
1277	prop->setDashOffset(toDouble(str: attributes.strokeDashOffset));
1278
1279	//vector-effect attribute handling
1280	if (!attributes.vectorEffect.isEmpty()) {
1281	if (attributes.vectorEffect == QLatin1String("non-scaling-stroke"))
1282	prop->setVectorEffect(true);
1283	else if (attributes.vectorEffect == QLatin1String("none"))
1284	prop->setVectorEffect(false);
1285	}
1286
1287	//stroke-miterlimit
1288	if (!attributes.strokeMiterLimit.isEmpty() && attributes.strokeMiterLimit != QT_INHERIT)
1289	prop->setMiterLimit(toDouble(str: attributes.strokeMiterLimit));
1290
1291	//stroke-opacity atttribute handling
1292	if (!attributes.strokeOpacity.isEmpty() && attributes.strokeOpacity != QT_INHERIT)
1293	prop->setOpacity(qMin(a: qreal(1.0), b: qMax(a: qreal(0.0), b: toDouble(str: attributes.strokeOpacity))));
1294
1295	node->appendStyleProperty(prop, id: attributes.id);
1296	}
1297	}
1298
1299	enum FontSizeSpec { XXSmall, XSmall, Small, Medium, Large, XLarge, XXLarge,
1300	FontSizeNone, FontSizeValue };
1301
1302	static const qreal sizeTable[] =
1303	{ qreal(6.9), qreal(8.3), qreal(10.0), qreal(12.0), qreal(14.4), qreal(17.3), qreal(20.7) };
1304
1305	Q_STATIC_ASSERT(sizeof(sizeTable)/sizeof(sizeTable[0]) == FontSizeNone);
1306
1307	static FontSizeSpec fontSizeSpec(QStringView spec)
1308	{
1309	switch (spec.at(n: 0).unicode()) {
1310	case 'x':
1311	if (spec == QLatin1String("xx-small"))
1312	return XXSmall;
1313	if (spec == QLatin1String("x-small"))
1314	return XSmall;
1315	if (spec == QLatin1String("x-large"))
1316	return XLarge;
1317	if (spec == QLatin1String("xx-large"))
1318	return XXLarge;
1319	break;
1320	case 's':
1321	if (spec == QLatin1String("small"))
1322	return Small;
1323	break;
1324	case 'm':
1325	if (spec == QLatin1String("medium"))
1326	return Medium;
1327	break;
1328	case 'l':
1329	if (spec == QLatin1String("large"))
1330	return Large;
1331	break;
1332	case 'n':
1333	if (spec == QLatin1String("none"))
1334	return FontSizeNone;
1335	break;
1336	default:
1337	break;
1338	}
1339	return FontSizeValue;
1340	}
1341
1342	static void parseFont(QSvgNode *node,
1343	const QSvgAttributes &attributes,
1344	QSvgHandler *handler)
1345	{
1346	if (attributes.fontFamily.isEmpty() && attributes.fontSize.isEmpty() && attributes.fontStyle.isEmpty() &&
1347	attributes.fontWeight.isEmpty() && attributes.fontVariant.isEmpty() && attributes.textAnchor.isEmpty())
1348	return;
1349
1350	QSvgFontStyle *fontStyle = nullptr;
1351	if (!attributes.fontFamily.isEmpty()) {
1352	QSvgTinyDocument *doc = node->document();
1353	if (doc) {
1354	QSvgFont *svgFont = doc->svgFont(family: attributes.fontFamily.toString());
1355	if (svgFont)
1356	fontStyle = new QSvgFontStyle(svgFont, doc);
1357	}
1358	}
1359	if (!fontStyle)
1360	fontStyle = new QSvgFontStyle;
1361	if (!attributes.fontFamily.isEmpty() && attributes.fontFamily != QT_INHERIT) {
1362	QString family = attributes.fontFamily.toString().trimmed();
1363	if (family.at(i: 0) == QLatin1Char('\'') || family.at(i: 0) == QLatin1Char('\"'))
1364	family = family.mid(position: 1, n: family.size() - 2);
1365	fontStyle->setFamily(family);
1366	}
1367
1368	if (!attributes.fontSize.isEmpty() && attributes.fontSize != QT_INHERIT) {
1369	// TODO: Support relative sizes 'larger' and 'smaller'.
1370	const FontSizeSpec spec = fontSizeSpec(spec: attributes.fontSize);
1371	switch (spec) {
1372	case FontSizeNone:
1373	break;
1374	case FontSizeValue: {
1375	QSvgHandler::LengthType type;
1376	qreal fs = parseLength(str: attributes.fontSize, type: &type, handler);
1377	fs = convertToPixels(len: fs, true, type);
1378	fontStyle->setSize(qMin(a: fs, b: qreal(0xffff)));
1379	}
1380	break;
1381	default:
1382	fontStyle->setSize(sizeTable[spec]);
1383	break;
1384	}
1385	}
1386
1387	if (!attributes.fontStyle.isEmpty() && attributes.fontStyle != QT_INHERIT) {
1388	if (attributes.fontStyle == QLatin1String("normal")) {
1389	fontStyle->setStyle(QFont::StyleNormal);
1390	} else if (attributes.fontStyle == QLatin1String("italic")) {
1391	fontStyle->setStyle(QFont::StyleItalic);
1392	} else if (attributes.fontStyle == QLatin1String("oblique")) {
1393	fontStyle->setStyle(QFont::StyleOblique);
1394	}
1395	}
1396
1397	if (!attributes.fontWeight.isEmpty() && attributes.fontWeight != QT_INHERIT) {
1398	bool ok = false;
1399	const int weightNum = attributes.fontWeight.toInt(ok: &ok);
1400	if (ok) {
1401	fontStyle->setWeight(weightNum);
1402	} else {
1403	if (attributes.fontWeight == QLatin1String("normal")) {
1404	fontStyle->setWeight(QFont::Normal);
1405	} else if (attributes.fontWeight == QLatin1String("bold")) {
1406	fontStyle->setWeight(QFont::Bold);
1407	} else if (attributes.fontWeight == QLatin1String("bolder")) {
1408	fontStyle->setWeight(QSvgFontStyle::BOLDER);
1409	} else if (attributes.fontWeight == QLatin1String("lighter")) {
1410	fontStyle->setWeight(QSvgFontStyle::LIGHTER);
1411	}
1412	}
1413	}
1414
1415	if (!attributes.fontVariant.isEmpty() && attributes.fontVariant != QT_INHERIT) {
1416	if (attributes.fontVariant == QLatin1String("normal"))
1417	fontStyle->setVariant(QFont::MixedCase);
1418	else if (attributes.fontVariant == QLatin1String("small-caps"))
1419	fontStyle->setVariant(QFont::SmallCaps);
1420	}
1421
1422	if (!attributes.textAnchor.isEmpty() && attributes.textAnchor != QT_INHERIT) {
1423	if (attributes.textAnchor == QLatin1String("start"))
1424	fontStyle->setTextAnchor(Qt::AlignLeft);
1425	if (attributes.textAnchor == QLatin1String("middle"))
1426	fontStyle->setTextAnchor(Qt::AlignHCenter);
1427	else if (attributes.textAnchor == QLatin1String("end"))
1428	fontStyle->setTextAnchor(Qt::AlignRight);
1429	}
1430
1431	node->appendStyleProperty(prop: fontStyle, id: attributes.id);
1432	}
1433
1434	static void parseTransform(QSvgNode *node,
1435	const QSvgAttributes &attributes,
1436	QSvgHandler *)
1437	{
1438	if (attributes.transform.isEmpty())
1439	return;
1440	QTransform matrix = parseTransformationMatrix(value: attributes.transform.trimmed());
1441
1442	if (!matrix.isIdentity()) {
1443	node->appendStyleProperty(prop: new QSvgTransformStyle(QTransform(matrix)), id: attributes.id);
1444	}
1445
1446	}
1447
1448	static void parseVisibility(QSvgNode *node,
1449	const QSvgAttributes &attributes,
1450	QSvgHandler *)
1451	{
1452	QSvgNode *parent = node->parent();
1453
1454	if (parent && (attributes.visibility.isEmpty() || attributes.visibility == QT_INHERIT))
1455	node->setVisible(parent->isVisible());
1456	else if (attributes.visibility == QLatin1String("hidden") || attributes.visibility == QLatin1String("collapse")) {
1457	node->setVisible(false);
1458	} else
1459	node->setVisible(true);
1460	}
1461
1462	static void pathArcSegment(QPainterPath &path,
1463	qreal xc, qreal yc,
1464	qreal th0, qreal th1,
1465	qreal rx, qreal ry, qreal xAxisRotation)
1466	{
1467	qreal sinTh, cosTh;
1468	qreal a00, a01, a10, a11;
1469	qreal x1, y1, x2, y2, x3, y3;
1470	qreal t;
1471	qreal thHalf;
1472
1473	sinTh = qSin(v: xAxisRotation * (Q_PI / 180.0));
1474	cosTh = qCos(v: xAxisRotation * (Q_PI / 180.0));
1475
1476	a00 = cosTh * rx;
1477	a01 = -sinTh * ry;
1478	a10 = sinTh * rx;
1479	a11 = cosTh * ry;
1480
1481	thHalf = 0.5 * (th1 - th0);
1482	t = (8.0 / 3.0) * qSin(v: thHalf * 0.5) * qSin(v: thHalf * 0.5) / qSin(v: thHalf);
1483	x1 = xc + qCos(v: th0) - t * qSin(v: th0);
1484	y1 = yc + qSin(v: th0) + t * qCos(v: th0);
1485	x3 = xc + qCos(v: th1);
1486	y3 = yc + qSin(v: th1);
1487	x2 = x3 + t * qSin(v: th1);
1488	y2 = y3 - t * qCos(v: th1);
1489
1490	path.cubicTo(ctrlPt1x: a00 * x1 + a01 * y1, ctrlPt1y: a10 * x1 + a11 * y1,
1491	ctrlPt2x: a00 * x2 + a01 * y2, ctrlPt2y: a10 * x2 + a11 * y2,
1492	endPtx: a00 * x3 + a01 * y3, endPty: a10 * x3 + a11 * y3);
1493	}
1494
1495	// the arc handling code underneath is from XSVG (BSD license)
1496	/*
1497	* Copyright 2002 USC/Information Sciences Institute
1498	*
1499	* Permission to use, copy, modify, distribute, and sell this software
1500	* and its documentation for any purpose is hereby granted without
1501	* fee, provided that the above copyright notice appear in all copies
1502	* and that both that copyright notice and this permission notice
1503	* appear in supporting documentation, and that the name of
1504	* Information Sciences Institute not be used in advertising or
1505	* publicity pertaining to distribution of the software without
1506	* specific, written prior permission. Information Sciences Institute
1507	* makes no representations about the suitability of this software for
1508	* any purpose. It is provided "as is" without express or implied
1509	* warranty.
1510	*
1511	* INFORMATION SCIENCES INSTITUTE DISCLAIMS ALL WARRANTIES WITH REGARD
1512	* TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF
1513	* MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL INFORMATION SCIENCES
1514	* INSTITUTE BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
1515	* DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA
1516	* OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
1517	* TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
1518	* PERFORMANCE OF THIS SOFTWARE.
1519	*
1520	*/
1521	static void pathArc(QPainterPath &path,
1522	qreal rx,
1523	qreal ry,
1524	qreal x_axis_rotation,
1525	int large_arc_flag,
1526	int sweep_flag,
1527	qreal x,
1528	qreal y,
1529	qreal curx, qreal cury)
1530	{
1531	const qreal Pr1 = rx * rx;
1532	const qreal Pr2 = ry * ry;
1533
1534	if (!Pr1 || !Pr2)
1535	return;
1536
1537	qreal sin_th, cos_th;
1538	qreal a00, a01, a10, a11;
1539	qreal x0, y0, x1, y1, xc, yc;
1540	qreal d, sfactor, sfactor_sq;
1541	qreal th0, th1, th_arc;
1542	int i, n_segs;
1543	qreal dx, dy, dx1, dy1, Px, Py, check;
1544
1545	rx = qAbs(t: rx);
1546	ry = qAbs(t: ry);
1547
1548	sin_th = qSin(v: x_axis_rotation * (Q_PI / 180.0));
1549	cos_th = qCos(v: x_axis_rotation * (Q_PI / 180.0));
1550
1551	dx = (curx - x) / 2.0;
1552	dy = (cury - y) / 2.0;
1553	dx1 = cos_th * dx + sin_th * dy;
1554	dy1 = -sin_th * dx + cos_th * dy;
1555	Px = dx1 * dx1;
1556	Py = dy1 * dy1;
1557	/* Spec : check if radii are large enough */
1558	check = Px / Pr1 + Py / Pr2;
1559	if (check > 1) {
1560	rx = rx * qSqrt(v: check);
1561	ry = ry * qSqrt(v: check);
1562	}
1563
1564	a00 = cos_th / rx;
1565	a01 = sin_th / rx;
1566	a10 = -sin_th / ry;
1567	a11 = cos_th / ry;
1568	x0 = a00 * curx + a01 * cury;
1569	y0 = a10 * curx + a11 * cury;
1570	x1 = a00 * x + a01 * y;
1571	y1 = a10 * x + a11 * y;
1572	/* (x0, y0) is current point in transformed coordinate space.
1573	(x1, y1) is new point in transformed coordinate space.
1574
1575	The arc fits a unit-radius circle in this space.
1576	*/
1577	d = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0);
1578	if (!d)
1579	return;
1580	sfactor_sq = 1.0 / d - 0.25;
1581	if (sfactor_sq < 0) sfactor_sq = 0;
1582	sfactor = qSqrt(v: sfactor_sq);
1583	if (sweep_flag == large_arc_flag) sfactor = -sfactor;
1584	xc = 0.5 * (x0 + x1) - sfactor * (y1 - y0);
1585	yc = 0.5 * (y0 + y1) + sfactor * (x1 - x0);
1586	/* (xc, yc) is center of the circle. */
1587
1588	th0 = qAtan2(y: y0 - yc, x: x0 - xc);
1589	th1 = qAtan2(y: y1 - yc, x: x1 - xc);
1590
1591	th_arc = th1 - th0;
1592	if (th_arc < 0 && sweep_flag)
1593	th_arc += 2 * Q_PI;
1594	else if (th_arc > 0 && !sweep_flag)
1595	th_arc -= 2 * Q_PI;
1596
1597	n_segs = qCeil(v: qAbs(t: th_arc / (Q_PI * 0.5 + 0.001)));
1598
1599	for (i = 0; i < n_segs; i++) {
1600	pathArcSegment(path, xc, yc,
1601	th0: th0 + i * th_arc / n_segs,
1602	th1: th0 + (i + 1) * th_arc / n_segs,
1603	rx, ry, xAxisRotation: x_axis_rotation);
1604	}
1605	}
1606
1607	static bool parsePathDataFast(QStringView dataStr, QPainterPath &path, bool limitLength)
1608	{
1609	const int maxElementCount = 0x7fff; // Assume file corruption if more path elements than this
1610	qreal x0 = 0, y0 = 0; // starting point
1611	qreal x = 0, y = 0; // current point
1612	char lastMode = 0;
1613	QPointF ctrlPt;
1614	const QChar *str = dataStr.constData();
1615	const QChar *end = str + dataStr.size();
1616
1617	bool ok = true;
1618	while (ok && str != end) {
1619	while (str->isSpace() && (str + 1) != end)
1620	++str;
1621	QChar pathElem = *str;
1622	++str;
1623	QChar endc = *end;
1624	*const_cast<QChar *>(end) = u'\0'; // parseNumbersArray requires 0-termination that QStringView cannot guarantee
1625	const char *pattern = nullptr;
1626	if (pathElem == QLatin1Char('a') || pathElem == QLatin1Char('A'))
1627	pattern = "rrrffrr";
1628	QVarLengthArray<qreal, 8> arg;
1629	parseNumbersArray(str, points&: arg, pattern);
1630	*const_cast<QChar *>(end) = endc;
1631	if (pathElem == QLatin1Char('z') || pathElem == QLatin1Char('Z'))
1632	arg.append(t: 0);//dummy
1633	const qreal *num = arg.constData();
1634	int count = arg.size();
1635	while (ok && count > 0) {
1636	qreal offsetX = x; // correction offsets
1637	qreal offsetY = y; // for relative commands
1638	switch (pathElem.unicode()) {
1639	case 'm': {
1640	if (count < 2) {
1641	ok = false;
1642	break;
1643	}
1644	x = x0 = num[0] + offsetX;
1645	y = y0 = num[1] + offsetY;
1646	num += 2;
1647	count -= 2;
1648	path.moveTo(x: x0, y: y0);
1649
1650	// As per 1.2 spec 8.3.2 The "moveto" commands
1651	// If a 'moveto' is followed by multiple pairs of coordinates without explicit commands,
1652	// the subsequent pairs shall be treated as implicit 'lineto' commands.
1653	pathElem = QLatin1Char('l');
1654	}
1655	break;
1656	case 'M': {
1657	if (count < 2) {
1658	ok = false;
1659	break;
1660	}
1661	x = x0 = num[0];
1662	y = y0 = num[1];
1663	num += 2;
1664	count -= 2;
1665	path.moveTo(x: x0, y: y0);
1666
1667	// As per 1.2 spec 8.3.2 The "moveto" commands
1668	// If a 'moveto' is followed by multiple pairs of coordinates without explicit commands,
1669	// the subsequent pairs shall be treated as implicit 'lineto' commands.
1670	pathElem = QLatin1Char('L');
1671	}
1672	break;
1673	case 'z':
1674	case 'Z': {
1675	x = x0;
1676	y = y0;
1677	count--; // skip dummy
1678	num++;
1679	path.closeSubpath();
1680	}
1681	break;
1682	case 'l': {
1683	if (count < 2) {
1684	ok = false;
1685	break;
1686	}
1687	x = num[0] + offsetX;
1688	y = num[1] + offsetY;
1689	num += 2;
1690	count -= 2;
1691	path.lineTo(x, y);
1692
1693	}
1694	break;
1695	case 'L': {
1696	if (count < 2) {
1697	ok = false;
1698	break;
1699	}
1700	x = num[0];
1701	y = num[1];
1702	num += 2;
1703	count -= 2;
1704	path.lineTo(x, y);
1705	}
1706	break;
1707	case 'h': {
1708	x = num[0] + offsetX;
1709	num++;
1710	count--;
1711	path.lineTo(x, y);
1712	}
1713	break;
1714	case 'H': {
1715	x = num[0];
1716	num++;
1717	count--;
1718	path.lineTo(x, y);
1719	}
1720	break;
1721	case 'v': {
1722	y = num[0] + offsetY;
1723	num++;
1724	count--;
1725	path.lineTo(x, y);
1726	}
1727	break;
1728	case 'V': {
1729	y = num[0];
1730	num++;
1731	count--;
1732	path.lineTo(x, y);
1733	}
1734	break;
1735	case 'c': {
1736	if (count < 6) {
1737	ok = false;
1738	break;
1739	}
1740	QPointF c1(num[0] + offsetX, num[1] + offsetY);
1741	QPointF c2(num[2] + offsetX, num[3] + offsetY);
1742	QPointF e(num[4] + offsetX, num[5] + offsetY);
1743	num += 6;
1744	count -= 6;
1745	path.cubicTo(ctrlPt1: c1, ctrlPt2: c2, endPt: e);
1746	ctrlPt = c2;
1747	x = e.x();
1748	y = e.y();
1749	break;
1750	}
1751	case 'C': {
1752	if (count < 6) {
1753	ok = false;
1754	break;
1755	}
1756	QPointF c1(num[0], num[1]);
1757	QPointF c2(num[2], num[3]);
1758	QPointF e(num[4], num[5]);
1759	num += 6;
1760	count -= 6;
1761	path.cubicTo(ctrlPt1: c1, ctrlPt2: c2, endPt: e);
1762	ctrlPt = c2;
1763	x = e.x();
1764	y = e.y();
1765	break;
1766	}
1767	case 's': {
1768	if (count < 4) {
1769	ok = false;
1770	break;
1771	}
1772	QPointF c1;
1773	if (lastMode == 'c' || lastMode == 'C' ||
1774	lastMode == 's' || lastMode == 'S')
1775	c1 = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y());
1776	else
1777	c1 = QPointF(x, y);
1778	QPointF c2(num[0] + offsetX, num[1] + offsetY);
1779	QPointF e(num[2] + offsetX, num[3] + offsetY);
1780	num += 4;
1781	count -= 4;
1782	path.cubicTo(ctrlPt1: c1, ctrlPt2: c2, endPt: e);
1783	ctrlPt = c2;
1784	x = e.x();
1785	y = e.y();
1786	break;
1787	}
1788	case 'S': {
1789	if (count < 4) {
1790	ok = false;
1791	break;
1792	}
1793	QPointF c1;
1794	if (lastMode == 'c' || lastMode == 'C' ||
1795	lastMode == 's' || lastMode == 'S')
1796	c1 = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y());
1797	else
1798	c1 = QPointF(x, y);
1799	QPointF c2(num[0], num[1]);
1800	QPointF e(num[2], num[3]);
1801	num += 4;
1802	count -= 4;
1803	path.cubicTo(ctrlPt1: c1, ctrlPt2: c2, endPt: e);
1804	ctrlPt = c2;
1805	x = e.x();
1806	y = e.y();
1807	break;
1808	}
1809	case 'q': {
1810	if (count < 4) {
1811	ok = false;
1812	break;
1813	}
1814	QPointF c(num[0] + offsetX, num[1] + offsetY);
1815	QPointF e(num[2] + offsetX, num[3] + offsetY);
1816	num += 4;
1817	count -= 4;
1818	path.quadTo(ctrlPt: c, endPt: e);
1819	ctrlPt = c;
1820	x = e.x();
1821	y = e.y();
1822	break;
1823	}
1824	case 'Q': {
1825	if (count < 4) {
1826	ok = false;
1827	break;
1828	}
1829	QPointF c(num[0], num[1]);
1830	QPointF e(num[2], num[3]);
1831	num += 4;
1832	count -= 4;
1833	path.quadTo(ctrlPt: c, endPt: e);
1834	ctrlPt = c;
1835	x = e.x();
1836	y = e.y();
1837	break;
1838	}
1839	case 't': {
1840	if (count < 2) {
1841	ok = false;
1842	break;
1843	}
1844	QPointF e(num[0] + offsetX, num[1] + offsetY);
1845	num += 2;
1846	count -= 2;
1847	QPointF c;
1848	if (lastMode == 'q' || lastMode == 'Q' ||
1849	lastMode == 't' || lastMode == 'T')
1850	c = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y());
1851	else
1852	c = QPointF(x, y);
1853	path.quadTo(ctrlPt: c, endPt: e);
1854	ctrlPt = c;
1855	x = e.x();
1856	y = e.y();
1857	break;
1858	}
1859	case 'T': {
1860	if (count < 2) {
1861	ok = false;
1862	break;
1863	}
1864	QPointF e(num[0], num[1]);
1865	num += 2;
1866	count -= 2;
1867	QPointF c;
1868	if (lastMode == 'q' || lastMode == 'Q' ||
1869	lastMode == 't' || lastMode == 'T')
1870	c = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y());
1871	else
1872	c = QPointF(x, y);
1873	path.quadTo(ctrlPt: c, endPt: e);
1874	ctrlPt = c;
1875	x = e.x();
1876	y = e.y();
1877	break;
1878	}
1879	case 'a': {
1880	if (count < 7) {
1881	ok = false;
1882	break;
1883	}
1884	qreal rx = (*num++);
1885	qreal ry = (*num++);
1886	qreal xAxisRotation = (*num++);
1887	qreal largeArcFlag = (*num++);
1888	qreal sweepFlag = (*num++);
1889	qreal ex = (*num++) + offsetX;
1890	qreal ey = (*num++) + offsetY;
1891	count -= 7;
1892	qreal curx = x;
1893	qreal cury = y;
1894	pathArc(path, rx, ry, x_axis_rotation: xAxisRotation, large_arc_flag: int(largeArcFlag),
1895	sweep_flag: int(sweepFlag), x: ex, y: ey, curx, cury);
1896
1897	x = ex;
1898	y = ey;
1899	}
1900	break;
1901	case 'A': {
1902	if (count < 7) {
1903	ok = false;
1904	break;
1905	}
1906	qreal rx = (*num++);
1907	qreal ry = (*num++);
1908	qreal xAxisRotation = (*num++);
1909	qreal largeArcFlag = (*num++);
1910	qreal sweepFlag = (*num++);
1911	qreal ex = (*num++);
1912	qreal ey = (*num++);
1913	count -= 7;
1914	qreal curx = x;
1915	qreal cury = y;
1916	pathArc(path, rx, ry, x_axis_rotation: xAxisRotation, large_arc_flag: int(largeArcFlag),
1917	sweep_flag: int(sweepFlag), x: ex, y: ey, curx, cury);
1918
1919	x = ex;
1920	y = ey;
1921	}
1922	break;
1923	default:
1924	ok = false;
1925	break;
1926	}
1927	lastMode = pathElem.toLatin1();
1928	if (limitLength && path.elementCount() > maxElementCount)
1929	ok = false;
1930	}
1931	}
1932	return ok;
1933	}
1934
1935	static bool parseStyle(QSvgNode *node,
1936	const QXmlStreamAttributes &attributes,
1937	QSvgHandler *);
1938
1939	static bool parseStyle(QSvgNode *node,
1940	const QSvgAttributes &attributes,
1941	QSvgHandler *);
1942
1943	#ifndef QT_NO_CSSPARSER
1944
1945	static void parseCSStoXMLAttrs(const QList<QCss::Declaration> &declarations,
1946	QXmlStreamAttributes &attributes)
1947	{
1948	for (int i = 0; i < declarations.size(); ++i) {
1949	const QCss::Declaration &decl = declarations.at(i);
1950	if (decl.d->property.isEmpty())
1951	continue;
1952	QCss::Value val = decl.d->values.first();
1953	QString valueStr;
1954	const int valCount = decl.d->values.size();
1955	if (valCount != 1) {
1956	for (int i = 0; i < valCount; ++i) {
1957	valueStr += decl.d->values[i].toString();
1958	if (i + 1 < valCount)
1959	valueStr += QLatin1Char(',');
1960	}
1961	} else {
1962	valueStr = val.toString();
1963	}
1964	if (val.type == QCss::Value::Uri) {
1965	valueStr.prepend(s: QLatin1String("url("));
1966	valueStr.append(c: QLatin1Char(')'));
1967	} else if (val.type == QCss::Value::Function) {
1968	QStringList lst = val.variant.toStringList();
1969	valueStr.append(s: lst.at(i: 0));
1970	valueStr.append(c: QLatin1Char('('));
1971	for (int i = 1; i < lst.size(); ++i) {
1972	valueStr.append(s: lst.at(i));
1973	if ((i +1) < lst.size())
1974	valueStr.append(c: QLatin1Char(','));
1975	}
1976	valueStr.append(c: QLatin1Char(')'));
1977	} else if (val.type == QCss::Value::KnownIdentifier) {
1978	switch (val.variant.toInt()) {
1979	case QCss::Value_None:
1980	valueStr = QLatin1String("none");
1981	break;
1982	default:
1983	break;
1984	}
1985	}
1986
1987	attributes.append(namespaceUri: QString(), name: decl.d->property, value: valueStr);
1988	}
1989	}
1990
1991	void QSvgHandler::parseCSStoXMLAttrs(const QString &css, QList<QSvgCssAttribute> *attributes)
1992	{
1993	// preprocess (for unicode escapes), tokenize and remove comments
1994	m_cssParser.init(css);
1995	QString key;
1996
1997	attributes->reserve(asize: 10);
1998
1999	while (m_cssParser.hasNext()) {
2000	m_cssParser.skipSpace();
2001
2002	if (!m_cssParser.hasNext())
2003	break;
2004	m_cssParser.next();
2005
2006	QString name;
2007	if (m_cssParser.hasEscapeSequences) {
2008	key = m_cssParser.lexem();
2009	name = key;
2010	} else {
2011	const QCss::Symbol &sym = m_cssParser.symbol();
2012	name = sym.text.mid(position: sym.start, n: sym.len);
2013	}
2014
2015	m_cssParser.skipSpace();
2016	if (!m_cssParser.test(t: QCss::COLON))
2017	break;
2018
2019	m_cssParser.skipSpace();
2020	if (!m_cssParser.hasNext())
2021	break;
2022
2023	QSvgCssAttribute attribute;
2024	attribute.name = name;
2025
2026	const int firstSymbol = m_cssParser.index;
2027	int symbolCount = 0;
2028	do {
2029	m_cssParser.next();
2030	++symbolCount;
2031	} while (m_cssParser.hasNext() && !m_cssParser.test(t: QCss::SEMICOLON));
2032
2033	bool canExtractValueByRef = !m_cssParser.hasEscapeSequences;
2034	if (canExtractValueByRef) {
2035	int len = m_cssParser.symbols.at(i: firstSymbol).len;
2036	for (int i = firstSymbol + 1; i < firstSymbol + symbolCount; ++i) {
2037	len += m_cssParser.symbols.at(i).len;
2038
2039	if (m_cssParser.symbols.at(i: i - 1).start + m_cssParser.symbols.at(i: i - 1).len
2040	!= m_cssParser.symbols.at(i).start) {
2041	canExtractValueByRef = false;
2042	break;
2043	}
2044	}
2045	if (canExtractValueByRef) {
2046	const QCss::Symbol &sym = m_cssParser.symbols.at(i: firstSymbol);
2047	attribute.value = sym.text.mid(position: sym.start, n: len);
2048	}
2049	}
2050	if (!canExtractValueByRef) {
2051	QString value;
2052	for (int i = firstSymbol; i < m_cssParser.index - 1; ++i)
2053	value += m_cssParser.symbols.at(i).lexem();
2054	attribute.value = value;
2055	}
2056
2057	attributes->append(t: attribute);
2058
2059	m_cssParser.skipSpace();
2060	}
2061	}
2062
2063	static void cssStyleLookup(QSvgNode *node,
2064	QSvgHandler *handler,
2065	QSvgStyleSelector *selector,
2066	QXmlStreamAttributes &attributes)
2067	{
2068	QCss::StyleSelector::NodePtr cssNode;
2069	cssNode.ptr = node;
2070	QList<QCss::Declaration> decls = selector->declarationsForNode(node: cssNode);
2071
2072	parseCSStoXMLAttrs(declarations: decls, attributes);
2073	parseStyle(node, attributes, handler);
2074	}
2075
2076	static void cssStyleLookup(QSvgNode *node,
2077	QSvgHandler *handler,
2078	QSvgStyleSelector *selector)
2079	{
2080	QXmlStreamAttributes attributes;
2081	cssStyleLookup(node, handler, selector, attributes);
2082	}
2083
2084	#endif // QT_NO_CSSPARSER
2085
2086	QtSvg::Options QSvgHandler::options() const
2087	{
2088	return m_options;
2089	}
2090
2091	bool QSvgHandler::trustedSourceMode() const
2092	{
2093	return m_options.testFlag(flag: QtSvg::AssumeTrustedSource);
2094	}
2095
2096	static inline QStringList stringToList(const QString &str)
2097	{
2098	QStringList lst = str.split(sep: QLatin1Char(','), behavior: Qt::SkipEmptyParts);
2099	return lst;
2100	}
2101
2102	static bool parseCoreNode(QSvgNode *node,
2103	const QXmlStreamAttributes &attributes)
2104	{
2105	QStringList features;
2106	QStringList extensions;
2107	QStringList languages;
2108	QStringList formats;
2109	QStringList fonts;
2110	QString xmlClassStr;
2111
2112	for (int i = 0; i < attributes.size(); ++i) {
2113	const QXmlStreamAttribute &attribute = attributes.at(i);
2114	QStringView name = attribute.qualifiedName();
2115	if (name.isEmpty())
2116	continue;
2117	QStringView value = attribute.value();
2118	switch (name.at(n: 0).unicode()) {
2119	case 'c':
2120	if (name == QLatin1String("class"))
2121	xmlClassStr = value.toString();
2122	break;
2123	case 'r':
2124	if (name == QLatin1String("requiredFeatures"))
2125	features = stringToList(str: value.toString());
2126	else if (name == QLatin1String("requiredExtensions"))
2127	extensions = stringToList(str: value.toString());
2128	else if (name == QLatin1String("requiredFormats"))
2129	formats = stringToList(str: value.toString());
2130	else if (name == QLatin1String("requiredFonts"))
2131	fonts = stringToList(str: value.toString());
2132	break;
2133	case 's':
2134	if (name == QLatin1String("systemLanguage"))
2135	languages = stringToList(str: value.toString());
2136	break;
2137	default:
2138	break;
2139	}
2140	}
2141
2142	node->setRequiredFeatures(features);
2143	node->setRequiredExtensions(extensions);
2144	node->setRequiredLanguages(languages);
2145	node->setRequiredFormats(formats);
2146	node->setRequiredFonts(fonts);
2147	node->setNodeId(someId(attributes));
2148	node->setXmlClass(xmlClassStr);
2149
2150	return true;
2151	}
2152
2153	static void parseOpacity(QSvgNode *node,
2154	const QSvgAttributes &attributes,
2155	QSvgHandler *)
2156	{
2157	if (attributes.opacity.isEmpty())
2158	return;
2159
2160	const QStringView value = attributes.opacity.trimmed();
2161
2162	bool ok = false;
2163	qreal op = value.toDouble(ok: &ok);
2164
2165	if (ok) {
2166	QSvgOpacityStyle *opacity = new QSvgOpacityStyle(qBound(min: qreal(0.0), val: op, max: qreal(1.0)));
2167	node->appendStyleProperty(prop: opacity, id: attributes.id);
2168	}
2169	}
2170
2171	static QPainter::CompositionMode svgToQtCompositionMode(const QString &op)
2172	{
2173	#define NOOP qDebug()<<"Operation: "<<op<<" is not implemented"
2174	if (op == QLatin1String("clear")) {
2175	return QPainter::CompositionMode_Clear;
2176	} else if (op == QLatin1String("src")) {
2177	return QPainter::CompositionMode_Source;
2178	} else if (op == QLatin1String("dst")) {
2179	return QPainter::CompositionMode_Destination;
2180	} else if (op == QLatin1String("src-over")) {
2181	return QPainter::CompositionMode_SourceOver;
2182	} else if (op == QLatin1String("dst-over")) {
2183	return QPainter::CompositionMode_DestinationOver;
2184	} else if (op == QLatin1String("src-in")) {
2185	return QPainter::CompositionMode_SourceIn;
2186	} else if (op == QLatin1String("dst-in")) {
2187	return QPainter::CompositionMode_DestinationIn;
2188	} else if (op == QLatin1String("src-out")) {
2189	return QPainter::CompositionMode_SourceOut;
2190	} else if (op == QLatin1String("dst-out")) {
2191	return QPainter::CompositionMode_DestinationOut;
2192	} else if (op == QLatin1String("src-atop")) {
2193	return QPainter::CompositionMode_SourceAtop;
2194	} else if (op == QLatin1String("dst-atop")) {
2195	return QPainter::CompositionMode_DestinationAtop;
2196	} else if (op == QLatin1String("xor")) {
2197	return QPainter::CompositionMode_Xor;
2198	} else if (op == QLatin1String("plus")) {
2199	return QPainter::CompositionMode_Plus;
2200	} else if (op == QLatin1String("multiply")) {
2201	return QPainter::CompositionMode_Multiply;
2202	} else if (op == QLatin1String("screen")) {
2203	return QPainter::CompositionMode_Screen;
2204	} else if (op == QLatin1String("overlay")) {
2205	return QPainter::CompositionMode_Overlay;
2206	} else if (op == QLatin1String("darken")) {
2207	return QPainter::CompositionMode_Darken;
2208	} else if (op == QLatin1String("lighten")) {
2209	return QPainter::CompositionMode_Lighten;
2210	} else if (op == QLatin1String("color-dodge")) {
2211	return QPainter::CompositionMode_ColorDodge;
2212	} else if (op == QLatin1String("color-burn")) {
2213	return QPainter::CompositionMode_ColorBurn;
2214	} else if (op == QLatin1String("hard-light")) {
2215	return QPainter::CompositionMode_HardLight;
2216	} else if (op == QLatin1String("soft-light")) {
2217	return QPainter::CompositionMode_SoftLight;
2218	} else if (op == QLatin1String("difference")) {
2219	return QPainter::CompositionMode_Difference;
2220	} else if (op == QLatin1String("exclusion")) {
2221	return QPainter::CompositionMode_Exclusion;
2222	} else {
2223	NOOP;
2224	}
2225
2226	return QPainter::CompositionMode_SourceOver;
2227	}
2228
2229	static void parseCompOp(QSvgNode *node,
2230	const QSvgAttributes &attributes,
2231	QSvgHandler *)
2232	{
2233	if (attributes.compOp.isEmpty())
2234	return;
2235	QString value = attributes.compOp.toString().trimmed();
2236
2237	if (!value.isEmpty()) {
2238	QSvgCompOpStyle *compop = new QSvgCompOpStyle(svgToQtCompositionMode(op: value));
2239	node->appendStyleProperty(prop: compop, id: attributes.id);
2240	}
2241	}
2242
2243	static inline QSvgNode::DisplayMode displayStringToEnum(const QString &str)
2244	{
2245	if (str == QLatin1String("inline")) {
2246	return QSvgNode::InlineMode;
2247	} else if (str == QLatin1String("block")) {
2248	return QSvgNode::BlockMode;
2249	} else if (str == QLatin1String("list-item")) {
2250	return QSvgNode::ListItemMode;
2251	} else if (str == QLatin1String("run-in")) {
2252	return QSvgNode::RunInMode;
2253	} else if (str == QLatin1String("compact")) {
2254	return QSvgNode::CompactMode;
2255	} else if (str == QLatin1String("marker")) {
2256	return QSvgNode::MarkerMode;
2257	} else if (str == QLatin1String("table")) {
2258	return QSvgNode::TableMode;
2259	} else if (str == QLatin1String("inline-table")) {
2260	return QSvgNode::InlineTableMode;
2261	} else if (str == QLatin1String("table-row-group")) {
2262	return QSvgNode::TableRowGroupMode;
2263	} else if (str == QLatin1String("table-header-group")) {
2264	return QSvgNode::TableHeaderGroupMode;
2265	} else if (str == QLatin1String("table-footer-group")) {
2266	return QSvgNode::TableFooterGroupMode;
2267	} else if (str == QLatin1String("table-row")) {
2268	return QSvgNode::TableRowMode;
2269	} else if (str == QLatin1String("table-column-group")) {
2270	return QSvgNode::TableColumnGroupMode;
2271	} else if (str == QLatin1String("table-column")) {
2272	return QSvgNode::TableColumnMode;
2273	} else if (str == QLatin1String("table-cell")) {
2274	return QSvgNode::TableCellMode;
2275	} else if (str == QLatin1String("table-caption")) {
2276	return QSvgNode::TableCaptionMode;
2277	} else if (str == QLatin1String("none")) {
2278	return QSvgNode::NoneMode;
2279	} else if (str == QT_INHERIT) {
2280	return QSvgNode::InheritMode;
2281	}
2282	return QSvgNode::BlockMode;
2283	}
2284
2285	static void parseOthers(QSvgNode *node,
2286	const QSvgAttributes &attributes,
2287	QSvgHandler *)
2288	{
2289	if (attributes.display.isEmpty())
2290	return;
2291	QString displayStr = attributes.display.toString().trimmed();
2292
2293	if (!displayStr.isEmpty()) {
2294	node->setDisplayMode(displayStringToEnum(str: displayStr));
2295	}
2296	}
2297
2298	static void parseExtendedAttributes(QSvgNode *node,
2299	const QSvgAttributes &attributes,
2300	QSvgHandler *handler)
2301	{
2302	if (handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly))
2303	return;
2304
2305	if (!attributes.mask.isEmpty()) {
2306	QString maskStr = attributes.mask.toString().trimmed();
2307	if (maskStr.size() > 3 && maskStr.mid(position: 0, n: 3) == QLatin1String("url"))
2308	maskStr = maskStr.mid(position: 3, n: maskStr.size() - 3);
2309	QString maskId = idFromUrl(url: maskStr);
2310	if (maskId.startsWith(c: QLatin1Char('#'))) //TODO: handle urls and ids in a single place
2311	maskId.remove(i: 0, len: 1);
2312
2313	node->setMaskId(maskId);
2314	}
2315
2316	if (!attributes.markerStart.isEmpty() &&
2317	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly)) {
2318	QString markerStr = attributes.markerStart.toString().trimmed();
2319	if (markerStr.size() > 3 && markerStr.mid(position: 0, n: 3) == QLatin1String("url"))
2320	markerStr = markerStr.mid(position: 3, n: markerStr.size() - 3);
2321	QString markerId = idFromUrl(url: markerStr);
2322	if (markerId.startsWith(c: QLatin1Char('#'))) //TODO: handle urls and ids in a single place
2323	markerId.remove(i: 0, len: 1);
2324	node->setMarkerStartId(markerId);
2325	}
2326	if (!attributes.markerMid.isEmpty() &&
2327	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly)) {
2328	QString markerStr = attributes.markerMid.toString().trimmed();
2329	if (markerStr.size() > 3 && markerStr.mid(position: 0, n: 3) == QLatin1String("url"))
2330	markerStr = markerStr.mid(position: 3, n: markerStr.size() - 3);
2331	QString markerId = idFromUrl(url: markerStr);
2332	if (markerId.startsWith(c: QLatin1Char('#'))) //TODO: handle urls and ids in a single place
2333	markerId.remove(i: 0, len: 1);
2334	node->setMarkerMidId(markerId);
2335	}
2336	if (!attributes.markerEnd.isEmpty() &&
2337	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly)) {
2338	QString markerStr = attributes.markerEnd.toString().trimmed();
2339	if (markerStr.size() > 3 && markerStr.mid(position: 0, n: 3) == QLatin1String("url"))
2340	markerStr = markerStr.mid(position: 3, n: markerStr.size() - 3);
2341	QString markerId = idFromUrl(url: markerStr);
2342	if (markerId.startsWith(c: QLatin1Char('#'))) //TODO: handle urls and ids in a single place
2343	markerId.remove(i: 0, len: 1);
2344	node->setMarkerEndId(markerId);
2345	}
2346
2347	if (!attributes.filter.isEmpty() &&
2348	!handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly)) {
2349	QString filterStr = attributes.filter.toString().trimmed();
2350
2351	if (filterStr.size() > 3 && filterStr.mid(position: 0, n: 3) == QLatin1String("url"))
2352	filterStr = filterStr.mid(position: 3, n: filterStr.size() - 3);
2353	QString filterId = idFromUrl(url: filterStr);
2354	if (filterId.startsWith(c: QLatin1Char('#'))) //TODO: handle urls and ids in a single place
2355	filterId.remove(i: 0, len: 1);
2356	node->setFilterId(filterId);
2357	}
2358
2359	}
2360
2361	static void parseRenderingHints(QSvgNode *node,
2362	const QSvgAttributes &attributes,
2363	QSvgHandler *)
2364	{
2365	if (attributes.imageRendering.isEmpty())
2366	return;
2367
2368	QString ir = attributes.imageRendering.toString().trimmed();
2369	QSvgQualityStyle *p = new QSvgQualityStyle(0);
2370	if (ir == QLatin1String("auto"))
2371	p->setImageRendering(QSvgQualityStyle::ImageRenderingAuto);
2372	else if (ir == QLatin1String("optimizeSpeed"))
2373	p->setImageRendering(QSvgQualityStyle::ImageRenderingOptimizeSpeed);
2374	else if (ir == QLatin1String("optimizeQuality"))
2375	p->setImageRendering(QSvgQualityStyle::ImageRenderingOptimizeQuality);
2376	node->appendStyleProperty(prop: p, id: attributes.id);
2377	}
2378
2379
2380	static bool parseStyle(QSvgNode *node,
2381	const QSvgAttributes &attributes,
2382	QSvgHandler *handler)
2383	{
2384	parseColor(node, attributes, handler);
2385	parseBrush(node, attributes, handler);
2386	parsePen(node, attributes, handler);
2387	parseFont(node, attributes, handler);
2388	parseTransform(node, attributes, handler);
2389	parseVisibility(node, attributes, handler);
2390	parseOpacity(node, attributes, handler);
2391	parseCompOp(node, attributes, handler);
2392	parseRenderingHints(node, attributes, handler);
2393	parseOthers(node, attributes, handler);
2394	parseExtendedAttributes(node, attributes, handler);
2395
2396	#if 0
2397	value = attributes.value("audio-level");
2398
2399	value = attributes.value("color-rendering");
2400
2401	value = attributes.value("display-align");
2402
2403	value = attributes.value("image-rendering");
2404
2405	value = attributes.value("line-increment");
2406
2407	value = attributes.value("pointer-events");
2408
2409	value = attributes.value("shape-rendering");
2410
2411	value = attributes.value("solid-color");
2412
2413	value = attributes.value("solid-opacity");
2414
2415	value = attributes.value("text-rendering");
2416
2417	value = attributes.value("vector-effect");
2418
2419	value = attributes.value("viewport-fill");
2420
2421	value = attributes.value("viewport-fill-opacity");
2422	#endif
2423	return true;
2424	}
2425
2426	static bool parseStyle(QSvgNode *node,
2427	const QXmlStreamAttributes &attrs,
2428	QSvgHandler *handler)
2429	{
2430	return parseStyle(node, attributes: QSvgAttributes(attrs, handler), handler);
2431	}
2432
2433	static bool parseAnchorNode(QSvgNode *parent,
2434	const QXmlStreamAttributes &attributes,
2435	QSvgHandler *)
2436	{
2437	Q_UNUSED(parent); Q_UNUSED(attributes);
2438	return true;
2439	}
2440
2441	static bool parseAnimateNode(QSvgNode *parent,
2442	const QXmlStreamAttributes &attributes,
2443	QSvgHandler *)
2444	{
2445	Q_UNUSED(parent); Q_UNUSED(attributes);
2446	return true;
2447	}
2448
2449	static int parseClockValue(QStringView str, bool *ok)
2450	{
2451	int res = 0;
2452	int ms = 1000;
2453	str = str.trimmed();
2454	if (str.endsWith(s: QLatin1String("ms"))) {
2455	str.chop(n: 2);
2456	ms = 1;
2457	} else if (str.endsWith(s: QLatin1String("s"))) {
2458	str.chop(n: 1);
2459	}
2460	double val = ms * toDouble(str, ok);
2461	if (ok) {
2462	if (val > std::numeric_limits<int>::min() && val < std::numeric_limits<int>::max())
2463	res = static_cast<int>(val);
2464	else
2465	*ok = false;
2466	}
2467	return res;
2468	}
2469
2470	static bool parseBaseAnimate(QSvgNode *parent,
2471	const QXmlStreamAttributes &attributes,
2472	QSvgAnimate *anim,
2473	QSvgHandler *handler)
2474	{
2475	QString beginStr = attributes.value(qualifiedName: QLatin1String("begin")).toString();
2476	QString durStr = attributes.value(qualifiedName: QLatin1String("dur")).toString();
2477	QString endStr = attributes.value(qualifiedName: QLatin1String("end")).toString();
2478	QString repeatStr = attributes.value(qualifiedName: QLatin1String("repeatCount")).toString();
2479
2480	bool ok = true;
2481	int begin = parseClockValue(str: beginStr, ok: &ok);
2482	if (!ok)
2483	return false;
2484	int dur = parseClockValue(str: durStr, ok: &ok);
2485	if (!ok)
2486	return false;
2487	int end = parseClockValue(str: endStr, ok: &ok);
2488	if (!ok)
2489	return false;
2490	qreal repeatCount = (repeatStr == QLatin1String("indefinite")) ? -1 :
2491	qMax(a: 1.0, b: toDouble(str: repeatStr));
2492
2493	anim->setRunningTime(startMs: begin, durMs: dur, endMs: end, by: 0);
2494	anim->setRepeatCount(repeatCount);
2495
2496	parent->appendStyleProperty(prop: anim, id: QString());
2497	parent->document()->setAnimated(true);
2498
2499	handler->setAnimPeriod(start: begin, end);
2500	return true;
2501	}
2502
2503	static bool parseAnimateColorNode(QSvgNode *parent,
2504	const QXmlStreamAttributes &attributes,
2505	QSvgHandler *handler)
2506	{
2507	QStringView fromStr = attributes.value(qualifiedName: QLatin1String("from"));
2508	QStringView toStr = attributes.value(qualifiedName: QLatin1String("to"));
2509	QString valuesStr = attributes.value(qualifiedName: QLatin1String("values")).toString();
2510	QString targetStr = attributes.value(qualifiedName: QLatin1String("attributeName")).toString();
2511	QString fillStr = attributes.value(qualifiedName: QLatin1String("fill")).toString();
2512
2513	if (targetStr != QLatin1String("fill") && targetStr != QLatin1String("stroke"))
2514	return false;
2515
2516	QList<QColor> colors;
2517	if (valuesStr.isEmpty()) {
2518	QColor startColor, endColor;
2519	resolveColor(colorStr: fromStr, color&: startColor, handler);
2520	resolveColor(colorStr: toStr, color&: endColor, handler);
2521	colors.reserve(asize: 2);
2522	colors.append(t: startColor);
2523	colors.append(t: endColor);
2524	} else {
2525	QStringList str = valuesStr.split(sep: QLatin1Char(';'));
2526	colors.reserve(asize: str.size());
2527	QStringList::const_iterator itr;
2528	for (itr = str.constBegin(); itr != str.constEnd(); ++itr) {
2529	QColor color;
2530	resolveColor(colorStr: *itr, color, handler);
2531	colors.append(t: color);
2532	}
2533	}
2534
2535	QSvgAnimateColor *anim = new QSvgAnimateColor();
2536	parseBaseAnimate(parent, attributes, anim, handler);
2537
2538	anim->setArgs(fill: (targetStr == QLatin1String("fill")), colors);
2539	anim->setFreeze(fillStr == QLatin1String("freeze"));
2540
2541	return true;
2542	}
2543
2544	static bool parseAimateMotionNode(QSvgNode *parent,
2545	const QXmlStreamAttributes &attributes,
2546	QSvgHandler *)
2547	{
2548	Q_UNUSED(parent); Q_UNUSED(attributes);
2549	return true;
2550	}
2551
2552	static void parseNumberTriplet(QList<qreal> &values, const QChar *&s)
2553	{
2554	QList<qreal> list = parseNumbersList(str&: s);
2555	values << list;
2556	for (int i = 3 - list.size(); i > 0; --i)
2557	values.append(t: 0.0);
2558	}
2559
2560	static bool parseAnimateTransformNode(QSvgNode *parent,
2561	const QXmlStreamAttributes &attributes,
2562	QSvgHandler *handler)
2563	{
2564	QString typeStr = attributes.value(qualifiedName: QLatin1String("type")).toString();
2565	QString values = attributes.value(qualifiedName: QLatin1String("values")).toString();
2566	QString fillStr = attributes.value(qualifiedName: QLatin1String("fill")).toString();
2567	QString fromStr = attributes.value(qualifiedName: QLatin1String("from")).toString();
2568	QString toStr = attributes.value(qualifiedName: QLatin1String("to")).toString();
2569	QString byStr = attributes.value(qualifiedName: QLatin1String("by")).toString();
2570	QString addtv = attributes.value(qualifiedName: QLatin1String("additive")).toString();
2571
2572	QSvgAnimateTransform::Additive additive = QSvgAnimateTransform::Replace;
2573	if (addtv == QLatin1String("sum"))
2574	additive = QSvgAnimateTransform::Sum;
2575
2576	QList<qreal> vals;
2577	if (values.isEmpty()) {
2578	const QChar *s;
2579	if (fromStr.isEmpty()) {
2580	if (!byStr.isEmpty()) {
2581	// By-animation.
2582	additive = QSvgAnimateTransform::Sum;
2583	vals.append(t: 0.0);
2584	vals.append(t: 0.0);
2585	vals.append(t: 0.0);
2586	parseNumberTriplet(values&: vals, s&: s = byStr.constData());
2587	} else {
2588	// To-animation not defined.
2589	return false;
2590	}
2591	} else {
2592	if (!toStr.isEmpty()) {
2593	// From-to-animation.
2594	parseNumberTriplet(values&: vals, s&: s = fromStr.constData());
2595	parseNumberTriplet(values&: vals, s&: s = toStr.constData());
2596	} else if (!byStr.isEmpty()) {
2597	// From-by-animation.
2598	parseNumberTriplet(values&: vals, s&: s = fromStr.constData());
2599	parseNumberTriplet(values&: vals, s&: s = byStr.constData());
2600	for (int i = vals.size() - 3; i < vals.size(); ++i)
2601	vals[i] += vals[i - 3];
2602	} else {
2603	return false;
2604	}
2605	}
2606	} else {
2607	const QChar *s = values.constData();
2608	while (s && *s != QLatin1Char(0)) {
2609	parseNumberTriplet(values&: vals, s);
2610	if (*s == QLatin1Char(0))
2611	break;
2612	++s;
2613	}
2614	}
2615	if (vals.size() % 3 != 0)
2616	return false;
2617
2618	QSvgAnimateTransform::TransformType type = QSvgAnimateTransform::Empty;
2619	if (typeStr == QLatin1String("translate")) {
2620	type = QSvgAnimateTransform::Translate;
2621	} else if (typeStr == QLatin1String("scale")) {
2622	type = QSvgAnimateTransform::Scale;
2623	} else if (typeStr == QLatin1String("rotate")) {
2624	type = QSvgAnimateTransform::Rotate;
2625	} else if (typeStr == QLatin1String("skewX")) {
2626	type = QSvgAnimateTransform::SkewX;
2627	} else if (typeStr == QLatin1String("skewY")) {
2628	type = QSvgAnimateTransform::SkewY;
2629	} else {
2630	return false;
2631	}
2632
2633	QSvgAnimateTransform *anim = new QSvgAnimateTransform();
2634	parseBaseAnimate(parent, attributes, anim, handler);
2635
2636	anim->setArgs(type, additive, args: vals);
2637	anim->setFreeze(fillStr == QLatin1String("freeze"));
2638
2639	return true;
2640	}
2641
2642	static QSvgNode * createAnimationNode(QSvgNode *parent,
2643	const QXmlStreamAttributes &attributes,
2644	QSvgHandler *)
2645	{
2646	Q_UNUSED(parent); Q_UNUSED(attributes);
2647	return 0;
2648	}
2649
2650	static bool parseAudioNode(QSvgNode *parent,
2651	const QXmlStreamAttributes &attributes,
2652	QSvgHandler *)
2653	{
2654	Q_UNUSED(parent); Q_UNUSED(attributes);
2655	return true;
2656	}
2657
2658	static QSvgNode *createCircleNode(QSvgNode *parent,
2659	const QXmlStreamAttributes &attributes,
2660	QSvgHandler *)
2661	{
2662	const QStringView cx = attributes.value(qualifiedName: QLatin1String("cx"));
2663	const QStringView cy = attributes.value(qualifiedName: QLatin1String("cy"));
2664	const QStringView r = attributes.value(qualifiedName: QLatin1String("r"));
2665	qreal ncx = toDouble(str: cx);
2666	qreal ncy = toDouble(str: cy);
2667	qreal nr = toDouble(str: r);
2668	if (nr < 0.0)
2669	return nullptr;
2670
2671	QRectF rect(ncx-nr, ncy-nr, nr*2, nr*2);
2672	QSvgNode *circle = new QSvgCircle(parent, rect);
2673	return circle;
2674	}
2675
2676	static QSvgNode *createDefsNode(QSvgNode *parent,
2677	const QXmlStreamAttributes &attributes,
2678	QSvgHandler *)
2679	{
2680	Q_UNUSED(attributes);
2681	QSvgDefs *defs = new QSvgDefs(parent);
2682	return defs;
2683	}
2684
2685	static bool parseDiscardNode(QSvgNode *parent,
2686	const QXmlStreamAttributes &attributes,
2687	QSvgHandler *)
2688	{
2689	Q_UNUSED(parent); Q_UNUSED(attributes);
2690	return true;
2691	}
2692
2693	static QSvgNode *createEllipseNode(QSvgNode *parent,
2694	const QXmlStreamAttributes &attributes,
2695	QSvgHandler *)
2696	{
2697	const QStringView cx = attributes.value(qualifiedName: QLatin1String("cx"));
2698	const QStringView cy = attributes.value(qualifiedName: QLatin1String("cy"));
2699	const QStringView rx = attributes.value(qualifiedName: QLatin1String("rx"));
2700	const QStringView ry = attributes.value(qualifiedName: QLatin1String("ry"));
2701	qreal ncx = toDouble(str: cx);
2702	qreal ncy = toDouble(str: cy);
2703	qreal nrx = toDouble(str: rx);
2704	qreal nry = toDouble(str: ry);
2705
2706	QRectF rect(ncx-nrx, ncy-nry, nrx*2, nry*2);
2707	QSvgNode *ellipse = new QSvgEllipse(parent, rect);
2708	return ellipse;
2709	}
2710
2711	static QSvgStyleProperty *createFontNode(QSvgNode *parent,
2712	const QXmlStreamAttributes &attributes,
2713	QSvgHandler *)
2714	{
2715	const QStringView hax = attributes.value(qualifiedName: QLatin1String("horiz-adv-x"));
2716	QString myId = someId(attributes);
2717
2718	qreal horizAdvX = toDouble(str: hax);
2719
2720	while (parent && parent->type() != QSvgNode::Doc) {
2721	parent = parent->parent();
2722	}
2723
2724	if (parent && !myId.isEmpty()) {
2725	QSvgTinyDocument *doc = static_cast<QSvgTinyDocument*>(parent);
2726	QSvgFont *font = doc->svgFont(family: myId);
2727	if (!font) {
2728	font = new QSvgFont(horizAdvX);
2729	font->setFamilyName(myId);
2730	doc->addSvgFont(font);
2731	}
2732	return new QSvgFontStyle(font, doc);
2733	}
2734	return nullptr;
2735	}
2736
2737	static bool parseFontFaceNode(QSvgStyleProperty *parent,
2738	const QXmlStreamAttributes &attributes,
2739	QSvgHandler *)
2740	{
2741	if (parent->type() != QSvgStyleProperty::FONT) {
2742	return false;
2743	}
2744
2745	QSvgFontStyle *style = static_cast<QSvgFontStyle*>(parent);
2746	QSvgFont *font = style->svgFont();
2747	QString name = attributes.value(qualifiedName: QLatin1String("font-family")).toString();
2748	const QStringView unitsPerEmStr = attributes.value(qualifiedName: QLatin1String("units-per-em"));
2749
2750	qreal unitsPerEm = toDouble(str: unitsPerEmStr);
2751	if (!unitsPerEm)
2752	unitsPerEm = QSvgFont::DEFAULT_UNITS_PER_EM;
2753
2754	if (!name.isEmpty())
2755	font->setFamilyName(name);
2756	font->setUnitsPerEm(unitsPerEm);
2757
2758	if (!font->familyName().isEmpty())
2759	if (!style->doc()->svgFont(family: font->familyName()))
2760	style->doc()->addSvgFont(font);
2761
2762	return true;
2763	}
2764
2765	static bool parseFontFaceNameNode(QSvgStyleProperty *parent,
2766	const QXmlStreamAttributes &attributes,
2767	QSvgHandler *)
2768	{
2769	if (parent->type() != QSvgStyleProperty::FONT) {
2770	return false;
2771	}
2772
2773	QSvgFontStyle *style = static_cast<QSvgFontStyle*>(parent);
2774	QSvgFont *font = style->svgFont();
2775	QString name = attributes.value(qualifiedName: QLatin1String("name")).toString();
2776
2777	if (!name.isEmpty())
2778	font->setFamilyName(name);
2779
2780	if (!font->familyName().isEmpty())
2781	if (!style->doc()->svgFont(family: font->familyName()))
2782	style->doc()->addSvgFont(font);
2783
2784	return true;
2785	}
2786
2787	static bool parseFontFaceSrcNode(QSvgStyleProperty *parent,
2788	const QXmlStreamAttributes &attributes,
2789	QSvgHandler *)
2790	{
2791	Q_UNUSED(parent); Q_UNUSED(attributes);
2792	return true;
2793	}
2794
2795	static bool parseFontFaceUriNode(QSvgStyleProperty *parent,
2796	const QXmlStreamAttributes &attributes,
2797	QSvgHandler *)
2798	{
2799	Q_UNUSED(parent); Q_UNUSED(attributes);
2800	return true;
2801	}
2802
2803	static bool parseForeignObjectNode(QSvgNode *parent,
2804	const QXmlStreamAttributes &attributes,
2805	QSvgHandler *)
2806	{
2807	Q_UNUSED(parent); Q_UNUSED(attributes);
2808	return true;
2809	}
2810
2811	static QSvgNode *createGNode(QSvgNode *parent,
2812	const QXmlStreamAttributes &attributes,
2813	QSvgHandler *)
2814	{
2815	Q_UNUSED(attributes);
2816	QSvgG *node = new QSvgG(parent);
2817	return node;
2818	}
2819
2820	static bool parseGlyphNode(QSvgStyleProperty *parent,
2821	const QXmlStreamAttributes &attributes,
2822	QSvgHandler *)
2823	{
2824	if (parent->type() != QSvgStyleProperty::FONT) {
2825	return false;
2826	}
2827
2828	QSvgFontStyle *style = static_cast<QSvgFontStyle*>(parent);
2829	QSvgFont *font = style->svgFont();
2830	createSvgGlyph(font, attributes);
2831	return true;
2832	}
2833
2834	static bool parseHandlerNode(QSvgNode *parent,
2835	const QXmlStreamAttributes &attributes,
2836	QSvgHandler *)
2837	{
2838	Q_UNUSED(parent); Q_UNUSED(attributes);
2839	return true;
2840	}
2841
2842	static bool parseHkernNode(QSvgNode *parent,
2843	const QXmlStreamAttributes &attributes,
2844	QSvgHandler *)
2845	{
2846	Q_UNUSED(parent); Q_UNUSED(attributes);
2847	return true;
2848	}
2849
2850	static QSvgNode *createImageNode(QSvgNode *parent,
2851	const QXmlStreamAttributes &attributes,
2852	QSvgHandler *handler)
2853	{
2854	const QStringView x = attributes.value(qualifiedName: QLatin1String("x"));
2855	const QStringView y = attributes.value(qualifiedName: QLatin1String("y"));
2856	const QStringView width = attributes.value(qualifiedName: QLatin1String("width"));
2857	const QStringView height = attributes.value(qualifiedName: QLatin1String("height"));
2858	QString filename = attributes.value(qualifiedName: QLatin1String("xlink:href")).toString();
2859	if (filename.isEmpty() && !handler->options().testFlag(flag: QtSvg::Tiny12FeaturesOnly))
2860	filename = attributes.value(qualifiedName: QLatin1String("href")).toString();
2861	qreal nx = toDouble(str: x);
2862	qreal ny = toDouble(str: y);
2863	QSvgHandler::LengthType type;
2864	qreal nwidth = parseLength(str: width.toString(), type: &type, handler);
2865	nwidth = convertToPixels(len: nwidth, true, type);
2866
2867	qreal nheight = parseLength(str: height.toString(), type: &type, handler);
2868	nheight = convertToPixels(len: nheight, false, type);
2869
2870	filename = filename.trimmed();
2871	if (filename.isEmpty()) {
2872	qCWarning(lcSvgHandler) << "QSvgHandler: Image filename is empty";
2873	return 0;
2874	}
2875	if (nwidth <= 0 || nheight <= 0) {
2876	qCWarning(lcSvgHandler) << "QSvgHandler: Width or height for" << filename << "image was not greater than 0";
2877	return 0;
2878	}
2879
2880	QImage image;
2881	enum {
2882	NotLoaded,
2883	LoadedFromData,
2884	LoadedFromFile
2885	} filenameType = NotLoaded;
2886
2887	if (filename.startsWith(s: QLatin1String("data"))) {
2888	int idx = filename.lastIndexOf(s: QLatin1String("base64,"));
2889	if (idx != -1) {
2890	idx += 7;
2891	const QString dataStr = filename.mid(position: idx);
2892	QByteArray data = QByteArray::fromBase64(base64: dataStr.toLatin1());
2893	image = QImage::fromData(data);
2894	filenameType = LoadedFromData;
2895	}
2896	}
2897
2898	if (image.isNull()) {
2899	const auto *file = qobject_cast<QFile *>(object: handler->device());
2900	if (file) {
2901	QUrl url(filename);
2902	if (url.isRelative()) {
2903	QFileInfo info(file->fileName());
2904	filename = info.absoluteDir().absoluteFilePath(fileName: filename);
2905	}
2906	}
2907
2908	if (handler->trustedSourceMode() || !QImageReader::imageFormat(fileName: filename).startsWith(bv: "svg")) {
2909	image = QImage(filename);
2910	filenameType = LoadedFromFile;
2911	}
2912	}
2913
2914	if (image.isNull()) {
2915	qCWarning(lcSvgHandler) << "Could not create image from" << filename;
2916	return 0;
2917	}
2918
2919	if (image.format() == QImage::Format_ARGB32)
2920	image = image.convertToFormat(f: QImage::Format_ARGB32_Premultiplied);
2921
2922	QSvgNode *img = new QSvgImage(parent,
2923	image,
2924	filenameType == LoadedFromFile ? filename : QString{},
2925	QRectF(nx,
2926	ny,
2927	nwidth,
2928	nheight));
2929	return img;
2930	}
2931
2932	static QSvgNode *createLineNode(QSvgNode *parent,
2933	const QXmlStreamAttributes &attributes,
2934	QSvgHandler *)
2935	{
2936	const QStringView x1 = attributes.value(qualifiedName: QLatin1String("x1"));
2937	const QStringView y1 = attributes.value(qualifiedName: QLatin1String("y1"));
2938	const QStringView x2 = attributes.value(qualifiedName: QLatin1String("x2"));
2939	const QStringView y2 = attributes.value(qualifiedName: QLatin1String("y2"));
2940	qreal nx1 = toDouble(str: x1);
2941	qreal ny1 = toDouble(str: y1);
2942	qreal nx2 = toDouble(str: x2);
2943	qreal ny2 = toDouble(str: y2);
2944
2945	QLineF lineBounds(nx1, ny1, nx2, ny2);
2946	QSvgNode *line = new QSvgLine(parent, lineBounds);
2947	return line;
2948	}
2949
2950
2951	static void parseBaseGradient(QSvgNode *node,
2952	const QXmlStreamAttributes &attributes,
2953	QSvgGradientStyle *gradProp,
2954	QSvgHandler *handler)
2955	{
2956	QString link = attributes.value(qualifiedName: QLatin1String("xlink:href")).toString();
2957	QStringView trans = attributes.value(qualifiedName: QLatin1String("gradientTransform"));
2958	QString spread = attributes.value(qualifiedName: QLatin1String("spreadMethod")).toString();
2959	QString units = attributes.value(qualifiedName: QLatin1String("gradientUnits")).toString();
2960	QStringView colorStr = attributes.value(qualifiedName: QLatin1String("color"));
2961	QStringView colorOpacityStr = attributes.value(qualifiedName: QLatin1String("color-opacity"));
2962
2963	QColor color;
2964	if (constructColor(colorStr, opacity: colorOpacityStr, color, handler)) {
2965	handler->popColor();
2966	handler->pushColor(color);
2967	}
2968
2969	QTransform matrix;
2970	QGradient *grad = gradProp->qgradient();
2971	if (node && !link.isEmpty()) {
2972	QSvgStyleProperty *prop = node->styleProperty(id: link);
2973	//qDebug()<<"inherited "<<prop<<" ("<<link<<")";
2974	if (prop && prop->type() == QSvgStyleProperty::GRADIENT) {
2975	QSvgGradientStyle *inherited =
2976	static_cast<QSvgGradientStyle*>(prop);
2977	if (!inherited->stopLink().isEmpty()) {
2978	gradProp->setStopLink(link: inherited->stopLink(), doc: handler->document());
2979	} else {
2980	grad->setStops(inherited->qgradient()->stops());
2981	gradProp->setGradientStopsSet(inherited->gradientStopsSet());
2982	}
2983
2984	matrix = inherited->qtransform();
2985	} else {
2986	gradProp->setStopLink(link, doc: handler->document());
2987	}
2988	}
2989
2990	if (!trans.isEmpty()) {
2991	matrix = parseTransformationMatrix(value: trans);
2992	gradProp->setTransform(matrix);
2993	} else if (!matrix.isIdentity()) {
2994	gradProp->setTransform(matrix);
2995	}
2996
2997	if (!spread.isEmpty()) {
2998	if (spread == QLatin1String("pad")) {
2999	grad->setSpread(QGradient::PadSpread);
3000	} else if (spread == QLatin1String("reflect")) {
3001	grad->setSpread(QGradient::ReflectSpread);
3002	} else if (spread == QLatin1String("repeat")) {
3003	grad->setSpread(QGradient::RepeatSpread);
3004	}
3005	}
3006
3007	if (units.isEmpty() || units == QLatin1String("objectBoundingBox")) {
3008	grad->setCoordinateMode(QGradient::ObjectMode);
3009	}
3010	}
3011
3012	static QSvgStyleProperty *createLinearGradientNode(QSvgNode *node,
3013	const QXmlStreamAttributes &attributes,
3014	QSvgHandler *handler)
3015	{
3016	const QStringView x1 = attributes.value(qualifiedName: QLatin1String("x1"));
3017	const QStringView y1 = attributes.value(qualifiedName: QLatin1String("y1"));
3018	const QStringView x2 = attributes.value(qualifiedName: QLatin1String("x2"));
3019	const QStringView y2 = attributes.value(qualifiedName: QLatin1String("y2"));
3020
3021	qreal nx1 = 0.0;
3022	qreal ny1 = 0.0;
3023	qreal nx2 = 1.0;
3024	qreal ny2 = 0.0;
3025
3026	if (!x1.isEmpty())
3027	nx1 = convertToNumber(str: x1, handler);
3028	if (!y1.isEmpty())
3029	ny1 = convertToNumber(str: y1, handler);
3030	if (!x2.isEmpty())
3031	nx2 = convertToNumber(str: x2, handler);
3032	if (!y2.isEmpty())
3033	ny2 = convertToNumber(str: y2, handler);
3034
3035	QSvgNode *itr = node;
3036	while (itr && itr->type() != QSvgNode::Doc) {
3037	itr = itr->parent();
3038	}
3039
3040	QLinearGradient *grad = new QLinearGradient(nx1, ny1, nx2, ny2);
3041	grad->setInterpolationMode(QGradient::ComponentInterpolation);
3042	QSvgGradientStyle *prop = new QSvgGradientStyle(grad);
3043	parseBaseGradient(node, attributes, gradProp: prop, handler);
3044
3045	return prop;
3046	}
3047
3048	static bool parseMetadataNode(QSvgNode *parent,
3049	const QXmlStreamAttributes &attributes,
3050	QSvgHandler *)
3051	{
3052	Q_UNUSED(parent); Q_UNUSED(attributes);
3053	return true;
3054	}
3055
3056	static bool parseMissingGlyphNode(QSvgStyleProperty *parent,
3057	const QXmlStreamAttributes &attributes,
3058	QSvgHandler *)
3059	{
3060	if (parent->type() != QSvgStyleProperty::FONT) {
3061	return false;
3062	}
3063
3064	QSvgFontStyle *style = static_cast<QSvgFontStyle*>(parent);
3065	QSvgFont *font = style->svgFont();
3066	createSvgGlyph(font, attributes);
3067	return true;
3068	}
3069
3070	static bool parseMpathNode(QSvgNode *parent,
3071	const QXmlStreamAttributes &attributes,
3072	QSvgHandler *)
3073	{
3074	Q_UNUSED(parent); Q_UNUSED(attributes);
3075	return true;
3076	}
3077
3078	static bool parseMaskNode(QSvgNode *parent,
3079	const QXmlStreamAttributes &attributes,
3080	QSvgHandler *)
3081	{
3082	Q_UNUSED(parent); Q_UNUSED(attributes);
3083	return true;
3084	}
3085
3086	static bool parseMarkerNode(QSvgNode *,
3087	const QXmlStreamAttributes &,
3088	QSvgHandler *)
3089	{
3090	return true;
3091	}
3092
3093	static QSvgNode *createMaskNode(QSvgNode *parent,
3094	const QXmlStreamAttributes &attributes,
3095	QSvgHandler *handler)
3096	{
3097	const QStringView x = attributes.value(qualifiedName: QLatin1String("x"));
3098	const QStringView y = attributes.value(qualifiedName: QLatin1String("y"));
3099	const QStringView width = attributes.value(qualifiedName: QLatin1String("width"));
3100	const QStringView height = attributes.value(qualifiedName: QLatin1String("height"));
3101	const QStringView mU = attributes.value(qualifiedName: QLatin1String("maskUnits"));
3102	const QStringView mCU = attributes.value(qualifiedName: QLatin1String("maskContentUnits"));
3103
3104	QtSvg::UnitTypes nmU = mU.contains(s: QLatin1String("userSpaceOnUse")) ?
3105	QtSvg::UnitTypes::userSpaceOnUse : QtSvg::UnitTypes::objectBoundingBox;
3106
3107	QtSvg::UnitTypes nmCU = mCU.contains(s: QLatin1String("objectBoundingBox")) ?
3108	QtSvg::UnitTypes::objectBoundingBox : QtSvg::UnitTypes::userSpaceOnUse;
3109
3110	bool ok;
3111	QSvgHandler::LengthType type;
3112
3113	QtSvg::UnitTypes nmUx = nmU;
3114	QtSvg::UnitTypes nmUy = nmU;
3115	QtSvg::UnitTypes nmUw = nmU;
3116	QtSvg::UnitTypes nmUh = nmU;
3117	qreal nx = parseLength(str: x.toString(), type: &type, handler, ok: &ok);
3118	nx = convertToPixels(len: nx, true, type);
3119	if (x.isEmpty() || !ok) {
3120	nx = -0.1;
3121	nmUx = QtSvg::UnitTypes::objectBoundingBox;
3122	} else if (type == QSvgHandler::LT_PERCENT && nmU == QtSvg::UnitTypes::userSpaceOnUse) {
3123	nx = nx / 100. * parent->document()->viewBox().width();
3124	} else if (type == QSvgHandler::LT_PERCENT) {
3125	nx = nx / 100.;
3126	}
3127
3128	qreal ny = parseLength(str: y.toString(), type: &type, handler, ok: &ok);
3129	ny = convertToPixels(len: ny, true, type);
3130	if (y.isEmpty() || !ok) {
3131	ny = -0.1;
3132	nmUy = QtSvg::UnitTypes::objectBoundingBox;
3133	} else if (type == QSvgHandler::LT_PERCENT && nmU == QtSvg::UnitTypes::userSpaceOnUse) {
3134	ny = ny / 100. * parent->document()->viewBox().height();
3135	} else if (type == QSvgHandler::LT_PERCENT) {
3136	ny = ny / 100.;
3137	}
3138
3139	qreal nwidth = parseLength(str: width.toString(), type: &type, handler, ok: &ok);
3140	nwidth = convertToPixels(len: nwidth, true, type);
3141	if (width.isEmpty() || !ok) {
3142	nwidth = 1.2;
3143	nmUw = QtSvg::UnitTypes::objectBoundingBox;
3144	} else if (type == QSvgHandler::LT_PERCENT && nmU == QtSvg::UnitTypes::userSpaceOnUse) {
3145	nwidth = nwidth / 100. * parent->document()->viewBox().width();
3146	} else if (type == QSvgHandler::LT_PERCENT) {
3147	nwidth = nwidth / 100.;
3148	}
3149
3150	qreal nheight = parseLength(str: height.toString(), type: &type, handler, ok: &ok);
3151	nheight = convertToPixels(len: nheight, true, type);
3152	if (height.isEmpty() || !ok) {
3153	nheight = 1.2;
3154	nmUh = QtSvg::UnitTypes::objectBoundingBox;
3155	} else if (type == QSvgHandler::LT_PERCENT && nmU == QtSvg::UnitTypes::userSpaceOnUse) {
3156	nheight = nheight / 100. * parent->document()->viewBox().height();
3157	} else if (type == QSvgHandler::LT_PERCENT) {
3158	nheight = nheight / 100.;
3159	}
3160
3161	QRectF bounds(nx, ny, nwidth, nheight);
3162	if (bounds.isEmpty())
3163	return nullptr;
3164
3165	QSvgNode *mask = new QSvgMask(parent, QSvgRectF(bounds, nmUx, nmUy, nmUw, nmUh), nmCU);
3166
3167	return mask;
3168	}
3169
3170	static void parseFilterBounds(QSvgNode *, const QXmlStreamAttributes &attributes,
3171	QSvgHandler *handler, QSvgRectF *rect)
3172	{
3173	const QStringView xStr = attributes.value(qualifiedName: QLatin1String("x"));
3174	const QStringView yStr = attributes.value(qualifiedName: QLatin1String("y"));
3175	const QStringView widthStr = attributes.value(qualifiedName: QLatin1String("width"));
3176	const QStringView heightStr = attributes.value(qualifiedName: QLatin1String("height"));
3177
3178	qreal x = 0;
3179	if (!xStr.isEmpty()) {
3180	QSvgHandler::LengthType type;
3181	x = parseLength(str: xStr.toString(), type: &type, handler);
3182	if (type != QSvgHandler::LT_PT) {
3183	x = convertToPixels(len: x, true, type);
3184	rect->setUnitX(QtSvg::UnitTypes::userSpaceOnUse);
3185	}
3186	if (type == QSvgHandler::LT_PERCENT) {
3187	x /= 100.;
3188	rect->setUnitX(QtSvg::UnitTypes::objectBoundingBox);
3189	}
3190	rect->setX(x);
3191	}
3192	qreal y = 0;
3193	if (!yStr.isEmpty()) {
3194	QSvgHandler::LengthType type;
3195	y = parseLength(str: yStr.toString(), type: &type, handler);
3196	if (type != QSvgHandler::LT_PT) {
3197	y = convertToPixels(len: y, false, type);
3198	rect->setUnitY(QtSvg::UnitTypes::userSpaceOnUse);
3199	}
3200	if (type == QSvgHandler::LT_PERCENT) {
3201	y /= 100.;
3202	rect->setUnitX(QtSvg::UnitTypes::objectBoundingBox);
3203	}
3204	rect->setY(y);
3205	}
3206	qreal width = 0;
3207	if (!widthStr.isEmpty()) {
3208	QSvgHandler::LengthType type;
3209	width = parseLength(str: widthStr.toString(), type: &type, handler);
3210	if (type != QSvgHandler::LT_PT) {
3211	width = convertToPixels(len: width, true, type);
3212	rect->setUnitW(QtSvg::UnitTypes::userSpaceOnUse);
3213	}
3214	if (type == QSvgHandler::LT_PERCENT) {
3215	width /= 100.;
3216	rect->setUnitX(QtSvg::UnitTypes::objectBoundingBox);
3217	}
3218	rect->setWidth(width);
3219	}
3220	qreal height = 0;
3221	if (!heightStr.isEmpty()) {
3222	QSvgHandler::LengthType type;
3223	height = parseLength(str: heightStr.toString(), type: &type, handler);
3224	if (type != QSvgHandler::LT_PT) {
3225	height = convertToPixels(len: height, false, type);
3226	rect->setUnitH(QtSvg::UnitTypes::userSpaceOnUse);
3227	}
3228	if (type == QSvgHandler::LT_PERCENT) {
3229	height /= 100.;
3230	rect->setUnitX(QtSvg::UnitTypes::objectBoundingBox);
3231	}
3232	rect->setHeight(height);
3233	}
3234	}
3235
3236	static QSvgNode *createFilterNode(QSvgNode *parent,
3237	const QXmlStreamAttributes &attributes,
3238	QSvgHandler *handler)
3239	{
3240	QString fU = attributes.value(qualifiedName: QLatin1String("filterUnits")).toString();
3241	QString pU = attributes.value(qualifiedName: QLatin1String("primitiveUnits")).toString();
3242
3243	QtSvg::UnitTypes filterUnits = fU.contains(s: QLatin1String("userSpaceOnUse")) ?
3244	QtSvg::UnitTypes::userSpaceOnUse : QtSvg::UnitTypes::objectBoundingBox;
3245
3246	QtSvg::UnitTypes primitiveUnits = pU.contains(s: QLatin1String("objectBoundingBox")) ?
3247	QtSvg::UnitTypes::objectBoundingBox : QtSvg::UnitTypes::userSpaceOnUse;
3248
3249	// https://www.w3.org/TR/SVG11/filters.html#FilterEffectsRegion
3250	// If ‘x’ or ‘y’ is not specified, the effect is as if a value of -10% were specified.
3251	// If ‘width’ or ‘height’ is not specified, the effect is as if a value of 120% were specified.
3252	QSvgRectF rect;
3253	if (filterUnits == QtSvg::UnitTypes::userSpaceOnUse) {
3254	qreal width = parent->document()->viewBox().width();
3255	qreal height = parent->document()->viewBox().height();
3256	rect = QSvgRectF(QRectF(-0.1 * width, -0.1 * height, 1.2 * width, 1.2 * height),
3257	QtSvg::UnitTypes::userSpaceOnUse, QtSvg::UnitTypes::userSpaceOnUse,
3258	QtSvg::UnitTypes::userSpaceOnUse, QtSvg::UnitTypes::userSpaceOnUse);
3259	} else {
3260	rect = QSvgRectF(QRectF(-0.1, -0.1, 1.2, 1.2),
3261	QtSvg::UnitTypes::objectBoundingBox, QtSvg::UnitTypes::objectBoundingBox,
3262	QtSvg::UnitTypes::objectBoundingBox, QtSvg::UnitTypes::objectBoundingBox);
3263	}
3264
3265	parseFilterBounds(parent, attributes, handler, rect: &rect);
3266
3267	QSvgNode *filter = new QSvgFilterContainer(parent, rect, filterUnits, primitiveUnits);
3268	return filter;
3269	}
3270
3271	static void parseFilterAttributes(QSvgNode *parent, const QXmlStreamAttributes &attributes,
3272	QSvgHandler *handler, QString *inString, QString *outString,
3273	QSvgRectF *rect)
3274	{
3275	*inString = attributes.value(qualifiedName: QLatin1String("in")).toString();
3276	*outString = attributes.value(qualifiedName: QLatin1String("result")).toString();
3277
3278	// https://www.w3.org/TR/SVG11/filters.html#FilterPrimitiveSubRegion
3279	// the default subregion is 0%,0%,100%,100%, where as a special-case the percentages are
3280	// relative to the dimensions of the filter region, thus making the the default filter primitive
3281	// subregion equal to the filter region.
3282	*rect = QSvgRectF(QRectF(0, 0, 1.0, 1.0),
3283	QtSvg::UnitTypes::unknown, QtSvg::UnitTypes::unknown,
3284	QtSvg::UnitTypes::unknown, QtSvg::UnitTypes::unknown);
3285	// if we recognize unit == unknown we use the filter as a reference instead of the item, see
3286	// QSvgFeFilterPrimitive::localSubRegion
3287
3288	parseFilterBounds(parent, attributes, handler, rect);
3289	}
3290
3291	static QSvgNode *createFeColorMatrixNode(QSvgNode *parent,
3292	const QXmlStreamAttributes &attributes,
3293	QSvgHandler *handler)
3294	{
3295	const QString typeString = attributes.value(qualifiedName: QLatin1String("type")).toString();
3296	QString valuesString = attributes.value(qualifiedName: QLatin1String("values")).toString();
3297
3298	QString inputString;
3299	QString outputString;
3300	QSvgRectF rect;
3301
3302	QSvgFeColorMatrix::ColorShiftType type;
3303	QSvgFeColorMatrix::Matrix values;
3304	values.fill(value: 0);
3305
3306	parseFilterAttributes(parent, attributes, handler,
3307	inString: &inputString, outString: &outputString, rect: &rect);
3308
3309	if (typeString.startsWith(s: QLatin1String("saturate")))
3310	type = QSvgFeColorMatrix::ColorShiftType::Saturate;
3311	else if (typeString.startsWith(s: QLatin1String("hueRotate")))
3312	type = QSvgFeColorMatrix::ColorShiftType::HueRotate;
3313	else if (typeString.startsWith(s: QLatin1String("luminanceToAlpha")))
3314	type = QSvgFeColorMatrix::ColorShiftType::LuminanceToAlpha;
3315	else
3316	type = QSvgFeColorMatrix::ColorShiftType::Matrix;
3317
3318	if (!valuesString.isEmpty()) {
3319	static QRegularExpression delimiterRE(QLatin1String("[,\\s]"));
3320	const QStringList valueStringList = valuesString.split(sep: delimiterRE, behavior: Qt::SkipEmptyParts);
3321
3322	for (int i = 0, j = 0; i < qMin(a: 20, b: valueStringList.size()); i++) {
3323	bool ok;
3324	qreal v = toDouble(str: valueStringList.at(i), ok: &ok);
3325	if (ok) {
3326	values.data()[j] = v;
3327	j++;
3328	}
3329	}
3330	} else {
3331	values.setToIdentity();
3332	}
3333
3334	QSvgNode *filter = new QSvgFeColorMatrix(parent, inputString, outputString, rect,
3335	type, values);
3336	return filter;
3337	}
3338
3339	static QSvgNode *createFeGaussianBlurNode(QSvgNode *parent,
3340	const QXmlStreamAttributes &attributes,
3341	QSvgHandler *handler)
3342	{
3343	const QString edgeModeString = attributes.value(qualifiedName: QLatin1String("edgeMode")).toString();
3344	QString stdDeviationString = attributes.value(qualifiedName: QLatin1String("stdDeviation")).toString();
3345
3346	QString inputString;
3347	QString outputString;
3348	QSvgRectF rect;
3349
3350	QSvgFeGaussianBlur::EdgeMode edgemode = QSvgFeGaussianBlur::EdgeMode::Duplicate;
3351
3352	parseFilterAttributes(parent, attributes, handler,
3353	inString: &inputString, outString: &outputString, rect: &rect);
3354	qreal stdDeviationX = 0;
3355	qreal stdDeviationY = 0;
3356	if (stdDeviationString.contains(QStringLiteral(" "))){
3357	stdDeviationX = qMax(a: 0., b: toDouble(str: stdDeviationString.split(QStringLiteral(" ")).first()));
3358	stdDeviationY = qMax(a: 0., b: toDouble(str: stdDeviationString.split(QStringLiteral(" ")).last()));
3359	} else {
3360	stdDeviationY = stdDeviationX = qMax(a: 0., b: toDouble(str: stdDeviationString));
3361	}
3362
3363	if (edgeModeString.startsWith(s: QLatin1String("wrap")))
3364	edgemode = QSvgFeGaussianBlur::EdgeMode::Wrap;
3365	else if (edgeModeString.startsWith(s: QLatin1String("none")))
3366	edgemode = QSvgFeGaussianBlur::EdgeMode::None;
3367
3368	QSvgNode *filter = new QSvgFeGaussianBlur(parent, inputString, outputString, rect,
3369	stdDeviationX, stdDeviationY, edgemode);
3370	return filter;
3371	}
3372
3373	static QSvgNode *createFeOffsetNode(QSvgNode *parent,
3374	const QXmlStreamAttributes &attributes,
3375	QSvgHandler *handler)
3376	{
3377	QStringView dxString = attributes.value(qualifiedName: QLatin1String("dx"));
3378	QStringView dyString = attributes.value(qualifiedName: QLatin1String("dy"));
3379
3380	QString inputString;
3381	QString outputString;
3382	QSvgRectF rect;
3383
3384	parseFilterAttributes(parent, attributes, handler,
3385	inString: &inputString, outString: &outputString, rect: &rect);
3386
3387	qreal dx = 0;
3388	if (!dxString.isEmpty()) {
3389	QSvgHandler::LengthType type;
3390	dx = parseLength(str: dxString.toString(), type: &type, handler);
3391	if (type != QSvgHandler::LT_PT)
3392	dx = convertToPixels(len: dx, true, type);
3393	}
3394
3395	qreal dy = 0;
3396	if (!dyString.isEmpty()) {
3397	QSvgHandler::LengthType type;
3398	dy = parseLength(str: dyString.toString(), type: &type, handler);
3399	if (type != QSvgHandler::LT_PT)
3400	dy = convertToPixels(len: dy, true, type);
3401	}
3402
3403	QSvgNode *filter = new QSvgFeOffset(parent, inputString, outputString, rect,
3404	dx, dy);
3405	return filter;
3406	}
3407
3408	static QSvgNode *createFeCompositeNode(QSvgNode *parent,
3409	const QXmlStreamAttributes &attributes,
3410	QSvgHandler *handler)
3411	{
3412	QString in2String = attributes.value(qualifiedName: QLatin1String("in2")).toString();
3413	QString operatorString = attributes.value(qualifiedName: QLatin1String("operator")).toString();
3414	QString k1String = attributes.value(qualifiedName: QLatin1String("k1")).toString();
3415	QString k2String = attributes.value(qualifiedName: QLatin1String("k2")).toString();
3416	QString k3String = attributes.value(qualifiedName: QLatin1String("k3")).toString();
3417	QString k4String = attributes.value(qualifiedName: QLatin1String("k4")).toString();
3418
3419	QString inputString;
3420	QString outputString;
3421	QSvgRectF rect;
3422
3423	parseFilterAttributes(parent, attributes, handler,
3424	inString: &inputString, outString: &outputString, rect: &rect);
3425
3426	QSvgFeComposite::Operator op = QSvgFeComposite::Operator::Over;
3427	if (operatorString.startsWith(QStringLiteral("in")))
3428	op = QSvgFeComposite::Operator::In;
3429	else if (operatorString.startsWith(QStringLiteral("out")))
3430	op = QSvgFeComposite::Operator::Out;
3431	else if (operatorString.startsWith(QStringLiteral("atop")))
3432	op = QSvgFeComposite::Operator::Atop;
3433	else if (operatorString.startsWith(QStringLiteral("xor")))
3434	op = QSvgFeComposite::Operator::Xor;
3435	else if (operatorString.startsWith(QStringLiteral("lighter")))
3436	op = QSvgFeComposite::Operator::Lighter;
3437	else if (operatorString.startsWith(QStringLiteral("arithmetic")))
3438	op = QSvgFeComposite::Operator::Arithmetic;
3439
3440	QVector4D k(0, 0, 0, 0);
3441
3442	if (op == QSvgFeComposite::Operator::Arithmetic) {
3443	bool ok;
3444	qreal v = toDouble(str: k1String, ok: &ok);
3445	if (ok)
3446	k.setX(v);
3447	v = toDouble(str: k2String, ok: &ok);
3448	if (ok)
3449	k.setY(v);
3450	v = toDouble(str: k3String, ok: &ok);
3451	if (ok)
3452	k.setZ(v);
3453	v = toDouble(str: k4String, ok: &ok);
3454	if (ok)
3455	k.setW(v);
3456	}
3457
3458	QSvgNode *filter = new QSvgFeComposite(parent, inputString, outputString, rect,
3459	in2String, op, k);
3460	return filter;
3461	}
3462
3463
3464	static QSvgNode *createFeMergeNode(QSvgNode *parent,
3465	const QXmlStreamAttributes &attributes,
3466	QSvgHandler *handler)
3467	{
3468	QString inputString;
3469	QString outputString;
3470	QSvgRectF rect;
3471
3472	parseFilterAttributes(parent, attributes, handler,
3473	inString: &inputString, outString: &outputString, rect: &rect);
3474
3475	QSvgNode *filter = new QSvgFeMerge(parent, inputString, outputString, rect);
3476	return filter;
3477	}
3478
3479	static QSvgNode *createFeFloodNode(QSvgNode *parent,
3480	const QXmlStreamAttributes &attributes,
3481	QSvgHandler *handler)
3482	{
3483	QStringView colorStr = attributes.value(qualifiedName: QLatin1String("flood-color"));
3484	const QStringView opacityStr = attributes.value(qualifiedName: QLatin1String("flood-opacity"));
3485
3486	QColor color;
3487	if (!constructColor(colorStr, opacity: opacityStr, color, handler)) {
3488	color = QColor(Qt::black);
3489	bool ok;
3490	qreal op = qMin(a: qreal(1.0), b: qMax(a: qreal(0.0), b: toDouble(str: opacityStr, ok: &ok)));
3491	if (ok)
3492	color.setAlphaF(op);
3493	}
3494
3495	QString inputString;
3496	QString outputString;
3497	QSvgRectF rect;
3498
3499	parseFilterAttributes(parent, attributes, handler,
3500	inString: &inputString, outString: &outputString, rect: &rect);
3501
3502	QSvgNode *filter = new QSvgFeFlood(parent, inputString, outputString, rect, color);
3503	return filter;
3504	}
3505
3506	static QSvgNode *createFeMergeNodeNode(QSvgNode *parent,
3507	const QXmlStreamAttributes &attributes,
3508	QSvgHandler *handler)
3509	{
3510	QString inputString;
3511	QString outputString;
3512	QSvgRectF rect;
3513
3514	parseFilterAttributes(parent, attributes, handler,
3515	inString: &inputString, outString: &outputString, rect: &rect);
3516
3517	QSvgNode *filter = new QSvgFeMergeNode(parent, inputString, outputString, rect);
3518	return filter;
3519	}
3520
3521	static QSvgNode *createFeUnsupportedNode(QSvgNode *parent,
3522	const QXmlStreamAttributes &attributes,
3523	QSvgHandler *handler)
3524	{
3525	QString inputString;
3526	QString outputString;
3527	QSvgRectF rect;
3528
3529	parseFilterAttributes(parent, attributes, handler,
3530	inString: &inputString, outString: &outputString, rect: &rect);
3531
3532	QSvgNode *filter = new QSvgFeUnsupported(parent, inputString, outputString, rect);
3533	return filter;
3534	}
3535
3536	static bool parseSymbolLikeAttributes(const QXmlStreamAttributes &attributes, QSvgHandler *handler,
3537	QRectF *rect, QRectF *viewBox, QPointF *refPoint,
3538	QSvgSymbolLike::PreserveAspectRatios *aspect,
3539	QSvgSymbolLike::Overflow *overflow,
3540	bool marker = false)
3541	{
3542	const QStringView xStr = attributes.value(qualifiedName: QLatin1String("x"));
3543	const QStringView yStr = attributes.value(qualifiedName: QLatin1String("y"));
3544	const QStringView refXStr = attributes.value(qualifiedName: QLatin1String("refX"));
3545	const QStringView refYStr = attributes.value(qualifiedName: QLatin1String("refY"));
3546	const QStringView widthStr = attributes.value(qualifiedName: QLatin1String(marker ? "markerWidth":"width"));
3547	const QStringView heightStr = attributes.value(qualifiedName: QLatin1String(marker ? "markerHeight":"height"));
3548	const QString pAspectRStr = attributes.value(qualifiedName: QLatin1String("preserveAspectRatio")).toString();
3549	const QStringView overflowStr = attributes.value(qualifiedName: QLatin1String("overflow"));
3550
3551	QString viewBoxStr = attributes.value(qualifiedName: QLatin1String("viewBox")).toString();
3552
3553
3554	qreal x = 0;
3555	if (!xStr.isEmpty()) {
3556	QSvgHandler::LengthType type;
3557	x = parseLength(str: xStr.toString(), type: &type, handler);
3558	if (type != QSvgHandler::LT_PT)
3559	x = convertToPixels(len: x, true, type);
3560	}
3561	qreal y = 0;
3562	if (!yStr.isEmpty()) {
3563	QSvgHandler::LengthType type;
3564	y = parseLength(str: yStr.toString(), type: &type, handler);
3565	if (type != QSvgHandler::LT_PT)
3566	y = convertToPixels(len: y, false, type);
3567	}
3568	qreal width = 0;
3569	if (!widthStr.isEmpty()) {
3570	QSvgHandler::LengthType type;
3571	width = parseLength(str: widthStr.toString(), type: &type, handler);
3572	if (type != QSvgHandler::LT_PT)
3573	width = convertToPixels(len: width, true, type);
3574	}
3575	qreal height = 0;
3576	if (!heightStr.isEmpty()) {
3577	QSvgHandler::LengthType type;
3578	height = parseLength(str: heightStr.toString(), type: &type, handler);
3579	if (type != QSvgHandler::LT_PT)
3580	height = convertToPixels(len: height, false, type);
3581	}
3582
3583	*rect = QRectF(x, y, width, height);
3584
3585	x = 0;
3586	if (!refXStr.isEmpty()) {
3587	QSvgHandler::LengthType type;
3588	x = parseLength(str: refXStr.toString(), type: &type, handler);
3589	if (type != QSvgHandler::LT_PT)
3590	x = convertToPixels(len: x, true, type);
3591	}
3592	y = 0;
3593	if (!refYStr.isEmpty()) {
3594	QSvgHandler::LengthType type;
3595	y = parseLength(str: refYStr.toString(), type: &type, handler);
3596	if (type != QSvgHandler::LT_PT)
3597	y = convertToPixels(len: y, false, type);
3598	}
3599	*refPoint = QPointF(x,y);
3600
3601	QStringList viewBoxValues;
3602	if (!viewBoxStr.isEmpty()) {
3603	viewBoxStr = viewBoxStr.replace(before: QLatin1Char(' '), after: QLatin1Char(','));
3604	viewBoxStr = viewBoxStr.replace(before: QLatin1Char('\r'), after: QLatin1Char(','));
3605	viewBoxStr = viewBoxStr.replace(before: QLatin1Char('\n'), after: QLatin1Char(','));
3606	viewBoxStr = viewBoxStr.replace(before: QLatin1Char('\t'), after: QLatin1Char(','));
3607	viewBoxValues = viewBoxStr.split(sep: QLatin1Char(','), behavior: Qt::SkipEmptyParts);
3608	}
3609	if (viewBoxValues.size() == 4) {
3610	QString xStr = viewBoxValues.at(i: 0).trimmed();
3611	QString yStr = viewBoxValues.at(i: 1).trimmed();
3612	QString widthStr = viewBoxValues.at(i: 2).trimmed();
3613	QString heightStr = viewBoxValues.at(i: 3).trimmed();
3614
3615	QSvgHandler::LengthType lt;
3616	qreal x = parseLength(str: xStr, type: &lt, handler);
3617	qreal y = parseLength(str: yStr, type: &lt, handler);
3618	qreal w = parseLength(str: widthStr, type: &lt, handler);
3619	qreal h = parseLength(str: heightStr, type: &lt, handler);
3620
3621	*viewBox = QRectF(x, y, w, h);
3622
3623	} else if (width > 0 && height > 0) {
3624	*viewBox = QRectF(0, 0, width, height);
3625	} else {
3626	*viewBox = handler->document()->viewBox();
3627	}
3628
3629	if (viewBox->isNull())
3630	return false;
3631
3632	QStringList pAspectRStrs = pAspectRStr.split(sep: QLatin1String(" "));
3633	QSvgSymbolLike::PreserveAspectRatio aspectX = QSvgSymbolLike::PreserveAspectRatio::xMid;
3634	QSvgSymbolLike::PreserveAspectRatio aspectY = QSvgSymbolLike::PreserveAspectRatio::yMid;
3635	QSvgSymbolLike::PreserveAspectRatio aspectMS = QSvgSymbolLike::PreserveAspectRatio::meet;
3636
3637	for (auto &pAStr : std::as_const(t&: pAspectRStrs)) {
3638	if (pAStr.startsWith(s: QLatin1String("none"))) {
3639	aspectX = QSvgSymbolLike::PreserveAspectRatio::None;
3640	aspectY = QSvgSymbolLike::PreserveAspectRatio::None;
3641	}else {
3642	if (pAStr.startsWith(s: QLatin1String("xMin")))
3643	aspectX = QSvgSymbolLike::PreserveAspectRatio::xMin;
3644	else if (pAStr.startsWith(s: QLatin1String("xMax")))
3645	aspectX = QSvgSymbolLike::PreserveAspectRatio::xMax;
3646	if (pAStr.endsWith(s: QLatin1String("YMin")))
3647	aspectY = QSvgSymbolLike::PreserveAspectRatio::yMin;
3648	else if (pAStr.endsWith(s: QLatin1String("YMax")))
3649	aspectY = QSvgSymbolLike::PreserveAspectRatio::yMax;
3650	}
3651
3652	if (pAStr.endsWith(s: QLatin1String("slice")))
3653	aspectMS = QSvgSymbolLike::PreserveAspectRatio::slice;
3654	}
3655	*aspect = aspectX | aspectY | aspectMS;
3656
3657	// overflow is not limited to the symbol element but it is often found with the symbol element.
3658	// the symbol element makes little sense without the overflow attribute so it is added here.
3659	// if we decide to remove this from QSvgSymbol, the default value should be set to visible.
3660
3661	// The default value is visible but chrome uses default value hidden.
3662	*overflow = QSvgSymbolLike::Overflow::Hidden;
3663
3664	if (overflowStr.endsWith(s: QLatin1String("auto")))
3665	*overflow = QSvgSymbolLike::Overflow::Auto;
3666	else if (overflowStr.endsWith(s: QLatin1String("visible")))
3667	*overflow = QSvgSymbolLike::Overflow::Visible;
3668	else if (overflowStr.endsWith(s: QLatin1String("hidden")))
3669	*overflow = QSvgSymbolLike::Overflow::Hidden;
3670	else if (overflowStr.endsWith(s: QLatin1String("scroll")))
3671	*overflow = QSvgSymbolLike::Overflow::Scroll;
3672
3673	return true;
3674	}
3675
3676	static QSvgNode *createSymbolNode(QSvgNode *parent,
3677	const QXmlStreamAttributes &attributes,
3678	QSvgHandler *handler)
3679	{
3680	QRectF rect, viewBox;
3681	QPointF refP;
3682	QSvgSymbolLike::PreserveAspectRatios aspect;
3683	QSvgSymbolLike::Overflow overflow;
3684
3685	if (!parseSymbolLikeAttributes(attributes, handler, rect: &rect, viewBox: &viewBox, refPoint: &refP, aspect: &aspect, overflow: &overflow))
3686	return nullptr;
3687
3688	refP = QPointF(0, 0); //refX, refY is ignored in Symbol in Firefox and Chrome.
3689	QSvgNode *symbol = new QSvgSymbol(parent, rect, viewBox, refP, aspect, overflow);
3690	return symbol;
3691	}
3692
3693	static QSvgNode *createMarkerNode(QSvgNode *parent,
3694	const QXmlStreamAttributes &attributes,
3695	QSvgHandler *handler)
3696	{
3697	QRectF rect, viewBox;
3698	QPointF refP;
3699	QSvgSymbolLike::PreserveAspectRatios aspect;
3700	QSvgSymbolLike::Overflow overflow;
3701
3702	const QString orientStr = attributes.value(qualifiedName: QLatin1String("orient")).toString();
3703	const QString markerUnitsStr = attributes.value(qualifiedName: QLatin1String("markerUnits")).toString();
3704
3705	qreal orientationAngle = 0;
3706	QSvgMarker::Orientation orientation;
3707	if (orientStr.startsWith(s: QLatin1String("auto-start-reverse")))
3708	orientation = QSvgMarker::Orientation::AutoStartReverse;
3709	else if (orientStr.startsWith(s: QLatin1String("auto")))
3710	orientation = QSvgMarker::Orientation::Auto;
3711	else {
3712	orientation = QSvgMarker::Orientation::Value;
3713	bool ok;
3714	qreal a;
3715	if (orientStr.endsWith(QStringLiteral("turn")))
3716	a = 360. * toDouble(str: orientStr.mid(position: 0, n: orientStr.length()-4), ok: &ok);
3717	else if (orientStr.endsWith(QStringLiteral("grad")))
3718	a = toDouble(str: orientStr.mid(position: 0, n: orientStr.length()-4), ok: &ok);
3719	else if (orientStr.endsWith(QStringLiteral("rad")))
3720	a = 180. / M_PI * toDouble(str: orientStr.mid(position: 0, n: orientStr.length()-3), ok: &ok);
3721	else
3722	a = toDouble(str: orientStr, ok: &ok);
3723	if (ok)
3724	orientationAngle = a;
3725	}
3726
3727	QSvgMarker::MarkerUnits markerUnits = QSvgMarker::MarkerUnits::StrokeWidth;
3728	if (markerUnitsStr.startsWith(s: QLatin1String("userSpaceOnUse")))
3729	markerUnits = QSvgMarker::MarkerUnits::UserSpaceOnUse;
3730
3731	if (!parseSymbolLikeAttributes(attributes, handler, rect: &rect, viewBox: &viewBox, refPoint: &refP, aspect: &aspect, overflow: &overflow, marker: true))
3732	return nullptr;
3733
3734	QSvgNode *marker = new QSvgMarker(parent, rect, viewBox, refP, aspect, overflow,
3735	orientation, orientationAngle, markerUnits);
3736	return marker;
3737	}
3738
3739	static QSvgNode *createPathNode(QSvgNode *parent,
3740	const QXmlStreamAttributes &attributes,
3741	QSvgHandler *handler)
3742	{
3743	QStringView data = attributes.value(qualifiedName: QLatin1String("d"));
3744
3745	QPainterPath qpath;
3746	qpath.setFillRule(Qt::WindingFill);
3747	if (!parsePathDataFast(dataStr: data, path&: qpath, limitLength: !handler->trustedSourceMode()))
3748	qCWarning(lcSvgHandler, "Invalid path data; path truncated.");
3749
3750	QSvgNode *path = new QSvgPath(parent, qpath);
3751	return path;
3752	}
3753
3754	static QSvgNode *createPolygonNode(QSvgNode *parent,
3755	const QXmlStreamAttributes &attributes,
3756	QSvgHandler *)
3757	{
3758	QString pointsStr = attributes.value(qualifiedName: QLatin1String("points")).toString();
3759
3760	//same QPolygon parsing is in createPolylineNode
3761	const QChar *s = pointsStr.constData();
3762	QList<qreal> points = parseNumbersList(str&: s);
3763	QPolygonF poly(points.size()/2);
3764	for (int i = 0; i < poly.size(); ++i)
3765	poly[i] = QPointF(points.at(i: 2 * i), points.at(i: 2 * i + 1));
3766	QSvgNode *polygon = new QSvgPolygon(parent, poly);
3767	return polygon;
3768	}
3769
3770	static QSvgNode *createPolylineNode(QSvgNode *parent,
3771	const QXmlStreamAttributes &attributes,
3772	QSvgHandler *)
3773	{
3774	QString pointsStr = attributes.value(qualifiedName: QLatin1String("points")).toString();
3775
3776	//same QPolygon parsing is in createPolygonNode
3777	const QChar *s = pointsStr.constData();
3778	QList<qreal> points = parseNumbersList(str&: s);
3779	QPolygonF poly(points.size()/2);
3780	for (int i = 0; i < poly.size(); ++i)
3781	poly[i] = QPointF(points.at(i: 2 * i), points.at(i: 2 * i + 1));
3782
3783	QSvgNode *line = new QSvgPolyline(parent, poly);
3784	return line;
3785	}
3786
3787	static bool parsePrefetchNode(QSvgNode *parent,
3788	const QXmlStreamAttributes &attributes,
3789	QSvgHandler *)
3790	{
3791	Q_UNUSED(parent); Q_UNUSED(attributes);
3792	return true;
3793	}
3794
3795	static QSvgStyleProperty *createRadialGradientNode(QSvgNode *node,
3796	const QXmlStreamAttributes &attributes,
3797	QSvgHandler *handler)
3798	{
3799	const QStringView cx = attributes.value(qualifiedName: QLatin1String("cx"));
3800	const QStringView cy = attributes.value(qualifiedName: QLatin1String("cy"));
3801	const QStringView r = attributes.value(qualifiedName: QLatin1String("r"));
3802	const QStringView fx = attributes.value(qualifiedName: QLatin1String("fx"));
3803	const QStringView fy = attributes.value(qualifiedName: QLatin1String("fy"));
3804
3805	qreal ncx = 0.5;
3806	qreal ncy = 0.5;
3807	if (!cx.isEmpty())
3808	ncx = toDouble(str: cx);
3809	if (!cy.isEmpty())
3810	ncy = toDouble(str: cy);
3811
3812	qreal nr = 0.5;
3813	if (!r.isEmpty())
3814	nr = toDouble(str: r);
3815	if (nr <= 0.0)
3816	return nullptr;
3817
3818	qreal nfx = ncx;
3819	if (!fx.isEmpty())
3820	nfx = toDouble(str: fx);
3821	qreal nfy = ncy;
3822	if (!fy.isEmpty())
3823	nfy = toDouble(str: fy);
3824
3825	QRadialGradient *grad = new QRadialGradient(ncx, ncy, nr, nfx, nfy, 0);
3826	grad->setInterpolationMode(QGradient::ComponentInterpolation);
3827
3828	QSvgGradientStyle *prop = new QSvgGradientStyle(grad);
3829	parseBaseGradient(node, attributes, gradProp: prop, handler);
3830
3831	return prop;
3832	}
3833
3834	static QSvgNode *createRectNode(QSvgNode *parent,
3835	const QXmlStreamAttributes &attributes,
3836	QSvgHandler *handler)
3837	{
3838	const QStringView x = attributes.value(qualifiedName: QLatin1String("x"));
3839	const QStringView y = attributes.value(qualifiedName: QLatin1String("y"));
3840	const QStringView width = attributes.value(qualifiedName: QLatin1String("width"));
3841	const QStringView height = attributes.value(qualifiedName: QLatin1String("height"));
3842	const QStringView rx = attributes.value(qualifiedName: QLatin1String("rx"));
3843	const QStringView ry = attributes.value(qualifiedName: QLatin1String("ry"));
3844
3845	bool ok = true;
3846	QSvgHandler::LengthType type;
3847	qreal nwidth = parseLength(str: width.toString(), type: &type, handler, ok: &ok);
3848	if (!ok)
3849	return nullptr;
3850	nwidth = convertToPixels(len: nwidth, true, type);
3851	qreal nheight = parseLength(str: height.toString(), type: &type, handler, ok: &ok);
3852	if (!ok)
3853	return nullptr;
3854	nheight = convertToPixels(len: nheight, true, type);
3855	qreal nrx = toDouble(str: rx);
3856	qreal nry = toDouble(str: ry);
3857
3858	QRectF bounds(toDouble(str: x), toDouble(str: y), nwidth, nheight);
3859	if (bounds.isEmpty())
3860	return nullptr;
3861
3862	if (!rx.isEmpty() && ry.isEmpty())
3863	nry = nrx;
3864	else if (!ry.isEmpty() && rx.isEmpty())
3865	nrx = nry;
3866
3867	//9.2 The 'rect' element clearly specifies it
3868	// but the case might in fact be handled because
3869	// we draw rounded rectangles differently
3870	if (nrx > bounds.width()/2)
3871	nrx = bounds.width()/2;
3872	if (nry > bounds.height()/2)
3873	nry = bounds.height()/2;
3874
3875	//we draw rounded rect from 0...99
3876	//svg from 0...bounds.width()/2 so we're adjusting the
3877	//coordinates
3878	nrx *= (100/(bounds.width()/2));
3879	nry *= (100/(bounds.height()/2));
3880
3881	QSvgNode *rect = new QSvgRect(parent, bounds, nrx, nry);
3882	return rect;
3883	}
3884
3885	static bool parseScriptNode(QSvgNode *parent,
3886	const QXmlStreamAttributes &attributes,
3887	QSvgHandler *)
3888	{
3889	Q_UNUSED(parent); Q_UNUSED(attributes);
3890	return true;
3891	}
3892
3893	static bool parseSetNode(QSvgNode *parent,
3894	const QXmlStreamAttributes &attributes,
3895	QSvgHandler *)
3896	{
3897	Q_UNUSED(parent); Q_UNUSED(attributes);
3898	return true;
3899	}
3900
3901	static QSvgStyleProperty *createSolidColorNode(QSvgNode *parent,
3902	const QXmlStreamAttributes &attributes,
3903	QSvgHandler *handler)
3904	{
3905	Q_UNUSED(parent); Q_UNUSED(attributes);
3906	QStringView solidColorStr = attributes.value(qualifiedName: QLatin1String("solid-color"));
3907	QStringView solidOpacityStr = attributes.value(qualifiedName: QLatin1String("solid-opacity"));
3908
3909	if (solidOpacityStr.isEmpty())
3910	solidOpacityStr = attributes.value(qualifiedName: QLatin1String("opacity"));
3911
3912	QColor color;
3913	if (!constructColor(colorStr: solidColorStr, opacity: solidOpacityStr, color, handler))
3914	return 0;
3915	QSvgSolidColorStyle *style = new QSvgSolidColorStyle(color);
3916	return style;
3917	}
3918
3919	static bool parseStopNode(QSvgStyleProperty *parent,
3920	const QXmlStreamAttributes &attributes,
3921	QSvgHandler *handler)
3922	{
3923	if (parent->type() != QSvgStyleProperty::GRADIENT)
3924	return false;
3925	QString nodeIdStr = someId(attributes);
3926	QString xmlClassStr = attributes.value(qualifiedName: QLatin1String("class")).toString();
3927
3928	//### nasty hack because stop gradients are not in the rendering tree
3929	// we force a dummy node with the same id and class into a rendering
3930	// tree to figure out whether the selector has a style for it
3931	// QSvgStyleSelector should be coded in a way that could avoid it
3932	QSvgAnimation anim;
3933	anim.setNodeId(nodeIdStr);
3934	anim.setXmlClass(xmlClassStr);
3935
3936	QXmlStreamAttributes xmlAttr = attributes;
3937
3938	#ifndef QT_NO_CSSPARSER
3939	cssStyleLookup(node: &anim, handler, selector: handler->selector(), attributes&: xmlAttr);
3940	#endif
3941	parseStyle(node: &anim, attrs: xmlAttr, handler);
3942
3943	QSvgAttributes attrs(xmlAttr, handler);
3944
3945	QSvgGradientStyle *style =
3946	static_cast<QSvgGradientStyle*>(parent);
3947	QStringView colorStr = attrs.stopColor;
3948	QColor color;
3949
3950	bool ok = true;
3951	qreal offset = convertToNumber(str: attrs.offset, handler, ok: &ok);
3952	if (!ok)
3953	offset = 0.0;
3954	QString black = QString::fromLatin1(ba: "#000000");
3955	if (colorStr.isEmpty()) {
3956	colorStr = black;
3957	}
3958
3959	constructColor(colorStr, opacity: attrs.stopOpacity, color, handler);
3960
3961	QGradient *grad = style->qgradient();
3962
3963	offset = qMin(a: qreal(1), b: qMax(a: qreal(0), b: offset)); // Clamp to range [0, 1]
3964	QGradientStops stops;
3965	if (style->gradientStopsSet()) {
3966	stops = grad->stops();
3967	// If the stop offset equals the one previously added, add an epsilon to make it greater.
3968	if (offset <= stops.back().first)
3969	offset = stops.back().first + FLT_EPSILON;
3970	}
3971
3972	// If offset is greater than one, it must be clamped to one.
3973	if (offset > 1.0) {
3974	if ((stops.size() == 1) || (stops.at(i: stops.size() - 2).first < 1.0 - FLT_EPSILON)) {
3975	stops.back().first = 1.0 - FLT_EPSILON;
3976	grad->setStops(stops);
3977	}
3978	offset = 1.0;
3979	}
3980
3981	grad->setColorAt(pos: offset, color);
3982	style->setGradientStopsSet(true);
3983	return true;
3984	}
3985
3986	static bool parseStyleNode(QSvgNode *parent,
3987	const QXmlStreamAttributes &attributes,
3988	QSvgHandler *handler)
3989	{
3990	Q_UNUSED(parent);
3991	#ifdef QT_NO_CSSPARSER
3992	Q_UNUSED(attributes);
3993	Q_UNUSED(handler);
3994	#else
3995	const QStringView type = attributes.value(qualifiedName: QLatin1String("type"));
3996	if (type.compare(s: QLatin1String("text/css"), cs: Qt::CaseInsensitive) == 0 || type.isNull())
3997	handler->setInStyle(true);
3998	#endif
3999
4000	return true;
4001	}
4002
4003	static QSvgNode *createSvgNode(QSvgNode *parent,
4004	const QXmlStreamAttributes &attributes,
4005	QSvgHandler *handler)
4006	{
4007	Q_UNUSED(parent); Q_UNUSED(attributes);
4008
4009	QSvgTinyDocument *node = new QSvgTinyDocument(handler->options());
4010	const QStringView widthStr = attributes.value(qualifiedName: QLatin1String("width"));
4011	const QStringView heightStr = attributes.value(qualifiedName: QLatin1String("height"));
4012	QString viewBoxStr = attributes.value(qualifiedName: QLatin1String("viewBox")).toString();
4013
4014	QSvgHandler::LengthType type = QSvgHandler::LT_PX; // FIXME: is the default correct?
4015	qreal width = 0;
4016	if (!widthStr.isEmpty()) {
4017	width = parseLength(str: widthStr.toString(), type: &type, handler);
4018	if (type != QSvgHandler::LT_PT)
4019	width = convertToPixels(len: width, true, type);
4020	node->setWidth(len: int(width), percent: type == QSvgHandler::LT_PERCENT);
4021	}
4022	qreal height = 0;
4023	if (!heightStr.isEmpty()) {
4024	height = parseLength(str: heightStr.toString(), type: &type, handler);
4025	if (type != QSvgHandler::LT_PT)
4026	height = convertToPixels(len: height, false, type);
4027	node->setHeight(len: int(height), percent: type == QSvgHandler::LT_PERCENT);
4028	}
4029
4030	QStringList viewBoxValues;
4031	if (!viewBoxStr.isEmpty()) {
4032	viewBoxStr = viewBoxStr.replace(before: QLatin1Char(' '), after: QLatin1Char(','));
4033	viewBoxStr = viewBoxStr.replace(before: QLatin1Char('\r'), after: QLatin1Char(','));
4034	viewBoxStr = viewBoxStr.replace(before: QLatin1Char('\n'), after: QLatin1Char(','));
4035	viewBoxStr = viewBoxStr.replace(before: QLatin1Char('\t'), after: QLatin1Char(','));
4036	viewBoxValues = viewBoxStr.split(sep: QLatin1Char(','), behavior: Qt::SkipEmptyParts);
4037	}
4038	if (viewBoxValues.size() == 4) {
4039	QString xStr = viewBoxValues.at(i: 0).trimmed();
4040	QString yStr = viewBoxValues.at(i: 1).trimmed();
4041	QString widthStr = viewBoxValues.at(i: 2).trimmed();
4042	QString heightStr = viewBoxValues.at(i: 3).trimmed();
4043
4044	QSvgHandler::LengthType lt;
4045	qreal x = parseLength(str: xStr, type: &lt, handler);
4046	qreal y = parseLength(str: yStr, type: &lt, handler);
4047	qreal w = parseLength(str: widthStr, type: &lt, handler);
4048	qreal h = parseLength(str: heightStr, type: &lt, handler);
4049
4050	node->setViewBox(QRectF(x, y, w, h));
4051
4052	} else if (width && height) {
4053	if (type == QSvgHandler::LT_PT) {
4054	width = convertToPixels(len: width, false, type);
4055	height = convertToPixels(len: height, false, type);
4056	}
4057	node->setViewBox(QRectF(0, 0, width, height));
4058	}
4059	handler->setDefaultCoordinateSystem(QSvgHandler::LT_PX);
4060
4061	return node;
4062	}
4063
4064	static QSvgNode *createSwitchNode(QSvgNode *parent,
4065	const QXmlStreamAttributes &attributes,
4066	QSvgHandler *)
4067	{
4068	Q_UNUSED(attributes);
4069	QSvgSwitch *node = new QSvgSwitch(parent);
4070	return node;
4071	}
4072
4073	static QSvgNode *createPatternNode(QSvgNode *parent,
4074	const QXmlStreamAttributes &attributes,
4075	QSvgHandler *handler)
4076	{
4077	const QStringView x = attributes.value(qualifiedName: QLatin1String("x"));
4078	const QStringView y = attributes.value(qualifiedName: QLatin1String("y"));
4079	const QStringView width = attributes.value(qualifiedName: QLatin1String("width"));
4080	const QStringView height = attributes.value(qualifiedName: QLatin1String("height"));
4081	const QStringView patternUnits = attributes.value(qualifiedName: QLatin1String("patternUnits"));
4082	const QStringView patternContentUnits = attributes.value(qualifiedName: QLatin1String("patternContentUnits"));
4083	const QStringView patternTransform = attributes.value(qualifiedName: QLatin1String("patternTransform"));
4084
4085	QtSvg::UnitTypes nPatternUnits = patternUnits.contains(s: QLatin1String("userSpaceOnUse")) ?
4086	QtSvg::UnitTypes::userSpaceOnUse : QtSvg::UnitTypes::objectBoundingBox;
4087
4088	QtSvg::UnitTypes nPatternContentUnits = patternContentUnits.contains(s: QLatin1String("objectBoundingBox")) ?
4089	QtSvg::UnitTypes::objectBoundingBox : QtSvg::UnitTypes::userSpaceOnUse;
4090
4091	QString viewBoxStr = attributes.value(qualifiedName: QLatin1String("viewBox")).toString();
4092
4093	bool ok = false;
4094	QSvgHandler::LengthType type;
4095
4096	qreal nx = parseLength(str: x.toString(), type: &type, handler, ok: &ok);
4097	nx = convertToPixels(len: nx, true, type);
4098	if (!ok)
4099	nx = 0.0;
4100	else if (type == QSvgHandler::LT_PERCENT && nPatternUnits == QtSvg::UnitTypes::userSpaceOnUse)
4101	nx = (nx / 100.) * handler->document()->viewBox().width();
4102	else if (type == QSvgHandler::LT_PERCENT)
4103	nx = nx / 100.;
4104
4105	qreal ny = parseLength(str: y.toString(), type: &type, handler, ok: &ok);
4106	ny = convertToPixels(len: ny, true, type);
4107	if (!ok)
4108	ny = 0.0;
4109	else if (type == QSvgHandler::LT_PERCENT && nPatternUnits == QtSvg::UnitTypes::userSpaceOnUse)
4110	ny = (ny / 100.) * handler->document()->viewBox().height();
4111	else if (type == QSvgHandler::LT_PERCENT)
4112	ny = ny / 100.;
4113
4114	qreal nwidth = parseLength(str: width.toString(), type: &type, handler, ok: &ok);
4115	nwidth = convertToPixels(len: nwidth, true, type);
4116	if (!ok)
4117	nwidth = 0.0;
4118	else if (type == QSvgHandler::LT_PERCENT && nPatternUnits == QtSvg::UnitTypes::userSpaceOnUse)
4119	nwidth = (nwidth / 100.) * handler->document()->viewBox().width();
4120	else if (type == QSvgHandler::LT_PERCENT)
4121	nwidth = nwidth / 100.;
4122
4123	qreal nheight = parseLength(str: height.toString(), type: &type, handler, ok: &ok);
4124	nheight = convertToPixels(len: nheight, true, type);
4125	if (!ok)
4126	nheight = 0.0;
4127	else if (type == QSvgHandler::LT_PERCENT && nPatternUnits == QtSvg::UnitTypes::userSpaceOnUse)
4128	nheight = (nheight / 100.) * handler->document()->viewBox().height();
4129	else if (type == QSvgHandler::LT_PERCENT)
4130	nheight = nheight / 100.;
4131
4132
4133	QStringList viewBoxValues;
4134	QRectF viewBox;
4135	if (!viewBoxStr.isEmpty()) {
4136	viewBoxStr = viewBoxStr.replace(before: QLatin1Char(' '), after: QLatin1Char(','));
4137	viewBoxStr = viewBoxStr.replace(before: QLatin1Char('\r'), after: QLatin1Char(','));
4138	viewBoxStr = viewBoxStr.replace(before: QLatin1Char('\n'), after: QLatin1Char(','));
4139	viewBoxStr = viewBoxStr.replace(before: QLatin1Char('\t'), after: QLatin1Char(','));
4140	viewBoxValues = viewBoxStr.split(sep: QLatin1Char(','), behavior: Qt::SkipEmptyParts);
4141	}
4142	if (viewBoxValues.size() == 4) {
4143	QString xStr = viewBoxValues.at(i: 0).trimmed();
4144	QString yStr = viewBoxValues.at(i: 1).trimmed();
4145	QString widthStr = viewBoxValues.at(i: 2).trimmed();
4146	QString heightStr = viewBoxValues.at(i: 3).trimmed();
4147
4148	qreal x = convertToNumber(str: xStr, handler);
4149	qreal y = convertToNumber(str: yStr, handler);
4150	qreal w = convertToNumber(str: widthStr, handler);
4151	qreal h = convertToNumber(str: heightStr, handler);
4152
4153	if (w > 0 && h > 0)
4154	viewBox.setRect(ax: x, ay: y, aaw: w, aah: h);
4155	}
4156
4157	QTransform matrix;
4158	if (!patternTransform.isEmpty())
4159	matrix = parseTransformationMatrix(value: patternTransform);
4160
4161	QRectF bounds(nx, ny, nwidth, nheight);
4162	if (bounds.isEmpty())
4163	return nullptr;
4164
4165	QSvgRectF patternRectF(bounds, nPatternUnits, nPatternUnits, nPatternUnits, nPatternUnits);
4166	QSvgPattern *node = new QSvgPattern(parent, patternRectF, viewBox, nPatternContentUnits, matrix);
4167
4168	// Create a style node for the Pattern.
4169	QSvgPatternStyle *prop = new QSvgPatternStyle(node);
4170	node->appendStyleProperty(prop, id: someId(attributes));
4171
4172	return node;
4173	}
4174
4175	static bool parseTbreakNode(QSvgNode *parent,
4176	const QXmlStreamAttributes &,
4177	QSvgHandler *)
4178	{
4179	if (parent->type() != QSvgNode::Textarea)
4180	return false;
4181	static_cast<QSvgText*>(parent)->addLineBreak();
4182	return true;
4183	}
4184
4185	static QSvgNode *createTextNode(QSvgNode *parent,
4186	const QXmlStreamAttributes &attributes,
4187	QSvgHandler *handler)
4188	{
4189	const QStringView x = attributes.value(qualifiedName: QLatin1String("x"));
4190	const QStringView y = attributes.value(qualifiedName: QLatin1String("y"));
4191	//### editable and rotate not handled
4192	QSvgHandler::LengthType type;
4193	qreal nx = parseLength(str: x.toString(), type: &type, handler);
4194	nx = convertToPixels(len: nx, true, type);
4195	qreal ny = parseLength(str: y.toString(), type: &type, handler);
4196	ny = convertToPixels(len: ny, true, type);
4197
4198	QSvgNode *text = new QSvgText(parent, QPointF(nx, ny));
4199	return text;
4200	}
4201
4202	static QSvgNode *createTextAreaNode(QSvgNode *parent,
4203	const QXmlStreamAttributes &attributes,
4204	QSvgHandler *handler)
4205	{
4206	QSvgText *node = static_cast<QSvgText *>(createTextNode(parent, attributes, handler));
4207	if (node) {
4208	QSvgHandler::LengthType type;
4209	qreal width = parseLength(str: attributes.value(qualifiedName: QLatin1String("width")), type: &type, handler);
4210	qreal height = parseLength(str: attributes.value(qualifiedName: QLatin1String("height")), type: &type, handler);
4211	node->setTextArea(QSizeF(width, height));
4212	}
4213	return node;
4214	}
4215
4216	static QSvgNode *createTspanNode(QSvgNode *parent,
4217	const QXmlStreamAttributes &,
4218	QSvgHandler *)
4219	{
4220	return new QSvgTspan(parent);
4221	}
4222
4223	static QSvgNode *createUseNode(QSvgNode *parent,
4224	const QXmlStreamAttributes &attributes,
4225	QSvgHandler *handler)
4226	{
4227	QString linkId = attributes.value(qualifiedName: QLatin1String("xlink:href")).toString().remove(i: 0, len: 1);
4228	const QStringView xStr = attributes.value(qualifiedName: QLatin1String("x"));
4229	const QStringView yStr = attributes.value(qualifiedName: QLatin1String("y"));
4230	QSvgStructureNode *group = nullptr;
4231
4232	if (linkId.isEmpty())
4233	linkId = attributes.value(qualifiedName: QLatin1String("href")).toString().remove(i: 0, len: 1);
4234	switch (parent->type()) {
4235	case QSvgNode::Doc:
4236	case QSvgNode::Defs:
4237	case QSvgNode::Group:
4238	case QSvgNode::Switch:
4239	case QSvgNode::Mask:
4240	group = static_cast<QSvgStructureNode*>(parent);
4241	break;
4242	default:
4243	break;
4244	}
4245
4246	if (group) {
4247	QPointF pt;
4248	if (!xStr.isNull() || !yStr.isNull()) {
4249	QSvgHandler::LengthType type;
4250	qreal nx = parseLength(str: xStr.toString(), type: &type, handler);
4251	nx = convertToPixels(len: nx, true, type);
4252
4253	qreal ny = parseLength(str: yStr.toString(), type: &type, handler);
4254	ny = convertToPixels(len: ny, true, type);
4255	pt = QPointF(nx, ny);
4256	}
4257
4258	QSvgNode *link = group->scopeNode(id: linkId);
4259	if (link) {
4260	if (parent->isDescendantOf(parent: link))
4261	qCWarning(lcSvgHandler, "link #%s is recursive!", qPrintable(linkId));
4262
4263	return new QSvgUse(pt, parent, link);
4264	}
4265
4266	//delay link resolving, link might have not been created yet
4267	return new QSvgUse(pt, parent, linkId);
4268	}
4269
4270	qCWarning(lcSvgHandler, "<use> element %s in wrong context!", qPrintable(linkId));
4271	return 0;
4272	}
4273
4274	static QSvgNode *createVideoNode(QSvgNode *parent,
4275	const QXmlStreamAttributes &attributes,
4276	QSvgHandler *)
4277	{
4278	Q_UNUSED(parent); Q_UNUSED(attributes);
4279	return 0;
4280	}
4281
4282	typedef QSvgNode *(*FactoryMethod)(QSvgNode *, const QXmlStreamAttributes &, QSvgHandler *);
4283
4284	static FactoryMethod findGroupFactory(const QString &name, QtSvg::Options options)
4285	{
4286	if (name.isEmpty())
4287	return 0;
4288
4289	QStringView ref = QStringView{name}.mid(pos: 1, n: name.size() - 1);
4290	switch (name.at(i: 0).unicode()) {
4291	case 'd':
4292	if (ref == QLatin1String("efs")) return createDefsNode;
4293	break;
4294	case 'f':
4295	if (ref == QLatin1String("ilter") && !options.testFlag(flag: QtSvg::Tiny12FeaturesOnly)) return createFilterNode;
4296	break;
4297	case 'g':
4298	if (ref.isEmpty()) return createGNode;
4299	break;
4300	case 'm':
4301	if (ref == QLatin1String("ask") && !options.testFlag(flag: QtSvg::Tiny12FeaturesOnly)) return createMaskNode;
4302	if (ref == QLatin1String("arker") && !options.testFlag(flag: QtSvg::Tiny12FeaturesOnly)) return createMarkerNode;
4303	break;
4304	case 's':
4305	if (ref == QLatin1String("vg")) return createSvgNode;
4306	if (ref == QLatin1String("witch")) return createSwitchNode;
4307	if (ref == QLatin1String("ymbol") && !options.testFlag(flag: QtSvg::Tiny12FeaturesOnly)) return createSymbolNode;
4308	break;
4309	case 'p':
4310	if (ref == QLatin1String("attern") && !options.testFlag(flag: QtSvg::Tiny12FeaturesOnly)) return createPatternNode;
4311	break;
4312	default:
4313	break;
4314	}
4315	return 0;
4316	}
4317
4318	static FactoryMethod findGraphicsFactory(const QString &name, QtSvg::Options options)
4319	{
4320	Q_UNUSED(options);
4321	if (name.isEmpty())
4322	return 0;
4323
4324	QStringView ref = QStringView{name}.mid(pos: 1, n: name.size() - 1);
4325	switch (name.at(i: 0).unicode()) {
4326	case 'a':
4327	if (ref == QLatin1String("nimation")) return createAnimationNode;
4328	break;
4329	case 'c':
4330	if (ref == QLatin1String("ircle")) return createCircleNode;
4331	break;
4332	case 'e':
4333	if (ref == QLatin1String("llipse")) return createEllipseNode;
4334	break;
4335	case 'i':
4336	if (ref == QLatin1String("mage")) return createImageNode;
4337	break;
4338	case 'l':
4339	if (ref == QLatin1String("ine")) return createLineNode;
4340	break;
4341	case 'p':
4342	if (ref == QLatin1String("ath")) return createPathNode;
4343	if (ref == QLatin1String("olygon")) return createPolygonNode;
4344	if (ref == QLatin1String("olyline")) return createPolylineNode;
4345	break;
4346	case 'r':
4347	if (ref == QLatin1String("ect")) return createRectNode;
4348	break;
4349	case 't':
4350	if (ref == QLatin1String("ext")) return createTextNode;
4351	if (ref == QLatin1String("extArea")) return createTextAreaNode;
4352	if (ref == QLatin1String("span")) return createTspanNode;
4353	break;
4354	case 'u':
4355	if (ref == QLatin1String("se")) return createUseNode;
4356	break;
4357	case 'v':
4358	if (ref == QLatin1String("ideo")) return createVideoNode;
4359	break;
4360	default:
4361	break;
4362	}
4363	return 0;
4364	}
4365
4366	static FactoryMethod findFilterFactory(const QString &name, QtSvg::Options options)
4367	{
4368	if (options.testFlag(flag: QtSvg::Tiny12FeaturesOnly))
4369	return 0;
4370
4371	if (name.isEmpty())
4372	return 0;
4373
4374	if (!name.startsWith(s: QLatin1String("fe")))
4375	return 0;
4376
4377	if (name == QLatin1String("feMerge")) return createFeMergeNode;
4378	if (name == QLatin1String("feColorMatrix")) return createFeColorMatrixNode;
4379	if (name == QLatin1String("feGaussianBlur")) return createFeGaussianBlurNode;
4380	if (name == QLatin1String("feOffset")) return createFeOffsetNode;
4381	if (name == QLatin1String("feMergeNode")) return createFeMergeNodeNode;
4382	if (name == QLatin1String("feComposite")) return createFeCompositeNode;
4383	if (name == QLatin1String("feFlood")) return createFeFloodNode;
4384
4385	static const QStringList unsupportedFilters = {
4386	QStringLiteral("feBlend"),
4387	QStringLiteral("feComponentTransfer"),
4388	QStringLiteral("feConvolveMatrix"),
4389	QStringLiteral("feDiffuseLighting"),
4390	QStringLiteral("feDisplacementMap"),
4391	QStringLiteral("feDropShadow"),
4392	QStringLiteral("feFuncA"),
4393	QStringLiteral("feFuncB"),
4394	QStringLiteral("feFuncG"),
4395	QStringLiteral("feFuncR"),
4396	QStringLiteral("feImage"),
4397	QStringLiteral("feMorphology"),
4398	QStringLiteral("feSpecularLighting"),
4399	QStringLiteral("feTile"),
4400	QStringLiteral("feTurbulence")
4401	};
4402
4403	if (unsupportedFilters.contains(str: name))
4404	return createFeUnsupportedNode;
4405
4406	return 0;
4407	}
4408
4409	typedef bool (*ParseMethod)(QSvgNode *, const QXmlStreamAttributes &, QSvgHandler *);
4410
4411	static ParseMethod findUtilFactory(const QString &name, QtSvg::Options options)
4412	{
4413	if (name.isEmpty())
4414	return 0;
4415
4416	QStringView ref = QStringView{name}.mid(pos: 1, n: name.size() - 1);
4417	switch (name.at(i: 0).unicode()) {
4418	case 'a':
4419	if (ref.isEmpty()) return parseAnchorNode;
4420	if (ref == QLatin1String("nimate")) return parseAnimateNode;
4421	if (ref == QLatin1String("nimateColor")) return parseAnimateColorNode;
4422	if (ref == QLatin1String("nimateMotion")) return parseAimateMotionNode;
4423	if (ref == QLatin1String("nimateTransform")) return parseAnimateTransformNode;
4424	if (ref == QLatin1String("udio")) return parseAudioNode;
4425	break;
4426	case 'd':
4427	if (ref == QLatin1String("iscard")) return parseDiscardNode;
4428	break;
4429	case 'f':
4430	if (ref == QLatin1String("oreignObject")) return parseForeignObjectNode;
4431	break;
4432	case 'h':
4433	if (ref == QLatin1String("andler")) return parseHandlerNode;
4434	if (ref == QLatin1String("kern")) return parseHkernNode;
4435	break;
4436	case 'm':
4437	if (ref == QLatin1String("etadata")) return parseMetadataNode;
4438	if (ref == QLatin1String("path")) return parseMpathNode;
4439	if (ref == QLatin1String("ask") && !options.testFlag(flag: QtSvg::Tiny12FeaturesOnly)) return parseMaskNode;
4440	if (ref == QLatin1String("arker") && !options.testFlag(flag: QtSvg::Tiny12FeaturesOnly)) return parseMarkerNode;
4441	break;
4442	case 'p':
4443	if (ref == QLatin1String("refetch")) return parsePrefetchNode;
4444	break;
4445	case 's':
4446	if (ref == QLatin1String("cript")) return parseScriptNode;
4447	if (ref == QLatin1String("et")) return parseSetNode;
4448	if (ref == QLatin1String("tyle")) return parseStyleNode;
4449	break;
4450	case 't':
4451	if (ref == QLatin1String("break")) return parseTbreakNode;
4452	break;
4453	default:
4454	break;
4455	}
4456	return 0;
4457	}
4458
4459	typedef QSvgStyleProperty *(*StyleFactoryMethod)(QSvgNode *,
4460	const QXmlStreamAttributes &,
4461	QSvgHandler *);
4462
4463	static StyleFactoryMethod findStyleFactoryMethod(const QString &name)
4464	{
4465	if (name.isEmpty())
4466	return 0;
4467
4468	QStringView ref = QStringView{name}.mid(pos: 1, n: name.size() - 1);
4469	switch (name.at(i: 0).unicode()) {
4470	case 'f':
4471	if (ref == QLatin1String("ont")) return createFontNode;
4472	break;
4473	case 'l':
4474	if (ref == QLatin1String("inearGradient")) return createLinearGradientNode;
4475	break;
4476	case 'r':
4477	if (ref == QLatin1String("adialGradient")) return createRadialGradientNode;
4478	break;
4479	case 's':
4480	if (ref == QLatin1String("olidColor")) return createSolidColorNode;
4481	break;
4482	default:
4483	break;
4484	}
4485	return 0;
4486	}
4487
4488	typedef bool (*StyleParseMethod)(QSvgStyleProperty *,
4489	const QXmlStreamAttributes &,
4490	QSvgHandler *);
4491
4492	static StyleParseMethod findStyleUtilFactoryMethod(const QString &name)
4493	{
4494	if (name.isEmpty())
4495	return 0;
4496
4497	QStringView ref = QStringView{name}.mid(pos: 1, n: name.size() - 1);
4498	switch (name.at(i: 0).unicode()) {
4499	case 'f':
4500	if (ref == QLatin1String("ont-face")) return parseFontFaceNode;
4501	if (ref == QLatin1String("ont-face-name")) return parseFontFaceNameNode;
4502	if (ref == QLatin1String("ont-face-src")) return parseFontFaceSrcNode;
4503	if (ref == QLatin1String("ont-face-uri")) return parseFontFaceUriNode;
4504	break;
4505	case 'g':
4506	if (ref == QLatin1String("lyph")) return parseGlyphNode;
4507	break;
4508	case 'm':
4509	if (ref == QLatin1String("issing-glyph")) return parseMissingGlyphNode;
4510	break;
4511	case 's':
4512	if (ref == QLatin1String("top")) return parseStopNode;
4513	break;
4514	default:
4515	break;
4516	}
4517	return 0;
4518	}
4519
4520	QSvgHandler::QSvgHandler(QIODevice *device, QtSvg::Options options)
4521	: xml(new QXmlStreamReader(device))
4522	, m_ownsReader(true)
4523	, m_options(options)
4524	{
4525	init();
4526	}
4527
4528	QSvgHandler::QSvgHandler(const QByteArray &data, QtSvg::Options options)
4529	: xml(new QXmlStreamReader(data))
4530	, m_ownsReader(true)
4531	, m_options(options)
4532	{
4533	init();
4534	}
4535
4536	QSvgHandler::QSvgHandler(QXmlStreamReader *const reader, QtSvg::Options options)
4537	: xml(reader)
4538	, m_ownsReader(false)
4539	, m_options(options)
4540	{
4541	init();
4542	}
4543
4544	void QSvgHandler::init()
4545	{
4546	m_doc = 0;
4547	m_style = 0;
4548	m_animEnd = 0;
4549	m_defaultCoords = LT_PX;
4550	m_defaultPen = QPen(Qt::black, 1, Qt::SolidLine, Qt::FlatCap, Qt::SvgMiterJoin);
4551	m_defaultPen.setMiterLimit(4);
4552	parse();
4553	}
4554
4555	static bool detectPatternCycles(const QSvgNode *node, QList<const QSvgNode *> active = {})
4556	{
4557	QSvgFillStyle *fillStyle = static_cast<QSvgFillStyle*>
4558	(node->styleProperty(type: QSvgStyleProperty::FILL));
4559	if (fillStyle && fillStyle->style() && fillStyle->style()->type() == QSvgStyleProperty::PATTERN) {
4560	QSvgPatternStyle *patternStyle = static_cast<QSvgPatternStyle *>(fillStyle->style());
4561	if (active.contains(t: patternStyle->patternNode()))
4562	return true;
4563	}
4564
4565	QSvgStrokeStyle *strokeStyle = static_cast<QSvgStrokeStyle*>
4566	(node->styleProperty(type: QSvgStyleProperty::STROKE));
4567	if (strokeStyle && strokeStyle->style() && strokeStyle->style()->type() == QSvgStyleProperty::PATTERN) {
4568	QSvgPatternStyle *patternStyle = static_cast<QSvgPatternStyle *>(strokeStyle->style());
4569	if (active.contains(t: patternStyle->patternNode()))
4570	return true;
4571	}
4572
4573	return false;
4574	}
4575
4576	static bool detectCycles(const QSvgNode *node, QList<const QSvgNode *> active = {})
4577	{
4578	if (Q_UNLIKELY(!node))
4579	return false;
4580	switch (node->type()) {
4581	case QSvgNode::Doc:
4582	case QSvgNode::Group:
4583	case QSvgNode::Defs:
4584	case QSvgNode::Pattern:
4585	{
4586	if (node->type() == QSvgNode::Pattern)
4587	active.append(t: node);
4588
4589	auto *g = static_cast<const QSvgStructureNode*>(node);
4590	for (auto *r : g->renderers()) {
4591	if (detectCycles(node: r, active))
4592	return true;
4593	}
4594	}
4595	break;
4596	case QSvgNode::Use:
4597	{
4598	if (active.contains(t: node))
4599	return true;
4600
4601	auto *u = static_cast<const QSvgUse*>(node);
4602	auto *target = u->link();
4603	if (target) {
4604	active.append(t: u);
4605	if (detectCycles(node: target, active))
4606	return true;
4607	}
4608	}
4609	break;
4610	case QSvgNode::Rect:
4611	case QSvgNode::Ellipse:
4612	case QSvgNode::Circle:
4613	case QSvgNode::Line:
4614	case QSvgNode::Path:
4615	case QSvgNode::Polygon:
4616	case QSvgNode::Polyline:
4617	case QSvgNode::Tspan:
4618	if (detectPatternCycles(node, active))
4619	return true;
4620	break;
4621	default:
4622	break;
4623	}
4624	return false;
4625	}
4626
4627	// Having too many unfinished elements will cause a stack overflow
4628	// in the dtor of QSvgTinyDocument, see oss-fuzz issue 24000.
4629	static const int unfinishedElementsLimit = 2048;
4630
4631	void QSvgHandler::parse()
4632	{
4633	xml->setNamespaceProcessing(false);
4634	#ifndef QT_NO_CSSPARSER
4635	m_selector = new QSvgStyleSelector;
4636	m_inStyle = false;
4637	#endif
4638	bool done = false;
4639	int remainingUnfinishedElements = unfinishedElementsLimit;
4640	while (!xml->atEnd() && !done) {
4641	switch (xml->readNext()) {
4642	case QXmlStreamReader::StartElement:
4643	// he we could/should verify the namespaces, and simply
4644	// call m_skipNodes(Unknown) if we don't know the
4645	// namespace. We do support http://www.w3.org/2000/svg
4646	// but also http://www.w3.org/2000/svg-20000303-stylable
4647	// And if the document uses an external dtd, the reported
4648	// namespaceUri is empty. The only possible strategy at
4649	// this point is to do what everyone else seems to do and
4650	// ignore the reported namespaceUri completely.
4651	if (remainingUnfinishedElements
4652	&& startElement(localName: xml->name().toString(), attributes: xml->attributes())) {
4653	--remainingUnfinishedElements;
4654	} else {
4655	delete m_doc;
4656	m_doc = nullptr;
4657	return;
4658	}
4659	break;
4660	case QXmlStreamReader::EndElement:
4661	done = endElement(localName: xml->name());
4662	++remainingUnfinishedElements;
4663	break;
4664	case QXmlStreamReader::Characters:
4665	characters(str: xml->text());
4666	break;
4667	case QXmlStreamReader::ProcessingInstruction:
4668	processingInstruction(target: xml->processingInstructionTarget().toString(), data: xml->processingInstructionData().toString());
4669	break;
4670	default:
4671	break;
4672	}
4673	}
4674	resolvePaintServers(node: m_doc);
4675	resolveNodes();
4676	if (detectCycles(node: m_doc)) {
4677	qCWarning(lcSvgHandler, "Cycles detected in SVG, document discarded.");
4678	delete m_doc;
4679	m_doc = nullptr;
4680	}
4681	}
4682
4683	bool QSvgHandler::startElement(const QString &localName,
4684	const QXmlStreamAttributes &attributes)
4685	{
4686	QSvgNode *node = nullptr;
4687
4688	pushColorCopy();
4689
4690	/* The xml:space attribute may appear on any element. We do
4691	* a lookup by the qualified name here, but this is namespace aware, since
4692	* the XML namespace can only be bound to prefix "xml." */
4693	const QStringView xmlSpace(attributes.value(qualifiedName: QLatin1String("xml:space")));
4694	if (xmlSpace.isNull()) {
4695	// This element has no xml:space attribute.
4696	m_whitespaceMode.push(t: m_whitespaceMode.isEmpty() ? QSvgText::Default : m_whitespaceMode.top());
4697	} else if (xmlSpace == QLatin1String("preserve")) {
4698	m_whitespaceMode.push(t: QSvgText::Preserve);
4699	} else if (xmlSpace == QLatin1String("default")) {
4700	m_whitespaceMode.push(t: QSvgText::Default);
4701	} else {
4702	const QByteArray msg = '"' + xmlSpace.toString().toLocal8Bit()
4703	+ "\" is an invalid value for attribute xml:space. "
4704	"Valid values are \"preserve\" and \"default\".";
4705	qCWarning(lcSvgHandler, "%s", prefixMessage(msg, xml).constData());
4706	m_whitespaceMode.push(t: QSvgText::Default);
4707	}
4708
4709	if (!m_doc && localName != QLatin1String("svg"))
4710	return false;
4711
4712	if (m_doc && localName == QLatin1String("svg")) {
4713	m_skipNodes.push(t: Doc);
4714	qCWarning(lcSvgHandler) << "Skipping a nested svg element, because "
4715	"SVG Document must not contain nested svg elements in Svg Tiny 1.2";
4716	}
4717
4718	if (!m_skipNodes.isEmpty() && m_skipNodes.top() == Doc)
4719	return true;
4720
4721	if (FactoryMethod method = findGroupFactory(name: localName, options: options())) {
4722	//group
4723	node = method(m_doc ? m_nodes.top() : 0, attributes, this);
4724
4725	if (node) {
4726	if (!m_doc) {
4727	Q_ASSERT(node->type() == QSvgNode::Doc);
4728	m_doc = static_cast<QSvgTinyDocument*>(node);
4729	} else {
4730	switch (m_nodes.top()->type()) {
4731	case QSvgNode::Doc:
4732	case QSvgNode::Group:
4733	case QSvgNode::Defs:
4734	case QSvgNode::Switch:
4735	case QSvgNode::Mask:
4736	case QSvgNode::Symbol:
4737	case QSvgNode::Marker:
4738	case QSvgNode::Pattern:
4739	{
4740	QSvgStructureNode *group =
4741	static_cast<QSvgStructureNode*>(m_nodes.top());
4742	group->addChild(child: node, id: someId(attributes));
4743	}
4744	break;
4745	default:
4746	const QByteArray msg = QByteArrayLiteral("Could not add child element to parent element because the types are incorrect.");
4747	qCWarning(lcSvgHandler, "%s", prefixMessage(msg, xml).constData());
4748	delete node;
4749	node = 0;
4750	break;
4751	}
4752	}
4753
4754	if (node) {
4755	parseCoreNode(node, attributes);
4756	#ifndef QT_NO_CSSPARSER
4757	cssStyleLookup(node, handler: this, selector: m_selector);
4758	#endif
4759	parseStyle(node, attrs: attributes, handler: this);
4760	if (node->type() == QSvgNode::Filter)
4761	m_toBeResolved.append(t: node);
4762	}
4763	}
4764	} else if (FactoryMethod method = findGraphicsFactory(name: localName, options: options())) {
4765	//rendering element
4766	Q_ASSERT(!m_nodes.isEmpty());
4767	node = method(m_nodes.top(), attributes, this);
4768	if (node) {
4769	switch (m_nodes.top()->type()) {
4770	case QSvgNode::Doc:
4771	case QSvgNode::Group:
4772	case QSvgNode::Defs:
4773	case QSvgNode::Switch:
4774	case QSvgNode::Mask:
4775	case QSvgNode::Symbol:
4776	case QSvgNode::Marker:
4777	case QSvgNode::Pattern:
4778	{
4779	if (node->type() == QSvgNode::Tspan) {
4780	const QByteArray msg = QByteArrayLiteral("\'tspan\' element in wrong context.");
4781	qCWarning(lcSvgHandler, "%s", prefixMessage(msg, xml).constData());
4782	delete node;
4783	node = 0;
4784	break;
4785	}
4786	QSvgStructureNode *group =
4787	static_cast<QSvgStructureNode*>(m_nodes.top());
4788	group->addChild(child: node, id: someId(attributes));
4789	}
4790	break;
4791	case QSvgNode::Text:
4792	case QSvgNode::Textarea:
4793	if (node->type() == QSvgNode::Tspan) {
4794	static_cast<QSvgText *>(m_nodes.top())->addTspan(tspan: static_cast<QSvgTspan *>(node));
4795	} else {
4796	const QByteArray msg = QByteArrayLiteral("\'text\' or \'textArea\' element contains invalid element type.");
4797	qCWarning(lcSvgHandler, "%s", prefixMessage(msg, xml).constData());
4798	delete node;
4799	node = 0;
4800	}
4801	break;
4802	default:
4803	const QByteArray msg = QByteArrayLiteral("Could not add child element to parent element because the types are incorrect.");
4804	qCWarning(lcSvgHandler, "%s", prefixMessage(msg, xml).constData());
4805	delete node;
4806	node = 0;
4807	break;
4808	}
4809
4810	if (node) {
4811	parseCoreNode(node, attributes);
4812	#ifndef QT_NO_CSSPARSER
4813	cssStyleLookup(node, handler: this, selector: m_selector);
4814	#endif
4815	parseStyle(node, attrs: attributes, handler: this);
4816	if (node->type() == QSvgNode::Text || node->type() == QSvgNode::Textarea) {
4817	static_cast<QSvgText *>(node)->setWhitespaceMode(m_whitespaceMode.top());
4818	} else if (node->type() == QSvgNode::Tspan) {
4819	static_cast<QSvgTspan *>(node)->setWhitespaceMode(m_whitespaceMode.top());
4820	} else if (node->type() == QSvgNode::Use) {
4821	auto useNode = static_cast<QSvgUse *>(node);
4822	if (!useNode->isResolved())
4823	m_toBeResolved.append(t: useNode);
4824	}
4825	}
4826	}
4827	} else if (FactoryMethod method = findFilterFactory(name: localName, options: options())) {
4828	//filter nodes to be aded to be filtercontainer
4829	Q_ASSERT(!m_nodes.isEmpty());
4830	node = method(m_nodes.top(), attributes, this);
4831	if (node) {
4832	if (m_nodes.top()->type() == QSvgNode::Filter ||
4833	(m_nodes.top()->type() == QSvgNode::FeMerge && node->type() == QSvgNode::FeMergenode)) {
4834	QSvgStructureNode *container =
4835	static_cast<QSvgStructureNode*>(m_nodes.top());
4836	container->addChild(child: node, id: someId(attributes));
4837	} else {
4838	const QByteArray msg = QByteArrayLiteral("Could not add child element to parent element because the types are incorrect.");
4839	qCWarning(lcSvgHandler, "%s", prefixMessage(msg, xml).constData());
4840	delete node;
4841	node = 0;
4842	}
4843	}
4844	} else if (ParseMethod method = findUtilFactory(name: localName, options: options())) {
4845	Q_ASSERT(!m_nodes.isEmpty());
4846	if (!method(m_nodes.top(), attributes, this))
4847	qCWarning(lcSvgHandler, "%s", msgProblemParsing(localName, xml).constData());
4848	} else if (StyleFactoryMethod method = findStyleFactoryMethod(name: localName)) {
4849	QSvgStyleProperty *prop = method(m_nodes.top(), attributes, this);
4850	if (prop) {
4851	m_style = prop;
4852	m_nodes.top()->appendStyleProperty(prop, id: someId(attributes));
4853	} else {
4854	const QByteArray msg = QByteArrayLiteral("Could not parse node: ") + localName.toLocal8Bit();
4855	qCWarning(lcSvgHandler, "%s", prefixMessage(msg, xml).constData());
4856	}
4857	} else if (StyleParseMethod method = findStyleUtilFactoryMethod(name: localName)) {
4858	if (m_style) {
4859	if (!method(m_style, attributes, this))
4860	qCWarning(lcSvgHandler, "%s", msgProblemParsing(localName, xml).constData());
4861	}
4862	} else {
4863	qCDebug(lcSvgHandler) << "Skipping unknown element" << localName;
4864	m_skipNodes.push(t: Unknown);
4865	return true;
4866	}
4867
4868	if (node) {
4869	m_nodes.push(t: node);
4870	m_skipNodes.push(t: Graphics);
4871	} else {
4872	//qDebug()<<"Skipping "<<localName;
4873	m_skipNodes.push(t: Style);
4874	}
4875	return true;
4876	}
4877
4878	bool QSvgHandler::endElement(const QStringView localName)
4879	{
4880	CurrentNode node = m_skipNodes.top();
4881
4882	if (node == Doc && localName != QLatin1String("svg"))
4883	return false;
4884
4885	m_skipNodes.pop();
4886	m_whitespaceMode.pop();
4887
4888	popColor();
4889
4890	if (node == Unknown)
4891	return false;
4892
4893	#ifdef QT_NO_CSSPARSER
4894	Q_UNUSED(localName);
4895	#else
4896	if (m_inStyle && localName == QLatin1String("style"))
4897	m_inStyle = false;
4898	#endif
4899
4900	if (node == Graphics)
4901	m_nodes.pop();
4902	else if (m_style && !m_skipNodes.isEmpty() && m_skipNodes.top() != Style)
4903	m_style = 0;
4904
4905	return ((localName == QLatin1String("svg")) && (node != Doc));
4906	}
4907
4908	void QSvgHandler::resolvePaintServers(QSvgNode *node, int nestedDepth)
4909	{
4910	if (!node || (node->type() != QSvgNode::Doc && node->type() != QSvgNode::Group
4911	&& node->type() != QSvgNode::Defs && node->type() != QSvgNode::Switch)) {
4912	return;
4913	}
4914
4915	QSvgStructureNode *structureNode = static_cast<QSvgStructureNode *>(node);
4916
4917	const QList<QSvgNode *> ren = structureNode->renderers();
4918	for (auto it = ren.begin(); it != ren.end(); ++it) {
4919	QSvgFillStyle *fill = static_cast<QSvgFillStyle *>((*it)->styleProperty(type: QSvgStyleProperty::FILL));
4920	if (fill && !fill->isPaintStyleResolved()) {
4921	QString id = fill->paintStyleId();
4922	QSvgPaintStyleProperty *style = structureNode->styleProperty(id);
4923	if (style) {
4924	fill->setFillStyle(style);
4925	} else {
4926	qCWarning(lcSvgHandler, "%s", msgCouldNotResolveProperty(id, xml).constData());
4927	fill->setBrush(Qt::NoBrush);
4928	}
4929	}
4930
4931	QSvgStrokeStyle *stroke = static_cast<QSvgStrokeStyle *>((*it)->styleProperty(type: QSvgStyleProperty::STROKE));
4932	if (stroke && !stroke->isPaintStyleResolved()) {
4933	QString id = stroke->paintStyleId();
4934	QSvgPaintStyleProperty *style = structureNode->styleProperty(id);
4935	if (style) {
4936	stroke->setStyle(style);
4937	} else {
4938	qCWarning(lcSvgHandler, "%s", msgCouldNotResolveProperty(id, xml).constData());
4939	stroke->setStroke(Qt::NoBrush);
4940	}
4941	}
4942
4943	if (nestedDepth < 2048)
4944	resolvePaintServers(node: *it, nestedDepth: nestedDepth + 1);
4945	}
4946	}
4947
4948	void QSvgHandler::resolveNodes()
4949	{
4950	for (QSvgNode *node : std::as_const(t&: m_toBeResolved)) {
4951	if (node->type() == QSvgNode::Use) {
4952	QSvgUse *useNode = static_cast<QSvgUse *>(node);
4953	const auto parent = useNode->parent();
4954	if (!parent)
4955	continue;
4956
4957	QSvgNode::Type t = parent->type();
4958	if (t != QSvgNode::Doc && t != QSvgNode::Defs && t != QSvgNode::Group && t != QSvgNode::Switch)
4959	continue;
4960
4961	QSvgStructureNode *group = static_cast<QSvgStructureNode *>(parent);
4962	QSvgNode *link = group->scopeNode(id: useNode->linkId());
4963	if (!link) {
4964	qCWarning(lcSvgHandler, "link #%s is undefined!", qPrintable(useNode->linkId()));
4965	continue;
4966	}
4967
4968	if (useNode->parent()->isDescendantOf(parent: link))
4969	qCWarning(lcSvgHandler, "link #%s is recursive!", qPrintable(useNode->linkId()));
4970
4971	useNode->setLink(link);
4972	} else if (node->type() == QSvgNode::Filter) {
4973	QSvgFilterContainer *filter = static_cast<QSvgFilterContainer *>(node);
4974	for (const QSvgNode *renderer : filter->renderers()) {
4975	const QSvgFeFilterPrimitive *primitive = QSvgFeFilterPrimitive::castToFilterPrimitive(node: renderer);
4976	if (!primitive || primitive->type() == QSvgNode::FeUnsupported) {
4977	filter->setSupported(false);
4978	break;
4979	}
4980	}
4981	}
4982	}
4983	m_toBeResolved.clear();
4984	}
4985
4986	bool QSvgHandler::characters(const QStringView str)
4987	{
4988	#ifndef QT_NO_CSSPARSER
4989	if (m_inStyle) {
4990	QString css = str.toString();
4991	QCss::StyleSheet sheet;
4992	QCss::Parser(css).parse(styleSheet: &sheet);
4993	m_selector->styleSheets.append(t: sheet);
4994	return true;
4995	}
4996	#endif
4997	if (m_skipNodes.isEmpty() || m_skipNodes.top() == Unknown || m_nodes.isEmpty())
4998	return true;
4999
5000	if (m_nodes.top()->type() == QSvgNode::Text || m_nodes.top()->type() == QSvgNode::Textarea) {
5001	static_cast<QSvgText*>(m_nodes.top())->addText(text: str.toString());
5002	} else if (m_nodes.top()->type() == QSvgNode::Tspan) {
5003	static_cast<QSvgTspan*>(m_nodes.top())->addText(text: str.toString());
5004	}
5005
5006	return true;
5007	}
5008
5009	QIODevice *QSvgHandler::device() const
5010	{
5011	return xml->device();
5012	}
5013
5014	QSvgTinyDocument *QSvgHandler::document() const
5015	{
5016	return m_doc;
5017	}
5018
5019	QSvgHandler::LengthType QSvgHandler::defaultCoordinateSystem() const
5020	{
5021	return m_defaultCoords;
5022	}
5023
5024	void QSvgHandler::setDefaultCoordinateSystem(LengthType type)
5025	{
5026	m_defaultCoords = type;
5027	}
5028
5029	void QSvgHandler::pushColor(const QColor &color)
5030	{
5031	m_colorStack.push(t: color);
5032	m_colorTagCount.push(t: 1);
5033	}
5034
5035	void QSvgHandler::pushColorCopy()
5036	{
5037	if (m_colorTagCount.size())
5038	++m_colorTagCount.top();
5039	else
5040	pushColor(color: Qt::black);
5041	}
5042
5043	void QSvgHandler::popColor()
5044	{
5045	if (m_colorTagCount.size()) {
5046	if (!--m_colorTagCount.top()) {
5047	m_colorStack.pop();
5048	m_colorTagCount.pop();
5049	}
5050	}
5051	}
5052
5053	QColor QSvgHandler::currentColor() const
5054	{
5055	if (!m_colorStack.isEmpty())
5056	return m_colorStack.top();
5057	else
5058	return QColor(0, 0, 0);
5059	}
5060
5061	#ifndef QT_NO_CSSPARSER
5062
5063	void QSvgHandler::setInStyle(bool b)
5064	{
5065	m_inStyle = b;
5066	}
5067
5068	bool QSvgHandler::inStyle() const
5069	{
5070	return m_inStyle;
5071	}
5072
5073	QSvgStyleSelector * QSvgHandler::selector() const
5074	{
5075	return m_selector;
5076	}
5077
5078	#endif // QT_NO_CSSPARSER
5079
5080	bool QSvgHandler::processingInstruction(const QString &target, const QString &data)
5081	{
5082	#ifdef QT_NO_CSSPARSER
5083	Q_UNUSED(target);
5084	Q_UNUSED(data);
5085	#else
5086	if (target == QLatin1String("xml-stylesheet")) {
5087	QRegularExpression rx(QLatin1String("type=\\\"(.+)\\\""),
5088	QRegularExpression::InvertedGreedinessOption);
5089	QRegularExpressionMatchIterator iter = rx.globalMatch(subject: data);
5090	bool isCss = false;
5091	while (iter.hasNext()) {
5092	QRegularExpressionMatch match = iter.next();
5093	QString type = match.captured(nth: 1);
5094	if (type.toLower() == QLatin1String("text/css")) {
5095	isCss = true;
5096	}
5097	}
5098
5099	if (isCss) {
5100	QRegularExpression rx(QLatin1String("href=\\\"(.+)\\\""),
5101	QRegularExpression::InvertedGreedinessOption);
5102	QRegularExpressionMatch match = rx.match(subject: data);
5103	QString addr = match.captured(nth: 1);
5104	QFileInfo fi(addr);
5105	//qDebug()<<"External CSS file "<<fi.absoluteFilePath()<<fi.exists();
5106	if (fi.exists()) {
5107	QFile file(fi.absoluteFilePath());
5108	if (!file.open(flags: QIODevice::ReadOnly | QIODevice::Text)) {
5109	return true;
5110	}
5111	QByteArray cssData = file.readAll();
5112	QString css = QString::fromUtf8(ba: cssData);
5113
5114	QCss::StyleSheet sheet;
5115	QCss::Parser(css).parse(styleSheet: &sheet);
5116	m_selector->styleSheets.append(t: sheet);
5117	}
5118
5119	}
5120	}
5121	#endif
5122
5123	return true;
5124	}
5125
5126	void QSvgHandler::setAnimPeriod(int start, int end)
5127	{
5128	Q_UNUSED(start);
5129	m_animEnd = qMax(a: end, b: m_animEnd);
5130	}
5131
5132	int QSvgHandler::animationDuration() const
5133	{
5134	return m_animEnd;
5135	}
5136
5137	QSvgHandler::~QSvgHandler()
5138	{
5139	#ifndef QT_NO_CSSPARSER
5140	delete m_selector;
5141	m_selector = 0;
5142	#endif
5143
5144	if(m_ownsReader)
5145	delete xml;
5146	}
5147
5148	QT_END_NAMESPACE
5149