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

1347 lines
47KB
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. const float snapDistance = 8.0f;

  31. static const Colour resizableBorderColour (0x7066aaff);

  32. static const Colour alignmentMarkerColour (0x77ff0000);

  33. 

  34. 

  35. //==============================================================================

  36. class SizeGuideComponent   : public Component,

  37.                              public ComponentListener

  38. {

  39. public:

  40.     enum Type    { left, right, top, bottom };

  41. 

  42.     //==============================================================================

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

  44.                         Component& parentForOverlays, Type type_)

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

  46.           font (10.0f)

  47.     {

  48.         component->addComponentListener (this);

  49. 

  50.         setAlwaysOnTop (true);

  51.         parentForOverlays.addAndMakeVisible (this);

  52.         updatePosition();

  53.     }

  54. 

  55.     ~SizeGuideComponent()

  56.     {

  57.         if (component != 0)

  58.             component->removeComponentListener (this);

  59.     }

  60. 

  61.     //==============================================================================

  62.     void paint (Graphics& g)

  63.     {

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

  65. 

  66.         g.setColour (resizableBorderColour);

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

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

  69.                           dashes, 2, 1.0f);

  70. 

  71.         g.setFont (font);

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

  73. 

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

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

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

  77. 

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

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

  80.     }

  81. 

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

  83.     {

  84.         updatePosition();

  85.     }

  86. 

  87.     void componentBeingDeleted (Component&)

  88.     {

  89.         setVisible (false);

  90.         component = 0;

  91.     }

  92. 

  93.     //==============================================================================

  94.     void updatePosition()

  95.     {

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

  97.         Coordinate coord (false);

  98.         bool isHorizontal = false;

  99. 

  100.         switch (type)

  101.         {

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

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

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

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

  106.             default:        jassertfalse; break;

  107.         }

  108. 

  109.         setName (coord.toString());

  110. 

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

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

  113. 

  114.         Point<int> p1, p2;

  115. 

  116.         switch (type)

  117.         {

  118.         case left:

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

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

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

  122.             break;

  123. 

  124.         case right:

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

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

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

  128.             break;

  129. 

  130.         case top:

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

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

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

  134.             break;

  135. 

  136.         case bottom:

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

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

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

  140.             break;

  141. 

  142.         default:

  143.             jassertfalse;

  144.             break;

  145.         }

  146. 

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

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

  149.         setBounds (bounds);

  150. 

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

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

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

  154.         repaint();

  155.     }

  156. 

  157. private:

  158.     ComponentDocument& document;

  159.     ValueTree state;

  160.     Component* component;

  161.     Type type;

  162.     Font font;

  163.     Point<int> lineEnd1, lineEnd2;

  164.     Rectangle<int> textArea;

  165. };

  166. 

  167. //==============================================================================

  168. class ComponentEditor::Canvas   : public Component,

  169.                                   public ValueTree::Listener,

  170.                                   public Timer

  171. {

  172. public:

  173.     //==============================================================================

  174.     Canvas (ComponentEditor& editor_)

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

  176.           dragStartWidth (0), dragStartHeight (0)

  177.     {

  178.         setOpaque (true);

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

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

  181. 

  182.         setSize (500, 500);

  183. 

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

  185.         updateComponents();

  186.     }

  187. 

  188.     ~Canvas()

  189.     {

  190.         dragger = 0;

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

  192.         componentHolder->deleteAllChildren();

  193.         deleteAllChildren();

  194.     }

  195. 

  196.     //==============================================================================

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

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

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

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

  201. 

  202.     void timerCallback()

  203.     {

  204.         stopTimer();

  205. 

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

  207.             getDocument().beginNewTransaction();

  208.     }

  209. 

  210.     //==============================================================================

  211.     void paint (Graphics& g)

  212.     {

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

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

  215. 

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

  217. 

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

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

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

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

  222. 

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

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

  225. 

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

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

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

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

  230.     }

  231. 

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

  233.     {

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

  235.         float pos, tickLength;

  236.         String label;

  237. 

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

  239.         {

  240.             if (pos > 0)

  241.             {

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

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

  244.             }

  245.         }

  246.     }

  247. 

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

  249.     {

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

  251.         float pos, tickLength;

  252.         String label;

  253. 

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

  255.         {

  256.             if (pos > 0)

  257.             {

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

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

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

  261.             }

  262.         }

  263.     }

  264. 

  265.     const Rectangle<int> getContentArea() const

  266.     {

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

  268.     }

  269. 

  270.     //==============================================================================

  271.     void resized()

  272.     {

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

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

  275.         updateComponents();

  276.     }

  277. 

  278.     void updateComponents()

  279.     {

  280.         ComponentDocument& doc = getDocument();

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

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

  283. 

  284.         int i;

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

  286.         {

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

  288. 

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

  290.             {

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

  292.                 delete c;

  293.             }

  294.         }

  295. 

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

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

  298.         {

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

  300.             Component* c = getComponentForState (v);

  301. 

  302.             if (c == 0)

  303.             {

  304.                 c = doc.createComponent (i);

  305.                 componentHolder->addAndMakeVisible (c);

  306.             }

  307. 

  308.             doc.updateComponent (c);

  309.         }

  310. 

  311.         startTimer (500);

  312.     }

  313. 

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

  315.     {

  316.         updateComponents();

  317.     }

  318. 

  319.     void valueTreeChildrenChanged (ValueTree& treeWhoseChildHasChanged)

  320.     {

  321.         updateComponents();

  322.     }

  323. 

  324.     void valueTreeParentChanged (ValueTree& treeWhoseParentHasChanged)

  325.     {

  326.     }

  327. 

  328.     //==============================================================================

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

  330.     {

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

  332. 

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

  334.         {

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

  336.             jassert (c != 0);

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

  338.         }

  339.     }

  340. 

  341.     //==============================================================================

  342.     void mouseMove (const MouseEvent& e)

  343.     {

  344.         updateDragZone (e.getPosition());

  345.     }

  346. 

  347.     void mouseDown (const MouseEvent& e)

  348.     {

  349.         updateDragZone (e.getPosition());

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

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

  352.         showSizeGuides();

  353.     }

  354. 

  355.     void mouseDrag (const MouseEvent& e)

  356.     {

  357.         if (dragZone.isDraggingRightEdge())

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

  359. 

  360.         if (dragZone.isDraggingBottomEdge())

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

  362.     }

  363. 

  364.     void mouseUp (const MouseEvent& e)

  365.     {

  366.         hideSizeGuides();

  367.         updateDragZone (e.getPosition());

  368.     }

  369. 

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

  371.     {

  372.         ResizableBorderComponent::Zone newZone

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

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

  375. 

  376.         if (dragZone != newZone)

  377.         {

  378.             dragZone = newZone;

  379.             setMouseCursor (newZone.getMouseCursor());

  380.         }

  381.     }

  382. 

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

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

  385. 

  386.     //==============================================================================

  387.     class DragOperation

  388.     {

  389.     public:

  390.         DragOperation (Canvas& canvas_,

  391.                        const Array<Component*>& items,

  392.                        const Array<Component*>& itemsToSnapTo,

  393.                        const MouseEvent& e,

  394.                        const ResizableBorderComponent::Zone& zone_)

  395.             : canvas (canvas_),

  396.               zone (zone_)

  397.         {

  398.             int i;

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

  400.             {

  401.                 jassert (items.getUnchecked(i) != 0);

  402.                 const ValueTree v (getDocument().getComponentState (items.getUnchecked(i)));

  403.                 draggedComponents.add (v);

  404.                 const Rectangle<float> floatPos (getComponentPosition (v));

  405. 

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

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

  408. 

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

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

  411. 

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

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

  414. 

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

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

  417. 

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

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

  420. 

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

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

  423.             }

  424. 

  425.             if (isDraggingLeftRight())

  426.             {

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

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

  429. 

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

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

  432.             }

  433. 

  434.             if (isDraggingUpDown())

  435.             {

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

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

  438. 

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

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

  441.             }

  442. 

  443.             for (i = 0; i < itemsToSnapTo.size(); ++i)

  444.             {

  445.                 jassert (itemsToSnapTo.getUnchecked(i) != 0);

  446.                 const ValueTree v (getDocument().getComponentState (itemsToSnapTo.getUnchecked(i)));

  447.                 const Rectangle<float> floatPos (getComponentPosition (v));

  448. 

  449.                 if (isDraggingLeftRight())

  450.                 {

  451.                     verticalSnapTargets.add (SnapLine (floatPos.getX(), floatPos.getY(), floatPos.getBottom()));

  452.                     verticalSnapTargets.add (SnapLine (floatPos.getRight(), floatPos.getY(), floatPos.getBottom()));

  453.                 }

  454. 

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

  456.                     verticalSnapTargets.add (SnapLine (floatPos.getCentreX(), floatPos.getY(), floatPos.getBottom()));

  457. 

  458.                 if (isDraggingUpDown())

  459.                 {

  460.                     horizontalSnapTargets.add (SnapLine (floatPos.getY(), floatPos.getX(), floatPos.getRight()));

  461.                     horizontalSnapTargets.add (SnapLine (floatPos.getBottom(), floatPos.getX(), floatPos.getRight()));

  462.                 }

  463. 

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

  465.                     horizontalSnapTargets.add (SnapLine (floatPos.getCentreY(), floatPos.getX(), floatPos.getRight()));

  466.             }

  467. 

  468.             mergeSnapLines (verticalSnapTargets);

  469.             mergeSnapLines (horizontalSnapTargets);

  470. 

  471.             getDocument().beginNewTransaction();

  472.         }

  473. 

  474.         ~DragOperation()

  475.         {

  476.             getDocument().beginNewTransaction();

  477.         }

  478. 

  479.         //==============================================================================

  480.         struct SnapLine

  481.         {

  482.             SnapLine() : position (0), start (0), end (0)  {}

  483. 

  484.             SnapLine (const float position_, const float start_, const float end_)

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

  486.             {}

  487. 

  488.             float position, start, end;

  489.         };

  490. 

  491.         //==============================================================================

  492.         class AlignmentHintComponent  : public Component

  493.         {

  494.         public:

  495.             AlignmentHintComponent (const SnapLine& line_, bool isVertical_, Component* parent)

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

  497.             {

  498.                 const int extraEndLength = 5;

  499.                 setAlwaysOnTop (true);

  500. 

  501.                 if (isVertical)

  502.                     setBounds (roundToInt (line.position), roundToInt (line.start) - extraEndLength, 1, roundToInt (line.end - line.start) + extraEndLength * 2);

  503.                 else

  504.                     setBounds (roundToInt (line.start) - extraEndLength, roundToInt (line.position), roundToInt (line.end - line.start) + extraEndLength * 2, 1);

  505. 

  506.                 parent->addAndMakeVisible (this);

  507.             }

  508. 

  509.             void paint (Graphics& g)

  510.             {

  511.                 g.fillAll (alignmentMarkerColour);

  512.             }

  513. 

  514.         private:

  515.             const SnapLine line;

  516.             const bool isVertical;

  517. 

  518.             AlignmentHintComponent (const AlignmentHintComponent&);

  519.             AlignmentHintComponent& operator= (const AlignmentHintComponent&);

  520.         };

  521. 

  522.         //==============================================================================

  523.         void drag (const MouseEvent& e)

  524.         {

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

  526. 

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

  528.             if (! isDraggingLeftRight())

  529.                 distance = Point<int> (0, distance.getY());

  530. 

  531.             if (! isDraggingUpDown())

  532.                 distance = Point<int> (distance.getX(), 0);

  533. 

  534.             snapGuides.clear();

  535. 

  536.             performSnap (verticalSnapTargets, getVerticalSnapPositions (distance), true, distance);

  537.             performSnap (horizontalSnapTargets, getHorizontalSnapPositions (distance), false, distance);

  538. 

  539.             for (int n = 50;;)

  540.             {

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

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

  543.                 bool anyUpdated = false;

  544. 

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

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

  547.                         anyUpdated = true;

  548. 

  549.                 if (! anyUpdated)

  550.                     break;

  551. 

  552.                 if (--n == 0)

  553.                 {

  554.                     jassertfalse;

  555.                     break;

  556.                 }

  557.             }

  558.         }

  559. 

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

  561.         {

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

  563. 

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

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

  566. 

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

  568. 

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

  570.         }

  571. 

  572.         //==============================================================================

  573.     private:

  574.         Canvas& canvas;

  575.         Array <ValueTree> draggedComponents;

  576.         Array <Rectangle<int> > originalPositions;

  577.         Array <SnapLine> verticalSnapPositions, horizontalSnapPositions;

  578.         Array <SnapLine> verticalSnapTargets, horizontalSnapTargets;

  579.         const ResizableBorderComponent::Zone zone;

  580.         OwnedArray<Component> snapGuides;

  581. 

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

  583. 

  584.         const Rectangle<float> getComponentPosition (const ValueTree& state)

  585.         {

  586.             RectangleCoordinates relativePos (getDocument().getCoordsFor (state));

  587.             ScopedPointer<Coordinate::MarkerResolver> markers (getDocument().createMarkerResolver (state));

  588.             const Rectangle<int> intPos (relativePos.resolve (*markers));

  589.             originalPositions.add (intPos);

  590. 

  591.             return Rectangle<float> ((float) intPos.getX(), (float) intPos.getY(),

  592.                                      (float) intPos.getWidth(), (float) intPos.getHeight());

  593.         }

  594. 

  595.         static void mergeSnapLines (Array <SnapLine>& lines)

  596.         {

  597.             for (int i = lines.size(); --i > 0;)

  598.             {

  599.                 SnapLine& s1 = lines.getReference(i);

  600. 

  601.                 for (int j = i; --j >= 0;)

  602.                 {

  603.                     SnapLine& s2 = lines.getReference(j);

  604. 

  605.                     if (s1.position == s2.position)

  606.                     {

  607.                         s2.start = jmin (s1.start, s2.start);

  608.                         s2.end = jmax (s1.end, s2.end);

  609.                         lines.remove (i);

  610.                     }

  611.                 }

  612.             }

  613.         }

  614. 

  615.         void performSnap (const Array<SnapLine>& targets, const Array<SnapLine>& sources, bool isVertical, Point<int>& distance)

  616.         {

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

  618.                 return;

  619. 

  620.             float best = std::numeric_limits<float>::max();

  621.             float absBest = fabsf (best);

  622.             Array <SnapLine> lines;

  623. 

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

  625.             {

  626.                 const SnapLine& target = targets.getReference(i);

  627. 

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

  629.                 {

  630.                     const SnapLine& source = sources.getReference(j);

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

  632.                     const float absDiff = fabsf (diff);

  633. 

  634.                     if (absDiff <= absBest)

  635.                     {

  636.                         if (absDiff < absBest)

  637.                             lines.clearQuick();

  638. 

  639.                         lines.add (SnapLine (target.position, jmin (target.start, source.start), jmax (target.end, source.end)));

  640.                         best = diff;

  641.                         absBest = absDiff;

  642.                     }

  643.                 }

  644.             }

  645. 

  646.             jassert (absBest < std::numeric_limits<float>::max());

  647. 

  648.             if (absBest < snapDistance)

  649.             {

  650.                 distance += isVertical ? Point<int> (roundToInt (best), 0) : Point<int> (0, roundToInt (best));

  651. 

  652.                 for (int i = lines.size(); --i >= 0;)

  653.                     if (lines.getReference(i).position != 0)

  654.                         snapGuides.add (new AlignmentHintComponent (lines.getReference(i), isVertical, canvas.overlay));

  655.             }

  656.         }

  657. 

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

  659.         {

  660.             Array<SnapLine> p (verticalSnapPositions);

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

  662.             {

  663.                 SnapLine& s = p.getReference(i);

  664.                 s.position += distance.getX();

  665.                 s.start += distance.getY();

  666.                 s.end += distance.getY();

  667.             }

  668. 

  669.             return p;

  670.         }

  671. 

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

  673.         {

  674.             Array<SnapLine> p (horizontalSnapPositions);

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

  676.             {

  677.                 SnapLine& s = p.getReference(i);

  678.                 s.position += distance.getY();

  679.                 s.start += distance.getX();

  680.                 s.end += distance.getX();

  681.             }

  682. 

  683.             return p;

  684.         }

  685. 

  686.         bool isDraggingLeftRight() const        { return zone.isDraggingWholeObject() || zone.isDraggingLeftEdge() || zone.isDraggingRightEdge(); }

  687.         bool isDraggingUpDown() const           { return zone.isDraggingWholeObject() || zone.isDraggingTopEdge() || zone.isDraggingBottomEdge(); }

  688. 

  689.         DragOperation (const DragOperation&);

  690.         DragOperation& operator= (const DragOperation&);

  691.     };

  692. 

  693.     //==============================================================================

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

  695.     {

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

  697.     }

  698. 

  699.     void continueDrag (const MouseEvent& e)

  700.     {

  701.         if (dragger != 0)

  702.             dragger->drag (e);

  703.     }

  704. 

  705.     void endDrag (const MouseEvent& e)

  706.     {

  707.         if (dragger != 0)

  708.         {

  709.             dragger->drag (e);

  710.             dragger = 0;

  711.         }

  712.     }

  713. 

  714. private:

  715.     ComponentEditor& editor;

  716.     const BorderSize border;

  717.     const int resizerThickness;

  718.     ScopedPointer <DragOperation> dragger;

  719.     ResizableBorderComponent::Zone dragZone;

  720.     int dragStartWidth, dragStartHeight;

  721. 

  722.     //==============================================================================

  723.     class ComponentResizeFrame    : public Component,

  724.                                     public ComponentListener

  725.     {

  726.     public:

  727.         ComponentResizeFrame (Canvas& canvas_,

  728.                               Component* componentToAttachTo)

  729.             : canvas (canvas_),

  730.               component (componentToAttachTo),

  731.               borderThickness (4)

  732.         {

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

  734.             componentToAttachTo->addComponentListener (this);

  735.         }

  736. 

  737.         ~ComponentResizeFrame()

  738.         {

  739.             if (component != 0)

  740.                 component->removeComponentListener (this);

  741.         }

  742. 

  743.         void paint (Graphics& g)

  744.         {

  745.             g.setColour (resizableBorderColour);

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

  747.         }

  748. 

  749.         void mouseEnter (const MouseEvent& e)           { updateDragZone (e.getPosition()); }

  750.         void mouseExit (const MouseEvent& e)            { updateDragZone (e.getPosition()); }

  751.         void mouseMove (const MouseEvent& e)            { updateDragZone (e.getPosition()); }

  752. 

  753.         void mouseDown (const MouseEvent& e)

  754.         {

  755.             jassert (component != 0);

  756. 

  757.             if (component != 0)

  758.             {

  759.                 updateDragZone (e.getPosition());

  760.                 canvas.beginDrag (e, dragZone);

  761.                 canvas.showSizeGuides();

  762.             }

  763.         }

  764. 

  765.         void mouseDrag (const MouseEvent& e)

  766.         {

  767.             if (component != 0)

  768.                 canvas.continueDrag (e);

  769.         }

  770. 

  771.         void mouseUp (const MouseEvent& e)

  772.         {

  773.             canvas.hideSizeGuides();

  774. 

  775.             if (component != 0)

  776.                 canvas.endDrag (e);

  777. 

  778.             updateDragZone (e.getPosition());

  779.         }

  780. 

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

  782.         {

  783.             if (component != 0)

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

  785.         }

  786. 

  787.         bool hitTest (int x, int y)

  788.         {

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

  790.         }

  791. 

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

  793. 

  794.         void showSizeGuides()

  795.         {

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

  797.             {

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

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

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

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

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

  803.             }

  804.         }

  805. 

  806.         void hideSizeGuides()

  807.         {

  808.             sizeGuides.clear();

  809.         }

  810. 

  811.     private:

  812.         Canvas& canvas;

  813.         Component::SafePointer<Component> component;

  814.         ResizableBorderComponent::Zone dragZone;

  815.         const int borderThickness;

  816.         OwnedArray <SizeGuideComponent> sizeGuides;

  817. 

  818.         const Rectangle<int> getCentreArea() const

  819.         {

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

  821.         }

  822. 

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

  824.         {

  825.             ResizableBorderComponent::Zone newZone

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

  827.                                                                         BorderSize (borderThickness), p);

  828. 

  829.             if (dragZone != newZone)

  830.             {

  831.                 dragZone = newZone;

  832.                 setMouseCursor (newZone.getMouseCursor());

  833.             }

  834.         }

  835.     };

  836. 

  837.     //==============================================================================

  838.     class OverlayComponent  : public Component,

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

  840.                               public ChangeListener

  841.     {

  842.     public:

  843.         OverlayComponent (Canvas& canvas_)

  844.             : canvas (canvas_)

  845.         {

  846.             setAlwaysOnTop (true);

  847.             setWantsKeyboardFocus (true);

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

  849.         }

  850. 

  851.         ~OverlayComponent()

  852.         {

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

  854. 

  855.             lasso = 0;

  856.             deleteAllChildren();

  857.         }

  858. 

  859.         //==============================================================================

  860.         void mouseDown (const MouseEvent& e)

  861.         {

  862.             lasso = 0;

  863.             mouseDownCompUID = 0;

  864.             isDraggingClickedComp = false;

  865. 

  866.             if (e.mods.isPopupMenu())

  867.             {

  868.                 PopupMenu m;

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

  870. 

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

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

  873.             }

  874.             else

  875.             {

  876.                 Component* underMouse = 0;

  877. 

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

  879.                 {

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

  881.                     if (c->getBounds().contains (e.getPosition()))

  882.                     {

  883.                         underMouse = c;

  884.                         break;

  885.                     }

  886.                 }

  887. 

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

  889.                 {

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

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

  892.                 }

  893.                 else

  894.                 {

  895.                     mouseDownCompUID = underMouse->getComponentUID();

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

  897. 

  898.                     updateSelectedComponentResizeFrames();

  899.                     hideSizeGuides();

  900.                     showSizeGuides();

  901.                 }

  902.             }

  903.         }

  904. 

  905.         void mouseDrag (const MouseEvent& e)

  906.         {

  907.             if (lasso != 0)

  908.             {

  909.                 lasso->dragLasso (e);

  910.             }

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

  912.             {

  913.                 if (! isDraggingClickedComp)

  914.                 {

  915.                     isDraggingClickedComp = true;

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

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

  918.                 }

  919. 

  920.                 canvas.continueDrag (e);

  921.                 showSizeGuides();

  922.             }

  923.         }

  924. 

  925.         void mouseUp (const MouseEvent& e)

  926.         {

  927.             hideSizeGuides();

  928. 

  929.             if (lasso != 0)

  930.             {

  931.                 lasso->endLasso();

  932.                 lasso = 0;

  933. 

  934.                 if (e.mouseWasClicked())

  935.                     canvas.getSelection().deselectAll();

  936.             }

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

  938.             {

  939.                 if (! isDraggingClickedComp)

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

  941.             }

  942. 

  943.             canvas.endDrag (e);

  944.         }

  945. 

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

  947.         {

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

  949. 

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

  951.             {

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

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

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

  955.             }

  956.         }

  957. 

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

  959. 

  960.         void changeListenerCallback (void*)

  961.         {

  962.             updateSelectedComponentResizeFrames();

  963.         }

  964. 

  965.         void modifierKeysChanged (const ModifierKeys&)

  966.         {

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

  968.         }

  969. 

  970.         void showSizeGuides()

  971.         {

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

  973.             {

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

  975.                 if (resizer != 0)

  976.                     resizer->showSizeGuides();

  977.             }

  978.         }

  979. 

  980.         void hideSizeGuides()

  981.         {

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

  983.             {

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

  985.                 if (resizer != 0)

  986.                     resizer->hideSizeGuides();

  987.             }

  988.         }

  989. 

  990.     private:

  991.         //==============================================================================

  992.         Canvas& canvas;

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

  994.         bool mouseDownResult, isDraggingClickedComp;

  995.         uint32 mouseDownCompUID;

  996. 

  997.         ComponentResizeFrame* getSelectorFrameFor (Component* c) const

  998.         {

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

  1000.             {

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

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

  1003.                     return resizer;

  1004.             }

  1005. 

  1006.             return 0;

  1007.         }

  1008. 

  1009.         void updateSelectedComponentResizeFrames()

  1010.         {

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

  1012. 

  1013.             int i;

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

  1015.             {

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

  1017. 

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

  1019.                     delete resizer;

  1020.             }

  1021. 

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

  1023.             {

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

  1025. 

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

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

  1028.             }

  1029.         }

  1030.     };

  1031. 

  1032.     //==============================================================================

  1033.     Component* componentHolder;

  1034.     OverlayComponent* overlay;

  1035.     ComponentDocument::SelectedItems selection;

  1036. 

  1037.     Component* getComponentForUID (const uint32 uid) const

  1038.     {

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

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

  1041.                 return componentHolder->getChildComponent (i);

  1042. 

  1043.         return 0;

  1044.     }

  1045. 

  1046.     Component* getComponentForState (const ValueTree& state)

  1047.     {

  1048.         ComponentDocument& doc = getDocument();

  1049. 

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

  1051.         {

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

  1053. 

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

  1055.                 return c;

  1056.         }

  1057. 

  1058.         return 0;

  1059.     }

  1060. 

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

  1062.     {

  1063.         Array<Component*> comps;

  1064. 

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

  1066.         {

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

  1068.             jassert (c != 0);

  1069.             if (c != 0)

  1070.                 comps.add (c);

  1071.         }

  1072. 

  1073.         return comps;

  1074.     }

  1075. 

  1076.     const Array<Component*> getUnselectedComps() const

  1077.     {

  1078.         Array<Component*> comps;

  1079. 

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

  1081.             if (! selection.isSelected (componentHolder->getChildComponent(i)->getComponentUID()))

  1082.                 comps.add (componentHolder->getChildComponent(i));

  1083. 

  1084.         return comps;

  1085.     }

  1086. };

  1087. 

  1088. //==============================================================================

  1089. class ComponentEditor::ClassInfoHolder  : public Component

  1090. {

  1091. public:

  1092.     ClassInfoHolder (ComponentEditor& editor_)

  1093.         : editor (editor_)

  1094.     {

  1095.         addAndMakeVisible (panel = new PropertyPanelWithTooltips());

  1096. 

  1097.         Array <PropertyComponent*> props;

  1098.         editor.getDocument().createClassProperties (props);

  1099.         panel->getPanel()->addSection ("Component Properties", props, true);

  1100.     }

  1101. 

  1102.     ~ClassInfoHolder()

  1103.     {

  1104.         deleteAllChildren();

  1105.     }

  1106. 

  1107.     void resized()

  1108.     {

  1109.         panel->setBounds (getLocalBounds());

  1110.     }

  1111. 

  1112. private:

  1113.     ComponentEditor& editor;

  1114.     PropertyPanelWithTooltips* panel;

  1115. };

  1116. 

  1117. //==============================================================================

  1118. class ComponentEditor::LayoutEditorHolder  : public Component

  1119. {

  1120. public:

  1121.     LayoutEditorHolder (ComponentEditor& editor_)

  1122.         : editor (editor_), infoPanel (0)

  1123.     {

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

  1125.     }

  1126. 

  1127.     ~LayoutEditorHolder()

  1128.     {

  1129.         deleteAndZero (infoPanel);

  1130.         deleteAllChildren();

  1131.     }

  1132. 

  1133.     void createCanvas()

  1134.     {

  1135.         viewport->setViewedComponent (new Canvas (editor));

  1136.         addAndMakeVisible (infoPanel = new InfoPanel (editor));

  1137.     }

  1138. 

  1139.     void resized()

  1140.     {

  1141.         const int infoPanelWidth = 200;

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

  1143. 

  1144.         if (infoPanel != 0)

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

  1146.     }

  1147. 

  1148.     Viewport* getViewport() const   { return viewport; }

  1149. 

  1150. private:

  1151.     class InfoPanel  : public Component,

  1152.                        public ChangeListener

  1153.     {

  1154.     public:

  1155.         InfoPanel (ComponentEditor& editor_)

  1156.           : editor (editor_)

  1157.         {

  1158.             setOpaque (true);

  1159. 

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

  1161. 

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

  1163.         }

  1164. 

  1165.         ~InfoPanel()

  1166.         {

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

  1168. 

  1169.             props->clear();

  1170.             deleteAllChildren();

  1171.         }

  1172. 

  1173.         void changeListenerCallback (void*)

  1174.         {

  1175.             Array <PropertyComponent*> newComps;

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

  1177. 

  1178.             props->clear();

  1179.             props->addProperties (newComps);

  1180.         }

  1181. 

  1182.         void paint (Graphics& g)

  1183.         {

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

  1185.         }

  1186. 

  1187.         void resized()

  1188.         {

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

  1190.         }

  1191. 

  1192.     private:

  1193.         ComponentEditor& editor;

  1194.         PropertyPanel* props;

  1195.     };

  1196. 

  1197.     ComponentEditor& editor;

  1198.     Viewport* viewport;

  1199.     InfoPanel* infoPanel;

  1200. };

  1201. 

  1202. //==============================================================================

  1203. class ComponentEditor::BackgroundEditorHolder  : public Component

  1204. {

  1205. public:

  1206.     BackgroundEditorHolder (ComponentEditor& editor_)

  1207.         : editor (editor_)

  1208.     {

  1209.     }

  1210. 

  1211.     ~BackgroundEditorHolder()

  1212.     {

  1213.     }

  1214. 

  1215. private:

  1216.     ComponentEditor& editor;

  1217. };

  1218. 

  1219. //==============================================================================

  1220. class ComponentEditor::CodeEditorHolder  : public Component

  1221. {

  1222. public:

  1223.     CodeEditorHolder (ComponentEditor& editor_)

  1224.         : editor (editor_)

  1225.     {

  1226.     }

  1227. 

  1228.     ~CodeEditorHolder()

  1229.     {

  1230.     }

  1231. 

  1232. private:

  1233.     ComponentEditor& editor;

  1234. };

  1235. 

  1236. //==============================================================================

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

  1238.                                   Project* project_, ComponentDocument* componentDocument_)

  1239.     : DocumentEditorComponent (document),

  1240.       project (project_),

  1241.       componentDocument (componentDocument_),

  1242.       classInfoHolder (0),

  1243.       layoutEditorHolder (0),

  1244.       backgroundEditorHolder (0),

  1245.       codeEditorHolder (0)

  1246. {

  1247.     setOpaque (true);

  1248. 

  1249.     if (componentDocument != 0)

  1250.     {

  1251.         classInfoHolder = new ClassInfoHolder (*this);

  1252.         layoutEditorHolder = new LayoutEditorHolder (*this);

  1253.         backgroundEditorHolder = new BackgroundEditorHolder (*this);

  1254.         codeEditorHolder = new CodeEditorHolder (*this);

  1255.         layoutEditorHolder->createCanvas();

  1256.     }

  1257. 

  1258.     addAndMakeVisible (tabs = new TabbedComponent (TabbedButtonBar::TabsAtRight));

  1259.     tabs->setTabBarDepth (22);

  1260. 

  1261.     tabs->addTab ("Class Settings", Colour::greyLevel (0.88f), classInfoHolder, true);

  1262.     tabs->addTab ("Components", Colours::white, layoutEditorHolder, true);

  1263.     tabs->addTab ("Background", Colours::white, backgroundEditorHolder, true);

  1264.     tabs->addTab ("Source Code", Colours::white, codeEditorHolder, true);

  1265. 

  1266.     tabs->setCurrentTabIndex (1);

  1267. }

  1268. 

  1269. ComponentEditor::~ComponentEditor()

  1270. {

  1271.     deleteAllChildren();

  1272. }

  1273. 

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

  1275. {

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

  1277. }

  1278. 

  1279. void ComponentEditor::resized()

  1280. {

  1281.     tabs->setBounds (getLocalBounds());

  1282. }

  1283. 

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

  1285. {

  1286.     return dynamic_cast <Canvas*> (getViewport()->getViewedComponent());

  1287. }

  1288. 

  1289. Viewport* ComponentEditor::getViewport() const

  1290. {

  1291.     return layoutEditorHolder->getViewport();

  1292. }

  1293. 

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

  1295. {

  1296.     DocumentEditorComponent::getAllCommands (commands);

  1297. 

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

  1299.                               CommandIDs::redo };

  1300. 

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

  1302. }

  1303. 

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

  1305. {

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

  1307. 

  1308.     switch (commandID)

  1309.     {

  1310.     case CommandIDs::undo:

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

  1312.                         CommandCategories::general, 0);

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

  1314.         break;

  1315. 

  1316.     case CommandIDs::redo:

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

  1318.                         CommandCategories::general, 0);

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

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

  1321.         break;

  1322. 

  1323.     default:

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

  1325.         break;

  1326.     }

  1327. }

  1328. 

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

  1330. {

  1331.     switch (info.commandID)

  1332.     {

  1333.     case CommandIDs::undo:

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

  1335.         return true;

  1336. 

  1337.     case CommandIDs::redo:

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

  1339.         return true;

  1340. 

  1341.     default:

  1342.         break;

  1343.     }

  1344. 

  1345.     return DocumentEditorComponent::perform (info);

  1346. }