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

1297 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. 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.             float vx, vy, vw, vh;

  66. 

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

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

  69.                  && vw > 0

  70.                  && vh > 0)

  71.             {

  72.                 newState.viewBoxW = vw;

  73.                 newState.viewBoxH = vh;

  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> (vx, vy, vw, vh),

  107.                                                    Rectangle<float> (0.0f, 0.0f, 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.         float lastX = 0, lastY = 0;

  200.         float lastX2 = 0, lastY2 = 0;

  201.         juce_wchar lastCommandChar = 0;

  202.         bool isRelative = true;

  203.         bool carryOn = true;

  204. 

  205.         const CharPointer_ASCII validCommandChars ("MmLlHhVvCcSsQqTtAaZz");

  206. 

  207.         while (! d.isEmpty())

  208.         {

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

  210. 

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

  212.             {

  213.                 lastCommandChar = d.getAndAdvance();

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

  215.             }

  216. 

  217.             switch (lastCommandChar)

  218.             {

  219.             case 'M':

  220.             case 'm':

  221.             case 'L':

  222.             case 'l':

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

  224.                 {

  225.                     if (isRelative)

  226.                     {

  227.                         x += lastX;

  228.                         y += lastY;

  229.                     }

  230. 

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

  232.                     {

  233.                         path.startNewSubPath (x, y);

  234.                         lastCommandChar = 'l';

  235.                     }

  236.                     else

  237.                         path.lineTo (x, y);

  238. 

  239.                     lastX2 = lastX;

  240.                     lastY2 = lastY;

  241.                     lastX = x;

  242.                     lastY = y;

  243.                 }

  244.                 else

  245.                 {

  246.                     ++d;

  247.                 }

  248. 

  249.                 break;

  250. 

  251.             case 'H':

  252.             case 'h':

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

  254.                 {

  255.                     if (isRelative)

  256.                         x += lastX;

  257. 

  258.                     path.lineTo (x, lastY);

  259. 

  260.                     lastX2 = lastX;

  261.                     lastX = x;

  262.                 }

  263.                 else

  264.                 {

  265.                     ++d;

  266.                 }

  267.                 break;

  268. 

  269.             case 'V':

  270.             case 'v':

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

  272.                 {

  273.                     if (isRelative)

  274.                         y += lastY;

  275. 

  276.                     path.lineTo (lastX, y);

  277. 

  278.                     lastY2 = lastY;

  279.                     lastY = y;

  280.                 }

  281.                 else

  282.                 {

  283.                     ++d;

  284.                 }

  285.                 break;

  286. 

  287.             case 'C':

  288.             case 'c':

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

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

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

  292.                 {

  293.                     if (isRelative)

  294.                     {

  295.                         x += lastX;

  296.                         y += lastY;

  297.                         x2 += lastX;

  298.                         y2 += lastY;

  299.                         x3 += lastX;

  300.                         y3 += lastY;

  301.                     }

  302. 

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

  304. 

  305.                     lastX2 = x2;

  306.                     lastY2 = y2;

  307.                     lastX = x3;

  308.                     lastY = y3;

  309.                 }

  310.                 else

  311.                 {

  312.                     ++d;

  313.                 }

  314.                 break;

  315. 

  316.             case 'S':

  317.             case 's':

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

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

  320.                 {

  321.                     if (isRelative)

  322.                     {

  323.                         x += lastX;

  324.                         y += lastY;

  325.                         x3 += lastX;

  326.                         y3 += lastY;

  327.                     }

  328. 

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

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

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

  332. 

  333.                     lastX2 = x;

  334.                     lastY2 = y;

  335.                     lastX = x3;

  336.                     lastY = y3;

  337.                 }

  338.                 else

  339.                 {

  340.                     ++d;

  341.                 }

  342.                 break;

  343. 

  344.             case 'Q':

  345.             case 'q':

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

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

  348.                 {

  349.                     if (isRelative)

  350.                     {

  351.                         x += lastX;

  352.                         y += lastY;

  353.                         x2 += lastX;

  354.                         y2 += lastY;

  355.                     }

  356. 

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

  358. 

  359.                     lastX2 = x;

  360.                     lastY2 = y;

  361.                     lastX = x2;

  362.                     lastY = y2;

  363.                 }

  364.                 else

  365.                 {

  366.                     ++d;

  367.                 }

  368.                 break;

  369. 

  370.             case 'T':

  371.             case 't':

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

  373.                 {

  374.                     if (isRelative)

  375.                     {

  376.                         x += lastX;

  377.                         y += lastY;

  378.                     }

  379. 

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

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

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

  383. 

  384.                     lastX2 = x2;

  385.                     lastY2 = y2;

  386.                     lastX = x;

  387.                     lastY = y;

  388.                 }

  389.                 else

  390.                 {

  391.                     ++d;

  392.                 }

  393.                 break;

  394. 

  395.             case 'A':

  396.             case 'a':

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

  398.                 {

  399.                     String num;

  400. 

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

  402.                     {

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

  404. 

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

  406.                         {

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

  408. 

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

  410.                             {

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

  412. 

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

  414.                                 {

  415.                                     if (isRelative)

  416.                                     {

  417.                                         x2 += lastX;

  418.                                         y2 += lastY;

  419.                                     }

  420. 

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

  422.                                     {

  423.                                         double centreX, centreY, startAngle, deltaAngle;

  424.                                         double rx = x, ry = y;

  425. 

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

  427.                                                                     angle, largeArc, sweep,

  428.                                                                     rx, ry, centreX, centreY,

  429.                                                                     startAngle, deltaAngle);

  430. 

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

  432.                                                             (float) rx, (float) ry,

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

  434.                                                             false);

  435. 

  436.                                         path.lineTo (x2, y2);

  437.                                     }

  438. 

  439.                                     lastX2 = lastX;

  440.                                     lastY2 = lastY;

  441.                                     lastX = x2;

  442.                                     lastY = y2;

  443.                                 }

  444.                             }

  445.                         }

  446.                     }

  447.                 }

  448.                 else

  449.                 {

  450.                     ++d;

  451.                 }

  452. 

  453.                 break;

  454. 

  455.             case 'Z':

  456.             case 'z':

  457.                 path.closeSubPath();

  458.                 d = d.findEndOfWhitespace();

  459.                 break;

  460. 

  461.             default:

  462.                 carryOn = false;

  463.                 break;

  464.             }

  465. 

  466.             if (! carryOn)

  467.                 break;

  468.         }

  469. 

  470.         return parseShape (xml, path);

  471.     }

  472. 

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

  474.     {

  475.         Path rect;

  476. 

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

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

  479. 

  480.         if (hasRX || hasRY)

  481.         {

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

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

  484. 

  485.             if (! hasRX)

  486.                 rx = ry;

  487.             else if (! hasRY)

  488.                 ry = rx;

  489. 

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

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

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

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

  494.                                       rx, ry);

  495.         }

  496.         else

  497.         {

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

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

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

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

  502.         }

  503. 

  504.         return parseShape (xml, rect);

  505.     }

  506. 

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

  508.     {

  509.         Path circle;

  510. 

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

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

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

  514. 

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

  516. 

  517.         return parseShape (xml, circle);

  518.     }

  519. 

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

  521.     {

  522.         Path ellipse;

  523. 

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

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

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

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

  528. 

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

  530. 

  531.         return parseShape (xml, ellipse);

  532.     }

  533. 

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

  535.     {

  536.         Path line;

  537. 

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

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

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

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

  542. 

  543.         line.startNewSubPath (x1, y1);

  544.         line.lineTo (x2, y2);

  545. 

  546.         return parseShape (xml, line);

  547.     }

  548. 

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

  550.     {

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

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

  553.         Path path;

  554.         float x, y;

  555. 

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

  557.         {

  558.             float firstX = x;

  559.             float firstY = y;

  560.             float lastX = 0, lastY = 0;

  561. 

  562.             path.startNewSubPath (x, y);

  563. 

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

  565.             {

  566.                 lastX = x;

  567.                 lastY = y;

  568.                 path.lineTo (x, y);

  569.             }

  570. 

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

  572.                 path.closeSubPath();

  573.         }

  574. 

  575.         return parseShape (xml, path);

  576.     }

  577. 

  578.     //==============================================================================

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

  580.                           const bool shouldParseTransform = true) const

  581.     {

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

  583.         {

  584.             SVGState newState (*this);

  585.             newState.addTransform (xml);

  586. 

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

  588.         }

  589. 

  590.         DrawablePath* dp = new DrawablePath();

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

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

  593. 

  594.         path.applyTransform (transform);

  595.         dp->setPath (path);

  596. 

  597.         Path::Iterator iter (path);

  598. 

  599.         bool containsClosedSubPath = false;

  600.         while (iter.next())

  601.         {

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

  603.             {

  604.                 containsClosedSubPath = true;

  605.                 break;

  606.             }

  607.         }

  608. 

  609.         dp->setFill (getPathFillType (path,

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

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

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

  613.                                       containsClosedSubPath ? Colours::black

  614.                                                             : Colours::transparentBlack));

  615. 

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

  617. 

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

  619.         {

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

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

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

  623.                                                 Colours::transparentBlack));

  624. 

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

  626.         }

  627. 

  628.         return dp;

  629.     }

  630. 

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

  632.     {

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

  634. 

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

  636.             return nullptr;

  637. 

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

  639.     }

  640. 

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

  642.     {

  643.         if (fillXml == 0)

  644.             return;

  645. 

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

  647.         {

  648.             int index = 0;

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

  650. 

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

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

  653. 

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

  655. 

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

  657.                 offset *= 0.01;

  658. 

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

  660.         }

  661.     }

  662. 

  663.     FillType getPathFillType (const Path& path,

  664.                               const String& fill,

  665.                               const String& fillOpacity,

  666.                               const String& overallOpacity,

  667.                               const Colour& defaultColour) const

  668.     {

  669.         float opacity = 1.0f;

  670. 

  671.         if (overallOpacity.isNotEmpty())

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

  673. 

  674.         if (fillOpacity.isNotEmpty())

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

  676. 

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

  678.         {

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

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

  681. 

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

  683. 

  684.             if (fillXml != nullptr

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

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

  687.             {

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

  689. 

  690.                 ColourGradient gradient;

  691. 

  692.                 addGradientStopsIn (gradient, inheritedFrom);

  693.                 addGradientStopsIn (gradient, fillXml);

  694. 

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

  696.                 {

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

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

  699.                 }

  700.                 else

  701.                 {

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

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

  704.                 }

  705. 

  706.                 if (overallOpacity.isNotEmpty())

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

  708. 

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

  710. 

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

  712. 

  713.                 float gradientWidth = viewBoxW;

  714.                 float gradientHeight = viewBoxH;

  715.                 float dx = 0.0f;

  716.                 float dy = 0.0f;

  717. 

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

  719. 

  720.                 if (! userSpace)

  721.                 {

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

  723.                     dx = bounds.getX();

  724.                     dy = bounds.getY();

  725.                     gradientWidth = bounds.getWidth();

  726.                     gradientHeight = bounds.getHeight();

  727.                 }

  728. 

  729.                 if (gradient.isRadial)

  730.                 {

  731.                     if (userSpace)

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

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

  734.                     else

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

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

  737. 

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

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

  740. 

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

  742.                 }

  743.                 else

  744.                 {

  745.                     if (userSpace)

  746.                     {

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

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

  749. 

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

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

  752.                     }

  753.                     else

  754.                     {

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

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

  757. 

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

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

  760.                     }

  761. 

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

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

  764.                 }

  765. 

  766.                 FillType type (gradient);

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

  768.                                    .followedBy (transform);

  769.                 return type;

  770.             }

  771.         }

  772. 

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

  774.             return Colours::transparentBlack;

  775. 

  776.         int i = 0;

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

  778.         return colour.withMultipliedAlpha (opacity);

  779.     }

  780. 

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

  782.     {

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

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

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

  786. 

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

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

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

  790. 

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

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

  793. 

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

  795.             joinStyle = PathStrokeType::curved;

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

  797.             joinStyle = PathStrokeType::beveled;

  798. 

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

  800.             capStyle = PathStrokeType::rounded;

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

  802.             capStyle = PathStrokeType::square;

  803. 

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

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

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

  807. 

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

  809.                                joinStyle, capStyle);

  810.     }

  811. 

  812.     //==============================================================================

  813.     Drawable* parseText (const XmlElement& xml)

  814.     {

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

  816. 

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

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

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

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

  821. 

  822. 

  823.         //xxx not done text yet!

  824. 

  825. 

  826.         forEachXmlChildElement (xml, e)

  827.         {

  828.             if (e->isTextElement())

  829.             {

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

  831. 

  832.                 Path path;

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

  834.                 delete s;  // xxx not finished!

  835.             }

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

  837.             {

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

  839.                 delete s;  // xxx not finished!

  840.             }

  841.         }

  842. 

  843.         return nullptr;

  844.     }

  845. 

  846.     //==============================================================================

  847.     void addTransform (const XmlElement& xml)

  848.     {

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

  850.                         .followedBy (transform);

  851.     }

  852. 

  853.     //==============================================================================

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

  855.     {

  856.         String number;

  857. 

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

  859.         {

  860.             value = 0;

  861.             return false;

  862.         }

  863. 

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

  865.         return true;

  866.     }

  867. 

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

  869.     {

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

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

  872.     }

  873. 

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

  875.     {

  876.         float n = s.getFloatValue();

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

  878. 

  879.         if (len > 2)

  880.         {

  881.             const float dpi = 96.0f;

  882. 

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

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

  885. 

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

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

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

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

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

  891.         }

  892. 

  893.         return n;

  894.     }

  895. 

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

  897.                        const bool allowUnits, const bool isX) const

  898.     {

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

  900.         float value;

  901. 

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

  903.             coords.add (value);

  904.     }

  905. 

  906.     //==============================================================================

  907.     void parseCSSStyle (const XmlElement& xml)

  908.     {

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

  910.     }

  911. 

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

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

  914.     {

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

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

  917. 

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

  919. 

  920.         if (styleAtt.isNotEmpty())

  921.         {

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

  923. 

  924.             if (value.isNotEmpty())

  925.                 return value;

  926.         }

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

  928.         {

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

  930. 

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

  932. 

  933.             if (index < 0)

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

  935. 

  936.             if (index >= 0)

  937.             {

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

  939. 

  940.                 if (openBracket > index)

  941.                 {

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

  943. 

  944.                     if (closeBracket > openBracket)

  945.                     {

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

  947. 

  948.                         if (value.isNotEmpty())

  949.                             return value;

  950.                     }

  951.                 }

  952.             }

  953.         }

  954. 

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

  956. 

  957.         if (xml != nullptr)

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

  959. 

  960.         return defaultValue;

  961.     }

  962. 

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

  964.     {

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

  966.             return xml->getStringAttribute (attributeName);

  967. 

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

  969. 

  970.         if (xml != nullptr)

  971.             return getInheritedAttribute  (xml, attributeName);

  972. 

  973.         return String::empty;

  974.     }

  975. 

  976.     //==============================================================================

  977.     static bool isIdentifierChar (const juce_wchar c)

  978.     {

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

  980.     }

  981. 

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

  983.     {

  984.         int i = 0;

  985. 

  986.         for (;;)

  987.         {

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

  989. 

  990.             if (i < 0)

  991.                 break;

  992. 

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

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

  995.             {

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

  997. 

  998.                 if (i < 0)

  999.                     break;

  1000. 

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

  1002. 

  1003.                 if (end < 0)

  1004.                     end = 0x7ffff;

  1005. 

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

  1007.             }

  1008. 

  1009.             ++i;

  1010.         }

  1011. 

  1012.         return defaultValue;

  1013.     }

  1014. 

  1015.     //==============================================================================

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

  1017.     {

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

  1019.             ++s;

  1020. 

  1021.         String::CharPointerType start (s);

  1022.         int numChars = 0;

  1023. 

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

  1025.         {

  1026.             ++numChars;

  1027.             ++s;

  1028.         }

  1029. 

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

  1031.         {

  1032.             ++numChars;

  1033.             ++s;

  1034.         }

  1035. 

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

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

  1038.         {

  1039.             s += 2;

  1040.             numChars += 2;

  1041. 

  1042.             while (s.isDigit())

  1043.             {

  1044.                 ++numChars;

  1045.                 ++s;

  1046.             }

  1047.         }

  1048. 

  1049.         if (allowUnits)

  1050.         {

  1051.             while (s.isLetter())

  1052.             {

  1053.                 ++numChars;

  1054.                 ++s;

  1055.             }

  1056.         }

  1057. 

  1058.         if (numChars == 0)

  1059.             return false;

  1060. 

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

  1062. 

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

  1064.             ++s;

  1065. 

  1066.         return true;

  1067.     }

  1068. 

  1069.     //==============================================================================

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

  1071.     {

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

  1073.         {

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

  1075.             int numChars = 0;

  1076. 

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

  1078.             {

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

  1080. 

  1081.                 if (hexValue >= 0)

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

  1083.                 else

  1084.                     break;

  1085.             }

  1086. 

  1087.             if (numChars <= 3)

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

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

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

  1091.             else

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

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

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

  1095.         }

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

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

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

  1099.         {

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

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

  1102. 

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

  1104.             {

  1105.                 index = closeBracket;

  1106. 

  1107.                 StringArray tokens;

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

  1109.                 tokens.trim();

  1110.                 tokens.removeEmptyStrings();

  1111. 

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

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

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

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

  1116.                 else

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

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

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

  1120.             }

  1121.         }

  1122. 

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

  1124.     }

  1125. 

  1126.     static const AffineTransform parseTransform (String t)

  1127.     {

  1128.         AffineTransform result;

  1129. 

  1130.         while (t.isNotEmpty())

  1131.         {

  1132.             StringArray tokens;

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

  1134.                                .upToFirstOccurrenceOf (")", false, false),

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

  1136. 

  1137.             tokens.removeEmptyStrings (true);

  1138. 

  1139.             float numbers [6];

  1140. 

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

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

  1143. 

  1144.             AffineTransform trans;

  1145. 

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

  1147.             {

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

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

  1150.             }

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

  1152.             {

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

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

  1155.             }

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

  1157.             {

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

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

  1160.                 else

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

  1162.             }

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

  1164.             {

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

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

  1167.                 else

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

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

  1170.             }

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

  1172.             {

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

  1174.                                          0.0f, 1.0f, 0.0f);

  1175.             }

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

  1177.             {

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

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

  1180.             }

  1181. 

  1182.             result = trans.followedBy (result);

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

  1184.         }

  1185. 

  1186.         return result;

  1187.     }

  1188. 

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

  1190.                                             const double x2, const double y2,

  1191.                                             const double angle,

  1192.                                             const bool largeArc, const bool sweep,

  1193.                                             double& rx, double& ry,

  1194.                                             double& centreX, double& centreY,

  1195.                                             double& startAngle, double& deltaAngle)

  1196.     {

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

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

  1199. 

  1200.         const double cosAngle = cos (angle);

  1201.         const double sinAngle = sin (angle);

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

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

  1204.         const double xp2 = xp * xp;

  1205.         const double yp2 = yp * yp;

  1206. 

  1207.         double rx2 = rx * rx;

  1208.         double ry2 = ry * ry;

  1209. 

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

  1211.         double c;

  1212. 

  1213.         if (s <= 1.0)

  1214.         {

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

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

  1217. 

  1218.             if (largeArc == sweep)

  1219.                 c = -c;

  1220.         }

  1221.         else

  1222.         {

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

  1224.             rx *= s2;

  1225.             ry *= s2;

  1226.             rx2 = rx * rx;

  1227.             ry2 = ry * ry;

  1228.             c = 0;

  1229.         }

  1230. 

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

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

  1233. 

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

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

  1236. 

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

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

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

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

  1241. 

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

  1243. 

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

  1245. 

  1246.         if (uy < 0)

  1247.             startAngle = -startAngle;

  1248. 

  1249.         startAngle += double_Pi * 0.5;

  1250. 

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

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

  1253. 

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

  1255.             deltaAngle = -deltaAngle;

  1256. 

  1257.         if (sweep)

  1258.         {

  1259.             if (deltaAngle < 0)

  1260.                 deltaAngle += double_Pi * 2.0;

  1261.         }

  1262.         else

  1263.         {

  1264.             if (deltaAngle > 0)

  1265.                 deltaAngle -= double_Pi * 2.0;

  1266.         }

  1267. 

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

  1269.     }

  1270. 

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

  1272.     {

  1273.         forEachXmlChildElement (*parent, e)

  1274.         {

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

  1276.                 return e;

  1277. 

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

  1279. 

  1280.             if (found != nullptr)

  1281.                 return found;

  1282.         }

  1283. 

  1284.         return nullptr;

  1285.     }

  1286. 

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

  1288. };

  1289. 

  1290. 

  1291. //==============================================================================

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

  1293. {

  1294.     SVGState state (&svgDocument);

  1295.     return state.parseSVGElement (svgDocument);

  1296. }