1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtSvg module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qplatformdefs.h"

    43 

    44 #include "qsvghandler_p.h"

    45 

    46 #ifndef QT_NO_SVG

    47 

    48 #include "qsvgtinydocument_p.h"

    49 #include "qsvgstructure_p.h"

    50 #include "qsvggraphics_p.h"

    51 #include "qsvgnode_p.h"

    52 #include "qsvgfont_p.h"

    53 

    54 #include "qapplication.h"

    55 #include "qwidget.h"

    56 #include "qpen.h"

    57 #include "qpainterpath.h"

    58 #include "qbrush.h"

    59 #include "qcolor.h"

    60 #include "qtextformat.h"

    61 #include "qvector.h"

    62 #include "qfileinfo.h"

    63 #include "qfile.h"

    64 #include "qdebug.h"

    65 #include "qmath.h"

    66 #include "qnumeric.h"

    67 #include "qvarlengtharray.h"

    68 #include "private/qmath_p.h"

    69 

    70 #include "float.h"

    71 

    72 QT_BEGIN_NAMESPACE

    73 

    74 static const char *qt_inherit_text = "inherit";

    75 #define QT_INHERIT QLatin1String(qt_inherit_text)

    76 

    77 double qstrtod(const char *s00, char const **se, bool *ok);

    78 

    79 // ======== duplicated from qcolor_p

    80 

    81 static inline int qsvg_h2i(char hex)

    82 {

    83     if (hex >= '0' && hex <= '9')

    84         return hex - '0';

    85     if (hex >= 'a' && hex <= 'f')

    86         return hex - 'a' + 10;

    87     if (hex >= 'A' && hex <= 'F')

    88         return hex - 'A' + 10;

    89     return -1;

    90 }

    91 

    92 static inline int qsvg_hex2int(const char *s)

    93 {

    94     return (qsvg_h2i(s[0]) << 4) | qsvg_h2i(s[1]);

    95 }

    96 

    97 static inline int qsvg_hex2int(char s)

    98 {

    99     int h = qsvg_h2i(s);

   100     return (h << 4) | h;

   101 }

   102 

   103 bool qsvg_get_hex_rgb(const char *name, QRgb *rgb)

   104 {

   105     if(name[0] != '#')

   106         return false;

   107     name++;

   108     int len = qstrlen(name);

   109     int r, g, b;

   110     if (len == 12) {

   111         r = qsvg_hex2int(name);

   112         g = qsvg_hex2int(name + 4);

   113         b = qsvg_hex2int(name + 8);

   114     } else if (len == 9) {

   115         r = qsvg_hex2int(name);

   116         g = qsvg_hex2int(name + 3);

   117         b = qsvg_hex2int(name + 6);

   118     } else if (len == 6) {

   119         r = qsvg_hex2int(name);

   120         g = qsvg_hex2int(name + 2);

   121         b = qsvg_hex2int(name + 4);

   122     } else if (len == 3) {

   123         r = qsvg_hex2int(name[0]);

   124         g = qsvg_hex2int(name[1]);

   125         b = qsvg_hex2int(name[2]);

   126     } else {

   127         r = g = b = -1;

   128     }

   129     if ((uint)r > 255 || (uint)g > 255 || (uint)b > 255) {

   130         *rgb = 0;

   131         return false;

   132     }

   133     *rgb = qRgb(r, g ,b);

   134     return true;

   135 }

   136 

   137 bool qsvg_get_hex_rgb(const QChar *str, int len, QRgb *rgb)

   138 {

   139     if (len > 13)

   140         return false;

   141     char tmp[16];

   142     for(int i = 0; i < len; ++i)

   143         tmp[i] = str[i].toLatin1();

   144     tmp[len] = 0;

   145     return qsvg_get_hex_rgb(tmp, rgb);

   146 }

   147 

   148 // ======== end of qcolor_p duplicate

   149 

   150 static bool parsePathDataFast(const QStringRef &data, QPainterPath &path);

   151 

   152 static inline QString someId(const QXmlStreamAttributes &attributes)

   153 {

   154     QString id = attributes.value(QLatin1String("id")).toString();

   155     if (id.isEmpty())

   156         id = attributes.value(QLatin1String("xml:id")).toString();

   157     return id;

   158 }

   159 

   160 struct QSvgAttributes

   161 {

   162     QSvgAttributes(const QXmlStreamAttributes &xmlAttributes, QSvgHandler *handler);

   163 

   164     QString id;

   165 

   166     QStringRef color;

   167     QStringRef colorOpacity;

   168     QStringRef fill;

   169     QStringRef fillRule;

   170     QStringRef fillOpacity;

   171     QStringRef stroke;

   172     QStringRef strokeDashArray;

   173     QStringRef strokeDashOffset;

   174     QStringRef strokeLineCap;

   175     QStringRef strokeLineJoin;

   176     QStringRef strokeMiterLimit;

   177     QStringRef strokeOpacity;

   178     QStringRef strokeWidth;

   179     QStringRef vectorEffect;

   180     QStringRef fontFamily;

   181     QStringRef fontSize;

   182     QStringRef fontStyle;

   183     QStringRef fontWeight;

   184     QStringRef fontVariant;

   185     QStringRef textAnchor;

   186     QStringRef transform;

   187     QStringRef visibility;

   188     QStringRef opacity;

   189     QStringRef compOp;

   190     QStringRef display;

   191     QStringRef offset;

   192     QStringRef stopColor;

   193     QStringRef stopOpacity;

   194 

   195     QVector<QSvgCssAttribute> m_cssAttributes;

   196 };

   197 

   198 QSvgAttributes::QSvgAttributes(const QXmlStreamAttributes &xmlAttributes, QSvgHandler *handler)

   199 {

   200     QStringRef style = xmlAttributes.value(QLatin1String("style"));

   201     if (!style.isEmpty()) {

   202         handler->parseCSStoXMLAttrs(style.toString(), &m_cssAttributes);

   203         for (int j = 0; j < m_cssAttributes.count(); ++j) {

   204             const QSvgCssAttribute &attribute = m_cssAttributes.at(j);

   205             QStringRef name = attribute.name;

   206             QStringRef value = attribute.value;

   207             if (name.isEmpty())

   208                 continue;

   209 

   210             switch (name.at(0).unicode()) {

   211 

   212             case 'c':

   213                 if (name == QLatin1String("color"))

   214                     color = value;

   215                 else if (name == QLatin1String("color-opacity"))

   216                     colorOpacity = value;

   217                 else if (name == QLatin1String("comp-op"))

   218                     compOp = value;

   219                 break;

   220 

   221             case 'd':

   222                 if (name == QLatin1String("display"))

   223                     display = value;

   224                 break;

   225 

   226             case 'f':

   227                 if (name == QLatin1String("fill"))

   228                     fill = value;

   229                 else if (name == QLatin1String("fill-rule"))

   230                     fillRule = value;

   231                 else if (name == QLatin1String("fill-opacity"))

   232                     fillOpacity = value;

   233                 else if (name == QLatin1String("font-family"))

   234                     fontFamily = value;

   235                 else if (name == QLatin1String("font-size"))

   236                     fontSize = value;

   237                 else if (name == QLatin1String("font-style"))

   238                     fontStyle = value;

   239                 else if (name == QLatin1String("font-weight"))

   240                     fontWeight = value;

   241                 else if (name == QLatin1String("font-variant"))

   242                     fontVariant = value;

   243                 break;

   244 

   245             case 'o':

   246                 if (name == QLatin1String("opacity"))

   247                     opacity = value;

   248                 else if (name == QLatin1String("offset"))

   249                     offset = value;

   250                 break;

   251 

   252             case 's':

   253                 if (name.length() > 5 && QStringRef(name.string(), name.position() + 1, 5) == QLatin1String("troke")) {

   254                     QStringRef strokeRef(name.string(), name.position() + 6, name.length() - 6);

   255                     if (strokeRef.isEmpty())

   256                         stroke = value;

   257                     else if (strokeRef == QLatin1String("-dasharray"))

   258                         strokeDashArray = value;

   259                     else if (strokeRef == QLatin1String("-dashoffset"))

   260                         strokeDashOffset = value;

   261                     else if (strokeRef == QLatin1String("-linecap"))

   262                         strokeLineCap = value;

   263                     else if (strokeRef == QLatin1String("-linejoin"))

   264                         strokeLineJoin = value;

   265                     else if (strokeRef == QLatin1String("-miterlimit"))

   266                         strokeMiterLimit = value;

   267                     else if (strokeRef == QLatin1String("-opacity"))

   268                         strokeOpacity = value;

   269                     else if (strokeRef == QLatin1String("-width"))

   270                         strokeWidth = value;

   271                 }

   272                 else if (name == QLatin1String("stop-color"))

   273                     stopColor = value;

   274                 else if (name == QLatin1String("stop-opacity"))

   275                     stopOpacity = value;

   276                 break;

   277 

   278             case 't':

   279                 if (name == QLatin1String("text-anchor"))

   280                     textAnchor = value;

   281                 else if (name == QLatin1String("transform"))

   282                     transform = value;

   283                 break;

   284 

   285             case 'v':

   286                 if (name == QLatin1String("vector-effect"))

   287                     vectorEffect = value;

   288                 else if (name == QLatin1String("visibility"))

   289                     visibility = value;

   290                 break;

   291 

   292             default:

   293                 break;

   294            }

   295         }

   296     }

   297 

   298     for (int i = 0; i < xmlAttributes.count(); ++i) {

   299         const QXmlStreamAttribute &attribute = xmlAttributes.at(i);

   300         QStringRef name = attribute.qualifiedName();

   301         if (name.isEmpty())

   302             continue;

   303         QStringRef value = attribute.value();

   304 

   305         switch (name.at(0).unicode()) {

   306 

   307         case 'c':

   308             if (name == QLatin1String("color"))

   309                 color = value;

   310             else if (name == QLatin1String("color-opacity"))

   311                 colorOpacity = value;

   312             else if (name == QLatin1String("comp-op"))

   313                 compOp = value;

   314             break;

   315 

   316         case 'd':

   317             if (name == QLatin1String("display"))

   318                 display = value;

   319             break;

   320 

   321         case 'f':

   322             if (name == QLatin1String("fill"))

   323                 fill = value;

   324             else if (name == QLatin1String("fill-rule"))

   325                 fillRule = value;

   326             else if (name == QLatin1String("fill-opacity"))

   327                 fillOpacity = value;

   328             else if (name == QLatin1String("font-family"))

   329                 fontFamily = value;

   330             else if (name == QLatin1String("font-size"))

   331                 fontSize = value;

   332             else if (name == QLatin1String("font-style"))

   333                 fontStyle = value;

   334             else if (name == QLatin1String("font-weight"))

   335                 fontWeight = value;

   336             else if (name == QLatin1String("font-variant"))

   337                 fontVariant = value;

   338             break;

   339 

   340         case 'i':

   341             if (name == QLatin1String("id"))

   342                 id = value.toString();

   343             break;

   344 

   345         case 'o':

   346             if (name == QLatin1String("opacity"))

   347                 opacity = value;

   348             if (name == QLatin1String("offset"))

   349                 offset = value;

   350             break;

   351 

   352         case 's':

   353             if (name.length() > 5 && QStringRef(name.string(), name.position() + 1, 5) == QLatin1String("troke")) {

   354                 QStringRef strokeRef(name.string(), name.position() + 6, name.length() - 6);

   355                 if (strokeRef.isEmpty())

   356                     stroke = value;

   357                 else if (strokeRef == QLatin1String("-dasharray"))

   358                     strokeDashArray = value;

   359                 else if (strokeRef == QLatin1String("-dashoffset"))

   360                     strokeDashOffset = value;

   361                 else if (strokeRef == QLatin1String("-linecap"))

   362                     strokeLineCap = value;

   363                 else if (strokeRef == QLatin1String("-linejoin"))

   364                     strokeLineJoin = value;

   365                 else if (strokeRef == QLatin1String("-miterlimit"))

   366                     strokeMiterLimit = value;

   367                 else if (strokeRef == QLatin1String("-opacity"))

   368                     strokeOpacity = value;

   369                 else if (strokeRef == QLatin1String("-width"))

   370                     strokeWidth = value;

   371             }

   372             else if (name == QLatin1String("stop-color"))

   373                 stopColor = value;

   374             else if (name == QLatin1String("stop-opacity"))

   375                 stopOpacity = value;

   376             break;

   377 

   378         case 't':

   379             if (name == QLatin1String("text-anchor"))

   380                 textAnchor = value;

   381             else if (name == QLatin1String("transform"))

   382                 transform = value;

   383             break;

   384 

   385         case 'v':

   386             if (name == QLatin1String("vector-effect"))

   387                 vectorEffect = value;

   388             else if (name == QLatin1String("visibility"))

   389                 visibility = value;

   390             break;

   391 

   392         case 'x':

   393             if (name == QLatin1String("xml:id") && id.isEmpty())

   394                 id = value.toString();

   395             break;

   396 

   397         default:

   398             break;

   399         }

   400     }

   401 

   402 }

   403 

   404 static const char * QSvgStyleSelector_nodeString[] = {

   405     "svg",

   406     "g",

   407     "defs",

   408     "switch",

   409     "animation",

   410     "arc",

   411     "circle",

   412     "ellipse",

   413     "image",

   414     "line",

   415     "path",

   416     "polygon",

   417     "polyline",

   418     "rect",

   419     "text",

   420     "textarea",

   421     "use",

   422     "video"

   423 };

   424 

   425 class QSvgStyleSelector : public QCss::StyleSelector

   426 {

   427 public:

   428     QSvgStyleSelector()

   429     {

   430         nameCaseSensitivity = Qt::CaseInsensitive;

   431     }

   432     virtual ~QSvgStyleSelector()

   433     {

   434     }

   435 

   436     inline QString nodeToName(QSvgNode *node) const

   437     {

   438         return QLatin1String(QSvgStyleSelector_nodeString[node->type()]);

   439     }

   440 

   441     inline QSvgNode *svgNode(NodePtr node) const

   442     {

   443         return (QSvgNode*)node.ptr;

   444     }

   445     inline QSvgStructureNode *nodeToStructure(QSvgNode *n) const

   446     {

   447         if (n &&

   448             (n->type() == QSvgNode::DOC ||

   449              n->type() == QSvgNode::G ||

   450              n->type() == QSvgNode::DEFS ||

   451              n->type() == QSvgNode::SWITCH)) {

   452             return (QSvgStructureNode*)n;

   453         }

   454         return 0;

   455     }

   456 

   457     inline QSvgStructureNode *svgStructure(NodePtr node) const

   458     {

   459         QSvgNode *n = svgNode(node);

   460         QSvgStructureNode *st = nodeToStructure(n);

   461         return st;

   462     }

   463 

   464     virtual bool nodeNameEquals(NodePtr node, const QString& nodeName) const

   465     {

   466         QSvgNode *n = svgNode(node);

   467         if (!n)

   468             return false;

   469         QString name = nodeToName(n);

   470         return QString::compare(name, nodeName, Qt::CaseInsensitive) == 0;

   471     }

   472     virtual QString attribute(NodePtr node, const QString &name) const

   473     {

   474         QSvgNode *n = svgNode(node);

   475         if ((!n->nodeId().isEmpty() && (name == QLatin1String("id") ||

   476                                         name == QLatin1String("xml:id"))))

   477             return n->nodeId();

   478         if (!n->xmlClass().isEmpty() && name == QLatin1String("class"))

   479             return n->xmlClass();

   480         return QString();

   481     }

   482     virtual bool hasAttributes(NodePtr node) const

   483     {

   484         QSvgNode *n = svgNode(node);

   485         return (n &&

   486                 (!n->nodeId().isEmpty() || !n->xmlClass().isEmpty()));

   487     }

   488 

   489     virtual QStringList nodeIds(NodePtr node) const

   490     {

   491         QSvgNode *n = svgNode(node);

   492         QString nid;

   493         if (n)

   494             nid = n->nodeId();

   495         QStringList lst; lst.append(nid);

   496         return lst;

   497     }

   498 

   499     virtual QStringList nodeNames(NodePtr node) const

   500     {

   501         QSvgNode *n = svgNode(node);

   502         if (n)

   503            return QStringList(nodeToName(n));

   504         return QStringList();

   505     }

   506 

   507     virtual bool isNullNode(NodePtr node) const

   508     {

   509         return !node.ptr;

   510     }

   511 

   512     virtual NodePtr parentNode(NodePtr node) const

   513     {

   514         QSvgNode *n = svgNode(node);

   515         NodePtr newNode;

   516         newNode.ptr = 0;

   517         newNode.id = 0;

   518         if (n) {

   519             QSvgNode *svgParent = n->parent();

   520             if (svgParent) {

   521                 newNode.ptr = svgParent;

   522             }

   523         }

   524         return newNode;

   525     }

   526     virtual NodePtr previousSiblingNode(NodePtr node) const

   527     {

   528         NodePtr newNode;

   529         newNode.ptr = 0;

   530         newNode.id = 0;

   531 

   532         QSvgNode *n = svgNode(node);

   533         if (!n)

   534             return newNode;

   535         QSvgStructureNode *svgParent = nodeToStructure(n->parent());

   536 

   537         if (svgParent) {

   538             newNode.ptr = svgParent->previousSiblingNode(n);

   539         }

   540         return newNode;

   541     }

   542     virtual NodePtr duplicateNode(NodePtr node) const

   543     {

   544         NodePtr n;

   545         n.ptr = node.ptr;

   546         n.id  = node.id;

   547         return n;

   548     }

   549     virtual void freeNode(NodePtr node) const

   550     {

   551         Q_UNUSED(node);

   552     }

   553 };

   554 

   555 // '0' is 0x30 and '9' is 0x39

   556 static inline bool isDigit(ushort ch)

   557 {

   558     static quint16 magic = 0x3ff;

   559     return ((ch >> 4) == 3) && (magic >> (ch & 15));

   560 }

   561 

   562 static qreal toDouble(const QChar *&str)

   563 {

   564     const int maxLen = 255;//technically doubles can go til 308+ but whatever

   565     char temp[maxLen+1];

   566     int pos = 0;

   567 

   568     if (*str == QLatin1Char('-')) {

   569         temp[pos++] = '-';

   570         ++str;

   571     } else if (*str == QLatin1Char('+')) {

   572         ++str;

   573     }

   574     while (isDigit(str->unicode()) && pos < maxLen) {

   575         temp[pos++] = str->toLatin1();

   576         ++str;

   577     }

   578     if (*str == QLatin1Char('.') && pos < maxLen) {

   579         temp[pos++] = '.';

   580         ++str;

   581     }

   582     while (isDigit(str->unicode()) && pos < maxLen) {

   583         temp[pos++] = str->toLatin1();

   584         ++str;

   585     }

   586     bool exponent = false;

   587     if (*str == QLatin1Char('e') && pos < maxLen) {

   588         exponent = true;

   589         temp[pos++] = 'e';

   590         ++str;

   591         if ((*str == QLatin1Char('-') || *str == QLatin1Char('+')) && pos < maxLen) {

   592             temp[pos++] = str->toLatin1();

   593             ++str;

   594         }

   595         while (isDigit(str->unicode()) && pos < maxLen) {

   596             temp[pos++] = str->toLatin1();

   597             ++str;

   598         }

   599     }

   600 

   601     temp[pos] = '\0';

   602 

   603     qreal val;

   604     if (!exponent && pos < 10) {

   605         int ival = 0;

   606         const char *t = temp;

   607         bool neg = false;

   608         if(*t == '-') {

   609             neg = true;

   610             ++t;

   611         }

   612         while(*t && *t != '.') {

   613             ival *= 10;

   614             ival += (*t) - '0';

   615             ++t;

   616         }

   617         if(*t == '.') {

   618             ++t;

   619             int div = 1;

   620             while(*t) {

   621                 ival *= 10;

   622                 ival += (*t) - '0';

   623                 div *= 10;

   624                 ++t;

   625             }

   626             val = ((qreal)ival)/((qreal)div);

   627         } else {

   628             val = ival;

   629         }

   630         if (neg)

   631             val = -val;

   632     } else {

   633 #if defined(Q_WS_QWS) && !defined(Q_OS_VXWORKS)

   634         if(sizeof(qreal) == sizeof(float))

   635             val = strtof(temp, 0);

   636         else

   637 #endif

   638         {

   639             bool ok = false;

   640             val = qstrtod(temp, 0, &ok);

   641         }

   642     }

   643     return val;

   644 

   645 }

   646 static qreal toDouble(const QString &str, bool *ok = NULL)

   647 {

   648     const QChar *c = str.constData();

   649     qreal res = toDouble(c);

   650     if (ok) {

   651         *ok = ((*c) == QLatin1Char('\0'));

   652     }

   653     return res;

   654 }

   655 

   656 static qreal toDouble(const QStringRef &str, bool *ok = NULL)

   657 {

   658     const QChar *c = str.constData();

   659     qreal res = toDouble(c);

   660     if (ok) {

   661         *ok = (c == (str.constData() + str.length()));

   662     }

   663     return res;

   664 }

   665 

   666 static QVector<qreal> parseNumbersList(const QChar *&str)

   667 {

   668     QVector<qreal> points;

   669     if (!str)

   670         return points;

   671     points.reserve(32);

   672 

   673     while (str->isSpace())

   674         ++str;

   675     while (isDigit(str->unicode()) ||

   676            *str == QLatin1Char('-') || *str == QLatin1Char('+') ||

   677            *str == QLatin1Char('.')) {

   678 

   679         points.append(toDouble(str));

   680 

   681         while (str->isSpace())

   682             ++str;

   683         if (*str == QLatin1Char(','))

   684             ++str;

   685 

   686         //eat the rest of space

   687         while (str->isSpace())

   688             ++str;

   689     }

   690 

   691     return points;

   692 }

   693 

   694 static inline void parseNumbersArray(const QChar *&str, QVarLengthArray<qreal, 8> &points)

   695 {

   696     while (str->isSpace())

   697         ++str;

   698     while (isDigit(str->unicode()) ||

   699            *str == QLatin1Char('-') || *str == QLatin1Char('+') ||

   700            *str == QLatin1Char('.')) {

   701 

   702         points.append(toDouble(str));

   703 

   704         while (str->isSpace())

   705             ++str;

   706         if (*str == QLatin1Char(','))

   707             ++str;

   708 

   709         //eat the rest of space

   710         while (str->isSpace())

   711             ++str;

   712     }

   713 }

   714 

   715 static QVector<qreal> parsePercentageList(const QChar *&str)

   716 {

   717     QVector<qreal> points;

   718     if (!str)

   719         return points;

   720 

   721     while (str->isSpace())

   722         ++str;

   723     while ((*str >= QLatin1Char('0') && *str <= QLatin1Char('9')) ||

   724            *str == QLatin1Char('-') || *str == QLatin1Char('+') ||

   725            *str == QLatin1Char('.')) {

   726 

   727         points.append(toDouble(str));

   728 

   729         while (str->isSpace())

   730             ++str;

   731         if (*str == QLatin1Char('%'))

   732             ++str;

   733         while (str->isSpace())

   734             ++str;

   735         if (*str == QLatin1Char(','))

   736             ++str;

   737 

   738         //eat the rest of space

   739         while (str->isSpace())

   740             ++str;

   741     }

   742 

   743     return points;

   744 }

   745 

   746 static QString idFromUrl(const QString &url)

   747 {

   748     QString::const_iterator itr = url.constBegin();

   749     while ((*itr).isSpace())

   750         ++itr;

   751     if ((*itr) == QLatin1Char('('))

   752         ++itr;

   753     while ((*itr).isSpace())

   754         ++itr;

   755     if ((*itr) == QLatin1Char('#'))

   756         ++itr;

   757     QString id;

   758     while ((*itr) != QLatin1Char(')')) {

   759         id += *itr;

   760         ++itr;

   761     }

   762     return id;

   763 }

   764 

   765 static inline QStringRef trimRef(const QStringRef &str)

   766 {

   767     if (str.isEmpty())

   768         return QStringRef();

   769     const QChar *s = str.string()->constData() + str.position();

   770     int end = str.length() - 1;

   771     if (!s[0].isSpace() && !s[end].isSpace())

   772         return str;

   773 

   774     int start = 0;

   775     while (start<=end && s[start].isSpace())  // skip white space from start

   776         start++;

   777     if (start <= end) {                          // only white space

   778         while (s[end].isSpace())           // skip white space from end

   779             end--;

   780     }

   781     int l = end - start + 1;

   782     if (l <= 0)

   783         return QStringRef();

   784     return QStringRef(str.string(), str.position() + start, l);

   785 }

   786 

   787 /**

   788  * returns true when successfuly set the color. false signifies

   789  * that the color should be inherited

   790  */

   791 static bool resolveColor(const QStringRef &colorStr, QColor &color, QSvgHandler *handler)

   792 {

   793     QStringRef colorStrTr = trimRef(colorStr);

   794     if (colorStrTr.isEmpty())

   795         return false;

   796 

   797     switch(colorStrTr.at(0).unicode()) {

   798 

   799         case '#':

   800             {

   801                 // #rrggbb is very very common, so let's tackle it here

   802                 // rather than falling back to QColor

   803                 QRgb rgb;

   804                 bool ok = qsvg_get_hex_rgb(colorStrTr.unicode(), colorStrTr.length(), &rgb);

   805                 if (ok)

   806                     color.setRgb(rgb);

   807                 return ok;

   808             }

   809             break;

   810 

   811         case 'r':

   812             {

   813                 // starts with "rgb(", ends with ")" and consists of at least 7 characters "rgb(,,)"

   814                 if (colorStrTr.length() >= 7 && colorStrTr.at(colorStrTr.length() - 1) == QLatin1Char(')')

   815                     && QStringRef(colorStrTr.string(), colorStrTr.position(), 4) == QLatin1String("rgb(")) {

   816                     const QChar *s = colorStrTr.constData() + 4;

   817                     QVector<qreal> compo = parseNumbersList(s);

   818                     //1 means that it failed after reaching non-parsable

   819                     //character which is going to be "%"

   820                     if (compo.size() == 1) {

   821                         s = colorStrTr.constData() + 4;

   822                         compo = parsePercentageList(s);

   823                         for (int i = 0; i < compo.size(); ++i)

   824                             compo[i] *= (qreal)2.55;

   825                     }

   826 

   827                     if (compo.size() == 3) {

   828                         color = QColor(int(compo[0]),

   829                                        int(compo[1]),

   830                                        int(compo[2]));

   831                         return true;

   832                     }

   833                     return false;

   834                 }

   835             }

   836             break;

   837 

   838         case 'c':

   839             if (colorStrTr == QLatin1String("currentColor")) {

   840                 color = handler->currentColor();

   841                 return true;

   842             }

   843             break;

   844         case 'i':

   845             if (colorStrTr == QT_INHERIT)

   846                 return false;

   847             break;

   848         default:

   849             break;

   850     }

   851 

   852     color = QColor(colorStrTr.toString());

   853     return color.isValid();

   854 }

   855 

   856 static bool constructColor(const QStringRef &colorStr, const QStringRef &opacity,

   857                            QColor &color, QSvgHandler *handler)

   858 {

   859     if (!resolveColor(colorStr, color, handler))

   860         return false;

   861     if (!opacity.isEmpty()) {

   862         bool ok = true;

   863         qreal op = qMin(qreal(1.0), qMax(qreal(0.0), toDouble(opacity, &ok)));

   864         if (!ok)

   865             op = 1.0;

   866         color.setAlphaF(op);

   867     }

   868     return true;

   869 }

   870 

   871 static qreal parseLength(const QString &str, QSvgHandler::LengthType &type,

   872                          QSvgHandler *handler, bool *ok = NULL)

   873 {

   874     QString numStr = str.trimmed();

   875 

   876     if (numStr.endsWith(QLatin1Char('%'))) {

   877         numStr.chop(1);

   878         type = QSvgHandler::LT_PERCENT;

   879     } else if (numStr.endsWith(QLatin1String("px"))) {

   880         numStr.chop(2);

   881         type = QSvgHandler::LT_PX;

   882     } else if (numStr.endsWith(QLatin1String("pc"))) {

   883         numStr.chop(2);

   884         type = QSvgHandler::LT_PC;

   885     } else if (numStr.endsWith(QLatin1String("pt"))) {

   886         numStr.chop(2);

   887         type = QSvgHandler::LT_PT;

   888     } else if (numStr.endsWith(QLatin1String("mm"))) {

   889         numStr.chop(2);

   890         type = QSvgHandler::LT_MM;

   891     } else if (numStr.endsWith(QLatin1String("cm"))) {

   892         numStr.chop(2);

   893         type = QSvgHandler::LT_CM;

   894     } else if (numStr.endsWith(QLatin1String("in"))) {

   895         numStr.chop(2);

   896         type = QSvgHandler::LT_IN;

   897     } else {

   898         type = handler->defaultCoordinateSystem();

   899         //type = QSvgHandler::LT_OTHER;

   900     }

   901     qreal len = toDouble(numStr, ok);

   902     //qDebug()<<"len is "<<len<<", from '"<<numStr << "'";

   903     return len;

   904 }

   905 

   906 static inline qreal convertToNumber(const QString &str, QSvgHandler *handler, bool *ok = NULL)

   907 {

   908     QSvgHandler::LengthType type;

   909     qreal num = parseLength(str, type, handler, ok);

   910     if (type == QSvgHandler::LT_PERCENT) {

   911         num = num/100.0;

   912     }

   913     return num;

   914 }

   915 

   916 static bool createSvgGlyph(QSvgFont *font, const QXmlStreamAttributes &attributes)

   917 {

   918     QStringRef uncStr = attributes.value(QLatin1String("unicode"));

   919     QStringRef havStr = attributes.value(QLatin1String("horiz-adv-x"));

   920     QStringRef pathStr = attributes.value(QLatin1String("d"));

   921 

   922     QChar unicode = (uncStr.isEmpty()) ? 0 : uncStr.at(0);

   923     qreal havx = (havStr.isEmpty()) ? -1 : toDouble(havStr);

   924     QPainterPath path;

   925     path.setFillRule(Qt::WindingFill);

   926     parsePathDataFast(pathStr, path);

   927 

   928     font->addGlyph(unicode, path, havx);

   929 

   930     return true;

   931 }

   932 

   933 // this should really be called convertToDefaultCoordinateSystem

   934 // and convert when type != QSvgHandler::defaultCoordinateSystem

   935 static qreal convertToPixels(qreal len, bool , QSvgHandler::LengthType type)

   936 {

   937 

   938     switch (type) {

   939     case QSvgHandler::LT_PERCENT:

   940         break;

   941     case QSvgHandler::LT_PX:

   942         break;

   943     case QSvgHandler::LT_PC:

   944         break;

   945     case QSvgHandler::LT_PT:

   946         return len * 1.25;

   947         break;

   948     case QSvgHandler::LT_MM:

   949         return len * 3.543307;

   950         break;

   951     case QSvgHandler::LT_CM:

   952         return len * 35.43307;

   953         break;

   954     case QSvgHandler::LT_IN:

   955         return len * 90;

   956         break;

   957     case QSvgHandler::LT_OTHER:

   958         break;

   959     default:

   960         break;

   961     }

   962     return len;

   963 }

   964 

   965 static void parseColor(QSvgNode *,

   966                        const QSvgAttributes &attributes,

   967                        QSvgHandler *handler)

   968 {

   969     QColor color;

   970     if (constructColor(attributes.color, attributes.colorOpacity, color, handler)) {

   971         handler->popColor();

   972         handler->pushColor(color);

   973     }

   974 }

   975 

   976 static QSvgStyleProperty *styleFromUrl(QSvgNode *node, const QString &url)

   977 {

   978     return node ? node->styleProperty(idFromUrl(url)) : 0;

   979 }

   980 

   981 static void parseBrush(QSvgNode *node,

   982                        const QSvgAttributes &attributes,

   983                        QSvgHandler *handler)

   984 {

   985     if (!attributes.fill.isEmpty() || !attributes.fillRule.isEmpty() || !attributes.fillOpacity.isEmpty()) {

   986         QSvgFillStyle *prop = new QSvgFillStyle;

   987 

   988         //fill-rule attribute handling

   989         if (!attributes.fillRule.isEmpty() && attributes.fillRule != QT_INHERIT) {

   990             if (attributes.fillRule == QLatin1String("evenodd"))

   991                 prop->setFillRule(Qt::OddEvenFill);

   992             else if (attributes.fillRule == QLatin1String("nonzero"))

   993                 prop->setFillRule(Qt::WindingFill);

   994         }

   995 

   996         //fill-opacity atttribute handling

   997         if (!attributes.fillOpacity.isEmpty() && attributes.fillOpacity != QT_INHERIT) {

   998             prop->setFillOpacity(qMin(qreal(1.0), qMax(qreal(0.0), toDouble(attributes.fillOpacity))));

   999         }

  1000 

  1001         //fill attribute handling

  1002         if ((!attributes.fill.isEmpty()) && (attributes.fill != QT_INHERIT) ) {

  1003             if (attributes.fill.length() > 3 &&

  1004                 QStringRef(attributes.fill.string(), attributes.fill.position(), 3) == QLatin1String("url")) {

  1005                 QStringRef urlRef(attributes.fill.string(), attributes.fill.position() + 3, attributes.fill.length() - 3);

  1006                 QString value = urlRef.toString();

  1007                 QSvgStyleProperty *style = styleFromUrl(node, value);

  1008                 if (style) {

  1009                     if (style->type() == QSvgStyleProperty::SOLID_COLOR || style->type() == QSvgStyleProperty::GRADIENT)

  1010                         prop->setFillStyle(reinterpret_cast<QSvgFillStyleProperty *>(style));

  1011                 } else {

  1012                     QString id = idFromUrl(value);

  1013                     prop->setGradientId(id);

  1014                     prop->setGradientResolved(false);

  1015                 }

  1016             } else if (attributes.fill != QLatin1String("none")) {

  1017                 QColor color;

  1018                 if (resolveColor(attributes.fill, color, handler))

  1019                     prop->setBrush(QBrush(color));

  1020             } else {

  1021                 prop->setBrush(QBrush(Qt::NoBrush));

  1022             }

  1023         }

  1024         node->appendStyleProperty(prop, attributes.id);

  1025     }

  1026 }

  1027 

  1028 

  1029 

  1030 static QMatrix parseTransformationMatrix(const QStringRef &value)

  1031 {

  1032     if (value.isEmpty())

  1033         return QMatrix();

  1034 

  1035     QMatrix matrix;

  1036     const QChar *str = value.constData();

  1037     const QChar *end = str + value.length();

  1038 

  1039     while (str < end) {

  1040         if (str->isSpace() || *str == QLatin1Char(',')) {

  1041             ++str;

  1042             continue;

  1043         }

  1044         enum State {

  1045             Matrix,

  1046             Translate,

  1047             Rotate,

  1048             Scale,

  1049             SkewX,

  1050             SkewY

  1051         };

  1052         State state = Matrix;

  1053         if (*str == QLatin1Char('m')) {  //matrix

  1054             const char *ident = "atrix";

  1055             for (int i = 0; i < 5; ++i)

  1056                 if (*(++str) != QLatin1Char(ident[i]))

  1057                     goto error;

  1058             ++str;

  1059             state = Matrix;

  1060         } else if (*str == QLatin1Char('t')) { //translate

  1061             const char *ident = "ranslate";

  1062             for (int i = 0; i < 8; ++i)

  1063                 if (*(++str) != QLatin1Char(ident[i]))

  1064                     goto error;

  1065             ++str;

  1066             state = Translate;

  1067         } else if (*str == QLatin1Char('r')) { //rotate

  1068             const char *ident = "otate";

  1069             for (int i = 0; i < 5; ++i)

  1070                 if (*(++str) != QLatin1Char(ident[i]))

  1071                     goto error;

  1072             ++str;

  1073             state = Rotate;

  1074         } else if (*str == QLatin1Char('s')) { //scale, skewX, skewY

  1075             ++str;

  1076             if (*str == QLatin1Char('c')) {

  1077                 const char *ident = "ale";

  1078                 for (int i = 0; i < 3; ++i)

  1079                     if (*(++str) != QLatin1Char(ident[i]))

  1080                         goto error;

  1081                 ++str;

  1082                 state = Scale;

  1083             } else if (*str == QLatin1Char('k')) {

  1084                 if (*(++str) != QLatin1Char('e'))

  1085                     goto error;

  1086                 if (*(++str) != QLatin1Char('w'))

  1087                     goto error;

  1088                 ++str;

  1089                 if (*str == QLatin1Char('X'))

  1090                     state = SkewX;

  1091                 else if (*str == QLatin1Char('Y'))

  1092                     state = SkewY;

  1093                 else

  1094                     goto error;

  1095                 ++str;

  1096             } else {

  1097                 goto error;

  1098             }

  1099         } else {

  1100             goto error;

  1101         }

  1102 

  1103 

  1104         while (str < end && str->isSpace())

  1105             ++str;

  1106         if (*str != QLatin1Char('('))

  1107             goto error;

  1108         ++str;

  1109         QVarLengthArray<qreal, 8> points;

  1110         parseNumbersArray(str, points);

  1111         if (*str != QLatin1Char(')'))

  1112             goto error;

  1113         ++str;

  1114 

  1115         if(state == Matrix) {

  1116             if(points.count() != 6)

  1117                 goto error;

  1118             matrix = matrix * QMatrix(points[0], points[1],

  1119                                       points[2], points[3],

  1120                                       points[4], points[5]);

  1121         } else if (state == Translate) {

  1122             if (points.count() == 1)

  1123                 matrix.translate(points[0], 0);

  1124             else if (points.count() == 2)

  1125                 matrix.translate(points[0], points[1]);

  1126             else

  1127                 goto error;

  1128         } else if (state == Rotate) {

  1129             if(points.count() == 1) {

  1130                 matrix.rotate(points[0]);

  1131             } else if (points.count() == 3) {

  1132                 matrix.translate(points[1], points[2]);

  1133                 matrix.rotate(points[0]);

  1134                 matrix.translate(-points[1], -points[2]);