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.
7201 Commits
9 Branches
1.8GB
Tree: 750ab85fe9
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '750ab85fe9'
${ noResults }
JUCE/extras/Projucer/Source/ComponentEditor/components/jucer_SliderHandler.h

701 lines
27KB
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. static const Slider::SliderStyle sliderStyleTypes[] =

  26. {

  27.     Slider::LinearHorizontal,

  28.     Slider::LinearVertical,

  29.     Slider::LinearBar,

  30.     Slider::LinearBarVertical,

  31.     Slider::Rotary,

  32.     Slider::RotaryHorizontalDrag,

  33.     Slider::RotaryVerticalDrag,

  34.     Slider::RotaryHorizontalVerticalDrag,

  35.     Slider::IncDecButtons,

  36.     Slider::TwoValueHorizontal,

  37.     Slider::TwoValueVertical,

  38.     Slider::ThreeValueHorizontal,

  39.     Slider::ThreeValueVertical

  40. };

  41. 

  42. static const Slider::TextEntryBoxPosition sliderTextBoxPositions[] =

  43. {

  44.     Slider::NoTextBox,

  45.     Slider::TextBoxLeft,

  46.     Slider::TextBoxRight,

  47.     Slider::TextBoxAbove,

  48.     Slider::TextBoxBelow

  49. };

  50. 

  51. 

  52. struct SliderHandler  : public ComponentTypeHandler

  53. {

  54.     SliderHandler()

  55.         : ComponentTypeHandler ("Slider", "Slider", typeid (Slider), 150, 24)

  56.     {

  57.         registerColour (Slider::backgroundColourId, "background", "bkgcol");

  58.         registerColour (Slider::thumbColourId, "thumb", "thumbcol");

  59.         registerColour (Slider::trackColourId, "track", "trackcol");

  60.         registerColour (Slider::rotarySliderFillColourId, "rotary fill", "rotarysliderfill");

  61.         registerColour (Slider::rotarySliderOutlineColourId, "rotary outln", "rotaryslideroutline");

  62.         registerColour (Slider::textBoxTextColourId, "textbox text", "textboxtext");

  63.         registerColour (Slider::textBoxBackgroundColourId, "textbox bkgd", "textboxbkgd");

  64.         registerColour (Slider::textBoxHighlightColourId, "textbox highlt", "textboxhighlight");

  65.         registerColour (Slider::textBoxOutlineColourId, "textbox outln", "textboxoutline");

  66.     }

  67. 

  68.     Component* createNewComponent (JucerDocument*) override

  69.     {

  70.         return new Slider ("new slider");

  71.     }

  72. 

  73.     XmlElement* createXmlFor (Component* comp, const ComponentLayout* layout) override

  74.     {

  75.         XmlElement* e = ComponentTypeHandler::createXmlFor (comp, layout);

  76. 

  77.         Slider* s = dynamic_cast<Slider*> (comp);

  78.         e->setAttribute ("min", s->getMinimum());

  79.         e->setAttribute ("max", s->getMaximum());

  80.         e->setAttribute ("int", s->getInterval());

  81.         e->setAttribute ("style", sliderStyleToString (s->getSliderStyle()));

  82.         e->setAttribute ("textBoxPos", textBoxPosToString (s->getTextBoxPosition()));

  83.         e->setAttribute ("textBoxEditable", s->isTextBoxEditable());

  84.         e->setAttribute ("textBoxWidth", s->getTextBoxWidth());

  85.         e->setAttribute ("textBoxHeight", s->getTextBoxHeight());

  86.         e->setAttribute ("skewFactor", s->getSkewFactor());

  87.         e->setAttribute ("needsCallback", needsSliderListener (s));

  88. 

  89.         return e;

  90.     }

  91. 

  92.     bool restoreFromXml (const XmlElement& xml, Component* comp, const ComponentLayout* layout) override

  93.     {

  94.         if (! ComponentTypeHandler::restoreFromXml (xml, comp, layout))

  95.             return false;

  96. 

  97.         Slider* const s = dynamic_cast<Slider*> (comp);

  98. 

  99.         s->setRange (xml.getDoubleAttribute ("min", 0.0),

  100.                      xml.getDoubleAttribute ("max", 10.0),

  101.                      xml.getDoubleAttribute ("int", 0.0));

  102. 

  103.         s->setSliderStyle (sliderStringToStyle (xml.getStringAttribute ("style", "LinearHorizontal")));

  104. 

  105.         s->setTextBoxStyle (stringToTextBoxPos (xml.getStringAttribute ("textBoxPos", "TextBoxLeft")),

  106.                             ! xml.getBoolAttribute ("textBoxEditable", true),

  107.                             xml.getIntAttribute ("textBoxWidth", 80),

  108.                             xml.getIntAttribute ("textBoxHeight", 20));

  109. 

  110.         s->setSkewFactor (xml.getDoubleAttribute ("skewFactor", 1.0));

  111. 

  112.         setNeedsSliderListener (s, xml.getBoolAttribute ("needsCallback", true));

  113. 

  114.         return true;

  115.     }

  116. 

  117.     String getCreationParameters (GeneratedCode&, Component* component) override

  118.     {

  119.         return quotedString (component->getName(), false);

  120.     }

  121. 

  122.     void fillInCreationCode (GeneratedCode& code, Component* component, const String& memberVariableName) override

  123.     {

  124.         ComponentTypeHandler::fillInCreationCode (code, component, memberVariableName);

  125. 

  126.         Slider* const s = dynamic_cast<Slider*> (component);

  127. 

  128.         String r;

  129.         r << memberVariableName << "->setRange ("

  130.           << s->getMinimum() << ", " << s->getMaximum() << ", " << s->getInterval()

  131.           << ");\n"

  132.           << memberVariableName << "->setSliderStyle (Slider::"

  133.           << sliderStyleToString (s->getSliderStyle()) << ");\n"

  134.           << memberVariableName << "->setTextBoxStyle (Slider::"

  135.           << textBoxPosToString (s->getTextBoxPosition())

  136.           << ", " << CodeHelpers::boolLiteral (! s->isTextBoxEditable())

  137.           << ", " << s->getTextBoxWidth() << ", " << s->getTextBoxHeight() << ");\n"

  138.           << getColourIntialisationCode (component, memberVariableName);

  139. 

  140.         if (needsSliderListener (component))

  141.             r << memberVariableName << "->addListener (this);\n";

  142. 

  143.         if (s->getSkewFactor() != 1.0)

  144.             r << memberVariableName << "->setSkewFactor (" << s->getSkewFactor() << ");\n";

  145. 

  146.         r << '\n';

  147.         code.constructorCode += r;

  148.     }

  149. 

  150.     void fillInGeneratedCode (Component* component, GeneratedCode& code) override

  151.     {

  152.         ComponentTypeHandler::fillInGeneratedCode (component, code);

  153. 

  154.         if (needsSliderListener (component))

  155.         {

  156.             String& callback = code.getCallbackCode ("public SliderListener",

  157.                                                      "void",

  158.                                                      "sliderValueChanged (Slider* sliderThatWasMoved)",

  159.                                                      true);

  160. 

  161.             if (callback.isNotEmpty())

  162.                 callback << "else ";

  163. 

  164.             const String memberVariableName (code.document->getComponentLayout()->getComponentMemberVariableName (component));

  165.             const String userCodeComment ("UserSliderCode_" + memberVariableName);

  166. 

  167.             callback

  168.                 << "if (sliderThatWasMoved == " << memberVariableName

  169.                 << ")\n{\n    //[" << userCodeComment << "] -- add your slider handling code here..\n    //[/" << userCodeComment << "]\n}\n";

  170.         }

  171.     }

  172. 

  173.     void getEditableProperties (Component* component, JucerDocument& document, Array<PropertyComponent*>& props) override

  174.     {

  175.         ComponentTypeHandler::getEditableProperties (component, document, props);

  176. 

  177.         Slider* s = dynamic_cast<Slider*> (component);

  178.         jassert (s != 0);

  179. 

  180.         props.add (new SliderRangeProperty (s, document, "minimum", 0));

  181.         props.add (new SliderRangeProperty (s, document, "maximum", 1));

  182.         props.add (new SliderRangeProperty (s, document, "interval", 2));

  183.         props.add (new SliderTypeProperty (s, document));

  184.         props.add (new SliderTextboxProperty (s, document));

  185.         props.add (new SliderTextboxEditableProperty (s, document));

  186.         props.add (new SliderTextboxSizeProperty (s, document, true));

  187.         props.add (new SliderTextboxSizeProperty (s, document, false));

  188.         props.add (new SliderSkewProperty (s, document));

  189.         props.add (new SliderCallbackProperty (s, document));

  190. 

  191.         addColourProperties (component, document, props);

  192.     }

  193. 

  194.     static bool needsSliderListener (Component* slider)

  195.     {

  196.         return slider->getProperties().getWithDefault ("generateListenerCallback", true);

  197.     }

  198. 

  199.     static void setNeedsSliderListener (Component* slider, bool shouldDoCallback)

  200.     {

  201.         slider->getProperties().set ("generateListenerCallback", shouldDoCallback);

  202.     }

  203. 

  204. private:

  205.     //==============================================================================

  206.     struct SliderTypeProperty  : public ComponentChoiceProperty<Slider>

  207.     {

  208.         SliderTypeProperty (Slider* slider, JucerDocument& doc)

  209.             : ComponentChoiceProperty<Slider> ("type", slider, doc)

  210.         {

  211.             choices.add ("Linear Horizontal");

  212.             choices.add ("Linear Vertical");

  213.             choices.add ("Linear Bar Horizontal");

  214.             choices.add ("Linear Bar Vertical");

  215.             choices.add ("Rotary");

  216.             choices.add ("Rotary HorizontalDrag");

  217.             choices.add ("Rotary VerticalDrag");

  218.             choices.add ("Rotary HorizontalVerticalDrag");

  219.             choices.add ("Inc/Dec Buttons");

  220.             choices.add ("Two Value Horizontal");

  221.             choices.add ("Two Value Vertical");

  222.             choices.add ("Three Value Horizontal");

  223.             choices.add ("Three Value Vertical");

  224.         }

  225. 

  226.         void setIndex (int newIndex) override

  227.         {

  228.             if (newIndex >= 0 && newIndex < numElementsInArray (sliderStyleTypes))

  229.                 document.perform (new SliderTypeChangeAction (component, *document.getComponentLayout(),

  230.                                                               sliderStyleTypes[newIndex]),

  231.                                   "Change Slider style");

  232.         }

  233. 

  234.         int getIndex() const override

  235.         {

  236.             for (int i = 0; i < numElementsInArray (sliderStyleTypes); ++i)

  237.                 if (sliderStyleTypes[i] == dynamic_cast<Slider*> (component)->getSliderStyle())

  238.                     return i;

  239. 

  240.             return -1;

  241.         }

  242. 

  243.     private:

  244.         struct SliderTypeChangeAction  : public ComponentUndoableAction<Slider>

  245.         {

  246.             SliderTypeChangeAction (Slider* comp, ComponentLayout& l, Slider::SliderStyle newState_)

  247.                 : ComponentUndoableAction<Slider> (comp, l),

  248.                   newState (newState_)

  249.             {

  250.                 oldState = comp->getSliderStyle();

  251.             }

  252. 

  253.             bool perform() override

  254.             {

  255.                 showCorrectTab();

  256.                 getComponent()->setSliderStyle (newState);

  257.                 changed();

  258.                 return true;

  259.             }

  260. 

  261.             bool undo() override

  262.             {

  263.                 showCorrectTab();

  264.                 getComponent()->setSliderStyle (oldState);

  265.                 changed();

  266.                 return true;

  267.             }

  268. 

  269.             Slider::SliderStyle newState, oldState;

  270.         };

  271.     };

  272. 

  273.     //==============================================================================

  274.     struct SliderTextboxProperty  : public ComponentChoiceProperty<Slider>

  275.     {

  276.         SliderTextboxProperty (Slider* slider, JucerDocument& doc)

  277.             : ComponentChoiceProperty<Slider> ("text position", slider, doc)

  278.         {

  279.             choices.add ("No text box");

  280.             choices.add ("Text box on left");

  281.             choices.add ("Text box on right");

  282.             choices.add ("Text box above");

  283.             choices.add ("Text box below");

  284.         }

  285. 

  286.         void setIndex (int newIndex) override

  287.         {

  288.             if (newIndex >= 0 && newIndex < numElementsInArray (sliderTextBoxPositions))

  289.                 document.perform (new SliderTextBoxChangeAction (component, *document.getComponentLayout(),

  290.                                                                  sliderTextBoxPositions[newIndex]),

  291.                                   "Change Slider textbox");

  292.         }

  293. 

  294.         int getIndex() const override

  295.         {

  296.             for (int i = 0; i < numElementsInArray (sliderTextBoxPositions); ++i)

  297.                 if (sliderTextBoxPositions[i] == component->getTextBoxPosition())

  298.                     return i;

  299. 

  300.             return -1;

  301.         }

  302. 

  303.     private:

  304.         struct SliderTextBoxChangeAction  : public ComponentUndoableAction<Slider>

  305.         {

  306.             SliderTextBoxChangeAction (Slider* comp, ComponentLayout& l, Slider::TextEntryBoxPosition newState_)

  307.                 : ComponentUndoableAction<Slider> (comp, l),

  308.                   newState (newState_)

  309.             {

  310.                 oldState = comp->getTextBoxPosition();

  311.             }

  312. 

  313.             bool perform() override

  314.             {

  315.                 showCorrectTab();

  316.                 getComponent()->setTextBoxStyle (newState,

  317.                                                  ! getComponent()->isTextBoxEditable(),

  318.                                                  getComponent()->getTextBoxWidth(),

  319.                                                  getComponent()->getTextBoxHeight());

  320.                 changed();

  321.                 return true;

  322.             }

  323. 

  324.             bool undo() override

  325.             {

  326.                 showCorrectTab();

  327.                 getComponent()->setTextBoxStyle (oldState,

  328.                                                  ! getComponent()->isTextBoxEditable(),

  329.                                                  getComponent()->getTextBoxWidth(),

  330.                                                  getComponent()->getTextBoxHeight());

  331.                 changed();

  332.                 return true;

  333.             }

  334. 

  335.             Slider::TextEntryBoxPosition newState, oldState;

  336.         };

  337.     };

  338. 

  339.     //==============================================================================

  340.     struct SliderTextboxEditableProperty  : public ComponentBooleanProperty<Slider>

  341.     {

  342.         SliderTextboxEditableProperty (Slider* slider, JucerDocument& doc)

  343.             : ComponentBooleanProperty<Slider> ("text box mode", "Editable", "Editable", slider, doc)

  344.         {

  345.         }

  346. 

  347.         void setState (bool newState) override

  348.         {

  349.             document.perform (new SliderEditableChangeAction (component, *document.getComponentLayout(), newState),

  350.                               "Change Slider editability");

  351.         }

  352. 

  353.         bool getState() const override

  354.         {

  355.             return component->isTextBoxEditable();

  356.         }

  357. 

  358.     private:

  359.         struct SliderEditableChangeAction  : public ComponentUndoableAction<Slider>

  360.         {

  361.             SliderEditableChangeAction (Slider* const comp, ComponentLayout& l, bool newState_)

  362.                 : ComponentUndoableAction<Slider> (comp, l),

  363.                   newState (newState_)

  364.             {

  365.                 oldState = comp->isTextBoxEditable();

  366.             }

  367. 

  368.             bool perform() override

  369.             {

  370.                 showCorrectTab();

  371.                 getComponent()->setTextBoxIsEditable (newState);

  372.                 changed();

  373.                 return true;

  374.             }

  375. 

  376.             bool undo() override

  377.             {

  378.                 showCorrectTab();

  379.                 getComponent()->setTextBoxIsEditable (oldState);

  380.                 changed();

  381.                 return true;

  382.             }

  383. 

  384.             bool newState, oldState;

  385.         };

  386.     };

  387. 

  388.     //==============================================================================

  389.     struct SliderCallbackProperty  : public ComponentBooleanProperty<Slider>

  390.     {

  391.         SliderCallbackProperty (Slider* s, JucerDocument& doc)

  392.             : ComponentBooleanProperty<Slider> ("callback", "Generate SliderListener",

  393.                                                 "Generate SliderListener", s, doc)

  394.         {

  395.         }

  396. 

  397.         void setState (bool newState) override

  398.         {

  399.             document.perform (new SliderCallbackChangeAction (component, *document.getComponentLayout(), newState),

  400.                               "Change button callback");

  401.         }

  402. 

  403.         bool getState() const override       { return needsSliderListener (component); }

  404. 

  405.         struct SliderCallbackChangeAction  : public ComponentUndoableAction<Slider>

  406.         {

  407.             SliderCallbackChangeAction (Slider* comp, ComponentLayout& l, bool newState_)

  408.                 : ComponentUndoableAction<Slider> (comp, l),

  409.                   newState (newState_)

  410.             {

  411.                 oldState = needsSliderListener (comp);

  412.             }

  413. 

  414.             bool perform() override

  415.             {

  416.                 showCorrectTab();

  417.                 setNeedsSliderListener (getComponent(), newState);

  418.                 changed();

  419.                 return true;

  420.             }

  421. 

  422.             bool undo() override

  423.             {

  424.                 showCorrectTab();

  425.                 setNeedsSliderListener (getComponent(), oldState);

  426.                 changed();

  427.                 return true;

  428.             }

  429. 

  430.             bool newState, oldState;

  431.         };

  432.     };

  433. 

  434.     //==============================================================================

  435.     struct SliderTextboxSizeProperty  : public ComponentTextProperty<Slider>

  436.     {

  437.         SliderTextboxSizeProperty (Slider* slider, JucerDocument& doc, bool isWidth_)

  438.             : ComponentTextProperty<Slider> (isWidth_ ? "text box width" : "text box height",

  439.                                              12, false, slider, doc),

  440.               isWidth (isWidth_)

  441.         {

  442.         }

  443. 

  444.         void setText (const String& newText) override

  445.         {

  446.             document.perform (new SliderBoxSizeChangeAction (component, *document.getComponentLayout(), isWidth, newText.getIntValue()),

  447.                               "Change Slider textbox size");

  448.         }

  449. 

  450.         String getText() const override

  451.         {

  452.             return String (isWidth ? component->getTextBoxWidth()

  453.                                    : component->getTextBoxHeight());

  454.         }

  455. 

  456.     private:

  457.         const bool isWidth;

  458. 

  459.         struct SliderBoxSizeChangeAction  : public ComponentUndoableAction<Slider>

  460.         {

  461.             SliderBoxSizeChangeAction (Slider* const comp, ComponentLayout& l, bool isWidth_, int newSize_)

  462.                 : ComponentUndoableAction<Slider> (comp, l),

  463.                   isWidth (isWidth_),

  464.                   newSize (newSize_)

  465.             {

  466.                 oldSize = isWidth ? comp->getTextBoxWidth()

  467.                                   : comp->getTextBoxHeight();

  468.             }

  469. 

  470.             bool perform() override

  471.             {

  472.                 showCorrectTab();

  473.                 Slider& c = *getComponent();

  474. 

  475.                 if (isWidth)

  476.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  477.                                        ! c.isTextBoxEditable(),

  478.                                        newSize,

  479.                                        c.getTextBoxHeight());

  480.                 else

  481.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  482.                                        ! c.isTextBoxEditable(),

  483.                                        c.getTextBoxWidth(),

  484.                                        newSize);

  485.                 changed();

  486.                 return true;

  487.             }

  488. 

  489.             bool undo() override

  490.             {

  491.                 showCorrectTab();

  492.                 Slider& c = *getComponent();

  493. 

  494.                 if (isWidth)

  495.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  496.                                        ! c.isTextBoxEditable(),

  497.                                        oldSize,

  498.                                        c.getTextBoxHeight());

  499.                 else

  500.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  501.                                        ! c.isTextBoxEditable(),

  502.                                        c.getTextBoxWidth(),

  503.                                        oldSize);

  504.                 changed();

  505.                 return true;

  506.             }

  507. 

  508.             bool isWidth;

  509.             int newSize, oldSize;

  510.         };

  511.     };

  512. 

  513.     //==============================================================================

  514.     struct SliderRangeProperty  : public ComponentTextProperty<Slider>

  515.     {

  516.         SliderRangeProperty (Slider* slider, JucerDocument& doc,

  517.                              const String& name, int rangeParam_)

  518.             : ComponentTextProperty<Slider> (name, 15, false, slider, doc),

  519.               rangeParam (rangeParam_)

  520.         {

  521.         }

  522. 

  523.         void setText (const String& newText) override

  524.         {

  525.             double state [3];

  526.             state [0] = component->getMinimum();

  527.             state [1] = component->getMaximum();

  528.             state [2] = component->getInterval();

  529. 

  530.             state [rangeParam] = newText.getDoubleValue();

  531. 

  532.             document.perform (new SliderRangeChangeAction (component, *document.getComponentLayout(), state),

  533.                               "Change Slider range");

  534.         }

  535. 

  536.         String getText() const override

  537.         {

  538.             Slider* s = dynamic_cast<Slider*> (component);

  539.             jassert (s != nullptr);

  540. 

  541.             switch (rangeParam)

  542.             {

  543.                 case 0:     return String (s->getMinimum());

  544.                 case 1:     return String (s->getMaximum());

  545.                 case 2:     return String (s->getInterval());

  546.                 default:    jassertfalse; break;

  547.             }

  548. 

  549.             return {};

  550.         }

  551. 

  552.     private:

  553.         const int rangeParam;

  554. 

  555.         struct SliderRangeChangeAction  : public ComponentUndoableAction<Slider>

  556.         {

  557.             SliderRangeChangeAction (Slider* comp, ComponentLayout& l, const double newState_[3])

  558.                 : ComponentUndoableAction<Slider> (comp, l)

  559.             {

  560.                 newState[0] = newState_ [0];

  561.                 newState[1] = newState_ [1];

  562.                 newState[2] = newState_ [2];

  563. 

  564.                 oldState[0] = comp->getMinimum();

  565.                 oldState[1] = comp->getMaximum();

  566.                 oldState[2] = comp->getInterval();

  567.             }

  568. 

  569.             bool perform() override

  570.             {

  571.                 showCorrectTab();

  572.                 getComponent()->setRange (newState[0], newState[1], newState[2]);

  573.                 changed();

  574.                 return true;

  575.             }

  576. 

  577.             bool undo() override

  578.             {

  579.                 showCorrectTab();

  580.                 getComponent()->setRange (oldState[0], oldState[1], oldState[2]);

  581.                 changed();

  582.                 return true;

  583.             }

  584. 

  585.             double newState[3], oldState[3];

  586.         };

  587.     };

  588. 

  589.     //==============================================================================

  590.     struct SliderSkewProperty  : public ComponentTextProperty<Slider>

  591.     {

  592.         SliderSkewProperty (Slider* slider, JucerDocument& doc)

  593.             : ComponentTextProperty<Slider> ("skew factor", 12, false, slider, doc)

  594.         {

  595.         }

  596. 

  597.         void setText (const String& newText) override

  598.         {

  599.             const double skew = jlimit (0.001, 1000.0, newText.getDoubleValue());

  600. 

  601.             document.perform (new SliderSkewChangeAction (component, *document.getComponentLayout(), skew),

  602.                               "Change Slider skew");

  603.         }

  604. 

  605.         String getText() const override

  606.         {

  607.             Slider* s = dynamic_cast<Slider*> (component);

  608.             jassert (s != 0);

  609. 

  610.             return String (s->getSkewFactor());

  611.         }

  612. 

  613.         struct SliderSkewChangeAction  : public ComponentUndoableAction<Slider>

  614.         {

  615.             SliderSkewChangeAction (Slider* comp, ComponentLayout& l, double newValue_)

  616.                 : ComponentUndoableAction<Slider> (comp, l)

  617.             {

  618.                 newValue = newValue_;

  619.                 oldValue = comp->getSkewFactor();

  620.             }

  621. 

  622.             bool perform() override

  623.             {

  624.                 showCorrectTab();

  625.                 getComponent()->setSkewFactor (newValue);

  626.                 changed();

  627.                 return true;

  628.             }

  629. 

  630.             bool undo() override

  631.             {

  632.                 showCorrectTab();

  633.                 getComponent()->setSkewFactor (oldValue);

  634.                 changed();

  635.                 return true;

  636.             }

  637. 

  638.             double newValue, oldValue;

  639.         };

  640.     };

  641. 

  642.     //==============================================================================

  643.     static String sliderStyleToString (Slider::SliderStyle style)

  644.     {

  645.         switch (style)

  646.         {

  647.             case Slider::LinearHorizontal:              return "LinearHorizontal";

  648.             case Slider::LinearVertical:                return "LinearVertical";

  649.             case Slider::LinearBar:                     return "LinearBar";

  650.             case Slider::LinearBarVertical:             return "LinearBarVertical";

  651.             case Slider::Rotary:                        return "Rotary";

  652.             case Slider::RotaryHorizontalDrag:          return "RotaryHorizontalDrag";

  653.             case Slider::RotaryVerticalDrag:            return "RotaryVerticalDrag";

  654.             case Slider::RotaryHorizontalVerticalDrag:  return "RotaryHorizontalVerticalDrag";

  655.             case Slider::IncDecButtons:                 return "IncDecButtons";

  656.             case Slider::TwoValueHorizontal:            return "TwoValueHorizontal";

  657.             case Slider::TwoValueVertical:              return "TwoValueVertical";

  658.             case Slider::ThreeValueHorizontal:          return "ThreeValueHorizontal";

  659.             case Slider::ThreeValueVertical:            return "ThreeValueVertical";

  660.             default:                                    jassertfalse; break;

  661.         }

  662. 

  663.         return {};

  664.     }

  665. 

  666.     static Slider::SliderStyle sliderStringToStyle (const String& s)

  667.     {

  668.         for (int i = 0; i < numElementsInArray (sliderStyleTypes); ++i)

  669.             if (s == sliderStyleToString (sliderStyleTypes[i]))

  670.                 return sliderStyleTypes[i];

  671. 

  672.         jassertfalse;

  673.         return Slider::LinearHorizontal;

  674.     }

  675. 

  676.     static String textBoxPosToString (const Slider::TextEntryBoxPosition pos)

  677.     {

  678.         switch (pos)

  679.         {

  680.             case Slider::NoTextBox:     return "NoTextBox";

  681.             case Slider::TextBoxLeft:   return "TextBoxLeft";

  682.             case Slider::TextBoxRight:  return "TextBoxRight";

  683.             case Slider::TextBoxAbove:  return "TextBoxAbove";

  684.             case Slider::TextBoxBelow:  return "TextBoxBelow";

  685.             default:                    jassertfalse; break;

  686.         }

  687. 

  688.         return {};

  689.     }

  690. 

  691.     static Slider::TextEntryBoxPosition stringToTextBoxPos (const String& s)

  692.     {

  693.         for (int i = 0; i < numElementsInArray (sliderTextBoxPositions); ++i)

  694.             if (s == textBoxPosToString (sliderTextBoxPositions[i]))

  695.                 return sliderTextBoxPositions[i];

  696. 

  697.         jassertfalse;

  698.         return Slider::TextBoxLeft;

  699.     }

  700. };