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

1775 lines
59KB
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 UseShapeOp

  79.     {

  80.         const SVGState* state;

  81.         Path* sourcePath;

  82.         AffineTransform* transform;

  83.         Drawable* target;

  84. 

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

  86.         {

  87.             target = state->parseShape (xmlPath, *sourcePath, true, transform);

  88.             return target != nullptr;

  89.         }

  90.     };

  91. 

  92.     struct UseTextOp

  93.     {

  94.         const SVGState* state;

  95.         AffineTransform* transform;

  96.         Drawable* target;

  97. 

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

  99.         {

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

  101.             return target != nullptr;

  102.         }

  103.     };

  104. 

  105.     struct UseImageOp

  106.     {

  107.         const SVGState* state;

  108.         AffineTransform* transform;

  109.         Drawable* target;

  110. 

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

  112.         {

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

  114.             return target != nullptr;

  115.         }

  116.     };

  117. 

  118.     struct GetClipPathOp

  119.     {

  120.         SVGState* state;

  121.         Drawable* target;

  122. 

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

  124.         {

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

  126.         }

  127.     };

  128. 

  129.     struct SetGradientStopsOp

  130.     {

  131.         const SVGState* state;

  132.         ColourGradient* gradient;

  133. 

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

  135.         {

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

  137.         }

  138.     };

  139. 

  140.     struct GetFillTypeOp

  141.     {

  142.         const SVGState* state;

  143.         const Path* path;

  144.         float opacity;

  145.         FillType fillType;

  146. 

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

  148.         {

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

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

  151.             {

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

  153.                 return true;

  154.             }

  155. 

  156.             return false;

  157.         }

  158.     };

  159. 

  160.     //==============================================================================

  161.     Drawable* parseSVGElement (const XmlPath& xml)

  162.     {

  163.         auto drawable = new DrawableComposite();

  164.         setCommonAttributes (*drawable, xml);

  165. 

  166.         SVGState newState (*this);

  167. 

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

  169.             newState.addTransform (xml);

  170. 

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

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

  173. 

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

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

  176. 

  177.         Point<float> viewboxXY;

  178. 

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

  180.         {

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

  182.             auto viewParams = viewBoxAtt.getCharPointer();

  183.             Point<float> vwh;

  184. 

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

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

  187.                  && vwh.x > 0

  188.                  && vwh.y > 0)

  189.             {

  190.                 newState.viewBoxW = vwh.x;

  191.                 newState.viewBoxH = vwh.y;

  192. 

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

  194. 

  195.                 if (placementFlags != 0)

  196.                     newState.transform = RectanglePlacement (placementFlags)

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

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

  199.                                             .followedBy (newState.transform);

  200.             }

  201.         }

  202.         else

  203.         {

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

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

  206.         }

  207. 

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

  209. 

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

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

  212.                                                      RelativeCoordinate (viewboxXY.y),

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

  214.         drawable->resetBoundingBoxToContentArea();

  215. 

  216.         return drawable;

  217.     }

  218. 

  219.     //==============================================================================

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

  221.     {

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

  223. 

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

  225.         juce_wchar currentCommand = 0, previousCommand = 0;

  226.         bool isRelative = true;

  227.         bool carryOn = true;

  228. 

  229.         while (! d.isEmpty())

  230.         {

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

  232.             {

  233.                 currentCommand = d.getAndAdvance();

  234.                 isRelative = currentCommand >= 'a';

  235.             }

  236. 

  237.             switch (currentCommand)

  238.             {

  239.             case 'M':

  240.             case 'm':

  241.             case 'L':

  242.             case 'l':

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

  244.                 {

  245.                     if (isRelative)

  246.                         p1 += last;

  247. 

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

  249.                     {

  250.                         subpathStart = p1;

  251.                         path.startNewSubPath (p1);

  252.                         currentCommand = 'l';

  253.                     }

  254.                     else

  255.                         path.lineTo (p1);

  256. 

  257.                     last2 = last;

  258.                     last = p1;

  259.                 }

  260.                 break;

  261. 

  262.             case 'H':

  263.             case 'h':

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

  265.                 {

  266.                     if (isRelative)

  267.                         p1.x += last.x;

  268. 

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

  270. 

  271.                     last2.x = last.x;

  272.                     last.x = p1.x;

  273.                 }

  274.                 else

  275.                 {

  276.                     ++d;

  277.                 }

  278.                 break;

  279. 

  280.             case 'V':

  281.             case 'v':

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

  283.                 {

  284.                     if (isRelative)

  285.                         p1.y += last.y;

  286. 

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

  288. 

  289.                     last2.y = last.y;

  290.                     last.y = p1.y;

  291.                 }

  292.                 else

  293.                 {

  294.                     ++d;

  295.                 }

  296.                 break;

  297. 

  298.             case 'C':

  299.             case 'c':

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

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

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

  303.                 {

  304.                     if (isRelative)

  305.                     {

  306.                         p1 += last;

  307.                         p2 += last;

  308.                         p3 += last;

  309.                     }

  310. 

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

  312. 

  313.                     last2 = p2;

  314.                     last = p3;

  315.                 }

  316.                 break;

  317. 

  318.             case 'S':

  319.             case 's':

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

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

  322.                 {

  323.                     if (isRelative)

  324.                     {

  325.                         p1 += last;

  326.                         p3 += last;

  327.                     }

  328. 

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

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

  331. 

  332.                     last2 = p1;

  333.                     last = p3;

  334.                 }

  335.                 break;

  336. 

  337.             case 'Q':

  338.             case 'q':

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

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

  341.                 {

  342.                     if (isRelative)

  343.                     {

  344.                         p1 += last;

  345.                         p2 += last;

  346.                     }

  347. 

  348.                     path.quadraticTo (p1, p2);

  349. 

  350.                     last2 = p1;

  351.                     last = p2;

  352.                 }

  353.                 break;

  354. 

  355.             case 'T':

  356.             case 't':

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

  358.                 {

  359.                     if (isRelative)

  360.                         p1 += last;

  361. 

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

  363.                                                                                    : p1;

  364.                     path.quadraticTo (p2, p1);

  365. 

  366.                     last2 = p2;

  367.                     last = p1;

  368.                 }

  369.                 break;

  370. 

  371.             case 'A':

  372.             case 'a':

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

  374.                 {

  375.                     String num;

  376. 

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

  378.                     {

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

  380. 

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

  382.                         {

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

  384. 

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

  386.                             {

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

  388. 

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

  390.                                 {

  391.                                     if (isRelative)

  392.                                         p2 += last;

  393. 

  394.                                     if (last != p2)

  395.                                     {

  396.                                         double centreX, centreY, startAngle, deltaAngle;

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

  398. 

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

  400.                                                                     angle, largeArc, sweep,

  401.                                                                     rx, ry, centreX, centreY,

  402.                                                                     startAngle, deltaAngle);

  403. 

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

  405.                                                             (float) rx, (float) ry,

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

  407.                                                             false);

  408. 

  409.                                         path.lineTo (p2);

  410.                                     }

  411. 

  412.                                     last2 = last;

  413.                                     last = p2;

  414.                                 }

  415.                             }

  416.                         }

  417.                     }

  418.                 }

  419. 

  420.                 break;

  421. 

  422.             case 'Z':

  423.             case 'z':

  424.                 path.closeSubPath();

  425.                 last = last2 = subpathStart;

  426.                 d = d.findEndOfWhitespace();

  427.                 currentCommand = 'M';

  428.                 break;

  429. 

  430.             default:

  431.                 carryOn = false;

  432.                 break;

  433.             }

  434. 

  435.             if (! carryOn)

  436.                 break;

  437. 

  438.             previousCommand = currentCommand;

  439.         }

  440. 

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

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

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

  444.             path.closeSubPath();

  445.     }

  446. 

  447. private:

  448.     //==============================================================================

  449.     const File originalFile;

  450.     const XmlPath topLevelXml;

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

  452.     AffineTransform transform;

  453.     String cssStyleText;

  454. 

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

  456.     {

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

  458.     }

  459. 

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

  461.     {

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

  463.         d.setName (compID);

  464.         d.setComponentID (compID);

  465. 

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

  467.             d.setVisible (false);

  468.     }

  469. 

  470.     //==============================================================================

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

  472.     {

  473.         forEachXmlChildElement (*xml, e)

  474.         {

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

  476. 

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

  478.             {

  479.                 parentDrawable.addChildComponent (drawable);

  480. 

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

  482.                     drawable->setVisible (true);

  483. 

  484.                 if (shouldParseClip)

  485.                     parseClipPath (child, *drawable);

  486.             }

  487.         }

  488.     }

  489. 

  490.     Drawable* parseSubElement (const XmlPath& xml)

  491.     {

  492.         {

  493.             Path path;

  494.             if (parsePathElement (xml, path))

  495.                 return parseShape (xml, path);

  496.         }

  497. 

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

  499. 

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

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

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

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

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

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

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

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

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

  509. 

  510.         return nullptr;

  511.     }

  512. 

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

  514.     {

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

  516. 

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

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

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

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

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

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

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

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

  525. 

  526.         return false;

  527.     }

  528. 

  529.     DrawableComposite* parseSwitch (const XmlPath& xml)

  530.     {

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

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

  533. 

  534.         return nullptr;

  535.     }

  536. 

  537.     DrawableComposite* parseGroupElement (const XmlPath& xml, bool shouldParseTransform = true)

  538.     {

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

  540.         {

  541.             SVGState newState (*this);

  542.             newState.addTransform (xml);

  543. 

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

  545.         }

  546. 

  547.         auto* drawable = new DrawableComposite();

  548. 

  549.         setCommonAttributes (*drawable, xml);

  550. 

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

  552.         {

  553.             SVGState newState (*this);

  554.             newState.addTransform (xml);

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

  556.         }

  557.         else

  558.         {

  559.             parseSubElements (xml, *drawable);

  560.         }

  561. 

  562.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  563.         return drawable;

  564.     }

  565. 

  566.     DrawableComposite* parseLinkElement (const XmlPath& xml)

  567.     {

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

  569.     }

  570. 

  571.     //==============================================================================

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

  573.     {

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

  575. 

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

  577.             path.setUsingNonZeroWinding (false);

  578.     }

  579. 

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

  581.     {

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

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

  584. 

  585.         if (hasRX || hasRY)

  586.         {

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

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

  589. 

  590.             if (! hasRX)

  591.                 rx = ry;

  592.             else if (! hasRY)

  593.                 ry = rx;

  594. 

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

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

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

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

  599.                                       rx, ry);

  600.         }

  601.         else

  602.         {

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

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

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

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

  607.         }

  608.     }

  609. 

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

  611.     {

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

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

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

  615. 

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

  617.     }

  618. 

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

  620.     {

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

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

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

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

  625. 

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

  627.     }

  628. 

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

  630.     {

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

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

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

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

  635. 

  636.         line.startNewSubPath (x1, y1);

  637.         line.lineTo (x2, y2);

  638.     }

  639. 

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

  641.     {

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

  643.         auto points = pointsAtt.getCharPointer();

  644.         Point<float> p;

  645. 

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

  647.         {

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

  649. 

  650.             path.startNewSubPath (first);

  651. 

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

  653.             {

  654.                 last = p;

  655.                 path.lineTo (p);

  656.             }

  657. 

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

  659.                 path.closeSubPath();

  660.         }

  661.     }

  662. 

  663.     static String getLinkedID (const XmlPath& xml)

  664.     {

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

  666. 

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

  668.             return link.substring (1);

  669. 

  670.         return {};

  671.     }

  672. 

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

  674.     {

  675.         auto linkedID = getLinkedID (xml);

  676. 

  677.         if (linkedID.isNotEmpty())

  678.         {

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

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

  681.         }

  682. 

  683.         return false;

  684.     }

  685. 

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

  687.     {

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

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

  690. 

  691.         return nullptr;

  692.     }

  693. 

  694.     static String parseURL (const String& str)

  695.     {

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

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

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

  699. 

  700.         return {};

  701.     }

  702. 

  703.     //==============================================================================

  704. 

  705.     Drawable* useShape (const XmlPath& xml, Path& path) const

  706.     {

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

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

  709. 

  710.         UseShapeOp op = { this, &path, &translation, nullptr };

  711. 

  712.         auto linkedID = getLinkedID (xml);

  713. 

  714.         if (linkedID.isNotEmpty())

  715.             topLevelXml.applyOperationToChildWithID (linkedID, op);

  716. 

  717.         return op.target;

  718.     }

  719. 

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

  721.                           const bool shouldParseTransform = true,

  722.                           AffineTransform* additonalTransform = nullptr) const

  723.     {

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

  725.         {

  726.             SVGState newState (*this);

  727.             newState.addTransform (xml);

  728. 

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

  730.         }

  731. 

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

  733.             return useShape (xml, path);

  734. 

  735.         auto dp = new DrawablePath();

  736.         setCommonAttributes (*dp, xml);

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

  738. 

  739.         path.applyTransform (transform);

  740. 

  741.         if (additonalTransform != nullptr)

  742.             path.applyTransform (*additonalTransform);

  743. 

  744.         dp->setPath (path);

  745. 

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

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

  748.                                       getStyleAttribute (xml, "opacity"),

  749.                                       pathContainsClosedSubPath (path) ? Colours::black

  750.                                                                        : Colours::transparentBlack));

  751. 

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

  753. 

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

  755.         {

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

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

  758.                                                 getStyleAttribute (xml, "opacity"),

  759.                                                 Colours::transparentBlack));

  760. 

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

  762.         }

  763. 

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

  765. 

  766.         if (strokeDashArray.isNotEmpty())

  767.             parseDashArray (strokeDashArray, *dp);

  768. 

  769.         return dp;

  770.     }

  771. 

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

  773.     {

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

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

  776.                 return true;

  777. 

  778.         return false;

  779.     }

  780. 

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

  782.     {

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

  784.             return;

  785. 

  786.         Array<float> dashLengths;

  787. 

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

  789.         {

  790.             float value;

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

  792.                 break;

  793. 

  794.             dashLengths.add (value);

  795. 

  796.             t = t.findEndOfWhitespace();

  797. 

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

  799.                 ++t;

  800.         }

  801. 

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

  803.         {

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

  805. 

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

  807.             {

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

  809.                 {

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

  811.                         return;

  812. 

  813.                     const float nonZeroLength = 0.001f;

  814.                     dashes[i] = nonZeroLength;

  815. 

  816.                     const int pairedIndex = i ^ 1;

  817. 

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

  819.                           && dashes[pairedIndex] > nonZeroLength)

  820.                         dashes[pairedIndex] -= nonZeroLength;

  821.                 }

  822.             }

  823. 

  824.             dp.setDashLengths (dashLengths);

  825.         }

  826.     }

  827. 

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

  829.     {

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

  831. 

  832.         if (clipPath.isNotEmpty())

  833.         {

  834.             auto urlID = parseURL (clipPath);

  835. 

  836.             if (urlID.isNotEmpty())

  837.             {

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

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

  840.             }

  841.         }

  842. 

  843.         return false;

  844.     }

  845. 

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

  847.     {

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

  849.         {

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

  851. 

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

  853. 

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

  855.             {

  856.                 setCommonAttributes (*drawableClipPath, xmlPath);

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

  858.                 return true;

  859.             }

  860.         }

  861. 

  862.         return false;

  863.     }

  864. 

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

  866.     {

  867.         bool result = false;

  868. 

  869.         if (fillXml.xml != nullptr)

  870.         {

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

  872.             {

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

  874. 

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

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

  877. 

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

  879. 

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

  881.                     offset *= 0.01;

  882. 

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

  884.                 result = true;

  885.             }

  886.         }

  887. 

  888.         return result;

  889.     }

  890. 

  891.     FillType getGradientFillType (const XmlPath& fillXml,

  892.                                   const Path& path,

  893.                                   const float opacity) const

  894.     {

  895.         ColourGradient gradient;

  896. 

  897.         {

  898.             auto linkedID = getLinkedID (fillXml);

  899. 

  900.             if (linkedID.isNotEmpty())

  901.             {

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

  903.                 topLevelXml.applyOperationToChildWithID (linkedID, op);

  904.             }

  905.         }

  906. 

  907.         addGradientStopsIn (gradient, fillXml);

  908. 

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

  910.         {

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

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

  913. 

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

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

  916.         }

  917.         else

  918.         {

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

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

  921.         }

  922. 

  923.         if (opacity < 1.0f)

  924.             gradient.multiplyOpacity (opacity);

  925. 

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

  927. 

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

  929. 

  930.         float gradientWidth = viewBoxW;

  931.         float gradientHeight = viewBoxH;

  932.         float dx = 0.0f;

  933.         float dy = 0.0f;

  934. 

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

  936. 

  937.         if (! userSpace)

  938.         {

  939.             auto bounds = path.getBounds();

  940.             dx = bounds.getX();

  941.             dy = bounds.getY();

  942.             gradientWidth = bounds.getWidth();

  943.             gradientHeight = bounds.getHeight();

  944.         }

  945. 

  946.         if (gradient.isRadial)

  947.         {

  948.             if (userSpace)

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

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

  951.             else

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

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

  954. 

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

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

  957. 

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

  959.         }

  960.         else

  961.         {

  962.             if (userSpace)

  963.             {

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

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

  966. 

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

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

  969.             }

  970.             else

  971.             {

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

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

  974. 

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

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

  977.             }

  978. 

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

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

  981.         }

  982. 

  983.         FillType type (gradient);

  984. 

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

  986.                                    .followedBy (transform);

  987. 

  988.         if (gradient.isRadial)

  989.         {

  990.             type.transform = gradientTransform;

  991.         }

  992.         else

  993.         {

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

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

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

  997.                                                gradient.point1.x - gradient.point2.x)

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

  999. 

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

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

  1002. 

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

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

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

  1006.                                   / perpendicular.getDotProduct (perpendicular);

  1007. 

  1008.             type.gradient->point1 = newGradPoint1;

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

  1010.         }

  1011. 

  1012.         return type;

  1013.     }

  1014. 

  1015.     FillType getPathFillType (const Path& path,

  1016.                               const XmlPath& xml,

  1017.                               StringRef fillAttribute,

  1018.                               const String& fillOpacity,

  1019.                               const String& overallOpacity,

  1020.                               const Colour defaultColour) const

  1021.     {

  1022.         float opacity = 1.0f;

  1023. 

  1024.         if (overallOpacity.isNotEmpty())

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

  1026. 

  1027.         if (fillOpacity.isNotEmpty())

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

  1029. 

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

  1031.         String urlID = parseURL (fill);

  1032. 

  1033.         if (urlID.isNotEmpty())

  1034.         {

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

  1036. 

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

  1038.                 return op.fillType;

  1039.         }

  1040. 

  1041.         if (isNone (fill))

  1042.             return Colours::transparentBlack;

  1043. 

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

  1045.     }

  1046. 

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

  1048.     {

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

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

  1051. 

  1052.         return PathStrokeType::mitered;

  1053.     }

  1054. 

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

  1056.     {

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

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

  1059. 

  1060.         return PathStrokeType::butt;

  1061.     }

  1062. 

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

  1064.     {

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

  1066.     }

  1067. 

  1068.     PathStrokeType getStrokeFor (const XmlPath& xml) const

  1069.     {

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

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

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

  1073.     }

  1074. 

  1075.     //==============================================================================

  1076. 

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

  1078.     {

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

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

  1081. 

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

  1083. 

  1084.         auto linkedID = getLinkedID (xml);

  1085. 

  1086.         if (linkedID.isNotEmpty())

  1087.             topLevelXml.applyOperationToChildWithID (linkedID, op);

  1088. 

  1089.         return op.target;

  1090.     }

  1091. 

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

  1093.                          AffineTransform* additonalTransform = nullptr) const

  1094.     {

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

  1096.         {

  1097.             SVGState newState (*this);

  1098.             newState.addTransform (xml);

  1099. 

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

  1101.         }

  1102. 

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

  1104.             return useText (xml);

  1105. 

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

  1107.             return nullptr;

  1108. 

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

  1110. 

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

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

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

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

  1115. 

  1116.         auto font = getFont (xml);

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

  1118. 

  1119.         auto dc = new DrawableComposite();

  1120.         setCommonAttributes (*dc, xml);

  1121. 

  1122.         forEachXmlChildElement (*xml, e)

  1123.         {

  1124.             if (e->isTextElement())

  1125.             {

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

  1127. 

  1128.                 auto dt = new DrawableText();

  1129.                 dc->addAndMakeVisible (dt);

  1130. 

  1131.                 dt->setText (text);

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

  1133. 

  1134.                 if (additonalTransform != nullptr)

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

  1136.                 else

  1137.                     dt->setTransform (transform);

  1138. 

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

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

  1141. 

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

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

  1144. 

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

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

  1147. 

  1148.                 dt->setBoundingBox (bounds);

  1149.             }

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

  1151.             {

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

  1153.             }

  1154.         }

  1155. 

  1156.         return dc;

  1157.     }

  1158. 

  1159.     Font getFont (const XmlPath& xml) const

  1160.     {

  1161.         Font f;

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

  1163. 

  1164.         if (family.isNotEmpty())

  1165.             f.setTypefaceName (family);

  1166. 

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

  1168.             f.setItalic (true);

  1169. 

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

  1171.             f.setBold (true);

  1172. 

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

  1174.     }

  1175. 

  1176.     //==============================================================================

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

  1178.     {

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

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

  1181. 

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

  1183. 

  1184.         auto linkedID = getLinkedID (xml);

  1185. 

  1186.         if (linkedID.isNotEmpty())

  1187.             topLevelXml.applyOperationToChildWithID (linkedID, op);

  1188. 

  1189.         return op.target;

  1190.     }

  1191. 

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

  1193.                           AffineTransform* additionalTransform = nullptr) const

  1194.     {

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

  1196.         {

  1197.             SVGState newState (*this);

  1198.             newState.addTransform (xml);

  1199. 

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

  1201.         }

  1202. 

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

  1204.             return useImage (xml);

  1205. 

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

  1207.             return nullptr;

  1208. 

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

  1210. 

  1211.         ScopedPointer<InputStream> inputStream;

  1212.         MemoryOutputStream imageStream;

  1213. 

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

  1215.         {

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

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

  1218. 

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

  1220. 

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

  1222.             {

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

  1224. 

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

  1226.                 {

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

  1228. 

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

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

  1231.                 }

  1232.             }

  1233.         }

  1234.         else

  1235.         {

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

  1237. 

  1238.             if (linkedFile.existsAsFile())

  1239.                 inputStream = linkedFile.createInputStream();

  1240.         }

  1241. 

  1242.         if (inputStream != nullptr)

  1243.         {

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

  1245. 

  1246.             if (image.isValid())

  1247.             {

  1248.                 auto* di = new DrawableImage();

  1249. 

  1250.                 setCommonAttributes (*di, xml);

  1251.                 di->setImage (image);

  1252. 

  1253.                 if (additionalTransform != nullptr)

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

  1255.                 else

  1256.                     di->setTransform (transform);

  1257. 

  1258.                 return di;

  1259.             }

  1260.         }

  1261. 

  1262.         return nullptr;

  1263.     }

  1264. 

  1265.     //==============================================================================

  1266.     void addTransform (const XmlPath& xml)

  1267.     {

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

  1269.                         .followedBy (transform);

  1270.     }

  1271. 

  1272.     //==============================================================================

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

  1274.     {

  1275.         String number;

  1276. 

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

  1278.         {

  1279.             value = 0;

  1280.             return false;

  1281.         }

  1282. 

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

  1284.         return true;

  1285.     }

  1286. 

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

  1288.     {

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

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

  1291.     }

  1292. 

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

  1294.     {

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

  1296.             return true;

  1297. 

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

  1299.         return false;

  1300.     }

  1301. 

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

  1303.     {

  1304.         float n = s.getFloatValue();

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

  1306. 

  1307.         if (len > 2)

  1308.         {

  1309.             const float dpi = 96.0f;

  1310. 

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

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

  1313. 

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

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

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

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

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

  1319.         }

  1320. 

  1321.         return n;

  1322.     }

  1323. 

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

  1325.     {

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

  1327.     }

  1328. 

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

  1330.     {

  1331.         auto text = list.getCharPointer();

  1332.         float value;

  1333. 

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

  1335.             coords.add (value);

  1336.     }

  1337. 

  1338.     //==============================================================================

  1339.     void parseCSSStyle (const XmlPath& xml)

  1340.     {

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

  1342.     }

  1343. 

  1344.     void parseDefs (const XmlPath& xml)

  1345.     {

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

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

  1348.     }

  1349. 

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

  1351.     {

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

  1353. 

  1354.         while (! source.isEmpty())

  1355.         {

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

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

  1358.             {

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

  1360. 

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

  1362.                     return endOfName;

  1363. 

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

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

  1366.             }

  1367.         }

  1368. 

  1369.         return source;

  1370.     }

  1371. 

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

  1373.     {

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

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

  1376. 

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

  1378. 

  1379.         if (styleAtt.isNotEmpty())

  1380.         {

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

  1382. 

  1383.             if (value.isNotEmpty())

  1384.                 return value;

  1385.         }

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

  1387.         {

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

  1389.             {

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

  1391. 

  1392.                 if (openBrace.isEmpty())

  1393.                     break;

  1394. 

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

  1396. 

  1397.                 if (closeBrace.isEmpty())

  1398.                     break;

  1399. 

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

  1401.                                                         attributeName, defaultValue);

  1402.                 if (value.isNotEmpty())

  1403.                     return value;

  1404. 

  1405.                 i = closeBrace + 1;

  1406.             }

  1407.         }

  1408. 

  1409.         if (xml.parent != nullptr)

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

  1411. 

  1412.         return defaultValue;

  1413.     }

  1414. 

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

  1416.     {

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

  1418.             return xml->getStringAttribute (attributeName);

  1419. 

  1420.         if (xml.parent != nullptr)

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

  1422. 

  1423.         return {};

  1424.     }

  1425. 

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

  1427.     {

  1428.         if (align.isEmpty())

  1429.             return 0;

  1430. 

  1431.         if (isNone (align))

  1432.             return RectanglePlacement::stretchToFit;

  1433. 

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

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

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

  1437.                                                                                         : RectanglePlacement::xMid))

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

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

  1440.                                                                                         : RectanglePlacement::yMid));

  1441.     }

  1442. 

  1443.     //==============================================================================

  1444.     static bool isIdentifierChar (const juce_wchar c)

  1445.     {

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

  1447.     }

  1448. 

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

  1450.     {

  1451.         int i = 0;

  1452. 

  1453.         for (;;)

  1454.         {

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

  1456. 

  1457.             if (i < 0)

  1458.                 break;

  1459. 

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

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

  1462.             {

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

  1464. 

  1465.                 if (i < 0)

  1466.                     break;

  1467. 

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

  1469. 

  1470.                 if (end < 0)

  1471.                     end = 0x7ffff;

  1472. 

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

  1474.             }

  1475. 

  1476.             ++i;

  1477.         }

  1478. 

  1479.         return defaultValue;

  1480.     }

  1481. 

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

  1483.     static bool isStartOfNumber (juce_wchar c) noexcept

  1484.     {

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

  1486.     }

  1487. 

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

  1489.     {

  1490.         String::CharPointerType s (text);

  1491. 

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

  1493.             ++s;

  1494. 

  1495.         auto start = s;

  1496. 

  1497.         if (isStartOfNumber (*s))

  1498.             ++s;

  1499. 

  1500.         while (s.isDigit())

  1501.             ++s;

  1502. 

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

  1504.         {

  1505.             ++s;

  1506. 

  1507.             while (s.isDigit())

  1508.                 ++s;

  1509.         }

  1510. 

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

  1512.         {

  1513.             s += 2;

  1514. 

  1515.             while (s.isDigit())

  1516.                 ++s;

  1517.         }

  1518. 

  1519.         if (allowUnits)

  1520.             while (s.isLetter())

  1521.                 ++s;

  1522. 

  1523.         if (s == start)

  1524.         {

  1525.             text = s;

  1526.             return false;

  1527.         }

  1528. 

  1529.         value = String (start, s);

  1530. 

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

  1532.             ++s;

  1533. 

  1534.         text = s;

  1535.         return true;

  1536.     }

  1537. 

  1538.     //==============================================================================

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

  1540.     {

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

  1542. 

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

  1544.         {

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

  1546.             int numChars = 0;

  1547.             auto s = text.getCharPointer();

  1548. 

  1549.             while (numChars < 6)

  1550.             {

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

  1552. 

  1553.                 if (hexValue >= 0)

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

  1555.                 else

  1556.                     break;

  1557.             }

  1558. 

  1559.             if (numChars <= 3)

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

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

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

  1563. 

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

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

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

  1567.         }

  1568. 

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

  1570.         {

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

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

  1573. 

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

  1575.             {

  1576.                 StringArray tokens;

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

  1578.                 tokens.trim();

  1579.                 tokens.removeEmptyStrings();

  1580. 

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

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

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

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

  1585. 

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

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

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

  1589.             }

  1590.         }

  1591. 

  1592.         if (text == "inherit")

  1593.         {

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

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

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

  1597.         }

  1598. 

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

  1600.     }

  1601. 

  1602.     static AffineTransform parseTransform (String t)

  1603.     {

  1604.         AffineTransform result;

  1605. 

  1606.         while (t.isNotEmpty())

  1607.         {

  1608.             StringArray tokens;

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

  1610.                                .upToFirstOccurrenceOf (")", false, false),

  1611.                               ", ", "");

  1612. 

  1613.             tokens.removeEmptyStrings (true);

  1614. 

  1615.             float numbers[6];

  1616. 

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

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

  1619. 

  1620.             AffineTransform trans;

  1621. 

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

  1623.             {

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

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

  1626.             }

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

  1628.             {

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

  1630.             }

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

  1632.             {

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

  1634.             }

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

  1636.             {

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

  1638.             }

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

  1640.             {

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

  1642.             }

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

  1644.             {

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

  1646.             }

  1647. 

  1648.             result = trans.followedBy (result);

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

  1650.         }

  1651. 

  1652.         return result;

  1653.     }

  1654. 

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

  1656.                                             const double x2, const double y2,

  1657.                                             const double angle,

  1658.                                             const bool largeArc, const bool sweep,

  1659.                                             double& rx, double& ry,

  1660.                                             double& centreX, double& centreY,

  1661.                                             double& startAngle, double& deltaAngle) noexcept

  1662.     {

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

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

  1665. 

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

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

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

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

  1670.         const double xp2 = xp * xp;

  1671.         const double yp2 = yp * yp;

  1672. 

  1673.         double rx2 = rx * rx;

  1674.         double ry2 = ry * ry;

  1675. 

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

  1677.         double c;

  1678. 

  1679.         if (s <= 1.0)

  1680.         {

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

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

  1683. 

  1684.             if (largeArc == sweep)

  1685.                 c = -c;

  1686.         }

  1687.         else

  1688.         {

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

  1690.             rx *= s2;

  1691.             ry *= s2;

  1692.             c = 0;

  1693.         }

  1694. 

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

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

  1697. 

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

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

  1700. 

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

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

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

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

  1705. 

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

  1707. 

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

  1709. 

  1710.         if (uy < 0)

  1711.             startAngle = -startAngle;

  1712. 

  1713.         startAngle += double_Pi * 0.5;

  1714. 

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

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

  1717. 

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

  1719.             deltaAngle = -deltaAngle;

  1720. 

  1721.         if (sweep)

  1722.         {

  1723.             if (deltaAngle < 0)

  1724.                 deltaAngle += double_Pi * 2.0;

  1725.         }

  1726.         else

  1727.         {

  1728.             if (deltaAngle > 0)

  1729.                 deltaAngle -= double_Pi * 2.0;

  1730.         }

  1731. 

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

  1733.     }

  1734. 

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

  1736. };

  1737. 

  1738. 

  1739. //==============================================================================

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

  1741. {

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

  1743.         return nullptr;

  1744. 

  1745.     SVGState state (&svgDocument);

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

  1747. }

  1748. 

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

  1750. {

  1751.     XmlDocument doc (svgFile);

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

  1753. 

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

  1755.     {

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

  1757. 

  1758.         if (svgDocument != nullptr)

  1759.         {

  1760.             SVGState state (svgDocument, svgFile);

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

  1762.         }

  1763.     }

  1764. 

  1765.     return nullptr;

  1766. }

  1767. 

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

  1769. {

  1770.     SVGState state (nullptr);

  1771.     Path p;

  1772.     state.parsePathString (p, svgPath);

  1773.     return p;

  1774. }