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.
5512 Commits
9 Branches
2.1GB
Tree: fd7a36a177
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'fd7a36a177'
${ noResults }
JUCE/extras/Introjucer/Source/ComponentEditor/properties/jucer_PositionPropertyBase.h

456 lines
16KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2015 - ROLI Ltd.

  6. 

  7.    Permission is granted to use this software under the terms of either:

  8.    a) the GPL v2 (or any later version)

  9.    b) the Affero GPL v3

  10. 

  11.    Details of these licenses can be found at: www.gnu.org/licenses

  12. 

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

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

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

  16. 

  17.    ------------------------------------------------------------------------------

  18. 

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

  20.    available: visit www.juce.com for more information.

  21. 

  22.   ==============================================================================

  23. */

  24. 

  25. #ifndef JUCER_POSITIONPROPERTYBASE_H_INCLUDED

  26. #define JUCER_POSITIONPROPERTYBASE_H_INCLUDED

  27. 

  28. #include "../ui/jucer_PaintRoutineEditor.h"

  29. #include "../ui/jucer_ComponentLayoutEditor.h"

  30. 

  31. //==============================================================================

  32. /**

  33.     Base class for a property that edits the x, y, w, or h of a PositionedRectangle.

  34. */

  35. class PositionPropertyBase  : public PropertyComponent,

  36.                               protected ChangeListener,

  37.                               private ButtonListener

  38. {

  39. public:

  40.     enum ComponentPositionDimension

  41.     {

  42.         componentX          = 0,

  43.         componentY          = 1,

  44.         componentWidth      = 2,

  45.         componentHeight     = 3

  46.     };

  47. 

  48.     PositionPropertyBase (Component* comp,

  49.                           const String& name,

  50.                           ComponentPositionDimension dimension_,

  51.                           const bool includeAnchorOptions_,

  52.                           const bool allowRelativeOptions_,

  53.                           ComponentLayout* layout_)

  54.         : PropertyComponent (name),

  55.           layout (layout_),

  56.           button ("mode"),

  57.           component (comp),

  58.           dimension (dimension_),

  59.           includeAnchorOptions (includeAnchorOptions_),

  60.           allowRelativeOptions (allowRelativeOptions_)

  61.     {

  62.         addAndMakeVisible (button);

  63.         button.addListener (this);

  64.         button.setTriggeredOnMouseDown (true);

  65.         button.setConnectedEdges (TextButton::ConnectedOnLeft | TextButton::ConnectedOnRight);

  66. 

  67.         addAndMakeVisible (textEditor = new PositionPropLabel (*this));

  68.     }

  69. 

  70.     String getText() const

  71.     {

  72.         RelativePositionedRectangle rpr (getPosition());

  73.         PositionedRectangle& p = rpr.rect;

  74.         String s;

  75. 

  76.         switch (dimension)

  77.         {

  78.         case componentX:

  79.             if (p.getPositionModeX() == PositionedRectangle::proportionOfParentSize)

  80.                 s << valueToString (p.getX() * 100.0) << '%';

  81.             else

  82.                 s << valueToString (p.getX());

  83.             break;

  84. 

  85.         case componentY:

  86.             if (p.getPositionModeY() == PositionedRectangle::proportionOfParentSize)

  87.                 s << valueToString (p.getY() * 100.0) << '%';

  88.             else

  89.                 s << valueToString (p.getY());

  90.             break;

  91. 

  92.         case componentWidth:

  93.             if (p.getWidthMode() == PositionedRectangle::proportionalSize)

  94.                 s << valueToString (p.getWidth() * 100.0) << '%';

  95.             else

  96.                 s << valueToString (p.getWidth());

  97.             break;

  98. 

  99.         case componentHeight:

  100.             if (p.getHeightMode() == PositionedRectangle::proportionalSize)

  101.                 s << valueToString (p.getHeight() * 100.0) << '%';

  102.             else

  103.                 s << valueToString (p.getHeight());

  104.             break;

  105. 

  106.         default:

  107.             jassertfalse;

  108.             break;

  109.         };

  110. 

  111.         return s;

  112.     }

  113. 

  114.     static String valueToString (const double n)

  115.     {

  116.         return String (roundToInt (n * 1000.0) / 1000.0);

  117.     }

  118. 

  119.     void setText (const String& newText)

  120.     {

  121.         RelativePositionedRectangle rpr (getPosition());

  122.         PositionedRectangle p (rpr.rect);

  123.         const double value = newText.getDoubleValue();

  124. 

  125.         switch (dimension)

  126.         {

  127.         case componentX:

  128.             if (p.getPositionModeX() == PositionedRectangle::proportionOfParentSize)

  129.                 p.setX (value / 100.0);

  130.             else

  131.                 p.setX (value);

  132.             break;

  133. 

  134.         case componentY:

  135.             if (p.getPositionModeY() == PositionedRectangle::proportionOfParentSize)

  136.                 p.setY (value / 100.0);

  137.             else

  138.                 p.setY (value);

  139.             break;

  140. 

  141.         case componentWidth:

  142.             if (p.getWidthMode() == PositionedRectangle::proportionalSize)

  143.                 p.setWidth (value / 100.0);

  144.             else

  145.                 p.setWidth (value);

  146.             break;

  147. 

  148.         case componentHeight:

  149.             if (p.getHeightMode() == PositionedRectangle::proportionalSize)

  150.                 p.setHeight (value / 100.0);

  151.             else

  152.                 p.setHeight (value);

  153.             break;

  154. 

  155.         default:

  156.             jassertfalse;

  157.             break;

  158.         };

  159. 

  160.         if (p != rpr.rect)

  161.         {

  162.             rpr.rect = p;

  163.             setPosition (rpr);

  164.         }

  165.     }

  166. 

  167.     void changeListenerCallback (ChangeBroadcaster*)

  168.     {

  169.         refresh();

  170.     }

  171. 

  172.     bool showMenu (ComponentLayout* compLayout)

  173.     {

  174.         RelativePositionedRectangle rpr (getPosition());

  175.         PositionedRectangle p (rpr.rect);

  176. 

  177.         PositionedRectangle::AnchorPoint xAnchor = p.getAnchorPointX();

  178.         PositionedRectangle::AnchorPoint yAnchor = p.getAnchorPointY();

  179.         PositionedRectangle::PositionMode xMode = p.getPositionModeX();

  180.         PositionedRectangle::PositionMode yMode = p.getPositionModeY();

  181.         PositionedRectangle::SizeMode sizeW = p.getWidthMode();

  182.         PositionedRectangle::SizeMode sizeH = p.getHeightMode();

  183. 

  184.         String relCompName ("parent");

  185. 

  186.         if (Component* const relComp = compLayout != nullptr ? compLayout->getComponentRelativePosTarget (component, (int) dimension)

  187.                                                              : nullptr)

  188.             relCompName = compLayout->getComponentMemberVariableName (relComp);

  189. 

  190.         jassert (relCompName.isNotEmpty());

  191. 

  192.         PopupMenu m;

  193. 

  194.         if (dimension == componentX || dimension == componentY)

  195.         {

  196.             const PositionedRectangle::PositionMode posMode = (dimension == componentX) ? xMode : yMode;

  197. 

  198.             m.addItem (10, ((dimension == componentX) ? "Absolute distance from left of "

  199.                                                       : "Absolute distance from top of ") + relCompName,

  200.                        true, posMode == PositionedRectangle::absoluteFromParentTopLeft);

  201. 

  202.             m.addItem (11, ((dimension == componentX) ? "Absolute distance from right of "

  203.                                                       : "Absolute distance from bottom of ") + relCompName,

  204.                        true, posMode == PositionedRectangle::absoluteFromParentBottomRight);

  205. 

  206.             m.addItem (12, "Absolute distance from centre of " + relCompName,

  207.                        true, posMode == PositionedRectangle::absoluteFromParentCentre);

  208. 

  209.             m.addItem (13, ((dimension == componentX) ? "Percentage of width of "

  210.                                                       : "Percentage of height of ") + relCompName,

  211.                        true, posMode == PositionedRectangle::proportionOfParentSize);

  212. 

  213.             m.addSeparator();

  214. 

  215.             if (includeAnchorOptions)

  216.             {

  217.                 const PositionedRectangle::AnchorPoint anchor = (dimension == componentX) ? xAnchor : yAnchor;

  218. 

  219.                 m.addItem (14, (dimension == componentX) ? "Anchored at left of component"

  220.                                                          : "Anchored at top of component",

  221.                            true, anchor == PositionedRectangle::anchorAtLeftOrTop);

  222. 

  223.                 m.addItem (15, "Anchored at centre of component", true, anchor == PositionedRectangle::anchorAtCentre);

  224. 

  225.                 m.addItem (16, (dimension == componentX) ? "Anchored at right of component"

  226.                                                          : "Anchored at bottom of component",

  227.                            true, anchor == PositionedRectangle::anchorAtRightOrBottom);

  228.             }

  229.         }

  230.         else

  231.         {

  232.             const PositionedRectangle::SizeMode sizeMode = (dimension == componentWidth) ? sizeW : sizeH;

  233. 

  234.             m.addItem (20, (dimension == componentWidth) ? "Absolute width"

  235.                                                          : "Absolute height",

  236.                        true, sizeMode == PositionedRectangle::absoluteSize);

  237. 

  238.             m.addItem (21, ((dimension == componentWidth) ? "Percentage of width of "

  239.                                                           : "Percentage of height of ") + relCompName,

  240.                        true, sizeMode == PositionedRectangle::proportionalSize);

  241. 

  242.             m.addItem (22, ((dimension == componentWidth) ? "Subtracted from width of "

  243.                                                           : "Subtracted from height of ") + relCompName,

  244.                        true, sizeMode == PositionedRectangle::parentSizeMinusAbsolute);

  245.         }

  246. 

  247. 

  248.         if (allowRelativeOptions && compLayout != nullptr)

  249.         {

  250.             m.addSeparator();

  251.             m.addSubMenu ("Relative to", compLayout->getRelativeTargetMenu (component, (int) dimension));

  252.         }

  253. 

  254.         WeakReference<Component> ref (this);

  255. 

  256.         const int menuResult = m.showAt (&button);

  257. 

  258.         if (menuResult == 0 || ref == nullptr)

  259.             return false;

  260. 

  261.         switch (menuResult)

  262.         {

  263.         case 10:

  264.             if (dimension == componentX)

  265.                 xMode = PositionedRectangle::absoluteFromParentTopLeft;

  266.             else

  267.                 yMode = PositionedRectangle::absoluteFromParentTopLeft;

  268.             break;

  269. 

  270.         case 11:

  271.             if (dimension == componentX)

  272.                 xMode = PositionedRectangle::absoluteFromParentBottomRight;

  273.             else

  274.                 yMode = PositionedRectangle::absoluteFromParentBottomRight;

  275.             break;

  276. 

  277.         case 12:

  278.             if (dimension == componentX)

  279.                 xMode = PositionedRectangle::absoluteFromParentCentre;

  280.             else

  281.                 yMode = PositionedRectangle::absoluteFromParentCentre;

  282.             break;

  283. 

  284.         case 13:

  285.             if (dimension == componentX)

  286.                 xMode = PositionedRectangle::proportionOfParentSize;

  287.             else

  288.                 yMode = PositionedRectangle::proportionOfParentSize;

  289.             break;

  290. 

  291.         case 14:

  292.             if (dimension == componentX)

  293.                 xAnchor = PositionedRectangle::anchorAtLeftOrTop;

  294.             else

  295.                 yAnchor = PositionedRectangle::anchorAtLeftOrTop;

  296.             break;

  297. 

  298.         case 15:

  299.             if (dimension == componentX)

  300.                 xAnchor = PositionedRectangle::anchorAtCentre;

  301.             else

  302.                 yAnchor = PositionedRectangle::anchorAtCentre;

  303.             break;

  304. 

  305.         case 16:

  306.             if (dimension == componentX)

  307.                 xAnchor = PositionedRectangle::anchorAtRightOrBottom;

  308.             else

  309.                 yAnchor = PositionedRectangle::anchorAtRightOrBottom;

  310.             break;

  311. 

  312.         case 20:

  313.             if (dimension == componentWidth)

  314.                 sizeW = PositionedRectangle::absoluteSize;

  315.             else

  316.                 sizeH = PositionedRectangle::absoluteSize;

  317.             break;

  318. 

  319.         case 21:

  320.             if (dimension == componentWidth)

  321.                 sizeW = PositionedRectangle::proportionalSize;

  322.             else

  323.                 sizeH = PositionedRectangle::proportionalSize;

  324.             break;

  325. 

  326.         case 22:

  327.             if (dimension == componentWidth)

  328.                 sizeW = PositionedRectangle::parentSizeMinusAbsolute;

  329.             else

  330.                 sizeH = PositionedRectangle::parentSizeMinusAbsolute;

  331.             break;

  332. 

  333.         default:

  334.             if (allowRelativeOptions && compLayout != nullptr)

  335.                 compLayout->processRelativeTargetMenuResult (component, (int) dimension, menuResult);

  336.             break;

  337.         }

  338. 

  339.         Rectangle<int> parentArea;

  340. 

  341.         if (component->findParentComponentOfClass<ComponentLayoutEditor>() != 0)

  342.             parentArea.setSize (component->getParentWidth(), component->getParentHeight());

  343.         else if (dynamic_cast <PaintRoutineEditor*> (component->getParentComponent()) != 0)

  344.             parentArea = dynamic_cast <PaintRoutineEditor*> (component->getParentComponent())->getComponentArea();

  345.         else

  346.             jassertfalse;

  347. 

  348.         int x, xw, y, yh, w, h;

  349.         rpr.getRelativeTargetBounds (parentArea, compLayout, x, xw, y, yh, w, h);

  350. 

  351.         PositionedRectangle xyRect (p);

  352.         PositionedRectangle whRect (p);

  353. 

  354.         xyRect.setModes (xAnchor, xMode, yAnchor, yMode, sizeW, sizeH,

  355.                          Rectangle<int> (x, y, xw, yh));

  356. 

  357.         whRect.setModes (xAnchor, xMode, yAnchor, yMode, sizeW, sizeH,

  358.                          Rectangle<int> (x, y, w, h));

  359. 

  360.         p.setModes (xAnchor, xMode, yAnchor, yMode, sizeW, sizeH,

  361.                     Rectangle<int> (x, y, xw, yh));

  362. 

  363.         p.setX (xyRect.getX());

  364.         p.setY (xyRect.getY());

  365.         p.setWidth (whRect.getWidth());

  366.         p.setHeight (whRect.getHeight());

  367. 

  368.         if (p != rpr.rect)

  369.         {

  370.             rpr.rect = p;

  371.             setPosition (rpr);

  372.         }

  373. 

  374.         return true;

  375.     }

  376. 

  377.     void resized()

  378.     {

  379.         const Rectangle<int> r (getLookAndFeel().getPropertyComponentContentPosition (*this));

  380. 

  381.         button.changeWidthToFitText (r.getHeight());

  382.         button.setTopRightPosition (r.getRight(), r.getY());

  383. 

  384.         textEditor->setBounds (r.getX(), r.getY(), button.getX() - r.getX(), r.getHeight());

  385.     }

  386. 

  387.     void refresh()

  388.     {

  389.         textEditor->setText (getText(), dontSendNotification);

  390.     }

  391. 

  392.     void buttonClicked (Button*)

  393.     {

  394.         if (showMenu (layout))

  395.             refresh(); // (to clear the text editor if it's got focus)

  396.     }

  397. 

  398.     void textWasEdited()

  399.     {

  400.         const String newText (textEditor->getText());

  401.         if (getText() != newText)

  402.             setText (newText);

  403.     }

  404. 

  405.     //==============================================================================

  406.     virtual void setPosition (const RelativePositionedRectangle& newPos) = 0;

  407. 

  408.     virtual RelativePositionedRectangle getPosition() const = 0;

  409. 

  410. protected:

  411.     class PositionPropLabel  : public Label

  412.     {

  413.         PositionPropertyBase& owner;

  414. 

  415.     public:

  416.         PositionPropLabel (PositionPropertyBase& owner_)

  417.             : Label (String::empty, String::empty),

  418.               owner (owner_)

  419.         {

  420.             setEditable (true, true, false);

  421. 

  422.             setColour (backgroundColourId, Colours::white);

  423.             setColour (textColourId, Colours::black);

  424.             setColour (outlineColourId, findColour (ComboBox::outlineColourId));

  425. 

  426.             setColour (TextEditor::textColourId, Colours::black);

  427.             setColour (TextEditor::backgroundColourId, Colours::white);

  428.             setColour (TextEditor::outlineColourId, findColour (ComboBox::outlineColourId));

  429.         }

  430. 

  431.         TextEditor* createEditorComponent()

  432.         {

  433.             TextEditor* ed = Label::createEditorComponent();

  434.             ed->setInputRestrictions (14, "0123456789.-%");

  435. 

  436.             return ed;

  437.         }

  438. 

  439.         void textWasEdited()

  440.         {

  441.             owner.textWasEdited();

  442.         }

  443.     };

  444. 

  445.     ComponentLayout* layout;

  446.     ScopedPointer<PositionPropLabel> textEditor;

  447.     TextButton button;

  448. 

  449.     Component* component;

  450.     ComponentPositionDimension dimension;

  451.     const bool includeAnchorOptions, allowRelativeOptions;

  452. };

  453. 

  454. 

  455. #endif   // JUCER_POSITIONPROPERTYBASE_H_INCLUDED