DISTRHO
/
JUCE
mirror of https://github.com/DISTRHO/JUCE
1
0
Fork 0
Code Releases 1 Activity
The JUCE cross-platform C++ framework, with DISTRHO/KXStudio specific changes
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
6555 Commits
9 Branches
356MB
Tree: 4b96ffbf6f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '4b96ffbf6f'
${ noResults }
JUCE/modules/juce_gui_basics/drawables/juce_SVGParser.cpp

1496 lines
52KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2015 - ROLI 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.         template <typename OperationType>

  46.         bool applyOperationToChildWithID (const String& id, OperationType& op) const

  47.         {

  48.             forEachXmlChildElement (*xml, e)

  49.             {

  50.                 XmlPath child (e, this);

  51. 

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

  53.                 {

  54.                     op (child);

  55.                     return true;

  56.                 }

  57. 

  58.                 if (child.applyOperationToChildWithID (id, op))

  59.                     return true;

  60.             }

  61. 

  62.             return false;

  63.         }

  64. 

  65.         const XmlElement* xml;

  66.         const XmlPath* parent;

  67.     };

  68. 

  69.   //==============================================================================

  70.   struct UsePathOp

  71.   {

  72.     const SVGState* state;

  73.     Path* targetPath;

  74. 

  75.     void operator() (const XmlPath& xmlPath)

  76.     {

  77.       state->parsePathElement (xmlPath, *targetPath);

  78.     }

  79.   };

  80. 

  81.   struct GetClipPathOp

  82.   {

  83.     const SVGState* state;

  84.     Drawable* target;

  85. 

  86.     void operator() (const XmlPath& xmlPath)

  87.     {

  88.       state->applyClipPath (*target, xmlPath);

  89.     }

  90.   };

  91. 

  92.   struct SetGradientStopsOp

  93.   {

  94.     const SVGState* state;

  95.     ColourGradient* gradient;

  96. 

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

  98.     {

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

  100.     }

  101.   };

  102. 

  103.   struct GetFillTypeOp

  104.   {

  105.     const SVGState* state;

  106.     const Path* path;

  107.     float opacity;

  108.     FillType fillType;

  109. 

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

  111.     {

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

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

  114.     fillType = state->getGradientFillType (xml, *path, opacity);

  115.     }

  116.   };

  117. 

  118.     //==============================================================================

  119.     Drawable* parseSVGElement (const XmlPath& xml)

  120.     {

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

  122.             return nullptr;

  123. 

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

  125. 

  126.         setCommonAttributes (*drawable, xml);

  127. 

  128.         SVGState newState (*this);

  129. 

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

  131.             newState.addTransform (xml);

  132. 

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

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

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

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

  137. 

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

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

  140. 

  141.         Point<float> viewboxXY;

  142. 

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

  144.         {

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

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

  147.             Point<float> vwh;

  148. 

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

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

  151.                  && vwh.x > 0

  152.                  && vwh.y > 0)

  153.             {

  154.                 newState.viewBoxW = vwh.x;

  155.                 newState.viewBoxH = vwh.y;

  156. 

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

  158. 

  159.                 if (placementFlags != 0)

  160.                     newState.transform = RectanglePlacement (placementFlags)

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

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

  163.                                             .followedBy (newState.transform);

  164.             }

  165.         }

  166.         else

  167.         {

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

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

  170.         }

  171. 

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

  173. 

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

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

  176.                                                      RelativeCoordinate (viewboxXY.y),

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

  178.         drawable->resetBoundingBoxToContentArea();

  179. 

  180.         return drawable;

  181.     }

  182. 

  183.     //==============================================================================

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

  185.     {

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

  187. 

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

  189.         juce_wchar lastCommandChar = 0;

  190.         bool isRelative = true;

  191.         bool carryOn = true;

  192. 

  193.         const CharPointer_ASCII validCommandChars ("MmLlHhVvCcSsQqTtAaZz");

  194. 

  195.         while (! d.isEmpty())

  196.         {

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

  198.             {

  199.                 lastCommandChar = d.getAndAdvance();

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

  201.             }

  202. 

  203.             switch (lastCommandChar)

  204.             {

  205.             case 'M':

  206.             case 'm':

  207.             case 'L':

  208.             case 'l':

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

  210.                 {

  211.                     if (isRelative)

  212.                         p1 += last;

  213. 

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

  215.                     {

  216.                         subpathStart = p1;

  217.                         path.startNewSubPath (p1);

  218.                         lastCommandChar = 'l';

  219.                     }

  220.                     else

  221.                         path.lineTo (p1);

  222. 

  223.                     last2 = last;

  224.                     last = p1;

  225.                 }

  226.                 break;

  227. 

  228.             case 'H':

  229.             case 'h':

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

  231.                 {

  232.                     if (isRelative)

  233.                         p1.x += last.x;

  234. 

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

  236. 

  237.                     last2.x = last.x;

  238.                     last.x = p1.x;

  239.                 }

  240.                 else

  241.                 {

  242.                     ++d;

  243.                 }

  244.                 break;

  245. 

  246.             case 'V':

  247.             case 'v':

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

  249.                 {

  250.                     if (isRelative)

  251.                         p1.y += last.y;

  252. 

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

  254. 

  255.                     last2.y = last.y;

  256.                     last.y = p1.y;

  257.                 }

  258.                 else

  259.                 {

  260.                     ++d;

  261.                 }

  262.                 break;

  263. 

  264.             case 'C':

  265.             case 'c':

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

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

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

  269.                 {

  270.                     if (isRelative)

  271.                     {

  272.                         p1 += last;

  273.                         p2 += last;

  274.                         p3 += last;

  275.                     }

  276. 

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

  278. 

  279.                     last2 = p2;

  280.                     last = p3;

  281.                 }

  282.                 break;

  283. 

  284.             case 'S':

  285.             case 's':

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

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

  288.                 {

  289.                     if (isRelative)

  290.                     {

  291.                         p1 += last;

  292.                         p3 += last;

  293.                     }

  294. 

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

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

  297. 

  298.                     last2 = p1;

  299.                     last = p3;

  300.                 }

  301.                 break;

  302. 

  303.             case 'Q':

  304.             case 'q':

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

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

  307.                 {

  308.                     if (isRelative)

  309.                     {

  310.                         p1 += last;

  311.                         p2 += last;

  312.                     }

  313. 

  314.                     path.quadraticTo (p1, p2);

  315. 

  316.                     last2 = p1;

  317.                     last = p2;

  318.                 }

  319.                 break;

  320. 

  321.             case 'T':

  322.             case 't':

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

  324.                 {

  325.                     if (isRelative)

  326.                         p1 += last;

  327. 

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

  329.                     path.quadraticTo (p2, p1);

  330. 

  331.                     last2 = p2;

  332.                     last = p1;

  333.                 }

  334.                 break;

  335. 

  336.             case 'A':

  337.             case 'a':

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

  339.                 {

  340.                     String num;

  341. 

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

  343.                     {

  344.                         const float angle = degreesToRadians (num.getFloatValue());

  345. 

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

  347.                         {

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

  349. 

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

  351.                             {

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

  353. 

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

  355.                                 {

  356.                                     if (isRelative)

  357.                                         p2 += last;

  358. 

  359.                                     if (last != p2)

  360.                                     {

  361.                                         double centreX, centreY, startAngle, deltaAngle;

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

  363. 

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

  365.                                                                     angle, largeArc, sweep,

  366.                                                                     rx, ry, centreX, centreY,

  367.                                                                     startAngle, deltaAngle);

  368. 

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

  370.                                                             (float) rx, (float) ry,

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

  372.                                                             false);

  373. 

  374.                                         path.lineTo (p2);

  375.                                     }

  376. 

  377.                                     last2 = last;

  378.                                     last = p2;

  379.                                 }

  380.                             }

  381.                         }

  382.                     }

  383.                 }

  384. 

  385.                 break;

  386. 

  387.             case 'Z':

  388.             case 'z':

  389.                 path.closeSubPath();

  390.                 last = last2 = subpathStart;

  391.                 d = d.findEndOfWhitespace();

  392.                 lastCommandChar = 'M';

  393.                 break;

  394. 

  395.             default:

  396.                 carryOn = false;

  397.                 break;

  398.             }

  399. 

  400.             if (! carryOn)

  401.                 break;

  402.         }

  403. 

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

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

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

  407.             path.closeSubPath();

  408.     }

  409. 

  410. private:

  411.     //==============================================================================

  412.     const XmlPath topLevelXml;

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

  414.     AffineTransform transform;

  415.     String cssStyleText;

  416. 

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

  418.     {

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

  420.         d.setName (compID);

  421.         d.setComponentID (compID);

  422. 

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

  424.             d.setVisible (false);

  425.     }

  426. 

  427.     //==============================================================================

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

  429.     {

  430.         forEachXmlChildElement (*xml, e)

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

  432.     }

  433. 

  434.     Drawable* parseSubElement (const XmlPath& xml)

  435.     {

  436.         {

  437.             Path path;

  438.             if (parsePathElement (xml, path))

  439.                 return parseShape (xml, path);

  440.         }

  441. 

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

  443. 

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

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

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

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

  448.         if (tag == "a")         return parseLinkElement (xml);

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

  450. 

  451.         return nullptr;

  452.     }

  453. 

  454.     bool parsePathElement (const XmlPath& xml, Path& path) const

  455.     {

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

  457. 

  458.         if (tag == "path")      { parsePath (xml, path);           return true; }

  459.         if (tag == "rect")      { parseRect (xml, path);           return true; }

  460.         if (tag == "circle")    { parseCircle (xml, path);         return true; }

  461.         if (tag == "ellipse")   { parseEllipse (xml, path);        return true; }

  462.         if (tag == "line")      { parseLine (xml, path);           return true; }

  463.         if (tag == "polyline")  { parsePolygon (xml, true, path);  return true; }

  464.         if (tag == "polygon")   { parsePolygon (xml, false, path); return true; }

  465.         if (tag == "use")       { parseUse (xml, path);            return true; }

  466. 

  467.         return false;

  468.     }

  469. 

  470.     DrawableComposite* parseSwitch (const XmlPath& xml)

  471.     {

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

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

  474. 

  475.         return nullptr;

  476.     }

  477. 

  478.     DrawableComposite* parseGroupElement (const XmlPath& xml)

  479.     {

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

  481. 

  482.         setCommonAttributes (*drawable, xml);

  483. 

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

  485.         {

  486.             SVGState newState (*this);

  487.             newState.addTransform (xml);

  488. 

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

  490.         }

  491.         else

  492.         {

  493.             parseSubElements (xml, *drawable);

  494.         }

  495. 

  496.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  497.         return drawable;

  498.     }

  499. 

  500.     DrawableComposite* parseLinkElement (const XmlPath& xml)

  501.     {

  502.         return parseGroupElement (xml); // TODO: support for making this clickable

  503.     }

  504. 

  505.     //==============================================================================

  506.     void parsePath (const XmlPath& xml, Path& path) const

  507.     {

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

  509. 

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

  511.             path.setUsingNonZeroWinding (false);

  512.     }

  513. 

  514.     void parseRect (const XmlPath& xml, Path& rect) const

  515.     {

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

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

  518. 

  519.         if (hasRX || hasRY)

  520.         {

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

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

  523. 

  524.             if (! hasRX)

  525.                 rx = ry;

  526.             else if (! hasRY)

  527.                 ry = rx;

  528. 

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

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

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

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

  533.                                       rx, ry);

  534.         }

  535.         else

  536.         {

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

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

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

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

  541.         }

  542.     }

  543. 

  544.     void parseCircle (const XmlPath& xml, Path& circle) const

  545.     {

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

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

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

  549. 

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

  551.     }

  552. 

  553.     void parseEllipse (const XmlPath& xml, Path& ellipse) const

  554.     {

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

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

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

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

  559. 

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

  561.     }

  562. 

  563.     void parseLine (const XmlPath& xml, Path& line) const

  564.     {

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

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

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

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

  569. 

  570.         line.startNewSubPath (x1, y1);

  571.         line.lineTo (x2, y2);

  572.     }

  573. 

  574.     void parsePolygon (const XmlPath& xml, const bool isPolyline, Path& path) const

  575.     {

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

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

  578.         Point<float> p;

  579. 

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

  581.         {

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

  583. 

  584.             path.startNewSubPath (first);

  585. 

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

  587.             {

  588.                 last = p;

  589.                 path.lineTo (p);

  590.             }

  591. 

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

  593.                 path.closeSubPath();

  594.         }

  595.     }

  596. 

  597.     void parseUse (const XmlPath& xml, Path& path) const

  598.     {

  599.         const String link (xml->getStringAttribute ("xlink:href"));

  600. 

  601.         if (link.startsWithChar ('#'))

  602.         {

  603.             const String linkedID = link.substring (1);

  604. 

  605.             UsePathOp op = { this, &path };

  606.             topLevelXml.applyOperationToChildWithID (linkedID, op);

  607.         }

  608.     }

  609. 

  610.     static String parseURL (const String& str)

  611.     {

  612.         if (str.startsWithIgnoreCase ("url"))

  613.             return str.fromFirstOccurrenceOf ("#", false, false)

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

  615. 

  616.         return String();

  617.     }

  618. 

  619.     //==============================================================================

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

  621.                           const bool shouldParseTransform = true) const

  622.     {

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

  624.         {

  625.             SVGState newState (*this);

  626.             newState.addTransform (xml);

  627. 

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

  629.         }

  630. 

  631.         DrawablePath* dp = new DrawablePath();

  632.         setCommonAttributes (*dp, xml);

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

  634. 

  635.         path.applyTransform (transform);

  636.         dp->setPath (path);

  637. 

  638.         dp->setFill (getPathFillType (path,

  639.                                       getStyleAttribute (xml, "fill"),

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

  641.                                       getStyleAttribute (xml, "opacity"),

  642.                                       pathContainsClosedSubPath (path) ? Colours::black

  643.                                                                        : Colours::transparentBlack));

  644. 

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

  646. 

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

  648.         {

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

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

  651.                                                 getStyleAttribute (xml, "opacity"),

  652.                                                 Colours::transparentBlack));

  653. 

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

  655.         }

  656. 

  657.         const String strokeDashArray (getStyleAttribute (xml, "stroke-dasharray"));

  658. 

  659.         if (strokeDashArray.isNotEmpty())

  660.             parseDashArray (strokeDashArray, *dp);

  661. 

  662.         parseClipPath (xml, *dp);

  663. 

  664.         return dp;

  665.     }

  666. 

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

  668.     {

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

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

  671.                 return true;

  672. 

  673.         return false;

  674.     }

  675. 

  676.     void parseDashArray (const String& dashList, DrawablePath& dp) const

  677.     {

  678.         if (dashList.equalsIgnoreCase ("null") || dashList.equalsIgnoreCase ("none"))

  679.             return;

  680. 

  681.         Array<float> dashLengths;

  682. 

  683.         for (String::CharPointerType t = dashList.getCharPointer();;)

  684.         {

  685.             float value;

  686.             if (! parseCoord (t, value, true, true))

  687.                 break;

  688. 

  689.             dashLengths.add (value);

  690. 

  691.             t = t.findEndOfWhitespace();

  692. 

  693.             if (*t == ',')

  694.                 ++t;

  695.         }

  696. 

  697.         if (dashLengths.size() > 0)

  698.         {

  699.             float* const dashes = dashLengths.getRawDataPointer();

  700. 

  701.             for (int i = 0; i < dashLengths.size(); ++i)

  702.             {

  703.                 if (dashes[i] <= 0)  // SVG uses zero-length dashes to mean a dotted line

  704.                 {

  705.                     if (dashLengths.size() == 1)

  706.                         return;

  707. 

  708.                     const float nonZeroLength = 0.001f;

  709.                     dashes[i] = nonZeroLength;

  710. 

  711.                     const int pairedIndex = i ^ 1;

  712. 

  713.                     if (isPositiveAndBelow (pairedIndex, dashLengths.size())

  714.                           && dashes[pairedIndex] > nonZeroLength)

  715.                         dashes[pairedIndex] -= nonZeroLength;

  716.                 }

  717.             }

  718. 

  719.             dp.setDashLengths (dashLengths);

  720.         }

  721.     }

  722. 

  723.     void parseClipPath (const XmlPath& xml, Drawable& d) const

  724.     {

  725.         const String clipPath (getStyleAttribute (xml, "clip-path"));

  726. 

  727.         if (clipPath.isNotEmpty())

  728.         {

  729.             String urlID = parseURL (clipPath);

  730. 

  731.             if (urlID.isNotEmpty())

  732.             {

  733.                 GetClipPathOp op = { this, &d };

  734.                 topLevelXml.applyOperationToChildWithID (urlID, op);

  735.             }

  736.         }

  737.     }

  738. 

  739.     void applyClipPath (Drawable& target, const XmlPath& xmlPath) const

  740.     {

  741.         if (xmlPath->hasTagNameIgnoringNamespace ("clipPath"))

  742.         {

  743.             // TODO: implement clipping..

  744.             ignoreUnused (target);

  745.         }

  746.     }

  747. 

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

  749.     {

  750.         if (fillXml.xml != nullptr)

  751.         {

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

  753.             {

  754.                 int index = 0;

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

  756. 

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

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

  759. 

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

  761. 

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

  763.                     offset *= 0.01;

  764. 

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

  766.             }

  767.         }

  768.     }

  769. 

  770.     FillType getGradientFillType (const XmlPath& fillXml,

  771.                                   const Path& path,

  772.                                   const float opacity) const

  773.     {

  774.         ColourGradient gradient;

  775. 

  776.         {

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

  778. 

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

  780.             {

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

  782.                 topLevelXml.applyOperationToChildWithID (id.substring (1), op);

  783.             }

  784.         }

  785. 

  786.         addGradientStopsIn (gradient, fillXml);

  787. 

  788.         if (int numColours = gradient.getNumColours())

  789.         {

  790.             if (gradient.getColourPosition (0) > 0)

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

  792. 

  793.             if (gradient.getColourPosition (numColours - 1) < 1.0)

  794.                 gradient.addColour (1.0, gradient.getColour (numColours - 1));

  795.         }

  796.         else

  797.         {

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

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

  800.         }

  801. 

  802.         if (opacity < 1.0f)

  803.             gradient.multiplyOpacity (opacity);

  804. 

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

  806. 

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

  808. 

  809.         float gradientWidth = viewBoxW;

  810.         float gradientHeight = viewBoxH;

  811.         float dx = 0.0f;

  812.         float dy = 0.0f;

  813. 

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

  815. 

  816.         if (! userSpace)

  817.         {

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

  819.             dx = bounds.getX();

  820.             dy = bounds.getY();

  821.             gradientWidth = bounds.getWidth();

  822.             gradientHeight = bounds.getHeight();

  823.         }

  824. 

  825.         if (gradient.isRadial)

  826.         {

  827.             if (userSpace)

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

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

  830.             else

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

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

  833. 

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

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

  836. 

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

  838.         }

  839.         else

  840.         {

  841.             if (userSpace)

  842.             {

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

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

  845. 

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

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

  848.             }

  849.             else

  850.             {

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

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

  853. 

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

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

  856.             }

  857. 

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

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

  860.         }

  861. 

  862.         FillType type (gradient);

  863. 

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

  865.                                                     .followedBy (transform));

  866. 

  867.         if (gradient.isRadial)

  868.         {

  869.             type.transform = gradientTransform;

  870.         }

  871.         else

  872.         {

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

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

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

  876.                                                             gradient.point1.x - gradient.point2.x)

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

  878. 

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

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

  881. 

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

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

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

  885.                                   / perpendicular.getDotProduct (perpendicular);

  886. 

  887.             type.gradient->point1 = newGradPoint1;

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

  889.         }

  890. 

  891.         return type;

  892.     }

  893. 

  894.     FillType getPathFillType (const Path& path,

  895.                               const String& fill,

  896.                               const String& fillOpacity,

  897.                               const String& overallOpacity,

  898.                               const Colour defaultColour) const

  899.     {

  900.         float opacity = 1.0f;

  901. 

  902.         if (overallOpacity.isNotEmpty())

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

  904. 

  905.         if (fillOpacity.isNotEmpty())

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

  907. 

  908.         String urlID = parseURL (fill);

  909. 

  910.         if (urlID.isNotEmpty())

  911.         {

  912.             GetFillTypeOp op = { this, &path, opacity, FillType() };

  913. 

  914.             if (topLevelXml.applyOperationToChildWithID (urlID, op))

  915.                 return op.fillType;

  916.         }

  917. 

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

  919.             return Colours::transparentBlack;

  920. 

  921.         int i = 0;

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

  923.     }

  924. 

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

  926.     {

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

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

  929. 

  930.         return PathStrokeType::mitered;

  931.     }

  932. 

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

  934.     {

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

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

  937. 

  938.         return PathStrokeType::butt;

  939.     }

  940. 

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

  942.     {

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

  944.     }

  945. 

  946.     PathStrokeType getStrokeFor (const XmlPath& xml) const

  947.     {

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

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

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

  951.     }

  952. 

  953.     //==============================================================================

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

  955.     {

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

  957.         {

  958.             SVGState newState (*this);

  959.             newState.addTransform (xml);

  960. 

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

  962.         }

  963. 

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

  965. 

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

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

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

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

  970. 

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

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

  973. 

  974.         DrawableComposite* dc = new DrawableComposite();

  975.         setCommonAttributes (*dc, xml);

  976. 

  977.         forEachXmlChildElement (*xml, e)

  978.         {

  979.             if (e->isTextElement())

  980.             {

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

  982. 

  983.                 DrawableText* dt = new DrawableText();

  984.                 dc->addAndMakeVisible (dt);

  985. 

  986.                 dt->setText (text);

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

  988.                 dt->setTransform (transform);

  989. 

  990.                 int i = 0;

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

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

  993. 

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

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

  996. 

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

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

  999. 

  1000.                 dt->setBoundingBox (bounds);

  1001.             }

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

  1003.             {

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

  1005.             }

  1006.         }

  1007. 

  1008.         return dc;

  1009.     }

  1010. 

  1011.     Font getFont (const XmlPath& xml) const

  1012.     {

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

  1014. 

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

  1016. 

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

  1018.             style |= Font::bold;

  1019. 

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

  1021. 

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

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

  1024.     }

  1025. 

  1026.     //==============================================================================

  1027.     void addTransform (const XmlPath& xml)

  1028.     {

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

  1030.                         .followedBy (transform);

  1031.     }

  1032. 

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

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

  1035.     {

  1036.         String number;

  1037. 

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

  1039.         {

  1040.             value = 0;

  1041.             return false;

  1042.         }

  1043. 

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

  1045.         return true;

  1046.     }

  1047. 

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

  1049.     {

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

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

  1052.     }

  1053. 

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

  1055.     {

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

  1057.             return true;

  1058. 

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

  1060.         return false;

  1061.     }

  1062. 

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

  1064.     {

  1065.         float n = s.getFloatValue();

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

  1067. 

  1068.         if (len > 2)

  1069.         {

  1070.             const float dpi = 96.0f;

  1071. 

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

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

  1074. 

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

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

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

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

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

  1080.         }

  1081. 

  1082.         return n;

  1083.     }

  1084. 

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

  1086.     {

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

  1088.     }

  1089. 

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

  1091.     {

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

  1093.         float value;

  1094. 

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

  1096.             coords.add (value);

  1097.     }

  1098. 

  1099.     //==============================================================================

  1100.     void parseCSSStyle (const XmlPath& xml)

  1101.     {

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

  1103.     }

  1104. 

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

  1106.     {

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

  1108. 

  1109.         while (! source.isEmpty())

  1110.         {

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

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

  1113.             {

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

  1115. 

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

  1117.                     return endOfName;

  1118.             }

  1119.         }

  1120. 

  1121.         return source;

  1122.     }

  1123. 

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

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

  1126.     {

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

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

  1129. 

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

  1131. 

  1132.         if (styleAtt.isNotEmpty())

  1133.         {

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

  1135. 

  1136.             if (value.isNotEmpty())

  1137.                 return value;

  1138.         }

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

  1140.         {

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

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

  1143. 

  1144.             if (! openBrace.isEmpty())

  1145.             {

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

  1147. 

  1148.                 if (closeBrace != openBrace)

  1149.                 {

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

  1151.                                                                    attributeName, defaultValue));

  1152.                     if (value.isNotEmpty())

  1153.                         return value;

  1154.                 }

  1155.             }

  1156.         }

  1157. 

  1158.         if (xml.parent != nullptr)

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

  1160. 

  1161.         return defaultValue;

  1162.     }

  1163. 

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

  1165.     {

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

  1167.             return xml->getStringAttribute (attributeName);

  1168. 

  1169.         if (xml.parent != nullptr)

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

  1171. 

  1172.         return String();

  1173.     }

  1174. 

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

  1176.     {

  1177.         if (align.isEmpty())

  1178.             return 0;

  1179. 

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

  1181.             return RectanglePlacement::stretchToFit;

  1182. 

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

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

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

  1186.                                                                                         : RectanglePlacement::xMid))

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

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

  1189.                                                                                         : RectanglePlacement::yMid));

  1190.     }

  1191. 

  1192.     //==============================================================================

  1193.     static bool isIdentifierChar (const juce_wchar c)

  1194.     {

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

  1196.     }

  1197. 

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

  1199.     {

  1200.         int i = 0;

  1201. 

  1202.         for (;;)

  1203.         {

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

  1205. 

  1206.             if (i < 0)

  1207.                 break;

  1208. 

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

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

  1211.             {

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

  1213. 

  1214.                 if (i < 0)

  1215.                     break;

  1216. 

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

  1218. 

  1219.                 if (end < 0)

  1220.                     end = 0x7ffff;

  1221. 

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

  1223.             }

  1224. 

  1225.             ++i;

  1226.         }

  1227. 

  1228.         return defaultValue;

  1229.     }

  1230. 

  1231.     //==============================================================================

  1232.     static bool isStartOfNumber (juce_wchar c) noexcept

  1233.     {

  1234.         return CharacterFunctions::isDigit (c) || c == '-' || c == '+';

  1235.     }

  1236. 

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

  1238.     {

  1239.         String::CharPointerType s (text);

  1240. 

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

  1242.             ++s;

  1243. 

  1244.         String::CharPointerType start (s);

  1245. 

  1246.         if (isStartOfNumber (*s))

  1247.             ++s;

  1248. 

  1249.         while (s.isDigit())

  1250.             ++s;

  1251. 

  1252.         if (*s == '.')

  1253.         {

  1254.             ++s;

  1255. 

  1256.             while (s.isDigit())

  1257.                 ++s;

  1258.         }

  1259. 

  1260.         if ((*s == 'e' || *s == 'E') && isStartOfNumber (s[1]))

  1261.         {

  1262.             s += 2;

  1263. 

  1264.             while (s.isDigit())

  1265.                 ++s;

  1266.         }

  1267. 

  1268.         if (allowUnits)

  1269.             while (s.isLetter())

  1270.                 ++s;

  1271. 

  1272.         if (s == start)

  1273.         {

  1274.             text = s;

  1275.             return false;

  1276.         }

  1277. 

  1278.         value = String (start, s);

  1279. 

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

  1281.             ++s;

  1282. 

  1283.         text = s;

  1284.         return true;

  1285.     }

  1286. 

  1287.     //==============================================================================

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

  1289.     {

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

  1291.         {

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

  1293.             int numChars = 0;

  1294. 

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

  1296.             {

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

  1298. 

  1299.                 if (hexValue >= 0)

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

  1301.                 else

  1302.                     break;

  1303.             }

  1304. 

  1305.             if (numChars <= 3)

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

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

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

  1309. 

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

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

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

  1313.         }

  1314. 

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

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

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

  1318.         {

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

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

  1321. 

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

  1323.             {

  1324.                 index = closeBracket;

  1325. 

  1326.                 StringArray tokens;

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

  1328.                 tokens.trim();

  1329.                 tokens.removeEmptyStrings();

  1330. 

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

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

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

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

  1335.                 else

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

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

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

  1339.             }

  1340.         }

  1341. 

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

  1343.     }

  1344. 

  1345.     static AffineTransform parseTransform (String t)

  1346.     {

  1347.         AffineTransform result;

  1348. 

  1349.         while (t.isNotEmpty())

  1350.         {

  1351.             StringArray tokens;

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

  1353.                                .upToFirstOccurrenceOf (")", false, false),

  1354.                               ", ", "");

  1355. 

  1356.             tokens.removeEmptyStrings (true);

  1357. 

  1358.             float numbers[6];

  1359. 

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

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

  1362. 

  1363.             AffineTransform trans;

  1364. 

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

  1366.             {

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

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

  1369.             }

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

  1371.             {

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

  1373.             }

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

  1375.             {

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

  1377.             }

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

  1379.             {

  1380.                 trans = AffineTransform::rotation (degreesToRadians (numbers[0]), numbers[1], numbers[2]);

  1381.             }

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

  1383.             {

  1384.                 trans = AffineTransform::shear (std::tan (degreesToRadians (numbers[0])), 0.0f);

  1385.             }

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

  1387.             {

  1388.                 trans = AffineTransform::shear (0.0f, std::tan (degreesToRadians (numbers[0])));

  1389.             }

  1390. 

  1391.             result = trans.followedBy (result);

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

  1393.         }

  1394. 

  1395.         return result;

  1396.     }

  1397. 

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

  1399.                                             const double x2, const double y2,

  1400.                                             const double angle,

  1401.                                             const bool largeArc, const bool sweep,

  1402.                                             double& rx, double& ry,

  1403.                                             double& centreX, double& centreY,

  1404.                                             double& startAngle, double& deltaAngle) noexcept

  1405.     {

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

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

  1408. 

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

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

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

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

  1413.         const double xp2 = xp * xp;

  1414.         const double yp2 = yp * yp;

  1415. 

  1416.         double rx2 = rx * rx;

  1417.         double ry2 = ry * ry;

  1418. 

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

  1420.         double c;

  1421. 

  1422.         if (s <= 1.0)

  1423.         {

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

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

  1426. 

  1427.             if (largeArc == sweep)

  1428.                 c = -c;

  1429.         }

  1430.         else

  1431.         {

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

  1433.             rx *= s2;

  1434.             ry *= s2;

  1435.             c = 0;

  1436.         }

  1437. 

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

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

  1440. 

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

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

  1443. 

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

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

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

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

  1448. 

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

  1450. 

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

  1452. 

  1453.         if (uy < 0)

  1454.             startAngle = -startAngle;

  1455. 

  1456.         startAngle += double_Pi * 0.5;

  1457. 

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

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

  1460. 

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

  1462.             deltaAngle = -deltaAngle;

  1463. 

  1464.         if (sweep)

  1465.         {

  1466.             if (deltaAngle < 0)

  1467.                 deltaAngle += double_Pi * 2.0;

  1468.         }

  1469.         else

  1470.         {

  1471.             if (deltaAngle > 0)

  1472.                 deltaAngle -= double_Pi * 2.0;

  1473.         }

  1474. 

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

  1476.     }

  1477. 

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

  1479. };

  1480. 

  1481. 

  1482. //==============================================================================

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

  1484. {

  1485.     SVGState state (&svgDocument);

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

  1487. }

  1488. 

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

  1490. {

  1491.     SVGState state (nullptr);

  1492.     Path p;

  1493.     state.parsePathString (p, svgPath);

  1494.     return p;

  1495. }