DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
2376 Commits
9 Branches
446MB
Tree: 976be45c2a
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '976be45c2a'
${ noResults }
JUCE/modules/juce_gui_basics/drawables/juce_SVGParser.cpp

1238 lines
44KB
Raw Blame History 

  1. /*

  2.   ==============================================================================

  3. 

  4.    This file is part of the JUCE library - "Jules' Utility Class Extensions"

  5.    Copyright 2004-11 by Raw Material Software Ltd.

  6. 

  7.   ------------------------------------------------------------------------------

  8. 

  9.    JUCE can be redistributed and/or modified under the terms of the GNU General

  10.    Public License (Version 2), as published by the Free Software Foundation.

  11.    A copy of the license is included in the JUCE distribution, or can be found

  12.    online at www.gnu.org/licenses.

  13. 

  14.    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY

  15.    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR

  16.    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  17. 

  18.   ------------------------------------------------------------------------------

  19. 

  20.    To release a closed-source product which uses JUCE, commercial licenses are

  21.    available: visit www.rawmaterialsoftware.com/juce for more information.

  22. 

  23.   ==============================================================================

  24. */

  25. 

  26. class SVGState

  27. {

  28. public:

  29.     //==============================================================================

  30.     SVGState (const XmlElement* const topLevel)

  31.         : topLevelXml (topLevel),

  32.           elementX (0), elementY (0),

  33.           width (512), height (512),

  34.           viewBoxW (0), viewBoxH (0)

  35.     {

  36.     }

  37. 

  38.     //==============================================================================

  39.     Drawable* parseSVGElement (const XmlElement& xml)

  40.     {

  41.         if (! xml.hasTagName ("svg"))

  42.             return nullptr;

  43. 

  44.         DrawableComposite* const drawable = new DrawableComposite();

  45. 

  46.         drawable->setName (xml.getStringAttribute ("id"));

  47. 

  48.         SVGState newState (*this);

  49. 

  50.         if (xml.hasAttribute ("transform"))

  51.             newState.addTransform (xml);

  52. 

  53.         newState.elementX = getCoordLength (xml.getStringAttribute ("x",      String (newState.elementX)), viewBoxW);

  54.         newState.elementY = getCoordLength (xml.getStringAttribute ("y",      String (newState.elementY)), viewBoxH);

  55.         newState.width    = getCoordLength (xml.getStringAttribute ("width",  String (newState.width)),    viewBoxW);

  56.         newState.height   = getCoordLength (xml.getStringAttribute ("height", String (newState.height)),   viewBoxH);

  57. 

  58.         if (newState.width  <= 0) newState.width  = 100;

  59.         if (newState.height <= 0) newState.height = 100;

  60. 

  61.         if (xml.hasAttribute ("viewBox"))

  62.         {

  63.             const String viewBoxAtt (xml.getStringAttribute ("viewBox"));

  64.             String::CharPointerType viewParams (viewBoxAtt.getCharPointer());

  65.             Point<float> vxy, vwh;

  66. 

  67.             if (parseCoords (viewParams, vxy, true)

  68.                  && parseCoords (viewParams, vwh, true)

  69.                  && vwh.x > 0

  70.                  && vwh.y > 0)

  71.             {

  72.                 newState.viewBoxW = vwh.x;

  73.                 newState.viewBoxH = vwh.y;

  74. 

  75.                 int placementFlags = 0;

  76. 

  77.                 const String aspect (xml.getStringAttribute ("preserveAspectRatio"));

  78. 

  79.                 if (aspect.containsIgnoreCase ("none"))

  80.                 {

  81.                     placementFlags = RectanglePlacement::stretchToFit;

  82.                 }

  83.                 else

  84.                 {

  85.                     if (aspect.containsIgnoreCase ("slice"))        placementFlags |= RectanglePlacement::fillDestination;

  86. 

  87.                     if (aspect.containsIgnoreCase ("xMin"))         placementFlags |= RectanglePlacement::xLeft;

  88.                     else if (aspect.containsIgnoreCase ("xMax"))    placementFlags |= RectanglePlacement::xRight;

  89.                     else                                            placementFlags |= RectanglePlacement::xMid;

  90. 

  91.                     if (aspect.containsIgnoreCase ("yMin"))         placementFlags |= RectanglePlacement::yTop;

  92.                     else if (aspect.containsIgnoreCase ("yMax"))    placementFlags |= RectanglePlacement::yBottom;

  93.                     else                                            placementFlags |= RectanglePlacement::yMid;

  94.                 }

  95. 

  96.                 newState.transform = RectanglePlacement (placementFlags)

  97.                                         .getTransformToFit (Rectangle<float> (vxy.x, vxy.y, vwh.x, vwh.y),

  98.                                                             Rectangle<float> (newState.width, newState.height))

  99.                                         .followedBy (newState.transform);

  100.             }

  101.         }

  102.         else

  103.         {

  104.             if (viewBoxW == 0)  newState.viewBoxW = newState.width;

  105.             if (viewBoxH == 0)  newState.viewBoxH = newState.height;

  106.         }

  107. 

  108.         newState.parseSubElements (xml, drawable);

  109. 

  110.         drawable->setContentArea (RelativeRectangle (Rectangle<float> (newState.viewBoxW, newState.viewBoxH)));

  111.         drawable->resetBoundingBoxToContentArea();

  112. 

  113.         return drawable;

  114.     }

  115. 

  116. private:

  117.     //==============================================================================

  118.     const XmlElement* const topLevelXml;

  119.     float elementX, elementY, width, height, viewBoxW, viewBoxH;

  120.     AffineTransform transform;

  121.     String cssStyleText;

  122. 

  123.     //==============================================================================

  124.     void parseSubElements (const XmlElement& xml, DrawableComposite* const parentDrawable)

  125.     {

  126.         forEachXmlChildElement (xml, e)

  127.         {

  128.             Drawable* d = nullptr;

  129. 

  130.             if (e->hasTagName ("g"))                d = parseGroupElement (*e);

  131.             else if (e->hasTagName ("svg"))         d = parseSVGElement (*e);

  132.             else if (e->hasTagName ("path"))        d = parsePath (*e);

  133.             else if (e->hasTagName ("rect"))        d = parseRect (*e);

  134.             else if (e->hasTagName ("circle"))      d = parseCircle (*e);

  135.             else if (e->hasTagName ("ellipse"))     d = parseEllipse (*e);

  136.             else if (e->hasTagName ("line"))        d = parseLine (*e);

  137.             else if (e->hasTagName ("polyline"))    d = parsePolygon (*e, true);

  138.             else if (e->hasTagName ("polygon"))     d = parsePolygon (*e, false);

  139.             else if (e->hasTagName ("text"))        d = parseText (*e);

  140.             else if (e->hasTagName ("switch"))      d = parseSwitch (*e);

  141.             else if (e->hasTagName ("style"))       parseCSSStyle (*e);

  142. 

  143.             parentDrawable->addAndMakeVisible (d);

  144.         }

  145.     }

  146. 

  147.     DrawableComposite* parseSwitch (const XmlElement& xml)

  148.     {

  149.         const XmlElement* const group = xml.getChildByName ("g");

  150. 

  151.         if (group != nullptr)

  152.             return parseGroupElement (*group);

  153. 

  154.         return nullptr;

  155.     }

  156. 

  157.     DrawableComposite* parseGroupElement (const XmlElement& xml)

  158.     {

  159.         DrawableComposite* const drawable = new DrawableComposite();

  160. 

  161.         drawable->setName (xml.getStringAttribute ("id"));

  162. 

  163.         if (xml.hasAttribute ("transform"))

  164.         {

  165.             SVGState newState (*this);

  166.             newState.addTransform (xml);

  167. 

  168.             newState.parseSubElements (xml, drawable);

  169.         }

  170.         else

  171.         {

  172.             parseSubElements (xml, drawable);

  173.         }

  174. 

  175.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  176.         return drawable;

  177.     }

  178. 

  179.     //==============================================================================

  180.     Drawable* parsePath (const XmlElement& xml) const

  181.     {

  182.         const String dAttribute (xml.getStringAttribute ("d").trimStart());

  183.         String::CharPointerType d (dAttribute.getCharPointer());

  184.         Path path;

  185. 

  186.         if (getStyleAttribute (&xml, "fill-rule").trim().equalsIgnoreCase ("evenodd"))

  187.             path.setUsingNonZeroWinding (false);

  188. 

  189.         Point<float> subpathStart, last, last2, p1, p2, p3;

  190.         juce_wchar lastCommandChar = 0;

  191.         bool isRelative = true;

  192.         bool carryOn = true;

  193. 

  194.         const CharPointer_ASCII validCommandChars ("MmLlHhVvCcSsQqTtAaZz");

  195. 

  196.         while (! d.isEmpty())

  197.         {

  198.             if (validCommandChars.indexOf (*d) >= 0)

  199.             {

  200.                 lastCommandChar = d.getAndAdvance();

  201.                 isRelative = (lastCommandChar >= 'a' && lastCommandChar <= 'z');

  202.             }

  203. 

  204.             switch (lastCommandChar)

  205.             {

  206.             case 'M':

  207.             case 'm':

  208.             case 'L':

  209.             case 'l':

  210.                 if (parseCoordsOrSkip (d, p1, false))

  211.                 {

  212.                     if (isRelative)

  213.                         p1 += last;

  214. 

  215.                     if (lastCommandChar == 'M' || lastCommandChar == 'm')

  216.                     {

  217.                         subpathStart = p1;

  218.                         path.startNewSubPath (p1);

  219.                         lastCommandChar = 'l';

  220.                     }

  221.                     else

  222.                         path.lineTo (p1);

  223. 

  224.                     last2 = last;

  225.                     last = p1;

  226.                 }

  227.                 break;

  228. 

  229.             case 'H':

  230.             case 'h':

  231.                 if (parseCoord (d, p1.x, false, true))

  232.                 {

  233.                     if (isRelative)

  234.                         p1.x += last.x;

  235. 

  236.                     path.lineTo (p1.x, last.y);

  237. 

  238.                     last2.x = last.x;

  239.                     last.x = p1.x;

  240.                 }

  241.                 else

  242.                 {

  243.                     ++d;

  244.                 }

  245.                 break;

  246. 

  247.             case 'V':

  248.             case 'v':

  249.                 if (parseCoord (d, p1.y, false, false))

  250.                 {

  251.                     if (isRelative)

  252.                         p1.y += last.y;

  253. 

  254.                     path.lineTo (last.x, p1.y);

  255. 

  256.                     last2.y = last.y;

  257.                     last.y = p1.y;

  258.                 }

  259.                 else

  260.                 {

  261.                     ++d;

  262.                 }

  263.                 break;

  264. 

  265.             case 'C':

  266.             case 'c':

  267.                 if (parseCoordsOrSkip (d, p1, false)

  268.                      && parseCoordsOrSkip (d, p2, false)

  269.                      && parseCoordsOrSkip (d, p3, false))

  270.                 {

  271.                     if (isRelative)

  272.                     {

  273.                         p1 += last;

  274.                         p2 += last;

  275.                         p3 += last;

  276.                     }

  277. 

  278.                     path.cubicTo (p1, p2, p3);

  279. 

  280.                     last2 = p2;

  281.                     last = p3;

  282.                 }

  283.                 break;

  284. 

  285.             case 'S':

  286.             case 's':

  287.                 if (parseCoordsOrSkip (d, p1, false)

  288.                      && parseCoordsOrSkip (d, p3, false))

  289.                 {

  290.                     if (isRelative)

  291.                     {

  292.                         p1 += last;

  293.                         p3 += last;

  294.                     }

  295. 

  296.                     p2 = last + (last - last2);

  297.                     path.cubicTo (p2, p1, p3);

  298. 

  299.                     last2 = p1;

  300.                     last = p3;

  301.                 }

  302.                 break;

  303. 

  304.             case 'Q':

  305.             case 'q':

  306.                 if (parseCoordsOrSkip (d, p1, false)

  307.                      && parseCoordsOrSkip (d, p2, false))

  308.                 {

  309.                     if (isRelative)

  310.                     {

  311.                         p1 += last;

  312.                         p2 += last;

  313.                     }

  314. 

  315.                     path.quadraticTo (p1, p2);

  316. 

  317.                     last2 = p1;

  318.                     last = p2;

  319.                 }

  320.                 break;

  321. 

  322.             case 'T':

  323.             case 't':

  324.                 if (parseCoordsOrSkip (d, p1, false))

  325.                 {

  326.                     if (isRelative)

  327.                         p1 += last;

  328. 

  329.                     p2 = last + (last - last2);

  330.                     path.quadraticTo (p2, p1);

  331. 

  332.                     last2 = p2;

  333.                     last = p1;

  334.                 }

  335.                 break;

  336. 

  337.             case 'A':

  338.             case 'a':

  339.                 if (parseCoordsOrSkip (d, p1, false))

  340.                 {

  341.                     String num;

  342. 

  343.                     if (parseNextNumber (d, num, false))

  344.                     {

  345.                         const float angle = num.getFloatValue() * (180.0f / float_Pi);

  346. 

  347.                         if (parseNextNumber (d, num, false))

  348.                         {

  349.                             const bool largeArc = num.getIntValue() != 0;

  350. 

  351.                             if (parseNextNumber (d, num, false))

  352.                             {

  353.                                 const bool sweep = num.getIntValue() != 0;

  354. 

  355.                                 if (parseCoordsOrSkip (d, p2, false))

  356.                                 {

  357.                                     if (isRelative)

  358.                                         p2 += last;

  359. 

  360.                                     if (last != p2)

  361.                                     {

  362.                                         double centreX, centreY, startAngle, deltaAngle;

  363.                                         double rx = p1.x, ry = p1.y;

  364. 

  365.                                         endpointToCentreParameters (last.x, last.y, p2.x, p2.y,

  366.                                                                     angle, largeArc, sweep,

  367.                                                                     rx, ry, centreX, centreY,

  368.                                                                     startAngle, deltaAngle);

  369. 

  370.                                         path.addCentredArc ((float) centreX, (float) centreY,

  371.                                                             (float) rx, (float) ry,

  372.                                                             angle, (float) startAngle, (float) (startAngle + deltaAngle),

  373.                                                             false);

  374. 

  375.                                         path.lineTo (p2);

  376.                                     }

  377. 

  378.                                     last2 = last;

  379.                                     last = p2;

  380.                                 }

  381.                             }

  382.                         }

  383.                     }

  384.                 }

  385. 

  386.                 break;

  387. 

  388.             case 'Z':

  389.             case 'z':

  390.                 path.closeSubPath();

  391.                 last = last2 = subpathStart;

  392.                 d = d.findEndOfWhitespace();

  393.                 lastCommandChar = 'M';

  394.                 break;

  395. 

  396.             default:

  397.                 carryOn = false;

  398.                 break;

  399.             }

  400. 

  401.             if (! carryOn)

  402.                 break;

  403.         }

  404. 

  405.         return parseShape (xml, path);

  406.     }

  407. 

  408.     Drawable* parseRect (const XmlElement& xml) const

  409.     {

  410.         Path rect;

  411. 

  412.         const bool hasRX = xml.hasAttribute ("rx");

  413.         const bool hasRY = xml.hasAttribute ("ry");

  414. 

  415.         if (hasRX || hasRY)

  416.         {

  417.             float rx = getCoordLength (xml.getStringAttribute ("rx"), viewBoxW);

  418.             float ry = getCoordLength (xml.getStringAttribute ("ry"), viewBoxH);

  419. 

  420.             if (! hasRX)

  421.                 rx = ry;

  422.             else if (! hasRY)

  423.                 ry = rx;

  424. 

  425.             rect.addRoundedRectangle (getCoordLength (xml.getStringAttribute ("x"), viewBoxW),

  426.                                       getCoordLength (xml.getStringAttribute ("y"), viewBoxH),

  427.                                       getCoordLength (xml.getStringAttribute ("width"), viewBoxW),

  428.                                       getCoordLength (xml.getStringAttribute ("height"), viewBoxH),

  429.                                       rx, ry);

  430.         }

  431.         else

  432.         {

  433.             rect.addRectangle (getCoordLength (xml.getStringAttribute ("x"), viewBoxW),

  434.                                getCoordLength (xml.getStringAttribute ("y"), viewBoxH),

  435.                                getCoordLength (xml.getStringAttribute ("width"), viewBoxW),

  436.                                getCoordLength (xml.getStringAttribute ("height"), viewBoxH));

  437.         }

  438. 

  439.         return parseShape (xml, rect);

  440.     }

  441. 

  442.     Drawable* parseCircle (const XmlElement& xml) const

  443.     {

  444.         Path circle;

  445. 

  446.         const float cx = getCoordLength (xml.getStringAttribute ("cx"), viewBoxW);

  447.         const float cy = getCoordLength (xml.getStringAttribute ("cy"), viewBoxH);

  448.         const float radius = getCoordLength (xml.getStringAttribute ("r"), viewBoxW);

  449. 

  450.         circle.addEllipse (cx - radius, cy - radius, radius * 2.0f, radius * 2.0f);

  451. 

  452.         return parseShape (xml, circle);

  453.     }

  454. 

  455.     Drawable* parseEllipse (const XmlElement& xml) const

  456.     {

  457.         Path ellipse;

  458. 

  459.         const float cx      = getCoordLength (xml.getStringAttribute ("cx"), viewBoxW);

  460.         const float cy      = getCoordLength (xml.getStringAttribute ("cy"), viewBoxH);

  461.         const float radiusX = getCoordLength (xml.getStringAttribute ("rx"), viewBoxW);

  462.         const float radiusY = getCoordLength (xml.getStringAttribute ("ry"), viewBoxH);

  463. 

  464.         ellipse.addEllipse (cx - radiusX, cy - radiusY, radiusX * 2.0f, radiusY * 2.0f);

  465. 

  466.         return parseShape (xml, ellipse);

  467.     }

  468. 

  469.     Drawable* parseLine (const XmlElement& xml) const

  470.     {

  471.         Path line;

  472. 

  473.         const float x1 = getCoordLength (xml.getStringAttribute ("x1"), viewBoxW);

  474.         const float y1 = getCoordLength (xml.getStringAttribute ("y1"), viewBoxH);

  475.         const float x2 = getCoordLength (xml.getStringAttribute ("x2"), viewBoxW);

  476.         const float y2 = getCoordLength (xml.getStringAttribute ("y2"), viewBoxH);

  477. 

  478.         line.startNewSubPath (x1, y1);

  479.         line.lineTo (x2, y2);

  480. 

  481.         return parseShape (xml, line);

  482.     }

  483. 

  484.     Drawable* parsePolygon (const XmlElement& xml, const bool isPolyline) const

  485.     {

  486.         const String pointsAtt (xml.getStringAttribute ("points"));

  487.         String::CharPointerType points (pointsAtt.getCharPointer());

  488.         Path path;

  489.         Point<float> p;

  490. 

  491.         if (parseCoords (points, p, true))

  492.         {

  493.             Point<float> first (p), last;

  494. 

  495.             path.startNewSubPath (first);

  496. 

  497.             while (parseCoords (points, p, true))

  498.             {

  499.                 last = p;

  500.                 path.lineTo (p);

  501.             }

  502. 

  503.             if ((! isPolyline) || first == last)

  504.                 path.closeSubPath();

  505.         }

  506. 

  507.         return parseShape (xml, path);

  508.     }

  509. 

  510.     //==============================================================================

  511.     Drawable* parseShape (const XmlElement& xml, Path& path,

  512.                           const bool shouldParseTransform = true) const

  513.     {

  514.         if (shouldParseTransform && xml.hasAttribute ("transform"))

  515.         {

  516.             SVGState newState (*this);

  517.             newState.addTransform (xml);

  518. 

  519.             return newState.parseShape (xml, path, false);

  520.         }

  521. 

  522.         DrawablePath* dp = new DrawablePath();

  523.         dp->setName (xml.getStringAttribute ("id"));

  524.         dp->setFill (Colours::transparentBlack);

  525. 

  526.         path.applyTransform (transform);

  527.         dp->setPath (path);

  528. 

  529.         Path::Iterator iter (path);

  530. 

  531.         bool containsClosedSubPath = false;

  532.         while (iter.next())

  533.         {

  534.             if (iter.elementType == Path::Iterator::closePath)

  535.             {

  536.                 containsClosedSubPath = true;

  537.                 break;

  538.             }

  539.         }

  540. 

  541.         dp->setFill (getPathFillType (path,

  542.                                       getStyleAttribute (&xml, "fill"),

  543.                                       getStyleAttribute (&xml, "fill-opacity"),

  544.                                       getStyleAttribute (&xml, "opacity"),

  545.                                       containsClosedSubPath ? Colours::black

  546.                                                             : Colours::transparentBlack));

  547. 

  548.         const String strokeType (getStyleAttribute (&xml, "stroke"));

  549. 

  550.         if (strokeType.isNotEmpty() && ! strokeType.equalsIgnoreCase ("none"))

  551.         {

  552.             dp->setStrokeFill (getPathFillType (path, strokeType,

  553.                                                 getStyleAttribute (&xml, "stroke-opacity"),

  554.                                                 getStyleAttribute (&xml, "opacity"),

  555.                                                 Colours::transparentBlack));

  556. 

  557.             dp->setStrokeType (getStrokeFor (&xml));

  558.         }

  559. 

  560.         return dp;

  561.     }

  562. 

  563.     const XmlElement* findLinkedElement (const XmlElement* e) const

  564.     {

  565.         const String id (e->getStringAttribute ("xlink:href"));

  566. 

  567.         if (! id.startsWithChar ('#'))

  568.             return nullptr;

  569. 

  570.         return findElementForId (topLevelXml, id.substring (1));

  571.     }

  572. 

  573.     void addGradientStopsIn (ColourGradient& cg, const XmlElement* const fillXml) const

  574.     {

  575.         if (fillXml == 0)

  576.             return;

  577. 

  578.         forEachXmlChildElementWithTagName (*fillXml, e, "stop")

  579.         {

  580.             int index = 0;

  581.             Colour col (parseColour (getStyleAttribute  (e, "stop-color"), index, Colours::black));

  582. 

  583.             const String opacity (getStyleAttribute (e, "stop-opacity", "1"));

  584.             col = col.withMultipliedAlpha (jlimit (0.0f, 1.0f, opacity.getFloatValue()));

  585. 

  586.             double offset = e->getDoubleAttribute ("offset");

  587. 

  588.             if (e->getStringAttribute ("offset").containsChar ('%'))

  589.                 offset *= 0.01;

  590. 

  591.             cg.addColour (jlimit (0.0, 1.0, offset), col);

  592.         }

  593.     }

  594. 

  595.     FillType getPathFillType (const Path& path,

  596.                               const String& fill,

  597.                               const String& fillOpacity,

  598.                               const String& overallOpacity,

  599.                               const Colour& defaultColour) const

  600.     {

  601.         float opacity = 1.0f;

  602. 

  603.         if (overallOpacity.isNotEmpty())

  604.             opacity = jlimit (0.0f, 1.0f, overallOpacity.getFloatValue());

  605. 

  606.         if (fillOpacity.isNotEmpty())

  607.             opacity *= (jlimit (0.0f, 1.0f, fillOpacity.getFloatValue()));

  608. 

  609.         if (fill.startsWithIgnoreCase ("url"))

  610.         {

  611.             const String id (fill.fromFirstOccurrenceOf ("#", false, false)

  612.                                  .upToLastOccurrenceOf (")", false, false).trim());

  613. 

  614.             const XmlElement* const fillXml = findElementForId (topLevelXml, id);

  615. 

  616.             if (fillXml != nullptr

  617.                  && (fillXml->hasTagName ("linearGradient")

  618.                       || fillXml->hasTagName ("radialGradient")))

  619.             {

  620.                 const XmlElement* inheritedFrom = findLinkedElement (fillXml);

  621. 

  622.                 ColourGradient gradient;

  623. 

  624.                 addGradientStopsIn (gradient, inheritedFrom);

  625.                 addGradientStopsIn (gradient, fillXml);

  626. 

  627.                 if (gradient.getNumColours() > 0)

  628.                 {

  629.                     gradient.addColour (0.0, gradient.getColour (0));

  630.                     gradient.addColour (1.0, gradient.getColour (gradient.getNumColours() - 1));

  631.                 }

  632.                 else

  633.                 {

  634.                     gradient.addColour (0.0, Colours::black);

  635.                     gradient.addColour (1.0, Colours::black);

  636.                 }

  637. 

  638.                 if (overallOpacity.isNotEmpty())

  639.                     gradient.multiplyOpacity (overallOpacity.getFloatValue());

  640. 

  641.                 jassert (gradient.getNumColours() > 0);

  642. 

  643.                 gradient.isRadial = fillXml->hasTagName ("radialGradient");

  644. 

  645.                 float gradientWidth = viewBoxW;

  646.                 float gradientHeight = viewBoxH;

  647.                 float dx = 0.0f;

  648.                 float dy = 0.0f;

  649. 

  650.                 const bool userSpace = fillXml->getStringAttribute ("gradientUnits").equalsIgnoreCase ("userSpaceOnUse");

  651. 

  652.                 if (! userSpace)

  653.                 {

  654.                     const Rectangle<float> bounds (path.getBounds());

  655.                     dx = bounds.getX();

  656.                     dy = bounds.getY();

  657.                     gradientWidth = bounds.getWidth();

  658.                     gradientHeight = bounds.getHeight();

  659.                 }

  660. 

  661.                 if (gradient.isRadial)

  662.                 {

  663.                     if (userSpace)

  664.                         gradient.point1.setXY (dx + getCoordLength (fillXml->getStringAttribute ("cx", "50%"), gradientWidth),

  665.                                                dy + getCoordLength (fillXml->getStringAttribute ("cy", "50%"), gradientHeight));

  666.                     else

  667.                         gradient.point1.setXY (dx + gradientWidth * getCoordLength (fillXml->getStringAttribute ("cx", "50%"), 1.0f),

  668.                                                dy + gradientHeight * getCoordLength (fillXml->getStringAttribute ("cy", "50%"), 1.0f));

  669. 

  670.                     const float radius = getCoordLength (fillXml->getStringAttribute ("r", "50%"), gradientWidth);

  671.                     gradient.point2 = gradient.point1 + Point<float> (radius, 0.0f);

  672. 

  673.                     //xxx (the fx, fy focal point isn't handled properly here..)

  674.                 }

  675.                 else

  676.                 {

  677.                     if (userSpace)

  678.                     {

  679.                         gradient.point1.setXY (dx + getCoordLength (fillXml->getStringAttribute ("x1", "0%"), gradientWidth),

  680.                                                dy + getCoordLength (fillXml->getStringAttribute ("y1", "0%"), gradientHeight));

  681. 

  682.                         gradient.point2.setXY (dx + getCoordLength (fillXml->getStringAttribute ("x2", "100%"), gradientWidth),

  683.                                                dy + getCoordLength (fillXml->getStringAttribute ("y2", "0%"), gradientHeight));

  684.                     }

  685.                     else

  686.                     {

  687.                         gradient.point1.setXY (dx + gradientWidth * getCoordLength (fillXml->getStringAttribute ("x1", "0%"), 1.0f),

  688.                                                dy + gradientHeight * getCoordLength (fillXml->getStringAttribute ("y1", "0%"), 1.0f));

  689. 

  690.                         gradient.point2.setXY (dx + gradientWidth * getCoordLength (fillXml->getStringAttribute ("x2", "100%"), 1.0f),

  691.                                                dy + gradientHeight * getCoordLength (fillXml->getStringAttribute ("y2", "0%"), 1.0f));

  692.                     }

  693. 

  694.                     if (gradient.point1 == gradient.point2)

  695.                         return Colour (gradient.getColour (gradient.getNumColours() - 1));

  696.                 }

  697. 

  698.                 FillType type (gradient);

  699.                 type.transform = parseTransform (fillXml->getStringAttribute ("gradientTransform"))

  700.                                    .followedBy (transform);

  701.                 return type;

  702.             }

  703.         }

  704. 

  705.         if (fill.equalsIgnoreCase ("none"))

  706.             return Colours::transparentBlack;

  707. 

  708.         int i = 0;

  709.         const Colour colour (parseColour (fill, i, defaultColour));

  710.         return colour.withMultipliedAlpha (opacity);

  711.     }

  712. 

  713.     PathStrokeType getStrokeFor (const XmlElement* const xml) const

  714.     {

  715.         const String strokeWidth (getStyleAttribute (xml, "stroke-width"));

  716.         const String cap (getStyleAttribute (xml, "stroke-linecap"));

  717.         const String join (getStyleAttribute (xml, "stroke-linejoin"));

  718. 

  719.         //const String mitreLimit (getStyleAttribute (xml, "stroke-miterlimit"));

  720.         //const String dashArray (getStyleAttribute (xml, "stroke-dasharray"));

  721.         //const String dashOffset (getStyleAttribute (xml, "stroke-dashoffset"));

  722. 

  723.         PathStrokeType::JointStyle joinStyle = PathStrokeType::mitered;

  724.         PathStrokeType::EndCapStyle capStyle = PathStrokeType::butt;

  725. 

  726.         if (join.equalsIgnoreCase ("round"))

  727.             joinStyle = PathStrokeType::curved;

  728.         else if (join.equalsIgnoreCase ("bevel"))

  729.             joinStyle = PathStrokeType::beveled;

  730. 

  731.         if (cap.equalsIgnoreCase ("round"))

  732.             capStyle = PathStrokeType::rounded;

  733.         else if (cap.equalsIgnoreCase ("square"))

  734.             capStyle = PathStrokeType::square;

  735. 

  736.         float ox = 0.0f, oy = 0.0f;

  737.         float x = getCoordLength (strokeWidth, viewBoxW), y = 0.0f;

  738.         transform.transformPoints (ox, oy, x, y);

  739. 

  740.         return PathStrokeType (strokeWidth.isNotEmpty() ? juce_hypot (x - ox, y - oy) : 1.0f,

  741.                                joinStyle, capStyle);

  742.     }

  743. 

  744.     //==============================================================================

  745.     Drawable* parseText (const XmlElement& xml)

  746.     {

  747.         Array <float> xCoords, yCoords, dxCoords, dyCoords;

  748. 

  749.         getCoordList (xCoords, getInheritedAttribute (&xml, "x"), true, true);

  750.         getCoordList (yCoords, getInheritedAttribute (&xml, "y"), true, false);

  751.         getCoordList (dxCoords, getInheritedAttribute (&xml, "dx"), true, true);

  752.         getCoordList (dyCoords, getInheritedAttribute (&xml, "dy"), true, false);

  753. 

  754. 

  755.         //xxx not done text yet!

  756. 

  757. 

  758.         forEachXmlChildElement (xml, e)

  759.         {

  760.             if (e->isTextElement())

  761.             {

  762.                 const String text (e->getText());

  763. 

  764.                 Path path;

  765.                 Drawable* s = parseShape (*e, path);

  766.                 delete s;  // xxx not finished!

  767.             }

  768.             else if (e->hasTagName ("tspan"))

  769.             {

  770.                 Drawable* s = parseText (*e);

  771.                 delete s;  // xxx not finished!

  772.             }

  773.         }

  774. 

  775.         return nullptr;

  776.     }

  777. 

  778.     //==============================================================================

  779.     void addTransform (const XmlElement& xml)

  780.     {

  781.         transform = parseTransform (xml.getStringAttribute ("transform"))

  782.                         .followedBy (transform);

  783.     }

  784. 

  785.     //==============================================================================

  786.     bool parseCoord (String::CharPointerType& s, float& value, const bool allowUnits, const bool isX) const

  787.     {

  788.         String number;

  789. 

  790.         if (! parseNextNumber (s, number, allowUnits))

  791.         {

  792.             value = 0;

  793.             return false;

  794.         }

  795. 

  796.         value = getCoordLength (number, isX ? viewBoxW : viewBoxH);

  797.         return true;

  798.     }

  799. 

  800.     bool parseCoords (String::CharPointerType& s, Point<float>& p, const bool allowUnits) const

  801.     {

  802.         return parseCoord (s, p.x, allowUnits, true)

  803.             && parseCoord (s, p.y, allowUnits, false);

  804.     }

  805. 

  806.     bool parseCoordsOrSkip (String::CharPointerType& s, Point<float>& p, const bool allowUnits) const

  807.     {

  808.         const bool b = parseCoords (s, p, allowUnits);

  809.         if (! b)

  810.             ++s;

  811. 

  812.         return b;

  813.     }

  814. 

  815.     float getCoordLength (const String& s, const float sizeForProportions) const

  816.     {

  817.         float n = s.getFloatValue();

  818.         const int len = s.length();

  819. 

  820.         if (len > 2)

  821.         {

  822.             const float dpi = 96.0f;

  823. 

  824.             const juce_wchar n1 = s [len - 2];

  825.             const juce_wchar n2 = s [len - 1];

  826. 

  827.             if (n1 == 'i' && n2 == 'n')         n *= dpi;

  828.             else if (n1 == 'm' && n2 == 'm')    n *= dpi / 25.4f;

  829.             else if (n1 == 'c' && n2 == 'm')    n *= dpi / 2.54f;

  830.             else if (n1 == 'p' && n2 == 'c')    n *= 15.0f;

  831.             else if (n2 == '%')                 n *= 0.01f * sizeForProportions;

  832.         }

  833. 

  834.         return n;

  835.     }

  836. 

  837.     void getCoordList (Array <float>& coords, const String& list,

  838.                        const bool allowUnits, const bool isX) const

  839.     {

  840.         String::CharPointerType text (list.getCharPointer());

  841.         float value;

  842. 

  843.         while (parseCoord (text, value, allowUnits, isX))

  844.             coords.add (value);

  845.     }

  846. 

  847.     //==============================================================================

  848.     void parseCSSStyle (const XmlElement& xml)

  849.     {

  850.         cssStyleText = xml.getAllSubText() + "\n" + cssStyleText;

  851.     }

  852. 

  853.     String getStyleAttribute (const XmlElement* xml, const String& attributeName,

  854.                               const String& defaultValue = String::empty) const

  855.     {

  856.         if (xml->hasAttribute (attributeName))

  857.             return xml->getStringAttribute (attributeName, defaultValue);

  858. 

  859.         const String styleAtt (xml->getStringAttribute ("style"));

  860. 

  861.         if (styleAtt.isNotEmpty())

  862.         {

  863.             const String value (getAttributeFromStyleList (styleAtt, attributeName, String::empty));

  864. 

  865.             if (value.isNotEmpty())

  866.                 return value;

  867.         }

  868.         else if (xml->hasAttribute ("class"))

  869.         {

  870.             const String className ("." + xml->getStringAttribute ("class"));

  871. 

  872.             int index = cssStyleText.indexOfIgnoreCase (className + " ");

  873. 

  874.             if (index < 0)

  875.                 index = cssStyleText.indexOfIgnoreCase (className + "{");

  876. 

  877.             if (index >= 0)

  878.             {

  879.                 const int openBracket = cssStyleText.indexOfChar (index, '{');

  880. 

  881.                 if (openBracket > index)

  882.                 {

  883.                     const int closeBracket = cssStyleText.indexOfChar (openBracket, '}');

  884. 

  885.                     if (closeBracket > openBracket)

  886.                     {

  887.                         const String value (getAttributeFromStyleList (cssStyleText.substring (openBracket + 1, closeBracket), attributeName, defaultValue));

  888. 

  889.                         if (value.isNotEmpty())

  890.                             return value;

  891.                     }

  892.                 }

  893.             }

  894.         }

  895. 

  896.         xml = const_cast <XmlElement*> (topLevelXml)->findParentElementOf (xml);

  897. 

  898.         if (xml != nullptr)

  899.             return getStyleAttribute (xml, attributeName, defaultValue);

  900. 

  901.         return defaultValue;

  902.     }

  903. 

  904.     String getInheritedAttribute (const XmlElement* xml, const String& attributeName) const

  905.     {

  906.         if (xml->hasAttribute (attributeName))

  907.             return xml->getStringAttribute (attributeName);

  908. 

  909.         xml = const_cast <XmlElement*> (topLevelXml)->findParentElementOf (xml);

  910. 

  911.         if (xml != nullptr)

  912.             return getInheritedAttribute  (xml, attributeName);

  913. 

  914.         return String::empty;

  915.     }

  916. 

  917.     //==============================================================================

  918.     static bool isIdentifierChar (const juce_wchar c)

  919.     {

  920.         return CharacterFunctions::isLetter (c) || c == '-';

  921.     }

  922. 

  923.     static String getAttributeFromStyleList (const String& list, const String& attributeName, const String& defaultValue)

  924.     {

  925.         int i = 0;

  926. 

  927.         for (;;)

  928.         {

  929.             i = list.indexOf (i, attributeName);

  930. 

  931.             if (i < 0)

  932.                 break;

  933. 

  934.             if ((i == 0 || (i > 0 && ! isIdentifierChar (list [i - 1])))

  935.                  && ! isIdentifierChar (list [i + attributeName.length()]))

  936.             {

  937.                 i = list.indexOfChar (i, ':');

  938. 

  939.                 if (i < 0)

  940.                     break;

  941. 

  942.                 int end = list.indexOfChar (i, ';');

  943. 

  944.                 if (end < 0)

  945.                     end = 0x7ffff;

  946. 

  947.                 return list.substring (i + 1, end).trim();

  948.             }

  949. 

  950.             ++i;

  951.         }

  952. 

  953.         return defaultValue;

  954.     }

  955. 

  956.     //==============================================================================

  957.     static bool parseNextNumber (String::CharPointerType& s, String& value, const bool allowUnits)

  958.     {

  959.         while (s.isWhitespace() || *s == ',')

  960.             ++s;

  961. 

  962.         String::CharPointerType start (s);

  963.         int numChars = 0;

  964. 

  965.         if (s.isDigit() || *s == '.' || *s == '-')

  966.         {

  967.             ++numChars;

  968.             ++s;

  969.         }

  970. 

  971.         while (s.isDigit() || *s == '.')

  972.         {

  973.             ++numChars;

  974.             ++s;

  975.         }

  976. 

  977.         if ((*s == 'e' || *s == 'E')

  978.              && ((s + 1).isDigit() || s[1] == '-' || s[1] == '+'))

  979.         {

  980.             s += 2;

  981.             numChars += 2;

  982. 

  983.             while (s.isDigit())

  984.             {

  985.                 ++numChars;

  986.                 ++s;

  987.             }

  988.         }

  989. 

  990.         if (allowUnits)

  991.         {

  992.             while (s.isLetter())

  993.             {

  994.                 ++numChars;

  995.                 ++s;

  996.             }

  997.         }

  998. 

  999.         if (numChars == 0)

  1000.             return false;

  1001. 

  1002.         value = String (start, (size_t) numChars);

  1003. 

  1004.         while (s.isWhitespace() || *s == ',')

  1005.             ++s;

  1006. 

  1007.         return true;

  1008.     }

  1009. 

  1010.     //==============================================================================

  1011.     static Colour parseColour (const String& s, int& index, const Colour& defaultColour)

  1012.     {

  1013.         if (s [index] == '#')

  1014.         {

  1015.             uint32 hex[6] = { 0 };

  1016.             int numChars = 0;

  1017. 

  1018.             for (int i = 6; --i >= 0;)

  1019.             {

  1020.                 const int hexValue = CharacterFunctions::getHexDigitValue (s [++index]);

  1021. 

  1022.                 if (hexValue >= 0)

  1023.                     hex [numChars++] = (uint32) hexValue;

  1024.                 else

  1025.                     break;

  1026.             }

  1027. 

  1028.             if (numChars <= 3)

  1029.                 return Colour ((uint8) (hex [0] * 0x11),

  1030.                                (uint8) (hex [1] * 0x11),

  1031.                                (uint8) (hex [2] * 0x11));

  1032.             else

  1033.                 return Colour ((uint8) ((hex [0] << 4) + hex [1]),

  1034.                                (uint8) ((hex [2] << 4) + hex [3]),

  1035.                                (uint8) ((hex [4] << 4) + hex [5]));

  1036.         }

  1037.         else if (s [index] == 'r'

  1038.                   && s [index + 1] == 'g'

  1039.                   && s [index + 2] == 'b')

  1040.         {

  1041.             const int openBracket = s.indexOfChar (index, '(');

  1042.             const int closeBracket = s.indexOfChar (openBracket, ')');

  1043. 

  1044.             if (openBracket >= 3 && closeBracket > openBracket)

  1045.             {

  1046.                 index = closeBracket;

  1047. 

  1048.                 StringArray tokens;

  1049.                 tokens.addTokens (s.substring (openBracket + 1, closeBracket), ",", "");

  1050.                 tokens.trim();

  1051.                 tokens.removeEmptyStrings();

  1052. 

  1053.                 if (tokens[0].containsChar ('%'))

  1054.                     return Colour ((uint8) roundToInt (2.55 * tokens[0].getDoubleValue()),

  1055.                                    (uint8) roundToInt (2.55 * tokens[1].getDoubleValue()),

  1056.                                    (uint8) roundToInt (2.55 * tokens[2].getDoubleValue()));

  1057.                 else

  1058.                     return Colour ((uint8) tokens[0].getIntValue(),

  1059.                                    (uint8) tokens[1].getIntValue(),

  1060.                                    (uint8) tokens[2].getIntValue());

  1061.             }

  1062.         }

  1063. 

  1064.         return Colours::findColourForName (s, defaultColour);

  1065.     }

  1066. 

  1067.     static const AffineTransform parseTransform (String t)

  1068.     {

  1069.         AffineTransform result;

  1070. 

  1071.         while (t.isNotEmpty())

  1072.         {

  1073.             StringArray tokens;

  1074.             tokens.addTokens (t.fromFirstOccurrenceOf ("(", false, false)

  1075.                                .upToFirstOccurrenceOf (")", false, false),

  1076.                               ", ", String::empty);

  1077. 

  1078.             tokens.removeEmptyStrings (true);

  1079. 

  1080.             float numbers [6];

  1081. 

  1082.             for (int i = 0; i < 6; ++i)

  1083.                 numbers[i] = tokens[i].getFloatValue();

  1084. 

  1085.             AffineTransform trans;

  1086. 

  1087.             if (t.startsWithIgnoreCase ("matrix"))

  1088.             {

  1089.                 trans = AffineTransform (numbers[0], numbers[2], numbers[4],

  1090.                                          numbers[1], numbers[3], numbers[5]);

  1091.             }

  1092.             else if (t.startsWithIgnoreCase ("translate"))

  1093.             {

  1094.                 jassert (tokens.size() == 2);

  1095.                 trans = AffineTransform::translation (numbers[0], numbers[1]);

  1096.             }

  1097.             else if (t.startsWithIgnoreCase ("scale"))

  1098.             {

  1099.                 if (tokens.size() == 1)

  1100.                     trans = AffineTransform::scale (numbers[0], numbers[0]);

  1101.                 else

  1102.                     trans = AffineTransform::scale (numbers[0], numbers[1]);

  1103.             }

  1104.             else if (t.startsWithIgnoreCase ("rotate"))

  1105.             {

  1106.                 if (tokens.size() != 3)

  1107.                     trans = AffineTransform::rotation (numbers[0] / (180.0f / float_Pi));

  1108.                 else

  1109.                     trans = AffineTransform::rotation (numbers[0] / (180.0f / float_Pi),

  1110.                                                        numbers[1], numbers[2]);

  1111.             }

  1112.             else if (t.startsWithIgnoreCase ("skewX"))

  1113.             {

  1114.                 trans = AffineTransform (1.0f, std::tan (numbers[0] * (float_Pi / 180.0f)), 0.0f,

  1115.                                          0.0f, 1.0f, 0.0f);

  1116.             }

  1117.             else if (t.startsWithIgnoreCase ("skewY"))

  1118.             {

  1119.                 trans = AffineTransform (1.0f, 0.0f, 0.0f,

  1120.                                          std::tan (numbers[0] * (float_Pi / 180.0f)), 1.0f, 0.0f);

  1121.             }

  1122. 

  1123.             result = trans.followedBy (result);

  1124.             t = t.fromFirstOccurrenceOf (")", false, false).trimStart();

  1125.         }

  1126. 

  1127.         return result;

  1128.     }

  1129. 

  1130.     static void endpointToCentreParameters (const double x1, const double y1,

  1131.                                             const double x2, const double y2,

  1132.                                             const double angle,

  1133.                                             const bool largeArc, const bool sweep,

  1134.                                             double& rx, double& ry,

  1135.                                             double& centreX, double& centreY,

  1136.                                             double& startAngle, double& deltaAngle)

  1137.     {

  1138.         const double midX = (x1 - x2) * 0.5;

  1139.         const double midY = (y1 - y2) * 0.5;

  1140. 

  1141.         const double cosAngle = cos (angle);

  1142.         const double sinAngle = sin (angle);

  1143.         const double xp = cosAngle * midX + sinAngle * midY;

  1144.         const double yp = cosAngle * midY - sinAngle * midX;

  1145.         const double xp2 = xp * xp;

  1146.         const double yp2 = yp * yp;

  1147. 

  1148.         double rx2 = rx * rx;

  1149.         double ry2 = ry * ry;

  1150. 

  1151.         const double s = (xp2 / rx2) + (yp2 / ry2);

  1152.         double c;

  1153. 

  1154.         if (s <= 1.0)

  1155.         {

  1156.             c = std::sqrt (jmax (0.0, ((rx2 * ry2) - (rx2 * yp2) - (ry2 * xp2))

  1157.                                          / (( rx2 * yp2) + (ry2 * xp2))));

  1158. 

  1159.             if (largeArc == sweep)

  1160.                 c = -c;

  1161.         }

  1162.         else

  1163.         {

  1164.             const double s2 = std::sqrt (s);

  1165.             rx *= s2;

  1166.             ry *= s2;

  1167.             rx2 = rx * rx;

  1168.             ry2 = ry * ry;

  1169.             c = 0;

  1170.         }

  1171. 

  1172.         const double cpx = ((rx * yp) / ry) * c;

  1173.         const double cpy = ((-ry * xp) / rx) * c;

  1174. 

  1175.         centreX = ((x1 + x2) * 0.5) + (cosAngle * cpx) - (sinAngle * cpy);

  1176.         centreY = ((y1 + y2) * 0.5) + (sinAngle * cpx) + (cosAngle * cpy);

  1177. 

  1178.         const double ux = (xp - cpx) / rx;

  1179.         const double uy = (yp - cpy) / ry;

  1180.         const double vx = (-xp - cpx) / rx;

  1181.         const double vy = (-yp - cpy) / ry;

  1182. 

  1183.         const double length = juce_hypot (ux, uy);

  1184. 

  1185.         startAngle = acos (jlimit (-1.0, 1.0, ux / length));

  1186. 

  1187.         if (uy < 0)

  1188.             startAngle = -startAngle;

  1189. 

  1190.         startAngle += double_Pi * 0.5;

  1191. 

  1192.         deltaAngle = acos (jlimit (-1.0, 1.0, ((ux * vx) + (uy * vy))

  1193.                                                 / (length * juce_hypot (vx, vy))));

  1194. 

  1195.         if ((ux * vy) - (uy * vx) < 0)

  1196.             deltaAngle = -deltaAngle;

  1197. 

  1198.         if (sweep)

  1199.         {

  1200.             if (deltaAngle < 0)

  1201.                 deltaAngle += double_Pi * 2.0;

  1202.         }

  1203.         else

  1204.         {

  1205.             if (deltaAngle > 0)

  1206.                 deltaAngle -= double_Pi * 2.0;

  1207.         }

  1208. 

  1209.         deltaAngle = fmod (deltaAngle, double_Pi * 2.0);

  1210.     }

  1211. 

  1212.     static const XmlElement* findElementForId (const XmlElement* const parent, const String& id)

  1213.     {

  1214.         forEachXmlChildElement (*parent, e)

  1215.         {

  1216.             if (e->compareAttribute ("id", id))

  1217.                 return e;

  1218. 

  1219.             const XmlElement* const found = findElementForId (e, id);

  1220. 

  1221.             if (found != nullptr)

  1222.                 return found;

  1223.         }

  1224. 

  1225.         return nullptr;

  1226.     }

  1227. 

  1228.     SVGState& operator= (const SVGState&);

  1229. };

  1230. 

  1231. 

  1232. //==============================================================================

  1233. Drawable* Drawable::createFromSVG (const XmlElement& svgDocument)

  1234. {

  1235.     SVGState state (&svgDocument);

  1236.     return state.parseSVGElement (svgDocument);

  1237. }