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.
7685 Commits
9 Branches
4.5GB
Tree: c55e73a50e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c55e73a50e'
${ noResults }
JUCE/extras/Projucer/Source/ComponentEditor/paintelements/jucer_PaintElementPath.cpp

1638 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. #include "../../jucer_Headers.h"

  28. #include "jucer_PaintElementPath.h"

  29. #include "../properties/jucer_PositionPropertyBase.h"

  30. #include "jucer_PaintElementUndoableAction.h"

  31. #include "../jucer_UtilityFunctions.h"

  32. 

  33. //==============================================================================

  34. class ChangePointAction     : public PaintElementUndoableAction <PaintElementPath>

  35. {

  36. public:

  37.     ChangePointAction (PathPoint* const point,

  38.                        const int pointIndex,

  39.                        const PathPoint& newValue_)

  40.         : PaintElementUndoableAction <PaintElementPath> (point->owner),

  41.           index (pointIndex),

  42.           newValue (newValue_),

  43.           oldValue (*point)

  44.     {

  45.     }

  46. 

  47.     ChangePointAction (PathPoint* const point,

  48.                        const PathPoint& newValue_)

  49.         : PaintElementUndoableAction <PaintElementPath> (point->owner),

  50.           index (point->owner->indexOfPoint (point)),

  51.           newValue (newValue_),

  52.           oldValue (*point)

  53.     {

  54.     }

  55. 

  56.     bool perform()

  57.     {

  58.         return changeTo (newValue);

  59.     }

  60. 

  61.     bool undo()

  62.     {

  63.         return changeTo (oldValue);

  64.     }

  65. 

  66. private:

  67.     const int index;

  68.     PathPoint newValue, oldValue;

  69. 

  70.     PathPoint* getPoint() const

  71.     {

  72.         PathPoint* p = getElement()->getPoint (index);

  73.         jassert (p != nullptr);

  74.         return p;

  75.     }

  76. 

  77.     bool changeTo (const PathPoint& value) const

  78.     {

  79.         showCorrectTab();

  80. 

  81.         PaintElementPath* const path = getElement();

  82.         jassert (path != nullptr);

  83. 

  84.         PathPoint* const p = path->getPoint (index);

  85.         jassert (p != nullptr);

  86. 

  87.         const bool typeChanged = (p->type != value.type);

  88.         *p = value;

  89.         p->owner = path;

  90. 

  91.         if (typeChanged)

  92.             path->pointListChanged();

  93. 

  94.         path->changed();

  95.         return true;

  96.     }

  97. };

  98. 

  99. 

  100. //==============================================================================

  101. class PathWindingModeProperty    : public ChoicePropertyComponent,

  102.                                    public ChangeListener

  103. {

  104. public:

  105.     PathWindingModeProperty (PaintElementPath* const owner_)

  106.         : ChoicePropertyComponent ("winding rule"),

  107.           owner (owner_)

  108.     {

  109.         choices.add ("Non-zero winding");

  110.         choices.add ("Even/odd winding");

  111. 

  112.         owner->getDocument()->addChangeListener (this);

  113.     }

  114. 

  115.     ~PathWindingModeProperty()

  116.     {

  117.         owner->getDocument()->removeChangeListener (this);

  118.     }

  119. 

  120.     void setIndex (int newIndex)            { owner->setNonZeroWinding (newIndex == 0, true); }

  121.     int getIndex() const                    { return owner->isNonZeroWinding() ? 0 : 1; }

  122. 

  123.     void changeListenerCallback (ChangeBroadcaster*)     { refresh(); }

  124. 

  125. private:

  126.     PaintElementPath* const owner;

  127. };

  128. 

  129. 

  130. //==============================================================================

  131. PaintElementPath::PaintElementPath (PaintRoutine* pr)

  132.     : ColouredElement (pr, "Path", true, true),

  133.       nonZeroWinding (true)

  134. {

  135. }

  136. 

  137. PaintElementPath::~PaintElementPath()

  138. {

  139. }

  140. 

  141. static int randomPos (int size)

  142. {

  143.     return size / 4 + Random::getSystemRandom().nextInt (size / 4) - size / 8;

  144. }

  145. 

  146. void PaintElementPath::setInitialBounds (int w, int h)

  147. {

  148.     String s;

  149. 

  150.     int x = randomPos (w);

  151.     int y = randomPos (h);

  152. 

  153.     s << "s "

  154.       << x << " " << y << " l "

  155.       << (x + 30) << " " << (y + 50) << " l "

  156.       << (x - 30) << " " << (y + 50) << " x";

  157. 

  158.     restorePathFromString (s);

  159. }

  160. 

  161. //==============================================================================

  162. int PaintElementPath::getBorderSize() const

  163. {

  164.     return isStrokePresent ? 1 + roundFloatToInt (strokeType.stroke.getStrokeThickness())

  165.                            : 0;

  166. }

  167. 

  168. Rectangle<int> PaintElementPath::getCurrentBounds (const Rectangle<int>& parentArea) const

  169. {

  170.     updateStoredPath (getDocument()->getComponentLayout(), parentArea);

  171. 

  172.     Rectangle<float> r (path.getBounds());

  173. 

  174.     const int borderSize = getBorderSize();

  175. 

  176.     return Rectangle<int> ((int) r.getX() - borderSize,

  177.                            (int) r.getY() - borderSize,

  178.                            (int) r.getWidth() + borderSize * 2,

  179.                            (int) r.getHeight() + borderSize * 2);

  180. }

  181. 

  182. void PaintElementPath::setCurrentBounds (const Rectangle<int>& b,

  183.                                          const Rectangle<int>& parentArea,

  184.                                          const bool /*undoable*/)

  185. {

  186.     Rectangle<int> newBounds (b);

  187.     newBounds.setSize (jmax (1, newBounds.getWidth()),

  188.                        jmax (1, newBounds.getHeight()));

  189. 

  190.     const Rectangle<int> current (getCurrentBounds (parentArea));

  191. 

  192.     if (newBounds != current)

  193.     {

  194.         const int borderSize = getBorderSize();

  195. 

  196.         const int dx = newBounds.getX() - current.getX();

  197.         const int dy = newBounds.getY() - current.getY();

  198. 

  199.         const double scaleStartX = current.getX() + borderSize;

  200.         const double scaleStartY = current.getY() + borderSize;

  201.         const double scaleX = (newBounds.getWidth() - borderSize * 2) / (double) (current.getWidth() - borderSize * 2);

  202.         const double scaleY = (newBounds.getHeight() - borderSize * 2) / (double) (current.getHeight() - borderSize * 2);

  203. 

  204.         for (int i = 0; i < points.size(); ++i)

  205.         {

  206.             PathPoint* const destPoint = points.getUnchecked(i);

  207.             PathPoint p (*destPoint);

  208. 

  209.             for (int j = p.getNumPoints(); --j >= 0;)

  210.                 rescalePoint (p.pos[j], dx, dy,

  211.                               scaleX, scaleY,

  212.                               scaleStartX, scaleStartY,

  213.                               parentArea);

  214. 

  215.             perform (new ChangePointAction (destPoint, i, p), "Move path");

  216.         }

  217.     }

  218. }

  219. 

  220. void PaintElementPath::rescalePoint (RelativePositionedRectangle& pos, int dx, int dy,

  221.                                      double scaleX, double scaleY,

  222.                                      double scaleStartX, double scaleStartY,

  223.                                      const Rectangle<int>& parentArea) const

  224. {

  225.     double x, y, w, h;

  226.     pos.getRectangleDouble (x, y, w, h, parentArea, getDocument()->getComponentLayout());

  227. 

  228.     x = (x - scaleStartX) * scaleX + scaleStartX + dx;

  229.     y = (y - scaleStartY) * scaleY + scaleStartY + dy;

  230. 

  231.     pos.updateFrom (x, y, w, h, parentArea, getDocument()->getComponentLayout());

  232. }

  233. 

  234. //==============================================================================

  235. static void drawArrow (Graphics& g, const Point<float> p1, const Point<float> p2)

  236. {

  237.     g.drawArrow (Line<float> (p1.x, p1.y, (p1.x + p2.x) * 0.5f, (p1.y + p2.y) * 0.5f), 1.0f, 8.0f, 10.0f);

  238.     g.drawLine (p1.x + (p2.x - p1.x) * 0.49f, p1.y + (p2.y - p1.y) * 0.49f, p2.x, p2.y);

  239. }

  240. 

  241. void PaintElementPath::draw (Graphics& g, const ComponentLayout* layout, const Rectangle<int>& parentArea)

  242. {

  243.     updateStoredPath (layout, parentArea);

  244.     path.setUsingNonZeroWinding (nonZeroWinding);

  245. 

  246.     fillType.setFillType (g, getDocument(), parentArea);

  247.     g.fillPath (path);

  248. 

  249.     if (isStrokePresent)

  250.     {

  251.         strokeType.fill.setFillType (g, getDocument(), parentArea);

  252.         g.strokePath (path, getStrokeType().stroke);

  253.     }

  254. }

  255. 

  256. void PaintElementPath::drawExtraEditorGraphics (Graphics& g, const Rectangle<int>& relativeTo)

  257. {

  258.     ComponentLayout* layout = getDocument()->getComponentLayout();

  259. 

  260.     for (int i = 0; i < points.size(); ++i)

  261.     {

  262.         PathPoint* const p = points.getUnchecked (i);

  263. 

  264.         const int numPoints = p->getNumPoints();

  265. 

  266.         if (numPoints > 0)

  267.         {

  268.             if (owner->getSelectedPoints().isSelected (p))

  269.             {

  270.                 g.setColour (Colours::red);

  271.                 Point<float> p1, p2;

  272. 

  273.                 if (numPoints > 2)

  274.                 {

  275.                     p1 = p->pos[1].toXY (relativeTo, layout);

  276.                     p2 = p->pos[2].toXY (relativeTo, layout);

  277.                     drawArrow (g, p1, p2);

  278.                 }

  279. 

  280.                 if (numPoints > 1)

  281.                 {

  282.                     p1 = p->pos[0].toXY (relativeTo, layout);

  283.                     p2 = p->pos[1].toXY (relativeTo, layout);

  284.                     drawArrow (g, p1, p2);

  285.                 }

  286. 

  287.                 p2 = p->pos[0].toXY (relativeTo, layout);

  288. 

  289.                 if (const PathPoint* const nextPoint = points [i - 1])

  290.                 {

  291.                     p1 = nextPoint->pos [nextPoint->getNumPoints() - 1].toXY (relativeTo, layout);

  292.                     drawArrow (g, p1, p2);

  293.                 }

  294.             }

  295.         }

  296.     }

  297. }

  298. 

  299. void PaintElementPath::resized()

  300. {

  301.     ColouredElement::resized();

  302. }

  303. 

  304. void PaintElementPath::parentSizeChanged()

  305. {

  306.     repaint();

  307. }

  308. 

  309. //==============================================================================

  310. void PaintElementPath::mouseDown (const MouseEvent& e)

  311. {

  312.     if (e.mods.isPopupMenu() || ! owner->getSelectedElements().isSelected (this))

  313.         mouseDownOnSegment = -1;

  314.     else

  315.         mouseDownOnSegment = findSegmentAtXY (getX() + e.x, getY() + e.y);

  316. 

  317.     if (points [mouseDownOnSegment] != nullptr)

  318.         mouseDownSelectSegmentStatus = owner->getSelectedPoints().addToSelectionOnMouseDown (points [mouseDownOnSegment], e.mods);

  319.     else

  320.         ColouredElement::mouseDown (e);

  321. }

  322. 

  323. void PaintElementPath::mouseDrag (const MouseEvent& e)

  324. {

  325.     if (mouseDownOnSegment < 0)

  326.         ColouredElement::mouseDrag (e);

  327. }

  328. 

  329. void PaintElementPath::mouseUp (const MouseEvent& e)

  330. {

  331.     if (points [mouseDownOnSegment] == 0)

  332.         ColouredElement::mouseUp (e);

  333.     else

  334.         owner->getSelectedPoints().addToSelectionOnMouseUp (points [mouseDownOnSegment],

  335.                                                             e.mods, false, mouseDownSelectSegmentStatus);

  336. }

  337. 

  338. //==============================================================================

  339. void PaintElementPath::changed()

  340. {

  341.     ColouredElement::changed();

  342.     lastPathBounds = Rectangle<int>();

  343. }

  344. 

  345. void PaintElementPath::pointListChanged()

  346. {

  347.     changed();

  348.     siblingComponentsChanged();

  349. }

  350. 

  351. //==============================================================================

  352. void PaintElementPath::getEditableProperties (Array <PropertyComponent*>& props)

  353. {

  354.     props.add (new PathWindingModeProperty (this));

  355.     getColourSpecificProperties (props);

  356. }

  357. 

  358. //==============================================================================

  359. static String positionToPairOfValues (const RelativePositionedRectangle& position,

  360.                                       const ComponentLayout* layout)

  361. {

  362.     String x, y, w, h;

  363.     positionToCode (position, layout, x, y, w, h);

  364.     return castToFloat (x) + ", " + castToFloat (y);

  365. }

  366. 

  367. void PaintElementPath::fillInGeneratedCode (GeneratedCode& code, String& paintMethodCode)

  368. {

  369.     if (fillType.isInvisible() && (strokeType.isInvisible() || ! isStrokePresent))

  370.         return;

  371. 

  372.     const String pathVariable ("internalPath" + String (code.getUniqueSuffix()));

  373. 

  374.     const ComponentLayout* layout = code.document->getComponentLayout();

  375. 

  376.     code.privateMemberDeclarations

  377.         << "Path " << pathVariable << ";\n";

  378. 

  379.     String r;

  380.     bool somePointsAreRelative = false;

  381. 

  382.     if (! nonZeroWinding)

  383.         r << pathVariable << ".setUsingNonZeroWinding (false);\n";

  384. 

  385.     for (auto* p : points)

  386.     {

  387.         switch (p->type)

  388.         {

  389.         case Path::Iterator::startNewSubPath:

  390.             r << pathVariable << ".startNewSubPath (" << positionToPairOfValues (p->pos[0], layout) << ");\n";

  391.             somePointsAreRelative = somePointsAreRelative || ! p->pos[0].rect.isPositionAbsolute();

  392.             break;

  393. 

  394.         case Path::Iterator::lineTo:

  395.             r << pathVariable << ".lineTo (" << positionToPairOfValues (p->pos[0], layout) << ");\n";

  396.             somePointsAreRelative = somePointsAreRelative || ! p->pos[0].rect.isPositionAbsolute();

  397.             break;

  398. 

  399.         case Path::Iterator::quadraticTo:

  400.             r << pathVariable << ".quadraticTo (" << positionToPairOfValues (p->pos[0], layout)

  401.               << ", " << positionToPairOfValues (p->pos[1], layout) << ");\n";

  402. 

  403.             somePointsAreRelative = somePointsAreRelative || ! p->pos[0].rect.isPositionAbsolute();

  404.             somePointsAreRelative = somePointsAreRelative || ! p->pos[1].rect.isPositionAbsolute();

  405.             break;

  406. 

  407.         case Path::Iterator::cubicTo:

  408.             r << pathVariable << ".cubicTo (" << positionToPairOfValues (p->pos[0], layout)

  409.               << ", " << positionToPairOfValues (p->pos[1], layout)

  410.               << ", " << positionToPairOfValues (p->pos[2], layout) << ");\n";

  411. 

  412.             somePointsAreRelative = somePointsAreRelative || ! p->pos[0].rect.isPositionAbsolute();

  413.             somePointsAreRelative = somePointsAreRelative || ! p->pos[1].rect.isPositionAbsolute();

  414.             somePointsAreRelative = somePointsAreRelative || ! p->pos[2].rect.isPositionAbsolute();

  415.             break;

  416. 

  417.         case Path::Iterator::closePath:

  418.             r << pathVariable << ".closeSubPath();\n";

  419.             break;

  420. 

  421.         default:

  422.             jassertfalse;

  423.             break;

  424.         }

  425.     }

  426. 

  427.     r << '\n';

  428. 

  429.     if (somePointsAreRelative)

  430.         code.getCallbackCode (String(), "void", "resized()", false)

  431.             << pathVariable << ".clear();\n" << r;

  432.     else

  433.         code.constructorCode << r;

  434. 

  435.     String s;

  436.     s << "{\n"

  437.       << "    float x = 0, y = 0;\n";

  438. 

  439.     if (! fillType.isInvisible())

  440.         s << "    " << fillType.generateVariablesCode ("fill");

  441. 

  442.     if (isStrokePresent && ! strokeType.isInvisible())

  443.         s << "    " << strokeType.fill.generateVariablesCode ("stroke");

  444. 

  445.     s << "    //[UserPaintCustomArguments] Customize the painting arguments here..\n"

  446.       << customPaintCode

  447.       << "    //[/UserPaintCustomArguments]\n";

  448. 

  449.     RelativePositionedRectangle zero;

  450. 

  451.     if (! fillType.isInvisible())

  452.     {

  453.         s << "    ";

  454.         fillType.fillInGeneratedCode ("fill", zero, code, s);

  455.         s << "    g.fillPath (" << pathVariable << ", AffineTransform::translation(x, y));\n";

  456.     }

  457. 

  458.     if (isStrokePresent && ! strokeType.isInvisible())

  459.     {

  460.         s << "    ";

  461.         strokeType.fill.fillInGeneratedCode ("stroke", zero, code, s);

  462.         s << "    g.strokePath (" << pathVariable << ", " << strokeType.getPathStrokeCode() << ", AffineTransform::translation(x, y));\n";

  463.     }

  464. 

  465.     s << "}\n\n";

  466. 

  467.     paintMethodCode += s;

  468. }

  469. 

  470. void PaintElementPath::applyCustomPaintSnippets (StringArray& snippets)

  471. {

  472.     customPaintCode.clear();

  473. 

  474.     if (! snippets.isEmpty() && (! fillType.isInvisible() || (isStrokePresent && ! strokeType.isInvisible())))

  475.     {

  476.         customPaintCode = snippets[0];

  477.         snippets.remove(0);

  478.     }

  479. }

  480. 

  481. //==============================================================================

  482. XmlElement* PaintElementPath::createXml() const

  483. {

  484.     XmlElement* e = new XmlElement (getTagName());

  485.     position.applyToXml (*e);

  486.     addColourAttributes (e);

  487.     e->setAttribute ("nonZeroWinding", nonZeroWinding);

  488.     e->addTextElement (pathToString());

  489. 

  490.     return e;

  491. }

  492. 

  493. bool PaintElementPath::loadFromXml (const XmlElement& xml)

  494. {

  495.     if (xml.hasTagName (getTagName()))

  496.     {

  497.         position.restoreFromXml (xml, position);

  498.         loadColourAttributes (xml);

  499.         nonZeroWinding = xml.getBoolAttribute ("nonZeroWinding", true);

  500. 

  501.         restorePathFromString (xml.getAllSubText().trim());

  502. 

  503.         return true;

  504.     }

  505. 

  506.     jassertfalse;

  507.     return false;

  508. }

  509. 

  510. //==============================================================================

  511. void PaintElementPath::createSiblingComponents()

  512. {

  513.     ColouredElement::createSiblingComponents();

  514. 

  515.     for (int i = 0; i < points.size(); ++i)

  516.     {

  517.         switch (points.getUnchecked(i)->type)

  518.         {

  519.             case Path::Iterator::startNewSubPath:

  520.                 siblingComponents.add (new PathPointComponent (this, i, 0));

  521.                 break;

  522.             case Path::Iterator::lineTo:

  523.                 siblingComponents.add (new PathPointComponent (this, i, 0));

  524.                 break;

  525.             case Path::Iterator::quadraticTo:

  526.                 siblingComponents.add (new PathPointComponent (this, i, 0));

  527.                 siblingComponents.add (new PathPointComponent (this, i, 1));

  528.                 break;

  529.             case Path::Iterator::cubicTo:

  530.                 siblingComponents.add (new PathPointComponent (this, i, 0));

  531.                 siblingComponents.add (new PathPointComponent (this, i, 1));

  532.                 siblingComponents.add (new PathPointComponent (this, i, 2));

  533.                 break;

  534.             case Path::Iterator::closePath:

  535.                 break;

  536. 

  537.             default:

  538.                 jassertfalse; break;

  539.         }

  540.     }

  541. 

  542.     for (int i = 0; i < siblingComponents.size(); ++i)

  543.     {

  544.         getParentComponent()->addAndMakeVisible (siblingComponents.getUnchecked(i));

  545.         siblingComponents.getUnchecked(i)->updatePosition();

  546.     }

  547. }

  548. 

  549. 

  550. String PaintElementPath::pathToString() const

  551. {

  552.     String s;

  553. 

  554.     for (int i = 0; i < points.size(); ++i)

  555.     {

  556.         const PathPoint* const p = points.getUnchecked(i);

  557. 

  558.         switch (p->type)

  559.         {

  560.             case Path::Iterator::startNewSubPath:

  561.                 s << "s " << p->pos[0].toString() << ' ';

  562.                 break;

  563.             case Path::Iterator::lineTo:

  564.                 s << "l " << p->pos[0].toString() << ' ';

  565.                 break;

  566.             case Path::Iterator::quadraticTo:

  567.                 s << "q " << p->pos[0].toString()

  568.                   << ' '  << p->pos[1].toString() << ' ';

  569.                 break;

  570.             case Path::Iterator::cubicTo:

  571.                 s << "c " << p->pos[0].toString()

  572.                   << ' '  << p->pos[1].toString() << ' '

  573.                   << ' '  << p->pos[2].toString() << ' ';

  574.                 break;

  575.             case Path::Iterator::closePath:

  576.                 s << "x ";

  577.                 break;

  578. 

  579.             default:

  580.                 jassertfalse; break;

  581.         }

  582.     }

  583. 

  584.     return s.trimEnd();

  585. }

  586. 

  587. void PaintElementPath::restorePathFromString (const String& s)

  588. {

  589.     points.clear();

  590. 

  591.     StringArray tokens;

  592.     tokens.addTokens (s, false);

  593.     tokens.trim();

  594.     tokens.removeEmptyStrings();

  595. 

  596.     for (int i = 0; i < tokens.size(); ++i)

  597.     {

  598.         ScopedPointer<PathPoint> p (new PathPoint (this));

  599. 

  600.         if (tokens[i] == "s")

  601.         {

  602.             p->type = Path::Iterator::startNewSubPath;

  603.             p->pos [0] = RelativePositionedRectangle();

  604.             p->pos [0].rect = PositionedRectangle (tokens [i + 1] + " " + tokens [i + 2]);

  605.             i += 2;

  606.         }

  607.         else if (tokens[i] == "l")

  608.         {

  609.             p->type = Path::Iterator::lineTo;

  610.             p->pos [0] = RelativePositionedRectangle();

  611.             p->pos [0].rect = PositionedRectangle (tokens [i + 1] + " " + tokens [i + 2]);

  612.             i += 2;

  613.         }

  614.         else if (tokens[i] == "q")

  615.         {

  616.             p->type = Path::Iterator::quadraticTo;

  617.             p->pos [0] = RelativePositionedRectangle();

  618.             p->pos [0].rect = PositionedRectangle (tokens [i + 1] + " " + tokens [i + 2]);

  619.             p->pos [1] = RelativePositionedRectangle();

  620.             p->pos [1].rect = PositionedRectangle (tokens [i + 3] + " " + tokens [i + 4]);

  621.             i += 4;

  622.         }

  623.         else if (tokens[i] == "c")

  624.         {

  625.             p->type = Path::Iterator::cubicTo;

  626.             p->pos [0] = RelativePositionedRectangle();

  627.             p->pos [0].rect = PositionedRectangle (tokens [i + 1] + " " + tokens [i + 2]);

  628.             p->pos [1] = RelativePositionedRectangle();

  629.             p->pos [1].rect = PositionedRectangle (tokens [i + 3] + " " + tokens [i + 4]);

  630.             p->pos [2] = RelativePositionedRectangle();

  631.             p->pos [2].rect = PositionedRectangle (tokens [i + 5] + " " + tokens [i + 6]);

  632.             i += 6;

  633.         }

  634.         else if (tokens[i] == "x")

  635.         {

  636.             p->type = Path::Iterator::closePath;

  637.         }

  638.         else

  639.             continue;

  640. 

  641.         points.add (p.release());

  642.     }

  643. }

  644. 

  645. void PaintElementPath::setToPath (const Path& newPath)

  646. {

  647.     points.clear();

  648. 

  649.     Path::Iterator i (newPath);

  650. 

  651.     while (i.next())

  652.     {

  653.         ScopedPointer<PathPoint> p (new PathPoint (this));

  654.         p->type = i.elementType;

  655. 

  656.         if (i.elementType == Path::Iterator::startNewSubPath)

  657.         {

  658.             p->pos [0].rect.setX (i.x1);

  659.             p->pos [0].rect.setY (i.y1);

  660.         }

  661.         else if (i.elementType == Path::Iterator::lineTo)

  662.         {

  663.             p->pos [0].rect.setX (i.x1);

  664.             p->pos [0].rect.setY (i.y1);

  665.         }

  666.         else if (i.elementType == Path::Iterator::quadraticTo)

  667.         {

  668.             p->pos [0].rect.setX (i.x1);

  669.             p->pos [0].rect.setY (i.y1);

  670.             p->pos [1].rect.setX (i.x2);

  671.             p->pos [1].rect.setY (i.y2);

  672.         }

  673.         else if (i.elementType == Path::Iterator::cubicTo)

  674.         {

  675.             p->pos [0].rect.setX (i.x1);

  676.             p->pos [0].rect.setY (i.y1);

  677.             p->pos [1].rect.setX (i.x2);

  678.             p->pos [1].rect.setY (i.y2);

  679.             p->pos [2].rect.setX (i.x3);

  680.             p->pos [2].rect.setY (i.y3);

  681.         }

  682.         else if (i.elementType == Path::Iterator::closePath)

  683.         {

  684.         }

  685.         else

  686.         {

  687.             continue;

  688.         }

  689. 

  690.         points.add (p.release());

  691.     }

  692. }

  693. 

  694. void PaintElementPath::updateStoredPath (const ComponentLayout* layout, const Rectangle<int>& relativeTo) const

  695. {

  696.     if (lastPathBounds != relativeTo && ! relativeTo.isEmpty())

  697.     {

  698.         lastPathBounds = relativeTo;

  699.         path.clear();

  700. 

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

  702.         {

  703.             const PathPoint* const p = points.getUnchecked(i);

  704. 

  705.             switch (p->type)

  706.             {

  707.                 case Path::Iterator::startNewSubPath:

  708.                     path.startNewSubPath (p->pos[0].toXY (relativeTo, layout));

  709.                     break;

  710. 

  711.                 case Path::Iterator::lineTo:

  712.                     path.lineTo (p->pos[0].toXY (relativeTo, layout));

  713.                     break;

  714. 

  715.                 case Path::Iterator::quadraticTo:

  716.                     path.quadraticTo (p->pos[0].toXY (relativeTo, layout),

  717.                                       p->pos[1].toXY (relativeTo, layout));

  718.                     break;

  719. 

  720.                 case Path::Iterator::cubicTo:

  721.                     path.cubicTo (p->pos[0].toXY (relativeTo, layout),

  722.                                   p->pos[1].toXY (relativeTo, layout),

  723.                                   p->pos[2].toXY (relativeTo, layout));

  724.                     break;

  725. 

  726.                 case Path::Iterator::closePath:

  727.                     path.closeSubPath();

  728.                     break;

  729. 

  730.                 default:

  731.                     jassertfalse; break;

  732.             }

  733.         }

  734.     }

  735. }

  736. 

  737. //==============================================================================

  738. class ChangeWindingAction     : public PaintElementUndoableAction <PaintElementPath>

  739. {

  740. public:

  741.     ChangeWindingAction (PaintElementPath* const path, const bool newValue_)

  742.         : PaintElementUndoableAction <PaintElementPath> (path),

  743.           newValue (newValue_),

  744.           oldValue (path->isNonZeroWinding())

  745.     {

  746.     }

  747. 

  748.     bool perform()

  749.     {

  750.         showCorrectTab();

  751.         getElement()->setNonZeroWinding (newValue, false);

  752.         return true;

  753.     }

  754. 

  755.     bool undo()

  756.     {

  757.         showCorrectTab();

  758.         getElement()->setNonZeroWinding (oldValue, false);

  759.         return true;

  760.     }

  761. 

  762. private:

  763.     bool newValue, oldValue;

  764. };

  765. 

  766. void PaintElementPath::setNonZeroWinding (const bool nonZero, const bool undoable)

  767. {

  768.     if (nonZero != nonZeroWinding)

  769.     {

  770.         if (undoable)

  771.         {

  772.             perform (new ChangeWindingAction (this, nonZero), "Change path winding rule");

  773.         }

  774.         else

  775.         {

  776.             nonZeroWinding = nonZero;

  777.             changed();

  778.         }

  779.     }

  780. }

  781. 

  782. bool PaintElementPath::isSubpathClosed (int index) const

  783. {

  784.     for (int i = index + 1; i < points.size(); ++i)

  785.     {

  786.         if (points.getUnchecked (i)->type == Path::Iterator::closePath)

  787.             return true;

  788. 

  789.         if (points.getUnchecked (i)->type == Path::Iterator::startNewSubPath)

  790.             break;

  791.     }

  792. 

  793.     return false;

  794. }

  795. 

  796. //==============================================================================

  797. void PaintElementPath::setSubpathClosed (int index, const bool closed, const bool undoable)

  798. {

  799.     if (closed != isSubpathClosed (index))

  800.     {

  801.         for (int i = index + 1; i < points.size(); ++i)

  802.         {

  803.             PathPoint* p = points.getUnchecked (i);

  804. 

  805.             if (p->type == Path::Iterator::closePath)

  806.             {

  807.                 jassert (! closed);

  808. 

  809.                 deletePoint (i, undoable);

  810.                 return;

  811.             }

  812. 

  813.             if (p->type == Path::Iterator::startNewSubPath)

  814.             {

  815.                 jassert (closed);

  816. 

  817.                 PathPoint* pp = addPoint (i - 1, undoable);

  818. 

  819.                 PathPoint p2 (*pp);

  820.                 p2.type = Path::Iterator::closePath;

  821.                 perform (new ChangePointAction (pp, p2), "Close subpath");

  822.                 return;

  823.             }

  824.         }

  825. 

  826.         jassert (closed);

  827. 

  828.         PathPoint* p = addPoint (points.size() - 1, undoable);

  829.         PathPoint p2 (*p);

  830.         p2.type = Path::Iterator::closePath;

  831.         perform (new ChangePointAction (p, p2), "Close subpath");

  832.     }

  833. }

  834. 

  835. //==============================================================================

  836. class AddPointAction   : public PaintElementUndoableAction <PaintElementPath>

  837. {

  838. public:

  839.     AddPointAction (PaintElementPath* path, int pointIndexToAddItAfter_)

  840.         : PaintElementUndoableAction <PaintElementPath> (path),

  841.           indexAdded (-1),

  842.           pointIndexToAddItAfter (pointIndexToAddItAfter_)

  843.     {

  844.     }

  845. 

  846.     bool perform()

  847.     {

  848.         showCorrectTab();

  849. 

  850.         PaintElementPath* const path = getElement();

  851.         jassert (path != nullptr);

  852. 

  853.         PathPoint* const p = path->addPoint (pointIndexToAddItAfter, false);

  854.         jassert (p != nullptr);

  855. 

  856.         indexAdded = path->indexOfPoint (p);

  857.         jassert (indexAdded >= 0);

  858.         return true;

  859.     }

  860. 

  861.     bool undo()

  862.     {

  863.         showCorrectTab();

  864. 

  865.         PaintElementPath* const path = getElement();

  866.         jassert (path != nullptr);

  867. 

  868.         path->deletePoint (indexAdded, false);

  869.         return true;

  870.     }

  871. 

  872.     int indexAdded;

  873. 

  874. private:

  875.     int pointIndexToAddItAfter;

  876. };

  877. 

  878. PathPoint* PaintElementPath::addPoint (int pointIndexToAddItAfter, const bool undoable)

  879. {

  880.     if (undoable)

  881.     {

  882.         AddPointAction* action = new AddPointAction (this, pointIndexToAddItAfter);

  883.         perform (action, "Add path point");

  884.         return points [action->indexAdded];

  885.     }

  886. 

  887.     double x1 = 20.0, y1 = 20.0, x2, y2;

  888. 

  889.     ComponentLayout* layout = getDocument()->getComponentLayout();

  890.     const Rectangle<int> area (((PaintRoutineEditor*) getParentComponent())->getComponentArea());

  891. 

  892.     if (points [pointIndexToAddItAfter] != nullptr)

  893.         points [pointIndexToAddItAfter]->pos [points [pointIndexToAddItAfter]->getNumPoints() - 1].getXY (x1, y1, area, layout);

  894.     else if (points[0] != nullptr)

  895.         points[0]->pos[0].getXY (x1, y1, area, layout);

  896. 

  897.     x2 = x1 + 50.0;

  898.     y2 = y1 + 50.0;

  899. 

  900.     if (points [pointIndexToAddItAfter + 1] != nullptr)

  901.     {

  902.         if (points [pointIndexToAddItAfter + 1]->type == Path::Iterator::closePath

  903.              || points [pointIndexToAddItAfter + 1]->type == Path::Iterator::startNewSubPath)

  904.         {

  905.             int i = pointIndexToAddItAfter;

  906.             while (i > 0)

  907.                 if (points [--i]->type == Path::Iterator::startNewSubPath)

  908.                     break;

  909. 

  910.             if (i != pointIndexToAddItAfter)

  911.                 points [i]->pos[0].getXY (x2, y2, area, layout);

  912.         }

  913.         else

  914.         {

  915.             points [pointIndexToAddItAfter + 1]->pos[0].getXY (x2, y2, area, layout);

  916.         }

  917.     }

  918.     else

  919.     {

  920.         int i = pointIndexToAddItAfter + 1;

  921.         while (i > 0)

  922.             if (points [--i]->type == Path::Iterator::startNewSubPath)

  923.                 break;

  924. 

  925.         points[i]->pos[0].getXY (x2, y2, area, layout);

  926.     }

  927. 

  928.     PathPoint* const p = new PathPoint (this);

  929. 

  930.     p->type = Path::Iterator::lineTo;

  931.     p->pos[0].rect.setX ((x1 + x2) * 0.5f);

  932.     p->pos[0].rect.setY ((y1 + y2) * 0.5f);

  933. 

  934.     points.insert (pointIndexToAddItAfter + 1, p);

  935. 

  936.     pointListChanged();

  937.     return p;

  938. }

  939. 

  940. //==============================================================================

  941. class DeletePointAction   : public PaintElementUndoableAction <PaintElementPath>

  942. {

  943. public:

  944.     DeletePointAction (PaintElementPath* const path, const int indexToRemove_)

  945.         : PaintElementUndoableAction <PaintElementPath> (path),

  946.           indexToRemove (indexToRemove_),

  947.           oldValue (*path->getPoint (indexToRemove))

  948.     {

  949.     }

  950. 

  951.     bool perform()

  952.     {

  953.         showCorrectTab();

  954. 

  955.         PaintElementPath* const path = getElement();

  956.         jassert (path != nullptr);

  957. 

  958.         path->deletePoint (indexToRemove, false);

  959.         return path != nullptr;

  960.     }

  961. 

  962.     bool undo()

  963.     {

  964.         showCorrectTab();

  965. 

  966.         PaintElementPath* const path = getElement();

  967.         jassert (path != nullptr);

  968. 

  969.         PathPoint* p = path->addPoint (indexToRemove - 1, false);

  970.         *p = oldValue;

  971. 

  972.         return path != nullptr;

  973.     }

  974. 

  975.     int indexToRemove;

  976. 

  977. private:

  978.     PathPoint oldValue;

  979. };

  980. 

  981. void PaintElementPath::deletePoint (int pointIndex, const bool undoable)

  982. {

  983.     if (undoable)

  984.     {

  985.         perform (new DeletePointAction (this, pointIndex), "Delete path point");

  986.     }

  987.     else

  988.     {

  989.         PathPoint* const p = points [pointIndex];

  990. 

  991.         if (p != nullptr && pointIndex > 0)

  992.         {

  993.             owner->getSelectedPoints().deselect (p);

  994.             owner->getSelectedPoints().changed (true);

  995. 

  996.             points.remove (pointIndex);

  997.             pointListChanged();

  998.         }

  999.     }

  1000. }

  1001. 

  1002. //==============================================================================

  1003. bool PaintElementPath::getPoint (int index, int pointNumber, double& x, double& y, const Rectangle<int>& parentArea) const

  1004. {

  1005.     const PathPoint* const p = points [index];

  1006. 

  1007.     if (p == nullptr)

  1008.     {

  1009.         x = y = 0;

  1010.         return false;

  1011.     }

  1012. 

  1013.     jassert (pointNumber < 3 || p->type == Path::Iterator::cubicTo);

  1014.     jassert (pointNumber < 2 || p->type == Path::Iterator::cubicTo || p->type == Path::Iterator::quadraticTo);

  1015. 

  1016.     p->pos [pointNumber].getXY (x, y, parentArea, getDocument()->getComponentLayout());

  1017.     return true;

  1018. }

  1019. 

  1020. int PaintElementPath::findSegmentAtXY (int x, int y) const

  1021. {

  1022.     double x1, y1, x2, y2, x3, y3, lastX = 0.0, lastY = 0.0, subPathStartX = 0.0, subPathStartY = 0.0;

  1023. 

  1024.     ComponentLayout* const layout = getDocument()->getComponentLayout();

  1025.     const Rectangle<int> area (((PaintRoutineEditor*) getParentComponent())->getComponentArea());

  1026. 

  1027.     int subpathStartIndex = 0;

  1028. 

  1029.     float thickness = 10.0f;

  1030.     if (isStrokePresent)

  1031.         thickness = jmax (thickness, strokeType.stroke.getStrokeThickness());

  1032. 

  1033.     for (int i = 0; i < points.size(); ++i)

  1034.     {

  1035.         Path segmentPath;

  1036.         PathPoint* const p = points.getUnchecked (i);

  1037. 

  1038.         switch (p->type)

  1039.         {

  1040.         case Path::Iterator::startNewSubPath:

  1041.             p->pos[0].getXY (lastX, lastY, area, layout);

  1042.             subPathStartX = lastX;

  1043.             subPathStartY = lastY;

  1044.             subpathStartIndex = i;

  1045.             break;

  1046. 

  1047.         case Path::Iterator::lineTo:

  1048.             p->pos[0].getXY (x1, y1, area, layout);

  1049. 

  1050.             segmentPath.addLineSegment (Line<float> ((float) lastX, (float) lastY, (float) x1, (float) y1), thickness);

  1051.             if (segmentPath.contains ((float) x, (float) y))

  1052.                 return i;

  1053. 

  1054.             lastX = x1;

  1055.             lastY = y1;

  1056.             break;

  1057. 

  1058.         case Path::Iterator::quadraticTo:

  1059.             p->pos[0].getXY (x1, y1, area, layout);

  1060.             p->pos[1].getXY (x2, y2, area, layout);

  1061. 

  1062.             segmentPath.startNewSubPath ((float) lastX, (float) lastY);

  1063.             segmentPath.quadraticTo ((float) x1, (float) y1, (float) x2, (float) y2);

  1064.             PathStrokeType (thickness).createStrokedPath (segmentPath, segmentPath);

  1065. 

  1066.             if (segmentPath.contains ((float) x, (float) y))

  1067.                 return i;

  1068. 

  1069.             lastX = x2;

  1070.             lastY = y2;

  1071.             break;

  1072. 

  1073.         case Path::Iterator::cubicTo:

  1074.             p->pos[0].getXY (x1, y1, area, layout);

  1075.             p->pos[1].getXY (x2, y2, area, layout);

  1076.             p->pos[2].getXY (x3, y3, area, layout);

  1077. 

  1078.             segmentPath.startNewSubPath ((float) lastX, (float) lastY);

  1079.             segmentPath.cubicTo ((float) x1, (float) y1, (float) x2, (float) y2, (float) x3, (float) y3);

  1080.             PathStrokeType (thickness).createStrokedPath (segmentPath, segmentPath);

  1081. 

  1082.             if (segmentPath.contains ((float) x, (float) y))

  1083.                 return i;

  1084. 

  1085.             lastX = x3;

  1086.             lastY = y3;

  1087.             break;

  1088. 

  1089.         case Path::Iterator::closePath:

  1090.             segmentPath.addLineSegment (Line<float> ((float) lastX, (float) lastY, (float) subPathStartX, (float) subPathStartY), thickness);

  1091.             if (segmentPath.contains ((float) x, (float) y))

  1092.                 return subpathStartIndex;

  1093. 

  1094.             lastX = subPathStartX;

  1095.             lastY = subPathStartY;

  1096.             break;

  1097. 

  1098.         default:

  1099.             jassertfalse; break;

  1100.         }

  1101.     }

  1102. 

  1103.     return -1;

  1104. }

  1105. 

  1106. //==============================================================================

  1107. void PaintElementPath::movePoint (int index, int pointNumber,

  1108.                                   double newX, double newY,

  1109.                                   const Rectangle<int>& parentArea,

  1110.                                   const bool undoable)

  1111. {

  1112.     if (PathPoint* const p = points [index])

  1113.     {

  1114.         PathPoint newPoint (*p);

  1115.         jassert (pointNumber < 3 || p->type == Path::Iterator::cubicTo);

  1116.         jassert (pointNumber < 2 || p->type == Path::Iterator::cubicTo || p->type == Path::Iterator::quadraticTo);

  1117. 

  1118.         RelativePositionedRectangle& pr = newPoint.pos [pointNumber];

  1119. 

  1120.         double x, y, w, h;

  1121.         pr.getRectangleDouble (x, y, w, h, parentArea, getDocument()->getComponentLayout());

  1122.         pr.updateFrom (newX, newY, w, h, parentArea, getDocument()->getComponentLayout());

  1123. 

  1124.         if (undoable)

  1125.         {

  1126.             perform (new ChangePointAction (p, index, newPoint), "Move path point");

  1127.         }

  1128.         else

  1129.         {

  1130.             *p = newPoint;

  1131.             changed();

  1132.         }

  1133.     }

  1134. }

  1135. 

  1136. RelativePositionedRectangle PaintElementPath::getPoint (int index, int pointNumber) const

  1137. {

  1138.     if (PathPoint* const p = points [index])

  1139.     {

  1140.         jassert (pointNumber < 3 || p->type == Path::Iterator::cubicTo);

  1141.         jassert (pointNumber < 2 || p->type == Path::Iterator::cubicTo || p->type == Path::Iterator::quadraticTo);

  1142. 

  1143.         return p->pos [pointNumber];

  1144.     }

  1145. 

  1146.     jassertfalse;

  1147.     return RelativePositionedRectangle();

  1148. }

  1149. 

  1150. void PaintElementPath::setPoint (int index, int pointNumber, const RelativePositionedRectangle& newPos, const bool undoable)

  1151. {

  1152.     if (PathPoint* const p = points [index])

  1153.     {

  1154.         PathPoint newPoint (*p);

  1155. 

  1156.         jassert (pointNumber < 3 || p->type == Path::Iterator::cubicTo);

  1157.         jassert (pointNumber < 2 || p->type == Path::Iterator::cubicTo || p->type == Path::Iterator::quadraticTo);

  1158. 

  1159.         if (newPoint.pos [pointNumber] != newPos)

  1160.         {

  1161.             newPoint.pos [pointNumber] = newPos;

  1162. 

  1163.             if (undoable)

  1164.             {

  1165.                 perform (new ChangePointAction (p, index, newPoint), "Change path point position");

  1166.             }

  1167.             else

  1168.             {

  1169.                 *p = newPoint;

  1170.                 changed();

  1171.             }

  1172.         }

  1173.     }

  1174.     else

  1175.     {

  1176.         jassertfalse;

  1177.     }

  1178. }

  1179. 

  1180. //==============================================================================

  1181. class PathPointTypeProperty : public ChoicePropertyComponent,

  1182.                               public ChangeListener

  1183. {

  1184. public:

  1185.     PathPointTypeProperty (PaintElementPath* const owner_,

  1186.                            const int index_)

  1187.         : ChoicePropertyComponent ("point type"),

  1188.           owner (owner_),

  1189.           index (index_)

  1190.     {

  1191.         choices.add ("Start of sub-path");

  1192.         choices.add ("Line");

  1193.         choices.add ("Quadratic");

  1194.         choices.add ("Cubic");

  1195. 

  1196.         owner->getDocument()->addChangeListener (this);

  1197.     }

  1198. 

  1199.     ~PathPointTypeProperty()

  1200.     {

  1201.         owner->getDocument()->removeChangeListener (this);

  1202.     }

  1203. 

  1204.     void setIndex (int newIndex)

  1205.     {

  1206.         Path::Iterator::PathElementType type = Path::Iterator::startNewSubPath;

  1207. 

  1208.         switch (newIndex)

  1209.         {

  1210.             case 0:     type = Path::Iterator::startNewSubPath; break;

  1211.             case 1:     type = Path::Iterator::lineTo; break;

  1212.             case 2:     type = Path::Iterator::quadraticTo; break;

  1213.             case 3:     type = Path::Iterator::cubicTo; break;

  1214.             default:    jassertfalse; break;

  1215.         }

  1216. 

  1217.         const Rectangle<int> area (((PaintRoutineEditor*) owner->getParentComponent())->getComponentArea());

  1218.         owner->getPoint (index)->changePointType (type, area, true);

  1219.     }

  1220. 

  1221.     int getIndex() const

  1222.     {

  1223.         const PathPoint* const p = owner->getPoint (index);

  1224.         jassert (p != nullptr);

  1225. 

  1226.         switch (p->type)

  1227.         {

  1228.             case Path::Iterator::startNewSubPath:   return 0;

  1229.             case Path::Iterator::lineTo:            return 1;

  1230.             case Path::Iterator::quadraticTo:       return 2;

  1231.             case Path::Iterator::cubicTo:           return 3;

  1232.             case Path::Iterator::closePath:         break;

  1233.             default:                                jassertfalse; break;

  1234.         }

  1235. 

  1236.         return 0;

  1237.     }

  1238. 

  1239.     void changeListenerCallback (ChangeBroadcaster*)

  1240.     {

  1241.         refresh();

  1242.     }

  1243. 

  1244. private:

  1245.     PaintElementPath* const owner;

  1246.     const int index;

  1247. };

  1248. 

  1249. //==============================================================================

  1250. class PathPointPositionProperty   : public PositionPropertyBase

  1251. {

  1252. public:

  1253.     PathPointPositionProperty (PaintElementPath* const owner_,

  1254.                                const int index_, const int pointNumber_,

  1255.                                const String& name,

  1256.                                ComponentPositionDimension dimension_)

  1257.         : PositionPropertyBase (owner_, name, dimension_, false, false,

  1258.                                 owner_->getDocument()->getComponentLayout()),

  1259.           owner (owner_),

  1260.           index (index_),

  1261.           pointNumber (pointNumber_)

  1262.     {

  1263.         owner->getDocument()->addChangeListener (this);

  1264.     }

  1265. 

  1266.     ~PathPointPositionProperty()

  1267.     {

  1268.         owner->getDocument()->removeChangeListener (this);

  1269.     }

  1270. 

  1271.     void setPosition (const RelativePositionedRectangle& newPos)

  1272.     {

  1273.         owner->setPoint (index, pointNumber, newPos, true);

  1274.     }

  1275. 

  1276.     RelativePositionedRectangle getPosition() const

  1277.     {

  1278.         return owner->getPoint (index, pointNumber);

  1279.     }

  1280. 

  1281. private:

  1282.     PaintElementPath* const owner;

  1283.     const int index, pointNumber;

  1284. };

  1285. 

  1286. //==============================================================================

  1287. class PathPointClosedProperty   : public ChoicePropertyComponent,

  1288.                                   private ChangeListener

  1289. {

  1290. public:

  1291.     PathPointClosedProperty (PaintElementPath* const owner_, const int index_)

  1292.         : ChoicePropertyComponent ("openness"),

  1293.           owner (owner_),

  1294.           index (index_)

  1295.     {

  1296.         owner->getDocument()->addChangeListener (this);

  1297. 

  1298.         choices.add ("Subpath is closed");

  1299.         choices.add ("Subpath is open-ended");

  1300.     }

  1301. 

  1302.     ~PathPointClosedProperty()

  1303.     {

  1304.         owner->getDocument()->removeChangeListener (this);

  1305.     }

  1306. 

  1307.     void changeListenerCallback (ChangeBroadcaster*)

  1308.     {

  1309.         refresh();

  1310.     }

  1311. 

  1312.     void setIndex (int newIndex)

  1313.     {

  1314.         owner->setSubpathClosed (index, newIndex == 0, true);

  1315.     }

  1316. 

  1317.     int getIndex() const

  1318.     {

  1319.         return owner->isSubpathClosed (index) ? 0 : 1;

  1320.     }

  1321. 

  1322. private:

  1323.     PaintElementPath* const owner;

  1324.     const int index;

  1325. };

  1326. 

  1327. //==============================================================================

  1328. class AddNewPointProperty   : public ButtonPropertyComponent

  1329. {

  1330. public:

  1331.     AddNewPointProperty (PaintElementPath* const owner_, const int index_)

  1332.         : ButtonPropertyComponent ("new point", false),

  1333.           owner (owner_),

  1334.           index (index_)

  1335.     {

  1336.     }

  1337. 

  1338.     void buttonClicked()

  1339.     {

  1340.         owner->addPoint (index, true);

  1341.     }

  1342. 

  1343.     String getButtonText() const      { return "Add new point"; }

  1344. 

  1345. private:

  1346.     PaintElementPath* const owner;

  1347.     const int index;

  1348. };

  1349. 

  1350. 

  1351. //==============================================================================

  1352. PathPoint::PathPoint (PaintElementPath* const owner_)

  1353.     : owner (owner_)

  1354. {

  1355. }

  1356. 

  1357. PathPoint::PathPoint (const PathPoint& other)

  1358.     : owner (other.owner),

  1359.       type (other.type)

  1360. {

  1361.     pos [0] = other.pos [0];

  1362.     pos [1] = other.pos [1];

  1363.     pos [2] = other.pos [2];

  1364. }

  1365. 

  1366. PathPoint& PathPoint::operator= (const PathPoint& other)

  1367. {

  1368.     owner = other.owner;

  1369.     type = other.type;

  1370.     pos [0] = other.pos [0];

  1371.     pos [1] = other.pos [1];

  1372.     pos [2] = other.pos [2];

  1373.     return *this;

  1374. }

  1375. 

  1376. PathPoint::~PathPoint()

  1377. {

  1378. }

  1379. 

  1380. int PathPoint::getNumPoints() const

  1381. {

  1382.     if (type == Path::Iterator::cubicTo)        return 3;

  1383.     if (type == Path::Iterator::quadraticTo)    return 2;

  1384.     if (type == Path::Iterator::closePath)      return 0;

  1385. 

  1386.     return 1;

  1387. }

  1388. 

  1389. PathPoint PathPoint::withChangedPointType (const Path::Iterator::PathElementType newType,

  1390.                                            const Rectangle<int>& parentArea) const

  1391. {

  1392.     PathPoint p (*this);

  1393. 

  1394.     if (newType != p.type)

  1395.     {

  1396.         int oldNumPoints = getNumPoints();

  1397.         p.type = newType;

  1398.         int numPoints = p.getNumPoints();

  1399. 

  1400.         if (numPoints != oldNumPoints)

  1401.         {

  1402.             double lastX, lastY;

  1403.             double x, y, w, h;

  1404. 

  1405.             p.pos [numPoints - 1] = p.pos [oldNumPoints - 1];

  1406.             p.pos [numPoints - 1].getRectangleDouble (x, y, w, h, parentArea, owner->getDocument()->getComponentLayout());

  1407. 

  1408.             const int index = owner->points.indexOf (this);

  1409. 

  1410.             if (PathPoint* lastPoint = owner->points [index - 1])

  1411.             {

  1412.                 lastPoint->pos [lastPoint->getNumPoints() - 1]

  1413.                             .getRectangleDouble (lastX, lastY, w, h, parentArea, owner->getDocument()->getComponentLayout());

  1414.             }

  1415.             else

  1416.             {

  1417.                 jassertfalse;

  1418.                 lastX = x;

  1419.                 lastY = y;

  1420.             }

  1421. 

  1422.             for (int i = 0; i < numPoints - 1; ++i)

  1423.             {

  1424.                 p.pos[i] = p.pos [numPoints - 1];

  1425. 

  1426.                 p.pos[i].updateFrom (lastX + (x - lastX) * (i + 1) / numPoints,

  1427.                                      lastY + (y - lastY) * (i + 1) / numPoints,

  1428.                                      w, h,

  1429.                                      parentArea,

  1430.                                      owner->getDocument()->getComponentLayout());

  1431.             }

  1432.         }

  1433.     }

  1434. 

  1435.     return p;

  1436. }

  1437. 

  1438. void PathPoint::changePointType (const Path::Iterator::PathElementType newType,

  1439.                                  const Rectangle<int>& parentArea, const bool undoable)

  1440. {

  1441.     if (newType != type)

  1442.     {

  1443.         if (undoable)

  1444.         {

  1445.             owner->perform (new ChangePointAction (this, withChangedPointType (newType, parentArea)),

  1446.                             "Change path point type");

  1447.         }

  1448.         else

  1449.         {

  1450.             *this = withChangedPointType (newType, parentArea);

  1451.             owner->pointListChanged();

  1452.         }

  1453.     }

  1454. }

  1455. 

  1456. void PathPoint::getEditableProperties (Array<PropertyComponent*>& props)

  1457. {

  1458.     const int index = owner->points.indexOf (this);

  1459.     jassert (index >= 0);

  1460. 

  1461.     switch (type)

  1462.     {

  1463.         case Path::Iterator::startNewSubPath:

  1464.             props.add (new PathPointPositionProperty (owner, index, 0, "x", PositionPropertyBase::componentX));

  1465.             props.add (new PathPointPositionProperty (owner, index, 0, "y", PositionPropertyBase::componentY));

  1466. 

  1467.             props.add (new PathPointClosedProperty (owner, index));

  1468.             props.add (new AddNewPointProperty (owner, index));

  1469.             break;

  1470. 

  1471.         case Path::Iterator::lineTo:

  1472.             props.add (new PathPointTypeProperty (owner, index));

  1473.             props.add (new PathPointPositionProperty (owner, index, 0, "x", PositionPropertyBase::componentX));

  1474.             props.add (new PathPointPositionProperty (owner, index, 0, "y", PositionPropertyBase::componentY));

  1475.             props.add (new AddNewPointProperty (owner, index));

  1476.             break;

  1477. 

  1478.         case Path::Iterator::quadraticTo:

  1479.             props.add (new PathPointTypeProperty (owner, index));

  1480.             props.add (new PathPointPositionProperty (owner, index, 0, "control pt x", PositionPropertyBase::componentX));

  1481.             props.add (new PathPointPositionProperty (owner, index, 0, "control pt y", PositionPropertyBase::componentY));

  1482.             props.add (new PathPointPositionProperty (owner, index, 1, "x", PositionPropertyBase::componentX));

  1483.             props.add (new PathPointPositionProperty (owner, index, 1, "y", PositionPropertyBase::componentY));

  1484.             props.add (new AddNewPointProperty (owner, index));

  1485.             break;

  1486. 

  1487.         case Path::Iterator::cubicTo:

  1488.             props.add (new PathPointTypeProperty (owner, index));

  1489.             props.add (new PathPointPositionProperty (owner, index, 0, "control pt1 x", PositionPropertyBase::componentX));

  1490.             props.add (new PathPointPositionProperty (owner, index, 0, "control pt1 y", PositionPropertyBase::componentY));

  1491.             props.add (new PathPointPositionProperty (owner, index, 1, "control pt2 x", PositionPropertyBase::componentX));

  1492.             props.add (new PathPointPositionProperty (owner, index, 1, "control pt2 y", PositionPropertyBase::componentY));

  1493.             props.add (new PathPointPositionProperty (owner, index, 2, "x", PositionPropertyBase::componentX));

  1494.             props.add (new PathPointPositionProperty (owner, index, 2, "y", PositionPropertyBase::componentY));

  1495.             props.add (new AddNewPointProperty (owner, index));

  1496.             break;

  1497. 

  1498.         case Path::Iterator::closePath:

  1499.             break;

  1500. 

  1501.         default:

  1502.             jassertfalse;

  1503.             break;

  1504.     }

  1505. }

  1506. 

  1507. void PathPoint::deleteFromPath()

  1508. {

  1509.     owner->deletePoint (owner->points.indexOf (this), true);

  1510. }

  1511. 

  1512. //==============================================================================

  1513. PathPointComponent::PathPointComponent (PaintElementPath* const path_,

  1514.                                         const int index_,

  1515.                                         const int pointNumber_)

  1516.     : ElementSiblingComponent (path_),

  1517.       path (path_),

  1518.       routine (path_->getOwner()),

  1519.       index (index_),

  1520.       pointNumber (pointNumber_),

  1521.       selected (false)

  1522. {

  1523.     setSize (11, 11);

  1524.     setRepaintsOnMouseActivity (true);

  1525. 

  1526.     selected = routine->getSelectedPoints().isSelected (path_->points [index]);

  1527.     routine->getSelectedPoints().addChangeListener (this);

  1528. }

  1529. 

  1530. PathPointComponent::~PathPointComponent()

  1531. {

  1532.     routine->getSelectedPoints().removeChangeListener (this);

  1533. }

  1534. 

  1535. void PathPointComponent::updatePosition()

  1536. {

  1537.     const Rectangle<int> area (((PaintRoutineEditor*) getParentComponent())->getComponentArea());

  1538.     jassert (getParentComponent() != nullptr);

  1539. 

  1540.     double x, y;

  1541.     path->getPoint (index, pointNumber, x, y, area);

  1542. 

  1543.     setCentrePosition (roundToInt (x),

  1544.                        roundToInt (y));

  1545. }

  1546. 

  1547. void PathPointComponent::showPopupMenu()

  1548. {

  1549. }

  1550. 

  1551. void PathPointComponent::paint (Graphics& g)

  1552. {

  1553.     if (isMouseOverOrDragging())

  1554.         g.fillAll (Colours::red);

  1555. 

  1556.     if (selected)

  1557.     {

  1558.         g.setColour (Colours::red);

  1559.         g.drawRect (getLocalBounds());

  1560.     }

  1561. 

  1562.     g.setColour (Colours::white);

  1563.     g.fillRect (getWidth() / 2 - 3, getHeight() / 2 - 3, 7, 7);

  1564. 

  1565.     g.setColour (Colours::black);

  1566. 

  1567.     if (pointNumber < path->getPoint (index)->getNumPoints() - 1)

  1568.         g.drawRect (getWidth() / 2 - 2, getHeight() / 2 - 2, 5, 5);

  1569.     else

  1570.         g.fillRect (getWidth() / 2 - 2, getHeight() / 2 - 2, 5, 5);

  1571. }

  1572. 

  1573. void PathPointComponent::mouseDown (const MouseEvent& e)

  1574. {

  1575.     dragging = false;

  1576. 

  1577.     if (e.mods.isPopupMenu())

  1578.     {

  1579.         showPopupMenu();

  1580.         return; // this may be deleted now..

  1581.     }

  1582. 

  1583.     dragX = getX() + getWidth() / 2;

  1584.     dragY = getY() + getHeight() / 2;

  1585. 

  1586.     mouseDownSelectStatus = routine->getSelectedPoints().addToSelectionOnMouseDown (path->points [index], e.mods);

  1587. 

  1588.     owner->getDocument()->beginTransaction();

  1589. }

  1590. 

  1591. void PathPointComponent::mouseDrag (const MouseEvent& e)

  1592. {

  1593.     if (! e.mods.isPopupMenu())

  1594.     {

  1595.         if (selected && ! dragging)

  1596.             dragging = e.mouseWasDraggedSinceMouseDown();

  1597. 

  1598.         if (dragging)

  1599.         {

  1600.             const Rectangle<int> area (((PaintRoutineEditor*) getParentComponent())->getComponentArea());

  1601.             int x = dragX + e.getDistanceFromDragStartX() - area.getX();

  1602.             int y = dragY + e.getDistanceFromDragStartY() - area.getY();

  1603. 

  1604.             if (JucerDocument* const document = owner->getDocument())

  1605.             {

  1606.                 x = document->snapPosition (x);

  1607.                 y = document->snapPosition (y);

  1608.             }

  1609. 

  1610.             owner->getDocument()->getUndoManager().undoCurrentTransactionOnly();

  1611.             path->movePoint (index, pointNumber, x + area.getX(), y + area.getY(), area, true);

  1612.         }

  1613.     }

  1614. }

  1615. 

  1616. void PathPointComponent::mouseUp (const MouseEvent& e)

  1617. {

  1618.     routine->getSelectedPoints().addToSelectionOnMouseUp (path->points [index],

  1619.                                                           e.mods, dragging,

  1620.                                                           mouseDownSelectStatus);

  1621. }

  1622. 

  1623. void PathPointComponent::changeListenerCallback (ChangeBroadcaster* source)

  1624. {

  1625.     ElementSiblingComponent::changeListenerCallback (source);

  1626. 

  1627.     const bool nowSelected = routine->getSelectedPoints().isSelected (path->points [index]);

  1628. 

  1629.     if (nowSelected != selected)

  1630.     {

  1631.         selected = nowSelected;

  1632.         repaint();

  1633. 

  1634.         if (Component* parent = getParentComponent())

  1635.             parent->repaint();

  1636.     }

  1637. }