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

1257 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.             Point<float> vxy, vwh;

  66. 

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

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

  69.                  && vwh.x > 0

  70.                  && vwh.y > 0)

  71.             {

  72.                 newState.viewBoxW = vwh.x;

  73.                 newState.viewBoxH = vwh.y;

  74. 

  75.                 int placementFlags = 0;

  76. 

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

  78. 

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

  80.                 {

  81.                     placementFlags = RectanglePlacement::stretchToFit;

  82.                 }

  83.                 else

  84.                 {

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

  86. 

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

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

  89.                     else                                            placementFlags |= RectanglePlacement::xMid;

  90. 

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

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

  93.                     else                                            placementFlags |= RectanglePlacement::yMid;

  94.                 }

  95. 

  96.                 newState.transform = RectanglePlacement (placementFlags)

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

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

  99.                                         .followedBy (newState.transform);

  100.             }

  101.         }

  102.         else

  103.         {

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

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

  106.         }

  107. 

  108.         newState.parseSubElements (xml, drawable);

  109. 

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

  111.         drawable->resetBoundingBoxToContentArea();

  112. 

  113.         return drawable;

  114.     }

  115. 

  116. private:

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

  118.     const XmlElement* const topLevelXml;

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

  120.     AffineTransform transform;

  121.     String cssStyleText;

  122. 

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

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

  125.     {

  126.         forEachXmlChildElement (xml, e)

  127.         {

  128.             Drawable* d = nullptr;

  129. 

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

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

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

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

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

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

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

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

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

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

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

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

  142. 

  143.             parentDrawable->addAndMakeVisible (d);

  144.         }

  145.     }

  146. 

  147.     DrawableComposite* parseSwitch (const XmlElement& xml)

  148.     {

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

  150.             return parseGroupElement (*group);

  151. 

  152.         return nullptr;

  153.     }

  154. 

  155.     DrawableComposite* parseGroupElement (const XmlElement& xml)

  156.     {

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

  158. 

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

  160. 

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

  162.         {

  163.             SVGState newState (*this);

  164.             newState.addTransform (xml);

  165. 

  166.             newState.parseSubElements (xml, drawable);

  167.         }

  168.         else

  169.         {

  170.             parseSubElements (xml, drawable);

  171.         }

  172. 

  173.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  174.         return drawable;

  175.     }

  176. 

  177.     //==============================================================================

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

  179.     {

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

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

  182.         Path path;

  183. 

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

  185.             path.setUsingNonZeroWinding (false);

  186. 

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

  188.         juce_wchar lastCommandChar = 0;

  189.         bool isRelative = true;

  190.         bool carryOn = true;

  191. 

  192.         const CharPointer_ASCII validCommandChars ("MmLlHhVvCcSsQqTtAaZz");

  193. 

  194.         while (! d.isEmpty())

  195.         {

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

  197.             {

  198.                 lastCommandChar = d.getAndAdvance();

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

  200.             }

  201. 

  202.             switch (lastCommandChar)

  203.             {

  204.             case 'M':

  205.             case 'm':

  206.             case 'L':

  207.             case 'l':

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

  209.                 {

  210.                     if (isRelative)

  211.                         p1 += last;

  212. 

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

  214.                     {

  215.                         subpathStart = p1;

  216.                         path.startNewSubPath (p1);

  217.                         lastCommandChar = 'l';

  218.                     }

  219.                     else

  220.                         path.lineTo (p1);

  221. 

  222.                     last2 = last;

  223.                     last = p1;

  224.                 }

  225.                 break;

  226. 

  227.             case 'H':

  228.             case 'h':

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

  230.                 {

  231.                     if (isRelative)

  232.                         p1.x += last.x;

  233. 

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

  235. 

  236.                     last2.x = last.x;

  237.                     last.x = p1.x;

  238.                 }

  239.                 else

  240.                 {

  241.                     ++d;

  242.                 }

  243.                 break;

  244. 

  245.             case 'V':

  246.             case 'v':

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

  248.                 {

  249.                     if (isRelative)

  250.                         p1.y += last.y;

  251. 

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

  253. 

  254.                     last2.y = last.y;

  255.                     last.y = p1.y;

  256.                 }

  257.                 else

  258.                 {

  259.                     ++d;

  260.                 }

  261.                 break;

  262. 

  263.             case 'C':

  264.             case 'c':

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

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

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

  268.                 {

  269.                     if (isRelative)

  270.                     {

  271.                         p1 += last;

  272.                         p2 += last;

  273.                         p3 += last;

  274.                     }

  275. 

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

  277. 

  278.                     last2 = p2;

  279.                     last = p3;

  280.                 }

  281.                 break;

  282. 

  283.             case 'S':

  284.             case 's':

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

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

  287.                 {

  288.                     if (isRelative)

  289.                     {

  290.                         p1 += last;

  291.                         p3 += last;

  292.                     }

  293. 

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

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

  296. 

  297.                     last2 = p1;

  298.                     last = p3;

  299.                 }

  300.                 break;

  301. 

  302.             case 'Q':

  303.             case 'q':

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

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

  306.                 {

  307.                     if (isRelative)

  308.                     {

  309.                         p1 += last;

  310.                         p2 += last;

  311.                     }

  312. 

  313.                     path.quadraticTo (p1, p2);

  314. 

  315.                     last2 = p1;

  316.                     last = p2;

  317.                 }

  318.                 break;

  319. 

  320.             case 'T':

  321.             case 't':

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

  323.                 {

  324.                     if (isRelative)

  325.                         p1 += last;

  326. 

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

  328.                     path.quadraticTo (p2, p1);

  329. 

  330.                     last2 = p2;

  331.                     last = p1;

  332.                 }

  333.                 break;

  334. 

  335.             case 'A':

  336.             case 'a':

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

  338.                 {

  339.                     String num;

  340. 

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

  342.                     {

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

  344. 

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

  346.                         {

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

  348. 

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

  350.                             {

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

  352. 

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

  354.                                 {

  355.                                     if (isRelative)

  356.                                         p2 += last;

  357. 

  358.                                     if (last != p2)

  359.                                     {

  360.                                         double centreX, centreY, startAngle, deltaAngle;

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

  362. 

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

  364.                                                                     angle, largeArc, sweep,

  365.                                                                     rx, ry, centreX, centreY,

  366.                                                                     startAngle, deltaAngle);

  367. 

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

  369.                                                             (float) rx, (float) ry,

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

  371.                                                             false);

  372. 

  373.                                         path.lineTo (p2);

  374.                                     }

  375. 

  376.                                     last2 = last;

  377.                                     last = p2;

  378.                                 }

  379.                             }

  380.                         }

  381.                     }

  382.                 }

  383. 

  384.                 break;

  385. 

  386.             case 'Z':

  387.             case 'z':

  388.                 path.closeSubPath();

  389.                 last = last2 = subpathStart;

  390.                 d = d.findEndOfWhitespace();

  391.                 lastCommandChar = 'M';

  392.                 break;

  393. 

  394.             default:

  395.                 carryOn = false;

  396.                 break;

  397.             }

  398. 

  399.             if (! carryOn)

  400.                 break;

  401.         }

  402. 

  403.         return parseShape (xml, path);

  404.     }

  405. 

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

  407.     {

  408.         Path rect;

  409. 

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

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

  412. 

  413.         if (hasRX || hasRY)

  414.         {

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

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

  417. 

  418.             if (! hasRX)

  419.                 rx = ry;

  420.             else if (! hasRY)

  421.                 ry = rx;

  422. 

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

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

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

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

  427.                                       rx, ry);

  428.         }

  429.         else

  430.         {

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

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

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

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

  435.         }

  436. 

  437.         return parseShape (xml, rect);

  438.     }

  439. 

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

  441.     {

  442.         Path circle;

  443. 

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

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

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

  447. 

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

  449. 

  450.         return parseShape (xml, circle);

  451.     }

  452. 

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

  454.     {

  455.         Path ellipse;

  456. 

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

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

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

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

  461. 

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

  463. 

  464.         return parseShape (xml, ellipse);

  465.     }

  466. 

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

  468.     {

  469.         Path line;

  470. 

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

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

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

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

  475. 

  476.         line.startNewSubPath (x1, y1);

  477.         line.lineTo (x2, y2);

  478. 

  479.         return parseShape (xml, line);

  480.     }

  481. 

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

  483.     {

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

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

  486.         Path path;

  487.         Point<float> p;

  488. 

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

  490.         {

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

  492. 

  493.             path.startNewSubPath (first);

  494. 

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

  496.             {

  497.                 last = p;

  498.                 path.lineTo (p);

  499.             }

  500. 

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

  502.                 path.closeSubPath();

  503.         }

  504. 

  505.         return parseShape (xml, path);

  506.     }

  507. 

  508.     //==============================================================================

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

  510.                           const bool shouldParseTransform = true) const

  511.     {

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

  513.         {

  514.             SVGState newState (*this);

  515.             newState.addTransform (xml);

  516. 

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

  518.         }

  519. 

  520.         DrawablePath* dp = new DrawablePath();

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

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

  523. 

  524.         path.applyTransform (transform);

  525.         dp->setPath (path);

  526. 

  527.         Path::Iterator iter (path);

  528. 

  529.         bool containsClosedSubPath = false;

  530.         while (iter.next())

  531.         {

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

  533.             {

  534.                 containsClosedSubPath = true;

  535.                 break;

  536.             }

  537.         }

  538. 

  539.         dp->setFill (getPathFillType (path,

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

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

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

  543.                                       containsClosedSubPath ? Colours::black

  544.                                                             : Colours::transparentBlack));

  545. 

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

  547. 

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

  549.         {

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

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

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

  553.                                                 Colours::transparentBlack));

  554. 

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

  556.         }

  557. 

  558.         return dp;

  559.     }

  560. 

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

  562.     {

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

  564. 

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

  566.             return nullptr;

  567. 

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

  569.     }

  570. 

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

  572.     {

  573.         if (fillXml != nullptr)

  574.         {

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

  576.             {

  577.                 int index = 0;

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

  579. 

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

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

  582. 

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

  584. 

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

  586.                     offset *= 0.01;

  587. 

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

  589.             }

  590.         }

  591.     }

  592. 

  593.     FillType getGradientFillType (const XmlElement* fillXml,

  594.                                   const Path& path,

  595.                                   const float opacity) const

  596.     {

  597.         ColourGradient gradient;

  598. 

  599.         addGradientStopsIn (gradient, findLinkedElement (fillXml));

  600.         addGradientStopsIn (gradient, fillXml);

  601. 

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

  603.         {

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

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

  606.         }

  607.         else

  608.         {

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

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

  611.         }

  612. 

  613.         if (opacity < 1.0f)

  614.             gradient.multiplyOpacity (opacity);

  615. 

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

  617. 

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

  619. 

  620.         float gradientWidth = viewBoxW;

  621.         float gradientHeight = viewBoxH;

  622.         float dx = 0.0f;

  623.         float dy = 0.0f;

  624. 

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

  626. 

  627.         if (! userSpace)

  628.         {

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

  630.             dx = bounds.getX();

  631.             dy = bounds.getY();

  632.             gradientWidth = bounds.getWidth();

  633.             gradientHeight = bounds.getHeight();

  634.         }

  635. 

  636.         if (gradient.isRadial)

  637.         {

  638.             if (userSpace)

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

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

  641.             else

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

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

  644. 

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

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

  647. 

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

  649.         }

  650.         else

  651.         {

  652.             if (userSpace)

  653.             {

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

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

  656. 

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

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

  659.             }

  660.             else

  661.             {

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

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

  664. 

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

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

  667.             }

  668. 

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

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

  671.         }

  672. 

  673.         FillType type (gradient);

  674. 

  675.         const AffineTransform gradientTransform (parseTransform (fillXml->getStringAttribute ("gradientTransform"))

  676.                                                     .followedBy (transform));

  677. 

  678.         if (gradient.isRadial)

  679.         {

  680.             type.transform = gradientTransform;

  681.         }

  682.         else

  683.         {

  684.             // Transform the perpendicular vector into the new coordinate space for the gradient.

  685.             // This vector is now the slope of the linear gradient as it should appear in the new coord space

  686.             const Point<float> perpendicular (Point<float> (gradient.point2.y - gradient.point1.y,

  687.                                                             gradient.point1.x - gradient.point2.x)

  688.                                                   .transformedBy (gradientTransform.withAbsoluteTranslation (0, 0)));

  689. 

  690.             const Point<float> newGradPoint1 (gradient.point1.transformedBy (gradientTransform));

  691.             const Point<float> newGradPoint2 (gradient.point2.transformedBy (gradientTransform));

  692. 

  693.             // Project the transformed gradient vector onto the transformed slope of the linear

  694.             // gradient as it should appear in the new coordinate space

  695.             const float scale = perpendicular.getDotProduct (newGradPoint2 - newGradPoint1)

  696.                                   / perpendicular.getDotProduct (perpendicular);

  697. 

  698.             type.gradient->point1 = newGradPoint1;

  699.             type.gradient->point2 = newGradPoint2 - perpendicular * scale;

  700.         }

  701. 

  702.         return type;

  703.     }

  704. 

  705.     FillType getPathFillType (const Path& path,

  706.                               const String& fill,

  707.                               const String& fillOpacity,

  708.                               const String& overallOpacity,

  709.                               const Colour& defaultColour) const

  710.     {

  711.         float opacity = 1.0f;

  712. 

  713.         if (overallOpacity.isNotEmpty())

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

  715. 

  716.         if (fillOpacity.isNotEmpty())

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

  718. 

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

  720.         {

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

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

  723. 

  724.             if (const XmlElement* const fillXml = findElementForId (topLevelXml, id))

  725.                 if (fillXml->hasTagName ("linearGradient") || fillXml->hasTagName ("radialGradient"))

  726.                     return getGradientFillType (fillXml, path, opacity);

  727.         }

  728. 

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

  730.             return Colours::transparentBlack;

  731. 

  732.         int i = 0;

  733.         return parseColour (fill, i, defaultColour).withMultipliedAlpha (opacity);

  734.     }

  735. 

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

  737.     {

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

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

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

  741. 

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

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

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

  745. 

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

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

  748. 

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

  750.             joinStyle = PathStrokeType::curved;

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

  752.             joinStyle = PathStrokeType::beveled;

  753. 

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

  755.             capStyle = PathStrokeType::rounded;

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

  757.             capStyle = PathStrokeType::square;

  758. 

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

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

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

  762. 

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

  764.                                joinStyle, capStyle);

  765.     }

  766. 

  767.     //==============================================================================

  768.     Drawable* parseText (const XmlElement& xml)

  769.     {

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

  771. 

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

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

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

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

  776. 

  777. 

  778.         //xxx not done text yet!

  779. 

  780. 

  781.         forEachXmlChildElement (xml, e)

  782.         {

  783.             if (e->isTextElement())

  784.             {

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

  786. 

  787.                 Path path;

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

  789.                 delete s;  // xxx not finished!

  790.             }

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

  792.             {

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

  794.                 delete s;  // xxx not finished!

  795.             }

  796.         }

  797. 

  798.         return nullptr;

  799.     }

  800. 

  801.     //==============================================================================

  802.     void addTransform (const XmlElement& xml)

  803.     {

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

  805.                         .followedBy (transform);

  806.     }

  807. 

  808.     //==============================================================================

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

  810.     {

  811.         String number;

  812. 

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

  814.         {

  815.             value = 0;

  816.             return false;

  817.         }

  818. 

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

  820.         return true;

  821.     }

  822. 

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

  824.     {

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

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

  827.     }

  828. 

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

  830.     {

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

  832.         if (! b)

  833.             ++s;

  834. 

  835.         return b;

  836.     }

  837. 

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

  839.     {

  840.         float n = s.getFloatValue();

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

  842. 

  843.         if (len > 2)

  844.         {

  845.             const float dpi = 96.0f;

  846. 

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

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

  849. 

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

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

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

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

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

  855.         }

  856. 

  857.         return n;

  858.     }

  859. 

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

  861.                        const bool allowUnits, const bool isX) const

  862.     {

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

  864.         float value;

  865. 

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

  867.             coords.add (value);

  868.     }

  869. 

  870.     //==============================================================================

  871.     void parseCSSStyle (const XmlElement& xml)

  872.     {

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

  874.     }

  875. 

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

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

  878.     {

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

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

  881. 

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

  883. 

  884.         if (styleAtt.isNotEmpty())

  885.         {

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

  887. 

  888.             if (value.isNotEmpty())

  889.                 return value;

  890.         }

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

  892.         {

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

  894. 

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

  896. 

  897.             if (index < 0)

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

  899. 

  900.             if (index >= 0)

  901.             {

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

  903. 

  904.                 if (openBracket > index)

  905.                 {

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

  907. 

  908.                     if (closeBracket > openBracket)

  909.                     {

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

  911. 

  912.                         if (value.isNotEmpty())

  913.                             return value;

  914.                     }

  915.                 }

  916.             }

  917.         }

  918. 

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

  920. 

  921.         if (xml != nullptr)

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

  923. 

  924.         return defaultValue;

  925.     }

  926. 

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

  928.     {

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

  930.             return xml->getStringAttribute (attributeName);

  931. 

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

  933. 

  934.         if (xml != nullptr)

  935.             return getInheritedAttribute  (xml, attributeName);

  936. 

  937.         return String::empty;

  938.     }

  939. 

  940.     //==============================================================================

  941.     static bool isIdentifierChar (const juce_wchar c)

  942.     {

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

  944.     }

  945. 

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

  947.     {

  948.         int i = 0;

  949. 

  950.         for (;;)

  951.         {

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

  953. 

  954.             if (i < 0)

  955.                 break;

  956. 

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

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

  959.             {

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

  961. 

  962.                 if (i < 0)

  963.                     break;

  964. 

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

  966. 

  967.                 if (end < 0)

  968.                     end = 0x7ffff;

  969. 

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

  971.             }

  972. 

  973.             ++i;

  974.         }

  975. 

  976.         return defaultValue;

  977.     }

  978. 

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

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

  981.     {

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

  983.             ++s;

  984. 

  985.         String::CharPointerType start (s);

  986.         int numChars = 0;

  987. 

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

  989.         {

  990.             ++numChars;

  991.             ++s;

  992.         }

  993. 

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

  995.         {

  996.             ++numChars;

  997.             ++s;

  998.         }

  999. 

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

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

  1002.         {

  1003.             s += 2;

  1004.             numChars += 2;

  1005. 

  1006.             while (s.isDigit())

  1007.             {

  1008.                 ++numChars;

  1009.                 ++s;

  1010.             }

  1011.         }

  1012. 

  1013.         if (allowUnits)

  1014.         {

  1015.             while (s.isLetter())

  1016.             {

  1017.                 ++numChars;

  1018.                 ++s;

  1019.             }

  1020.         }

  1021. 

  1022.         if (numChars == 0)

  1023.             return false;

  1024. 

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

  1026. 

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

  1028.             ++s;

  1029. 

  1030.         return true;

  1031.     }

  1032. 

  1033.     //==============================================================================

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

  1035.     {

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

  1037.         {

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

  1039.             int numChars = 0;

  1040. 

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

  1042.             {

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

  1044. 

  1045.                 if (hexValue >= 0)

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

  1047.                 else

  1048.                     break;

  1049.             }

  1050. 

  1051.             if (numChars <= 3)

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

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

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

  1055. 

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

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

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

  1059.         }

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

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

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

  1063.         {

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

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

  1066. 

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

  1068.             {

  1069.                 index = closeBracket;

  1070. 

  1071.                 StringArray tokens;

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

  1073.                 tokens.trim();

  1074.                 tokens.removeEmptyStrings();

  1075. 

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

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

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

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

  1080.                 else

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

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

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

  1084.             }

  1085.         }

  1086. 

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

  1088.     }

  1089. 

  1090.     static const AffineTransform parseTransform (String t)

  1091.     {

  1092.         AffineTransform result;

  1093. 

  1094.         while (t.isNotEmpty())

  1095.         {

  1096.             StringArray tokens;

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

  1098.                                .upToFirstOccurrenceOf (")", false, false),

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

  1100. 

  1101.             tokens.removeEmptyStrings (true);

  1102. 

  1103.             float numbers [6];

  1104. 

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

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

  1107. 

  1108.             AffineTransform trans;

  1109. 

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

  1111.             {

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

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

  1114.             }

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

  1116.             {

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

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

  1119.             }

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

  1121.             {

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

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

  1124.                 else

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

  1126.             }

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

  1128.             {

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

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

  1131.                 else

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

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

  1134.             }

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

  1136.             {

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

  1138.                                          0.0f, 1.0f, 0.0f);

  1139.             }

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

  1141.             {

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

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

  1144.             }

  1145. 

  1146.             result = trans.followedBy (result);

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

  1148.         }

  1149. 

  1150.         return result;

  1151.     }

  1152. 

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

  1154.                                             const double x2, const double y2,

  1155.                                             const double angle,

  1156.                                             const bool largeArc, const bool sweep,

  1157.                                             double& rx, double& ry,

  1158.                                             double& centreX, double& centreY,

  1159.                                             double& startAngle, double& deltaAngle)

  1160.     {

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

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

  1163. 

  1164.         const double cosAngle = cos (angle);

  1165.         const double sinAngle = sin (angle);

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

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

  1168.         const double xp2 = xp * xp;

  1169.         const double yp2 = yp * yp;

  1170. 

  1171.         double rx2 = rx * rx;

  1172.         double ry2 = ry * ry;

  1173. 

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

  1175.         double c;

  1176. 

  1177.         if (s <= 1.0)

  1178.         {

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

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

  1181. 

  1182.             if (largeArc == sweep)

  1183.                 c = -c;

  1184.         }

  1185.         else

  1186.         {

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

  1188.             rx *= s2;

  1189.             ry *= s2;

  1190.             c = 0;

  1191.         }

  1192. 

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

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

  1195. 

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

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

  1198. 

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

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

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

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

  1203. 

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

  1205. 

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

  1207. 

  1208.         if (uy < 0)

  1209.             startAngle = -startAngle;

  1210. 

  1211.         startAngle += double_Pi * 0.5;

  1212. 

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

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

  1215. 

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

  1217.             deltaAngle = -deltaAngle;

  1218. 

  1219.         if (sweep)

  1220.         {

  1221.             if (deltaAngle < 0)

  1222.                 deltaAngle += double_Pi * 2.0;

  1223.         }

  1224.         else

  1225.         {

  1226.             if (deltaAngle > 0)

  1227.                 deltaAngle -= double_Pi * 2.0;

  1228.         }

  1229. 

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

  1231.     }

  1232. 

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

  1234.     {

  1235.         forEachXmlChildElement (*parent, e)

  1236.         {

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

  1238.                 return e;

  1239. 

  1240.             if (const XmlElement* const found = findElementForId (e, id))

  1241.                 return found;

  1242.         }

  1243. 

  1244.         return nullptr;

  1245.     }

  1246. 

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

  1248. };

  1249. 

  1250. 

  1251. //==============================================================================

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

  1253. {

  1254.     SVGState state (&svgDocument);

  1255.     return state.parseSVGElement (svgDocument);

  1256. }