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.
11026 Commits
9 Branches
4.8GB
Tree: 092bc44413
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '092bc44413'
${ noResults }
JUCE/extras/Projucer/Source/ComponentEditor/Components/jucer_SliderHandler.h

703 lines
27KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE 6 technical preview.

  5.    Copyright (c) 2020 - Raw Material Software Limited

  6. 

  7.    You may use this code under the terms of the GPL v3

  8.    (see www.gnu.org/licenses).

  9. 

  10.    For this technical preview, this file is not subject to commercial licensing.

  11. 

  12.    JUCE IS PROVIDED "AS IS" WITHOUT ANY WARRANTY, AND ALL WARRANTIES, WHETHER

  13.    EXPRESSED OR IMPLIED, INCLUDING MERCHANTABILITY AND FITNESS FOR PURPOSE, ARE

  14.    DISCLAIMED.

  15. 

  16.   ==============================================================================

  17. */

  18. 

  19. #pragma once

  20. 

  21. 

  22. //==============================================================================

  23. static const Slider::SliderStyle sliderStyleTypes[] =

  24. {

  25.     Slider::LinearHorizontal,

  26.     Slider::LinearVertical,

  27.     Slider::LinearBar,

  28.     Slider::LinearBarVertical,

  29.     Slider::Rotary,

  30.     Slider::RotaryHorizontalDrag,

  31.     Slider::RotaryVerticalDrag,

  32.     Slider::RotaryHorizontalVerticalDrag,

  33.     Slider::IncDecButtons,

  34.     Slider::TwoValueHorizontal,

  35.     Slider::TwoValueVertical,

  36.     Slider::ThreeValueHorizontal,

  37.     Slider::ThreeValueVertical

  38. };

  39. 

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

  41. {

  42.     Slider::NoTextBox,

  43.     Slider::TextBoxLeft,

  44.     Slider::TextBoxRight,

  45.     Slider::TextBoxAbove,

  46.     Slider::TextBoxBelow

  47. };

  48. 

  49. 

  50. struct SliderHandler  : public ComponentTypeHandler

  51. {

  52.     SliderHandler()

  53.         : ComponentTypeHandler ("Slider", "juce::Slider", typeid (Slider), 150, 24)

  54.     {

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

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

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

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

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

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

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

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

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

  64.     }

  65. 

  66.     Component* createNewComponent (JucerDocument*) override

  67.     {

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

  69.     }

  70. 

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

  72.     {

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

  74. 

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

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

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

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

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

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

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

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

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

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

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

  86. 

  87.         return e;

  88.     }

  89. 

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

  91.     {

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

  93.             return false;

  94. 

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

  96. 

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

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

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

  100. 

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

  102. 

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

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

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

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

  107. 

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

  109. 

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

  111. 

  112.         return true;

  113.     }

  114. 

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

  116.     {

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

  118.     }

  119. 

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

  121.     {

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

  123. 

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

  125. 

  126.         String r;

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

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

  129.           << ");\n"

  130.           << memberVariableName << "->setSliderStyle (juce::Slider::"

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

  132.           << memberVariableName << "->setTextBoxStyle (juce::Slider::"

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

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

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

  136.           << getColourIntialisationCode (component, memberVariableName);

  137. 

  138.         if (needsSliderListener (component))

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

  140. 

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

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

  143. 

  144.         r << '\n';

  145.         code.constructorCode += r;

  146.     }

  147. 

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

  149.     {

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

  151. 

  152.         if (needsSliderListener (component))

  153.         {

  154.             String& callback = code.getCallbackCode ("public juce::Slider::Listener",

  155.                                                      "void",

  156.                                                      "sliderValueChanged (juce::Slider* sliderThatWasMoved)",

  157.                                                      true);

  158. 

  159.             if (callback.isNotEmpty())

  160.                 callback << "else ";

  161. 

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

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

  164. 

  165.             callback

  166.                 << "if (sliderThatWasMoved == " << memberVariableName << ".get())\n"

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

  168.         }

  169.     }

  170. 

  171.     void getEditableProperties (Component* component, JucerDocument& document,

  172.                                 Array<PropertyComponent*>& props, bool multipleSelected) override

  173.     {

  174.         ComponentTypeHandler::getEditableProperties (component, document, props, multipleSelected);

  175. 

  176.         if (multipleSelected)

  177.             return;

  178. 

  179.         if (auto* s = dynamic_cast<Slider*> (component))

  180.         {

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

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

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

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

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

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

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

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

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

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

  191.         }

  192. 

  193.         addColourProperties (component, document, props);

  194.     }

  195. 

  196.     static bool needsSliderListener (Component* slider)

  197.     {

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

  199.     }

  200. 

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

  202.     {

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

  204.     }

  205. 

  206. private:

  207.     //==============================================================================

  208.     struct SliderTypeProperty  : public ComponentChoiceProperty<Slider>

  209.     {

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

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

  212.         {

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

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

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

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

  217.             choices.add ("Rotary");

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

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

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

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

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

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

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

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

  226.         }

  227. 

  228.         void setIndex (int newIndex) override

  229.         {

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

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

  232.                                                               sliderStyleTypes[newIndex]),

  233.                                   "Change Slider style");

  234.         }

  235. 

  236.         int getIndex() const override

  237.         {

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

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

  240.                     return i;

  241. 

  242.             return -1;

  243.         }

  244. 

  245.     private:

  246.         struct SliderTypeChangeAction  : public ComponentUndoableAction<Slider>

  247.         {

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

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

  250.                   newState (newState_)

  251.             {

  252.                 oldState = comp->getSliderStyle();

  253.             }

  254. 

  255.             bool perform() override

  256.             {

  257.                 showCorrectTab();

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

  259.                 changed();

  260.                 return true;

  261.             }

  262. 

  263.             bool undo() override

  264.             {

  265.                 showCorrectTab();

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

  267.                 changed();

  268.                 return true;

  269.             }

  270. 

  271.             Slider::SliderStyle newState, oldState;

  272.         };

  273.     };

  274. 

  275.     //==============================================================================

  276.     struct SliderTextboxProperty  : public ComponentChoiceProperty<Slider>

  277.     {

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

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

  280.         {

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

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

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

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

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

  286.         }

  287. 

  288.         void setIndex (int newIndex) override

  289.         {

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

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

  292.                                                                  sliderTextBoxPositions[newIndex]),

  293.                                   "Change Slider textbox");

  294.         }

  295. 

  296.         int getIndex() const override

  297.         {

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

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

  300.                     return i;

  301. 

  302.             return -1;

  303.         }

  304. 

  305.     private:

  306.         struct SliderTextBoxChangeAction  : public ComponentUndoableAction<Slider>

  307.         {

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

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

  310.                   newState (newState_)

  311.             {

  312.                 oldState = comp->getTextBoxPosition();

  313.             }

  314. 

  315.             bool perform() override

  316.             {

  317.                 showCorrectTab();

  318.                 getComponent()->setTextBoxStyle (newState,

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

  320.                                                  getComponent()->getTextBoxWidth(),

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

  322.                 changed();

  323.                 return true;

  324.             }

  325. 

  326.             bool undo() override

  327.             {

  328.                 showCorrectTab();

  329.                 getComponent()->setTextBoxStyle (oldState,

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

  331.                                                  getComponent()->getTextBoxWidth(),

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

  333.                 changed();

  334.                 return true;

  335.             }

  336. 

  337.             Slider::TextEntryBoxPosition newState, oldState;

  338.         };

  339.     };

  340. 

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

  342.     struct SliderTextboxEditableProperty  : public ComponentBooleanProperty<Slider>

  343.     {

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

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

  346.         {

  347.         }

  348. 

  349.         void setState (bool newState) override

  350.         {

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

  352.                               "Change Slider editability");

  353.         }

  354. 

  355.         bool getState() const override

  356.         {

  357.             return component->isTextBoxEditable();

  358.         }

  359. 

  360.     private:

  361.         struct SliderEditableChangeAction  : public ComponentUndoableAction<Slider>

  362.         {

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

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

  365.                   newState (newState_)

  366.             {

  367.                 oldState = comp->isTextBoxEditable();

  368.             }

  369. 

  370.             bool perform() override

  371.             {

  372.                 showCorrectTab();

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

  374.                 changed();

  375.                 return true;

  376.             }

  377. 

  378.             bool undo() override

  379.             {

  380.                 showCorrectTab();

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

  382.                 changed();

  383.                 return true;

  384.             }

  385. 

  386.             bool newState, oldState;

  387.         };

  388.     };

  389. 

  390.     //==============================================================================

  391.     struct SliderCallbackProperty  : public ComponentBooleanProperty<Slider>

  392.     {

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

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

  395.                                                 "Generate SliderListener", s, doc)

  396.         {

  397.         }

  398. 

  399.         void setState (bool newState) override

  400.         {

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

  402.                               "Change button callback");

  403.         }

  404. 

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

  406. 

  407.         struct SliderCallbackChangeAction  : public ComponentUndoableAction<Slider>

  408.         {

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

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

  411.                   newState (newState_)

  412.             {

  413.                 oldState = needsSliderListener (comp);

  414.             }

  415. 

  416.             bool perform() override

  417.             {

  418.                 showCorrectTab();

  419.                 setNeedsSliderListener (getComponent(), newState);

  420.                 changed();

  421.                 return true;

  422.             }

  423. 

  424.             bool undo() override

  425.             {

  426.                 showCorrectTab();

  427.                 setNeedsSliderListener (getComponent(), oldState);

  428.                 changed();

  429.                 return true;

  430.             }

  431. 

  432.             bool newState, oldState;

  433.         };

  434.     };

  435. 

  436.     //==============================================================================

  437.     struct SliderTextboxSizeProperty  : public ComponentTextProperty<Slider>

  438.     {

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

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

  441.                                              12, false, slider, doc),

  442.               isWidth (isWidth_)

  443.         {

  444.         }

  445. 

  446.         void setText (const String& newText) override

  447.         {

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

  449.                               "Change Slider textbox size");

  450.         }

  451. 

  452.         String getText() const override

  453.         {

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

  455.                                    : component->getTextBoxHeight());

  456.         }

  457. 

  458.     private:

  459.         const bool isWidth;

  460. 

  461.         struct SliderBoxSizeChangeAction  : public ComponentUndoableAction<Slider>

  462.         {

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

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

  465.                   isWidth (isWidth_),

  466.                   newSize (newSize_)

  467.             {

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

  469.                                   : comp->getTextBoxHeight();

  470.             }

  471. 

  472.             bool perform() override

  473.             {

  474.                 showCorrectTab();

  475.                 Slider& c = *getComponent();

  476. 

  477.                 if (isWidth)

  478.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  479.                                        ! c.isTextBoxEditable(),

  480.                                        newSize,

  481.                                        c.getTextBoxHeight());

  482.                 else

  483.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  484.                                        ! c.isTextBoxEditable(),

  485.                                        c.getTextBoxWidth(),

  486.                                        newSize);

  487.                 changed();

  488.                 return true;

  489.             }

  490. 

  491.             bool undo() override

  492.             {

  493.                 showCorrectTab();

  494.                 Slider& c = *getComponent();

  495. 

  496.                 if (isWidth)

  497.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  498.                                        ! c.isTextBoxEditable(),

  499.                                        oldSize,

  500.                                        c.getTextBoxHeight());

  501.                 else

  502.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  503.                                        ! c.isTextBoxEditable(),

  504.                                        c.getTextBoxWidth(),

  505.                                        oldSize);

  506.                 changed();

  507.                 return true;

  508.             }

  509. 

  510.             bool isWidth;

  511.             int newSize, oldSize;

  512.         };

  513.     };

  514. 

  515.     //==============================================================================

  516.     struct SliderRangeProperty  : public ComponentTextProperty<Slider>

  517.     {

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

  519.                              const String& name, int rangeParam_)

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

  521.               rangeParam (rangeParam_)

  522.         {

  523.         }

  524. 

  525.         void setText (const String& newText) override

  526.         {

  527.             double state [3];

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

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

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

  531. 

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

  533. 

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

  535.                               "Change Slider range");

  536.         }

  537. 

  538.         String getText() const override

  539.         {

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

  541.             jassert (s != nullptr);

  542. 

  543.             switch (rangeParam)

  544.             {

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

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

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

  548.                 default:    jassertfalse; break;

  549.             }

  550. 

  551.             return {};

  552.         }

  553. 

  554.     private:

  555.         const int rangeParam;

  556. 

  557.         struct SliderRangeChangeAction  : public ComponentUndoableAction<Slider>

  558.         {

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

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

  561.             {

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

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

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

  565. 

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

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

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

  569.             }

  570. 

  571.             bool perform() override

  572.             {

  573.                 showCorrectTab();

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

  575.                 changed();

  576.                 return true;

  577.             }

  578. 

  579.             bool undo() override

  580.             {

  581.                 showCorrectTab();

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

  583.                 changed();

  584.                 return true;

  585.             }

  586. 

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

  588.         };

  589.     };

  590. 

  591.     //==============================================================================

  592.     struct SliderSkewProperty  : public ComponentTextProperty<Slider>

  593.     {

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

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

  596.         {

  597.         }

  598. 

  599.         void setText (const String& newText) override

  600.         {

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

  602. 

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

  604.                               "Change Slider skew");

  605.         }

  606. 

  607.         String getText() const override

  608.         {

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

  610.             jassert (s != nullptr);

  611. 

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

  613.         }

  614. 

  615.         struct SliderSkewChangeAction  : public ComponentUndoableAction<Slider>

  616.         {

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

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

  619.             {

  620.                 newValue = newValue_;

  621.                 oldValue = comp->getSkewFactor();

  622.             }

  623. 

  624.             bool perform() override

  625.             {

  626.                 showCorrectTab();

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

  628.                 changed();

  629.                 return true;

  630.             }

  631. 

  632.             bool undo() override

  633.             {

  634.                 showCorrectTab();

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

  636.                 changed();

  637.                 return true;

  638.             }

  639. 

  640.             double newValue, oldValue;

  641.         };

  642.     };

  643. 

  644.     //==============================================================================

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

  646.     {

  647.         switch (style)

  648.         {

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

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

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

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

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

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

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

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

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

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

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

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

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

  662.             default:                                    jassertfalse; break;

  663.         }

  664. 

  665.         return {};

  666.     }

  667. 

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

  669.     {

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

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

  672.                 return sliderStyleTypes[i];

  673. 

  674.         jassertfalse;

  675.         return Slider::LinearHorizontal;

  676.     }

  677. 

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

  679.     {

  680.         switch (pos)

  681.         {

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

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

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

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

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

  687.             default:                    jassertfalse; break;

  688.         }

  689. 

  690.         return {};

  691.     }

  692. 

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

  694.     {

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

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

  697.                 return sliderTextBoxPositions[i];

  698. 

  699.         jassertfalse;

  700.         return Slider::TextBoxLeft;

  701.     }

  702. };