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.
2142 Commits
16 Branches
16GB
Tree: e681ad1f1b
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'e681ad1f1b'
${ noResults }
Carla/source/modules/juce_gui_basics/drawables/juce_SVGParser.cpp

1334 lines
47KB
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.         setDrawableID (*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.                 int placementFlags = 0;

  89. 

  90.                 const String aspect (xml->getStringAttribute ("preserveAspectRatio"));

  91. 

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

  93.                 {

  94.                     placementFlags = RectanglePlacement::stretchToFit;

  95.                 }

  96.                 else

  97.                 {

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

  99. 

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

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

  102.                     else                                            placementFlags |= RectanglePlacement::xMid;

  103. 

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

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

  106.                     else                                            placementFlags |= RectanglePlacement::yMid;

  107.                 }

  108. 

  109.                 newState.transform = RectanglePlacement (placementFlags)

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

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

  112.                                         .followedBy (newState.transform);

  113.             }

  114.         }

  115.         else

  116.         {

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

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

  119.         }

  120. 

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

  122. 

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

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

  125.                                                      RelativeCoordinate (viewboxXY.y),

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

  127.         drawable->resetBoundingBoxToContentArea();

  128. 

  129.         return drawable;

  130.     }

  131. 

  132.     //==============================================================================

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

  134.     {

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

  136. 

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

  138.         juce_wchar lastCommandChar = 0;

  139.         bool isRelative = true;

  140.         bool carryOn = true;

  141. 

  142.         const CharPointer_ASCII validCommandChars ("MmLlHhVvCcSsQqTtAaZz");

  143. 

  144.         while (! d.isEmpty())

  145.         {

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

  147.             {

  148.                 lastCommandChar = d.getAndAdvance();

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

  150.             }

  151. 

  152.             switch (lastCommandChar)

  153.             {

  154.             case 'M':

  155.             case 'm':

  156.             case 'L':

  157.             case 'l':

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

  159.                 {

  160.                     if (isRelative)

  161.                         p1 += last;

  162. 

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

  164.                     {

  165.                         subpathStart = p1;

  166.                         path.startNewSubPath (p1);

  167.                         lastCommandChar = 'l';

  168.                     }

  169.                     else

  170.                         path.lineTo (p1);

  171. 

  172.                     last2 = last;

  173.                     last = p1;

  174.                 }

  175.                 break;

  176. 

  177.             case 'H':

  178.             case 'h':

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

  180.                 {

  181.                     if (isRelative)

  182.                         p1.x += last.x;

  183. 

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

  185. 

  186.                     last2.x = last.x;

  187.                     last.x = p1.x;

  188.                 }

  189.                 else

  190.                 {

  191.                     ++d;

  192.                 }

  193.                 break;

  194. 

  195.             case 'V':

  196.             case 'v':

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

  198.                 {

  199.                     if (isRelative)

  200.                         p1.y += last.y;

  201. 

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

  203. 

  204.                     last2.y = last.y;

  205.                     last.y = p1.y;

  206.                 }

  207.                 else

  208.                 {

  209.                     ++d;

  210.                 }

  211.                 break;

  212. 

  213.             case 'C':

  214.             case 'c':

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

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

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

  218.                 {

  219.                     if (isRelative)

  220.                     {

  221.                         p1 += last;

  222.                         p2 += last;

  223.                         p3 += last;

  224.                     }

  225. 

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

  227. 

  228.                     last2 = p2;

  229.                     last = p3;

  230.                 }

  231.                 break;

  232. 

  233.             case 'S':

  234.             case 's':

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

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

  237.                 {

  238.                     if (isRelative)

  239.                     {

  240.                         p1 += last;

  241.                         p3 += last;

  242.                     }

  243. 

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

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

  246. 

  247.                     last2 = p1;

  248.                     last = p3;

  249.                 }

  250.                 break;

  251. 

  252.             case 'Q':

  253.             case 'q':

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

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

  256.                 {

  257.                     if (isRelative)

  258.                     {

  259.                         p1 += last;

  260.                         p2 += last;

  261.                     }

  262. 

  263.                     path.quadraticTo (p1, p2);

  264. 

  265.                     last2 = p1;

  266.                     last = p2;

  267.                 }

  268.                 break;

  269. 

  270.             case 'T':

  271.             case 't':

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

  273.                 {

  274.                     if (isRelative)

  275.                         p1 += last;

  276. 

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

  278.                     path.quadraticTo (p2, p1);

  279. 

  280.                     last2 = p2;

  281.                     last = p1;

  282.                 }

  283.                 break;

  284. 

  285.             case 'A':

  286.             case 'a':

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

  288.                 {

  289.                     String num;

  290. 

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

  292.                     {

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

  294. 

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

  296.                         {

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

  298. 

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

  300.                             {

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

  302. 

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

  304.                                 {

  305.                                     if (isRelative)

  306.                                         p2 += last;

  307. 

  308.                                     if (last != p2)

  309.                                     {

  310.                                         double centreX, centreY, startAngle, deltaAngle;

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

  312. 

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

  314.                                                                     angle, largeArc, sweep,

  315.                                                                     rx, ry, centreX, centreY,

  316.                                                                     startAngle, deltaAngle);

  317. 

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

  319.                                                             (float) rx, (float) ry,

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

  321.                                                             false);

  322. 

  323.                                         path.lineTo (p2);

  324.                                     }

  325. 

  326.                                     last2 = last;

  327.                                     last = p2;

  328.                                 }

  329.                             }

  330.                         }

  331.                     }

  332.                 }

  333. 

  334.                 break;

  335. 

  336.             case 'Z':

  337.             case 'z':

  338.                 path.closeSubPath();

  339.                 last = last2 = subpathStart;

  340.                 d = d.findEndOfWhitespace();

  341.                 lastCommandChar = 'M';

  342.                 break;

  343. 

  344.             default:

  345.                 carryOn = false;

  346.                 break;

  347.             }

  348. 

  349.             if (! carryOn)

  350.                 break;

  351.         }

  352. 

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

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

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

  356.             path.closeSubPath();

  357.     }

  358. 

  359. private:

  360.     //==============================================================================

  361.     const XmlPath topLevelXml;

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

  363.     AffineTransform transform;

  364.     String cssStyleText;

  365. 

  366.     static void setDrawableID (Drawable& d, const XmlPath& xml)

  367.     {

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

  369.         d.setName (compID);

  370.         d.setComponentID (compID);

  371.     }

  372. 

  373.     //==============================================================================

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

  375.     {

  376.         forEachXmlChildElement (*xml, e)

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

  378.     }

  379. 

  380.     Drawable* parseSubElement (const XmlPath& xml)

  381.     {

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

  383. 

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

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

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

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

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

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

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

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

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

  393.         if (tag == "text")        return parseText (xml);

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

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

  396. 

  397.         return nullptr;

  398.     }

  399. 

  400.     DrawableComposite* parseSwitch (const XmlPath& xml)

  401.     {

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

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

  404. 

  405.         return nullptr;

  406.     }

  407. 

  408.     DrawableComposite* parseGroupElement (const XmlPath& xml)

  409.     {

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

  411. 

  412.         setDrawableID (*drawable, xml);

  413. 

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

  415.         {

  416.             SVGState newState (*this);

  417.             newState.addTransform (xml);

  418. 

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

  420.         }

  421.         else

  422.         {

  423.             parseSubElements (xml, *drawable);

  424.         }

  425. 

  426.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  427.         return drawable;

  428.     }

  429. 

  430.     //==============================================================================

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

  432.     {

  433.         Path path;

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

  435. 

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

  437.             path.setUsingNonZeroWinding (false);

  438. 

  439.         return parseShape (xml, path);

  440.     }

  441. 

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

  443.     {

  444.         Path rect;

  445. 

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

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

  448. 

  449.         if (hasRX || hasRY)

  450.         {

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

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

  453. 

  454.             if (! hasRX)

  455.                 rx = ry;

  456.             else if (! hasRY)

  457.                 ry = rx;

  458. 

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

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

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

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

  463.                                       rx, ry);

  464.         }

  465.         else

  466.         {

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

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

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

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

  471.         }

  472. 

  473.         return parseShape (xml, rect);

  474.     }

  475. 

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

  477.     {

  478.         Path circle;

  479. 

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

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

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

  483. 

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

  485. 

  486.         return parseShape (xml, circle);

  487.     }

  488. 

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

  490.     {

  491.         Path ellipse;

  492. 

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

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

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

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

  497. 

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

  499. 

  500.         return parseShape (xml, ellipse);

  501.     }

  502. 

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

  504.     {

  505.         Path line;

  506. 

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

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

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

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

  511. 

  512.         line.startNewSubPath (x1, y1);

  513.         line.lineTo (x2, y2);

  514. 

  515.         return parseShape (xml, line);

  516.     }

  517. 

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

  519.     {

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

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

  522.         Path path;

  523.         Point<float> p;

  524. 

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

  526.         {

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

  528. 

  529.             path.startNewSubPath (first);

  530. 

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

  532.             {

  533.                 last = p;

  534.                 path.lineTo (p);

  535.             }

  536. 

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

  538.                 path.closeSubPath();

  539.         }

  540. 

  541.         return parseShape (xml, path);

  542.     }

  543. 

  544.     //==============================================================================

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

  546.                           const bool shouldParseTransform = true) const

  547.     {

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

  549.         {

  550.             SVGState newState (*this);

  551.             newState.addTransform (xml);

  552. 

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

  554.         }

  555. 

  556.         DrawablePath* dp = new DrawablePath();

  557.         setDrawableID (*dp, xml);

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

  559. 

  560.         path.applyTransform (transform);

  561.         dp->setPath (path);

  562. 

  563.         Path::Iterator iter (path);

  564. 

  565.         bool containsClosedSubPath = false;

  566.         while (iter.next())

  567.         {

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

  569.             {

  570.                 containsClosedSubPath = true;

  571.                 break;

  572.             }

  573.         }

  574. 

  575.         dp->setFill (getPathFillType (path,

  576.                                       getStyleAttribute (xml, "fill"),

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

  578.                                       getStyleAttribute (xml, "opacity"),

  579.                                       containsClosedSubPath ? Colours::black

  580.                                                             : Colours::transparentBlack));

  581. 

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

  583. 

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

  585.         {

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

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

  588.                                                 getStyleAttribute (xml, "opacity"),

  589.                                                 Colours::transparentBlack));

  590. 

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

  592.         }

  593. 

  594.         return dp;

  595.     }

  596. 

  597.     struct SetGradientStopsOp

  598.     {

  599.         const SVGState* state;

  600.         ColourGradient* gradient;

  601. 

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

  603.         {

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

  605.         }

  606.     };

  607. 

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

  609.     {

  610.         if (fillXml.xml != nullptr)

  611.         {

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

  613.             {

  614.                 int index = 0;

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

  616. 

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

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

  619. 

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

  621. 

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

  623.                     offset *= 0.01;

  624. 

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

  626.             }

  627.         }

  628.     }

  629. 

  630.     FillType getGradientFillType (const XmlPath& fillXml,

  631.                                   const Path& path,

  632.                                   const float opacity) const

  633.     {

  634.         ColourGradient gradient;

  635. 

  636.         {

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

  638. 

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

  640.             {

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

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

  643.             }

  644.         }

  645. 

  646.         addGradientStopsIn (gradient, fillXml);

  647. 

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

  649.         {

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

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

  652.         }

  653.         else

  654.         {

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

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

  657.         }

  658. 

  659.         if (opacity < 1.0f)

  660.             gradient.multiplyOpacity (opacity);

  661. 

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

  663. 

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

  665. 

  666.         float gradientWidth = viewBoxW;

  667.         float gradientHeight = viewBoxH;

  668.         float dx = 0.0f;

  669.         float dy = 0.0f;

  670. 

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

  672. 

  673.         if (! userSpace)

  674.         {

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

  676.             dx = bounds.getX();

  677.             dy = bounds.getY();

  678.             gradientWidth = bounds.getWidth();

  679.             gradientHeight = bounds.getHeight();

  680.         }

  681. 

  682.         if (gradient.isRadial)

  683.         {

  684.             if (userSpace)

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

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

  687.             else

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

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

  690. 

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

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

  693. 

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

  695.         }

  696.         else

  697.         {

  698.             if (userSpace)

  699.             {

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

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

  702. 

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

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

  705.             }

  706.             else

  707.             {

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

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

  710. 

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

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

  713.             }

  714. 

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

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

  717.         }

  718. 

  719.         FillType type (gradient);

  720. 

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

  722.                                                     .followedBy (transform));

  723. 

  724.         if (gradient.isRadial)

  725.         {

  726.             type.transform = gradientTransform;

  727.         }

  728.         else

  729.         {

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

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

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

  733.                                                             gradient.point1.x - gradient.point2.x)

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

  735. 

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

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

  738. 

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

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

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

  742.                                   / perpendicular.getDotProduct (perpendicular);

  743. 

  744.             type.gradient->point1 = newGradPoint1;

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

  746.         }

  747. 

  748.         return type;

  749.     }

  750. 

  751.     struct GetFillTypeOp

  752.     {

  753.         const SVGState* state;

  754.         FillType* dest;

  755.         const Path* path;

  756.         float opacity;

  757. 

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

  759.         {

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

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

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

  763.         }

  764.     };

  765. 

  766.     FillType getPathFillType (const Path& path,

  767.                               const String& fill,

  768.                               const String& fillOpacity,

  769.                               const String& overallOpacity,

  770.                               const Colour defaultColour) const

  771.     {

  772.         float opacity = 1.0f;

  773. 

  774.         if (overallOpacity.isNotEmpty())

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

  776. 

  777.         if (fillOpacity.isNotEmpty())

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

  779. 

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

  781.         {

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

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

  784. 

  785.             FillType result;

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

  787. 

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

  789.                 return result;

  790.         }

  791. 

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

  793.             return Colours::transparentBlack;

  794. 

  795.         int i = 0;

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

  797.     }

  798. 

  799.     PathStrokeType getStrokeFor (const XmlPath& xml) const

  800.     {

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

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

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

  804. 

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

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

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

  808. 

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

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

  811. 

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

  813.             joinStyle = PathStrokeType::curved;

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

  815.             joinStyle = PathStrokeType::beveled;

  816. 

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

  818.             capStyle = PathStrokeType::rounded;

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

  820.             capStyle = PathStrokeType::square;

  821. 

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

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

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

  825. 

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

  827.                                joinStyle, capStyle);

  828.     }

  829. 

  830.     //==============================================================================

  831.     Drawable* parseText (const XmlPath& xml)

  832.     {

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

  834. 

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

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

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

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

  839. 

  840. 

  841.         //xxx not done text yet!

  842. 

  843. 

  844.         forEachXmlChildElement (*xml, e)

  845.         {

  846.             if (e->isTextElement())

  847.             {

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

  849. 

  850.                 Path path;

  851.                 Drawable* s = parseShape (xml.getChild (e), path);

  852.                 delete s;  // xxx not finished!

  853.             }

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

  855.             {

  856.                 Drawable* s = parseText (xml.getChild (e));

  857.                 delete s;  // xxx not finished!

  858.             }

  859.         }

  860. 

  861.         return nullptr;

  862.     }

  863. 

  864.     //==============================================================================

  865.     void addTransform (const XmlPath& xml)

  866.     {

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

  868.                         .followedBy (transform);

  869.     }

  870. 

  871.     //==============================================================================

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

  873.     {

  874.         String number;

  875. 

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

  877.         {

  878.             value = 0;

  879.             return false;

  880.         }

  881. 

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

  883.         return true;

  884.     }

  885. 

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

  887.     {

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

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

  890.     }

  891. 

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

  893.     {

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

  895.             return true;

  896. 

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

  898.         return false;

  899.     }

  900. 

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

  902.     {

  903.         float n = s.getFloatValue();

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

  905. 

  906.         if (len > 2)

  907.         {

  908.             const float dpi = 96.0f;

  909. 

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

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

  912. 

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

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

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

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

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

  918.         }

  919. 

  920.         return n;

  921.     }

  922. 

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

  924.     {

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

  926.     }

  927. 

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

  929.                        const bool allowUnits, const bool isX) const

  930.     {

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

  932.         float value;

  933. 

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

  935.             coords.add (value);

  936.     }

  937. 

  938.     //==============================================================================

  939.     void parseCSSStyle (const XmlPath& xml)

  940.     {

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

  942.     }

  943. 

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

  945.     {

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

  947. 

  948.         while (! source.isEmpty())

  949.         {

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

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

  952.             {

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

  954. 

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

  956.                     return endOfName;

  957.             }

  958.         }

  959. 

  960.         return source;

  961.     }

  962. 

  963.     String getStyleAttribute (const XmlPath& xml, const String& attributeName,

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

  965.     {

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

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

  968. 

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

  970. 

  971.         if (styleAtt.isNotEmpty())

  972.         {

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

  974. 

  975.             if (value.isNotEmpty())

  976.                 return value;

  977.         }

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

  979.         {

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

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

  982. 

  983.             if (! openBrace.isEmpty())

  984.             {

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

  986. 

  987.                 if (closeBrace != openBrace)

  988.                 {

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

  990.                                                                    attributeName, defaultValue));

  991.                     if (value.isNotEmpty())

  992.                         return value;

  993.                 }

  994.             }

  995.         }

  996. 

  997.         if (xml.parent != nullptr)

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

  999. 

  1000.         return defaultValue;

  1001.     }

  1002. 

  1003.     String getInheritedAttribute (const XmlPath& xml, const String& attributeName) const

  1004.     {

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

  1006.             return xml->getStringAttribute (attributeName);

  1007. 

  1008.         if (xml.parent != nullptr)

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

  1010. 

  1011.         return String();

  1012.     }

  1013. 

  1014.     //==============================================================================

  1015.     static bool isIdentifierChar (const juce_wchar c)

  1016.     {

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

  1018.     }

  1019. 

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

  1021.     {

  1022.         int i = 0;

  1023. 

  1024.         for (;;)

  1025.         {

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

  1027. 

  1028.             if (i < 0)

  1029.                 break;

  1030. 

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

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

  1033.             {

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

  1035. 

  1036.                 if (i < 0)

  1037.                     break;

  1038. 

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

  1040. 

  1041.                 if (end < 0)

  1042.                     end = 0x7ffff;

  1043. 

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

  1045.             }

  1046. 

  1047.             ++i;

  1048.         }

  1049. 

  1050.         return defaultValue;

  1051.     }

  1052. 

  1053.     //==============================================================================

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

  1055.     {

  1056.         String::CharPointerType s (text);

  1057. 

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

  1059.             ++s;

  1060. 

  1061.         String::CharPointerType start (s);

  1062. 

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

  1064.             ++s;

  1065. 

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

  1067.             ++s;

  1068. 

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

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

  1071.         {

  1072.             s += 2;

  1073. 

  1074.             while (s.isDigit())

  1075.                 ++s;

  1076.         }

  1077. 

  1078.         if (allowUnits)

  1079.             while (s.isLetter())

  1080.                 ++s;

  1081. 

  1082.         if (s == start)

  1083.         {

  1084.             text = s;

  1085.             return false;

  1086.         }

  1087. 

  1088.         value = String (start, s);

  1089. 

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

  1091.             ++s;

  1092. 

  1093.         text = s;

  1094.         return true;

  1095.     }

  1096. 

  1097.     //==============================================================================

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

  1099.     {

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

  1101.         {

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

  1103.             int numChars = 0;

  1104. 

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

  1106.             {

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

  1108. 

  1109.                 if (hexValue >= 0)

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

  1111.                 else

  1112.                     break;

  1113.             }

  1114. 

  1115.             if (numChars <= 3)

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

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

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

  1119. 

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

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

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

  1123.         }

  1124. 

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

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

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

  1128.         {

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

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

  1131. 

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

  1133.             {

  1134.                 index = closeBracket;

  1135. 

  1136.                 StringArray tokens;

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

  1138.                 tokens.trim();

  1139.                 tokens.removeEmptyStrings();

  1140. 

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

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

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

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

  1145.                 else

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

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

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

  1149.             }

  1150.         }

  1151. 

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

  1153.     }

  1154. 

  1155.     static AffineTransform parseTransform (String t)

  1156.     {

  1157.         AffineTransform result;

  1158. 

  1159.         while (t.isNotEmpty())

  1160.         {

  1161.             StringArray tokens;

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

  1163.                                .upToFirstOccurrenceOf (")", false, false),

  1164.                               ", ", "");

  1165. 

  1166.             tokens.removeEmptyStrings (true);

  1167. 

  1168.             float numbers [6];

  1169. 

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

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

  1172. 

  1173.             AffineTransform trans;

  1174. 

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

  1176.             {

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

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

  1179.             }

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

  1181.             {

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

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

  1184.             }

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

  1186.             {

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

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

  1189.                 else

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

  1191.             }

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

  1193.             {

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

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

  1196.                 else

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

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

  1199.             }

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

  1201.             {

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

  1203.                                          0.0f, 1.0f, 0.0f);

  1204.             }

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

  1206.             {

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

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

  1209.             }

  1210. 

  1211.             result = trans.followedBy (result);

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

  1213.         }

  1214. 

  1215.         return result;

  1216.     }

  1217. 

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

  1219.                                             const double x2, const double y2,

  1220.                                             const double angle,

  1221.                                             const bool largeArc, const bool sweep,

  1222.                                             double& rx, double& ry,

  1223.                                             double& centreX, double& centreY,

  1224.                                             double& startAngle, double& deltaAngle)

  1225.     {

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

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

  1228. 

  1229.         const double cosAngle = cos (angle);

  1230.         const double sinAngle = sin (angle);

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

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

  1233.         const double xp2 = xp * xp;

  1234.         const double yp2 = yp * yp;

  1235. 

  1236.         double rx2 = rx * rx;

  1237.         double ry2 = ry * ry;

  1238. 

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

  1240.         double c;

  1241. 

  1242.         if (s <= 1.0)

  1243.         {

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

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

  1246. 

  1247.             if (largeArc == sweep)

  1248.                 c = -c;

  1249.         }

  1250.         else

  1251.         {

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

  1253.             rx *= s2;

  1254.             ry *= s2;

  1255.             c = 0;

  1256.         }

  1257. 

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

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

  1260. 

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

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

  1263. 

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

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

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

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

  1268. 

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

  1270. 

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

  1272. 

  1273.         if (uy < 0)

  1274.             startAngle = -startAngle;

  1275. 

  1276.         startAngle += double_Pi * 0.5;

  1277. 

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

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

  1280. 

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

  1282.             deltaAngle = -deltaAngle;

  1283. 

  1284.         if (sweep)

  1285.         {

  1286.             if (deltaAngle < 0)

  1287.                 deltaAngle += double_Pi * 2.0;

  1288.         }

  1289.         else

  1290.         {

  1291.             if (deltaAngle > 0)

  1292.                 deltaAngle -= double_Pi * 2.0;

  1293.         }

  1294. 

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

  1296.     }

  1297. 

  1298.     template <typename OperationType>

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

  1300.     {

  1301.         forEachXmlChildElement (*parent, e)

  1302.         {

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

  1304.             {

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

  1306.                 return true;

  1307.             }

  1308. 

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

  1310.                 return true;

  1311.         }

  1312. 

  1313.         return false;

  1314.     }

  1315. 

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

  1317. };

  1318. 

  1319. 

  1320. //==============================================================================

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

  1322. {

  1323.     SVGState state (&svgDocument);

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

  1325. }

  1326. 

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

  1328. {

  1329.     SVGState state (nullptr);

  1330.     Path p;

  1331.     state.parsePathString (p, svgPath);

  1332.     return p;

  1333. }