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

1507 lines
51KB
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)  : topLevelXml (topLevel, nullptr)

  32.     {

  33.     }

  34. 

  35.     struct XmlPath

  36.     {

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

  38. 

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

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

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

  42. 

  43.         template <typename OperationType>

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

  45.         {

  46.             forEachXmlChildElement (*xml, e)

  47.             {

  48.                 XmlPath child (e, this);

  49. 

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

  51.                 {

  52.                     op (child);

  53.                     return true;

  54.                 }

  55. 

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

  57.                     return true;

  58.             }

  59. 

  60.             return false;

  61.         }

  62. 

  63.         const XmlElement* xml;

  64.         const XmlPath* parent;

  65.     };

  66. 

  67.     //==============================================================================

  68.     struct UsePathOp

  69.     {

  70.         const SVGState* state;

  71.         Path* targetPath;

  72. 

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

  74.         {

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

  76.         }

  77.     };

  78. 

  79.     struct GetClipPathOp

  80.     {

  81.         const SVGState* state;

  82.         Drawable* target;

  83. 

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

  85.         {

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

  87.         }

  88.     };

  89. 

  90.     struct SetGradientStopsOp

  91.     {

  92.         const SVGState* state;

  93.         ColourGradient* gradient;

  94. 

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

  96.         {

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

  98.         }

  99.     };

  100. 

  101.     struct GetFillTypeOp

  102.     {

  103.         const SVGState* state;

  104.         const Path* path;

  105.         float opacity;

  106.         FillType fillType;

  107. 

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

  109.         {

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

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

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

  113.         }

  114.     };

  115. 

  116.     //==============================================================================

  117.     Drawable* parseSVGElement (const XmlPath& xml)

  118.     {

  119.         auto drawable = new DrawableComposite();

  120.         setCommonAttributes (*drawable, xml);

  121. 

  122.         SVGState newState (*this);

  123. 

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

  125.             newState.addTransform (xml);

  126. 

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

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

  129. 

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

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

  132. 

  133.         Point<float> viewboxXY;

  134. 

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

  136.         {

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

  138.             auto viewParams = viewBoxAtt.getCharPointer();

  139.             Point<float> vwh;

  140. 

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

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

  143.                  && vwh.x > 0

  144.                  && vwh.y > 0)

  145.             {

  146.                 newState.viewBoxW = vwh.x;

  147.                 newState.viewBoxH = vwh.y;

  148. 

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

  150. 

  151.                 if (placementFlags != 0)

  152.                     newState.transform = RectanglePlacement (placementFlags)

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

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

  155.                                             .followedBy (newState.transform);

  156.             }

  157.         }

  158.         else

  159.         {

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

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

  162.         }

  163. 

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

  165. 

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

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

  168.                                                      RelativeCoordinate (viewboxXY.y),

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

  170.         drawable->resetBoundingBoxToContentArea();

  171. 

  172.         return drawable;

  173.     }

  174. 

  175.     //==============================================================================

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

  177.     {

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

  179. 

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

  181.         juce_wchar currentCommand = 0, previousCommand = 0;

  182.         bool isRelative = true;

  183.         bool carryOn = true;

  184. 

  185.         while (! d.isEmpty())

  186.         {

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

  188.             {

  189.                 currentCommand = d.getAndAdvance();

  190.                 isRelative = currentCommand >= 'a';

  191.             }

  192. 

  193.             switch (currentCommand)

  194.             {

  195.             case 'M':

  196.             case 'm':

  197.             case 'L':

  198.             case 'l':

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

  200.                 {

  201.                     if (isRelative)

  202.                         p1 += last;

  203. 

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

  205.                     {

  206.                         subpathStart = p1;

  207.                         path.startNewSubPath (p1);

  208.                         currentCommand = 'l';

  209.                     }

  210.                     else

  211.                         path.lineTo (p1);

  212. 

  213.                     last2 = last;

  214.                     last = p1;

  215.                 }

  216.                 break;

  217. 

  218.             case 'H':

  219.             case 'h':

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

  221.                 {

  222.                     if (isRelative)

  223.                         p1.x += last.x;

  224. 

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

  226. 

  227.                     last2.x = last.x;

  228.                     last.x = p1.x;

  229.                 }

  230.                 else

  231.                 {

  232.                     ++d;

  233.                 }

  234.                 break;

  235. 

  236.             case 'V':

  237.             case 'v':

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

  239.                 {

  240.                     if (isRelative)

  241.                         p1.y += last.y;

  242. 

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

  244. 

  245.                     last2.y = last.y;

  246.                     last.y = p1.y;

  247.                 }

  248.                 else

  249.                 {

  250.                     ++d;

  251.                 }

  252.                 break;

  253. 

  254.             case 'C':

  255.             case 'c':

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

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

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

  259.                 {

  260.                     if (isRelative)

  261.                     {

  262.                         p1 += last;

  263.                         p2 += last;

  264.                         p3 += last;

  265.                     }

  266. 

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

  268. 

  269.                     last2 = p2;

  270.                     last = p3;

  271.                 }

  272.                 break;

  273. 

  274.             case 'S':

  275.             case 's':

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

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

  278.                 {

  279.                     if (isRelative)

  280.                     {

  281.                         p1 += last;

  282.                         p3 += last;

  283.                     }

  284. 

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

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

  287. 

  288.                     last2 = p1;

  289.                     last = p3;

  290.                 }

  291.                 break;

  292. 

  293.             case 'Q':

  294.             case 'q':

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

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

  297.                 {

  298.                     if (isRelative)

  299.                     {

  300.                         p1 += last;

  301.                         p2 += last;

  302.                     }

  303. 

  304.                     path.quadraticTo (p1, p2);

  305. 

  306.                     last2 = p1;

  307.                     last = p2;

  308.                 }

  309.                 break;

  310. 

  311.             case 'T':

  312.             case 't':

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

  314.                 {

  315.                     if (isRelative)

  316.                         p1 += last;

  317. 

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

  319.                                                                                    : p1;

  320.                     path.quadraticTo (p2, p1);

  321. 

  322.                     last2 = p2;

  323.                     last = p1;

  324.                 }

  325.                 break;

  326. 

  327.             case 'A':

  328.             case 'a':

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

  330.                 {

  331.                     String num;

  332. 

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

  334.                     {

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

  336. 

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

  338.                         {

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

  340. 

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

  342.                             {

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

  344. 

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

  346.                                 {

  347.                                     if (isRelative)

  348.                                         p2 += last;

  349. 

  350.                                     if (last != p2)

  351.                                     {

  352.                                         double centreX, centreY, startAngle, deltaAngle;

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

  354. 

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

  356.                                                                     angle, largeArc, sweep,

  357.                                                                     rx, ry, centreX, centreY,

  358.                                                                     startAngle, deltaAngle);

  359. 

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

  361.                                                             (float) rx, (float) ry,

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

  363.                                                             false);

  364. 

  365.                                         path.lineTo (p2);

  366.                                     }

  367. 

  368.                                     last2 = last;

  369.                                     last = p2;

  370.                                 }

  371.                             }

  372.                         }

  373.                     }

  374.                 }

  375. 

  376.                 break;

  377. 

  378.             case 'Z':

  379.             case 'z':

  380.                 path.closeSubPath();

  381.                 last = last2 = subpathStart;

  382.                 d = d.findEndOfWhitespace();

  383.                 currentCommand = 'M';

  384.                 break;

  385. 

  386.             default:

  387.                 carryOn = false;

  388.                 break;

  389.             }

  390. 

  391.             if (! carryOn)

  392.                 break;

  393. 

  394.             previousCommand = currentCommand;

  395.         }

  396. 

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

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

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

  400.             path.closeSubPath();

  401.     }

  402. 

  403. private:

  404.     //==============================================================================

  405.     const XmlPath topLevelXml;

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

  407.     AffineTransform transform;

  408.     String cssStyleText;

  409. 

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

  411.     {

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

  413.         d.setName (compID);

  414.         d.setComponentID (compID);

  415. 

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

  417.             d.setVisible (false);

  418.     }

  419. 

  420.     //==============================================================================

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

  422.     {

  423.         forEachXmlChildElement (*xml, e)

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

  425.     }

  426. 

  427.     Drawable* parseSubElement (const XmlPath& xml)

  428.     {

  429.         {

  430.             Path path;

  431.             if (parsePathElement (xml, path))

  432.                 return parseShape (xml, path);

  433.         }

  434. 

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

  436. 

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

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

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

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

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

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

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

  444. 

  445.         return nullptr;

  446.     }

  447. 

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

  449.     {

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

  451. 

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

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

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

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

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

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

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

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

  460. 

  461.         return false;

  462.     }

  463. 

  464.     DrawableComposite* parseSwitch (const XmlPath& xml)

  465.     {

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

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

  468. 

  469.         return nullptr;

  470.     }

  471. 

  472.     DrawableComposite* parseGroupElement (const XmlPath& xml)

  473.     {

  474.         auto drawable = new DrawableComposite();

  475. 

  476.         setCommonAttributes (*drawable, xml);

  477. 

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

  479.         {

  480.             SVGState newState (*this);

  481.             newState.addTransform (xml);

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

  483.         }

  484.         else

  485.         {

  486.             parseSubElements (xml, *drawable);

  487.         }

  488. 

  489.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  490.         return drawable;

  491.     }

  492. 

  493.     DrawableComposite* parseLinkElement (const XmlPath& xml)

  494.     {

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

  496.     }

  497. 

  498.     //==============================================================================

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

  500.     {

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

  502. 

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

  504.             path.setUsingNonZeroWinding (false);

  505.     }

  506. 

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

  508.     {

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

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

  511. 

  512.         if (hasRX || hasRY)

  513.         {

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

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

  516. 

  517.             if (! hasRX)

  518.                 rx = ry;

  519.             else if (! hasRY)

  520.                 ry = rx;

  521. 

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

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

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

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

  526.                                       rx, ry);

  527.         }

  528.         else

  529.         {

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

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

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

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

  534.         }

  535.     }

  536. 

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

  538.     {

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

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

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

  542. 

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

  544.     }

  545. 

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

  547.     {

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

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

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

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

  552. 

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

  554.     }

  555. 

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

  557.     {

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

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

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

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

  562. 

  563.         line.startNewSubPath (x1, y1);

  564.         line.lineTo (x2, y2);

  565.     }

  566. 

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

  568.     {

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

  570.         auto points = pointsAtt.getCharPointer();

  571.         Point<float> p;

  572. 

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

  574.         {

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

  576. 

  577.             path.startNewSubPath (first);

  578. 

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

  580.             {

  581.                 last = p;

  582.                 path.lineTo (p);

  583.             }

  584. 

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

  586.                 path.closeSubPath();

  587.         }

  588.     }

  589. 

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

  591.     {

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

  593. 

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

  595.         {

  596.             auto linkedID = link.substring (1);

  597. 

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

  599.             topLevelXml.applyOperationToChildWithID (linkedID, op);

  600.         }

  601.     }

  602. 

  603.     static String parseURL (const String& str)

  604.     {

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

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

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

  608. 

  609.         return {};

  610.     }

  611. 

  612.     //==============================================================================

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

  614.                           const bool shouldParseTransform = true) const

  615.     {

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

  617.         {

  618.             SVGState newState (*this);

  619.             newState.addTransform (xml);

  620. 

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

  622.         }

  623. 

  624.         auto dp = new DrawablePath();

  625.         setCommonAttributes (*dp, xml);

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

  627. 

  628.         path.applyTransform (transform);

  629.         dp->setPath (path);

  630. 

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

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

  633.                                       getStyleAttribute (xml, "opacity"),

  634.                                       pathContainsClosedSubPath (path) ? Colours::black

  635.                                                                        : Colours::transparentBlack));

  636. 

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

  638. 

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

  640.         {

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

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

  643.                                                 getStyleAttribute (xml, "opacity"),

  644.                                                 Colours::transparentBlack));

  645. 

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

  647.         }

  648. 

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

  650. 

  651.         if (strokeDashArray.isNotEmpty())

  652.             parseDashArray (strokeDashArray, *dp);

  653. 

  654.         parseClipPath (xml, *dp);

  655.         return dp;

  656.     }

  657. 

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

  659.     {

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

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

  662.                 return true;

  663. 

  664.         return false;

  665.     }

  666. 

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

  668.     {

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

  670.             return;

  671. 

  672.         Array<float> dashLengths;

  673. 

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

  675.         {

  676.             float value;

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

  678.                 break;

  679. 

  680.             dashLengths.add (value);

  681. 

  682.             t = t.findEndOfWhitespace();

  683. 

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

  685.                 ++t;

  686.         }

  687. 

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

  689.         {

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

  691. 

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

  693.             {

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

  695.                 {

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

  697.                         return;

  698. 

  699.                     const float nonZeroLength = 0.001f;

  700.                     dashes[i] = nonZeroLength;

  701. 

  702.                     const int pairedIndex = i ^ 1;

  703. 

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

  705.                           && dashes[pairedIndex] > nonZeroLength)

  706.                         dashes[pairedIndex] -= nonZeroLength;

  707.                 }

  708.             }

  709. 

  710.             dp.setDashLengths (dashLengths);

  711.         }

  712.     }

  713. 

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

  715.     {

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

  717. 

  718.         if (clipPath.isNotEmpty())

  719.         {

  720.             auto urlID = parseURL (clipPath);

  721. 

  722.             if (urlID.isNotEmpty())

  723.             {

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

  725.                 topLevelXml.applyOperationToChildWithID (urlID, op);

  726.             }

  727.         }

  728.     }

  729. 

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

  731.     {

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

  733.         {

  734.             // TODO: implement clipping..

  735.             ignoreUnused (target);

  736.         }

  737.     }

  738. 

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

  740.     {

  741.         if (fillXml.xml != nullptr)

  742.         {

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

  744.             {

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

  746. 

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

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

  749. 

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

  751. 

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

  753.                     offset *= 0.01;

  754. 

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

  756.             }

  757.         }

  758.     }

  759. 

  760.     FillType getGradientFillType (const XmlPath& fillXml,

  761.                                   const Path& path,

  762.                                   const float opacity) const

  763.     {

  764.         ColourGradient gradient;

  765. 

  766.         {

  767.             auto link = fillXml->getStringAttribute ("xlink:href");

  768. 

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

  770.             {

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

  772.                 topLevelXml.applyOperationToChildWithID (link.substring (1), op);

  773.             }

  774.         }

  775. 

  776.         addGradientStopsIn (gradient, fillXml);

  777. 

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

  779.         {

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

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

  782. 

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

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

  785.         }

  786.         else

  787.         {

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

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

  790.         }

  791. 

  792.         if (opacity < 1.0f)

  793.             gradient.multiplyOpacity (opacity);

  794. 

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

  796. 

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

  798. 

  799.         float gradientWidth = viewBoxW;

  800.         float gradientHeight = viewBoxH;

  801.         float dx = 0.0f;

  802.         float dy = 0.0f;

  803. 

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

  805. 

  806.         if (! userSpace)

  807.         {

  808.             auto bounds = path.getBounds();

  809.             dx = bounds.getX();

  810.             dy = bounds.getY();

  811.             gradientWidth = bounds.getWidth();

  812.             gradientHeight = bounds.getHeight();

  813.         }

  814. 

  815.         if (gradient.isRadial)

  816.         {

  817.             if (userSpace)

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

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

  820.             else

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

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

  823. 

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

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

  826. 

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

  828.         }

  829.         else

  830.         {

  831.             if (userSpace)

  832.             {

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

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

  835. 

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

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

  838.             }

  839.             else

  840.             {

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

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

  843. 

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

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

  846.             }

  847. 

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

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

  850.         }

  851. 

  852.         FillType type (gradient);

  853. 

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

  855.                                    .followedBy (transform);

  856. 

  857.         if (gradient.isRadial)

  858.         {

  859.             type.transform = gradientTransform;

  860.         }

  861.         else

  862.         {

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

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

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

  866.                                                gradient.point1.x - gradient.point2.x)

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

  868. 

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

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

  871. 

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

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

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

  875.                                   / perpendicular.getDotProduct (perpendicular);

  876. 

  877.             type.gradient->point1 = newGradPoint1;

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

  879.         }

  880. 

  881.         return type;

  882.     }

  883. 

  884.     FillType getPathFillType (const Path& path,

  885.                               const XmlPath& xml,

  886.                               StringRef fillAttribute,

  887.                               const String& fillOpacity,

  888.                               const String& overallOpacity,

  889.                               const Colour defaultColour) const

  890.     {

  891.         float opacity = 1.0f;

  892. 

  893.         if (overallOpacity.isNotEmpty())

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

  895. 

  896.         if (fillOpacity.isNotEmpty())

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

  898. 

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

  900.         String urlID = parseURL (fill);

  901. 

  902.         if (urlID.isNotEmpty())

  903.         {

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

  905. 

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

  907.                 return op.fillType;

  908.         }

  909. 

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

  911.             return Colours::transparentBlack;

  912. 

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

  914.     }

  915. 

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

  917.     {

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

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

  920. 

  921.         return PathStrokeType::mitered;

  922.     }

  923. 

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

  925.     {

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

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

  928. 

  929.         return PathStrokeType::butt;

  930.     }

  931. 

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

  933.     {

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

  935.     }

  936. 

  937.     PathStrokeType getStrokeFor (const XmlPath& xml) const

  938.     {

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

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

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

  942.     }

  943. 

  944.     //==============================================================================

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

  946.     {

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

  948.         {

  949.             SVGState newState (*this);

  950.             newState.addTransform (xml);

  951. 

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

  953.         }

  954. 

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

  956. 

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

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

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

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

  961. 

  962.         auto font = getFont (xml);

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

  964. 

  965.         auto dc = new DrawableComposite();

  966.         setCommonAttributes (*dc, xml);

  967. 

  968.         forEachXmlChildElement (*xml, e)

  969.         {

  970.             if (e->isTextElement())

  971.             {

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

  973. 

  974.                 auto dt = new DrawableText();

  975.                 dc->addAndMakeVisible (dt);

  976. 

  977.                 dt->setText (text);

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

  979.                 dt->setTransform (transform);

  980. 

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

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

  983. 

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

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

  986. 

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

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

  989. 

  990.                 dt->setBoundingBox (bounds);

  991.             }

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

  993.             {

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

  995.             }

  996.         }

  997. 

  998.         return dc;

  999.     }

  1000. 

  1001.     Font getFont (const XmlPath& xml) const

  1002.     {

  1003.         auto fontSize = getCoordLength (getStyleAttribute (xml, "font-size"), 1.0f);

  1004. 

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

  1006. 

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

  1008.             style |= Font::bold;

  1009. 

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

  1011. 

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

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

  1014.     }

  1015. 

  1016.     //==============================================================================

  1017.     void addTransform (const XmlPath& xml)

  1018.     {

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

  1020.                         .followedBy (transform);

  1021.     }

  1022. 

  1023.     //==============================================================================

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

  1025.     {

  1026.         String number;

  1027. 

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

  1029.         {

  1030.             value = 0;

  1031.             return false;

  1032.         }

  1033. 

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

  1035.         return true;

  1036.     }

  1037. 

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

  1039.     {

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

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

  1042.     }

  1043. 

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

  1045.     {

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

  1047.             return true;

  1048. 

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

  1050.         return false;

  1051.     }

  1052. 

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

  1054.     {

  1055.         float n = s.getFloatValue();

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

  1057. 

  1058.         if (len > 2)

  1059.         {

  1060.             const float dpi = 96.0f;

  1061. 

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

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

  1064. 

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

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

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

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

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

  1070.         }

  1071. 

  1072.         return n;

  1073.     }

  1074. 

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

  1076.     {

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

  1078.     }

  1079. 

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

  1081.     {

  1082.         auto text = list.getCharPointer();

  1083.         float value;

  1084. 

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

  1086.             coords.add (value);

  1087.     }

  1088. 

  1089.     //==============================================================================

  1090.     void parseCSSStyle (const XmlPath& xml)

  1091.     {

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

  1093.     }

  1094. 

  1095.     void parseDefs (const XmlPath& xml)

  1096.     {

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

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

  1099.     }

  1100. 

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

  1102.     {

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

  1104. 

  1105.         while (! source.isEmpty())

  1106.         {

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

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

  1109.             {

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

  1111. 

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

  1113.                     return endOfName;

  1114. 

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

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

  1117.             }

  1118.         }

  1119. 

  1120.         return source;

  1121.     }

  1122. 

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

  1124.     {

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

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

  1127. 

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

  1129. 

  1130.         if (styleAtt.isNotEmpty())

  1131.         {

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

  1133. 

  1134.             if (value.isNotEmpty())

  1135.                 return value;

  1136.         }

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

  1138.         {

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

  1140.             {

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

  1142. 

  1143.                 if (openBrace.isEmpty())

  1144.                     break;

  1145. 

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

  1147. 

  1148.                 if (closeBrace.isEmpty())

  1149.                     break;

  1150. 

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

  1152.                                                         attributeName, defaultValue);

  1153.                 if (value.isNotEmpty())

  1154.                     return value;

  1155. 

  1156.                 i = closeBrace + 1;

  1157.             }

  1158.         }

  1159. 

  1160.         if (xml.parent != nullptr)

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

  1162. 

  1163.         return defaultValue;

  1164.     }

  1165. 

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

  1167.     {

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

  1169.             return xml->getStringAttribute (attributeName);

  1170. 

  1171.         if (xml.parent != nullptr)

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

  1173. 

  1174.         return {};

  1175.     }

  1176. 

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

  1178.     {

  1179.         if (align.isEmpty())

  1180.             return 0;

  1181. 

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

  1183.             return RectanglePlacement::stretchToFit;

  1184. 

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

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

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

  1188.                                                                                         : RectanglePlacement::xMid))

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

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

  1191.                                                                                         : RectanglePlacement::yMid));

  1192.     }

  1193. 

  1194.     //==============================================================================

  1195.     static bool isIdentifierChar (const juce_wchar c)

  1196.     {

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

  1198.     }

  1199. 

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

  1201.     {

  1202.         int i = 0;

  1203. 

  1204.         for (;;)

  1205.         {

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

  1207. 

  1208.             if (i < 0)

  1209.                 break;

  1210. 

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

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

  1213.             {

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

  1215. 

  1216.                 if (i < 0)

  1217.                     break;

  1218. 

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

  1220. 

  1221.                 if (end < 0)

  1222.                     end = 0x7ffff;

  1223. 

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

  1225.             }

  1226. 

  1227.             ++i;

  1228.         }

  1229. 

  1230.         return defaultValue;

  1231.     }

  1232. 

  1233.     //==============================================================================

  1234.     static bool isStartOfNumber (juce_wchar c) noexcept

  1235.     {

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

  1237.     }

  1238. 

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

  1240.     {

  1241.         String::CharPointerType s (text);

  1242. 

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

  1244.             ++s;

  1245. 

  1246.         auto start = s;

  1247. 

  1248.         if (isStartOfNumber (*s))

  1249.             ++s;

  1250. 

  1251.         while (s.isDigit())

  1252.             ++s;

  1253. 

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

  1255.         {

  1256.             ++s;

  1257. 

  1258.             while (s.isDigit())

  1259.                 ++s;

  1260.         }

  1261. 

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

  1263.         {

  1264.             s += 2;

  1265. 

  1266.             while (s.isDigit())

  1267.                 ++s;

  1268.         }

  1269. 

  1270.         if (allowUnits)

  1271.             while (s.isLetter())

  1272.                 ++s;

  1273. 

  1274.         if (s == start)

  1275.         {

  1276.             text = s;

  1277.             return false;

  1278.         }

  1279. 

  1280.         value = String (start, s);

  1281. 

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

  1283.             ++s;

  1284. 

  1285.         text = s;

  1286.         return true;

  1287.     }

  1288. 

  1289.     //==============================================================================

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

  1291.     {

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

  1293. 

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

  1295.         {

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

  1297.             int numChars = 0;

  1298.             auto s = text.getCharPointer();

  1299. 

  1300.             while (numChars < 6)

  1301.             {

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

  1303. 

  1304.                 if (hexValue >= 0)

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

  1306.                 else

  1307.                     break;

  1308.             }

  1309. 

  1310.             if (numChars <= 3)

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

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

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

  1314. 

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

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

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

  1318.         }

  1319. 

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

  1321.         {

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

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

  1324. 

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

  1326.             {

  1327.                 StringArray tokens;

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

  1329.                 tokens.trim();

  1330.                 tokens.removeEmptyStrings();

  1331. 

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

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

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

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

  1336. 

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

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

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

  1340.             }

  1341.         }

  1342. 

  1343.         if (text == "inherit")

  1344.         {

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

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

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

  1348.         }

  1349. 

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

  1351.     }

  1352. 

  1353.     static AffineTransform parseTransform (String t)

  1354.     {

  1355.         AffineTransform result;

  1356. 

  1357.         while (t.isNotEmpty())

  1358.         {

  1359.             StringArray tokens;

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

  1361.                                .upToFirstOccurrenceOf (")", false, false),

  1362.                               ", ", "");

  1363. 

  1364.             tokens.removeEmptyStrings (true);

  1365. 

  1366.             float numbers[6];

  1367. 

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

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

  1370. 

  1371.             AffineTransform trans;

  1372. 

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

  1374.             {

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

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

  1377.             }

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

  1379.             {

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

  1381.             }

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

  1383.             {

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

  1385.             }

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

  1387.             {

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

  1389.             }

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

  1391.             {

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

  1393.             }

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

  1395.             {

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

  1397.             }

  1398. 

  1399.             result = trans.followedBy (result);

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

  1401.         }

  1402. 

  1403.         return result;

  1404.     }

  1405. 

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

  1407.                                             const double x2, const double y2,

  1408.                                             const double angle,

  1409.                                             const bool largeArc, const bool sweep,

  1410.                                             double& rx, double& ry,

  1411.                                             double& centreX, double& centreY,

  1412.                                             double& startAngle, double& deltaAngle) noexcept

  1413.     {

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

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

  1416. 

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

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

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

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

  1421.         const double xp2 = xp * xp;

  1422.         const double yp2 = yp * yp;

  1423. 

  1424.         double rx2 = rx * rx;

  1425.         double ry2 = ry * ry;

  1426. 

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

  1428.         double c;

  1429. 

  1430.         if (s <= 1.0)

  1431.         {

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

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

  1434. 

  1435.             if (largeArc == sweep)

  1436.                 c = -c;

  1437.         }

  1438.         else

  1439.         {

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

  1441.             rx *= s2;

  1442.             ry *= s2;

  1443.             c = 0;

  1444.         }

  1445. 

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

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

  1448. 

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

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

  1451. 

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

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

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

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

  1456. 

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

  1458. 

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

  1460. 

  1461.         if (uy < 0)

  1462.             startAngle = -startAngle;

  1463. 

  1464.         startAngle += double_Pi * 0.5;

  1465. 

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

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

  1468. 

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

  1470.             deltaAngle = -deltaAngle;

  1471. 

  1472.         if (sweep)

  1473.         {

  1474.             if (deltaAngle < 0)

  1475.                 deltaAngle += double_Pi * 2.0;

  1476.         }

  1477.         else

  1478.         {

  1479.             if (deltaAngle > 0)

  1480.                 deltaAngle -= double_Pi * 2.0;

  1481.         }

  1482. 

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

  1484.     }

  1485. 

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

  1487. };

  1488. 

  1489. 

  1490. //==============================================================================

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

  1492. {

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

  1494.         return nullptr;

  1495. 

  1496.     SVGState state (&svgDocument);

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

  1498. }

  1499. 

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

  1501. {

  1502.     SVGState state (nullptr);

  1503.     Path p;

  1504.     state.parsePathString (p, svgPath);

  1505.     return p;

  1506. }