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.
7685 Commits
9 Branches
1.9GB
Tree: c55e73a50e
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'c55e73a50e'
${ 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 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 SliderListener",

  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, Array<PropertyComponent*>& props) override

  176.     {

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

  178. 

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

  180.         jassert (s != 0);

  181. 

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

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

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

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

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

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

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

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

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

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

  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.             Slider* s = dynamic_cast<Slider*> (component);

  610.             jassert (s != 0);

  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. };