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.
2713 Commits
9 Branches
440MB
Tree: 5d35a31f2e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '5d35a31f2e'
${ noResults }
JUCE/modules/juce_gui_basics/drawables/juce_SVGParser.cpp

1233 lines
43KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library - "Jules' Utility Class Extensions"

  5.    Copyright 2004-11 by Raw Material Software Ltd.

  6. 

  7.   ------------------------------------------------------------------------------

  8. 

  9.    JUCE can be redistributed and/or modified under the terms of the GNU General

  10.    Public License (Version 2), as published by the Free Software Foundation.

  11.    A copy of the license is included in the JUCE distribution, or can be found

  12.    online at www.gnu.org/licenses.

  13. 

  14.    JUCE is distributed in the hope that it will be useful, but WITHOUT ANY

  15.    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR

  16.    A PARTICULAR PURPOSE.  See the GNU General Public License for more details.

  17. 

  18.   ------------------------------------------------------------------------------

  19. 

  20.    To release a closed-source product which uses JUCE, commercial licenses are

  21.    available: visit www.rawmaterialsoftware.com/juce for more information.

  22. 

  23.   ==============================================================================

  24. */

  25. 

  26. class SVGState

  27. {

  28. public:

  29.     //==============================================================================

  30.     SVGState (const XmlElement* const topLevel)

  31.         : topLevelXml (topLevel),

  32.           elementX (0), elementY (0),

  33.           width (512), height (512),

  34.           viewBoxW (0), viewBoxH (0)

  35.     {

  36.     }

  37. 

  38.     //==============================================================================

  39.     Drawable* parseSVGElement (const XmlElement& xml)

  40.     {

  41.         if (! xml.hasTagName ("svg"))

  42.             return nullptr;

  43. 

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

  45. 

  46.         drawable->setName (xml.getStringAttribute ("id"));

  47. 

  48.         SVGState newState (*this);

  49. 

  50.         if (xml.hasAttribute ("transform"))

  51.             newState.addTransform (xml);

  52. 

  53.         newState.elementX = getCoordLength (xml.getStringAttribute ("x",      String (newState.elementX)), viewBoxW);

  54.         newState.elementY = getCoordLength (xml.getStringAttribute ("y",      String (newState.elementY)), viewBoxH);

  55.         newState.width    = getCoordLength (xml.getStringAttribute ("width",  String (newState.width)),    viewBoxW);

  56.         newState.height   = getCoordLength (xml.getStringAttribute ("height", String (newState.height)),   viewBoxH);

  57. 

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

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

  60. 

  61.         if (xml.hasAttribute ("viewBox"))

  62.         {

  63.             const String viewBoxAtt (xml.getStringAttribute ("viewBox"));

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

  65.             Point<float> vxy, vwh;

  66. 

  67.             if (parseCoords (viewParams, vxy, true)

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

  69.                  && vwh.x > 0

  70.                  && vwh.y > 0)

  71.             {

  72.                 newState.viewBoxW = vwh.x;

  73.                 newState.viewBoxH = vwh.y;

  74. 

  75.                 int placementFlags = 0;

  76. 

  77.                 const String aspect (xml.getStringAttribute ("preserveAspectRatio"));

  78. 

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

  80.                 {

  81.                     placementFlags = RectanglePlacement::stretchToFit;

  82.                 }

  83.                 else

  84.                 {

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

  86. 

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

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

  89.                     else                                            placementFlags |= RectanglePlacement::xMid;

  90. 

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

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

  93.                     else                                            placementFlags |= RectanglePlacement::yMid;

  94.                 }

  95. 

  96.                 newState.transform = RectanglePlacement (placementFlags)

  97.                                         .getTransformToFit (Rectangle<float> (vxy.x, vxy.y, vwh.x, vwh.y),

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

  99.                                         .followedBy (newState.transform);

  100.             }

  101.         }

  102.         else

  103.         {

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

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

  106.         }

  107. 

  108.         newState.parseSubElements (xml, drawable);

  109. 

  110.         drawable->setContentArea (RelativeRectangle (Rectangle<float> (newState.viewBoxW, newState.viewBoxH)));

  111.         drawable->resetBoundingBoxToContentArea();

  112. 

  113.         return drawable;

  114.     }

  115. 

  116. private:

  117.     //==============================================================================

  118.     const XmlElement* const topLevelXml;

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

  120.     AffineTransform transform;

  121.     String cssStyleText;

  122. 

  123.     //==============================================================================

  124.     void parseSubElements (const XmlElement& xml, DrawableComposite* const parentDrawable)

  125.     {

  126.         forEachXmlChildElement (xml, e)

  127.         {

  128.             Drawable* d = nullptr;

  129. 

  130.             if (e->hasTagName ("g"))                d = parseGroupElement (*e);

  131.             else if (e->hasTagName ("svg"))         d = parseSVGElement (*e);

  132.             else if (e->hasTagName ("path"))        d = parsePath (*e);

  133.             else if (e->hasTagName ("rect"))        d = parseRect (*e);

  134.             else if (e->hasTagName ("circle"))      d = parseCircle (*e);

  135.             else if (e->hasTagName ("ellipse"))     d = parseEllipse (*e);

  136.             else if (e->hasTagName ("line"))        d = parseLine (*e);

  137.             else if (e->hasTagName ("polyline"))    d = parsePolygon (*e, true);

  138.             else if (e->hasTagName ("polygon"))     d = parsePolygon (*e, false);

  139.             else if (e->hasTagName ("text"))        d = parseText (*e);

  140.             else if (e->hasTagName ("switch"))      d = parseSwitch (*e);

  141.             else if (e->hasTagName ("style"))       parseCSSStyle (*e);

  142. 

  143.             parentDrawable->addAndMakeVisible (d);

  144.         }

  145.     }

  146. 

  147.     DrawableComposite* parseSwitch (const XmlElement& xml)

  148.     {

  149.         if (const XmlElement* const group = xml.getChildByName ("g"))

  150.             return parseGroupElement (*group);

  151. 

  152.         return nullptr;

  153.     }

  154. 

  155.     DrawableComposite* parseGroupElement (const XmlElement& xml)

  156.     {

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

  158. 

  159.         drawable->setName (xml.getStringAttribute ("id"));

  160. 

  161.         if (xml.hasAttribute ("transform"))

  162.         {

  163.             SVGState newState (*this);

  164.             newState.addTransform (xml);

  165. 

  166.             newState.parseSubElements (xml, drawable);

  167.         }

  168.         else

  169.         {

  170.             parseSubElements (xml, drawable);

  171.         }

  172. 

  173.         drawable->resetContentAreaAndBoundingBoxToFitChildren();

  174.         return drawable;

  175.     }

  176. 

  177.     //==============================================================================

  178.     Drawable* parsePath (const XmlElement& xml) const

  179.     {

  180.         const String dAttribute (xml.getStringAttribute ("d").trimStart());

  181.         String::CharPointerType d (dAttribute.getCharPointer());

  182.         Path path;

  183. 

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

  185.             path.setUsingNonZeroWinding (false);

  186. 

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

  188.         juce_wchar lastCommandChar = 0;

  189.         bool isRelative = true;

  190.         bool carryOn = true;

  191. 

  192.         const CharPointer_ASCII validCommandChars ("MmLlHhVvCcSsQqTtAaZz");

  193. 

  194.         while (! d.isEmpty())

  195.         {

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

  197.             {

  198.                 lastCommandChar = d.getAndAdvance();

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

  200.             }

  201. 

  202.             switch (lastCommandChar)

  203.             {

  204.             case 'M':

  205.             case 'm':

  206.             case 'L':

  207.             case 'l':

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

  209.                 {

  210.                     if (isRelative)

  211.                         p1 += last;

  212. 

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

  214.                     {

  215.                         subpathStart = p1;

  216.                         path.startNewSubPath (p1);

  217.                         lastCommandChar = 'l';

  218.                     }

  219.                     else

  220.                         path.lineTo (p1);

  221. 

  222.                     last2 = last;

  223.                     last = p1;

  224.                 }

  225.                 break;

  226. 

  227.             case 'H':

  228.             case 'h':

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

  230.                 {

  231.                     if (isRelative)

  232.                         p1.x += last.x;

  233. 

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

  235. 

  236.                     last2.x = last.x;

  237.                     last.x = p1.x;

  238.                 }

  239.                 else

  240.                 {

  241.                     ++d;

  242.                 }

  243.                 break;

  244. 

  245.             case 'V':

  246.             case 'v':

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

  248.                 {

  249.                     if (isRelative)

  250.                         p1.y += last.y;

  251. 

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

  253. 

  254.                     last2.y = last.y;

  255.                     last.y = p1.y;

  256.                 }

  257.                 else

  258.                 {

  259.                     ++d;

  260.                 }

  261.                 break;

  262. 

  263.             case 'C':

  264.             case 'c':

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

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

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

  268.                 {

  269.                     if (isRelative)

  270.                     {

  271.                         p1 += last;

  272.                         p2 += last;

  273.                         p3 += last;

  274.                     }

  275. 

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

  277. 

  278.                     last2 = p2;

  279.                     last = p3;

  280.                 }

  281.                 break;

  282. 

  283.             case 'S':

  284.             case 's':

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

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

  287.                 {

  288.                     if (isRelative)

  289.                     {

  290.                         p1 += last;

  291.                         p3 += last;

  292.                     }

  293. 

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

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

  296. 

  297.                     last2 = p1;

  298.                     last = p3;

  299.                 }

  300.                 break;

  301. 

  302.             case 'Q':

  303.             case 'q':

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

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

  306.                 {

  307.                     if (isRelative)

  308.                     {

  309.                         p1 += last;

  310.                         p2 += last;

  311.                     }

  312. 

  313.                     path.quadraticTo (p1, p2);

  314. 

  315.                     last2 = p1;

  316.                     last = p2;

  317.                 }

  318.                 break;

  319. 

  320.             case 'T':

  321.             case 't':

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

  323.                 {

  324.                     if (isRelative)

  325.                         p1 += last;

  326. 

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

  328.                     path.quadraticTo (p2, p1);

  329. 

  330.                     last2 = p2;

  331.                     last = p1;

  332.                 }

  333.                 break;

  334. 

  335.             case 'A':

  336.             case 'a':

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

  338.                 {

  339.                     String num;

  340. 

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

  342.                     {

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

  344. 

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

  346.                         {

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

  348. 

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

  350.                             {

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

  352. 

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

  354.                                 {

  355.                                     if (isRelative)

  356.                                         p2 += last;

  357. 

  358.                                     if (last != p2)

  359.                                     {

  360.                                         double centreX, centreY, startAngle, deltaAngle;

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

  362. 

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

  364.                                                                     angle, largeArc, sweep,

  365.                                                                     rx, ry, centreX, centreY,

  366.                                                                     startAngle, deltaAngle);

  367. 

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

  369.                                                             (float) rx, (float) ry,

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

  371.                                                             false);

  372. 

  373.                                         path.lineTo (p2);

  374.                                     }

  375. 

  376.                                     last2 = last;

  377.                                     last = p2;

  378.                                 }

  379.                             }

  380.                         }

  381.                     }

  382.                 }

  383. 

  384.                 break;

  385. 

  386.             case 'Z':

  387.             case 'z':

  388.                 path.closeSubPath();

  389.                 last = last2 = subpathStart;

  390.                 d = d.findEndOfWhitespace();

  391.                 lastCommandChar = 'M';

  392.                 break;

  393. 

  394.             default:

  395.                 carryOn = false;

  396.                 break;

  397.             }

  398. 

  399.             if (! carryOn)

  400.                 break;

  401.         }

  402. 

  403.         return parseShape (xml, path);

  404.     }

  405. 

  406.     Drawable* parseRect (const XmlElement& xml) const

  407.     {

  408.         Path rect;

  409. 

  410.         const bool hasRX = xml.hasAttribute ("rx");

  411.         const bool hasRY = xml.hasAttribute ("ry");

  412. 

  413.         if (hasRX || hasRY)

  414.         {

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

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

  417. 

  418.             if (! hasRX)

  419.                 rx = ry;

  420.             else if (! hasRY)

  421.                 ry = rx;

  422. 

  423.             rect.addRoundedRectangle (getCoordLength (xml.getStringAttribute ("x"), viewBoxW),

  424.                                       getCoordLength (xml.getStringAttribute ("y"), viewBoxH),

  425.                                       getCoordLength (xml.getStringAttribute ("width"), viewBoxW),

  426.                                       getCoordLength (xml.getStringAttribute ("height"), viewBoxH),

  427.                                       rx, ry);

  428.         }

  429.         else

  430.         {

  431.             rect.addRectangle (getCoordLength (xml.getStringAttribute ("x"), viewBoxW),

  432.                                getCoordLength (xml.getStringAttribute ("y"), viewBoxH),

  433.                                getCoordLength (xml.getStringAttribute ("width"), viewBoxW),

  434.                                getCoordLength (xml.getStringAttribute ("height"), viewBoxH));

  435.         }

  436. 

  437.         return parseShape (xml, rect);

  438.     }

  439. 

  440.     Drawable* parseCircle (const XmlElement& xml) const

  441.     {

  442.         Path circle;

  443. 

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

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

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

  447. 

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

  449. 

  450.         return parseShape (xml, circle);

  451.     }

  452. 

  453.     Drawable* parseEllipse (const XmlElement& xml) const

  454.     {

  455.         Path ellipse;

  456. 

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

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

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

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

  461. 

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

  463. 

  464.         return parseShape (xml, ellipse);

  465.     }

  466. 

  467.     Drawable* parseLine (const XmlElement& xml) const

  468.     {

  469.         Path line;

  470. 

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

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

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

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

  475. 

  476.         line.startNewSubPath (x1, y1);

  477.         line.lineTo (x2, y2);

  478. 

  479.         return parseShape (xml, line);

  480.     }

  481. 

  482.     Drawable* parsePolygon (const XmlElement& xml, const bool isPolyline) const

  483.     {

  484.         const String pointsAtt (xml.getStringAttribute ("points"));

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

  486.         Path path;

  487.         Point<float> p;

  488. 

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

  490.         {

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

  492. 

  493.             path.startNewSubPath (first);

  494. 

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

  496.             {

  497.                 last = p;

  498.                 path.lineTo (p);

  499.             }

  500. 

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

  502.                 path.closeSubPath();

  503.         }

  504. 

  505.         return parseShape (xml, path);

  506.     }

  507. 

  508.     //==============================================================================

  509.     Drawable* parseShape (const XmlElement& xml, Path& path,

  510.                           const bool shouldParseTransform = true) const

  511.     {

  512.         if (shouldParseTransform && xml.hasAttribute ("transform"))

  513.         {

  514.             SVGState newState (*this);

  515.             newState.addTransform (xml);

  516. 

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

  518.         }

  519. 

  520.         DrawablePath* dp = new DrawablePath();

  521.         dp->setName (xml.getStringAttribute ("id"));

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

  523. 

  524.         path.applyTransform (transform);

  525.         dp->setPath (path);

  526. 

  527.         Path::Iterator iter (path);

  528. 

  529.         bool containsClosedSubPath = false;

  530.         while (iter.next())

  531.         {

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

  533.             {

  534.                 containsClosedSubPath = true;

  535.                 break;

  536.             }

  537.         }

  538. 

  539.         dp->setFill (getPathFillType (path,

  540.                                       getStyleAttribute (&xml, "fill"),

  541.                                       getStyleAttribute (&xml, "fill-opacity"),

  542.                                       getStyleAttribute (&xml, "opacity"),

  543.                                       containsClosedSubPath ? Colours::black

  544.                                                             : Colours::transparentBlack));

  545. 

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

  547. 

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

  549.         {

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

  551.                                                 getStyleAttribute (&xml, "stroke-opacity"),

  552.                                                 getStyleAttribute (&xml, "opacity"),

  553.                                                 Colours::transparentBlack));

  554. 

  555.             dp->setStrokeType (getStrokeFor (&xml));

  556.         }

  557. 

  558.         return dp;

  559.     }

  560. 

  561.     const XmlElement* findLinkedElement (const XmlElement* e) const

  562.     {

  563.         const String id (e->getStringAttribute ("xlink:href"));

  564. 

  565.         if (! id.startsWithChar ('#'))

  566.             return nullptr;

  567. 

  568.         return findElementForId (topLevelXml, id.substring (1));

  569.     }

  570. 

  571.     void addGradientStopsIn (ColourGradient& cg, const XmlElement* const fillXml) const

  572.     {

  573.         if (fillXml != nullptr)

  574.         {

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

  576.             {

  577.                 int index = 0;

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

  579. 

  580.                 const String opacity (getStyleAttribute (e, "stop-opacity", "1"));

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

  582. 

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

  584. 

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

  586.                     offset *= 0.01;

  587. 

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

  589.             }

  590.         }

  591.     }

  592. 

  593.     FillType getGradientFillType (const XmlElement* fillXml,

  594.                                   const Path& path,

  595.                                   const float opacity) const

  596.     {

  597.         ColourGradient gradient;

  598. 

  599.         addGradientStopsIn (gradient, findLinkedElement (fillXml));

  600.         addGradientStopsIn (gradient, fillXml);

  601. 

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

  603.         {

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

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

  606.         }

  607.         else

  608.         {

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

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

  611.         }

  612. 

  613.         if (opacity < 1.0f)

  614.             gradient.multiplyOpacity (opacity);

  615. 

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

  617. 

  618.         gradient.isRadial = fillXml->hasTagName ("radialGradient");

  619. 

  620.         float gradientWidth = viewBoxW;

  621.         float gradientHeight = viewBoxH;

  622.         float dx = 0.0f;

  623.         float dy = 0.0f;

  624. 

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

  626. 

  627.         if (! userSpace)

  628.         {

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

  630.             dx = bounds.getX();

  631.             dy = bounds.getY();

  632.             gradientWidth = bounds.getWidth();

  633.             gradientHeight = bounds.getHeight();

  634.         }

  635. 

  636.         if (gradient.isRadial)

  637.         {

  638.             if (userSpace)

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

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

  641.             else

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

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

  644. 

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

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

  647. 

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

  649.         }

  650.         else

  651.         {

  652.             if (userSpace)

  653.             {

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

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

  656. 

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

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

  659.             }

  660.             else

  661.             {

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

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

  664. 

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

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

  667.             }

  668. 

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

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

  671.         }

  672. 

  673.         FillType type (gradient);

  674.         type.transform = parseTransform (fillXml->getStringAttribute ("gradientTransform"))

  675.                            .followedBy (transform);

  676.         return type;

  677.     }

  678. 

  679.     FillType getPathFillType (const Path& path,

  680.                               const String& fill,

  681.                               const String& fillOpacity,

  682.                               const String& overallOpacity,

  683.                               const Colour& defaultColour) const

  684.     {

  685.         float opacity = 1.0f;

  686. 

  687.         if (overallOpacity.isNotEmpty())

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

  689. 

  690.         if (fillOpacity.isNotEmpty())

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

  692. 

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

  694.         {

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

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

  697. 

  698.             if (const XmlElement* const fillXml = findElementForId (topLevelXml, id))

  699.                 if (fillXml->hasTagName ("linearGradient") || fillXml->hasTagName ("radialGradient"))

  700.                     return getGradientFillType (fillXml, path, opacity);

  701.         }

  702. 

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

  704.             return Colours::transparentBlack;

  705. 

  706.         int i = 0;

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

  708.     }

  709. 

  710.     PathStrokeType getStrokeFor (const XmlElement* const xml) const

  711.     {

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

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

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

  715. 

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

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

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

  719. 

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

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

  722. 

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

  724.             joinStyle = PathStrokeType::curved;

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

  726.             joinStyle = PathStrokeType::beveled;

  727. 

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

  729.             capStyle = PathStrokeType::rounded;

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

  731.             capStyle = PathStrokeType::square;

  732. 

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

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

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

  736. 

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

  738.                                joinStyle, capStyle);

  739.     }

  740. 

  741.     //==============================================================================

  742.     Drawable* parseText (const XmlElement& xml)

  743.     {

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

  745. 

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

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

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

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

  750. 

  751. 

  752.         //xxx not done text yet!

  753. 

  754. 

  755.         forEachXmlChildElement (xml, e)

  756.         {

  757.             if (e->isTextElement())

  758.             {

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

  760. 

  761.                 Path path;

  762.                 Drawable* s = parseShape (*e, path);

  763.                 delete s;  // xxx not finished!

  764.             }

  765.             else if (e->hasTagName ("tspan"))

  766.             {

  767.                 Drawable* s = parseText (*e);

  768.                 delete s;  // xxx not finished!

  769.             }

  770.         }

  771. 

  772.         return nullptr;

  773.     }

  774. 

  775.     //==============================================================================

  776.     void addTransform (const XmlElement& xml)

  777.     {

  778.         transform = parseTransform (xml.getStringAttribute ("transform"))

  779.                         .followedBy (transform);

  780.     }

  781. 

  782.     //==============================================================================

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

  784.     {

  785.         String number;

  786. 

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

  788.         {

  789.             value = 0;

  790.             return false;

  791.         }

  792. 

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

  794.         return true;

  795.     }

  796. 

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

  798.     {

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

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

  801.     }

  802. 

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

  804.     {

  805.         const bool b = parseCoords (s, p, allowUnits);

  806.         if (! b)

  807.             ++s;

  808. 

  809.         return b;

  810.     }

  811. 

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

  813.     {

  814.         float n = s.getFloatValue();

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

  816. 

  817.         if (len > 2)

  818.         {

  819.             const float dpi = 96.0f;

  820. 

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

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

  823. 

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

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

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

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

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

  829.         }

  830. 

  831.         return n;

  832.     }

  833. 

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

  835.                        const bool allowUnits, const bool isX) const

  836.     {

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

  838.         float value;

  839. 

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

  841.             coords.add (value);

  842.     }

  843. 

  844.     //==============================================================================

  845.     void parseCSSStyle (const XmlElement& xml)

  846.     {

  847.         cssStyleText = xml.getAllSubText() + "\n" + cssStyleText;

  848.     }

  849. 

  850.     String getStyleAttribute (const XmlElement* xml, const String& attributeName,

  851.                               const String& defaultValue = String::empty) const

  852.     {

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

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

  855. 

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

  857. 

  858.         if (styleAtt.isNotEmpty())

  859.         {

  860.             const String value (getAttributeFromStyleList (styleAtt, attributeName, String::empty));

  861. 

  862.             if (value.isNotEmpty())

  863.                 return value;

  864.         }

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

  866.         {

  867.             const String className ("." + xml->getStringAttribute ("class"));

  868. 

  869.             int index = cssStyleText.indexOfIgnoreCase (className + " ");

  870. 

  871.             if (index < 0)

  872.                 index = cssStyleText.indexOfIgnoreCase (className + "{");

  873. 

  874.             if (index >= 0)

  875.             {

  876.                 const int openBracket = cssStyleText.indexOfChar (index, '{');

  877. 

  878.                 if (openBracket > index)

  879.                 {

  880.                     const int closeBracket = cssStyleText.indexOfChar (openBracket, '}');

  881. 

  882.                     if (closeBracket > openBracket)

  883.                     {

  884.                         const String value (getAttributeFromStyleList (cssStyleText.substring (openBracket + 1, closeBracket), attributeName, defaultValue));

  885. 

  886.                         if (value.isNotEmpty())

  887.                             return value;

  888.                     }

  889.                 }

  890.             }

  891.         }

  892. 

  893.         xml = const_cast <XmlElement*> (topLevelXml)->findParentElementOf (xml);

  894. 

  895.         if (xml != nullptr)

  896.             return getStyleAttribute (xml, attributeName, defaultValue);

  897. 

  898.         return defaultValue;

  899.     }

  900. 

  901.     String getInheritedAttribute (const XmlElement* xml, const String& attributeName) const

  902.     {

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

  904.             return xml->getStringAttribute (attributeName);

  905. 

  906.         xml = const_cast <XmlElement*> (topLevelXml)->findParentElementOf (xml);

  907. 

  908.         if (xml != nullptr)

  909.             return getInheritedAttribute  (xml, attributeName);

  910. 

  911.         return String::empty;

  912.     }

  913. 

  914.     //==============================================================================

  915.     static bool isIdentifierChar (const juce_wchar c)

  916.     {

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

  918.     }

  919. 

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

  921.     {

  922.         int i = 0;

  923. 

  924.         for (;;)

  925.         {

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

  927. 

  928.             if (i < 0)

  929.                 break;

  930. 

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

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

  933.             {

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

  935. 

  936.                 if (i < 0)

  937.                     break;

  938. 

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

  940. 

  941.                 if (end < 0)

  942.                     end = 0x7ffff;

  943. 

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

  945.             }

  946. 

  947.             ++i;

  948.         }

  949. 

  950.         return defaultValue;

  951.     }

  952. 

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

  954.     static bool parseNextNumber (String::CharPointerType& s, String& value, const bool allowUnits)

  955.     {

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

  957.             ++s;

  958. 

  959.         String::CharPointerType start (s);

  960.         int numChars = 0;

  961. 

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

  963.         {

  964.             ++numChars;

  965.             ++s;

  966.         }

  967. 

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

  969.         {

  970.             ++numChars;

  971.             ++s;

  972.         }

  973. 

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

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

  976.         {

  977.             s += 2;

  978.             numChars += 2;

  979. 

  980.             while (s.isDigit())

  981.             {

  982.                 ++numChars;

  983.                 ++s;

  984.             }

  985.         }

  986. 

  987.         if (allowUnits)

  988.         {

  989.             while (s.isLetter())

  990.             {

  991.                 ++numChars;

  992.                 ++s;

  993.             }

  994.         }

  995. 

  996.         if (numChars == 0)

  997.             return false;

  998. 

  999.         value = String (start, (size_t) numChars);

  1000. 

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

  1002.             ++s;

  1003. 

  1004.         return true;

  1005.     }

  1006. 

  1007.     //==============================================================================

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

  1009.     {

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

  1011.         {

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

  1013.             int numChars = 0;

  1014. 

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

  1016.             {

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

  1018. 

  1019.                 if (hexValue >= 0)

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

  1021.                 else

  1022.                     break;

  1023.             }

  1024. 

  1025.             if (numChars <= 3)

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

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

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

  1029.             else

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

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

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

  1033.         }

  1034.         else if (s [index] == 'r'

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

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

  1037.         {

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

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

  1040. 

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

  1042.             {

  1043.                 index = closeBracket;

  1044. 

  1045.                 StringArray tokens;

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

  1047.                 tokens.trim();

  1048.                 tokens.removeEmptyStrings();

  1049. 

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

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

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

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

  1054.                 else

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

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

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

  1058.             }

  1059.         }

  1060. 

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

  1062.     }

  1063. 

  1064.     static const AffineTransform parseTransform (String t)

  1065.     {

  1066.         AffineTransform result;

  1067. 

  1068.         while (t.isNotEmpty())

  1069.         {

  1070.             StringArray tokens;

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

  1072.                                .upToFirstOccurrenceOf (")", false, false),

  1073.                               ", ", String::empty);

  1074. 

  1075.             tokens.removeEmptyStrings (true);

  1076. 

  1077.             float numbers [6];

  1078. 

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

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

  1081. 

  1082.             AffineTransform trans;

  1083. 

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

  1085.             {

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

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

  1088.             }

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

  1090.             {

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

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

  1093.             }

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

  1095.             {

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

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

  1098.                 else

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

  1100.             }

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

  1102.             {

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

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

  1105.                 else

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

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

  1108.             }

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

  1110.             {

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

  1112.                                          0.0f, 1.0f, 0.0f);

  1113.             }

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

  1115.             {

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

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

  1118.             }

  1119. 

  1120.             result = trans.followedBy (result);

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

  1122.         }

  1123. 

  1124.         return result;

  1125.     }

  1126. 

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

  1128.                                             const double x2, const double y2,

  1129.                                             const double angle,

  1130.                                             const bool largeArc, const bool sweep,

  1131.                                             double& rx, double& ry,

  1132.                                             double& centreX, double& centreY,

  1133.                                             double& startAngle, double& deltaAngle)

  1134.     {

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

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

  1137. 

  1138.         const double cosAngle = cos (angle);

  1139.         const double sinAngle = sin (angle);

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

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

  1142.         const double xp2 = xp * xp;

  1143.         const double yp2 = yp * yp;

  1144. 

  1145.         double rx2 = rx * rx;

  1146.         double ry2 = ry * ry;

  1147. 

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

  1149.         double c;

  1150. 

  1151.         if (s <= 1.0)

  1152.         {

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

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

  1155. 

  1156.             if (largeArc == sweep)

  1157.                 c = -c;

  1158.         }

  1159.         else

  1160.         {

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

  1162.             rx *= s2;

  1163.             ry *= s2;

  1164.             rx2 = rx * rx;

  1165.             ry2 = ry * ry;

  1166.             c = 0;

  1167.         }

  1168. 

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

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

  1171. 

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

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

  1174. 

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

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

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

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

  1179. 

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

  1181. 

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

  1183. 

  1184.         if (uy < 0)

  1185.             startAngle = -startAngle;

  1186. 

  1187.         startAngle += double_Pi * 0.5;

  1188. 

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

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

  1191. 

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

  1193.             deltaAngle = -deltaAngle;

  1194. 

  1195.         if (sweep)

  1196.         {

  1197.             if (deltaAngle < 0)

  1198.                 deltaAngle += double_Pi * 2.0;

  1199.         }

  1200.         else

  1201.         {

  1202.             if (deltaAngle > 0)

  1203.                 deltaAngle -= double_Pi * 2.0;

  1204.         }

  1205. 

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

  1207.     }

  1208. 

  1209.     static const XmlElement* findElementForId (const XmlElement* const parent, const String& id)

  1210.     {

  1211.         forEachXmlChildElement (*parent, e)

  1212.         {

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

  1214.                 return e;

  1215. 

  1216.             if (const XmlElement* const found = findElementForId (e, id))

  1217.                 return found;

  1218.         }

  1219. 

  1220.         return nullptr;

  1221.     }

  1222. 

  1223.     SVGState& operator= (const SVGState&);

  1224. };

  1225. 

  1226. 

  1227. //==============================================================================

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

  1229. {

  1230.     SVGState state (&svgDocument);

  1231.     return state.parseSVGElement (svgDocument);

  1232. }