falkTX
/
Carla
mirror of https://github.com/falkTX/Carla
1
0
Fork 0
Code Releases 42 Activity
Audio plugin host https://kx.studio/carla
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.
3031 Commits
16 Branches
16GB
Tree: 568ce5bb45
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '568ce5bb45'
${ noResults }
Carla/source/modules/juce_gui_basics/drawables/juce_SVGParser.cpp

1358 lines
48KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2013 - Raw Material Software Ltd.

  6. 

  7.    Permission is granted to use this software under the terms of either:

  8.    a) the GPL v2 (or any later version)

  9.    b) the Affero GPL v3

  10. 

  11.    Details of these licenses can be found at: www.gnu.org/licenses

  12. 

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

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

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

  16. 

  17.    ------------------------------------------------------------------------------

  18. 

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

  20.    available: visit www.juce.com for more information.

  21. 

  22.   ==============================================================================

  23. */

  24. 

  25. class SVGState

  26. {

  27. public:

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

  29.     explicit SVGState (const XmlElement* const topLevel)

  30.         : topLevelXml (topLevel, nullptr),

  31.           elementX (0), elementY (0),

  32.           width (512), height (512),

  33.           viewBoxW (0), viewBoxH (0)

  34.     {

  35.     }

  36. 

  37.     struct XmlPath

  38.     {

  39.         XmlPath (const XmlElement* e, const XmlPath* p) noexcept : xml (e), parent (p)  {}

  40. 

  41.         const XmlElement& operator*() const noexcept            { jassert (xml != nullptr); return *xml; }

  42.         const XmlElement* operator->() const noexcept           { return xml; }

  43.         XmlPath getChild (const XmlElement* e) const noexcept   { return XmlPath (e, this); }

  44. 

  45.         const XmlElement* xml;

  46.         const XmlPath* parent;

  47.     };

  48. 

  49.     //==============================================================================

  50.     Drawable* parseSVGElement (const XmlPath& xml)

  51.     {

  52.         if (! xml->hasTagNameIgnoringNamespace ("svg"))

  53.             return nullptr;

  54. 

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

  56. 

  57.         setCommonAttributes (*drawable, xml);

  58. 

  59.         SVGState newState (*this);

  60. 

  61.         if (xml->hasAttribute ("transform"))

  62.             newState.addTransform (xml);

  63. 

  64.         newState.elementX = getCoordLength (xml->getStringAttribute ("x",      String (newState.elementX)), viewBoxW);

  65.         newState.elementY = getCoordLength (xml->getStringAttribute ("y",      String (newState.elementY)), viewBoxH);

  66.         newState.width    = getCoordLength (xml->getStringAttribute ("width",  String (newState.width)),    viewBoxW);

  67.         newState.height   = getCoordLength (xml->getStringAttribute ("height", String (newState.height)),   viewBoxH);

  68. 

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

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

  71. 

  72.         Point<float> viewboxXY;

  73. 

  74.         if (xml->hasAttribute ("viewBox"))

  75.         {

  76.             const String viewBoxAtt (xml->getStringAttribute ("viewBox"));

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

  78.             Point<float> vwh;

  79. 

  80.             if (parseCoords (viewParams, viewboxXY, true)

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

  82.                  && vwh.x > 0

  83.                  && vwh.y > 0)

  84.             {

  85.                 newState.viewBoxW = vwh.x;

  86.                 newState.viewBoxH = vwh.y;

  87. 

  88.                 const int placementFlags = parsePlacementFlags (xml->getStringAttribute ("preserveAspectRatio").trim());

  89. 

  90.                 if (placementFlags != 0)

  91.                     newState.transform = RectanglePlacement (placementFlags)

  92.                                             .getTransformToFit (Rectangle<float> (viewboxXY.x, viewboxXY.y, vwh.x, vwh.y),

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

  94.                                             .followedBy (newState.transform);

  95.             }

  96.         }

  97.         else

  98.         {

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

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

  101.         }

  102. 

  103.         newState.parseSubElements (xml, *drawable);

  104. 

  105.         drawable->setContentArea (RelativeRectangle (RelativeCoordinate (viewboxXY.x),

  106.                                                      RelativeCoordinate (viewboxXY.x + newState.viewBoxW),

  107.                                                      RelativeCoordinate (viewboxXY.y),

  108.                                                      RelativeCoordinate (viewboxXY.y + newState.viewBoxH)));

  109.         drawable->resetBoundingBoxToContentArea();

  110. 

  111.         return drawable;

  112.     }

  113. 

  114.     //==============================================================================

  115.     void parsePathString (Path& path, const String& pathString) const

  116.     {

  117.         String::CharPointerType d (pathString.getCharPointer().findEndOfWhitespace());

  118. 

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

  120.         juce_wchar lastCommandChar = 0;

  121.         bool isRelative = true;

  122.         bool carryOn = true;

  123. 

  124.         const CharPointer_ASCII validCommandChars ("MmLlHhVvCcSsQqTtAaZz");

  125. 

  126.         while (! d.isEmpty())

  127.         {

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

  129.             {

  130.                 lastCommandChar = d.getAndAdvance();

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

  132.             }

  133. 

  134.             switch (lastCommandChar)

  135.             {

  136.             case 'M':

  137.             case 'm':

  138.             case 'L':

  139.             case 'l':

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

  141.                 {

  142.                     if (isRelative)

  143.                         p1 += last;

  144. 

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

  146.                     {

  147.                         subpathStart = p1;

  148.                         path.startNewSubPath (p1);

  149.                         lastCommandChar = 'l';

  150.                     }

  151.                     else

  152.                         path.lineTo (p1);

  153. 

  154.                     last2 = last;

  155.                     last = p1;

  156.                 }

  157.                 break;

  158. 

  159.             case 'H':

  160.             case 'h':

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

  162.                 {

  163.                     if (isRelative)

  164.                         p1.x += last.x;

  165. 

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

  167. 

  168.                     last2.x = last.x;

  169.                     last.x = p1.x;

  170.                 }

  171.                 else

  172.                 {

  173.                     ++d;

  174.                 }

  175.                 break;

  176. 

  177.             case 'V':

  178.             case 'v':

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

  180.                 {

  181.                     if (isRelative)

  182.                         p1.y += last.y;

  183. 

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

  185. 

  186.                     last2.y = last.y;

  187.                     last.y = p1.y;

  188.                 }

  189.                 else

  190.                 {

  191.                     ++d;

  192.                 }

  193.                 break;

  194. 

  195.             case 'C':

  196.             case 'c':

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

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

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

  200.                 {

  201.                     if (isRelative)

  202.                     {

  203.                         p1 += last;

  204.                         p2 += last;

  205.                         p3 += last;

  206.                     }

  207. 

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

  209. 

  210.                     last2 = p2;

  211.                     last = p3;

  212.                 }

  213.                 break;

  214. 

  215.             case 'S':

  216.             case 's':

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

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

  219.                 {

  220.                     if (isRelative)

  221.                     {

  222.                         p1 += last;

  223.                         p3 += last;

  224.                     }

  225. 

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

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

  228. 

  229.                     last2 = p1;

  230.                     last = p3;

  231.                 }

  232.                 break;

  233. 

  234.             case 'Q':

  235.             case 'q':

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

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

  238.                 {

  239.                     if (isRelative)

  240.                     {

  241.                         p1 += last;

  242.                         p2 += last;

  243.                     }

  244. 

  245.                     path.quadraticTo (p1, p2);

  246. 

  247.                     last2 = p1;

  248.                     last = p2;

  249.                 }

  250.                 break;

  251. 

  252.             case 'T':

  253.             case 't':

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

  255.                 {

  256.                     if (isRelative)

  257.                         p1 += last;

  258. 

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

  260.                     path.quadraticTo (p2, p1);

  261. 

  262.                     last2 = p2;

  263.                     last = p1;

  264.                 }

  265.                 break;

  266. 

  267.             case 'A':

  268.             case 'a':

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

  270.                 {

  271.                     String num;

  272. 

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

  274.                     {

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

  276. 

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

  278.                         {

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

  280. 

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

  282.                             {

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

  284. 

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

  286.                                 {

  287.                                     if (isRelative)

  288.                                         p2 += last;

  289. 

  290.                                     if (last != p2)

  291.                                     {

  292.                                         double centreX, centreY, startAngle, deltaAngle;

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

  294. 

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

  296.                                                                     angle, largeArc, sweep,

  297.                                                                     rx, ry, centreX, centreY,

  298.                                                                     startAngle, deltaAngle);

  299. 

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

  301.                                                             (float) rx, (float) ry,

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

  303.                                                             false);

  304. 

  305.                                         path.lineTo (p2);

  306.                                     }

  307. 

  308.                                     last2 = last;

  309.                                     last = p2;

  310.                                 }

  311.                             }

  312.                         }

  313.                     }

  314.                 }

  315. 

  316.                 break;

  317. 

  318.             case 'Z':

  319.             case 'z':

  320.                 path.closeSubPath();

  321.                 last = last2 = subpathStart;

  322.                 d = d.findEndOfWhitespace();

  323.                 lastCommandChar = 'M';

  324.                 break;

  325. 

  326.             default:

  327.                 carryOn = false;

  328.                 break;

  329.             }

  330. 

  331.             if (! carryOn)

  332.                 break;

  333.         }

  334. 

  335.         // paths that finish back at their start position often seem to be

  336.         // left without a 'z', so need to be closed explicitly..

  337.         if (path.getCurrentPosition() == subpathStart)

  338.             path.closeSubPath();

  339.     }

  340. 

  341. private:

  342.     //==============================================================================

  343.     const XmlPath topLevelXml;

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

  345.     AffineTransform transform;

  346.     String cssStyleText;

  347. 

  348.     static void setCommonAttributes (Drawable& d, const XmlPath& xml)

  349.     {

  350.         String compID (xml->getStringAttribute ("id"));

  351.         d.setName (compID);

  352.         d.setComponentID (compID);

  353. 

  354.         if (xml->getStringAttribute ("display") == "none")

  355.             d.setVisible (false);

  356.     }

  357. 

  358.     //==============================================================================

  359.     void parseSubElements (const XmlPath& xml, DrawableComposite& parentDrawable)

  360.     {

  361.         forEachXmlChildElement (*xml, e)

  362.             parentDrawable.addAndMakeVisible (parseSubElement (xml.getChild (e)));

  363.     }

  364. 

  365.     Drawable* parseSubElement (const XmlPath& xml)

  366.     {

  367.         const String tag (xml->getTagNameWithoutNamespace());

  368. 

  369.         if (tag == "g")           return parseGroupElement (xml);

  370.         if (tag == "svg")         return parseSVGElement (xml);

  371.         if (tag == "path")        return parsePath (xml);

  372.         if (tag == "rect")        return parseRect (xml);

  373.         if (tag == "circle")      return parseCircle (xml);

  374.         if (tag == "ellipse")     return parseEllipse (xml);

  375.         if (tag == "line")        return parseLine (xml);

  376.         if (tag == "polyline")    return parsePolygon (xml, true);

  377.         if (tag == "polygon")     return parsePolygon (xml, false);

  378.         if (tag == "text")        return parseText (xml, true);

  379.         if (tag == "switch")      return parseSwitch (xml);

  380.         if (tag == "style")       parseCSSStyle (xml);

  381. 

  382.         return nullptr;

  383.     }

  384. 

  385.     DrawableComposite* parseSwitch (const XmlPath& xml)

  386.     {

  387.         if (const XmlElement* const group = xml->getChildByName ("g"))

  388.             return parseGroupElement (xml.getChild (group));

  389. 

  390.         return nullptr;

  391.     }

  392. 

  393.     DrawableComposite* parseGroupElement (const XmlPath& xml)

  394.     {

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

  396. 

  397.         setCommonAttributes (*drawable, xml);

  398. 

  399.         if (xml->hasAttribute ("transform"))

  400.         {

  401.             SVGState newState (*this);

  402.             newState.addTransform (xml);

  403. 

  404.             newState.parseSubElements (xml, *drawable);

  405.         }

  406.         else

  407.         {

  408.             parseSubElements (xml, *drawable);

  409.         }

  410. 

  411.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  412.         return drawable;

  413.     }

  414. 

  415.     //==============================================================================

  416.     Drawable* parsePath (const XmlPath& xml) const

  417.     {

  418.         Path path;

  419.         parsePathString (path, xml->getStringAttribute ("d"));

  420. 

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

  422.             path.setUsingNonZeroWinding (false);

  423. 

  424.         return parseShape (xml, path);

  425.     }

  426. 

  427.     Drawable* parseRect (const XmlPath& xml) const

  428.     {

  429.         Path rect;

  430. 

  431.         const bool hasRX = xml->hasAttribute ("rx");

  432.         const bool hasRY = xml->hasAttribute ("ry");

  433. 

  434.         if (hasRX || hasRY)

  435.         {

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

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

  438. 

  439.             if (! hasRX)

  440.                 rx = ry;

  441.             else if (! hasRY)

  442.                 ry = rx;

  443. 

  444.             rect.addRoundedRectangle (getCoordLength (xml, "x", viewBoxW),

  445.                                       getCoordLength (xml, "y", viewBoxH),

  446.                                       getCoordLength (xml, "width", viewBoxW),

  447.                                       getCoordLength (xml, "height", viewBoxH),

  448.                                       rx, ry);

  449.         }

  450.         else

  451.         {

  452.             rect.addRectangle (getCoordLength (xml, "x", viewBoxW),

  453.                                getCoordLength (xml, "y", viewBoxH),

  454.                                getCoordLength (xml, "width", viewBoxW),

  455.                                getCoordLength (xml, "height", viewBoxH));

  456.         }

  457. 

  458.         return parseShape (xml, rect);

  459.     }

  460. 

  461.     Drawable* parseCircle (const XmlPath& xml) const

  462.     {

  463.         Path circle;

  464. 

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

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

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

  468. 

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

  470. 

  471.         return parseShape (xml, circle);

  472.     }

  473. 

  474.     Drawable* parseEllipse (const XmlPath& xml) const

  475.     {

  476.         Path ellipse;

  477. 

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

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

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

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

  482. 

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

  484. 

  485.         return parseShape (xml, ellipse);

  486.     }

  487. 

  488.     Drawable* parseLine (const XmlPath& xml) const

  489.     {

  490.         Path line;

  491. 

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

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

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

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

  496. 

  497.         line.startNewSubPath (x1, y1);

  498.         line.lineTo (x2, y2);

  499. 

  500.         return parseShape (xml, line);

  501.     }

  502. 

  503.     Drawable* parsePolygon (const XmlPath& xml, const bool isPolyline) const

  504.     {

  505.         const String pointsAtt (xml->getStringAttribute ("points"));

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

  507.         Path path;

  508.         Point<float> p;

  509. 

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

  511.         {

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

  513. 

  514.             path.startNewSubPath (first);

  515. 

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

  517.             {

  518.                 last = p;

  519.                 path.lineTo (p);

  520.             }

  521. 

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

  523.                 path.closeSubPath();

  524.         }

  525. 

  526.         return parseShape (xml, path);

  527.     }

  528. 

  529.     //==============================================================================

  530.     Drawable* parseShape (const XmlPath& xml, Path& path,

  531.                           const bool shouldParseTransform = true) const

  532.     {

  533.         if (shouldParseTransform && xml->hasAttribute ("transform"))

  534.         {

  535.             SVGState newState (*this);

  536.             newState.addTransform (xml);

  537. 

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

  539.         }

  540. 

  541.         DrawablePath* dp = new DrawablePath();

  542.         setCommonAttributes (*dp, xml);

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

  544. 

  545.         path.applyTransform (transform);

  546.         dp->setPath (path);

  547. 

  548.         dp->setFill (getPathFillType (path,

  549.                                       getStyleAttribute (xml, "fill"),

  550.                                       getStyleAttribute (xml, "fill-opacity"),

  551.                                       getStyleAttribute (xml, "opacity"),

  552.                                       pathContainsClosedSubPath (path) ? Colours::black

  553.                                                                        : Colours::transparentBlack));

  554. 

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

  556. 

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

  558.         {

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

  560.                                                 getStyleAttribute (xml, "stroke-opacity"),

  561.                                                 getStyleAttribute (xml, "opacity"),

  562.                                                 Colours::transparentBlack));

  563. 

  564.             dp->setStrokeType (getStrokeFor (xml));

  565.         }

  566. 

  567.         return dp;

  568.     }

  569. 

  570.     static bool pathContainsClosedSubPath (const Path& path) noexcept

  571.     {

  572.         for (Path::Iterator iter (path); iter.next();)

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

  574.                 return true;

  575. 

  576.         return false;

  577.     }

  578. 

  579.     struct SetGradientStopsOp

  580.     {

  581.         const SVGState* state;

  582.         ColourGradient* gradient;

  583. 

  584.         void operator() (const XmlPath& xml)

  585.         {

  586.             state->addGradientStopsIn (*gradient, xml);

  587.         }

  588.     };

  589. 

  590.     void addGradientStopsIn (ColourGradient& cg, const XmlPath& fillXml) const

  591.     {

  592.         if (fillXml.xml != nullptr)

  593.         {

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

  595.             {

  596.                 int index = 0;

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

  598. 

  599.                 const String opacity (getStyleAttribute (fillXml.getChild (e), "stop-opacity", "1"));

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

  601. 

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

  603. 

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

  605.                     offset *= 0.01;

  606. 

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

  608.             }

  609.         }

  610.     }

  611. 

  612.     FillType getGradientFillType (const XmlPath& fillXml,

  613.                                   const Path& path,

  614.                                   const float opacity) const

  615.     {

  616.         ColourGradient gradient;

  617. 

  618.         {

  619.             const String id (fillXml->getStringAttribute ("xlink:href"));

  620. 

  621.             if (id.startsWithChar ('#'))

  622.             {

  623.                 SetGradientStopsOp op = { this, &gradient, };

  624.                 findElementForId (topLevelXml, id.substring (1), op);

  625.             }

  626.         }

  627. 

  628.         addGradientStopsIn (gradient, fillXml);

  629. 

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

  631.         {

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

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

  634.         }

  635.         else

  636.         {

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

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

  639.         }

  640. 

  641.         if (opacity < 1.0f)

  642.             gradient.multiplyOpacity (opacity);

  643. 

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

  645. 

  646.         gradient.isRadial = fillXml->hasTagNameIgnoringNamespace ("radialGradient");

  647. 

  648.         float gradientWidth = viewBoxW;

  649.         float gradientHeight = viewBoxH;

  650.         float dx = 0.0f;

  651.         float dy = 0.0f;

  652. 

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

  654. 

  655.         if (! userSpace)

  656.         {

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

  658.             dx = bounds.getX();

  659.             dy = bounds.getY();

  660.             gradientWidth = bounds.getWidth();

  661.             gradientHeight = bounds.getHeight();

  662.         }

  663. 

  664.         if (gradient.isRadial)

  665.         {

  666.             if (userSpace)

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

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

  669.             else

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

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

  672. 

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

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

  675. 

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

  677.         }

  678.         else

  679.         {

  680.             if (userSpace)

  681.             {

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

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

  684. 

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

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

  687.             }

  688.             else

  689.             {

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

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

  692. 

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

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

  695.             }

  696. 

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

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

  699.         }

  700. 

  701.         FillType type (gradient);

  702. 

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

  704.                                                     .followedBy (transform));

  705. 

  706.         if (gradient.isRadial)

  707.         {

  708.             type.transform = gradientTransform;

  709.         }

  710.         else

  711.         {

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

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

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

  715.                                                             gradient.point1.x - gradient.point2.x)

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

  717. 

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

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

  720. 

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

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

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

  724.                                   / perpendicular.getDotProduct (perpendicular);

  725. 

  726.             type.gradient->point1 = newGradPoint1;

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

  728.         }

  729. 

  730.         return type;

  731.     }

  732. 

  733.     struct GetFillTypeOp

  734.     {

  735.         const SVGState* state;

  736.         FillType* dest;

  737.         const Path* path;

  738.         float opacity;

  739. 

  740.         void operator() (const XmlPath& xml)

  741.         {

  742.             if (xml->hasTagNameIgnoringNamespace ("linearGradient")

  743.                  || xml->hasTagNameIgnoringNamespace ("radialGradient"))

  744.                 *dest = state->getGradientFillType (xml, *path, opacity);

  745.         }

  746.     };

  747. 

  748.     FillType getPathFillType (const Path& path,

  749.                               const String& fill,

  750.                               const String& fillOpacity,

  751.                               const String& overallOpacity,

  752.                               const Colour defaultColour) const

  753.     {

  754.         float opacity = 1.0f;

  755. 

  756.         if (overallOpacity.isNotEmpty())

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

  758. 

  759.         if (fillOpacity.isNotEmpty())

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

  761. 

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

  763.         {

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

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

  766. 

  767.             FillType result;

  768.             GetFillTypeOp op = { this, &result, &path, opacity };

  769. 

  770.             if (findElementForId (topLevelXml, id, op))

  771.                 return result;

  772.         }

  773. 

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

  775.             return Colours::transparentBlack;

  776. 

  777.         int i = 0;

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

  779.     }

  780. 

  781.     static PathStrokeType::JointStyle getJointStyle (const String& join) noexcept

  782.     {

  783.         if (join.equalsIgnoreCase ("round"))  return PathStrokeType::curved;

  784.         if (join.equalsIgnoreCase ("bevel"))  return PathStrokeType::beveled;

  785. 

  786.         return PathStrokeType::mitered;

  787.     }

  788. 

  789.     static PathStrokeType::EndCapStyle getEndCapStyle (const String& cap) noexcept

  790.     {

  791.         if (cap.equalsIgnoreCase ("round"))   return PathStrokeType::rounded;

  792.         if (cap.equalsIgnoreCase ("square"))  return PathStrokeType::square;

  793. 

  794.         return PathStrokeType::butt;

  795.     }

  796. 

  797.     float getStrokeWidth (const String& strokeWidth) const noexcept

  798.     {

  799.         return transform.getScaleFactor() * getCoordLength (strokeWidth, viewBoxW);

  800.     }

  801. 

  802.     PathStrokeType getStrokeFor (const XmlPath& xml) const

  803.     {

  804.         return PathStrokeType (getStrokeWidth (getStyleAttribute (xml, "stroke-width", "1")),

  805.                                getJointStyle  (getStyleAttribute (xml, "stroke-linejoin")),

  806.                                getEndCapStyle (getStyleAttribute (xml, "stroke-linecap")));

  807.     }

  808. 

  809.     //==============================================================================

  810.     Drawable* parseText (const XmlPath& xml, bool shouldParseTransform)

  811.     {

  812.         if (shouldParseTransform && xml->hasAttribute ("transform"))

  813.         {

  814.             SVGState newState (*this);

  815.             newState.addTransform (xml);

  816. 

  817.             return newState.parseText (xml, false);

  818.         }

  819. 

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

  821. 

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

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

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

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

  826. 

  827.         const Font font (getFont (xml));

  828.         const String anchorStr = getStyleAttribute(xml, "text-anchor");

  829. 

  830.         DrawableComposite* dc = new DrawableComposite();

  831.         setCommonAttributes (*dc, xml);

  832. 

  833.         forEachXmlChildElement (*xml, e)

  834.         {

  835.             if (e->isTextElement())

  836.             {

  837.                 const String text (e->getText().trim());

  838. 

  839.                 DrawableText* dt = new DrawableText();

  840.                 dc->addAndMakeVisible (dt);

  841. 

  842.                 dt->setText (text);

  843.                 dt->setFont (font, true);

  844.                 dt->setTransform (transform);

  845. 

  846.                 int i = 0;

  847.                 dt->setColour (parseColour (getStyleAttribute (xml, "fill"), i, Colours::black)

  848.                                  .withMultipliedAlpha (getStyleAttribute (xml, "fill-opacity", "1").getFloatValue()));

  849. 

  850.                 Rectangle<float> bounds (xCoords[0], yCoords[0] - font.getAscent(),

  851.                                          font.getStringWidthFloat (text), font.getHeight());

  852. 

  853.                 if (anchorStr == "middle")   bounds.setX (bounds.getX() - bounds.getWidth() / 2.0f);

  854.                 else if (anchorStr == "end") bounds.setX (bounds.getX() - bounds.getWidth());

  855. 

  856.                 dt->setBoundingBox (bounds);

  857.             }

  858.             else if (e->hasTagNameIgnoringNamespace ("tspan"))

  859.             {

  860.                 dc->addAndMakeVisible (parseText (xml.getChild (e), true));

  861.             }

  862.         }

  863. 

  864.         return dc;

  865.     }

  866. 

  867.     Font getFont (const XmlPath& xml) const

  868.     {

  869.         const float fontSize = getCoordLength (getStyleAttribute (xml, "font-size"), 1.0f);

  870. 

  871.         int style = getStyleAttribute (xml, "font-style").containsIgnoreCase ("italic") ? Font::italic : Font::plain;

  872. 

  873.         if (getStyleAttribute (xml, "font-weight").containsIgnoreCase ("bold"))

  874.             style |= Font::bold;

  875. 

  876.         const String family (getStyleAttribute (xml, "font-family"));

  877. 

  878.         return family.isEmpty() ? Font (fontSize, style)

  879.                                 : Font (family, fontSize, style);

  880.     }

  881. 

  882.     //==============================================================================

  883.     void addTransform (const XmlPath& xml)

  884.     {

  885.         transform = parseTransform (xml->getStringAttribute ("transform"))

  886.                         .followedBy (transform);

  887.     }

  888. 

  889.     //==============================================================================

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

  891.     {

  892.         String number;

  893. 

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

  895.         {

  896.             value = 0;

  897.             return false;

  898.         }

  899. 

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

  901.         return true;

  902.     }

  903. 

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

  905.     {

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

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

  908.     }

  909. 

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

  911.     {

  912.         if (parseCoords (s, p, allowUnits))

  913.             return true;

  914. 

  915.         if (! s.isEmpty()) ++s;

  916.         return false;

  917.     }

  918. 

  919.     float getCoordLength (const String& s, const float sizeForProportions) const noexcept

  920.     {

  921.         float n = s.getFloatValue();

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

  923. 

  924.         if (len > 2)

  925.         {

  926.             const float dpi = 96.0f;

  927. 

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

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

  930. 

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

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

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

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

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

  936.         }

  937. 

  938.         return n;

  939.     }

  940. 

  941.     float getCoordLength (const XmlPath& xml, const char* attName, const float sizeForProportions) const noexcept

  942.     {

  943.         return getCoordLength (xml->getStringAttribute (attName), sizeForProportions);

  944.     }

  945. 

  946.     void getCoordList (Array<float>& coords, const String& list, bool allowUnits, const bool isX) const

  947.     {

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

  949.         float value;

  950. 

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

  952.             coords.add (value);

  953.     }

  954. 

  955.     //==============================================================================

  956.     void parseCSSStyle (const XmlPath& xml)

  957.     {

  958.         cssStyleText = xml->getAllSubText() + "\n" + cssStyleText;

  959.     }

  960. 

  961.     static String::CharPointerType findStyleItem (String::CharPointerType source, String::CharPointerType name)

  962.     {

  963.         const int nameLength = (int) name.length();

  964. 

  965.         while (! source.isEmpty())

  966.         {

  967.             if (source.getAndAdvance() == '.'

  968.                  && CharacterFunctions::compareIgnoreCaseUpTo (source, name, nameLength) == 0)

  969.             {

  970.                 String::CharPointerType endOfName ((source + nameLength).findEndOfWhitespace());

  971. 

  972.                 if (*endOfName == '{')

  973.                     return endOfName;

  974.             }

  975.         }

  976. 

  977.         return source;

  978.     }

  979. 

  980.     String getStyleAttribute (const XmlPath& xml, StringRef attributeName,

  981.                               const String& defaultValue = String()) const

  982.     {

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

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

  985. 

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

  987. 

  988.         if (styleAtt.isNotEmpty())

  989.         {

  990.             const String value (getAttributeFromStyleList (styleAtt, attributeName, String()));

  991. 

  992.             if (value.isNotEmpty())

  993.                 return value;

  994.         }

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

  996.         {

  997.             String::CharPointerType openBrace = findStyleItem (cssStyleText.getCharPointer(),

  998.                                                                xml->getStringAttribute ("class").getCharPointer());

  999. 

  1000.             if (! openBrace.isEmpty())

  1001.             {

  1002.                 String::CharPointerType closeBrace = CharacterFunctions::find (openBrace, (juce_wchar) '}');

  1003. 

  1004.                 if (closeBrace != openBrace)

  1005.                 {

  1006.                     const String value (getAttributeFromStyleList (String (openBrace + 1, closeBrace),

  1007.                                                                    attributeName, defaultValue));

  1008.                     if (value.isNotEmpty())

  1009.                         return value;

  1010.                 }

  1011.             }

  1012.         }

  1013. 

  1014.         if (xml.parent != nullptr)

  1015.             return getStyleAttribute (*xml.parent, attributeName, defaultValue);

  1016. 

  1017.         return defaultValue;

  1018.     }

  1019. 

  1020.     String getInheritedAttribute (const XmlPath& xml, StringRef attributeName) const

  1021.     {

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

  1023.             return xml->getStringAttribute (attributeName);

  1024. 

  1025.         if (xml.parent != nullptr)

  1026.             return getInheritedAttribute  (*xml.parent, attributeName);

  1027. 

  1028.         return String();

  1029.     }

  1030. 

  1031.     static int parsePlacementFlags (const String& align) noexcept

  1032.     {

  1033.         if (align.isEmpty())

  1034.             return 0;

  1035. 

  1036.         if (align.containsIgnoreCase ("none"))

  1037.             return RectanglePlacement::stretchToFit;

  1038. 

  1039.         return (align.containsIgnoreCase ("slice") ? RectanglePlacement::fillDestination : 0)

  1040.              | (align.containsIgnoreCase ("xMin")  ? RectanglePlacement::xLeft

  1041.                                                    : (align.containsIgnoreCase ("xMax") ? RectanglePlacement::xRight

  1042.                                                                                         : RectanglePlacement::xMid))

  1043.              | (align.containsIgnoreCase ("yMin")  ? RectanglePlacement::yTop

  1044.                                                    : (align.containsIgnoreCase ("yMax") ? RectanglePlacement::yBottom

  1045.                                                                                         : RectanglePlacement::yMid));

  1046.     }

  1047. 

  1048.     //==============================================================================

  1049.     static bool isIdentifierChar (const juce_wchar c)

  1050.     {

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

  1052.     }

  1053. 

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

  1055.     {

  1056.         int i = 0;

  1057. 

  1058.         for (;;)

  1059.         {

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

  1061. 

  1062.             if (i < 0)

  1063.                 break;

  1064. 

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

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

  1067.             {

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

  1069. 

  1070.                 if (i < 0)

  1071.                     break;

  1072. 

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

  1074. 

  1075.                 if (end < 0)

  1076.                     end = 0x7ffff;

  1077. 

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

  1079.             }

  1080. 

  1081.             ++i;

  1082.         }

  1083. 

  1084.         return defaultValue;

  1085.     }

  1086. 

  1087.     //==============================================================================

  1088.     static bool parseNextNumber (String::CharPointerType& text, String& value, const bool allowUnits)

  1089.     {

  1090.         String::CharPointerType s (text);

  1091. 

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

  1093.             ++s;

  1094. 

  1095.         String::CharPointerType start (s);

  1096. 

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

  1098.             ++s;

  1099. 

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

  1101.             ++s;

  1102. 

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

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

  1105.         {

  1106.             s += 2;

  1107. 

  1108.             while (s.isDigit())

  1109.                 ++s;

  1110.         }

  1111. 

  1112.         if (allowUnits)

  1113.             while (s.isLetter())

  1114.                 ++s;

  1115. 

  1116.         if (s == start)

  1117.         {

  1118.             text = s;

  1119.             return false;

  1120.         }

  1121. 

  1122.         value = String (start, s);

  1123. 

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

  1125.             ++s;

  1126. 

  1127.         text = s;

  1128.         return true;

  1129.     }

  1130. 

  1131.     //==============================================================================

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

  1133.     {

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

  1135.         {

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

  1137.             int numChars = 0;

  1138. 

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

  1140.             {

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

  1142. 

  1143.                 if (hexValue >= 0)

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

  1145.                 else

  1146.                     break;

  1147.             }

  1148. 

  1149.             if (numChars <= 3)

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

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

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

  1153. 

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

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

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

  1157.         }

  1158. 

  1159.         if (s [index] == 'r'

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

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

  1162.         {

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

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

  1165. 

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

  1167.             {

  1168.                 index = closeBracket;

  1169. 

  1170.                 StringArray tokens;

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

  1172.                 tokens.trim();

  1173.                 tokens.removeEmptyStrings();

  1174. 

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

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

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

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

  1179.                 else

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

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

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

  1183.             }

  1184.         }

  1185. 

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

  1187.     }

  1188. 

  1189.     static AffineTransform parseTransform (String t)

  1190.     {

  1191.         AffineTransform result;

  1192. 

  1193.         while (t.isNotEmpty())

  1194.         {

  1195.             StringArray tokens;

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

  1197.                                .upToFirstOccurrenceOf (")", false, false),

  1198.                               ", ", "");

  1199. 

  1200.             tokens.removeEmptyStrings (true);

  1201. 

  1202.             float numbers[6];

  1203. 

  1204.             for (int i = 0; i < numElementsInArray (numbers); ++i)

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

  1206. 

  1207.             AffineTransform trans;

  1208. 

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

  1210.             {

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

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

  1213.             }

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

  1215.             {

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

  1217.             }

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

  1219.             {

  1220.                 trans = AffineTransform::scale (numbers[0], numbers[tokens.size() > 1 ? 1 : 0]);

  1221.             }

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

  1223.             {

  1224.                 trans = AffineTransform::rotation (numbers[0] / (180.0f / float_Pi), numbers[1], numbers[2]);

  1225.             }

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

  1227.             {

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

  1229.             }

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

  1231.             {

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

  1233.             }

  1234. 

  1235.             result = trans.followedBy (result);

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

  1237.         }

  1238. 

  1239.         return result;

  1240.     }

  1241. 

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

  1243.                                             const double x2, const double y2,

  1244.                                             const double angle,

  1245.                                             const bool largeArc, const bool sweep,

  1246.                                             double& rx, double& ry,

  1247.                                             double& centreX, double& centreY,

  1248.                                             double& startAngle, double& deltaAngle) noexcept

  1249.     {

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

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

  1252. 

  1253.         const double cosAngle = std::cos (angle);

  1254.         const double sinAngle = std::sin (angle);

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

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

  1257.         const double xp2 = xp * xp;

  1258.         const double yp2 = yp * yp;

  1259. 

  1260.         double rx2 = rx * rx;

  1261.         double ry2 = ry * ry;

  1262. 

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

  1264.         double c;

  1265. 

  1266.         if (s <= 1.0)

  1267.         {

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

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

  1270. 

  1271.             if (largeArc == sweep)

  1272.                 c = -c;

  1273.         }

  1274.         else

  1275.         {

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

  1277.             rx *= s2;

  1278.             ry *= s2;

  1279.             c = 0;

  1280.         }

  1281. 

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

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

  1284. 

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

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

  1287. 

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

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

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

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

  1292. 

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

  1294. 

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

  1296. 

  1297.         if (uy < 0)

  1298.             startAngle = -startAngle;

  1299. 

  1300.         startAngle += double_Pi * 0.5;

  1301. 

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

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

  1304. 

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

  1306.             deltaAngle = -deltaAngle;

  1307. 

  1308.         if (sweep)

  1309.         {

  1310.             if (deltaAngle < 0)

  1311.                 deltaAngle += double_Pi * 2.0;

  1312.         }

  1313.         else

  1314.         {

  1315.             if (deltaAngle > 0)

  1316.                 deltaAngle -= double_Pi * 2.0;

  1317.         }

  1318. 

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

  1320.     }

  1321. 

  1322.     template <typename OperationType>

  1323.     static bool findElementForId (const XmlPath& parent, const String& id, OperationType& op)

  1324.     {

  1325.         forEachXmlChildElement (*parent, e)

  1326.         {

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

  1328.             {

  1329.                 op (parent.getChild (e));

  1330.                 return true;

  1331.             }

  1332. 

  1333.             if (findElementForId (parent.getChild (e), id, op))

  1334.                 return true;

  1335.         }

  1336. 

  1337.         return false;

  1338.     }

  1339. 

  1340.     SVGState& operator= (const SVGState&) JUCE_DELETED_FUNCTION;

  1341. };

  1342. 

  1343. 

  1344. //==============================================================================

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

  1346. {

  1347.     SVGState state (&svgDocument);

  1348.     return state.parseSVGElement (SVGState::XmlPath (&svgDocument, nullptr));

  1349. }

  1350. 

  1351. Path Drawable::parseSVGPath (const String& svgPath)

  1352. {

  1353.     SVGState state (nullptr);

  1354.     Path p;

  1355.     state.parsePathString (p, svgPath);

  1356.     return p;

  1357. }