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.
1070 Commits
9 Branches
407MB
Tree: a612dfdc2f
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'a612dfdc2f'
${ noResults }
JUCE/extras/Jucer (experimental)/Source/ui/Component Editor/jucer_ComponentEditor.cpp

1141 lines
38KB
Raw Blame History 

  1. /*

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

  3. 

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

  5.    Copyright 2004-9 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. #include "../../jucer_Headers.h"

  27. #include "jucer_ComponentEditor.h"

  28. 

  29. 

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

  31. class SizeGuideComponent   : public Component,

  32.                              public ComponentListener

  33. {

  34. public:

  35.     enum Type

  36.     {

  37.         left, right, top, bottom

  38.     };

  39. 

  40.     SizeGuideComponent (ComponentDocument& document_, const ValueTree& state_, Component* component_,

  41.                         Component& parentForOverlays, Type type_)

  42.         : document (document_), state (state_), component (component_), type (type_),

  43.           font (10.0f)

  44.     {

  45.         component->addComponentListener (this);

  46. 

  47.         setAlwaysOnTop (true);

  48.         parentForOverlays.addAndMakeVisible (this);

  49.         updatePosition();

  50.     }

  51. 

  52.     ~SizeGuideComponent()

  53.     {

  54.         if (component != 0)

  55.             component->removeComponentListener (this);

  56.     }

  57. 

  58.     void updatePosition()

  59.     {

  60.         RectangleCoordinates coords (document.getCoordsFor (state));

  61.         Coordinate coord (false);

  62.         bool isHorizontal = false;

  63. 

  64.         switch (type)

  65.         {

  66.             case left:      coord = coords.left; isHorizontal = true; break;

  67.             case right:     coord = coords.right; isHorizontal = true; break;

  68.             case top:       coord = coords.top; break;

  69.             case bottom:    coord = coords.bottom; break;

  70.             default:        jassertfalse; break;

  71.         }

  72. 

  73.         setName (coord.toString());

  74. 

  75.         int textW = (int) font.getStringWidth (getName());

  76.         int textH = (int) font.getHeight();

  77. 

  78.         Point<int> p1, p2;

  79. 

  80.         switch (type)

  81.         {

  82.         case left:

  83.             p1 = Point<int> (component->getX(), 0);

  84.             p2 = Point<int> (component->getX(), component->getY());

  85.             textArea.setBounds (p1.getX() - textW - 2, 4, textW, textH);

  86.             break;

  87. 

  88.         case right:

  89.             p1 = Point<int> (component->getRight(), 0);

  90.             p2 = Point<int> (component->getRight(), component->getY());

  91.             textArea.setBounds (p1.getX() + 2, 4, textW, textH);

  92.             break;

  93. 

  94.         case top:

  95.             p1 = Point<int> (0, component->getY());

  96.             p2 = Point<int> (component->getX(), component->getY());

  97.             textArea.setBounds (4, p1.getY() - textH - 2, textW, textH);

  98.             break;

  99. 

  100.         case bottom:

  101.             p1 = Point<int> (0, component->getBottom());

  102.             p2 = Point<int> (component->getX(), component->getBottom());

  103.             textArea.setBounds (4, p1.getY() + 2, textW, textH);

  104.             break;

  105. 

  106.         default:

  107.             jassertfalse;

  108.             break;

  109.         }

  110. 

  111.         Rectangle<int> bounds (Rectangle<int> (p1, p2).expanded (2, 2).getUnion (textArea));

  112.         bounds.setPosition (component->getParentComponent()->relativePositionToOtherComponent (getParentComponent(), bounds.getPosition()));

  113.         setBounds (bounds);

  114. 

  115.         lineEnd1 = component->getParentComponent()->relativePositionToOtherComponent (this, p1);

  116.         lineEnd2 = component->getParentComponent()->relativePositionToOtherComponent (this, p2);

  117.         textArea.setPosition (component->getParentComponent()->relativePositionToOtherComponent (this, textArea.getPosition()));

  118.         repaint();

  119.     }

  120. 

  121.     void paint (Graphics& g)

  122.     {

  123.         const float dashes[] = { 4.0f, 3.0f };

  124. 

  125.         g.setColour (Colours::grey.withAlpha (0.4f));

  126.         g.drawDashedLine (lineEnd1.getX() + 0.5f, lineEnd1.getY() + 0.5f,

  127.                           lineEnd2.getX() + 0.5f, lineEnd2.getY() + 0.5f,

  128.                           dashes, 2, 1.0f);

  129. 

  130.         g.setFont (font);

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

  132. 

  133.         for (int y = -1; y <= 1; ++y)

  134.             for (int x = -1; x <= 1; ++x)

  135.                 g.drawText (getName(), textArea.getX() + x, textArea.getY() + y, textArea.getWidth(), textArea.getHeight(), Justification::centred, 1);

  136. 

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

  138.         g.drawText (getName(), textArea.getX(), textArea.getY(), textArea.getWidth(), textArea.getHeight(), Justification::centred, 1);

  139.     }

  140. 

  141.     void componentMovedOrResized (Component&, bool, bool)

  142.     {

  143.         updatePosition();

  144.     }

  145. 

  146.     void componentBeingDeleted (Component&)

  147.     {

  148.         setVisible (false);

  149.         component = 0;

  150.     }

  151. 

  152. private:

  153.     ComponentDocument& document;

  154.     ValueTree state;

  155.     Component* component;

  156.     Type type;

  157.     Font font;

  158.     Point<int> lineEnd1, lineEnd2;

  159.     Rectangle<int> textArea;

  160. };

  161. 

  162. //==============================================================================

  163. class ComponentEditor::Canvas   : public Component,

  164.                                   public ValueTree::Listener,

  165.                                   public Timer

  166. {

  167. public:

  168.     Canvas (ComponentEditor& editor_)

  169.         : editor (editor_), border (14), resizerThickness (4),

  170.           dragStartWidth (0), dragStartHeight (0)

  171.     {

  172.         setOpaque (true);

  173.         addAndMakeVisible (componentHolder = new Component());

  174.         addAndMakeVisible (overlay = new OverlayComponent (*this));

  175. 

  176.         setSize (500, 500);

  177. 

  178.         getDocument().getRoot().addListener (this);

  179.         updateComponents();

  180.     }

  181. 

  182.     ~Canvas()

  183.     {

  184.         dragger = 0;

  185.         getDocument().getRoot().removeListener (this);

  186.         componentHolder->deleteAllChildren();

  187.         deleteAllChildren();

  188.     }

  189. 

  190.     void paint (Graphics& g)

  191.     {

  192.         g.fillAll (Colours::white);

  193.         g.setColour (Colour::greyLevel (0.9f));

  194. 

  195.         g.drawRect (getContentArea().expanded (resizerThickness, resizerThickness), resizerThickness);

  196. 

  197.         g.setFont (border.getBottom() - 5.0f);

  198.         g.setColour (Colours::grey);

  199.         g.drawText (String (componentHolder->getWidth()) + " x " + String (componentHolder->getHeight()),

  200.                     0, 0, jmax (getWidth() - border.getRight(), jmin (60, getWidth())), getHeight(), Justification::bottomRight, false);

  201. 

  202.         g.setFont (border.getTop() - 5.0f);

  203.         g.setColour (Colours::darkgrey);

  204. 

  205.         g.drawHorizontalLine (border.getTop() - 1, 2.0f, (float) getWidth() - border.getRight());

  206.         g.drawVerticalLine (border.getLeft() - 1, 2.0f, (float) getHeight() - border.getBottom());

  207.         drawXAxis (g, Rectangle<int> (border.getLeft(), 0, componentHolder->getWidth(), border.getTop()));

  208.         drawYAxis (g, Rectangle<int> (0, border.getTop(), border.getLeft(), componentHolder->getHeight()));

  209.     }

  210. 

  211.     void drawXAxis (Graphics& g, const Rectangle<int>& r)

  212.     {

  213.         TickIterator ticks (0, r.getWidth(), 1.0, 10, 50);

  214. 

  215.         float pos, tickLength;

  216.         String label;

  217. 

  218.         while (ticks.getNextTick (pos, tickLength, label))

  219.         {

  220.             if (pos > 0)

  221.             {

  222.                 g.drawVerticalLine (r.getX() + (int) pos, r.getBottom() - tickLength * r.getHeight(), (float) r.getBottom());

  223.                 g.drawSingleLineText (label, r.getX() + (int) pos + 2, (int) r.getBottom() - 6);

  224.             }

  225.         }

  226.     }

  227. 

  228.     void drawYAxis (Graphics& g, const Rectangle<int>& r)

  229.     {

  230.         TickIterator ticks (0, r.getHeight(), 1.0, 10, 80);

  231. 

  232.         float pos, tickLength;

  233.         String label;

  234. 

  235.         while (ticks.getNextTick (pos, tickLength, label))

  236.         {

  237.             if (pos > 0)

  238.             {

  239.                 g.drawHorizontalLine (r.getY() + (int) pos, r.getRight() - tickLength * r.getWidth(), (float) r.getRight());

  240.                 g.drawTextAsPath (label, AffineTransform::rotation (float_Pi / -2.0f)

  241.                                                          .translated (r.getRight() - 6.0f, r.getY() + pos - 2.0f));

  242.             }

  243.         }

  244.     }

  245. 

  246.     void resized()

  247.     {

  248.         componentHolder->setBounds (getContentArea());

  249.         overlay->setBounds (componentHolder->getBounds());

  250.         updateComponents();

  251.     }

  252. 

  253.     void zoom (float newScale, const Point<int>& centre)

  254.     {

  255.     }

  256. 

  257.     ComponentEditor& getEditor()                            { return editor; }

  258.     ComponentDocument& getDocument()                        { return editor.getDocument(); }

  259.     ComponentDocument::SelectedItems& getSelection()        { return selection; }

  260. 

  261.     Component* findComponentFor (const ValueTree& state)

  262.     {

  263.         ComponentDocument& doc = getDocument();

  264. 

  265.         for (int i = componentHolder->getNumChildComponents(); --i >= 0;)

  266.         {

  267.             Component* c = componentHolder->getChildComponent (i);

  268. 

  269.             if (doc.isStateForComponent (state, c))

  270.                 return c;

  271.         }

  272. 

  273.         return 0;

  274.     }

  275. 

  276.     void updateComponents()

  277.     {

  278.         ComponentDocument& doc = getDocument();

  279.         setSize ((int) doc.getCanvasWidth().getValue() + border.getLeftAndRight(),

  280.                  (int) doc.getCanvasHeight().getValue() + border.getTopAndBottom());

  281. 

  282.         int i;

  283.         for (i = componentHolder->getNumChildComponents(); --i >= 0;)

  284.         {

  285.             Component* c = componentHolder->getChildComponent (i);

  286. 

  287.             if (! doc.containsComponent (c))

  288.             {

  289.                 selection.deselect (c->getComponentUID());

  290.                 delete c;

  291.             }

  292.         }

  293. 

  294.         const int num = doc.getNumComponents();

  295.         for (i = 0; i < num; ++i)

  296.         {

  297.             const ValueTree v (doc.getComponent (i));

  298.             Component* c = findComponentFor (v);

  299. 

  300.             if (c == 0)

  301.             {

  302.                 c = doc.createComponent (i);

  303.                 componentHolder->addAndMakeVisible (c);

  304.             }

  305. 

  306.             doc.updateComponent (c);

  307.         }

  308. 

  309.         startTimer (500);

  310.     }

  311. 

  312.     void valueTreePropertyChanged (ValueTree& treeWhosePropertyHasChanged, const var::identifier& property)

  313.     {

  314.         updateComponents();

  315.     }

  316. 

  317.     void valueTreeChildrenChanged (ValueTree& treeWhoseChildHasChanged)

  318.     {

  319.         updateComponents();

  320.     }

  321. 

  322.     void valueTreeParentChanged (ValueTree& treeWhoseParentHasChanged)

  323.     {

  324.     }

  325. 

  326.     Component* getComponentHolder() const       { return componentHolder; }

  327. 

  328.     const Array<Component*> getSelectedComps() const

  329.     {

  330.         Array<Component*> comps;

  331. 

  332.         for (int i = 0; i < selection.getNumSelected(); ++i)

  333.         {

  334.             Component* c = getComponentForUID (selection.getSelectedItem (i));

  335.             jassert (c != 0);

  336.             if (c != 0)

  337.                 comps.add (c);

  338.         }

  339. 

  340.         return comps;

  341.     }

  342. 

  343.     void getSelectedItemProperties (Array <PropertyComponent*>& props)

  344.     {

  345.         //xxx needs to handle multiple selections..

  346. 

  347.         if (selection.getNumSelected() == 1)

  348.         {

  349.             Component* c = getComponentForUID (selection.getSelectedItem (0));

  350.             getDocument().getComponentProperties (props, c);

  351.         }

  352.     }

  353. 

  354.     void timerCallback()

  355.     {

  356.         stopTimer();

  357. 

  358.         if (! Component::isMouseButtonDownAnywhere())

  359.             getDocument().beginNewTransaction();

  360.     }

  361. 

  362.     void mouseMove (const MouseEvent& e)

  363.     {

  364.         updateDragZone (e.getPosition());

  365.     }

  366. 

  367.     void mouseDown (const MouseEvent& e)

  368.     {

  369.         updateDragZone (e.getPosition());

  370.         dragStartWidth = getDocument().getCanvasWidth().getValue();

  371.         dragStartHeight = getDocument().getCanvasHeight().getValue();

  372.         showSizeGuides();

  373.     }

  374. 

  375.     void mouseDrag (const MouseEvent& e)

  376.     {

  377.         if (dragZone.isDraggingRightEdge())

  378.             getDocument().getCanvasWidth() = jmax (1, dragStartWidth + e.getDistanceFromDragStartX());

  379. 

  380.         if (dragZone.isDraggingBottomEdge())

  381.             getDocument().getCanvasHeight() = jmax (1, dragStartHeight + e.getDistanceFromDragStartY());

  382.     }

  383. 

  384.     void mouseUp (const MouseEvent& e)

  385.     {

  386.         hideSizeGuides();

  387.         updateDragZone (e.getPosition());

  388.     }

  389. 

  390.     void updateDragZone (const Point<int>& p)

  391.     {

  392.         ResizableBorderComponent::Zone newZone

  393.             = ResizableBorderComponent::Zone::fromPositionOnBorder (getContentArea().expanded (resizerThickness, resizerThickness),

  394.                                                                     BorderSize (0, 0, resizerThickness, resizerThickness), p);

  395. 

  396.         if (dragZone != newZone)

  397.         {

  398.             dragZone = newZone;

  399.             setMouseCursor (newZone.getMouseCursor());

  400.         }

  401.     }

  402. 

  403.     void showSizeGuides()   { overlay->showSizeGuides(); }

  404.     void hideSizeGuides()   { overlay->hideSizeGuides(); }

  405. 

  406.     //==============================================================================

  407.     class DragOperation

  408.     {

  409.     public:

  410.         DragOperation (Canvas& canvas_,

  411.                        const Array<Component*>& items,

  412.                        const MouseEvent& e,

  413.                        const ResizableBorderComponent::Zone& zone_)

  414.             : canvas (canvas_),

  415.               zone (zone_)

  416.         {

  417.             for (int i = 0; i < items.size(); ++i)

  418.             {

  419.                 Component* comp = items.getUnchecked(i);

  420.                 jassert (comp != 0);

  421. 

  422.                 const ValueTree v (getDocument().getComponentState (comp));

  423.                 draggedComponents.add (v);

  424. 

  425.                 Rectangle<int> pos;

  426. 

  427.                 {

  428.                     RectangleCoordinates relativePos (getDocument().getCoordsFor (v));

  429.                     ScopedPointer<Coordinate::MarkerResolver> markers (getDocument().createMarkerResolver (v));

  430.                     pos = relativePos.resolve (*markers);

  431.                     originalPositions.add (pos);

  432.                 }

  433. 

  434.                 const Rectangle<float> floatPos ((float) pos.getX(), (float) pos.getY(),

  435.                                                  (float) pos.getWidth(), (float) pos.getHeight());

  436. 

  437.                 if (zone.isDraggingWholeObject() || zone.isDraggingLeftEdge())

  438.                     verticalSnapPositions.add (SnapLine (floatPos.getX(), floatPos.getY(), floatPos.getBottom()));

  439. 

  440.                 if (zone.isDraggingWholeObject() || (zone.isDraggingLeftEdge() && zone.isDraggingRightEdge()))

  441.                     verticalSnapPositions.add (SnapLine (floatPos.getCentreX(), floatPos.getY(), floatPos.getBottom()));

  442. 

  443.                 if (zone.isDraggingWholeObject() || zone.isDraggingRightEdge())

  444.                     verticalSnapPositions.add (SnapLine (floatPos.getRight(), floatPos.getY(), floatPos.getBottom()));

  445. 

  446.                 if (zone.isDraggingWholeObject() || zone.isDraggingTopEdge())

  447.                     horizontalSnapPositions.add (SnapLine (floatPos.getY(), floatPos.getX(), floatPos.getRight()));

  448. 

  449.                 if (zone.isDraggingWholeObject() || (zone.isDraggingTopEdge() && zone.isDraggingBottomEdge()))

  450.                     horizontalSnapPositions.add (SnapLine (floatPos.getCentreY(), floatPos.getX(), floatPos.getRight()));

  451. 

  452.                 if (zone.isDraggingWholeObject() || zone.isDraggingBottomEdge())

  453.                     horizontalSnapPositions.add (SnapLine (floatPos.getBottom(), floatPos.getX(), floatPos.getRight()));

  454.             }

  455. 

  456.             verticalSnapTargets.add (SnapLine (0, 0, 10000.0f));

  457.             verticalSnapTargets.add (SnapLine (getDocument().getCanvasWidth().getValue(), 0, 10000.0f));

  458. 

  459.             if (zone.isDraggingWholeObject() || (zone.isDraggingLeftEdge() && zone.isDraggingRightEdge()))

  460.                 verticalSnapTargets.add (SnapLine ((float) getDocument().getCanvasWidth().getValue() / 2.0f, 0, 10000.0f));

  461. 

  462.             horizontalSnapTargets.add (SnapLine (0, 0, 10000.0f));

  463.             horizontalSnapTargets.add (SnapLine (getDocument().getCanvasHeight().getValue(), 0, 10000.0f));

  464. 

  465.             if (zone.isDraggingWholeObject() || (zone.isDraggingTopEdge() && zone.isDraggingBottomEdge()))

  466.                 horizontalSnapTargets.add (SnapLine ((float) getDocument().getCanvasHeight().getValue() / 2.0f, 0, 10000.0f));

  467. 

  468.             getDocument().beginNewTransaction();

  469.         }

  470. 

  471.         ~DragOperation()

  472.         {

  473.             getDocument().beginNewTransaction();

  474.         }

  475. 

  476.         struct SnapLine

  477.         {

  478.             SnapLine (float position_, float start_, float end_)

  479.                 : position (position_), start (start_), end (end_)

  480.             {}

  481. 

  482.             float position, start, end;

  483.         };

  484. 

  485.         class SnapGuideComponent  : public Component

  486.         {

  487.         public:

  488.             SnapGuideComponent (const SnapLine& line_, bool isVertical_, Component* parent)

  489.                 : line (line_), isVertical (isVertical_)

  490.             {

  491.                 if (isVertical)

  492.                     setBounds (roundToInt (line.position), roundToInt (line.start), 1, roundToInt (line.end - line.start));

  493.                 else

  494.                     setBounds (roundToInt (line.start), roundToInt (line.position), roundToInt (line.end - line.start), 1);

  495. 

  496.                 parent->addAndMakeVisible (this);

  497.             }

  498. 

  499.             void paint (Graphics& g)

  500.             {

  501.                 g.fillAll (Colours::blue.withAlpha (0.3f));

  502.             }

  503. 

  504.         private:

  505.             const SnapLine line;

  506.             const bool isVertical;

  507. 

  508.             SnapGuideComponent (const SnapGuideComponent&);

  509.             SnapGuideComponent& operator= (const SnapGuideComponent&);

  510.         };

  511. 

  512.         void drag (const MouseEvent& e)

  513.         {

  514.             const float snapThreshold = 8.0f;

  515. 

  516.             getDocument().getUndoManager()->undoCurrentTransactionOnly();

  517. 

  518.             Point<int> distance (e.getOffsetFromDragStart());

  519.             snapGuides.clear();

  520. 

  521.             SnapLine snap (0, 0, 0);

  522.             const float snapX = findBestSnapDistance (verticalSnapTargets, getVerticalSnapPositions (distance), snap);

  523.             if (fabsf (snapX) < snapThreshold)

  524.             {

  525.                 distance = Point<int> (distance.getX() + snapX, distance.getY());

  526. 

  527.                 if (snap.position != 0)

  528.                     snapGuides.add (new SnapGuideComponent (snap, true, canvas.overlay));

  529.             }

  530. 

  531.             const float snapY = findBestSnapDistance (horizontalSnapTargets, getHorizontalSnapPositions (distance), snap);

  532.             if (fabsf (snapY) < snapThreshold)

  533.             {

  534.                 distance = Point<int> (distance.getX(), distance.getY() + snapY);

  535. 

  536.                 if (snap.position != 0)

  537.                     snapGuides.add (new SnapGuideComponent (snap, false, canvas.overlay));

  538.             }

  539. 

  540.             for (int n = 50;;)

  541.             {

  542.                 // Need to repeatedly apply the new positions until they all settle down, in case some of

  543.                 // the coords are relative to each other..

  544.                 bool anyUpdated = false;

  545. 

  546.                 for (int i = 0; i < draggedComponents.size(); ++i)

  547.                     if (dragItem (draggedComponents.getReference(i), distance, originalPositions.getReference(i)))

  548.                         anyUpdated = true;

  549. 

  550.                 if (! anyUpdated)

  551.                     break;

  552. 

  553.                 if (--n == 0)

  554.                 {

  555.                     jassertfalse;

  556.                     break;

  557.                 }

  558.             }

  559.         }

  560. 

  561.         bool dragItem (ValueTree& v, const Point<int>& distance, const Rectangle<int>& originalPos)

  562.         {

  563.             const Rectangle<int> newBounds (zone.resizeRectangleBy (originalPos, distance));

  564. 

  565.             RectangleCoordinates pr (getDocument().getCoordsFor (v));

  566.             ScopedPointer<Coordinate::MarkerResolver> markers (getDocument().createMarkerResolver (v));

  567. 

  568.             pr.moveToAbsolute (newBounds, *markers);

  569. 

  570.             return getDocument().setCoordsFor (v, pr);

  571.         }

  572. 

  573.         const Array<SnapLine> getVerticalSnapPositions (const Point<int>& distance) const

  574.         {

  575.             Array<SnapLine> p (verticalSnapPositions);

  576.             for (int i = p.size(); --i >= 0;)

  577.                 p.getReference(i).position += distance.getX();

  578. 

  579.             return p;

  580.         }

  581. 

  582.         const Array<SnapLine> getHorizontalSnapPositions (const Point<int>& distance) const

  583.         {

  584.             Array<SnapLine> p (horizontalSnapPositions);

  585.             for (int i = p.size(); --i >= 0;)

  586.                 p.getReference(i).position += distance.getY();

  587. 

  588.             return p;

  589.         }

  590. 

  591.         static float findBestSnapDistance (const Array<SnapLine>& targets, const Array<SnapLine>& sources, SnapLine& line)

  592.         {

  593.             if (targets.size() == 0 || sources.size() == 0)

  594.                 return 0.0f;

  595. 

  596.             float best = 1.0e10f;

  597.             float absBest = fabsf (best);

  598.             line = SnapLine (1.0e10f, 0, 0);

  599. 

  600.             for (int i = 0; i < targets.size(); ++i)

  601.             {

  602.                 for (int j = 0; j < sources.size(); ++j)

  603.                 {

  604.                     SnapLine& target = targets.getReference(i);

  605.                     SnapLine& source = sources.getReference(j);

  606.                     const float diff = target.position - source.position;

  607.                     const float absDiff = fabsf (diff);

  608. 

  609.                     if (absDiff < absBest)

  610.                     {

  611.                         line = SnapLine (target.position, jmin (target.start, source.start), jmax (target.end, source.end));

  612.                         best = diff;

  613.                         absBest = absDiff;

  614.                     }

  615.                 }

  616.             }

  617. 

  618.             jassert (absBest < 1.0e10f);

  619.             return best;

  620.         }

  621. 

  622.     private:

  623.         Canvas& canvas;

  624.         Array <ValueTree> draggedComponents;

  625.         Array <Rectangle<int> > originalPositions;

  626. 

  627.         Array <SnapLine> verticalSnapPositions, horizontalSnapPositions;

  628.         Array <SnapLine> verticalSnapTargets, horizontalSnapTargets;

  629.         const ResizableBorderComponent::Zone zone;

  630.         OwnedArray<Component> snapGuides;

  631. 

  632.         ComponentDocument& getDocument() throw()         { return canvas.getDocument(); }

  633.     };

  634. 

  635.     void beginDrag (const MouseEvent& e, const ResizableBorderComponent::Zone& zone)

  636.     {

  637.         dragger = new DragOperation (*this, getSelectedComps(), e, zone);

  638.     }

  639. 

  640.     void continueDrag (const MouseEvent& e)

  641.     {

  642.         if (dragger != 0)

  643.             dragger->drag (e);

  644.     }

  645. 

  646.     void endDrag (const MouseEvent& e)

  647.     {

  648.         if (dragger != 0)

  649.         {

  650.             dragger->drag (e);

  651.             dragger = 0;

  652.         }

  653.     }

  654. 

  655. private:

  656.     ComponentEditor& editor;

  657.     const BorderSize border;

  658.     const int resizerThickness;

  659.     ScopedPointer <DragOperation> dragger;

  660.     ResizableBorderComponent::Zone dragZone;

  661.     int dragStartWidth, dragStartHeight;

  662. 

  663.     const Rectangle<int> getContentArea() const

  664.     {

  665.         return border.subtractedFrom (getLocalBounds());

  666.     }

  667. 

  668.     //==============================================================================

  669.     class ComponentResizeFrame    : public Component,

  670.                                     public ComponentListener

  671.     {

  672.     public:

  673.         ComponentResizeFrame (Canvas& canvas_,

  674.                               Component* componentToAttachTo)

  675.             : canvas (canvas_),

  676.               component (componentToAttachTo),

  677.               borderThickness (4)

  678.         {

  679.             componentMovedOrResized (*componentToAttachTo, true, true);

  680.             componentToAttachTo->addComponentListener (this);

  681.         }

  682. 

  683.         ~ComponentResizeFrame()

  684.         {

  685.             if (component != 0)

  686.                 component->removeComponentListener (this);

  687.         }

  688. 

  689.         void paint (Graphics& g)

  690.         {

  691.             g.setColour (Colours::red.withAlpha (0.1f));

  692.             g.drawRect (0, 0, getWidth(), getHeight(), borderThickness);

  693.         }

  694. 

  695.         void mouseEnter (const MouseEvent& e)

  696.         {

  697.             //repaint();

  698.             updateDragZone (e.getPosition());

  699.         }

  700. 

  701.         void mouseExit (const MouseEvent& e)

  702.         {

  703.             //repaint();

  704.             updateDragZone (e.getPosition());

  705.         }

  706. 

  707.         void mouseMove (const MouseEvent& e)

  708.         {

  709.             updateDragZone (e.getPosition());

  710.         }

  711. 

  712.         void mouseDown (const MouseEvent& e)

  713.         {

  714.             jassert (component != 0);

  715. 

  716.             if (component != 0)

  717.             {

  718.                 updateDragZone (e.getPosition());

  719.                 canvas.beginDrag (e, dragZone);

  720.                 canvas.showSizeGuides();

  721.             }

  722.         }

  723. 

  724.         void mouseDrag (const MouseEvent& e)

  725.         {

  726.             if (component != 0)

  727.                 canvas.continueDrag (e);

  728.         }

  729. 

  730.         void mouseUp (const MouseEvent& e)

  731.         {

  732.             canvas.hideSizeGuides();

  733. 

  734.             if (component != 0)

  735.                 canvas.endDrag (e);

  736. 

  737.             updateDragZone (e.getPosition());

  738.         }

  739. 

  740.         void componentMovedOrResized (Component&, bool wasMoved, bool wasResized)

  741.         {

  742.             if (component != 0)

  743.                 setBounds (component->getBounds().expanded (borderThickness, borderThickness));

  744.         }

  745. 

  746.         bool hitTest (int x, int y)

  747.         {

  748.             return ! getCentreArea().contains (x, y);

  749.         }

  750. 

  751.         uint32 getTargetComponentUID() const  { return component == 0 ? 0 : component->getComponentUID(); }

  752. 

  753.         void showSizeGuides()

  754.         {

  755.             if (sizeGuides.size() == 0)

  756.             {

  757.                 const ValueTree v (canvas.getDocument().getComponentState (component));

  758.                 sizeGuides.add (new SizeGuideComponent (canvas.getDocument(), v, component, canvas, SizeGuideComponent::left));

  759.                 sizeGuides.add (new SizeGuideComponent (canvas.getDocument(), v, component, canvas, SizeGuideComponent::right));

  760.                 sizeGuides.add (new SizeGuideComponent (canvas.getDocument(), v, component, canvas, SizeGuideComponent::top));

  761.                 sizeGuides.add (new SizeGuideComponent (canvas.getDocument(), v, component, canvas, SizeGuideComponent::bottom));

  762.             }

  763.         }

  764. 

  765.         void hideSizeGuides()

  766.         {

  767.             sizeGuides.clear();

  768.         }

  769. 

  770.     private:

  771.         Canvas& canvas;

  772.         Component::SafePointer<Component> component;

  773.         ResizableBorderComponent::Zone dragZone;

  774.         const int borderThickness;

  775.         OwnedArray <SizeGuideComponent> sizeGuides;

  776. 

  777.         const Rectangle<int> getCentreArea() const

  778.         {

  779.             return getLocalBounds().reduced (borderThickness, borderThickness);

  780.         }

  781. 

  782.         void updateDragZone (const Point<int>& p)

  783.         {

  784.             ResizableBorderComponent::Zone newZone

  785.                 = ResizableBorderComponent::Zone::fromPositionOnBorder (getLocalBounds(),

  786.                                                                         BorderSize (borderThickness), p);

  787. 

  788.             if (dragZone != newZone)

  789.             {

  790.                 dragZone = newZone;

  791.                 setMouseCursor (newZone.getMouseCursor());

  792.             }

  793.         }

  794.     };

  795. 

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

  797.     class OverlayComponent  : public Component,

  798.                               public LassoSource <ComponentDocument::SelectedItems::ItemType>,

  799.                               public ChangeListener

  800.     {

  801.     public:

  802.         OverlayComponent (Canvas& canvas_)

  803.             : canvas (canvas_)

  804.         {

  805.             setAlwaysOnTop (true);

  806.             setWantsKeyboardFocus (true);

  807.             canvas.getSelection().addChangeListener (this);

  808.         }

  809. 

  810.         ~OverlayComponent()

  811.         {

  812.             canvas.getSelection().removeChangeListener (this);

  813. 

  814.             lasso = 0;

  815.             deleteAllChildren();

  816.         }

  817. 

  818.         void mouseDown (const MouseEvent& e)

  819.         {

  820.             lasso = 0;

  821.             mouseDownCompUID = 0;

  822.             isDraggingClickedComp = false;

  823. 

  824.             if (e.mods.isPopupMenu())

  825.             {

  826.                 PopupMenu m;

  827.                 canvas.getDocument().addNewComponentMenuItems (m);

  828. 

  829.                 const int r = m.show();

  830.                 canvas.getDocument().performNewComponentMenuItem (r);

  831.             }

  832.             else

  833.             {

  834.                 Component* underMouse = canvas.getComponentHolder()->getComponentAt (e.x, e.y);

  835. 

  836.                 if (underMouse == canvas.getComponentHolder())

  837.                     underMouse = 0;

  838. 

  839.                 if (underMouse == 0 || e.mods.isAltDown())

  840.                 {

  841.                     addAndMakeVisible (lasso = new LassoComponent <ComponentDocument::SelectedItems::ItemType>());

  842.                     lasso->beginLasso (e, this);

  843.                 }

  844.                 else

  845.                 {

  846.                     mouseDownCompUID = underMouse->getComponentUID();

  847.                     mouseDownResult = canvas.getSelection().addToSelectionOnMouseDown (mouseDownCompUID, e.mods);

  848. 

  849.                     updateSelectedComponentResizeFrames();

  850.                     hideSizeGuides();

  851.                     showSizeGuides();

  852.                 }

  853.             }

  854.         }

  855. 

  856.         void mouseDrag (const MouseEvent& e)

  857.         {

  858.             if (lasso != 0)

  859.             {

  860.                 lasso->dragLasso (e);

  861.             }

  862.             else if (mouseDownCompUID != 0 && (! e.mouseWasClicked()) && (! e.mods.isPopupMenu()))

  863.             {

  864.                 if (! isDraggingClickedComp)

  865.                 {

  866.                     isDraggingClickedComp = true;

  867.                     canvas.getSelection().addToSelectionOnMouseUp (mouseDownCompUID, e.mods, true, mouseDownResult);

  868.                     canvas.beginDrag (e, ResizableBorderComponent::Zone (ResizableBorderComponent::Zone::centre));

  869.                 }

  870. 

  871.                 canvas.continueDrag (e);

  872.                 showSizeGuides();

  873.             }

  874.         }

  875. 

  876.         void mouseUp (const MouseEvent& e)

  877.         {

  878.             hideSizeGuides();

  879. 

  880.             if (lasso != 0)

  881.             {

  882.                 lasso->endLasso();

  883.                 lasso = 0;

  884. 

  885.                 if (e.mouseWasClicked())

  886.                     canvas.getSelection().deselectAll();

  887.             }

  888.             else if (! e.mods.isPopupMenu())

  889.             {

  890.                 if (! isDraggingClickedComp)

  891.                     canvas.getSelection().addToSelectionOnMouseUp (mouseDownCompUID, e.mods, ! e.mouseWasClicked(), mouseDownResult);

  892.             }

  893. 

  894.             canvas.endDrag (e);

  895.         }

  896. 

  897.         void findLassoItemsInArea (Array <ComponentDocument::SelectedItems::ItemType>& itemsFound, int x, int y, int width, int height)

  898.         {

  899.             const Rectangle<int> lassoArea (x, y, width, height);

  900. 

  901.             for (int i = canvas.getComponentHolder()->getNumChildComponents(); --i >= 0;)

  902.             {

  903.                 Component* c = canvas.getComponentHolder()->getChildComponent(i);

  904.                 if (c->getBounds().intersects (lassoArea))

  905.                     itemsFound.add (c->getComponentUID());

  906.             }

  907.         }

  908. 

  909.         ComponentDocument::SelectedItems& getLassoSelection()   { return canvas.getSelection(); }

  910. 

  911.         void changeListenerCallback (void*)

  912.         {

  913.             updateSelectedComponentResizeFrames();

  914.         }

  915. 

  916.         void modifierKeysChanged (const ModifierKeys&)

  917.         {

  918.             Desktop::getInstance().getMainMouseSource().triggerFakeMove();

  919.         }

  920. 

  921.         void showSizeGuides()

  922.         {

  923.             for (int i = getNumChildComponents(); --i >= 0;)

  924.             {

  925.                 ComponentResizeFrame* resizer = dynamic_cast <ComponentResizeFrame*> (getChildComponent(i));

  926.                 if (resizer != 0)

  927.                     resizer->showSizeGuides();

  928.             }

  929.         }

  930. 

  931.         void hideSizeGuides()

  932.         {

  933.             for (int i = getNumChildComponents(); --i >= 0;)

  934.             {

  935.                 ComponentResizeFrame* resizer = dynamic_cast <ComponentResizeFrame*> (getChildComponent(i));

  936.                 if (resizer != 0)

  937.                     resizer->hideSizeGuides();

  938.             }

  939.         }

  940. 

  941.     private:

  942.         Canvas& canvas;

  943.         ScopedPointer <LassoComponent <ComponentDocument::SelectedItems::ItemType> > lasso;

  944.         bool mouseDownResult, isDraggingClickedComp;

  945.         uint32 mouseDownCompUID;

  946. 

  947.         ComponentResizeFrame* getSelectorFrameFor (Component* c) const

  948.         {

  949.             for (int i = getNumChildComponents(); --i >= 0;)

  950.             {

  951.                 ComponentResizeFrame* resizer = dynamic_cast <ComponentResizeFrame*> (getChildComponent(i));

  952.                 if (resizer != 0 && resizer->getTargetComponentUID() == c->getComponentUID())

  953.                     return resizer;

  954.             }

  955. 

  956.             return 0;

  957.         }

  958. 

  959.         void updateSelectedComponentResizeFrames()

  960.         {

  961.             ComponentDocument::SelectedItems& selection = canvas.getSelection();

  962. 

  963.             int i;

  964.             for (i = getNumChildComponents(); --i >= 0;)

  965.             {

  966.                 ComponentResizeFrame* resizer = dynamic_cast <ComponentResizeFrame*> (getChildComponent(i));

  967. 

  968.                 if (resizer != 0 && ! selection.isSelected (resizer->getTargetComponentUID()))

  969.                     delete resizer;

  970.             }

  971. 

  972.             for (i = canvas.getComponentHolder()->getNumChildComponents(); --i >= 0;)

  973.             {

  974.                 Component* c = canvas.getComponentHolder()->getChildComponent(i);

  975. 

  976.                 if (c != this && selection.isSelected (c->getComponentUID()) && getSelectorFrameFor (c) == 0)

  977.                     addAndMakeVisible (new ComponentResizeFrame (canvas, c));

  978.             }

  979.         }

  980.     };

  981. 

  982.     Component* componentHolder;

  983.     OverlayComponent* overlay;

  984.     ComponentDocument::SelectedItems selection;

  985. 

  986.     Component* getComponentForUID (const uint32 uid) const

  987.     {

  988.         for (int i = componentHolder->getNumChildComponents(); --i >= 0;)

  989.             if (componentHolder->getChildComponent (i)->getComponentUID() == uid)

  990.                 return componentHolder->getChildComponent (i);

  991. 

  992.         return 0;

  993.     }

  994. };

  995. 

  996. //==============================================================================

  997. class ComponentEditor::InfoPanel  : public Component,

  998.                                     public ChangeListener

  999. {

  1000. public:

  1001.     InfoPanel (ComponentEditor& editor_)

  1002.       : editor (editor_)

  1003.     {

  1004.         setOpaque (true);

  1005. 

  1006.         addAndMakeVisible (props = new PropertyPanel());

  1007. 

  1008.         editor.getCanvas()->getSelection().addChangeListener (this);

  1009.     }

  1010. 

  1011.     ~InfoPanel()

  1012.     {

  1013.         editor.getCanvas()->getSelection().removeChangeListener (this);

  1014. 

  1015.         props->clear();

  1016.         deleteAllChildren();

  1017.     }

  1018. 

  1019.     void changeListenerCallback (void*)

  1020.     {

  1021.         Array <PropertyComponent*> newComps;

  1022.         editor.getCanvas()->getSelectedItemProperties (newComps);

  1023. 

  1024.         props->clear();

  1025.         props->addProperties (newComps);

  1026.     }

  1027. 

  1028.     void paint (Graphics& g)

  1029.     {

  1030.         g.fillAll (Colour::greyLevel (0.92f));

  1031.     }

  1032. 

  1033.     void resized()

  1034.     {

  1035.         props->setSize (getWidth(), getHeight());

  1036.     }

  1037. 

  1038. private:

  1039.     ComponentEditor& editor;

  1040.     PropertyPanel* props;

  1041. };

  1042. 

  1043. 

  1044. //==============================================================================

  1045. ComponentEditor::ComponentEditor (OpenDocumentManager::Document* document,

  1046.                                   Project* project_, ComponentDocument* componentDocument_)

  1047.     : DocumentEditorComponent (document),

  1048.       project (project_),

  1049.       componentDocument (componentDocument_),

  1050.       infoPanel (0)

  1051. {

  1052.     setOpaque (true);

  1053. 

  1054.     addAndMakeVisible (viewport = new Viewport());

  1055. 

  1056.     if (document != 0)

  1057.     {

  1058.         viewport->setViewedComponent (new Canvas (*this));

  1059.         addAndMakeVisible (infoPanel = new InfoPanel (*this));

  1060.     }

  1061. }

  1062. 

  1063. ComponentEditor::~ComponentEditor()

  1064. {

  1065.     deleteAndZero (infoPanel);

  1066.     deleteAllChildren();

  1067. }

  1068. 

  1069. void ComponentEditor::paint (Graphics& g)

  1070. {

  1071.     g.fillAll (Colours::white);

  1072. }

  1073. 

  1074. void ComponentEditor::resized()

  1075. {

  1076.     const int infoPanelWidth = 200;

  1077.     viewport->setBounds (0, 0, getWidth() - infoPanelWidth, getHeight());

  1078. 

  1079.     if (infoPanel != 0)

  1080.         infoPanel->setBounds (getWidth() - infoPanelWidth, 0, infoPanelWidth, getHeight());

  1081. }

  1082. 

  1083. ComponentEditor::Canvas* ComponentEditor::getCanvas() const

  1084. {

  1085.     return dynamic_cast <Canvas*> (viewport->getViewedComponent());

  1086. }

  1087. 

  1088. void ComponentEditor::getAllCommands (Array <CommandID>& commands)

  1089. {

  1090.     DocumentEditorComponent::getAllCommands (commands);

  1091. 

  1092.     const CommandID ids[] = { CommandIDs::undo,

  1093.                               CommandIDs::redo };

  1094. 

  1095.     commands.addArray (ids, numElementsInArray (ids));

  1096. }

  1097. 

  1098. void ComponentEditor::getCommandInfo (CommandID commandID, ApplicationCommandInfo& result)

  1099. {

  1100.     result.setActive (document != 0);

  1101. 

  1102.     switch (commandID)

  1103.     {

  1104.     case CommandIDs::undo:

  1105.         result.setInfo ("Undo", "Undoes the last change",

  1106.                         CommandCategories::general, 0);

  1107.         result.defaultKeypresses.add (KeyPress ('z', ModifierKeys::commandModifier, 0));

  1108.         break;

  1109. 

  1110.     case CommandIDs::redo:

  1111.         result.setInfo ("Redo", "Redoes the last change",

  1112.                         CommandCategories::general, 0);

  1113.         result.defaultKeypresses.add (KeyPress ('z', ModifierKeys::shiftModifier | ModifierKeys::commandModifier, 0));

  1114.         result.defaultKeypresses.add (KeyPress ('y', ModifierKeys::commandModifier, 0));

  1115.         break;

  1116. 

  1117.     default:

  1118.         DocumentEditorComponent::getCommandInfo (commandID, result);

  1119.         break;

  1120.     }

  1121. }

  1122. 

  1123. bool ComponentEditor::perform (const InvocationInfo& info)

  1124. {

  1125.     switch (info.commandID)

  1126.     {

  1127.     case CommandIDs::undo:

  1128.         getDocument().getUndoManager()->undo();

  1129.         return true;

  1130. 

  1131.     case CommandIDs::redo:

  1132.         getDocument().getUndoManager()->redo();

  1133.         return true;

  1134. 

  1135.     default:

  1136.         break;

  1137.     }

  1138. 

  1139.     return DocumentEditorComponent::perform (info);

  1140. }