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.
1752 Commits
11 Branches
1.3GB
Tree: 43d9a4eb16
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '43d9a4eb16'
${ noResults }
JUCE/modules/juce_gui_basics/drawables/juce_SVGParser.cpp

1303 lines
45KB
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. BEGIN_JUCE_NAMESPACE

  27. 

  28. //==============================================================================

  29. class SVGState

  30. {

  31. public:

  32.     //==============================================================================

  33.     SVGState (const XmlElement* const topLevel)

  34.         : topLevelXml (topLevel),

  35.           elementX (0), elementY (0),

  36.           width (512), height (512),

  37.           viewBoxW (0), viewBoxH (0)

  38.     {

  39.     }

  40. 

  41.     //==============================================================================

  42.     Drawable* parseSVGElement (const XmlElement& xml)

  43.     {

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

  45.             return nullptr;

  46. 

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

  48. 

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

  50. 

  51.         SVGState newState (*this);

  52. 

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

  54.             newState.addTransform (xml);

  55. 

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

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

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

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

  60. 

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

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

  63. 

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

  65.         {

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

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

  68.             float vx, vy, vw, vh;

  69. 

  70.             if (parseCoords (viewParams, vx, vy, true)

  71.                  && parseCoords (viewParams, vw, vh, true)

  72.                  && vw > 0

  73.                  && vh > 0)

  74.             {

  75.                 newState.viewBoxW = vw;

  76.                 newState.viewBoxH = vh;

  77. 

  78.                 int placementFlags = 0;

  79. 

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

  81. 

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

  83.                 {

  84.                     placementFlags = RectanglePlacement::stretchToFit;

  85.                 }

  86.                 else

  87.                 {

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

  89.                         placementFlags |= RectanglePlacement::fillDestination;

  90. 

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

  92.                         placementFlags |= RectanglePlacement::xLeft;

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

  94.                         placementFlags |= RectanglePlacement::xRight;

  95.                     else

  96.                         placementFlags |= RectanglePlacement::xMid;

  97. 

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

  99.                         placementFlags |= RectanglePlacement::yTop;

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

  101.                         placementFlags |= RectanglePlacement::yBottom;

  102.                     else

  103.                         placementFlags |= RectanglePlacement::yMid;

  104.                 }

  105. 

  106.                 const RectanglePlacement placement (placementFlags);

  107. 

  108.                 newState.transform

  109.                     = placement.getTransformToFit (Rectangle<float> (vx, vy, vw, vh),

  110.                                                    Rectangle<float> (0.0f, 0.0f, newState.width, newState.height))

  111.                                .followedBy (newState.transform);

  112.             }

  113.         }

  114.         else

  115.         {

  116.             if (viewBoxW == 0)

  117.                 newState.viewBoxW = newState.width;

  118. 

  119.             if (viewBoxH == 0)

  120.                 newState.viewBoxH = newState.height;

  121.         }

  122. 

  123.         newState.parseSubElements (xml, drawable);

  124. 

  125.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  126.         return drawable;

  127.     }

  128. 

  129. private:

  130.     //==============================================================================

  131.     const XmlElement* const topLevelXml;

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

  133.     AffineTransform transform;

  134.     String cssStyleText;

  135. 

  136.     //==============================================================================

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

  138.     {

  139.         forEachXmlChildElement (xml, e)

  140.         {

  141.             Drawable* d = nullptr;

  142. 

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

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

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

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

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

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

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

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

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

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

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

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

  155. 

  156.             parentDrawable->addAndMakeVisible (d);

  157.         }

  158.     }

  159. 

  160.     DrawableComposite* parseSwitch (const XmlElement& xml)

  161.     {

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

  163. 

  164.         if (group != nullptr)

  165.             return parseGroupElement (*group);

  166. 

  167.         return nullptr;

  168.     }

  169. 

  170.     DrawableComposite* parseGroupElement (const XmlElement& xml)

  171.     {

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

  173. 

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

  175. 

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

  177.         {

  178.             SVGState newState (*this);

  179.             newState.addTransform (xml);

  180. 

  181.             newState.parseSubElements (xml, drawable);

  182.         }

  183.         else

  184.         {

  185.             parseSubElements (xml, drawable);

  186.         }

  187. 

  188.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  189.         return drawable;

  190.     }

  191. 

  192.     //==============================================================================

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

  194.     {

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

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

  197.         Path path;

  198. 

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

  200.             path.setUsingNonZeroWinding (false);

  201. 

  202.         float lastX = 0, lastY = 0;

  203.         float lastX2 = 0, lastY2 = 0;

  204.         juce_wchar lastCommandChar = 0;

  205.         bool isRelative = true;

  206.         bool carryOn = true;

  207. 

  208.         const CharPointer_ASCII validCommandChars ("MmLlHhVvCcSsQqTtAaZz");

  209. 

  210.         while (! d.isEmpty())

  211.         {

  212.             float x, y, x2, y2, x3, y3;

  213. 

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

  215.             {

  216.                 lastCommandChar = d.getAndAdvance();

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

  218.             }

  219. 

  220.             switch (lastCommandChar)

  221.             {

  222.             case 'M':

  223.             case 'm':

  224.             case 'L':

  225.             case 'l':

  226.                 if (parseCoords (d, x, y, false))

  227.                 {

  228.                     if (isRelative)

  229.                     {

  230.                         x += lastX;

  231.                         y += lastY;

  232.                     }

  233. 

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

  235.                     {

  236.                         path.startNewSubPath (x, y);

  237.                         lastCommandChar = 'l';

  238.                     }

  239.                     else

  240.                         path.lineTo (x, y);

  241. 

  242.                     lastX2 = lastX;

  243.                     lastY2 = lastY;

  244.                     lastX = x;

  245.                     lastY = y;

  246.                 }

  247.                 else

  248.                 {

  249.                     ++d;

  250.                 }

  251. 

  252.                 break;

  253. 

  254.             case 'H':

  255.             case 'h':

  256.                 if (parseCoord (d, x, false, true))

  257.                 {

  258.                     if (isRelative)

  259.                         x += lastX;

  260. 

  261.                     path.lineTo (x, lastY);

  262. 

  263.                     lastX2 = lastX;

  264.                     lastX = x;

  265.                 }

  266.                 else

  267.                 {

  268.                     ++d;

  269.                 }

  270.                 break;

  271. 

  272.             case 'V':

  273.             case 'v':

  274.                 if (parseCoord (d, y, false, false))

  275.                 {

  276.                     if (isRelative)

  277.                         y += lastY;

  278. 

  279.                     path.lineTo (lastX, y);

  280. 

  281.                     lastY2 = lastY;

  282.                     lastY = y;

  283.                 }

  284.                 else

  285.                 {

  286.                     ++d;

  287.                 }

  288.                 break;

  289. 

  290.             case 'C':

  291.             case 'c':

  292.                 if (parseCoords (d, x, y, false)

  293.                      && parseCoords (d, x2, y2, false)

  294.                      && parseCoords (d, x3, y3, false))

  295.                 {

  296.                     if (isRelative)

  297.                     {

  298.                         x += lastX;

  299.                         y += lastY;

  300.                         x2 += lastX;

  301.                         y2 += lastY;

  302.                         x3 += lastX;

  303.                         y3 += lastY;

  304.                     }

  305. 

  306.                     path.cubicTo (x, y, x2, y2, x3, y3);

  307. 

  308.                     lastX2 = x2;

  309.                     lastY2 = y2;

  310.                     lastX = x3;

  311.                     lastY = y3;

  312.                 }

  313.                 else

  314.                 {

  315.                     ++d;

  316.                 }

  317.                 break;

  318. 

  319.             case 'S':

  320.             case 's':

  321.                 if (parseCoords (d, x, y, false)

  322.                      && parseCoords (d, x3, y3, false))

  323.                 {

  324.                     if (isRelative)

  325.                     {

  326.                         x += lastX;

  327.                         y += lastY;

  328.                         x3 += lastX;

  329.                         y3 += lastY;

  330.                     }

  331. 

  332.                     x2 = lastX + (lastX - lastX2);

  333.                     y2 = lastY + (lastY - lastY2);

  334.                     path.cubicTo (x2, y2, x, y, x3, y3);

  335. 

  336.                     lastX2 = x;

  337.                     lastY2 = y;

  338.                     lastX = x3;

  339.                     lastY = y3;

  340.                 }

  341.                 else

  342.                 {

  343.                     ++d;

  344.                 }

  345.                 break;

  346. 

  347.             case 'Q':

  348.             case 'q':

  349.                 if (parseCoords (d, x, y, false)

  350.                      && parseCoords (d, x2, y2, false))

  351.                 {

  352.                     if (isRelative)

  353.                     {

  354.                         x += lastX;

  355.                         y += lastY;

  356.                         x2 += lastX;

  357.                         y2 += lastY;

  358.                     }

  359. 

  360.                     path.quadraticTo (x, y, x2, y2);

  361. 

  362.                     lastX2 = x;

  363.                     lastY2 = y;

  364.                     lastX = x2;

  365.                     lastY = y2;

  366.                 }

  367.                 else

  368.                 {

  369.                     ++d;

  370.                 }

  371.                 break;

  372. 

  373.             case 'T':

  374.             case 't':

  375.                 if (parseCoords (d, x, y, false))

  376.                 {

  377.                     if (isRelative)

  378.                     {

  379.                         x += lastX;

  380.                         y += lastY;

  381.                     }

  382. 

  383.                     x2 = lastX + (lastX - lastX2);

  384.                     y2 = lastY + (lastY - lastY2);

  385.                     path.quadraticTo (x2, y2, x, y);

  386. 

  387.                     lastX2 = x2;

  388.                     lastY2 = y2;

  389.                     lastX = x;

  390.                     lastY = y;

  391.                 }

  392.                 else

  393.                 {

  394.                     ++d;

  395.                 }

  396.                 break;

  397. 

  398.             case 'A':

  399.             case 'a':

  400.                 if (parseCoords (d, x, y, false))

  401.                 {

  402.                     String num;

  403. 

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

  405.                     {

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

  407. 

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

  409.                         {

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

  411. 

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

  413.                             {

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

  415. 

  416.                                 if (parseCoords (d, x2, y2, false))

  417.                                 {

  418.                                     if (isRelative)

  419.                                     {

  420.                                         x2 += lastX;

  421.                                         y2 += lastY;

  422.                                     }

  423. 

  424.                                     if (lastX != x2 || lastY != y2)

  425.                                     {

  426.                                         double centreX, centreY, startAngle, deltaAngle;

  427.                                         double rx = x, ry = y;

  428. 

  429.                                         endpointToCentreParameters (lastX, lastY, x2, y2,

  430.                                                                     angle, largeArc, sweep,

  431.                                                                     rx, ry, centreX, centreY,

  432.                                                                     startAngle, deltaAngle);

  433. 

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

  435.                                                             (float) rx, (float) ry,

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

  437.                                                             false);

  438. 

  439.                                         path.lineTo (x2, y2);

  440.                                     }

  441. 

  442.                                     lastX2 = lastX;

  443.                                     lastY2 = lastY;

  444.                                     lastX = x2;

  445.                                     lastY = y2;

  446.                                 }

  447.                             }

  448.                         }

  449.                     }

  450.                 }

  451.                 else

  452.                 {

  453.                     ++d;

  454.                 }

  455. 

  456.                 break;

  457. 

  458.             case 'Z':

  459.             case 'z':

  460.                 path.closeSubPath();

  461.                 d = d.findEndOfWhitespace();

  462.                 break;

  463. 

  464.             default:

  465.                 carryOn = false;

  466.                 break;

  467.             }

  468. 

  469.             if (! carryOn)

  470.                 break;

  471.         }

  472. 

  473.         return parseShape (xml, path);

  474.     }

  475. 

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

  477.     {

  478.         Path rect;

  479. 

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

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

  482. 

  483.         if (hasRX || hasRY)

  484.         {

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

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

  487. 

  488.             if (! hasRX)

  489.                 rx = ry;

  490.             else if (! hasRY)

  491.                 ry = rx;

  492. 

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

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

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

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

  497.                                       rx, ry);

  498.         }

  499.         else

  500.         {

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

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

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

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

  505.         }

  506. 

  507.         return parseShape (xml, rect);

  508.     }

  509. 

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

  511.     {

  512.         Path circle;

  513. 

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

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

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

  517. 

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

  519. 

  520.         return parseShape (xml, circle);

  521.     }

  522. 

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

  524.     {

  525.         Path ellipse;

  526. 

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

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

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

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

  531. 

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

  533. 

  534.         return parseShape (xml, ellipse);

  535.     }

  536. 

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

  538.     {

  539.         Path line;

  540. 

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

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

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

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

  545. 

  546.         line.startNewSubPath (x1, y1);

  547.         line.lineTo (x2, y2);

  548. 

  549.         return parseShape (xml, line);

  550.     }

  551. 

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

  553.     {

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

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

  556.         Path path;

  557.         float x, y;

  558. 

  559.         if (parseCoords (points, x, y, true))

  560.         {

  561.             float firstX = x;

  562.             float firstY = y;

  563.             float lastX = 0, lastY = 0;

  564. 

  565.             path.startNewSubPath (x, y);

  566. 

  567.             while (parseCoords (points, x, y, true))

  568.             {

  569.                 lastX = x;

  570.                 lastY = y;

  571.                 path.lineTo (x, y);

  572.             }

  573. 

  574.             if ((! isPolyline) || (firstX == lastX && firstY == lastY))

  575.                 path.closeSubPath();

  576.         }

  577. 

  578.         return parseShape (xml, path);

  579.     }

  580. 

  581.     //==============================================================================

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

  583.                           const bool shouldParseTransform = true) const

  584.     {

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

  586.         {

  587.             SVGState newState (*this);

  588.             newState.addTransform (xml);

  589. 

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

  591.         }

  592. 

  593.         DrawablePath* dp = new DrawablePath();

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

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

  596. 

  597.         path.applyTransform (transform);

  598.         dp->setPath (path);

  599. 

  600.         Path::Iterator iter (path);

  601. 

  602.         bool containsClosedSubPath = false;

  603.         while (iter.next())

  604.         {

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

  606.             {

  607.                 containsClosedSubPath = true;

  608.                 break;

  609.             }

  610.         }

  611. 

  612.         dp->setFill (getPathFillType (path,

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

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

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

  616.                                       containsClosedSubPath ? Colours::black

  617.                                                             : Colours::transparentBlack));

  618. 

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

  620. 

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

  622.         {

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

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

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

  626.                                                 Colours::transparentBlack));

  627. 

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

  629.         }

  630. 

  631.         return dp;

  632.     }

  633. 

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

  635.     {

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

  637. 

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

  639.             return nullptr;

  640. 

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

  642.     }

  643. 

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

  645.     {

  646.         if (fillXml == 0)

  647.             return;

  648. 

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

  650.         {

  651.             int index = 0;

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

  653. 

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

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

  656. 

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

  658. 

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

  660.                 offset *= 0.01;

  661. 

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

  663.         }

  664.     }

  665. 

  666.     FillType getPathFillType (const Path& path,

  667.                               const String& fill,

  668.                               const String& fillOpacity,

  669.                               const String& overallOpacity,

  670.                               const Colour& defaultColour) const

  671.     {

  672.         float opacity = 1.0f;

  673. 

  674.         if (overallOpacity.isNotEmpty())

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

  676. 

  677.         if (fillOpacity.isNotEmpty())

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

  679. 

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

  681.         {

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

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

  684. 

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

  686. 

  687.             if (fillXml != nullptr

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

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

  690.             {

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

  692. 

  693.                 ColourGradient gradient;

  694. 

  695.                 addGradientStopsIn (gradient, inheritedFrom);

  696.                 addGradientStopsIn (gradient, fillXml);

  697. 

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

  699.                 {

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

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

  702.                 }

  703.                 else

  704.                 {

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

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

  707.                 }

  708. 

  709.                 if (overallOpacity.isNotEmpty())

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

  711. 

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

  713. 

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

  715. 

  716.                 float gradientWidth = viewBoxW;

  717.                 float gradientHeight = viewBoxH;

  718.                 float dx = 0.0f;

  719.                 float dy = 0.0f;

  720. 

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

  722. 

  723.                 if (! userSpace)

  724.                 {

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

  726.                     dx = bounds.getX();

  727.                     dy = bounds.getY();

  728.                     gradientWidth = bounds.getWidth();

  729.                     gradientHeight = bounds.getHeight();

  730.                 }

  731. 

  732.                 if (gradient.isRadial)

  733.                 {

  734.                     if (userSpace)

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

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

  737.                     else

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

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

  740. 

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

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

  743. 

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

  745.                 }

  746.                 else

  747.                 {

  748.                     if (userSpace)

  749.                     {

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

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

  752. 

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

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

  755.                     }

  756.                     else

  757.                     {

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

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

  760. 

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

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

  763.                     }

  764. 

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

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

  767.                 }

  768. 

  769.                 FillType type (gradient);

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

  771.                                    .followedBy (transform);

  772.                 return type;

  773.             }

  774.         }

  775. 

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

  777.             return Colours::transparentBlack;

  778. 

  779.         int i = 0;

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

  781.         return colour.withMultipliedAlpha (opacity);

  782.     }

  783. 

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

  785.     {

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

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

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

  789. 

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

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

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

  793. 

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

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

  796. 

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

  798.             joinStyle = PathStrokeType::curved;

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

  800.             joinStyle = PathStrokeType::beveled;

  801. 

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

  803.             capStyle = PathStrokeType::rounded;

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

  805.             capStyle = PathStrokeType::square;

  806. 

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

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

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

  810. 

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

  812.                                joinStyle, capStyle);

  813.     }

  814. 

  815.     //==============================================================================

  816.     Drawable* parseText (const XmlElement& xml)

  817.     {

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

  819. 

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

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

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

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

  824. 

  825. 

  826.         //xxx not done text yet!

  827. 

  828. 

  829.         forEachXmlChildElement (xml, e)

  830.         {

  831.             if (e->isTextElement())

  832.             {

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

  834. 

  835.                 Path path;

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

  837.                 delete s;  // xxx not finished!

  838.             }

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

  840.             {

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

  842.                 delete s;  // xxx not finished!

  843.             }

  844.         }

  845. 

  846.         return nullptr;

  847.     }

  848. 

  849.     //==============================================================================

  850.     void addTransform (const XmlElement& xml)

  851.     {

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

  853.                         .followedBy (transform);

  854.     }

  855. 

  856.     //==============================================================================

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

  858.     {

  859.         String number;

  860. 

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

  862.         {

  863.             value = 0;

  864.             return false;

  865.         }

  866. 

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

  868.         return true;

  869.     }

  870. 

  871.     bool parseCoords (String::CharPointerType& s, float& x, float& y, const bool allowUnits) const

  872.     {

  873.         return parseCoord (s, x, allowUnits, true)

  874.             && parseCoord (s, y, allowUnits, false);

  875.     }

  876. 

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

  878.     {

  879.         float n = s.getFloatValue();

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

  881. 

  882.         if (len > 2)

  883.         {

  884.             const float dpi = 96.0f;

  885. 

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

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

  888. 

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

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

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

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

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

  894.         }

  895. 

  896.         return n;

  897.     }

  898. 

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

  900.                        const bool allowUnits, const bool isX) const

  901.     {

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

  903.         float value;

  904. 

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

  906.             coords.add (value);

  907.     }

  908. 

  909.     //==============================================================================

  910.     void parseCSSStyle (const XmlElement& xml)

  911.     {

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

  913.     }

  914. 

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

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

  917.     {

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

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

  920. 

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

  922. 

  923.         if (styleAtt.isNotEmpty())

  924.         {

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

  926. 

  927.             if (value.isNotEmpty())

  928.                 return value;

  929.         }

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

  931.         {

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

  933. 

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

  935. 

  936.             if (index < 0)

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

  938. 

  939.             if (index >= 0)

  940.             {

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

  942. 

  943.                 if (openBracket > index)

  944.                 {

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

  946. 

  947.                     if (closeBracket > openBracket)

  948.                     {

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

  950. 

  951.                         if (value.isNotEmpty())

  952.                             return value;

  953.                     }

  954.                 }

  955.             }

  956.         }

  957. 

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

  959. 

  960.         if (xml != nullptr)

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

  962. 

  963.         return defaultValue;

  964.     }

  965. 

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

  967.     {

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

  969.             return xml->getStringAttribute (attributeName);

  970. 

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

  972. 

  973.         if (xml != nullptr)

  974.             return getInheritedAttribute  (xml, attributeName);

  975. 

  976.         return String::empty;

  977.     }

  978. 

  979.     //==============================================================================

  980.     static bool isIdentifierChar (const juce_wchar c)

  981.     {

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

  983.     }

  984. 

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

  986.     {

  987.         int i = 0;

  988. 

  989.         for (;;)

  990.         {

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

  992. 

  993.             if (i < 0)

  994.                 break;

  995. 

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

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

  998.             {

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

  1000. 

  1001.                 if (i < 0)

  1002.                     break;

  1003. 

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

  1005. 

  1006.                 if (end < 0)

  1007.                     end = 0x7ffff;

  1008. 

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

  1010.             }

  1011. 

  1012.             ++i;

  1013.         }

  1014. 

  1015.         return defaultValue;

  1016.     }

  1017. 

  1018.     //==============================================================================

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

  1020.     {

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

  1022.             ++s;

  1023. 

  1024.         String::CharPointerType start (s);

  1025.         int numChars = 0;

  1026. 

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

  1028.         {

  1029.             ++numChars;

  1030.             ++s;

  1031.         }

  1032. 

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

  1034.         {

  1035.             ++numChars;

  1036.             ++s;

  1037.         }

  1038. 

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

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

  1041.         {

  1042.             s += 2;

  1043.             numChars += 2;

  1044. 

  1045.             while (s.isDigit())

  1046.             {

  1047.                 ++numChars;

  1048.                 ++s;

  1049.             }

  1050.         }

  1051. 

  1052.         if (allowUnits)

  1053.         {

  1054.             while (s.isLetter())

  1055.             {

  1056.                 ++numChars;

  1057.                 ++s;

  1058.             }

  1059.         }

  1060. 

  1061.         if (numChars == 0)

  1062.             return false;

  1063. 

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

  1065. 

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

  1067.             ++s;

  1068. 

  1069.         return true;

  1070.     }

  1071. 

  1072.     //==============================================================================

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

  1074.     {

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

  1076.         {

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

  1078.             int numChars = 0;

  1079. 

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

  1081.             {

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

  1083. 

  1084.                 if (hexValue >= 0)

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

  1086.                 else

  1087.                     break;

  1088.             }

  1089. 

  1090.             if (numChars <= 3)

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

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

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

  1094.             else

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

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

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

  1098.         }

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

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

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

  1102.         {

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

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

  1105. 

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

  1107.             {

  1108.                 index = closeBracket;

  1109. 

  1110.                 StringArray tokens;

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

  1112.                 tokens.trim();

  1113.                 tokens.removeEmptyStrings();

  1114. 

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

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

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

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

  1119.                 else

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

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

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

  1123.             }

  1124.         }

  1125. 

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

  1127.     }

  1128. 

  1129.     static const AffineTransform parseTransform (String t)

  1130.     {

  1131.         AffineTransform result;

  1132. 

  1133.         while (t.isNotEmpty())

  1134.         {

  1135.             StringArray tokens;

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

  1137.                                .upToFirstOccurrenceOf (")", false, false),

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

  1139. 

  1140.             tokens.removeEmptyStrings (true);

  1141. 

  1142.             float numbers [6];

  1143. 

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

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

  1146. 

  1147.             AffineTransform trans;

  1148. 

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

  1150.             {

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

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

  1153.             }

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

  1155.             {

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

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

  1158.             }

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

  1160.             {

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

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

  1163.                 else

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

  1165.             }

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

  1167.             {

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

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

  1170.                 else

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

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

  1173.             }

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

  1175.             {

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

  1177.                                          0.0f, 1.0f, 0.0f);

  1178.             }

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

  1180.             {

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

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

  1183.             }

  1184. 

  1185.             result = trans.followedBy (result);

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

  1187.         }

  1188. 

  1189.         return result;

  1190.     }

  1191. 

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

  1193.                                             const double x2, const double y2,

  1194.                                             const double angle,

  1195.                                             const bool largeArc, const bool sweep,

  1196.                                             double& rx, double& ry,

  1197.                                             double& centreX, double& centreY,

  1198.                                             double& startAngle, double& deltaAngle)

  1199.     {

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

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

  1202. 

  1203.         const double cosAngle = cos (angle);

  1204.         const double sinAngle = sin (angle);

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

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

  1207.         const double xp2 = xp * xp;

  1208.         const double yp2 = yp * yp;

  1209. 

  1210.         double rx2 = rx * rx;

  1211.         double ry2 = ry * ry;

  1212. 

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

  1214.         double c;

  1215. 

  1216.         if (s <= 1.0)

  1217.         {

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

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

  1220. 

  1221.             if (largeArc == sweep)

  1222.                 c = -c;

  1223.         }

  1224.         else

  1225.         {

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

  1227.             rx *= s2;

  1228.             ry *= s2;

  1229.             rx2 = rx * rx;

  1230.             ry2 = ry * ry;

  1231.             c = 0;

  1232.         }

  1233. 

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

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

  1236. 

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

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

  1239. 

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

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

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

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

  1244. 

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

  1246. 

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

  1248. 

  1249.         if (uy < 0)

  1250.             startAngle = -startAngle;

  1251. 

  1252.         startAngle += double_Pi * 0.5;

  1253. 

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

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

  1256. 

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

  1258.             deltaAngle = -deltaAngle;

  1259. 

  1260.         if (sweep)

  1261.         {

  1262.             if (deltaAngle < 0)

  1263.                 deltaAngle += double_Pi * 2.0;

  1264.         }

  1265.         else

  1266.         {

  1267.             if (deltaAngle > 0)

  1268.                 deltaAngle -= double_Pi * 2.0;

  1269.         }

  1270. 

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

  1272.     }

  1273. 

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

  1275.     {

  1276.         forEachXmlChildElement (*parent, e)

  1277.         {

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

  1279.                 return e;

  1280. 

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

  1282. 

  1283.             if (found != nullptr)

  1284.                 return found;

  1285.         }

  1286. 

  1287.         return nullptr;

  1288.     }

  1289. 

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

  1291. };

  1292. 

  1293. 

  1294. //==============================================================================

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

  1296. {

  1297.     SVGState state (&svgDocument);

  1298.     return state.parseSVGElement (svgDocument);

  1299. }

  1300. 

  1301. 

  1302. END_JUCE_NAMESPACE