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.
2330 Commits
9 Branches
890MB
Tree: a0ed9c96e4
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a0ed9c96e4'
${ noResults }
JUCE/modules/juce_gui_basics/drawables/juce_SVGParser.cpp

1248 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"))

  86.                         placementFlags |= RectanglePlacement::fillDestination;

  87. 

  88.                     if (aspect.containsIgnoreCase ("xMin"))

  89.                         placementFlags |= RectanglePlacement::xLeft;

  90.                     else if (aspect.containsIgnoreCase ("xMax"))

  91.                         placementFlags |= RectanglePlacement::xRight;

  92.                     else

  93.                         placementFlags |= RectanglePlacement::xMid;

  94. 

  95.                     if (aspect.containsIgnoreCase ("yMin"))

  96.                         placementFlags |= RectanglePlacement::yTop;

  97.                     else if (aspect.containsIgnoreCase ("yMax"))

  98.                         placementFlags |= RectanglePlacement::yBottom;

  99.                     else

  100.                         placementFlags |= RectanglePlacement::yMid;

  101.                 }

  102. 

  103.                 const RectanglePlacement placement (placementFlags);

  104. 

  105.                 newState.transform

  106.                     = placement.getTransformToFit (Rectangle<float> (vxy.x, vxy.y, vwh.x, vwh.y),

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

  108.                                .followedBy (newState.transform);

  109.             }

  110.         }

  111.         else

  112.         {

  113.             if (viewBoxW == 0)

  114.                 newState.viewBoxW = newState.width;

  115. 

  116.             if (viewBoxH == 0)

  117.                 newState.viewBoxH = newState.height;

  118.         }

  119. 

  120.         newState.parseSubElements (xml, drawable);

  121. 

  122.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  123.         return drawable;

  124.     }

  125. 

  126. private:

  127.     //==============================================================================

  128.     const XmlElement* const topLevelXml;

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

  130.     AffineTransform transform;

  131.     String cssStyleText;

  132. 

  133.     //==============================================================================

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

  135.     {

  136.         forEachXmlChildElement (xml, e)

  137.         {

  138.             Drawable* d = nullptr;

  139. 

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

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

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

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

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

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

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

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

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

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

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

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

  152. 

  153.             parentDrawable->addAndMakeVisible (d);

  154.         }

  155.     }

  156. 

  157.     DrawableComposite* parseSwitch (const XmlElement& xml)

  158.     {

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

  160. 

  161.         if (group != nullptr)

  162.             return parseGroupElement (*group);

  163. 

  164.         return nullptr;

  165.     }

  166. 

  167.     DrawableComposite* parseGroupElement (const XmlElement& xml)

  168.     {

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

  170. 

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

  172. 

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

  174.         {

  175.             SVGState newState (*this);

  176.             newState.addTransform (xml);

  177. 

  178.             newState.parseSubElements (xml, drawable);

  179.         }

  180.         else

  181.         {

  182.             parseSubElements (xml, drawable);

  183.         }

  184. 

  185.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  186.         return drawable;

  187.     }

  188. 

  189.     //==============================================================================

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

  191.     {

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

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

  194.         Path path;

  195. 

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

  197.             path.setUsingNonZeroWinding (false);

  198. 

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

  200.         juce_wchar lastCommandChar = 0;

  201.         bool isRelative = true;

  202.         bool carryOn = true;

  203. 

  204.         const CharPointer_ASCII validCommandChars ("MmLlHhVvCcSsQqTtAaZz");

  205. 

  206.         while (! d.isEmpty())

  207.         {

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

  209.             {

  210.                 lastCommandChar = d.getAndAdvance();

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

  212.             }

  213. 

  214.             switch (lastCommandChar)

  215.             {

  216.             case 'M':

  217.             case 'm':

  218.             case 'L':

  219.             case 'l':

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

  221.                 {

  222.                     if (isRelative)

  223.                         p1 += last;

  224. 

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

  226.                     {

  227.                         subpathStart = p1;

  228.                         path.startNewSubPath (p1);

  229.                         lastCommandChar = 'l';

  230.                     }

  231.                     else

  232.                         path.lineTo (p1);

  233. 

  234.                     last2 = last;

  235.                     last = p1;

  236.                 }

  237.                 break;

  238. 

  239.             case 'H':

  240.             case 'h':

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

  242.                 {

  243.                     if (isRelative)

  244.                         p1.x += last.x;

  245. 

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

  247. 

  248.                     last2.x = last.x;

  249.                     last.x = p1.x;

  250.                 }

  251.                 else

  252.                 {

  253.                     ++d;

  254.                 }

  255.                 break;

  256. 

  257.             case 'V':

  258.             case 'v':

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

  260.                 {

  261.                     if (isRelative)

  262.                         p1.y += last.y;

  263. 

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

  265. 

  266.                     last2.y = last.y;

  267.                     last.y = p1.y;

  268.                 }

  269.                 else

  270.                 {

  271.                     ++d;

  272.                 }

  273.                 break;

  274. 

  275.             case 'C':

  276.             case 'c':

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

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

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

  280.                 {

  281.                     if (isRelative)

  282.                     {

  283.                         p1 += last;

  284.                         p2 += last;

  285.                         p3 += last;

  286.                     }

  287. 

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

  289. 

  290.                     last2 = p2;

  291.                     last = p3;

  292.                 }

  293.                 break;

  294. 

  295.             case 'S':

  296.             case 's':

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

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

  299.                 {

  300.                     if (isRelative)

  301.                     {

  302.                         p1 += last;

  303.                         p3 += last;

  304.                     }

  305. 

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

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

  308. 

  309.                     last2 = p1;

  310.                     last = p3;

  311.                 }

  312.                 break;

  313. 

  314.             case 'Q':

  315.             case 'q':

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

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

  318.                 {

  319.                     if (isRelative)

  320.                     {

  321.                         p1 += last;

  322.                         p2 += last;

  323.                     }

  324. 

  325.                     path.quadraticTo (p1, p2);

  326. 

  327.                     last2 = p1;

  328.                     last = p2;

  329.                 }

  330.                 break;

  331. 

  332.             case 'T':

  333.             case 't':

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

  335.                 {

  336.                     if (isRelative)

  337.                         p1 += last;

  338. 

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

  340.                     path.quadraticTo (p2, p1);

  341. 

  342.                     last2 = p2;

  343.                     last = p1;

  344.                 }

  345.                 break;

  346. 

  347.             case 'A':

  348.             case 'a':

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

  350.                 {

  351.                     String num;

  352. 

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

  354.                     {

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

  356. 

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

  358.                         {

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

  360. 

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

  362.                             {

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

  364. 

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

  366.                                 {

  367.                                     if (isRelative)

  368.                                         p2 += last;

  369. 

  370.                                     if (last != p2)

  371.                                     {

  372.                                         double centreX, centreY, startAngle, deltaAngle;

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

  374. 

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

  376.                                                                     angle, largeArc, sweep,

  377.                                                                     rx, ry, centreX, centreY,

  378.                                                                     startAngle, deltaAngle);

  379. 

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

  381.                                                             (float) rx, (float) ry,

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

  383.                                                             false);

  384. 

  385.                                         path.lineTo (p2);

  386.                                     }

  387. 

  388.                                     last2 = last;

  389.                                     last = p2;

  390.                                 }

  391.                             }

  392.                         }

  393.                     }

  394.                 }

  395. 

  396.                 break;

  397. 

  398.             case 'Z':

  399.             case 'z':

  400.                 path.closeSubPath();

  401.                 last = last2 = subpathStart;

  402.                 d = d.findEndOfWhitespace();

  403.                 lastCommandChar = 'M';

  404.                 break;

  405. 

  406.             default:

  407.                 carryOn = false;

  408.                 break;

  409.             }

  410. 

  411.             if (! carryOn)

  412.                 break;

  413.         }

  414. 

  415.         return parseShape (xml, path);

  416.     }

  417. 

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

  419.     {

  420.         Path rect;

  421. 

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

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

  424. 

  425.         if (hasRX || hasRY)

  426.         {

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

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

  429. 

  430.             if (! hasRX)

  431.                 rx = ry;

  432.             else if (! hasRY)

  433.                 ry = rx;

  434. 

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

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

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

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

  439.                                       rx, ry);

  440.         }

  441.         else

  442.         {

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

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

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

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

  447.         }

  448. 

  449.         return parseShape (xml, rect);

  450.     }

  451. 

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

  453.     {

  454.         Path circle;

  455. 

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

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

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

  459. 

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

  461. 

  462.         return parseShape (xml, circle);

  463.     }

  464. 

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

  466.     {

  467.         Path ellipse;

  468. 

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

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

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

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

  473. 

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

  475. 

  476.         return parseShape (xml, ellipse);

  477.     }

  478. 

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

  480.     {

  481.         Path line;

  482. 

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

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

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

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

  487. 

  488.         line.startNewSubPath (x1, y1);

  489.         line.lineTo (x2, y2);

  490. 

  491.         return parseShape (xml, line);

  492.     }

  493. 

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

  495.     {

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

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

  498.         Path path;

  499.         Point<float> p;

  500. 

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

  502.         {

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

  504. 

  505.             path.startNewSubPath (first);

  506. 

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

  508.             {

  509.                 last = p;

  510.                 path.lineTo (p);

  511.             }

  512. 

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

  514.                 path.closeSubPath();

  515.         }

  516. 

  517.         return parseShape (xml, path);

  518.     }

  519. 

  520.     //==============================================================================

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

  522.                           const bool shouldParseTransform = true) const

  523.     {

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

  525.         {

  526.             SVGState newState (*this);

  527.             newState.addTransform (xml);

  528. 

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

  530.         }

  531. 

  532.         DrawablePath* dp = new DrawablePath();

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

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

  535. 

  536.         path.applyTransform (transform);

  537.         dp->setPath (path);

  538. 

  539.         Path::Iterator iter (path);

  540. 

  541.         bool containsClosedSubPath = false;

  542.         while (iter.next())

  543.         {

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

  545.             {

  546.                 containsClosedSubPath = true;

  547.                 break;

  548.             }

  549.         }

  550. 

  551.         dp->setFill (getPathFillType (path,

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

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

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

  555.                                       containsClosedSubPath ? Colours::black

  556.                                                             : Colours::transparentBlack));

  557. 

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

  559. 

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

  561.         {

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

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

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

  565.                                                 Colours::transparentBlack));

  566. 

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

  568.         }

  569. 

  570.         return dp;

  571.     }

  572. 

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

  574.     {

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

  576. 

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

  578.             return nullptr;

  579. 

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

  581.     }

  582. 

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

  584.     {

  585.         if (fillXml == 0)

  586.             return;

  587. 

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

  589.         {

  590.             int index = 0;

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

  592. 

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

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

  595. 

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

  597. 

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

  599.                 offset *= 0.01;

  600. 

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

  602.         }

  603.     }

  604. 

  605.     FillType getPathFillType (const Path& path,

  606.                               const String& fill,

  607.                               const String& fillOpacity,

  608.                               const String& overallOpacity,

  609.                               const Colour& defaultColour) const

  610.     {

  611.         float opacity = 1.0f;

  612. 

  613.         if (overallOpacity.isNotEmpty())

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

  615. 

  616.         if (fillOpacity.isNotEmpty())

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

  618. 

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

  620.         {

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

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

  623. 

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

  625. 

  626.             if (fillXml != nullptr

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

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

  629.             {

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

  631. 

  632.                 ColourGradient gradient;

  633. 

  634.                 addGradientStopsIn (gradient, inheritedFrom);

  635.                 addGradientStopsIn (gradient, fillXml);

  636. 

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

  638.                 {

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

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

  641.                 }

  642.                 else

  643.                 {

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

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

  646.                 }

  647. 

  648.                 if (overallOpacity.isNotEmpty())

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

  650. 

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

  652. 

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

  654. 

  655.                 float gradientWidth = viewBoxW;

  656.                 float gradientHeight = viewBoxH;

  657.                 float dx = 0.0f;

  658.                 float dy = 0.0f;

  659. 

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

  661. 

  662.                 if (! userSpace)

  663.                 {

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

  665.                     dx = bounds.getX();

  666.                     dy = bounds.getY();

  667.                     gradientWidth = bounds.getWidth();

  668.                     gradientHeight = bounds.getHeight();

  669.                 }

  670. 

  671.                 if (gradient.isRadial)

  672.                 {

  673.                     if (userSpace)

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

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

  676.                     else

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

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

  679. 

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

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

  682. 

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

  684.                 }

  685.                 else

  686.                 {

  687.                     if (userSpace)

  688.                     {

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

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

  691. 

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

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

  694.                     }

  695.                     else

  696.                     {

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

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

  699. 

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

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

  702.                     }

  703. 

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

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

  706.                 }

  707. 

  708.                 FillType type (gradient);

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

  710.                                    .followedBy (transform);

  711.                 return type;

  712.             }

  713.         }

  714. 

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

  716.             return Colours::transparentBlack;

  717. 

  718.         int i = 0;

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

  720.         return colour.withMultipliedAlpha (opacity);

  721.     }

  722. 

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

  724.     {

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

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

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

  728. 

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

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

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

  732. 

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

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

  735. 

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

  737.             joinStyle = PathStrokeType::curved;

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

  739.             joinStyle = PathStrokeType::beveled;

  740. 

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

  742.             capStyle = PathStrokeType::rounded;

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

  744.             capStyle = PathStrokeType::square;

  745. 

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

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

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

  749. 

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

  751.                                joinStyle, capStyle);

  752.     }

  753. 

  754.     //==============================================================================

  755.     Drawable* parseText (const XmlElement& xml)

  756.     {

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

  758. 

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

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

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

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

  763. 

  764. 

  765.         //xxx not done text yet!

  766. 

  767. 

  768.         forEachXmlChildElement (xml, e)

  769.         {

  770.             if (e->isTextElement())

  771.             {

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

  773. 

  774.                 Path path;

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

  776.                 delete s;  // xxx not finished!

  777.             }

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

  779.             {

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

  781.                 delete s;  // xxx not finished!

  782.             }

  783.         }

  784. 

  785.         return nullptr;

  786.     }

  787. 

  788.     //==============================================================================

  789.     void addTransform (const XmlElement& xml)

  790.     {

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

  792.                         .followedBy (transform);

  793.     }

  794. 

  795.     //==============================================================================

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

  797.     {

  798.         String number;

  799. 

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

  801.         {

  802.             value = 0;

  803.             return false;

  804.         }

  805. 

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

  807.         return true;

  808.     }

  809. 

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

  811.     {

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

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

  814.     }

  815. 

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

  817.     {

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

  819.         if (! b)

  820.             ++s;

  821. 

  822.         return b;

  823.     }

  824. 

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

  826.     {

  827.         float n = s.getFloatValue();

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

  829. 

  830.         if (len > 2)

  831.         {

  832.             const float dpi = 96.0f;

  833. 

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

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

  836. 

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

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

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

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

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

  842.         }

  843. 

  844.         return n;

  845.     }

  846. 

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

  848.                        const bool allowUnits, const bool isX) const

  849.     {

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

  851.         float value;

  852. 

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

  854.             coords.add (value);

  855.     }

  856. 

  857.     //==============================================================================

  858.     void parseCSSStyle (const XmlElement& xml)

  859.     {

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

  861.     }

  862. 

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

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

  865.     {

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

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

  868. 

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

  870. 

  871.         if (styleAtt.isNotEmpty())

  872.         {

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

  874. 

  875.             if (value.isNotEmpty())

  876.                 return value;

  877.         }

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

  879.         {

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

  881. 

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

  883. 

  884.             if (index < 0)

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

  886. 

  887.             if (index >= 0)

  888.             {

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

  890. 

  891.                 if (openBracket > index)

  892.                 {

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

  894. 

  895.                     if (closeBracket > openBracket)

  896.                     {

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

  898. 

  899.                         if (value.isNotEmpty())

  900.                             return value;

  901.                     }

  902.                 }

  903.             }

  904.         }

  905. 

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

  907. 

  908.         if (xml != nullptr)

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

  910. 

  911.         return defaultValue;

  912.     }

  913. 

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

  915.     {

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

  917.             return xml->getStringAttribute (attributeName);

  918. 

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

  920. 

  921.         if (xml != nullptr)

  922.             return getInheritedAttribute  (xml, attributeName);

  923. 

  924.         return String::empty;

  925.     }

  926. 

  927.     //==============================================================================

  928.     static bool isIdentifierChar (const juce_wchar c)

  929.     {

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

  931.     }

  932. 

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

  934.     {

  935.         int i = 0;

  936. 

  937.         for (;;)

  938.         {

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

  940. 

  941.             if (i < 0)

  942.                 break;

  943. 

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

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

  946.             {

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

  948. 

  949.                 if (i < 0)

  950.                     break;

  951. 

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

  953. 

  954.                 if (end < 0)

  955.                     end = 0x7ffff;

  956. 

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

  958.             }

  959. 

  960.             ++i;

  961.         }

  962. 

  963.         return defaultValue;

  964.     }

  965. 

  966.     //==============================================================================

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

  968.     {

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

  970.             ++s;

  971. 

  972.         String::CharPointerType start (s);

  973.         int numChars = 0;

  974. 

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

  976.         {

  977.             ++numChars;

  978.             ++s;

  979.         }

  980. 

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

  982.         {

  983.             ++numChars;

  984.             ++s;

  985.         }

  986. 

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

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

  989.         {

  990.             s += 2;

  991.             numChars += 2;

  992. 

  993.             while (s.isDigit())

  994.             {

  995.                 ++numChars;

  996.                 ++s;

  997.             }

  998.         }

  999. 

  1000.         if (allowUnits)

  1001.         {

  1002.             while (s.isLetter())

  1003.             {

  1004.                 ++numChars;

  1005.                 ++s;

  1006.             }

  1007.         }

  1008. 

  1009.         if (numChars == 0)

  1010.             return false;

  1011. 

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

  1013. 

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

  1015.             ++s;

  1016. 

  1017.         return true;

  1018.     }

  1019. 

  1020.     //==============================================================================

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

  1022.     {

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

  1024.         {

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

  1026.             int numChars = 0;

  1027. 

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

  1029.             {

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

  1031. 

  1032.                 if (hexValue >= 0)

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

  1034.                 else

  1035.                     break;

  1036.             }

  1037. 

  1038.             if (numChars <= 3)

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

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

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

  1042.             else

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

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

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

  1046.         }

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

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

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

  1050.         {

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

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

  1053. 

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

  1055.             {

  1056.                 index = closeBracket;

  1057. 

  1058.                 StringArray tokens;

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

  1060.                 tokens.trim();

  1061.                 tokens.removeEmptyStrings();

  1062. 

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

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

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

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

  1067.                 else

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

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

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

  1071.             }

  1072.         }

  1073. 

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

  1075.     }

  1076. 

  1077.     static const AffineTransform parseTransform (String t)

  1078.     {

  1079.         AffineTransform result;

  1080. 

  1081.         while (t.isNotEmpty())

  1082.         {

  1083.             StringArray tokens;

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

  1085.                                .upToFirstOccurrenceOf (")", false, false),

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

  1087. 

  1088.             tokens.removeEmptyStrings (true);

  1089. 

  1090.             float numbers [6];

  1091. 

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

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

  1094. 

  1095.             AffineTransform trans;

  1096. 

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

  1098.             {

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

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

  1101.             }

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

  1103.             {

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

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

  1106.             }

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

  1108.             {

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

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

  1111.                 else

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

  1113.             }

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

  1115.             {

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

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

  1118.                 else

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

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

  1121.             }

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

  1123.             {

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

  1125.                                          0.0f, 1.0f, 0.0f);

  1126.             }

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

  1128.             {

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

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

  1131.             }

  1132. 

  1133.             result = trans.followedBy (result);

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

  1135.         }

  1136. 

  1137.         return result;

  1138.     }

  1139. 

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

  1141.                                             const double x2, const double y2,

  1142.                                             const double angle,

  1143.                                             const bool largeArc, const bool sweep,

  1144.                                             double& rx, double& ry,

  1145.                                             double& centreX, double& centreY,

  1146.                                             double& startAngle, double& deltaAngle)

  1147.     {

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

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

  1150. 

  1151.         const double cosAngle = cos (angle);

  1152.         const double sinAngle = sin (angle);

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

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

  1155.         const double xp2 = xp * xp;

  1156.         const double yp2 = yp * yp;

  1157. 

  1158.         double rx2 = rx * rx;

  1159.         double ry2 = ry * ry;

  1160. 

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

  1162.         double c;

  1163. 

  1164.         if (s <= 1.0)

  1165.         {

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

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

  1168. 

  1169.             if (largeArc == sweep)

  1170.                 c = -c;

  1171.         }

  1172.         else

  1173.         {

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

  1175.             rx *= s2;

  1176.             ry *= s2;

  1177.             rx2 = rx * rx;

  1178.             ry2 = ry * ry;

  1179.             c = 0;

  1180.         }

  1181. 

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

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

  1184. 

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

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

  1187. 

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

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

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

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

  1192. 

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

  1194. 

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

  1196. 

  1197.         if (uy < 0)

  1198.             startAngle = -startAngle;

  1199. 

  1200.         startAngle += double_Pi * 0.5;

  1201. 

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

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

  1204. 

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

  1206.             deltaAngle = -deltaAngle;

  1207. 

  1208.         if (sweep)

  1209.         {

  1210.             if (deltaAngle < 0)

  1211.                 deltaAngle += double_Pi * 2.0;

  1212.         }

  1213.         else

  1214.         {

  1215.             if (deltaAngle > 0)

  1216.                 deltaAngle -= double_Pi * 2.0;

  1217.         }

  1218. 

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

  1220.     }

  1221. 

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

  1223.     {

  1224.         forEachXmlChildElement (*parent, e)

  1225.         {

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

  1227.                 return e;

  1228. 

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

  1230. 

  1231.             if (found != nullptr)

  1232.                 return found;

  1233.         }

  1234. 

  1235.         return nullptr;

  1236.     }

  1237. 

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

  1239. };

  1240. 

  1241. 

  1242. //==============================================================================

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

  1244. {

  1245.     SVGState state (&svgDocument);

  1246.     return state.parseSVGElement (svgDocument);

  1247. }