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

707 lines
27KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

  5.    Copyright (c) 2017 - ROLI Ltd.

  6. 

  7.    JUCE is an open source library subject to commercial or open-source

  8.    licensing.

  9. 

  10.    By using JUCE, you agree to the terms of both the JUCE 5 End-User License

  11.    Agreement and JUCE 5 Privacy Policy (both updated and effective as of the

  12.    27th April 2017).

  13. 

  14.    End User License Agreement: www.juce.com/juce-5-licence

  15.    Privacy Policy: www.juce.com/juce-5-privacy-policy

  16. 

  17.    Or: You may also use this code under the terms of the GPL v3 (see

  18.    www.gnu.org/licenses).

  19. 

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

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

  22.    DISCLAIMED.

  23. 

  24.   ==============================================================================

  25. */

  26. 

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

  28. {

  29.     Slider::LinearHorizontal,

  30.     Slider::LinearVertical,

  31.     Slider::LinearBar,

  32.     Slider::LinearBarVertical,

  33.     Slider::Rotary,

  34.     Slider::RotaryHorizontalDrag,

  35.     Slider::RotaryVerticalDrag,

  36.     Slider::RotaryHorizontalVerticalDrag,

  37.     Slider::IncDecButtons,

  38.     Slider::TwoValueHorizontal,

  39.     Slider::TwoValueVertical,

  40.     Slider::ThreeValueHorizontal,

  41.     Slider::ThreeValueVertical

  42. };

  43. 

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

  45. {

  46.     Slider::NoTextBox,

  47.     Slider::TextBoxLeft,

  48.     Slider::TextBoxRight,

  49.     Slider::TextBoxAbove,

  50.     Slider::TextBoxBelow

  51. };

  52. 

  53. 

  54. struct SliderHandler  : public ComponentTypeHandler

  55. {

  56.     SliderHandler()

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

  58.     {

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

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

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

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

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

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

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

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

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

  68.     }

  69. 

  70.     Component* createNewComponent (JucerDocument*) override

  71.     {

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

  73.     }

  74. 

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

  76.     {

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

  78. 

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

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

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

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

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

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

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

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

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

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

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

  90. 

  91.         return e;

  92.     }

  93. 

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

  95.     {

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

  97.             return false;

  98. 

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

  100. 

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

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

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

  104. 

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

  106. 

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

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

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

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

  111. 

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

  113. 

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

  115. 

  116.         return true;

  117.     }

  118. 

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

  120.     {

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

  122.     }

  123. 

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

  125.     {

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

  127. 

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

  129. 

  130.         String r;

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

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

  133.           << ");\n"

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

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

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

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

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

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

  140.           << getColourIntialisationCode (component, memberVariableName);

  141. 

  142.         if (needsSliderListener (component))

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

  144. 

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

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

  147. 

  148.         r << '\n';

  149.         code.constructorCode += r;

  150.     }

  151. 

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

  153.     {

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

  155. 

  156.         if (needsSliderListener (component))

  157.         {

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

  159.                                                      "void",

  160.                                                      "sliderValueChanged (Slider* sliderThatWasMoved)",

  161.                                                      true);

  162. 

  163.             if (callback.isNotEmpty())

  164.                 callback << "else ";

  165. 

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

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

  168. 

  169.             callback

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

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

  172.         }

  173.     }

  174. 

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

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

  177.     {

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

  179. 

  180.         if (multipleSelected)

  181.             return;

  182. 

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

  184.         {

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

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

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

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

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

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

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

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

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

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

  195.         }

  196. 

  197.         addColourProperties (component, document, props);

  198.     }

  199. 

  200.     static bool needsSliderListener (Component* slider)

  201.     {

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

  203.     }

  204. 

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

  206.     {

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

  208.     }

  209. 

  210. private:

  211.     //==============================================================================

  212.     struct SliderTypeProperty  : public ComponentChoiceProperty<Slider>

  213.     {

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

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

  216.         {

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

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

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

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

  221.             choices.add ("Rotary");

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

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

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

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

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

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

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

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

  230.         }

  231. 

  232.         void setIndex (int newIndex) override

  233.         {

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

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

  236.                                                               sliderStyleTypes[newIndex]),

  237.                                   "Change Slider style");

  238.         }

  239. 

  240.         int getIndex() const override

  241.         {

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

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

  244.                     return i;

  245. 

  246.             return -1;

  247.         }

  248. 

  249.     private:

  250.         struct SliderTypeChangeAction  : public ComponentUndoableAction<Slider>

  251.         {

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

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

  254.                   newState (newState_)

  255.             {

  256.                 oldState = comp->getSliderStyle();

  257.             }

  258. 

  259.             bool perform() override

  260.             {

  261.                 showCorrectTab();

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

  263.                 changed();

  264.                 return true;

  265.             }

  266. 

  267.             bool undo() override

  268.             {

  269.                 showCorrectTab();

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

  271.                 changed();

  272.                 return true;

  273.             }

  274. 

  275.             Slider::SliderStyle newState, oldState;

  276.         };

  277.     };

  278. 

  279.     //==============================================================================

  280.     struct SliderTextboxProperty  : public ComponentChoiceProperty<Slider>

  281.     {

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

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

  284.         {

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

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

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

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

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

  290.         }

  291. 

  292.         void setIndex (int newIndex) override

  293.         {

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

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

  296.                                                                  sliderTextBoxPositions[newIndex]),

  297.                                   "Change Slider textbox");

  298.         }

  299. 

  300.         int getIndex() const override

  301.         {

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

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

  304.                     return i;

  305. 

  306.             return -1;

  307.         }

  308. 

  309.     private:

  310.         struct SliderTextBoxChangeAction  : public ComponentUndoableAction<Slider>

  311.         {

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

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

  314.                   newState (newState_)

  315.             {

  316.                 oldState = comp->getTextBoxPosition();

  317.             }

  318. 

  319.             bool perform() override

  320.             {

  321.                 showCorrectTab();

  322.                 getComponent()->setTextBoxStyle (newState,

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

  324.                                                  getComponent()->getTextBoxWidth(),

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

  326.                 changed();

  327.                 return true;

  328.             }

  329. 

  330.             bool undo() override

  331.             {

  332.                 showCorrectTab();

  333.                 getComponent()->setTextBoxStyle (oldState,

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

  335.                                                  getComponent()->getTextBoxWidth(),

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

  337.                 changed();

  338.                 return true;

  339.             }

  340. 

  341.             Slider::TextEntryBoxPosition newState, oldState;

  342.         };

  343.     };

  344. 

  345.     //==============================================================================

  346.     struct SliderTextboxEditableProperty  : public ComponentBooleanProperty<Slider>

  347.     {

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

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

  350.         {

  351.         }

  352. 

  353.         void setState (bool newState) override

  354.         {

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

  356.                               "Change Slider editability");

  357.         }

  358. 

  359.         bool getState() const override

  360.         {

  361.             return component->isTextBoxEditable();

  362.         }

  363. 

  364.     private:

  365.         struct SliderEditableChangeAction  : public ComponentUndoableAction<Slider>

  366.         {

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

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

  369.                   newState (newState_)

  370.             {

  371.                 oldState = comp->isTextBoxEditable();

  372.             }

  373. 

  374.             bool perform() override

  375.             {

  376.                 showCorrectTab();

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

  378.                 changed();

  379.                 return true;

  380.             }

  381. 

  382.             bool undo() override

  383.             {

  384.                 showCorrectTab();

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

  386.                 changed();

  387.                 return true;

  388.             }

  389. 

  390.             bool newState, oldState;

  391.         };

  392.     };

  393. 

  394.     //==============================================================================

  395.     struct SliderCallbackProperty  : public ComponentBooleanProperty<Slider>

  396.     {

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

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

  399.                                                 "Generate SliderListener", s, doc)

  400.         {

  401.         }

  402. 

  403.         void setState (bool newState) override

  404.         {

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

  406.                               "Change button callback");

  407.         }

  408. 

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

  410. 

  411.         struct SliderCallbackChangeAction  : public ComponentUndoableAction<Slider>

  412.         {

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

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

  415.                   newState (newState_)

  416.             {

  417.                 oldState = needsSliderListener (comp);

  418.             }

  419. 

  420.             bool perform() override

  421.             {

  422.                 showCorrectTab();

  423.                 setNeedsSliderListener (getComponent(), newState);

  424.                 changed();

  425.                 return true;

  426.             }

  427. 

  428.             bool undo() override

  429.             {

  430.                 showCorrectTab();

  431.                 setNeedsSliderListener (getComponent(), oldState);

  432.                 changed();

  433.                 return true;

  434.             }

  435. 

  436.             bool newState, oldState;

  437.         };

  438.     };

  439. 

  440.     //==============================================================================

  441.     struct SliderTextboxSizeProperty  : public ComponentTextProperty<Slider>

  442.     {

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

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

  445.                                              12, false, slider, doc),

  446.               isWidth (isWidth_)

  447.         {

  448.         }

  449. 

  450.         void setText (const String& newText) override

  451.         {

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

  453.                               "Change Slider textbox size");

  454.         }

  455. 

  456.         String getText() const override

  457.         {

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

  459.                                    : component->getTextBoxHeight());

  460.         }

  461. 

  462.     private:

  463.         const bool isWidth;

  464. 

  465.         struct SliderBoxSizeChangeAction  : public ComponentUndoableAction<Slider>

  466.         {

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

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

  469.                   isWidth (isWidth_),

  470.                   newSize (newSize_)

  471.             {

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

  473.                                   : comp->getTextBoxHeight();

  474.             }

  475. 

  476.             bool perform() override

  477.             {

  478.                 showCorrectTab();

  479.                 Slider& c = *getComponent();

  480. 

  481.                 if (isWidth)

  482.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  483.                                        ! c.isTextBoxEditable(),

  484.                                        newSize,

  485.                                        c.getTextBoxHeight());

  486.                 else

  487.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  488.                                        ! c.isTextBoxEditable(),

  489.                                        c.getTextBoxWidth(),

  490.                                        newSize);

  491.                 changed();

  492.                 return true;

  493.             }

  494. 

  495.             bool undo() override

  496.             {

  497.                 showCorrectTab();

  498.                 Slider& c = *getComponent();

  499. 

  500.                 if (isWidth)

  501.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  502.                                        ! c.isTextBoxEditable(),

  503.                                        oldSize,

  504.                                        c.getTextBoxHeight());

  505.                 else

  506.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  507.                                        ! c.isTextBoxEditable(),

  508.                                        c.getTextBoxWidth(),

  509.                                        oldSize);

  510.                 changed();

  511.                 return true;

  512.             }

  513. 

  514.             bool isWidth;

  515.             int newSize, oldSize;

  516.         };

  517.     };

  518. 

  519.     //==============================================================================

  520.     struct SliderRangeProperty  : public ComponentTextProperty<Slider>

  521.     {

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

  523.                              const String& name, int rangeParam_)

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

  525.               rangeParam (rangeParam_)

  526.         {

  527.         }

  528. 

  529.         void setText (const String& newText) override

  530.         {

  531.             double state [3];

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

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

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

  535. 

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

  537. 

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

  539.                               "Change Slider range");

  540.         }

  541. 

  542.         String getText() const override

  543.         {

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

  545.             jassert (s != nullptr);

  546. 

  547.             switch (rangeParam)

  548.             {

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

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

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

  552.                 default:    jassertfalse; break;

  553.             }

  554. 

  555.             return {};

  556.         }

  557. 

  558.     private:

  559.         const int rangeParam;

  560. 

  561.         struct SliderRangeChangeAction  : public ComponentUndoableAction<Slider>

  562.         {

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

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

  565.             {

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

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

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

  569. 

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

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

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

  573.             }

  574. 

  575.             bool perform() override

  576.             {

  577.                 showCorrectTab();

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

  579.                 changed();

  580.                 return true;

  581.             }

  582. 

  583.             bool undo() override

  584.             {

  585.                 showCorrectTab();

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

  587.                 changed();

  588.                 return true;

  589.             }

  590. 

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

  592.         };

  593.     };

  594. 

  595.     //==============================================================================

  596.     struct SliderSkewProperty  : public ComponentTextProperty<Slider>

  597.     {

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

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

  600.         {

  601.         }

  602. 

  603.         void setText (const String& newText) override

  604.         {

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

  606. 

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

  608.                               "Change Slider skew");

  609.         }

  610. 

  611.         String getText() const override

  612.         {

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

  614.             jassert (s != 0);

  615. 

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

  617.         }

  618. 

  619.         struct SliderSkewChangeAction  : public ComponentUndoableAction<Slider>

  620.         {

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

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

  623.             {

  624.                 newValue = newValue_;

  625.                 oldValue = comp->getSkewFactor();

  626.             }

  627. 

  628.             bool perform() override

  629.             {

  630.                 showCorrectTab();

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

  632.                 changed();

  633.                 return true;

  634.             }

  635. 

  636.             bool undo() override

  637.             {

  638.                 showCorrectTab();

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

  640.                 changed();

  641.                 return true;

  642.             }

  643. 

  644.             double newValue, oldValue;

  645.         };

  646.     };

  647. 

  648.     //==============================================================================

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

  650.     {

  651.         switch (style)

  652.         {

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

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

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

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

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

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

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

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

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

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

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

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

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

  666.             default:                                    jassertfalse; break;

  667.         }

  668. 

  669.         return {};

  670.     }

  671. 

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

  673.     {

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

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

  676.                 return sliderStyleTypes[i];

  677. 

  678.         jassertfalse;

  679.         return Slider::LinearHorizontal;

  680.     }

  681. 

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

  683.     {

  684.         switch (pos)

  685.         {

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

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

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

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

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

  691.             default:                    jassertfalse; break;

  692.         }

  693. 

  694.         return {};

  695.     }

  696. 

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

  698.     {

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

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

  701.                 return sliderTextBoxPositions[i];

  702. 

  703.         jassertfalse;

  704.         return Slider::TextBoxLeft;

  705.     }

  706. };