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.
7796 Commits
9 Branches
2.8GB
Tree: 86f9c11d15
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '86f9c11d15'
${ noResults }
JUCE/modules/juce_gui_basics/drawables/juce_SVGParser.cpp

1731 lines
58KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2017 - ROLI Ltd.

  6. 

  7.    JUCE is an open source library subject to commercial or open-source

  8.    licensing.

  9. 

  10.    By using JUCE, you agree to the terms of both the JUCE 5 End-User License

  11.    Agreement and JUCE 5 Privacy Policy (both updated and effective as of the

  12.    27th April 2017).

  13. 

  14.    End User License Agreement: www.juce.com/juce-5-licence

  15.    Privacy Policy: www.juce.com/juce-5-privacy-policy

  16. 

  17.    Or: You may also use this code under the terms of the GPL v3 (see

  18.    www.gnu.org/licenses).

  19. 

  20.    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER

  21.    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE

  22.    DISCLAIMED.

  23. 

  24.   ==============================================================================

  25. */

  26. 

  27. class SVGState

  28. {

  29. public:

  30.     //==============================================================================

  31.     explicit SVGState (const XmlElement* topLevel, const File& svgFile = {})

  32.        : originalFile (svgFile), topLevelXml (topLevel, nullptr)

  33.     {

  34.     }

  35. 

  36.     struct XmlPath

  37.     {

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

  39. 

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

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

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

  43. 

  44.         template <typename OperationType>

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

  46.         {

  47.             forEachXmlChildElement (*xml, e)

  48.             {

  49.                 XmlPath child (e, this);

  50. 

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

  52.                       && ! child->hasTagName ("defs"))

  53.                     return op (child);

  54. 

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

  56.                     return true;

  57.             }

  58. 

  59.             return false;

  60.         }

  61. 

  62.         const XmlElement* xml;

  63.         const XmlPath* parent;

  64.     };

  65. 

  66.     //==============================================================================

  67.     struct UsePathOp

  68.     {

  69.         const SVGState* state;

  70.         Path* targetPath;

  71. 

  72.         bool operator() (const XmlPath& xmlPath) const

  73.         {

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

  75.         }

  76.     };

  77. 

  78.     struct UseTextOp

  79.     {

  80.         const SVGState* state;

  81.         AffineTransform* transform;

  82.         Drawable* target;

  83. 

  84.         bool operator() (const XmlPath& xmlPath)

  85.         {

  86.             target = state->parseText (xmlPath, true, transform);

  87.             return target != nullptr;

  88.         }

  89.     };

  90. 

  91.     struct UseImageOp

  92.     {

  93.         const SVGState* state;

  94.         AffineTransform* transform;

  95.         Drawable* target;

  96. 

  97.         bool operator() (const XmlPath& xmlPath)

  98.         {

  99.             target = state->parseImage (xmlPath, true, transform);

  100.             return target != nullptr;

  101.         }

  102.     };

  103. 

  104.     struct GetClipPathOp

  105.     {

  106.         SVGState* state;

  107.         Drawable* target;

  108. 

  109.         bool operator() (const XmlPath& xmlPath)

  110.         {

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

  112.         }

  113.     };

  114. 

  115.     struct SetGradientStopsOp

  116.     {

  117.         const SVGState* state;

  118.         ColourGradient* gradient;

  119. 

  120.         bool operator() (const XmlPath& xml) const

  121.         {

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

  123.         }

  124.     };

  125. 

  126.     struct GetFillTypeOp

  127.     {

  128.         const SVGState* state;

  129.         const Path* path;

  130.         float opacity;

  131.         FillType fillType;

  132. 

  133.         bool operator() (const XmlPath& xml)

  134.         {

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

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

  137.             {

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

  139.                 return true;

  140.             }

  141. 

  142.             return false;

  143.         }

  144.     };

  145. 

  146.     //==============================================================================

  147.     Drawable* parseSVGElement (const XmlPath& xml)

  148.     {

  149.         auto drawable = new DrawableComposite();

  150.         setCommonAttributes (*drawable, xml);

  151. 

  152.         SVGState newState (*this);

  153. 

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

  155.             newState.addTransform (xml);

  156. 

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

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

  159. 

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

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

  162. 

  163.         Point<float> viewboxXY;

  164. 

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

  166.         {

  167.             auto viewBoxAtt = xml->getStringAttribute ("viewBox");

  168.             auto viewParams = viewBoxAtt.getCharPointer();

  169.             Point<float> vwh;

  170. 

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

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

  173.                  && vwh.x > 0

  174.                  && vwh.y > 0)

  175.             {

  176.                 newState.viewBoxW = vwh.x;

  177.                 newState.viewBoxH = vwh.y;

  178. 

  179.                 auto placementFlags = parsePlacementFlags (xml->getStringAttribute ("preserveAspectRatio").trim());

  180. 

  181.                 if (placementFlags != 0)

  182.                     newState.transform = RectanglePlacement (placementFlags)

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

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

  185.                                             .followedBy (newState.transform);

  186.             }

  187.         }

  188.         else

  189.         {

  190.             if (viewBoxW == 0.0f)  newState.viewBoxW = newState.width;

  191.             if (viewBoxH == 0.0f)  newState.viewBoxH = newState.height;

  192.         }

  193. 

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

  195. 

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

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

  198.                                                      RelativeCoordinate (viewboxXY.y),

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

  200.         drawable->resetBoundingBoxToContentArea();

  201. 

  202.         return drawable;

  203.     }

  204. 

  205.     //==============================================================================

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

  207.     {

  208.         auto d = pathString.getCharPointer().findEndOfWhitespace();

  209. 

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

  211.         juce_wchar currentCommand = 0, previousCommand = 0;

  212.         bool isRelative = true;

  213.         bool carryOn = true;

  214. 

  215.         while (! d.isEmpty())

  216.         {

  217.             if (CharPointer_ASCII ("MmLlHhVvCcSsQqTtAaZz").indexOf (*d) >= 0)

  218.             {

  219.                 currentCommand = d.getAndAdvance();

  220.                 isRelative = currentCommand >= 'a';

  221.             }

  222. 

  223.             switch (currentCommand)

  224.             {

  225.             case 'M':

  226.             case 'm':

  227.             case 'L':

  228.             case 'l':

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

  230.                 {

  231.                     if (isRelative)

  232.                         p1 += last;

  233. 

  234.                     if (currentCommand == 'M' || currentCommand == 'm')

  235.                     {

  236.                         subpathStart = p1;

  237.                         path.startNewSubPath (p1);

  238.                         currentCommand = 'l';

  239.                     }

  240.                     else

  241.                         path.lineTo (p1);

  242. 

  243.                     last2 = last;

  244.                     last = p1;

  245.                 }

  246.                 break;

  247. 

  248.             case 'H':

  249.             case 'h':

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

  251.                 {

  252.                     if (isRelative)

  253.                         p1.x += last.x;

  254. 

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

  256. 

  257.                     last2.x = last.x;

  258.                     last.x = p1.x;

  259.                 }

  260.                 else

  261.                 {

  262.                     ++d;

  263.                 }

  264.                 break;

  265. 

  266.             case 'V':

  267.             case 'v':

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

  269.                 {

  270.                     if (isRelative)

  271.                         p1.y += last.y;

  272. 

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

  274. 

  275.                     last2.y = last.y;

  276.                     last.y = p1.y;

  277.                 }

  278.                 else

  279.                 {

  280.                     ++d;

  281.                 }

  282.                 break;

  283. 

  284.             case 'C':

  285.             case 'c':

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

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

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

  289.                 {

  290.                     if (isRelative)

  291.                     {

  292.                         p1 += last;

  293.                         p2 += last;

  294.                         p3 += last;

  295.                     }

  296. 

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

  298. 

  299.                     last2 = p2;

  300.                     last = p3;

  301.                 }

  302.                 break;

  303. 

  304.             case 'S':

  305.             case 's':

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

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

  308.                 {

  309.                     if (isRelative)

  310.                     {

  311.                         p1 += last;

  312.                         p3 += last;

  313.                     }

  314. 

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

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

  317. 

  318.                     last2 = p1;

  319.                     last = p3;

  320.                 }

  321.                 break;

  322. 

  323.             case 'Q':

  324.             case 'q':

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

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

  327.                 {

  328.                     if (isRelative)

  329.                     {

  330.                         p1 += last;

  331.                         p2 += last;

  332.                     }

  333. 

  334.                     path.quadraticTo (p1, p2);

  335. 

  336.                     last2 = p1;

  337.                     last = p2;

  338.                 }

  339.                 break;

  340. 

  341.             case 'T':

  342.             case 't':

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

  344.                 {

  345.                     if (isRelative)

  346.                         p1 += last;

  347. 

  348.                     p2 = CharPointer_ASCII ("QqTt").indexOf (previousCommand) >= 0 ? last + (last - last2)

  349.                                                                                    : p1;

  350.                     path.quadraticTo (p2, p1);

  351. 

  352.                     last2 = p2;

  353.                     last = p1;

  354.                 }

  355.                 break;

  356. 

  357.             case 'A':

  358.             case 'a':

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

  360.                 {

  361.                     String num;

  362. 

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

  364.                     {

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

  366. 

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

  368.                         {

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

  370. 

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

  372.                             {

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

  374. 

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

  376.                                 {

  377.                                     if (isRelative)

  378.                                         p2 += last;

  379. 

  380.                                     if (last != p2)

  381.                                     {

  382.                                         double centreX, centreY, startAngle, deltaAngle;

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

  384. 

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

  386.                                                                     angle, largeArc, sweep,

  387.                                                                     rx, ry, centreX, centreY,

  388.                                                                     startAngle, deltaAngle);

  389. 

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

  391.                                                             (float) rx, (float) ry,

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

  393.                                                             false);

  394. 

  395.                                         path.lineTo (p2);

  396.                                     }

  397. 

  398.                                     last2 = last;

  399.                                     last = p2;

  400.                                 }

  401.                             }

  402.                         }

  403.                     }

  404.                 }

  405. 

  406.                 break;

  407. 

  408.             case 'Z':

  409.             case 'z':

  410.                 path.closeSubPath();

  411.                 last = last2 = subpathStart;

  412.                 d = d.findEndOfWhitespace();

  413.                 currentCommand = 'M';

  414.                 break;

  415. 

  416.             default:

  417.                 carryOn = false;

  418.                 break;

  419.             }

  420. 

  421.             if (! carryOn)

  422.                 break;

  423. 

  424.             previousCommand = currentCommand;

  425.         }

  426. 

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

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

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

  430.             path.closeSubPath();

  431.     }

  432. 

  433. private:

  434.     //==============================================================================

  435.     const File originalFile;

  436.     const XmlPath topLevelXml;

  437.     float width = 512, height = 512, viewBoxW = 0, viewBoxH = 0;

  438.     AffineTransform transform;

  439.     String cssStyleText;

  440. 

  441.     static bool isNone (const String& s) noexcept

  442.     {

  443.         return s.equalsIgnoreCase ("none");

  444.     }

  445. 

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

  447.     {

  448.         auto compID = xml->getStringAttribute ("id");

  449.         d.setName (compID);

  450.         d.setComponentID (compID);

  451. 

  452.         if (isNone (xml->getStringAttribute ("display")))

  453.             d.setVisible (false);

  454.     }

  455. 

  456.     //==============================================================================

  457.     void parseSubElements (const XmlPath& xml, DrawableComposite& parentDrawable, const bool shouldParseClip = true)

  458.     {

  459.         forEachXmlChildElement (*xml, e)

  460.         {

  461.             const XmlPath child (xml.getChild (e));

  462. 

  463.             if (auto* drawable = parseSubElement (child))

  464.             {

  465.                 parentDrawable.addChildComponent (drawable);

  466. 

  467.                 if (! isNone (getStyleAttribute (child, "display")))

  468.                     drawable->setVisible (true);

  469. 

  470.                 if (shouldParseClip)

  471.                     parseClipPath (child, *drawable);

  472.             }

  473.         }

  474.     }

  475. 

  476.     Drawable* parseSubElement (const XmlPath& xml)

  477.     {

  478.         {

  479.             Path path;

  480.             if (parsePathElement (xml, path))

  481.                 return parseShape (xml, path);

  482.         }

  483. 

  484.         auto tag = xml->getTagNameWithoutNamespace();

  485. 

  486.         if (tag == "g")         return parseGroupElement (xml, true);

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

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

  489.         if (tag == "image")     return parseImage (xml, true);

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

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

  492.         if (tag == "use")       return parseUseOther (xml);

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

  494.         if (tag == "defs")      parseDefs (xml);

  495. 

  496.         return nullptr;

  497.     }

  498. 

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

  500.     {

  501.         auto tag = xml->getTagNameWithoutNamespace();

  502. 

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

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

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

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

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

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

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

  510.         if (tag == "use")       { return parseUsePath (xml, path); }

  511. 

  512.         return false;

  513.     }

  514. 

  515.     DrawableComposite* parseSwitch (const XmlPath& xml)

  516.     {

  517.         if (auto* group = xml->getChildByName ("g"))

  518.             return parseGroupElement (xml.getChild (group), true);

  519. 

  520.         return nullptr;

  521.     }

  522. 

  523.     DrawableComposite* parseGroupElement (const XmlPath& xml, bool shouldParseTransform)

  524.     {

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

  526.         {

  527.             SVGState newState (*this);

  528.             newState.addTransform (xml);

  529. 

  530.             return newState.parseGroupElement (xml, false);

  531.         }

  532. 

  533.         auto* drawable = new DrawableComposite();

  534.         setCommonAttributes (*drawable, xml);

  535.         parseSubElements (xml, *drawable);

  536. 

  537.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  538.         return drawable;

  539.     }

  540. 

  541.     DrawableComposite* parseLinkElement (const XmlPath& xml)

  542.     {

  543.         return parseGroupElement (xml, true); // TODO: support for making this clickable

  544.     }

  545. 

  546.     //==============================================================================

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

  548.     {

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

  550. 

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

  552.             path.setUsingNonZeroWinding (false);

  553.     }

  554. 

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

  556.     {

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

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

  559. 

  560.         if (hasRX || hasRY)

  561.         {

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

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

  564. 

  565.             if (! hasRX)

  566.                 rx = ry;

  567.             else if (! hasRY)

  568.                 ry = rx;

  569. 

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

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

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

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

  574.                                       rx, ry);

  575.         }

  576.         else

  577.         {

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

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

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

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

  582.         }

  583.     }

  584. 

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

  586.     {

  587.         auto cx = getCoordLength (xml, "cx", viewBoxW);

  588.         auto cy = getCoordLength (xml, "cy", viewBoxH);

  589.         auto radius = getCoordLength (xml, "r", viewBoxW);

  590. 

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

  592.     }

  593. 

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

  595.     {

  596.         auto cx      = getCoordLength (xml, "cx", viewBoxW);

  597.         auto cy      = getCoordLength (xml, "cy", viewBoxH);

  598.         auto radiusX = getCoordLength (xml, "rx", viewBoxW);

  599.         auto radiusY = getCoordLength (xml, "ry", viewBoxH);

  600. 

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

  602.     }

  603. 

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

  605.     {

  606.         auto x1 = getCoordLength (xml, "x1", viewBoxW);

  607.         auto y1 = getCoordLength (xml, "y1", viewBoxH);

  608.         auto x2 = getCoordLength (xml, "x2", viewBoxW);

  609.         auto y2 = getCoordLength (xml, "y2", viewBoxH);

  610. 

  611.         line.startNewSubPath (x1, y1);

  612.         line.lineTo (x2, y2);

  613.     }

  614. 

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

  616.     {

  617.         auto pointsAtt = xml->getStringAttribute ("points");

  618.         auto points = pointsAtt.getCharPointer();

  619.         Point<float> p;

  620. 

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

  622.         {

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

  624. 

  625.             path.startNewSubPath (first);

  626. 

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

  628.             {

  629.                 last = p;

  630.                 path.lineTo (p);

  631.             }

  632. 

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

  634.                 path.closeSubPath();

  635.         }

  636.     }

  637. 

  638.     static String getLinkedID (const XmlPath& xml)

  639.     {

  640.         auto link = xml->getStringAttribute ("xlink:href");

  641. 

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

  643.             return link.substring (1);

  644. 

  645.         return {};

  646.     }

  647. 

  648.     bool parseUsePath (const XmlPath& xml, Path& path) const

  649.     {

  650.         auto linkedID = getLinkedID (xml);

  651. 

  652.         if (linkedID.isNotEmpty())

  653.         {

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

  655.             return topLevelXml.applyOperationToChildWithID (linkedID, op);

  656.         }

  657. 

  658.         return false;

  659.     }

  660. 

  661.     Drawable* parseUseOther (const XmlPath& xml) const

  662.     {

  663.         if (auto* drawableText  = parseText (xml, false))    return drawableText;

  664.         if (auto* drawableImage = parseImage (xml, false))   return drawableImage;

  665. 

  666.         return nullptr;

  667.     }

  668. 

  669.     static String parseURL (const String& str)

  670.     {

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

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

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

  674. 

  675.         return {};

  676.     }

  677. 

  678.     //==============================================================================

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

  680.                           const bool shouldParseTransform = true,

  681.                           AffineTransform* additonalTransform = nullptr) const

  682.     {

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

  684.         {

  685.             SVGState newState (*this);

  686.             newState.addTransform (xml);

  687. 

  688.             return newState.parseShape (xml, path, false, additonalTransform);

  689.         }

  690. 

  691.         auto dp = new DrawablePath();

  692.         setCommonAttributes (*dp, xml);

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

  694. 

  695.         path.applyTransform (transform);

  696. 

  697.         if (additonalTransform != nullptr)

  698.             path.applyTransform (*additonalTransform);

  699. 

  700.         dp->setPath (path);

  701. 

  702.         dp->setFill (getPathFillType (path, xml, "fill",

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

  704.                                       getStyleAttribute (xml, "opacity"),

  705.                                       pathContainsClosedSubPath (path) ? Colours::black

  706.                                                                        : Colours::transparentBlack));

  707. 

  708.         auto strokeType = getStyleAttribute (xml, "stroke");

  709. 

  710.         if (strokeType.isNotEmpty() && ! isNone (strokeType))

  711.         {

  712.             dp->setStrokeFill (getPathFillType (path, xml, "stroke",

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

  714.                                                 getStyleAttribute (xml, "opacity"),

  715.                                                 Colours::transparentBlack));

  716. 

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

  718.         }

  719. 

  720.         auto strokeDashArray = getStyleAttribute (xml, "stroke-dasharray");

  721. 

  722.         if (strokeDashArray.isNotEmpty())

  723.             parseDashArray (strokeDashArray, *dp);

  724. 

  725.         return dp;

  726.     }

  727. 

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

  729.     {

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

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

  732.                 return true;

  733. 

  734.         return false;

  735.     }

  736. 

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

  738.     {

  739.         if (dashList.equalsIgnoreCase ("null") || isNone (dashList))

  740.             return;

  741. 

  742.         Array<float> dashLengths;

  743. 

  744.         for (auto t = dashList.getCharPointer();;)

  745.         {

  746.             float value;

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

  748.                 break;

  749. 

  750.             dashLengths.add (value);

  751. 

  752.             t = t.findEndOfWhitespace();

  753. 

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

  755.                 ++t;

  756.         }

  757. 

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

  759.         {

  760.             auto* dashes = dashLengths.getRawDataPointer();

  761. 

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

  763.             {

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

  765.                 {

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

  767.                         return;

  768. 

  769.                     const float nonZeroLength = 0.001f;

  770.                     dashes[i] = nonZeroLength;

  771. 

  772.                     const int pairedIndex = i ^ 1;

  773. 

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

  775.                           && dashes[pairedIndex] > nonZeroLength)

  776.                         dashes[pairedIndex] -= nonZeroLength;

  777.                 }

  778.             }

  779. 

  780.             dp.setDashLengths (dashLengths);

  781.         }

  782.     }

  783. 

  784.     bool parseClipPath (const XmlPath& xml, Drawable& d)

  785.     {

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

  787. 

  788.         if (clipPath.isNotEmpty())

  789.         {

  790.             auto urlID = parseURL (clipPath);

  791. 

  792.             if (urlID.isNotEmpty())

  793.             {

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

  795.                 return topLevelXml.applyOperationToChildWithID (urlID, op);

  796.             }

  797.         }

  798. 

  799.         return false;

  800.     }

  801. 

  802.     bool applyClipPath (Drawable& target, const XmlPath& xmlPath)

  803.     {

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

  805.         {

  806.             ScopedPointer<DrawableComposite> drawableClipPath (new DrawableComposite());

  807. 

  808.             parseSubElements (xmlPath, *drawableClipPath, false);

  809. 

  810.             if (drawableClipPath->getNumChildComponents() > 0)

  811.             {

  812.                 setCommonAttributes (*drawableClipPath, xmlPath);

  813.                 target.setClipPath (drawableClipPath.release());

  814.                 return true;

  815.             }

  816.         }

  817. 

  818.         return false;

  819.     }

  820. 

  821.     bool addGradientStopsIn (ColourGradient& cg, const XmlPath& fillXml) const

  822.     {

  823.         bool result = false;

  824. 

  825.         if (fillXml.xml != nullptr)

  826.         {

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

  828.             {

  829.                 auto col = parseColour (fillXml.getChild (e), "stop-color", Colours::black);

  830. 

  831.                 auto opacity = getStyleAttribute (fillXml.getChild (e), "stop-opacity", "1");

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

  833. 

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

  835. 

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

  837.                     offset *= 0.01;

  838. 

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

  840.                 result = true;

  841.             }

  842.         }

  843. 

  844.         return result;

  845.     }

  846. 

  847.     FillType getGradientFillType (const XmlPath& fillXml,

  848.                                   const Path& path,

  849.                                   const float opacity) const

  850.     {

  851.         ColourGradient gradient;

  852. 

  853.         {

  854.             auto linkedID = getLinkedID (fillXml);

  855. 

  856.             if (linkedID.isNotEmpty())

  857.             {

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

  859.                 topLevelXml.applyOperationToChildWithID (linkedID, op);

  860.             }

  861.         }

  862. 

  863.         addGradientStopsIn (gradient, fillXml);

  864. 

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

  866.         {

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

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

  869. 

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

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

  872.         }

  873.         else

  874.         {

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

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

  877.         }

  878. 

  879.         if (opacity < 1.0f)

  880.             gradient.multiplyOpacity (opacity);

  881. 

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

  883. 

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

  885. 

  886.         float gradientWidth = viewBoxW;

  887.         float gradientHeight = viewBoxH;

  888.         float dx = 0.0f;

  889.         float dy = 0.0f;

  890. 

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

  892. 

  893.         if (! userSpace)

  894.         {

  895.             auto bounds = path.getBounds();

  896.             dx = bounds.getX();

  897.             dy = bounds.getY();

  898.             gradientWidth = bounds.getWidth();

  899.             gradientHeight = bounds.getHeight();

  900.         }

  901. 

  902.         if (gradient.isRadial)

  903.         {

  904.             if (userSpace)

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

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

  907.             else

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

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

  910. 

  911.             auto radius = getCoordLength (fillXml->getStringAttribute ("r", "50%"), gradientWidth);

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

  913. 

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

  915.         }

  916.         else

  917.         {

  918.             if (userSpace)

  919.             {

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

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

  922. 

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

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

  925.             }

  926.             else

  927.             {

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

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

  930. 

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

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

  933.             }

  934. 

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

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

  937.         }

  938. 

  939.         FillType type (gradient);

  940. 

  941.         auto gradientTransform = parseTransform (fillXml->getStringAttribute ("gradientTransform"))

  942.                                    .followedBy (transform);

  943. 

  944.         if (gradient.isRadial)

  945.         {

  946.             type.transform = gradientTransform;

  947.         }

  948.         else

  949.         {

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

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

  952.             auto perpendicular = Point<float> (gradient.point2.y - gradient.point1.y,

  953.                                                gradient.point1.x - gradient.point2.x)

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

  955. 

  956.             auto newGradPoint1 = gradient.point1.transformedBy (gradientTransform);

  957.             auto newGradPoint2 = gradient.point2.transformedBy (gradientTransform);

  958. 

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

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

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

  962.                                   / perpendicular.getDotProduct (perpendicular);

  963. 

  964.             type.gradient->point1 = newGradPoint1;

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

  966.         }

  967. 

  968.         return type;

  969.     }

  970. 

  971.     FillType getPathFillType (const Path& path,

  972.                               const XmlPath& xml,

  973.                               StringRef fillAttribute,

  974.                               const String& fillOpacity,

  975.                               const String& overallOpacity,

  976.                               const Colour defaultColour) const

  977.     {

  978.         float opacity = 1.0f;

  979. 

  980.         if (overallOpacity.isNotEmpty())

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

  982. 

  983.         if (fillOpacity.isNotEmpty())

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

  985. 

  986.         String fill (getStyleAttribute (xml, fillAttribute));

  987.         String urlID = parseURL (fill);

  988. 

  989.         if (urlID.isNotEmpty())

  990.         {

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

  992. 

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

  994.                 return op.fillType;

  995.         }

  996. 

  997.         if (isNone (fill))

  998.             return Colours::transparentBlack;

  999. 

  1000.         return parseColour (xml, fillAttribute, defaultColour).withMultipliedAlpha (opacity);

  1001.     }

  1002. 

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

  1004.     {

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

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

  1007. 

  1008.         return PathStrokeType::mitered;

  1009.     }

  1010. 

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

  1012.     {

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

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

  1015. 

  1016.         return PathStrokeType::butt;

  1017.     }

  1018. 

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

  1020.     {

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

  1022.     }

  1023. 

  1024.     PathStrokeType getStrokeFor (const XmlPath& xml) const

  1025.     {

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

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

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

  1029.     }

  1030. 

  1031.     //==============================================================================

  1032. 

  1033.     Drawable* useText (const XmlPath& xml) const

  1034.     {

  1035.         auto translation = AffineTransform::translation ((float) xml->getDoubleAttribute ("x", 0.0),

  1036.                                                          (float) xml->getDoubleAttribute ("y", 0.0));

  1037. 

  1038.         UseTextOp op = { this, &translation, nullptr };

  1039. 

  1040.         auto linkedID = getLinkedID (xml);

  1041. 

  1042.         if (linkedID.isNotEmpty())

  1043.             topLevelXml.applyOperationToChildWithID (linkedID, op);

  1044. 

  1045.         return op.target;

  1046.     }

  1047. 

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

  1049.                          AffineTransform* additonalTransform = nullptr) const

  1050.     {

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

  1052.         {

  1053.             SVGState newState (*this);

  1054.             newState.addTransform (xml);

  1055. 

  1056.             return newState.parseText (xml, false, additonalTransform);

  1057.         }

  1058. 

  1059.         if (xml->hasTagName ("use"))

  1060.             return useText (xml);

  1061. 

  1062.         if (! xml->hasTagName ("text"))

  1063.             return nullptr;

  1064. 

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

  1066. 

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

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

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

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

  1071. 

  1072.         auto font = getFont (xml);

  1073.         auto anchorStr = getStyleAttribute (xml, "text-anchor");

  1074. 

  1075.         auto dc = new DrawableComposite();

  1076.         setCommonAttributes (*dc, xml);

  1077. 

  1078.         forEachXmlChildElement (*xml, e)

  1079.         {

  1080.             if (e->isTextElement())

  1081.             {

  1082.                 auto text = e->getText().trim();

  1083. 

  1084.                 auto dt = new DrawableText();

  1085.                 dc->addAndMakeVisible (dt);

  1086. 

  1087.                 dt->setText (text);

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

  1089. 

  1090.                 if (additonalTransform != nullptr)

  1091.                     dt->setTransform (transform.followedBy (*additonalTransform));

  1092.                 else

  1093.                     dt->setTransform (transform);

  1094. 

  1095.                 dt->setColour (parseColour (xml, "fill", Colours::black)

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

  1097. 

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

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

  1100. 

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

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

  1103. 

  1104.                 dt->setBoundingBox (bounds);

  1105.             }

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

  1107.             {

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

  1109.             }

  1110.         }

  1111. 

  1112.         return dc;

  1113.     }

  1114. 

  1115.     Font getFont (const XmlPath& xml) const

  1116.     {

  1117.         Font f;

  1118.         auto family = getStyleAttribute (xml, "font-family").unquoted();

  1119. 

  1120.         if (family.isNotEmpty())

  1121.             f.setTypefaceName (family);

  1122. 

  1123.         if (getStyleAttribute (xml, "font-style").containsIgnoreCase ("italic"))

  1124.             f.setItalic (true);

  1125. 

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

  1127.             f.setBold (true);

  1128. 

  1129.         return f.withPointHeight (getCoordLength (getStyleAttribute (xml, "font-size", "15"), 1.0f));

  1130.     }

  1131. 

  1132.     //==============================================================================

  1133.     Drawable* useImage (const XmlPath& xml) const

  1134.     {

  1135.         auto translation = AffineTransform::translation ((float) xml->getDoubleAttribute ("x", 0.0),

  1136.                                                          (float) xml->getDoubleAttribute ("y", 0.0));

  1137. 

  1138.         UseImageOp op = { this, &translation, nullptr };

  1139. 

  1140.         auto linkedID = getLinkedID (xml);

  1141. 

  1142.         if (linkedID.isNotEmpty())

  1143.             topLevelXml.applyOperationToChildWithID (linkedID, op);

  1144. 

  1145.         return op.target;

  1146.     }

  1147. 

  1148.     Drawable* parseImage (const XmlPath& xml, bool shouldParseTransform,

  1149.                           AffineTransform* additionalTransform = nullptr) const

  1150.     {

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

  1152.         {

  1153.             SVGState newState (*this);

  1154.             newState.addTransform (xml);

  1155. 

  1156.             return newState.parseImage (xml, false, additionalTransform);

  1157.         }

  1158. 

  1159.         if (xml->hasTagName ("use"))

  1160.             return useImage (xml);

  1161. 

  1162.         if (! xml->hasTagName ("image"))

  1163.             return nullptr;

  1164. 

  1165.         auto link = xml->getStringAttribute ("xlink:href");

  1166. 

  1167.         ScopedPointer<InputStream> inputStream;

  1168.         MemoryOutputStream imageStream;

  1169. 

  1170.         if (link.startsWith ("data:"))

  1171.         {

  1172.             const auto indexOfComma = link.indexOf (",");

  1173.             auto format = link.substring (5, indexOfComma).trim();

  1174. 

  1175.             const auto indexOfSemi = format.indexOf (";");

  1176. 

  1177.             if (format.substring (indexOfSemi + 1).trim().equalsIgnoreCase ("base64"))

  1178.             {

  1179.                 auto mime = format.substring (0, indexOfSemi).trim();

  1180. 

  1181.                 if (mime.equalsIgnoreCase ("image/png") || mime.equalsIgnoreCase ("image/jpeg"))

  1182.                 {

  1183.                     const String base64text = link.substring (indexOfComma + 1).removeCharacters ("\t\n\r ");

  1184. 

  1185.                     if (Base64::convertFromBase64 (imageStream, base64text))

  1186.                         inputStream = new MemoryInputStream (imageStream.getData(), imageStream.getDataSize(), false);

  1187.                 }

  1188.             }

  1189.         }

  1190.         else

  1191.         {

  1192.             auto linkedFile = originalFile.getParentDirectory().getChildFile (link);

  1193. 

  1194.             if (linkedFile.existsAsFile())

  1195.                 inputStream = linkedFile.createInputStream();

  1196.         }

  1197. 

  1198.         if (inputStream != nullptr)

  1199.         {

  1200.             auto image = ImageFileFormat::loadFrom (*inputStream);

  1201. 

  1202.             if (image.isValid())

  1203.             {

  1204.                 auto* di = new DrawableImage();

  1205. 

  1206.                 setCommonAttributes (*di, xml);

  1207.                 di->setImage (image);

  1208. 

  1209.                 if (additionalTransform != nullptr)

  1210.                     di->setTransform (transform.followedBy (*additionalTransform));

  1211.                 else

  1212.                     di->setTransform (transform);

  1213. 

  1214.                 return di;

  1215.             }

  1216.         }

  1217. 

  1218.         return nullptr;

  1219.     }

  1220. 

  1221.     //==============================================================================

  1222.     void addTransform (const XmlPath& xml)

  1223.     {

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

  1225.                         .followedBy (transform);

  1226.     }

  1227. 

  1228.     //==============================================================================

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

  1230.     {

  1231.         String number;

  1232. 

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

  1234.         {

  1235.             value = 0;

  1236.             return false;

  1237.         }

  1238. 

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

  1240.         return true;

  1241.     }

  1242. 

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

  1244.     {

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

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

  1247.     }

  1248. 

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

  1250.     {

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

  1252.             return true;

  1253. 

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

  1255.         return false;

  1256.     }

  1257. 

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

  1259.     {

  1260.         float n = s.getFloatValue();

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

  1262. 

  1263.         if (len > 2)

  1264.         {

  1265.             const float dpi = 96.0f;

  1266. 

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

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

  1269. 

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

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

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

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

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

  1275.         }

  1276. 

  1277.         return n;

  1278.     }

  1279. 

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

  1281.     {

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

  1283.     }

  1284. 

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

  1286.     {

  1287.         auto text = list.getCharPointer();

  1288.         float value;

  1289. 

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

  1291.             coords.add (value);

  1292.     }

  1293. 

  1294.     //==============================================================================

  1295.     void parseCSSStyle (const XmlPath& xml)

  1296.     {

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

  1298.     }

  1299. 

  1300.     void parseDefs (const XmlPath& xml)

  1301.     {

  1302.         if (auto* style = xml->getChildByName ("style"))

  1303.             parseCSSStyle (xml.getChild (style));

  1304.     }

  1305. 

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

  1307.     {

  1308.         auto nameLength = (int) name.length();

  1309. 

  1310.         while (! source.isEmpty())

  1311.         {

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

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

  1314.             {

  1315.                 auto endOfName = (source + nameLength).findEndOfWhitespace();

  1316. 

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

  1318.                     return endOfName;

  1319. 

  1320.                 if (*endOfName == ',')

  1321.                     return CharacterFunctions::find (endOfName, (juce_wchar) '{');

  1322.             }

  1323.         }

  1324. 

  1325.         return source;

  1326.     }

  1327. 

  1328.     String getStyleAttribute (const XmlPath& xml, StringRef attributeName, const String& defaultValue = String()) const

  1329.     {

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

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

  1332. 

  1333.         auto styleAtt = xml->getStringAttribute ("style");

  1334. 

  1335.         if (styleAtt.isNotEmpty())

  1336.         {

  1337.             auto value = getAttributeFromStyleList (styleAtt, attributeName, {});

  1338. 

  1339.             if (value.isNotEmpty())

  1340.                 return value;

  1341.         }

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

  1343.         {

  1344.             for (auto i = cssStyleText.getCharPointer();;)

  1345.             {

  1346.                 auto openBrace = findStyleItem (i, xml->getStringAttribute ("class").getCharPointer());

  1347. 

  1348.                 if (openBrace.isEmpty())

  1349.                     break;

  1350. 

  1351.                 auto closeBrace = CharacterFunctions::find (openBrace, (juce_wchar) '}');

  1352. 

  1353.                 if (closeBrace.isEmpty())

  1354.                     break;

  1355. 

  1356.                 auto value = getAttributeFromStyleList (String (openBrace + 1, closeBrace),

  1357.                                                         attributeName, defaultValue);

  1358.                 if (value.isNotEmpty())

  1359.                     return value;

  1360. 

  1361.                 i = closeBrace + 1;

  1362.             }

  1363.         }

  1364. 

  1365.         if (xml.parent != nullptr)

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

  1367. 

  1368.         return defaultValue;

  1369.     }

  1370. 

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

  1372.     {

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

  1374.             return xml->getStringAttribute (attributeName);

  1375. 

  1376.         if (xml.parent != nullptr)

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

  1378. 

  1379.         return {};

  1380.     }

  1381. 

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

  1383.     {

  1384.         if (align.isEmpty())

  1385.             return 0;

  1386. 

  1387.         if (isNone (align))

  1388.             return RectanglePlacement::stretchToFit;

  1389. 

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

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

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

  1393.                                                                                         : RectanglePlacement::xMid))

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

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

  1396.                                                                                         : RectanglePlacement::yMid));

  1397.     }

  1398. 

  1399.     //==============================================================================

  1400.     static bool isIdentifierChar (const juce_wchar c)

  1401.     {

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

  1403.     }

  1404. 

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

  1406.     {

  1407.         int i = 0;

  1408. 

  1409.         for (;;)

  1410.         {

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

  1412. 

  1413.             if (i < 0)

  1414.                 break;

  1415. 

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

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

  1418.             {

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

  1420. 

  1421.                 if (i < 0)

  1422.                     break;

  1423. 

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

  1425. 

  1426.                 if (end < 0)

  1427.                     end = 0x7ffff;

  1428. 

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

  1430.             }

  1431. 

  1432.             ++i;

  1433.         }

  1434. 

  1435.         return defaultValue;

  1436.     }

  1437. 

  1438.     //==============================================================================

  1439.     static bool isStartOfNumber (juce_wchar c) noexcept

  1440.     {

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

  1442.     }

  1443. 

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

  1445.     {

  1446.         String::CharPointerType s (text);

  1447. 

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

  1449.             ++s;

  1450. 

  1451.         auto start = s;

  1452. 

  1453.         if (isStartOfNumber (*s))

  1454.             ++s;

  1455. 

  1456.         while (s.isDigit())

  1457.             ++s;

  1458. 

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

  1460.         {

  1461.             ++s;

  1462. 

  1463.             while (s.isDigit())

  1464.                 ++s;

  1465.         }

  1466. 

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

  1468.         {

  1469.             s += 2;

  1470. 

  1471.             while (s.isDigit())

  1472.                 ++s;

  1473.         }

  1474. 

  1475.         if (allowUnits)

  1476.             while (s.isLetter())

  1477.                 ++s;

  1478. 

  1479.         if (s == start)

  1480.         {

  1481.             text = s;

  1482.             return false;

  1483.         }

  1484. 

  1485.         value = String (start, s);

  1486. 

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

  1488.             ++s;

  1489. 

  1490.         text = s;

  1491.         return true;

  1492.     }

  1493. 

  1494.     //==============================================================================

  1495.     Colour parseColour (const XmlPath& xml, StringRef attributeName, const Colour defaultColour) const

  1496.     {

  1497.         auto text = getStyleAttribute (xml, attributeName);

  1498. 

  1499.         if (text.startsWithChar ('#'))

  1500.         {

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

  1502.             int numChars = 0;

  1503.             auto s = text.getCharPointer();

  1504. 

  1505.             while (numChars < 6)

  1506.             {

  1507.                 auto hexValue = CharacterFunctions::getHexDigitValue (*++s);

  1508. 

  1509.                 if (hexValue >= 0)

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

  1511.                 else

  1512.                     break;

  1513.             }

  1514. 

  1515.             if (numChars <= 3)

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

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

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

  1519. 

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

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

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

  1523.         }

  1524. 

  1525.         if (text.startsWith ("rgb"))

  1526.         {

  1527.             auto openBracket = text.indexOfChar ('(');

  1528.             auto closeBracket = text.indexOfChar (openBracket, ')');

  1529. 

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

  1531.             {

  1532.                 StringArray tokens;

  1533.                 tokens.addTokens (text.substring (openBracket + 1, closeBracket), ",", "");

  1534.                 tokens.trim();

  1535.                 tokens.removeEmptyStrings();

  1536. 

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

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

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

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

  1541. 

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

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

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

  1545.             }

  1546.         }

  1547. 

  1548.         if (text == "inherit")

  1549.         {

  1550.             for (const XmlPath* p = xml.parent; p != nullptr; p = p->parent)

  1551.                 if (getStyleAttribute (*p, attributeName).isNotEmpty())

  1552.                     return parseColour (*p, attributeName, defaultColour);

  1553.         }

  1554. 

  1555.         return Colours::findColourForName (text, defaultColour);

  1556.     }

  1557. 

  1558.     static AffineTransform parseTransform (String t)

  1559.     {

  1560.         AffineTransform result;

  1561. 

  1562.         while (t.isNotEmpty())

  1563.         {

  1564.             StringArray tokens;

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

  1566.                                .upToFirstOccurrenceOf (")", false, false),

  1567.                               ", ", "");

  1568. 

  1569.             tokens.removeEmptyStrings (true);

  1570. 

  1571.             float numbers[6];

  1572. 

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

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

  1575. 

  1576.             AffineTransform trans;

  1577. 

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

  1579.             {

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

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

  1582.             }

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

  1584.             {

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

  1586.             }

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

  1588.             {

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

  1590.             }

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

  1592.             {

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

  1594.             }

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

  1596.             {

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

  1598.             }

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

  1600.             {

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

  1602.             }

  1603. 

  1604.             result = trans.followedBy (result);

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

  1606.         }

  1607. 

  1608.         return result;

  1609.     }

  1610. 

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

  1612.                                             const double x2, const double y2,

  1613.                                             const double angle,

  1614.                                             const bool largeArc, const bool sweep,

  1615.                                             double& rx, double& ry,

  1616.                                             double& centreX, double& centreY,

  1617.                                             double& startAngle, double& deltaAngle) noexcept

  1618.     {

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

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

  1621. 

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

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

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

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

  1626.         const double xp2 = xp * xp;

  1627.         const double yp2 = yp * yp;

  1628. 

  1629.         double rx2 = rx * rx;

  1630.         double ry2 = ry * ry;

  1631. 

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

  1633.         double c;

  1634. 

  1635.         if (s <= 1.0)

  1636.         {

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

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

  1639. 

  1640.             if (largeArc == sweep)

  1641.                 c = -c;

  1642.         }

  1643.         else

  1644.         {

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

  1646.             rx *= s2;

  1647.             ry *= s2;

  1648.             c = 0;

  1649.         }

  1650. 

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

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

  1653. 

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

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

  1656. 

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

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

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

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

  1661. 

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

  1663. 

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

  1665. 

  1666.         if (uy < 0)

  1667.             startAngle = -startAngle;

  1668. 

  1669.         startAngle += double_Pi * 0.5;

  1670. 

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

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

  1673. 

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

  1675.             deltaAngle = -deltaAngle;

  1676. 

  1677.         if (sweep)

  1678.         {

  1679.             if (deltaAngle < 0)

  1680.                 deltaAngle += double_Pi * 2.0;

  1681.         }

  1682.         else

  1683.         {

  1684.             if (deltaAngle > 0)

  1685.                 deltaAngle -= double_Pi * 2.0;

  1686.         }

  1687. 

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

  1689.     }

  1690. 

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

  1692. };

  1693. 

  1694. 

  1695. //==============================================================================

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

  1697. {

  1698.     if (! svgDocument.hasTagNameIgnoringNamespace ("svg"))

  1699.         return nullptr;

  1700. 

  1701.     SVGState state (&svgDocument);

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

  1703. }

  1704. 

  1705. Drawable* Drawable::createFromSVGFile (const File& svgFile)

  1706. {

  1707.     XmlDocument doc (svgFile);

  1708.     ScopedPointer<XmlElement> outer (doc.getDocumentElement (true));

  1709. 

  1710.     if (outer != nullptr && outer->hasTagName ("svg"))

  1711.     {

  1712.         ScopedPointer<XmlElement> svgDocument (doc.getDocumentElement());

  1713. 

  1714.         if (svgDocument != nullptr)

  1715.         {

  1716.             SVGState state (svgDocument, svgFile);

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

  1718.         }

  1719.     }

  1720. 

  1721.     return nullptr;

  1722. }

  1723. 

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

  1725. {

  1726.     SVGState state (nullptr);

  1727.     Path p;

  1728.     state.parsePathString (p, svgPath);

  1729.     return p;

  1730. }