/**************************************************************************** ** ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies). ** Contact: Nokia Corporation (qt-info@nokia.com) ** ** This file is part of the QtSvg module of the Qt Toolkit. ** ** $QT_BEGIN_LICENSE:LGPL$ ** No Commercial Usage ** This file contains pre-release code and may not be distributed. ** You may use this file in accordance with the terms and conditions ** contained in the Technology Preview License Agreement accompanying ** this package. ** ** GNU Lesser General Public License Usage ** Alternatively, this file may be used under the terms of the GNU Lesser ** General Public License version 2.1 as published by the Free Software ** Foundation and appearing in the file LICENSE.LGPL included in the ** packaging of this file. Please review the following information to ** ensure the GNU Lesser General Public License version 2.1 requirements ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. ** ** In addition, as a special exception, Nokia gives you certain ** additional rights. These rights are described in the Nokia Qt LGPL ** Exception version 1.1, included in the file LGPL_EXCEPTION.txt in this ** package. ** ** If you have questions regarding the use of this file, please contact ** Nokia at qt-info@nokia.com. ** ** ** ** ** ** ** ** ** $QT_END_LICENSE$ ** ****************************************************************************/ #include "qplatformdefs.h" #include "qsvghandler_p.h" #ifndef QT_NO_SVG #include "qsvgtinydocument_p.h" #include "qsvgstructure_p.h" #include "qsvggraphics_p.h" #include "qsvgnode_p.h" #include "qsvgfont_p.h" #include "qapplication.h" #include "qwidget.h" #include "qpen.h" #include "qpainterpath.h" #include "qbrush.h" #include "qcolor.h" #include "qtextformat.h" #include "qvector.h" #include "qfileinfo.h" #include "qfile.h" #include "qdebug.h" #include "qmath.h" #include "qnumeric.h" #include "qvarlengtharray.h" #include "private/qmath_p.h" #include "float.h" QT_BEGIN_NAMESPACE static const char *qt_inherit_text = "inherit"; #define QT_INHERIT QLatin1String(qt_inherit_text) double qstrtod(const char *s00, char const **se, bool *ok); // ======== duplicated from qcolor_p static inline int qsvg_h2i(char hex) { if (hex >= '0' && hex <= '9') return hex - '0'; if (hex >= 'a' && hex <= 'f') return hex - 'a' + 10; if (hex >= 'A' && hex <= 'F') return hex - 'A' + 10; return -1; } static inline int qsvg_hex2int(const char *s) { return (qsvg_h2i(s[0]) << 4) | qsvg_h2i(s[1]); } static inline int qsvg_hex2int(char s) { int h = qsvg_h2i(s); return (h << 4) | h; } bool qsvg_get_hex_rgb(const char *name, QRgb *rgb) { if(name[0] != '#') return false; name++; int len = qstrlen(name); int r, g, b; if (len == 12) { r = qsvg_hex2int(name); g = qsvg_hex2int(name + 4); b = qsvg_hex2int(name + 8); } else if (len == 9) { r = qsvg_hex2int(name); g = qsvg_hex2int(name + 3); b = qsvg_hex2int(name + 6); } else if (len == 6) { r = qsvg_hex2int(name); g = qsvg_hex2int(name + 2); b = qsvg_hex2int(name + 4); } else if (len == 3) { r = qsvg_hex2int(name[0]); g = qsvg_hex2int(name[1]); b = qsvg_hex2int(name[2]); } else { r = g = b = -1; } if ((uint)r > 255 || (uint)g > 255 || (uint)b > 255) { *rgb = 0; return false; } *rgb = qRgb(r, g ,b); return true; } bool qsvg_get_hex_rgb(const QChar *str, int len, QRgb *rgb) { if (len > 13) return false; char tmp[16]; for(int i = 0; i < len; ++i) tmp[i] = str[i].toLatin1(); tmp[len] = 0; return qsvg_get_hex_rgb(tmp, rgb); } // ======== end of qcolor_p duplicate static bool parsePathDataFast(const QStringRef &data, QPainterPath &path); static inline QString someId(const QXmlStreamAttributes &attributes) { QString id = attributes.value(QLatin1String("id")).toString(); if (id.isEmpty()) id = attributes.value(QLatin1String("xml:id")).toString(); return id; } struct QSvgAttributes { QSvgAttributes(const QXmlStreamAttributes &xmlAttributes, QSvgHandler *handler); QString id; QStringRef color; QStringRef colorOpacity; QStringRef fill; QStringRef fillRule; QStringRef fillOpacity; QStringRef stroke; QStringRef strokeDashArray; QStringRef strokeDashOffset; QStringRef strokeLineCap; QStringRef strokeLineJoin; QStringRef strokeMiterLimit; QStringRef strokeOpacity; QStringRef strokeWidth; QStringRef vectorEffect; QStringRef fontFamily; QStringRef fontSize; QStringRef fontStyle; QStringRef fontWeight; QStringRef fontVariant; QStringRef textAnchor; QStringRef transform; QStringRef visibility; QStringRef opacity; QStringRef compOp; QStringRef display; QStringRef offset; QStringRef stopColor; QStringRef stopOpacity; QVector m_cssAttributes; }; QSvgAttributes::QSvgAttributes(const QXmlStreamAttributes &xmlAttributes, QSvgHandler *handler) { QStringRef style = xmlAttributes.value(QLatin1String("style")); if (!style.isEmpty()) { handler->parseCSStoXMLAttrs(style.toString(), &m_cssAttributes); for (int j = 0; j < m_cssAttributes.count(); ++j) { const QSvgCssAttribute &attribute = m_cssAttributes.at(j); QStringRef name = attribute.name; QStringRef value = attribute.value; if (name.isEmpty()) continue; switch (name.at(0).unicode()) { case 'c': if (name == QLatin1String("color")) color = value; else if (name == QLatin1String("color-opacity")) colorOpacity = value; else if (name == QLatin1String("comp-op")) compOp = value; break; case 'd': if (name == QLatin1String("display")) display = value; break; case 'f': if (name == QLatin1String("fill")) fill = value; else if (name == QLatin1String("fill-rule")) fillRule = value; else if (name == QLatin1String("fill-opacity")) fillOpacity = value; else if (name == QLatin1String("font-family")) fontFamily = value; else if (name == QLatin1String("font-size")) fontSize = value; else if (name == QLatin1String("font-style")) fontStyle = value; else if (name == QLatin1String("font-weight")) fontWeight = value; else if (name == QLatin1String("font-variant")) fontVariant = value; break; case 'o': if (name == QLatin1String("opacity")) opacity = value; else if (name == QLatin1String("offset")) offset = value; break; case 's': if (name.length() > 5 && QStringRef(name.string(), name.position() + 1, 5) == QLatin1String("troke")) { QStringRef strokeRef(name.string(), name.position() + 6, name.length() - 6); if (strokeRef.isEmpty()) stroke = value; else if (strokeRef == QLatin1String("-dasharray")) strokeDashArray = value; else if (strokeRef == QLatin1String("-dashoffset")) strokeDashOffset = value; else if (strokeRef == QLatin1String("-linecap")) strokeLineCap = value; else if (strokeRef == QLatin1String("-linejoin")) strokeLineJoin = value; else if (strokeRef == QLatin1String("-miterlimit")) strokeMiterLimit = value; else if (strokeRef == QLatin1String("-opacity")) strokeOpacity = value; else if (strokeRef == QLatin1String("-width")) strokeWidth = value; } else if (name == QLatin1String("stop-color")) stopColor = value; else if (name == QLatin1String("stop-opacity")) stopOpacity = value; break; case 't': if (name == QLatin1String("text-anchor")) textAnchor = value; else if (name == QLatin1String("transform")) transform = value; break; case 'v': if (name == QLatin1String("vector-effect")) vectorEffect = value; else if (name == QLatin1String("visibility")) visibility = value; break; default: break; } } } for (int i = 0; i < xmlAttributes.count(); ++i) { const QXmlStreamAttribute &attribute = xmlAttributes.at(i); QStringRef name = attribute.qualifiedName(); if (name.isEmpty()) continue; QStringRef value = attribute.value(); switch (name.at(0).unicode()) { case 'c': if (name == QLatin1String("color")) color = value; else if (name == QLatin1String("color-opacity")) colorOpacity = value; else if (name == QLatin1String("comp-op")) compOp = value; break; case 'd': if (name == QLatin1String("display")) display = value; break; case 'f': if (name == QLatin1String("fill")) fill = value; else if (name == QLatin1String("fill-rule")) fillRule = value; else if (name == QLatin1String("fill-opacity")) fillOpacity = value; else if (name == QLatin1String("font-family")) fontFamily = value; else if (name == QLatin1String("font-size")) fontSize = value; else if (name == QLatin1String("font-style")) fontStyle = value; else if (name == QLatin1String("font-weight")) fontWeight = value; else if (name == QLatin1String("font-variant")) fontVariant = value; break; case 'i': if (name == QLatin1String("id")) id = value.toString(); break; case 'o': if (name == QLatin1String("opacity")) opacity = value; if (name == QLatin1String("offset")) offset = value; break; case 's': if (name.length() > 5 && QStringRef(name.string(), name.position() + 1, 5) == QLatin1String("troke")) { QStringRef strokeRef(name.string(), name.position() + 6, name.length() - 6); if (strokeRef.isEmpty()) stroke = value; else if (strokeRef == QLatin1String("-dasharray")) strokeDashArray = value; else if (strokeRef == QLatin1String("-dashoffset")) strokeDashOffset = value; else if (strokeRef == QLatin1String("-linecap")) strokeLineCap = value; else if (strokeRef == QLatin1String("-linejoin")) strokeLineJoin = value; else if (strokeRef == QLatin1String("-miterlimit")) strokeMiterLimit = value; else if (strokeRef == QLatin1String("-opacity")) strokeOpacity = value; else if (strokeRef == QLatin1String("-width")) strokeWidth = value; } else if (name == QLatin1String("stop-color")) stopColor = value; else if (name == QLatin1String("stop-opacity")) stopOpacity = value; break; case 't': if (name == QLatin1String("text-anchor")) textAnchor = value; else if (name == QLatin1String("transform")) transform = value; break; case 'v': if (name == QLatin1String("vector-effect")) vectorEffect = value; else if (name == QLatin1String("visibility")) visibility = value; break; case 'x': if (name == QLatin1String("xml:id") && id.isEmpty()) id = value.toString(); break; default: break; } } } static const char * QSvgStyleSelector_nodeString[] = { "svg", "g", "defs", "switch", "animation", "arc", "circle", "ellipse", "image", "line", "path", "polygon", "polyline", "rect", "text", "textarea", "use", "video" }; class QSvgStyleSelector : public QCss::StyleSelector { public: QSvgStyleSelector() { nameCaseSensitivity = Qt::CaseInsensitive; } virtual ~QSvgStyleSelector() { } inline QString nodeToName(QSvgNode *node) const { return QLatin1String(QSvgStyleSelector_nodeString[node->type()]); } inline QSvgNode *svgNode(NodePtr node) const { return (QSvgNode*)node.ptr; } inline QSvgStructureNode *nodeToStructure(QSvgNode *n) const { if (n && (n->type() == QSvgNode::DOC || n->type() == QSvgNode::G || n->type() == QSvgNode::DEFS || n->type() == QSvgNode::SWITCH)) { return (QSvgStructureNode*)n; } return 0; } inline QSvgStructureNode *svgStructure(NodePtr node) const { QSvgNode *n = svgNode(node); QSvgStructureNode *st = nodeToStructure(n); return st; } virtual bool nodeNameEquals(NodePtr node, const QString& nodeName) const { QSvgNode *n = svgNode(node); if (!n) return false; QString name = nodeToName(n); return QString::compare(name, nodeName, Qt::CaseInsensitive) == 0; } virtual QString attribute(NodePtr node, const QString &name) const { QSvgNode *n = svgNode(node); if ((!n->nodeId().isEmpty() && (name == QLatin1String("id") || name == QLatin1String("xml:id")))) return n->nodeId(); if (!n->xmlClass().isEmpty() && name == QLatin1String("class")) return n->xmlClass(); return QString(); } virtual bool hasAttributes(NodePtr node) const { QSvgNode *n = svgNode(node); return (n && (!n->nodeId().isEmpty() || !n->xmlClass().isEmpty())); } virtual QStringList nodeIds(NodePtr node) const { QSvgNode *n = svgNode(node); QString nid; if (n) nid = n->nodeId(); QStringList lst; lst.append(nid); return lst; } virtual QStringList nodeNames(NodePtr node) const { QSvgNode *n = svgNode(node); if (n) return QStringList(nodeToName(n)); return QStringList(); } virtual bool isNullNode(NodePtr node) const { return !node.ptr; } virtual NodePtr parentNode(NodePtr node) const { QSvgNode *n = svgNode(node); NodePtr newNode; newNode.ptr = 0; newNode.id = 0; if (n) { QSvgNode *svgParent = n->parent(); if (svgParent) { newNode.ptr = svgParent; } } return newNode; } virtual NodePtr previousSiblingNode(NodePtr node) const { NodePtr newNode; newNode.ptr = 0; newNode.id = 0; QSvgNode *n = svgNode(node); if (!n) return newNode; QSvgStructureNode *svgParent = nodeToStructure(n->parent()); if (svgParent) { newNode.ptr = svgParent->previousSiblingNode(n); } return newNode; } virtual NodePtr duplicateNode(NodePtr node) const { NodePtr n; n.ptr = node.ptr; n.id = node.id; return n; } virtual void freeNode(NodePtr node) const { Q_UNUSED(node); } }; // '0' is 0x30 and '9' is 0x39 static inline bool isDigit(ushort ch) { static quint16 magic = 0x3ff; return ((ch >> 4) == 3) && (magic >> (ch & 15)); } static qreal toDouble(const QChar *&str) { const int maxLen = 255;//technically doubles can go til 308+ but whatever char temp[maxLen+1]; int pos = 0; if (*str == QLatin1Char('-')) { temp[pos++] = '-'; ++str; } else if (*str == QLatin1Char('+')) { ++str; } while (isDigit(str->unicode()) && pos < maxLen) { temp[pos++] = str->toLatin1(); ++str; } if (*str == QLatin1Char('.') && pos < maxLen) { temp[pos++] = '.'; ++str; } while (isDigit(str->unicode()) && pos < maxLen) { temp[pos++] = str->toLatin1(); ++str; } bool exponent = false; if (*str == QLatin1Char('e') && pos < maxLen) { exponent = true; temp[pos++] = 'e'; ++str; if ((*str == QLatin1Char('-') || *str == QLatin1Char('+')) && pos < maxLen) { temp[pos++] = str->toLatin1(); ++str; } while (isDigit(str->unicode()) && pos < maxLen) { temp[pos++] = str->toLatin1(); ++str; } } temp[pos] = '\0'; qreal val; if (!exponent && pos < 10) { int ival = 0; const char *t = temp; bool neg = false; if(*t == '-') { neg = true; ++t; } while(*t && *t != '.') { ival *= 10; ival += (*t) - '0'; ++t; } if(*t == '.') { ++t; int div = 1; while(*t) { ival *= 10; ival += (*t) - '0'; div *= 10; ++t; } val = ((qreal)ival)/((qreal)div); } else { val = ival; } if (neg) val = -val; } else { #if defined(Q_WS_QWS) && !defined(Q_OS_VXWORKS) if(sizeof(qreal) == sizeof(float)) val = strtof(temp, 0); else #endif { bool ok = false; val = qstrtod(temp, 0, &ok); } } return val; } static qreal toDouble(const QString &str, bool *ok = NULL) { const QChar *c = str.constData(); qreal res = toDouble(c); if (ok) { *ok = ((*c) == QLatin1Char('\0')); } return res; } static qreal toDouble(const QStringRef &str, bool *ok = NULL) { const QChar *c = str.constData(); qreal res = toDouble(c); if (ok) { *ok = (c == (str.constData() + str.length())); } return res; } static QVector parseNumbersList(const QChar *&str) { QVector points; if (!str) return points; points.reserve(32); while (*str == QLatin1Char(' ')) ++str; while (isDigit(str->unicode()) || *str == QLatin1Char('-') || *str == QLatin1Char('+') || *str == QLatin1Char('.')) { points.append(toDouble(str)); while (*str == QLatin1Char(' ')) ++str; if (*str == QLatin1Char(',')) ++str; //eat the rest of space while (*str == QLatin1Char(' ')) ++str; } return points; } static inline void parseNumbersArray(const QChar *&str, QVarLengthArray &points) { while (*str == QLatin1Char(' ')) ++str; while (isDigit(str->unicode()) || *str == QLatin1Char('-') || *str == QLatin1Char('+') || *str == QLatin1Char('.')) { points.append(toDouble(str)); while (*str == QLatin1Char(' ')) ++str; if (*str == QLatin1Char(',')) ++str; //eat the rest of space while (*str == QLatin1Char(' ')) ++str; } } static QVector parsePercentageList(const QChar *&str) { QVector points; if (!str) return points; while (str->isSpace()) ++str; while ((*str >= QLatin1Char('0') && *str <= QLatin1Char('9')) || *str == QLatin1Char('-') || *str == QLatin1Char('+') || *str == QLatin1Char('.')) { points.append(toDouble(str)); while (*str == QLatin1Char(' ')) ++str; if (*str == QLatin1Char('%')) ++str; while (*str == QLatin1Char(' ')) ++str; if (*str == QLatin1Char(',')) ++str; //eat the rest of space while (*str == QLatin1Char(' ')) ++str; } return points; } static QString idFromUrl(const QString &url) { QString::const_iterator itr = url.constBegin(); while ((*itr).isSpace()) ++itr; if ((*itr) == QLatin1Char('(')) ++itr; while ((*itr).isSpace()) ++itr; if ((*itr) == QLatin1Char('#')) ++itr; QString id; while ((*itr) != QLatin1Char(')')) { id += *itr; ++itr; } return id; } static inline QStringRef trimRef(const QStringRef &str) { if (str.isEmpty()) return QStringRef(); const QChar *s = str.string()->constData() + str.position(); int end = str.length() - 1; if (!s[0].isSpace() && !s[end].isSpace()) return str; int start = 0; while (start<=end && s[start].isSpace()) // skip white space from start start++; if (start <= end) { // only white space while (s[end].isSpace()) // skip white space from end end--; } int l = end - start + 1; if (l <= 0) return QStringRef(); return QStringRef(str.string(), str.position() + start, l); } /** * returns true when successfuly set the color. false signifies * that the color should be inherited */ static bool resolveColor(const QStringRef &colorStr, QColor &color, QSvgHandler *handler) { QStringRef colorStrTr = trimRef(colorStr); if (colorStrTr.isEmpty()) return false; switch(colorStrTr.at(0).unicode()) { case '#': { // #rrggbb is very very common, so let's tackle it here // rather than falling back to QColor QRgb rgb; bool ok = qsvg_get_hex_rgb(colorStrTr.unicode(), colorStrTr.length(), &rgb); if (ok) color.setRgb(rgb); return ok; } break; case 'r': { // starts with "rgb(", ends with ")" and consists of at least 7 characters "rgb(,,)" if (colorStrTr.length() >= 7 && colorStrTr.at(colorStrTr.length() - 1) == QLatin1Char(')') && QStringRef(colorStrTr.string(), colorStrTr.position(), 4) == QLatin1String("rgb(")) { const QChar *s = colorStrTr.constData() + 4; QVector compo = parseNumbersList(s); //1 means that it failed after reaching non-parsable //character which is going to be "%" if (compo.size() == 1) { s = colorStrTr.constData() + 4; compo = parsePercentageList(s); for (int i = 0; i < compo.size(); ++i) compo[i] *= (qreal)2.55; } if (compo.size() == 3) { color = QColor(int(compo[0]), int(compo[1]), int(compo[2])); return true; } return false; } } break; case 'c': if (colorStrTr == QLatin1String("currentColor")) { color = handler->currentColor(); return true; } break; case 'i': if (colorStrTr == QT_INHERIT) return false; break; default: break; } color = QColor(colorStrTr.toString()); return color.isValid(); } static bool constructColor(const QStringRef &colorStr, const QStringRef &opacity, QColor &color, QSvgHandler *handler) { if (!resolveColor(colorStr, color, handler)) return false; if (!opacity.isEmpty()) { bool ok = true; qreal op = qMin(qreal(1.0), qMax(qreal(0.0), toDouble(opacity, &ok))); if (!ok) op = 1.0; color.setAlphaF(op); } return true; } static qreal parseLength(const QString &str, QSvgHandler::LengthType &type, QSvgHandler *handler, bool *ok = NULL) { QString numStr = str.trimmed(); if (numStr.endsWith(QLatin1Char('%'))) { numStr.chop(1); type = QSvgHandler::LT_PERCENT; } else if (numStr.endsWith(QLatin1String("px"))) { numStr.chop(2); type = QSvgHandler::LT_PX; } else if (numStr.endsWith(QLatin1String("pc"))) { numStr.chop(2); type = QSvgHandler::LT_PC; } else if (numStr.endsWith(QLatin1String("pt"))) { numStr.chop(2); type = QSvgHandler::LT_PT; } else if (numStr.endsWith(QLatin1String("mm"))) { numStr.chop(2); type = QSvgHandler::LT_MM; } else if (numStr.endsWith(QLatin1String("cm"))) { numStr.chop(2); type = QSvgHandler::LT_CM; } else if (numStr.endsWith(QLatin1String("in"))) { numStr.chop(2); type = QSvgHandler::LT_IN; } else { type = handler->defaultCoordinateSystem(); //type = QSvgHandler::LT_OTHER; } qreal len = toDouble(numStr, ok); //qDebug()<<"len is "<addGlyph(unicode, path, havx); return true; } // this should really be called convertToDefaultCoordinateSystem // and convert when type != QSvgHandler::defaultCoordinateSystem static qreal convertToPixels(qreal len, bool , QSvgHandler::LengthType type) { switch (type) { case QSvgHandler::LT_PERCENT: break; case QSvgHandler::LT_PX: break; case QSvgHandler::LT_PC: break; case QSvgHandler::LT_PT: return len * 1.25; break; case QSvgHandler::LT_MM: return len * 3.543307; break; case QSvgHandler::LT_CM: return len * 35.43307; break; case QSvgHandler::LT_IN: return len * 90; break; case QSvgHandler::LT_OTHER: break; default: break; } return len; } static void parseColor(QSvgNode *, const QSvgAttributes &attributes, QSvgHandler *handler) { QColor color; if (constructColor(attributes.color, attributes.colorOpacity, color, handler)) { handler->pushColor(color); } } static QSvgStyleProperty *styleFromUrl(QSvgNode *node, const QString &url) { while (node && (node->type() != QSvgNode::DOC && node->type() != QSvgNode::G && node->type() != QSvgNode::DEFS && node->type() != QSvgNode::SWITCH)) { node = node->parent(); } if (!node) return 0; return static_cast(node)->scopeStyle(idFromUrl(url)); } static void parseBrush(QSvgNode *node, const QSvgAttributes &attributes, QSvgHandler *handler) { if (!attributes.fill.isEmpty() || !attributes.fillRule.isEmpty() || !attributes.fillOpacity.isEmpty()) { QSvgFillStyle *prop = new QSvgFillStyle; //fill-rule attribute handling if (!attributes.fillRule.isEmpty() && attributes.fillRule != QT_INHERIT) { if (attributes.fillRule == QLatin1String("evenodd")) prop->setFillRule(Qt::OddEvenFill); else if (attributes.fillRule == QLatin1String("nonzero")) prop->setFillRule(Qt::WindingFill); } //fill-opacity atttribute handling if (!attributes.fillOpacity.isEmpty() && attributes.fillOpacity != QT_INHERIT) { prop->setFillOpacity(qMin(qreal(1.0), qMax(qreal(0.0), toDouble(attributes.fillOpacity)))); } //fill attribute handling if ((!attributes.fill.isEmpty()) && (attributes.fill != QT_INHERIT) ) { if (attributes.fill.length() > 3 && QStringRef(attributes.fill.string(), attributes.fill.position(), 3) == QLatin1String("url")) { QStringRef urlRef(attributes.fill.string(), attributes.fill.position() + 3, attributes.fill.length() - 3); QString value = urlRef.toString(); QSvgStyleProperty *style = styleFromUrl(node, value); if (style) { if (style->type() == QSvgStyleProperty::SOLID_COLOR || style->type() == QSvgStyleProperty::GRADIENT) prop->setFillStyle(reinterpret_cast(style)); } else { QString id = idFromUrl(value); prop->setGradientId(id); prop->setGradientResolved(false); } } else if (attributes.fill != QLatin1String("none")) { QColor color; if (resolveColor(attributes.fill, color, handler)) prop->setBrush(QBrush(color)); } else { prop->setBrush(QBrush(Qt::NoBrush)); } } node->appendStyleProperty(prop, attributes.id); } } static QMatrix parseTransformationMatrix(const QStringRef &value) { if (value.isEmpty()) return QMatrix(); QMatrix matrix; const QChar *str = value.constData(); const QChar *end = str + value.length(); while (str < end) { if (str->isSpace() || *str == QLatin1Char(',')) { ++str; continue; } enum State { Matrix, Translate, Rotate, Scale, SkewX, SkewY }; State state = Matrix; if (*str == QLatin1Char('m')) { //matrix const char *ident = "atrix"; for (int i = 0; i < 5; ++i) if (*(++str) != QLatin1Char(ident[i])) goto error; ++str; state = Matrix; } else if (*str == QLatin1Char('t')) { //translate const char *ident = "ranslate"; for (int i = 0; i < 8; ++i) if (*(++str) != QLatin1Char(ident[i])) goto error; ++str; state = Translate; } else if (*str == QLatin1Char('r')) { //rotate const char *ident = "otate"; for (int i = 0; i < 5; ++i) if (*(++str) != QLatin1Char(ident[i])) goto error; ++str; state = Rotate; } else if (*str == QLatin1Char('s')) { //scale, skewX, skewY ++str; if (*str == QLatin1Char('c')) { const char *ident = "ale"; for (int i = 0; i < 3; ++i) if (*(++str) != QLatin1Char(ident[i])) goto error; ++str; state = Scale; } else if (*str == QLatin1Char('k')) { if (*(++str) != QLatin1Char('e')) goto error; if (*(++str) != QLatin1Char('w')) goto error; ++str; if (*str == QLatin1Char('X')) state = SkewX; else if (*str == QLatin1Char('Y')) state = SkewY; else goto error; ++str; } else { goto error; } } else { goto error; } while (str < end && str->isSpace()) ++str; if (*str != QLatin1Char('(')) goto error; ++str; QVarLengthArray points; parseNumbersArray(str, points); if (*str != QLatin1Char(')')) goto error; ++str; if(state == Matrix) { if(points.count() != 6) goto error; matrix = matrix * QMatrix(points[0], points[1], points[2], points[3], points[4], points[5]); } else if (state == Translate) { if (points.count() == 1) matrix.translate(points[0], 0); else if (points.count() == 2) matrix.translate(points[0], points[1]); else goto error; } else if (state == Rotate) { if(points.count() == 1) { matrix.rotate(points[0]); } else if (points.count() == 3) { matrix.translate(points[1], points[2]); matrix.rotate(points[0]); matrix.translate(-points[1], -points[2]); } else { goto error; } } else if (state == Scale) { if (points.count() < 1 || points.count() > 2) goto error; qreal sx = points[0]; qreal sy = sx; if(points.count() == 2) sy = points[1]; matrix.scale(sx, sy); } else if (state == SkewX) { if (points.count() != 1) goto error; const qreal deg2rad = qreal(0.017453292519943295769); matrix.shear(tan(points[0]*deg2rad), 0); } else if (state == SkewY) { if (points.count() != 1) goto error; const qreal deg2rad = qreal(0.017453292519943295769); matrix.shear(0, tan(points[0]*deg2rad)); } } error: return matrix; } static void parsePen(QSvgNode *node, const QSvgAttributes &attributes, QSvgHandler *handler) { //qDebug()<<"Node "<type()<<", attrs are "< 3 && QStringRef(attributes.stroke.string(), attributes.stroke.position(), 3) == QLatin1String("url")) { QStringRef urlRef(attributes.stroke.string(), attributes.stroke.position() + 3, attributes.stroke.length() - 3); QString value = urlRef.toString(); QSvgStyleProperty *style = styleFromUrl(node, value); if (style) { if (style->type() == QSvgStyleProperty::SOLID_COLOR || style->type() == QSvgStyleProperty::GRADIENT) prop->setStyle(reinterpret_cast(style)); } else { QString id = idFromUrl(value); prop->setGradientId(id); prop->setGradientResolved(false); } } else if (attributes.stroke != QLatin1String("none")) { QColor color; if (resolveColor(attributes.stroke, color, handler)) prop->setStroke(QBrush(color)); } else { prop->setStroke(QBrush(Qt::NoBrush)); } } //stroke-width handling if (!attributes.strokeWidth.isEmpty() && attributes.strokeWidth != QT_INHERIT) { QSvgHandler::LengthType lt; prop->setWidth(parseLength(attributes.strokeWidth.toString(), lt, handler)); } //stroke-dasharray if (!attributes.strokeDashArray.isEmpty() && attributes.strokeDashArray != QT_INHERIT) { if (attributes.strokeDashArray == QLatin1String("none")) { prop->setDashArrayNone(); } else { QString dashArray = attributes.strokeDashArray.toString(); const QChar *s = dashArray.constData(); QVector dashes = parseNumbersList(s); // if the dash count is odd the dashes should be duplicated if ((dashes.size() & 1) != 0) dashes << QVector(dashes); prop->setDashArray(dashes); } } //stroke-linejoin attribute handling if (!attributes.strokeLineJoin.isEmpty()) { if (attributes.strokeLineJoin == QLatin1String("miter")) prop->setLineJoin(Qt::SvgMiterJoin); else if (attributes.strokeLineJoin == QLatin1String("round")) prop->setLineJoin(Qt::RoundJoin); else if (attributes.strokeLineJoin == QLatin1String("bevel")) prop->setLineJoin(Qt::BevelJoin); } //stroke-linecap attribute handling if (!attributes.strokeLineCap.isEmpty()) { if (attributes.strokeLineCap == QLatin1String("butt")) prop->setLineCap(Qt::FlatCap); else if (attributes.strokeLineCap == QLatin1String("round")) prop->setLineCap(Qt::RoundCap); else if (attributes.strokeLineCap == QLatin1String("square")) prop->setLineCap(Qt::SquareCap); } //stroke-dashoffset attribute handling if (!attributes.strokeDashOffset.isEmpty() && attributes.strokeDashOffset != QT_INHERIT) prop->setDashOffset(toDouble(attributes.strokeDashOffset)); //vector-effect attribute handling if (!attributes.vectorEffect.isEmpty()) { if (attributes.vectorEffect == QLatin1String("non-scaling-stroke")) prop->setVectorEffect(true); else if (attributes.vectorEffect == QLatin1String("none")) prop->setVectorEffect(false); } //stroke-miterlimit if (!attributes.strokeMiterLimit.isEmpty() && attributes.strokeMiterLimit != QT_INHERIT) prop->setMiterLimit(toDouble(attributes.strokeMiterLimit)); //stroke-opacity atttribute handling if (!attributes.strokeOpacity.isEmpty() && attributes.strokeOpacity != QT_INHERIT) prop->setOpacity(qMin(qreal(1.0), qMax(qreal(0.0), toDouble(attributes.strokeOpacity)))); node->appendStyleProperty(prop, attributes.id); } } static void parseFont(QSvgNode *node, const QSvgAttributes &attributes, QSvgHandler *handler) { if (attributes.fontFamily.isEmpty() && attributes.fontSize.isEmpty() && attributes.fontStyle.isEmpty() && attributes.fontWeight.isEmpty() && attributes.fontVariant.isEmpty() && attributes.textAnchor.isEmpty()) return; QSvgTinyDocument *doc = node->document(); QSvgFontStyle *fontStyle = 0; if (!attributes.fontFamily.isEmpty()) { QSvgFont *svgFont = doc->svgFont(attributes.fontFamily.toString()); if (svgFont) fontStyle = new QSvgFontStyle(svgFont, doc); } if (!fontStyle) fontStyle = new QSvgFontStyle; if (!attributes.fontFamily.isEmpty() && attributes.fontFamily != QT_INHERIT) fontStyle->setFamily(attributes.fontFamily.toString().trimmed()); if (!attributes.fontSize.isEmpty() && attributes.fontSize != QT_INHERIT) { QSvgHandler::LengthType dummy; // should always be pixel size fontStyle->setSize(parseLength(attributes.fontSize.toString(), dummy, handler)); } if (!attributes.fontStyle.isEmpty() && attributes.fontStyle != QT_INHERIT) { if (attributes.fontStyle == QLatin1String("normal")) { fontStyle->setStyle(QFont::StyleNormal); } else if (attributes.fontStyle == QLatin1String("italic")) { fontStyle->setStyle(QFont::StyleItalic); } else if (attributes.fontStyle == QLatin1String("oblique")) { fontStyle->setStyle(QFont::StyleOblique); } } if (!attributes.fontWeight.isEmpty() && attributes.fontWeight != QT_INHERIT) { bool ok = false; int weightNum = attributes.fontWeight.toString().toInt(&ok); if (ok) { fontStyle->setWeight(weightNum); } else { if (attributes.fontWeight == QLatin1String("normal")) { fontStyle->setWeight(400); } else if (attributes.fontWeight == QLatin1String("bold")) { fontStyle->setWeight(700); } else if (attributes.fontWeight == QLatin1String("bolder")) { fontStyle->setWeight(QSvgFontStyle::BOLDER); } else if (attributes.fontWeight == QLatin1String("lighter")) { fontStyle->setWeight(QSvgFontStyle::LIGHTER); } } } if (!attributes.fontVariant.isEmpty() && attributes.fontVariant != QT_INHERIT) { if (attributes.fontVariant == QLatin1String("normal")) fontStyle->setVariant(QFont::MixedCase); else if (attributes.fontVariant == QLatin1String("small-caps")) fontStyle->setVariant(QFont::SmallCaps); } if (!attributes.textAnchor.isEmpty() && attributes.textAnchor != QT_INHERIT) { if (attributes.textAnchor == QLatin1String("start")) fontStyle->setTextAnchor(Qt::AlignLeft); if (attributes.textAnchor == QLatin1String("middle")) fontStyle->setTextAnchor(Qt::AlignHCenter); else if (attributes.textAnchor == QLatin1String("end")) fontStyle->setTextAnchor(Qt::AlignRight); } node->appendStyleProperty(fontStyle, attributes.id); } static void parseTransform(QSvgNode *node, const QSvgAttributes &attributes, QSvgHandler *) { if (attributes.transform.isEmpty()) return; QMatrix matrix = parseTransformationMatrix(trimRef(attributes.transform)); if (!matrix.isIdentity()) { node->appendStyleProperty(new QSvgTransformStyle(QTransform(matrix)), attributes.id); } } static void parseVisibility(QSvgNode *node, const QSvgAttributes &attributes, QSvgHandler *) { QSvgNode *parent = node->parent(); if (parent && (attributes.visibility.isEmpty() || attributes.visibility == QT_INHERIT)) node->setVisible(parent->isVisible()); else if (attributes.visibility == QLatin1String("hidden") || attributes.visibility == QLatin1String("collapse")) { node->setVisible(false); } else node->setVisible(true); } static void pathArcSegment(QPainterPath &path, qreal xc, qreal yc, qreal th0, qreal th1, qreal rx, qreal ry, qreal xAxisRotation) { qreal sinTh, cosTh; qreal a00, a01, a10, a11; qreal x1, y1, x2, y2, x3, y3; qreal t; qreal thHalf; sinTh = qSin(xAxisRotation * (Q_PI / 180.0)); cosTh = qCos(xAxisRotation * (Q_PI / 180.0)); a00 = cosTh * rx; a01 = -sinTh * ry; a10 = sinTh * rx; a11 = cosTh * ry; thHalf = 0.5 * (th1 - th0); t = (8.0 / 3.0) * qSin(thHalf * 0.5) * qSin(thHalf * 0.5) / qSin(thHalf); x1 = xc + qCos(th0) - t * qSin(th0); y1 = yc + qSin(th0) + t * qCos(th0); x3 = xc + qCos(th1); y3 = yc + qSin(th1); x2 = x3 + t * qSin(th1); y2 = y3 - t * qCos(th1); path.cubicTo(a00 * x1 + a01 * y1, a10 * x1 + a11 * y1, a00 * x2 + a01 * y2, a10 * x2 + a11 * y2, a00 * x3 + a01 * y3, a10 * x3 + a11 * y3); } // the arc handling code underneath is from XSVG (BSD license) /* * Copyright 2002 USC/Information Sciences Institute * * Permission to use, copy, modify, distribute, and sell this software * and its documentation for any purpose is hereby granted without * fee, provided that the above copyright notice appear in all copies * and that both that copyright notice and this permission notice * appear in supporting documentation, and that the name of * Information Sciences Institute not be used in advertising or * publicity pertaining to distribution of the software without * specific, written prior permission. Information Sciences Institute * makes no representations about the suitability of this software for * any purpose. It is provided "as is" without express or implied * warranty. * * INFORMATION SCIENCES INSTITUTE DISCLAIMS ALL WARRANTIES WITH REGARD * TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF * MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL INFORMATION SCIENCES * INSTITUTE BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL * DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA * OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER * TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR * PERFORMANCE OF THIS SOFTWARE. * */ static void pathArc(QPainterPath &path, qreal rx, qreal ry, qreal x_axis_rotation, int large_arc_flag, int sweep_flag, qreal x, qreal y, qreal curx, qreal cury) { qreal sin_th, cos_th; qreal a00, a01, a10, a11; qreal x0, y0, x1, y1, xc, yc; qreal d, sfactor, sfactor_sq; qreal th0, th1, th_arc; int i, n_segs; qreal dx, dy, dx1, dy1, Pr1, Pr2, Px, Py, check; rx = qAbs(rx); ry = qAbs(ry); sin_th = qSin(x_axis_rotation * (Q_PI / 180.0)); cos_th = qCos(x_axis_rotation * (Q_PI / 180.0)); dx = (curx - x) / 2.0; dy = (cury - y) / 2.0; dx1 = cos_th * dx + sin_th * dy; dy1 = -sin_th * dx + cos_th * dy; Pr1 = rx * rx; Pr2 = ry * ry; Px = dx1 * dx1; Py = dy1 * dy1; /* Spec : check if radii are large enough */ check = Px / Pr1 + Py / Pr2; if (check > 1) { rx = rx * qSqrt(check); ry = ry * qSqrt(check); } a00 = cos_th / rx; a01 = sin_th / rx; a10 = -sin_th / ry; a11 = cos_th / ry; x0 = a00 * curx + a01 * cury; y0 = a10 * curx + a11 * cury; x1 = a00 * x + a01 * y; y1 = a10 * x + a11 * y; /* (x0, y0) is current point in transformed coordinate space. (x1, y1) is new point in transformed coordinate space. The arc fits a unit-radius circle in this space. */ d = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0); sfactor_sq = 1.0 / d - 0.25; if (sfactor_sq < 0) sfactor_sq = 0; sfactor = qSqrt(sfactor_sq); if (sweep_flag == large_arc_flag) sfactor = -sfactor; xc = 0.5 * (x0 + x1) - sfactor * (y1 - y0); yc = 0.5 * (y0 + y1) + sfactor * (x1 - x0); /* (xc, yc) is center of the circle. */ th0 = atan2(y0 - yc, x0 - xc); th1 = atan2(y1 - yc, x1 - xc); th_arc = th1 - th0; if (th_arc < 0 && sweep_flag) th_arc += 2 * Q_PI; else if (th_arc > 0 && !sweep_flag) th_arc -= 2 * Q_PI; n_segs = qCeil(qAbs(th_arc / (Q_PI * 0.5 + 0.001))); for (i = 0; i < n_segs; i++) { pathArcSegment(path, xc, yc, th0 + i * th_arc / n_segs, th0 + (i + 1) * th_arc / n_segs, rx, ry, x_axis_rotation); } } static bool parsePathDataFast(const QStringRef &dataStr, QPainterPath &path) { qreal x0 = 0, y0 = 0; // starting point qreal x = 0, y = 0; // current point char lastMode = 0; QPointF ctrlPt; const QChar *str = dataStr.constData(); const QChar *end = str + dataStr.size(); while (str != end) { while (*str == QLatin1Char(' ')) ++str; QChar pathElem = *str; ++str; QChar endc = *end; *const_cast(end) = 0; // parseNumbersArray requires 0-termination that QStringRef cannot guarantee QVarLengthArray arg; parseNumbersArray(str, arg); *const_cast(end) = endc; if (pathElem == QLatin1Char('z') || pathElem == QLatin1Char('Z')) arg.append(0);//dummy const qreal *num = arg.constData(); int count = arg.count(); while (count > 0) { qreal offsetX = x; // correction offsets qreal offsetY = y; // for relative commands switch (pathElem.unicode()) { case 'm': { if (count < 2) { num++; count--; break; } x = x0 = num[0] + offsetX; y = y0 = num[1] + offsetY; num += 2; count -= 2; path.moveTo(x0, y0); // As per 1.2 spec 8.3.2 The "moveto" commands // If a 'moveto' is followed by multiple pairs of coordinates without explicit commands, // the subsequent pairs shall be treated as implicit 'lineto' commands. pathElem = QLatin1Char('l'); } break; case 'M': { if (count < 2) { num++; count--; break; } x = x0 = num[0]; y = y0 = num[1]; num += 2; count -= 2; path.moveTo(x0, y0); // As per 1.2 spec 8.3.2 The "moveto" commands // If a 'moveto' is followed by multiple pairs of coordinates without explicit commands, // the subsequent pairs shall be treated as implicit 'lineto' commands. pathElem = QLatin1Char('L'); } break; case 'z': case 'Z': { x = x0; y = y0; count--; // skip dummy num++; path.closeSubpath(); } break; case 'l': { if (count < 2) { num++; count--; break; } x = x0 = num[0] + offsetX; y = y0 = num[1] + offsetY; num += 2; count -= 2; path.lineTo(x, y); } break; case 'L': { if (count < 2) { num++; count--; break; } x = x0 = num[0]; y = y0 = num[1]; num += 2; count -= 2; path.lineTo(x, y); } break; case 'h': { x = num[0] + offsetX; num++; count--; path.lineTo(x, y); } break; case 'H': { x = num[0]; num++; count--; path.lineTo(x, y); } break; case 'v': { y = num[0] + offsetY; num++; count--; path.lineTo(x, y); } break; case 'V': { y = num[0]; num++; count--; path.lineTo(x, y); } break; case 'c': { if (count < 6) { num += count; count = 0; break; } QPointF c1(num[0] + offsetX, num[1] + offsetY); QPointF c2(num[2] + offsetX, num[3] + offsetY); QPointF e(num[4] + offsetX, num[5] + offsetY); num += 6; count -= 6; path.cubicTo(c1, c2, e); ctrlPt = c2; x = e.x(); y = e.y(); break; } case 'C': { if (count < 6) { num += count; count = 0; break; } QPointF c1(num[0], num[1]); QPointF c2(num[2], num[3]); QPointF e(num[4], num[5]); num += 6; count -= 6; path.cubicTo(c1, c2, e); ctrlPt = c2; x = e.x(); y = e.y(); break; } case 's': { if (count < 4) { num += count; count = 0; break; } QPointF c1; if (lastMode == 'c' || lastMode == 'C' || lastMode == 's' || lastMode == 'S') c1 = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y()); else c1 = QPointF(x, y); QPointF c2(num[0] + offsetX, num[1] + offsetY); QPointF e(num[2] + offsetX, num[3] + offsetY); num += 4; count -= 4; path.cubicTo(c1, c2, e); ctrlPt = c2; x = e.x(); y = e.y(); break; } case 'S': { if (count < 4) { num += count; count = 0; break; } QPointF c1; if (lastMode == 'c' || lastMode == 'C' || lastMode == 's' || lastMode == 'S') c1 = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y()); else c1 = QPointF(x, y); QPointF c2(num[0], num[1]); QPointF e(num[2], num[3]); num += 4; count -= 4; path.cubicTo(c1, c2, e); ctrlPt = c2; x = e.x(); y = e.y(); break; } case 'q': { if (count < 4) { num += count; count = 0; break; } QPointF c(num[0] + offsetX, num[1] + offsetY); QPointF e(num[2] + offsetX, num[3] + offsetY); num += 4; count -= 4; path.quadTo(c, e); ctrlPt = c; x = e.x(); y = e.y(); break; } case 'Q': { if (count < 4) { num += count; count = 0; break; } QPointF c(num[0], num[1]); QPointF e(num[2], num[3]); num += 4; count -= 4; path.quadTo(c, e); ctrlPt = c; x = e.x(); y = e.y(); break; } case 't': { if (count < 2) { num += count; count = 0; break; } QPointF e(num[0] + offsetX, num[1] + offsetY); num += 2; count -= 2; QPointF c; if (lastMode == 'q' || lastMode == 'Q' || lastMode == 't' || lastMode == 'T') c = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y()); else c = QPointF(x, y); path.quadTo(c, e); ctrlPt = c; x = e.x(); y = e.y(); break; } case 'T': { if (count < 2) { num += count; count = 0; break; } QPointF e(num[0], num[1]); num += 2; count -= 2; QPointF c; if (lastMode == 'q' || lastMode == 'Q' || lastMode == 't' || lastMode == 'T') c = QPointF(2*x-ctrlPt.x(), 2*y-ctrlPt.y()); else c = QPointF(x, y); path.quadTo(c, e); ctrlPt = c; x = e.x(); y = e.y(); break; } case 'a': { if (count < 7) { num += count; count = 0; break; } qreal rx = (*num++); qreal ry = (*num++); qreal xAxisRotation = (*num++); qreal largeArcFlag = (*num++); qreal sweepFlag = (*num++); qreal ex = (*num++) + offsetX; qreal ey = (*num++) + offsetY; count -= 7; qreal curx = x; qreal cury = y; pathArc(path, rx, ry, xAxisRotation, int(largeArcFlag), int(sweepFlag), ex, ey, curx, cury); x = ex; y = ey; } break; case 'A': { if (count < 7) { num += count; count = 0; break; } qreal rx = (*num++); qreal ry = (*num++); qreal xAxisRotation = (*num++); qreal largeArcFlag = (*num++); qreal sweepFlag = (*num++); qreal ex = (*num++); qreal ey = (*num++); count -= 7; qreal curx = x; qreal cury = y; pathArc(path, rx, ry, xAxisRotation, int(largeArcFlag), int(sweepFlag), ex, ey, curx, cury); x = ex; y = ey; } break; default: return false; } lastMode = pathElem.toLatin1(); } } return true; } static bool parseStyle(QSvgNode *node, const QXmlStreamAttributes &attributes, QSvgHandler *); static bool parseStyle(QSvgNode *node, const QSvgAttributes &attributes, QSvgHandler *); static void parseCSStoXMLAttrs(const QVector &declarations, QXmlStreamAttributes &attributes) { for (int i = 0; i < declarations.count(); ++i) { const QCss::Declaration &decl = declarations.at(i); if (decl.d->property.isEmpty()) continue; QCss::Value val = decl.d->values.first(); QString valueStr; if (decl.d->values.count() != 1) { for (int i=0; ivalues.count(); ++i) { const QString &value = decl.d->values[i].toString(); if (value.isEmpty()) valueStr += QLatin1Char(','); else valueStr += value; } } else { valueStr = val.toString(); } if (val.type == QCss::Value::Uri) { valueStr.prepend(QLatin1String("url(")); valueStr.append(QLatin1Char(')')); } else if (val.type == QCss::Value::Function) { QStringList lst = val.variant.toStringList(); valueStr.append(lst.at(0)); valueStr.append(QLatin1Char('(')); for (int i = 1; i < lst.count(); ++i) { valueStr.append(lst.at(i)); if ((i +1) < lst.count()) valueStr.append(QLatin1Char(',')); } valueStr.append(QLatin1Char(')')); } else if (val.type == QCss::Value::KnownIdentifier) { switch (val.variant.toInt()) { case QCss::Value_None: valueStr = QLatin1String("none"); break; default: break; } } attributes.append(QString(), decl.d->property, valueStr); } } void QSvgHandler::parseCSStoXMLAttrs(QString css, QVector *attributes) { // preprocess (for unicode escapes), tokenize and remove comments m_cssParser.init(css); QString key; attributes->reserve(10); while (m_cssParser.hasNext()) { m_cssParser.skipSpace(); if (!m_cssParser.hasNext()) break; m_cssParser.next(); QStringRef name; if (m_cssParser.hasEscapeSequences) { key = m_cssParser.lexem(); name = QStringRef(&key, 0, key.length()); } else { const QCss::Symbol &sym = m_cssParser.symbol(); name = QStringRef(&sym.text, sym.start, sym.len); } m_cssParser.skipSpace(); if (!m_cssParser.test(QCss::COLON)) break; m_cssParser.skipSpace(); if (!m_cssParser.hasNext()) break; QSvgCssAttribute attribute; attribute.name = QXmlStreamStringRef(name); const int firstSymbol = m_cssParser.index; int symbolCount = 0; do { m_cssParser.next(); ++symbolCount; } while (m_cssParser.hasNext() && !m_cssParser.test(QCss::SEMICOLON)); bool canExtractValueByRef = !m_cssParser.hasEscapeSequences; if (canExtractValueByRef) { int len = m_cssParser.symbols.at(firstSymbol).len; for (int i = firstSymbol + 1; i < firstSymbol + symbolCount; ++i) { len += m_cssParser.symbols.at(i).len; if (m_cssParser.symbols.at(i - 1).start + m_cssParser.symbols.at(i - 1).len != m_cssParser.symbols.at(i).start) { canExtractValueByRef = false; break; } } if (canExtractValueByRef) { const QCss::Symbol &sym = m_cssParser.symbols.at(firstSymbol); attribute.value = QXmlStreamStringRef(QStringRef(&sym.text, sym.start, len)); } } if (!canExtractValueByRef) { QString value; for (int i = firstSymbol; i < m_cssParser.index - 1; ++i) value += m_cssParser.symbols.at(i).lexem(); attribute.value = QXmlStreamStringRef(QStringRef(&value, 0, value.length())); } attributes->append(attribute); m_cssParser.skipSpace(); } } static void cssStyleLookup(QSvgNode *node, QSvgHandler *handler, QSvgStyleSelector *selector) { QCss::StyleSelector::NodePtr cssNode; cssNode.ptr = node; QVector decls = selector->declarationsForNode(cssNode); QXmlStreamAttributes attributes; parseCSStoXMLAttrs(decls, attributes); parseStyle(node, attributes, handler); } static inline QStringList stringToList(const QString &str) { QStringList lst = str.split(QLatin1Char(','), QString::SkipEmptyParts); return lst; } static bool parseCoreNode(QSvgNode *node, const QXmlStreamAttributes &attributes) { QStringList features; QStringList extensions; QStringList languages; QStringList formats; QStringList fonts; QString xmlClassStr; for (int i = 0; i < attributes.count(); ++i) { const QXmlStreamAttribute &attribute = attributes.at(i); QStringRef name = attribute.qualifiedName(); if (name.isEmpty()) continue; QStringRef value = attribute.value(); switch (name.at(0).unicode()) { case 'c': if (name == QLatin1String("class")) xmlClassStr = value.toString(); break; case 'r': if (name == QLatin1String("requiredFeatures")) features = stringToList(value.toString()); else if (name == QLatin1String("requiredExtensions")) extensions = stringToList(value.toString()); else if (name == QLatin1String("requiredFormats")) formats = stringToList(value.toString()); else if (name == QLatin1String("requiredFonts")) fonts = stringToList(value.toString()); break; case 's': if (name == QLatin1String("systemLanguage")) languages = stringToList(value.toString()); break; default: break; } } node->setRequiredFeatures(features); node->setRequiredExtensions(extensions); node->setRequiredLanguages(languages); node->setRequiredFormats(formats); node->setRequiredFonts(fonts); node->setNodeId(someId(attributes)); node->setXmlClass(xmlClassStr); return true; } static void parseOpacity(QSvgNode *node, const QSvgAttributes &attributes, QSvgHandler *) { if (attributes.opacity.isEmpty()) return; const QString value = attributes.opacity.toString().trimmed(); bool ok = false; qreal op = value.toDouble(&ok); if (ok) { QSvgOpacityStyle *opacity = new QSvgOpacityStyle(qBound(qreal(0.0), op, qreal(1.0))); node->appendStyleProperty(opacity, attributes.id); } } static QPainter::CompositionMode svgToQtCompositionMode(const QString &op) { #define NOOP qDebug()<<"Operation: "<appendStyleProperty(compop, attributes.id); } } static inline QSvgNode::DisplayMode displayStringToEnum(const QString &str) { if (str == QLatin1String("inline")) { return QSvgNode::InlineMode; } else if (str == QLatin1String("block")) { return QSvgNode::BlockMode; } else if (str == QLatin1String("list-item")) { return QSvgNode::ListItemMode; } else if (str == QLatin1String("run-in")) { return QSvgNode::RunInMode; } else if (str == QLatin1String("compact")) { return QSvgNode::CompactMode; } else if (str == QLatin1String("marker")) { return QSvgNode::MarkerMode; } else if (str == QLatin1String("table")) { return QSvgNode::TableMode; } else if (str == QLatin1String("inline-table")) { return QSvgNode::InlineTableMode; } else if (str == QLatin1String("table-row")) { return QSvgNode::TableRowGroupMode; } else if (str == QLatin1String("table-header-group")) { return QSvgNode::TableHeaderGroupMode; } else if (str == QLatin1String("table-footer-group")) { return QSvgNode::TableFooterGroupMode; } else if (str == QLatin1String("table-row")) { return QSvgNode::TableRowMode; } else if (str == QLatin1String("table-column-group")) { return QSvgNode::TableColumnGroupMode; } else if (str == QLatin1String("table-column")) { return QSvgNode::TableColumnMode; } else if (str == QLatin1String("table-cell")) { return QSvgNode::TableCellMode; } else if (str == QLatin1String("table-caption")) { return QSvgNode::TableCaptionMode; } else if (str == QLatin1String("none")) { return QSvgNode::NoneMode; } else if (str == QT_INHERIT) { return QSvgNode::InheritMode; } return QSvgNode::BlockMode; } static void parseOthers(QSvgNode *node, const QSvgAttributes &attributes, QSvgHandler *) { if (attributes.display.isEmpty()) return; QString displayStr = attributes.display.toString().trimmed(); if (!displayStr.isEmpty()) { node->setDisplayMode(displayStringToEnum(displayStr)); } } static bool parseStyle(QSvgNode *node, const QSvgAttributes &attributes, QSvgHandler *handler) { parseColor(node, attributes, handler); parseBrush(node, attributes, handler); parsePen(node, attributes, handler); parseFont(node, attributes, handler); parseTransform(node, attributes, handler); parseVisibility(node, attributes, handler); parseOpacity(node, attributes, handler); parseCompOp(node, attributes, handler); parseOthers(node, attributes, handler); #if 0 value = attributes.value("audio-level"); value = attributes.value("color-rendering"); value = attributes.value("display-align"); value = attributes.value("image-rendering"); value = attributes.value("line-increment"); value = attributes.value("pointer-events"); value = attributes.value("shape-rendering"); value = attributes.value("solid-color"); value = attributes.value("solid-opacity"); value = attributes.value("text-rendering"); value = attributes.value("vector-effect"); value = attributes.value("viewport-fill"); value = attributes.value("viewport-fill-opacity"); #endif return true; } static bool parseStyle(QSvgNode *node, const QXmlStreamAttributes &attrs, QSvgHandler *handler) { return parseStyle(node, QSvgAttributes(attrs, handler), handler); } static bool parseAnchorNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static bool parseAnimateNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static bool parseAnimateColorNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *handler) { QString typeStr = attributes.value(QLatin1String("type")).toString(); QStringRef fromStr = attributes.value(QLatin1String("from")); QStringRef toStr = attributes.value(QLatin1String("to")); QString valuesStr = attributes.value(QLatin1String("values")).toString(); QString beginStr = attributes.value(QLatin1String("begin")).toString(); QString durStr = attributes.value(QLatin1String("dur")).toString(); QString targetStr = attributes.value(QLatin1String("attributeName")).toString(); QString repeatStr = attributes.value(QLatin1String("repeatCount")).toString(); QString fillStr = attributes.value(QLatin1String("fill")).toString(); QList colors; if (valuesStr.isEmpty()) { QColor startColor, endColor; resolveColor(fromStr, startColor, handler); resolveColor(toStr, endColor, handler); colors.append(startColor); colors.append(endColor); } else { QStringList str = valuesStr.split(QLatin1Char(';')); QStringList::const_iterator itr; for (itr = str.constBegin(); itr != str.constEnd(); ++itr) { QColor color; QString str = *itr; resolveColor(QStringRef(&str), color, handler); colors.append(color); } } int ms = 1000; beginStr = beginStr.trimmed(); if (beginStr.endsWith(QLatin1String("ms"))) { beginStr.chop(2); ms = 1; } else if (beginStr.endsWith(QLatin1String("s"))) { beginStr.chop(1); } durStr = durStr.trimmed(); if (durStr.endsWith(QLatin1String("ms"))) { durStr.chop(2); ms = 1; } else if (durStr.endsWith(QLatin1String("s"))) { durStr.chop(1); } int begin = static_cast(toDouble(beginStr) * ms); int end = static_cast((toDouble(durStr) + begin) * ms); QSvgAnimateColor *anim = new QSvgAnimateColor(begin, end, 0); anim->setArgs((targetStr == QLatin1String("fill")), colors); anim->setFreeze(fillStr == QLatin1String("freeze")); anim->setRepeatCount( (repeatStr == QLatin1String("indefinite")) ? -1 : (repeatStr == QLatin1String("")) ? 1 : toDouble(repeatStr)); parent->appendStyleProperty(anim, someId(attributes)); parent->document()->setAnimated(true); handler->setAnimPeriod(begin, end); return true; } static bool parseAimateMotionNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static void parseNumberTriplet(QVector &values, const QChar *&s) { QVector list = parseNumbersList(s); values << list; for (int i = 3 - list.size(); i > 0; --i) values.append(0.0); } static bool parseAnimateTransformNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *handler) { QString typeStr = attributes.value(QLatin1String("type")).toString(); QString values = attributes.value(QLatin1String("values")).toString(); QString beginStr = attributes.value(QLatin1String("begin")).toString(); QString durStr = attributes.value(QLatin1String("dur")).toString(); QString targetStr = attributes.value(QLatin1String("attributeName")).toString(); QString repeatStr = attributes.value(QLatin1String("repeatCount")).toString(); QString fillStr = attributes.value(QLatin1String("fill")).toString(); QString fromStr = attributes.value(QLatin1String("from")).toString(); QString toStr = attributes.value(QLatin1String("to")).toString(); QString byStr = attributes.value(QLatin1String("by")).toString(); QString addtv = attributes.value(QLatin1String("additive")).toString(); QSvgAnimateTransform::Additive additive = QSvgAnimateTransform::Replace; if (addtv == QLatin1String("sum")) additive = QSvgAnimateTransform::Sum; QVector vals; if (values.isEmpty()) { const QChar *s; if (fromStr.isEmpty()) { if (!byStr.isEmpty()) { // By-animation. additive = QSvgAnimateTransform::Sum; vals.append(0.0); vals.append(0.0); vals.append(0.0); parseNumberTriplet(vals, s = byStr.constData()); } else { // To-animation not defined. return false; } } else { if (!toStr.isEmpty()) { // From-to-animation. parseNumberTriplet(vals, s = fromStr.constData()); parseNumberTriplet(vals, s = toStr.constData()); } else if (!byStr.isEmpty()) { // From-by-animation. parseNumberTriplet(vals, s = fromStr.constData()); parseNumberTriplet(vals, s = byStr.constData()); for (int i = vals.size() - 3; i < vals.size(); ++i) vals[i] += vals[i - 3]; } else { return false; } } } else { const QChar *s = values.constData(); while (s && *s != QLatin1Char(0)) { parseNumberTriplet(vals, s); if (*s == QLatin1Char(0)) break; ++s; } } int ms = 1000; beginStr = beginStr.trimmed(); if (beginStr.endsWith(QLatin1String("ms"))) { beginStr.chop(2); ms = 1; } else if (beginStr.endsWith(QLatin1String("s"))) { beginStr.chop(1); } int begin = static_cast(toDouble(beginStr) * ms); durStr = durStr.trimmed(); if (durStr.endsWith(QLatin1String("ms"))) { durStr.chop(2); ms = 1; } else if (durStr.endsWith(QLatin1String("s"))) { durStr.chop(1); ms = 1000; } int end = static_cast(toDouble(durStr)*ms) + begin; QSvgAnimateTransform::TransformType type = QSvgAnimateTransform::Empty; if (typeStr == QLatin1String("translate")) { type = QSvgAnimateTransform::Translate; } else if (typeStr == QLatin1String("scale")) { type = QSvgAnimateTransform::Scale; } else if (typeStr == QLatin1String("rotate")) { type = QSvgAnimateTransform::Rotate; } else if (typeStr == QLatin1String("skewX")) { type = QSvgAnimateTransform::SkewX; } else if (typeStr == QLatin1String("skewY")) { type = QSvgAnimateTransform::SkewY; } else { return false; } QSvgAnimateTransform *anim = new QSvgAnimateTransform(begin, end, 0); anim->setArgs(type, additive, vals); anim->setFreeze(fillStr == QLatin1String("freeze")); anim->setRepeatCount( (repeatStr == QLatin1String("indefinite"))? -1 : (repeatStr == QLatin1String(""))? 1 : toDouble(repeatStr)); parent->appendStyleProperty(anim, someId(attributes)); parent->document()->setAnimated(true); handler->setAnimPeriod(begin, end); return true; } static QSvgNode * createAnimationNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return 0; } static bool parseAudioNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static QSvgNode *createCircleNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { QString cx = attributes.value(QLatin1String("cx")).toString(); QString cy = attributes.value(QLatin1String("cy")).toString(); QString r = attributes.value(QLatin1String("r")).toString(); qreal ncx = toDouble(cx); qreal ncy = toDouble(cy); qreal nr = toDouble(r); QRectF rect(ncx-nr, ncy-nr, nr*2, nr*2); QSvgNode *circle = new QSvgCircle(parent, rect); return circle; } static QSvgNode *createDefsNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(attributes); QSvgDefs *defs = new QSvgDefs(parent); return defs; } static bool parseDescNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static bool parseDiscardNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static QSvgNode *createEllipseNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { QString cx = attributes.value(QLatin1String("cx")).toString(); QString cy = attributes.value(QLatin1String("cy")).toString(); QString rx = attributes.value(QLatin1String("rx")).toString(); QString ry = attributes.value(QLatin1String("ry")).toString(); qreal ncx = toDouble(cx); qreal ncy = toDouble(cy); qreal nrx = toDouble(rx); qreal nry = toDouble(ry); QRectF rect(ncx-nrx, ncy-nry, nrx*2, nry*2); QSvgNode *ellipse = new QSvgEllipse(parent, rect); return ellipse; } static QSvgStyleProperty *createFontNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { QString hax = attributes.value(QLatin1String("horiz-adv-x")).toString(); QString myId = someId(attributes); qreal horizAdvX = toDouble(hax); while (parent && parent->type() != QSvgNode::DOC) { parent = parent->parent(); } if (parent) { QSvgTinyDocument *doc = static_cast(parent); QSvgFont *font = new QSvgFont(horizAdvX); font->setFamilyName(myId); if (!font->familyName().isEmpty()) { if (!doc->svgFont(font->familyName())) doc->addSvgFont(font); } return new QSvgFontStyle(font, doc); } return 0; } static bool parseFontFaceNode(QSvgStyleProperty *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { if (parent->type() != QSvgStyleProperty::FONT) { return false; } QSvgFontStyle *style = static_cast(parent); QSvgFont *font = style->svgFont(); QString name = attributes.value(QLatin1String("font-family")).toString(); QString unitsPerEmStr = attributes.value(QLatin1String("units-per-em")).toString(); qreal unitsPerEm = toDouble(unitsPerEmStr); if (!unitsPerEm) unitsPerEm = 1000; if (!name.isEmpty()) font->setFamilyName(name); font->setUnitsPerEm(unitsPerEm); if (!font->familyName().isEmpty()) if (!style->doc()->svgFont(font->familyName())) style->doc()->addSvgFont(font); return true; } static bool parseFontFaceNameNode(QSvgStyleProperty *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { if (parent->type() != QSvgStyleProperty::FONT) { return false; } QSvgFontStyle *style = static_cast(parent); QSvgFont *font = style->svgFont(); QString name = attributes.value(QLatin1String("name")).toString(); if (!name.isEmpty()) font->setFamilyName(name); if (!font->familyName().isEmpty()) if (!style->doc()->svgFont(font->familyName())) style->doc()->addSvgFont(font); return true; } static bool parseFontFaceSrcNode(QSvgStyleProperty *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static bool parseFontFaceUriNode(QSvgStyleProperty *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static bool parseForeignObjectNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static QSvgNode *createGNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(attributes); QSvgG *node = new QSvgG(parent); return node; } static bool parseGlyphNode(QSvgStyleProperty *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { if (parent->type() != QSvgStyleProperty::FONT) { return false; } QSvgFontStyle *style = static_cast(parent); QSvgFont *font = style->svgFont(); createSvgGlyph(font, attributes); return true; } static bool parseHandlerNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static bool parseHkernNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static QSvgNode *createImageNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *handler) { QString x = attributes.value(QLatin1String("x")).toString(); QString y = attributes.value(QLatin1String("y")).toString(); QString width = attributes.value(QLatin1String("width")).toString(); QString height = attributes.value(QLatin1String("height")).toString(); QString filename = attributes.value(QLatin1String("xlink:href")).toString(); qreal nx = toDouble(x); qreal ny = toDouble(y); QSvgHandler::LengthType type; qreal nwidth = parseLength(width, type, handler); nwidth = convertToPixels(nwidth, true, type); qreal nheight = parseLength(height, type, handler); nheight = convertToPixels(nheight, false, type); filename = filename.trimmed(); QImage image; if (filename.startsWith(QLatin1String("data"))) { int idx = filename.lastIndexOf(QLatin1String("base64,")); if (idx != -1) { idx += 7; QString dataStr = filename.mid(idx); QByteArray data = QByteArray::fromBase64(dataStr.toAscii()); image = QImage::fromData(data); } else { qDebug()<<"QSvgHandler::createImageNode: Unrecognized inline image format!"; } } else image = QImage(filename); if (image.isNull()) { qDebug()<<"couldn't create image from "<qgradient(); if (!link.isEmpty()) { QSvgStyleProperty *prop = node->styleProperty(link); //qDebug()<<"inherited "<type() == QSvgStyleProperty::GRADIENT) { QSvgGradientStyle *inherited = static_cast(prop); if (!inherited->stopLink().isEmpty()) { gradProp->setStopLink(inherited->stopLink(), handler->document()); } else { grad->setStops(inherited->qgradient()->stops()); gradProp->setGradientStopsSet(inherited->gradientStopsSet()); } matrix = inherited->qmatrix(); } else { gradProp->setStopLink(link, handler->document()); } } if (!trans.isEmpty()) { matrix = parseTransformationMatrix(trans); gradProp->setMatrix(matrix); } else if (!matrix.isIdentity()) { gradProp->setMatrix(matrix); } if (!spread.isEmpty()) { if (spread == QLatin1String("pad")) { grad->setSpread(QGradient::PadSpread); } else if (spread == QLatin1String("reflect")) { grad->setSpread(QGradient::ReflectSpread); } else if (spread == QLatin1String("repeat")) { grad->setSpread(QGradient::RepeatSpread); } } if (units.isEmpty() || units == QLatin1String("objectBoundingBox")) { grad->setCoordinateMode(QGradient::ObjectBoundingMode); } } static QSvgStyleProperty *createLinearGradientNode(QSvgNode *node, const QXmlStreamAttributes &attributes, QSvgHandler *handler) { QString x1 = attributes.value(QLatin1String("x1")).toString(); QString y1 = attributes.value(QLatin1String("y1")).toString(); QString x2 = attributes.value(QLatin1String("x2")).toString(); QString y2 = attributes.value(QLatin1String("y2")).toString(); qreal nx1 = 0.0; qreal ny1 = 0.0; qreal nx2 = 1.0; qreal ny2 = 0.0; if (!x1.isEmpty()) nx1 = convertToNumber(x1, handler); if (!y1.isEmpty()) ny1 = convertToNumber(y1, handler); if (!x2.isEmpty()) nx2 = convertToNumber(x2, handler); if (!y2.isEmpty()) ny2 = convertToNumber(y2, handler); QSvgNode *itr = node; while (itr && itr->type() != QSvgNode::DOC) { itr = itr->parent(); } QLinearGradient *grad = new QLinearGradient(nx1, ny1, nx2, ny2); grad->setInterpolationMode(QGradient::ComponentInterpolation); QSvgGradientStyle *prop = new QSvgGradientStyle(grad); parseBaseGradient(node, attributes, prop, handler); return prop; } static bool parseMetadataNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static bool parseMissingGlyphNode(QSvgStyleProperty *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { if (parent->type() != QSvgStyleProperty::FONT) { return false; } QSvgFontStyle *style = static_cast(parent); QSvgFont *font = style->svgFont(); createSvgGlyph(font, attributes); return true; } static bool parseMpathNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static QSvgNode *createPathNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { QStringRef data = attributes.value(QLatin1String("d")); QPainterPath qpath; qpath.setFillRule(Qt::WindingFill); //XXX do error handling parsePathDataFast(data, qpath); QSvgNode *path = new QSvgPath(parent, qpath); return path; } static QSvgNode *createPolygonNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { QString pointsStr = attributes.value(QLatin1String("points")).toString(); //same QPolygon parsing is in createPolylineNode const QChar *s = pointsStr.constData(); QVector points = parseNumbersList(s); QPolygonF poly(points.count()/2); int i = 0; QVector::const_iterator itr = points.constBegin(); while (itr != points.constEnd()) { qreal one = *itr; ++itr; qreal two = *itr; ++itr; poly[i] = QPointF(one, two); ++i; } QSvgNode *polygon = new QSvgPolygon(parent, poly); return polygon; } static QSvgNode *createPolylineNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { QString pointsStr = attributes.value(QLatin1String("points")).toString(); //same QPolygon parsing is in createPolygonNode const QChar *s = pointsStr.constData(); QVector points = parseNumbersList(s); QPolygonF poly(points.count()/2); int i = 0; QVector::const_iterator itr = points.constBegin(); while (itr != points.constEnd()) { qreal one = *itr; ++itr; qreal two = *itr; ++itr; poly[i] = QPointF(one, two); ++i; } QSvgNode *line = new QSvgPolyline(parent, poly); return line; } static bool parsePrefetchNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static QSvgStyleProperty *createRadialGradientNode(QSvgNode *node, const QXmlStreamAttributes &attributes, QSvgHandler *handler) { QString cx = attributes.value(QLatin1String("cx")).toString(); QString cy = attributes.value(QLatin1String("cy")).toString(); QString r = attributes.value(QLatin1String("r")).toString(); QString fx = attributes.value(QLatin1String("fx")).toString(); QString fy = attributes.value(QLatin1String("fy")).toString(); qreal ncx = 0.5; qreal ncy = 0.5; qreal nr = 0.5; if (!cx.isEmpty()) ncx = toDouble(cx); if (!cy.isEmpty()) ncy = toDouble(cy); if (!r.isEmpty()) nr = toDouble(r); qreal nfx = ncx; if (!fx.isEmpty()) nfx = toDouble(fx); qreal nfy = ncy; if (!fy.isEmpty()) nfy = toDouble(fy); QRadialGradient *grad = new QRadialGradient(ncx, ncy, nr, nfx, nfy); grad->setInterpolationMode(QGradient::ComponentInterpolation); QSvgGradientStyle *prop = new QSvgGradientStyle(grad); parseBaseGradient(node, attributes, prop, handler); return prop; } static QSvgNode *createRectNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *handler) { QString x = attributes.value(QLatin1String("x")).toString(); QString y = attributes.value(QLatin1String("y")).toString(); QString width = attributes.value(QLatin1String("width")).toString(); QString height = attributes.value(QLatin1String("height")).toString(); QString rx = attributes.value(QLatin1String("rx")).toString(); QString ry = attributes.value(QLatin1String("ry")).toString(); QSvgHandler::LengthType type; qreal nwidth = parseLength(width, type, handler); nwidth = convertToPixels(nwidth, true, type); qreal nheight = parseLength(height, type, handler); nheight = convertToPixels(nheight, true, type); qreal nrx = toDouble(rx); qreal nry = toDouble(ry); QRectF bounds(toDouble(x), toDouble(y), nwidth, nheight); //9.2 The 'rect' element clearly specifies it // but the case might in fact be handled because // we draw rounded rectangles differently if (nrx > bounds.width()/2) nrx = bounds.width()/2; if (nry > bounds.height()/2) nry = bounds.height()/2; if (nrx && !nry) nry = nrx; else if (nry && !nrx) nrx = nry; //we draw rounded rect from 0...99 //svg from 0...bounds.width()/2 so we're adjusting the //coordinates nrx *= (100/(bounds.width()/2)); nry *= (100/(bounds.height()/2)); QSvgNode *rect = new QSvgRect(parent, bounds, int(nrx), int(nry)); return rect; } static bool parseScriptNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static bool parseSetNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static QSvgStyleProperty *createSolidColorNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *handler) { Q_UNUSED(parent); Q_UNUSED(attributes); QStringRef solidColorStr = attributes.value(QLatin1String("solid-color")); QStringRef solidOpacityStr = attributes.value(QLatin1String("solid-opacity")); if (solidOpacityStr.isEmpty()) solidOpacityStr = attributes.value(QLatin1String("opacity")); QColor color; if (!constructColor(solidColorStr, solidOpacityStr, color, handler)) return 0; QSvgSolidColorStyle *style = new QSvgSolidColorStyle(color); return style; } static bool parseStopNode(QSvgStyleProperty *parent, const QXmlStreamAttributes &attributes, QSvgHandler *handler) { if (parent->type() != QSvgStyleProperty::GRADIENT) return false; QString nodeIdStr = someId(attributes); QString xmlClassStr = attributes.value(QLatin1String("class")).toString(); //### nasty hack because stop gradients are not in the rendering tree // we force a dummy node with the same id and class into a rendering // tree to figure out whether the selector has a style for it // QSvgStyleSelector should be coded in a way that could avoid it QSvgAnimation anim; anim.setNodeId(nodeIdStr); anim.setXmlClass(xmlClassStr); QCss::StyleSelector::NodePtr cssNode; cssNode.ptr = &anim; QVector decls = handler->selector()->declarationsForNode(cssNode); QXmlStreamAttributes xmlAttr = attributes; for (int i = 0; i < decls.count(); ++i) { const QCss::Declaration &decl = decls.at(i); if (decl.d->property.isEmpty()) continue; if (decl.d->values.count() != 1) continue; QCss::Value val = decl.d->values.first(); QString valueStr = val.toString(); if (val.type == QCss::Value::Uri) { valueStr.prepend(QLatin1String("url(")); valueStr.append(QLatin1Char(')')); } xmlAttr.append(QString(), decl.d->property, valueStr); } QSvgAttributes attrs(xmlAttr, handler); QSvgGradientStyle *style = static_cast(parent); QString offsetStr = attrs.offset.toString(); QStringRef colorStr = attrs.stopColor; QColor color; bool ok = true; qreal offset = convertToNumber(offsetStr, handler, &ok); if (!ok) offset = 0.0; QString black = QString::fromLatin1("#000000"); if (colorStr.isEmpty()) { colorStr = QStringRef(&black); } constructColor(colorStr, attrs.stopOpacity, color, handler); QGradient *grad = style->qgradient(); offset = qMin(qreal(1), qMax(qreal(0), offset)); // Clamp to range [0, 1] QGradientStops stops; if (style->gradientStopsSet()) { stops = grad->stops(); // If the stop offset equals the one previously added, add an epsilon to make it greater. if (offset <= stops.back().first) offset = stops.back().first + FLT_EPSILON; } // If offset is greater than one, it must be clamped to one. if (offset > 1.0) { if ((stops.size() == 1) || (stops.at(stops.size() - 2).first < 1.0 - FLT_EPSILON)) { stops.back().first = 1.0 - FLT_EPSILON; grad->setStops(stops); } offset = 1.0; } grad->setColorAt(offset, color); style->setGradientStopsSet(true); return true; } static bool parseStyleNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *handler) { Q_UNUSED(parent); QString type = attributes.value(QLatin1String("type")).toString(); type = type.toLower(); if (type == QLatin1String("text/css")) { handler->setInStyle(true); } return true; } static QSvgNode *createSvgNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *handler) { Q_UNUSED(parent); Q_UNUSED(attributes); QString baseProfile = attributes.value(QLatin1String("baseProfile")).toString(); #if 0 if (baseProfile.isEmpty() && baseProfile != QLatin1String("tiny")) { qWarning("Profile is %s while we only support tiny!", qPrintable(baseProfile)); } #endif QSvgTinyDocument *node = new QSvgTinyDocument(); QString widthStr = attributes.value(QLatin1String("width")).toString(); QString heightStr = attributes.value(QLatin1String("height")).toString(); QString viewBoxStr = attributes.value(QLatin1String("viewBox")).toString(); QSvgHandler::LengthType type = QSvgHandler::LT_PX; // FIXME: is the default correct? qreal width = 0; if (!widthStr.isEmpty()) { width = parseLength(widthStr, type, handler); if (type != QSvgHandler::LT_PT) width = convertToPixels(width, true, type); node->setWidth(int(width), type == QSvgHandler::LT_PERCENT); } qreal height = 0; if (!heightStr.isEmpty()) { height = parseLength(heightStr, type, handler); if (type != QSvgHandler::LT_PT) height = convertToPixels(height, false, type); node->setHeight(int(height), type == QSvgHandler::LT_PERCENT); } QStringList viewBoxValues; if (!viewBoxStr.isEmpty()) { viewBoxStr = viewBoxStr.replace(QLatin1Char(' '), QLatin1Char(',')); viewBoxValues = viewBoxStr.split(QLatin1Char(','), QString::SkipEmptyParts); } if (viewBoxValues.count() == 4) { QString xStr = viewBoxValues.at(0).trimmed(); QString yStr = viewBoxValues.at(1).trimmed(); QString widthStr = viewBoxValues.at(2).trimmed(); QString heightStr = viewBoxValues.at(3).trimmed(); QSvgHandler::LengthType lt; qreal x = parseLength(xStr, lt, handler); qreal y = parseLength(yStr, lt, handler); qreal w = parseLength(widthStr, lt, handler); qreal h = parseLength(heightStr, lt, handler); node->setViewBox(QRectF(x, y, w, h)); } else if (width && height) { if (type == QSvgHandler::LT_PT) { width = convertToPixels(width, false, type); height = convertToPixels(height, false, type); } node->setViewBox(QRectF(0, 0, width, height)); } handler->setDefaultCoordinateSystem(QSvgHandler::LT_PX); return node; } static QSvgNode *createSwitchNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(attributes); QSvgSwitch *node = new QSvgSwitch(parent); return node; } static bool parseTbreakNode(QSvgNode *parent, const QXmlStreamAttributes &, QSvgHandler *) { if (parent->type() != QSvgNode::TEXTAREA) return false; static_cast(parent)->addLineBreak(); return true; } static QSvgNode *createTextNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *handler) { QString x = attributes.value(QLatin1String("x")).toString(); QString y = attributes.value(QLatin1String("y")).toString(); //### editable and rotate not handled QSvgHandler::LengthType type; qreal nx = parseLength(x, type, handler); qreal ny = parseLength(y, type, handler); QSvgNode *text = new QSvgText(parent, QPointF(nx, ny)); return text; } static QSvgNode *createTextAreaNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *handler) { QSvgText *node = static_cast(createTextNode(parent, attributes, handler)); if (node) { QSvgHandler::LengthType type; qreal width = parseLength(attributes.value(QLatin1String("width")).toString(), type, handler); qreal height = parseLength(attributes.value(QLatin1String("height")).toString(), type, handler); node->setTextArea(QSizeF(width, height)); } return node; } static QSvgNode *createTspanNode(QSvgNode *parent, const QXmlStreamAttributes &, QSvgHandler *) { return new QSvgTspan(parent); } static bool parseTitleNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return true; } static QSvgNode *createUseNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *handler) { QString linkId = attributes.value(QLatin1String("xlink:href")).toString().remove(0, 1); QString xStr = attributes.value(QLatin1String("x")).toString(); QString yStr = attributes.value(QLatin1String("y")).toString(); QSvgStructureNode *group = 0; if (linkId.isEmpty()) linkId = attributes.value(QLatin1String("href")).toString().remove(0, 1); switch (parent->type()) { case QSvgNode::DOC: case QSvgNode::DEFS: case QSvgNode::G: case QSvgNode::SWITCH: group = static_cast(parent); break; default: break; } if (group) { QSvgNode *link = group->scopeNode(linkId); if (link) { QPointF pt; if (!xStr.isNull() || !yStr.isNull()) { QSvgHandler::LengthType type; qreal nx = parseLength(xStr, type, handler); nx = convertToPixels(nx, true, type); qreal ny = parseLength(yStr, type, handler); ny = convertToPixels(ny, true, type); pt = QPointF(nx, ny); } //delay link resolving till the first draw call on //use nodes, link 2might have not been created yet QSvgUse *node = new QSvgUse(pt, parent, link); return node; } } qWarning("link %s hasn't been detected!", qPrintable(linkId)); return 0; } static QSvgNode *createVideoNode(QSvgNode *parent, const QXmlStreamAttributes &attributes, QSvgHandler *) { Q_UNUSED(parent); Q_UNUSED(attributes); return 0; } typedef QSvgNode *(*FactoryMethod)(QSvgNode *, const QXmlStreamAttributes &, QSvgHandler *); static FactoryMethod findGroupFactory(const QString &name) { if (name.isEmpty()) return 0; QStringRef ref(&name, 1, name.length() - 1); switch (name.at(0).unicode()) { case 'd': if (ref == QLatin1String("efs")) return createDefsNode; break; case 'g': if (ref.isEmpty()) return createGNode; break; case 's': if (ref == QLatin1String("vg")) return createSvgNode; if (ref == QLatin1String("witch")) return createSwitchNode; break; default: break; } return 0; } static FactoryMethod findGraphicsFactory(const QString &name) { if (name.isEmpty()) return 0; QStringRef ref(&name, 1, name.length() - 1); switch (name.at(0).unicode()) { case 'a': if (ref == QLatin1String("nimation")) return createAnimationNode; break; case 'c': if (ref == QLatin1String("ircle")) return createCircleNode; break; case 'e': if (ref == QLatin1String("llipse")) return createEllipseNode; break; case 'i': if (ref == QLatin1String("mage")) return createImageNode; break; case 'l': if (ref == QLatin1String("ine")) return createLineNode; break; case 'p': if (ref == QLatin1String("ath")) return createPathNode; if (ref == QLatin1String("olygon")) return createPolygonNode; if (ref == QLatin1String("olyline")) return createPolylineNode; break; case 'r': if (ref == QLatin1String("ect")) return createRectNode; break; case 't': if (ref == QLatin1String("ext")) return createTextNode; if (ref == QLatin1String("extArea")) return createTextAreaNode; if (ref == QLatin1String("span")) return createTspanNode; break; case 'u': if (ref == QLatin1String("se")) return createUseNode; break; case 'v': if (ref == QLatin1String("ideo")) return createVideoNode; break; default: break; } return 0; } typedef bool (*ParseMethod)(QSvgNode *, const QXmlStreamAttributes &, QSvgHandler *); static ParseMethod findUtilFactory(const QString &name) { if (name.isEmpty()) return 0; QStringRef ref(&name, 1, name.length() - 1); switch (name.at(0).unicode()) { case 'a': if (ref.isEmpty()) return parseAnchorNode; if (ref == QLatin1String("nimate")) return parseAnimateNode; if (ref == QLatin1String("nimateColor")) return parseAnimateColorNode; if (ref == QLatin1String("nimateMotion")) return parseAimateMotionNode; if (ref == QLatin1String("nimateTransform")) return parseAnimateTransformNode; if (ref == QLatin1String("udio")) return parseAudioNode; break; case 'd': if (ref == QLatin1String("esc")) return parseDescNode; if (ref == QLatin1String("iscard")) return parseDiscardNode; break; case 'f': if (ref == QLatin1String("oreignObject")) return parseForeignObjectNode; break; case 'h': if (ref == QLatin1String("andler")) return parseHandlerNode; if (ref == QLatin1String("kern")) return parseHkernNode; break; case 'm': if (ref == QLatin1String("etadata")) return parseMetadataNode; if (ref == QLatin1String("path")) return parseMpathNode; break; case 'p': if (ref == QLatin1String("refetch")) return parsePrefetchNode; break; case 's': if (ref == QLatin1String("cript")) return parseScriptNode; if (ref == QLatin1String("et")) return parseSetNode; if (ref == QLatin1String("tyle")) return parseStyleNode; break; case 't': if (ref == QLatin1String("break")) return parseTbreakNode; if (ref == QLatin1String("itle")) return parseTitleNode; break; default: break; } return 0; } typedef QSvgStyleProperty *(*StyleFactoryMethod)(QSvgNode *, const QXmlStreamAttributes &, QSvgHandler *); static StyleFactoryMethod findStyleFactoryMethod(const QString &name) { if (name.isEmpty()) return 0; QStringRef ref(&name, 1, name.length() - 1); switch (name.at(0).unicode()) { case 'f': if (ref == QLatin1String("ont")) return createFontNode; break; case 'l': if (ref == QLatin1String("inearGradient")) return createLinearGradientNode; break; case 'r': if (ref == QLatin1String("adialGradient")) return createRadialGradientNode; break; case 's': if (ref == QLatin1String("olidColor")) return createSolidColorNode; break; default: break; } return 0; } typedef bool (*StyleParseMethod)(QSvgStyleProperty *, const QXmlStreamAttributes &, QSvgHandler *); static StyleParseMethod findStyleUtilFactoryMethod(const QString &name) { if (name.isEmpty()) return 0; QStringRef ref(&name, 1, name.length() - 1); switch (name.at(0).unicode()) { case 'f': if (ref == QLatin1String("ont-face")) return parseFontFaceNode; if (ref == QLatin1String("ont-face-name")) return parseFontFaceNameNode; if (ref == QLatin1String("ont-face-src")) return parseFontFaceSrcNode; if (ref == QLatin1String("ont-face-uri")) return parseFontFaceUriNode; break; case 'g': if (ref == QLatin1String("lyph")) return parseGlyphNode; break; case 'm': if (ref == QLatin1String("issing-glyph")) return parseMissingGlyphNode; break; case 's': if (ref == QLatin1String("top")) return parseStopNode; break; default: break; } return 0; } QSvgHandler::QSvgHandler(QIODevice *device) : xml(new QXmlStreamReader(device)) , m_ownsReader(true) { init(); } QSvgHandler::QSvgHandler(const QByteArray &data) : xml(new QXmlStreamReader(data)) , m_ownsReader(true) { init(); } QSvgHandler::QSvgHandler(QXmlStreamReader *const reader) : xml(reader) , m_ownsReader(false) { init(); } void QSvgHandler::init() { m_doc = 0; m_style = 0; m_animEnd = 0; m_defaultCoords = LT_PX; m_defaultPen = QPen(Qt::black, 1, Qt::SolidLine, Qt::FlatCap, Qt::SvgMiterJoin); m_defaultPen.setMiterLimit(4); parse(); } void QSvgHandler::parse() { xml->setNamespaceProcessing(false); m_selector = new QSvgStyleSelector; m_inStyle = false; bool done = false; while (!xml->atEnd() && !done) { switch (xml->readNext()) { case QXmlStreamReader::StartElement: // he we could/should verify the namespaces, and simply // call m_skipNodes(Unknown) if we don't know the // namespace. We do support http://www.w3.org/2000/svg // but also http://www.w3.org/2000/svg-20000303-stylable // And if the document uses an external dtd, the reported // namespaceUri is empty. The only possible strategy at // this point is to do what everyone else seems to do and // ignore the reported namespaceUri completely. startElement(xml->name().toString(), xml->attributes()); break; case QXmlStreamReader::EndElement: endElement(xml->name()); // if we are using somebody else's qxmlstreamreader // we should not read until the end of the stream done = !m_ownsReader && (xml->name() == QLatin1String("svg")); break; case QXmlStreamReader::Characters: characters(xml->text()); break; case QXmlStreamReader::ProcessingInstruction: processingInstruction(xml->processingInstructionTarget().toString(), xml->processingInstructionData().toString()); break; default: ; } } } bool QSvgHandler::startElement(const QString &localName, const QXmlStreamAttributes &attributes) { QSvgNode *node = 0; if (m_colorTagCount.count()) { int top = m_colorTagCount.pop(); ++top; m_colorTagCount.push(top); } /* The xml:space attribute may appear on any element. We do * a lookup by the qualified name here, but this is namespace aware, since * the XML namespace can only be bound to prefix "xml." */ const QStringRef xmlSpace(attributes.value(QLatin1String("xml:space"))); if(xmlSpace.isNull()) { // This element has no xml:space attribute. m_whitespaceMode.push(QSvgText::Default); } else if(xmlSpace == QLatin1String("preserve")) m_whitespaceMode.push(QSvgText::Preserve); else if(xmlSpace == QLatin1String("default")) m_whitespaceMode.push(QSvgText::Default); else { qWarning() << QString::fromLatin1("\"%1\" is an invalid value for attribute xml:space. " "Valid values are \"preserve\" and \"default\".").arg(xmlSpace.toString()); m_whitespaceMode.push(QSvgText::Default); } if (FactoryMethod method = findGroupFactory(localName)) { //group node = method(m_doc ? m_nodes.top() : 0, attributes, this); Q_ASSERT(node); if (!m_doc) { Q_ASSERT(node->type() == QSvgNode::DOC); m_doc = static_cast(node); } else { switch (m_nodes.top()->type()) { case QSvgNode::DOC: case QSvgNode::G: case QSvgNode::DEFS: case QSvgNode::SWITCH: { QSvgStructureNode *group = static_cast(m_nodes.top()); group->addChild(node, someId(attributes)); } break; default: break; } } parseCoreNode(node, attributes); cssStyleLookup(node, this, m_selector); parseStyle(node, attributes, this); } else if (FactoryMethod method = findGraphicsFactory(localName)) { //rendering element Q_ASSERT(!m_nodes.isEmpty()); node = method(m_nodes.top(), attributes, this); if (node) { switch (m_nodes.top()->type()) { case QSvgNode::DOC: case QSvgNode::G: case QSvgNode::DEFS: case QSvgNode::SWITCH: { QSvgStructureNode *group = static_cast(m_nodes.top()); group->addChild(node, someId(attributes)); } break; case QSvgNode::TEXT: case QSvgNode::TEXTAREA: if (node->type() == QSvgNode::TSPAN) { static_cast(m_nodes.top())->addTspan(static_cast(node)); } else { qWarning("\'text\' or \'textArea\' element contains invalid element type."); delete node; node = 0; } break; default: qWarning("Could not add child element to parent element because the types are incorrect."); delete node; node = 0; break; } if (node) { parseCoreNode(node, attributes); cssStyleLookup(node, this, m_selector); parseStyle(node, attributes, this); if (node->type() == QSvgNode::TEXT || node->type() == QSvgNode::TEXTAREA) { static_cast(node)->setWhitespaceMode(m_whitespaceMode.top()); } else if (node->type() == QSvgNode::TSPAN) { static_cast(node)->setWhitespaceMode(m_whitespaceMode.top()); } } } } else if (ParseMethod method = findUtilFactory(localName)) { Q_ASSERT(!m_nodes.isEmpty()); if (!method(m_nodes.top(), attributes, this)) { qWarning("Problem parsing %s", qPrintable(localName)); } } else if (StyleFactoryMethod method = findStyleFactoryMethod(localName)) { QSvgStyleProperty *prop = method(m_nodes.top(), attributes, this); if (prop) { m_style = prop; m_nodes.top()->appendStyleProperty(prop, someId(attributes), true); } else { qWarning("Could not parse node: %s", qPrintable(localName)); } } else if (StyleParseMethod method = findStyleUtilFactoryMethod(localName)) { if (m_style) { if (!method(m_style, attributes, this)) { qWarning("Problem parsing %s", qPrintable(localName)); } } } else { //qWarning()<<"Skipping unknown element!"<(m_nodes.top()); if (curNode->type() == QSvgNode::DOC || curNode->type() == QSvgNode::G || curNode->type() == QSvgNode::DEFS || curNode->type() == QSvgNode::SWITCH) { QSvgStructureNode* structureNode = static_cast(curNode); QList ren = structureNode->renderers(); QList::iterator itr = ren.begin(); while (itr != ren.end()) { QSvgNode *eleNode = *itr++; QSvgFillStyle *fill = static_cast(eleNode->styleProperty(QSvgStyleProperty::FILL)); if (fill && !(fill->isGradientResolved())) { QString id = fill->gradientId(); QSvgStyleProperty *style = structureNode->scopeStyle(id); if (style) { if (style->type() == QSvgStyleProperty::SOLID_COLOR || style->type() == QSvgStyleProperty::GRADIENT) fill->setFillStyle(reinterpret_cast(style)); } else { qWarning("Could not resolve property : %s",qPrintable(id)); fill->setBrush(QBrush(Qt::NoBrush)); } } QSvgStrokeStyle *stroke = static_cast(eleNode->styleProperty(QSvgStyleProperty::STROKE)); if (stroke && !(stroke->isGradientResolved())) { QString id = stroke->gradientId(); QSvgStyleProperty *style = structureNode->scopeStyle(id); if (style) { if (style->type() == QSvgStyleProperty::SOLID_COLOR || style->type() == QSvgStyleProperty::GRADIENT) stroke->setStyle(reinterpret_cast(style)); } else { qWarning("Could not resolve property : %s",qPrintable(id)); stroke->setStroke(QBrush(Qt::NoBrush)); } } } } m_nodes.pop(); } else if (m_style && !m_skipNodes.isEmpty() && m_skipNodes.top() != Style) m_style = 0; return true; } bool QSvgHandler::characters(const QStringRef &str) { if (m_inStyle) { QString css = str.toString(); QCss::StyleSheet sheet; QCss::Parser(css).parse(&sheet); m_selector->styleSheets.append(sheet); return true; } else if (m_skipNodes.isEmpty() || m_skipNodes.top() == Unknown) return true; if (m_nodes.top()->type() == QSvgNode::TEXT || m_nodes.top()->type() == QSvgNode::TEXTAREA) { static_cast(m_nodes.top())->addText(str.toString()); } else if (m_nodes.top()->type() == QSvgNode::TSPAN) { static_cast(m_nodes.top())->addText(str.toString()); } return true; } QSvgTinyDocument * QSvgHandler::document() const { return m_doc; } QSvgHandler::LengthType QSvgHandler::defaultCoordinateSystem() const { return m_defaultCoords; } void QSvgHandler::setDefaultCoordinateSystem(LengthType type) { m_defaultCoords = type; } void QSvgHandler::pushColor(const QColor &color) { m_colorStack.push(color); m_colorTagCount.push(1); } QColor QSvgHandler::currentColor() const { if (!m_colorStack.isEmpty()) return m_colorStack.top(); else return QColor(0, 0, 0); } void QSvgHandler::setInStyle(bool b) { m_inStyle = b; } bool QSvgHandler::inStyle() const { return m_inStyle; } QSvgStyleSelector * QSvgHandler::selector() const { return m_selector; } bool QSvgHandler::processingInstruction(const QString &target, const QString &data) { if (target == QLatin1String("xml-stylesheet")) { QRegExp rx(QLatin1String("type=\\\"(.+)\\\"")); rx.setMinimal(true); bool isCss = false; int pos = 0; while ((pos = rx.indexIn(data, pos)) != -1) { QString type = rx.cap(1); if (type.toLower() == QLatin1String("text/css")) { isCss = true; } pos += rx.matchedLength(); } if (isCss) { QRegExp rx(QLatin1String("href=\\\"(.+)\\\"")); rx.setMinimal(true); pos = 0; pos = rx.indexIn(data, pos); QString addr = rx.cap(1); QFileInfo fi(addr); //qDebug()<<"External CSS file "<styleSheets.append(sheet); } } } return true; } void QSvgHandler::setAnimPeriod(int start, int end) { Q_UNUSED(start); m_animEnd = qMax(end, m_animEnd); } int QSvgHandler::animationDuration() const { return m_animEnd; } QSvgHandler::~QSvgHandler() { delete m_selector; m_selector = 0; if(m_ownsReader) delete xml; } QT_END_NAMESPACE #endif // QT_NO_SVG