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

710 lines
27KB
Raw Blame History 

  1. /*

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

  3. 

  4.    This file is part of the JUCE library.

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

  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 7 End-User License

  11.    Agreement and JUCE Privacy Policy.

  12. 

  13.    End User License Agreement: www.juce.com/juce-7-licence

  14.    Privacy Policy: www.juce.com/juce-privacy-policy

  15. 

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

  17.    www.gnu.org/licenses).

  18. 

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

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

  21.    DISCLAIMED.

  22. 

  23.   ==============================================================================

  24. */

  25. 

  26. #pragma once

  27. 

  28. 

  29. //==============================================================================

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

  31. {

  32.     Slider::LinearHorizontal,

  33.     Slider::LinearVertical,

  34.     Slider::LinearBar,

  35.     Slider::LinearBarVertical,

  36.     Slider::Rotary,

  37.     Slider::RotaryHorizontalDrag,

  38.     Slider::RotaryVerticalDrag,

  39.     Slider::RotaryHorizontalVerticalDrag,

  40.     Slider::IncDecButtons,

  41.     Slider::TwoValueHorizontal,

  42.     Slider::TwoValueVertical,

  43.     Slider::ThreeValueHorizontal,

  44.     Slider::ThreeValueVertical

  45. };

  46. 

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

  48. {

  49.     Slider::NoTextBox,

  50.     Slider::TextBoxLeft,

  51.     Slider::TextBoxRight,

  52.     Slider::TextBoxAbove,

  53.     Slider::TextBoxBelow

  54. };

  55. 

  56. 

  57. struct SliderHandler  : public ComponentTypeHandler

  58. {

  59.     SliderHandler()

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

  61.     {

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

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

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

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

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

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

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

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

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

  71.     }

  72. 

  73.     Component* createNewComponent (JucerDocument*) override

  74.     {

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

  76.     }

  77. 

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

  79.     {

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

  81. 

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

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

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

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

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

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

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

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

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

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

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

  93. 

  94.         return e;

  95.     }

  96. 

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

  98.     {

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

  100.             return false;

  101. 

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

  103. 

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

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

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

  107. 

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

  109. 

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

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

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

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

  114. 

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

  116. 

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

  118. 

  119.         return true;

  120.     }

  121. 

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

  123.     {

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

  125.     }

  126. 

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

  128.     {

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

  130. 

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

  132. 

  133.         String r;

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

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

  136.           << ");\n"

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

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

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

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

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

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

  143.           << getColourIntialisationCode (component, memberVariableName);

  144. 

  145.         if (needsSliderListener (component))

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

  147. 

  148.         if (! approximatelyEqual (s->getSkewFactor(), 1.0))

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

  150. 

  151.         r << '\n';

  152.         code.constructorCode += r;

  153.     }

  154. 

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

  156.     {

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

  158. 

  159.         if (needsSliderListener (component))

  160.         {

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

  162.                                                      "void",

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

  164.                                                      true);

  165. 

  166.             if (callback.isNotEmpty())

  167.                 callback << "else ";

  168. 

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

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

  171. 

  172.             callback

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

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

  175.         }

  176.     }

  177. 

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

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

  180.     {

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

  182. 

  183.         if (multipleSelected)

  184.             return;

  185. 

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

  187.         {

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

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

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

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

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

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

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

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

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

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

  198.         }

  199. 

  200.         addColourProperties (component, document, props);

  201.     }

  202. 

  203.     static bool needsSliderListener (Component* slider)

  204.     {

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

  206.     }

  207. 

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

  209.     {

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

  211.     }

  212. 

  213. private:

  214.     //==============================================================================

  215.     struct SliderTypeProperty  : public ComponentChoiceProperty<Slider>

  216.     {

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

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

  219.         {

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

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

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

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

  224.             choices.add ("Rotary");

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

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

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

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

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

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

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

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

  233.         }

  234. 

  235.         void setIndex (int newIndex) override

  236.         {

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

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

  239.                                                               sliderStyleTypes[newIndex]),

  240.                                   "Change Slider style");

  241.         }

  242. 

  243.         int getIndex() const override

  244.         {

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

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

  247.                     return i;

  248. 

  249.             return -1;

  250.         }

  251. 

  252.     private:

  253.         struct SliderTypeChangeAction  : public ComponentUndoableAction<Slider>

  254.         {

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

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

  257.                   newState (newState_)

  258.             {

  259.                 oldState = comp->getSliderStyle();

  260.             }

  261. 

  262.             bool perform() override

  263.             {

  264.                 showCorrectTab();

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

  266.                 changed();

  267.                 return true;

  268.             }

  269. 

  270.             bool undo() override

  271.             {

  272.                 showCorrectTab();

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

  274.                 changed();

  275.                 return true;

  276.             }

  277. 

  278.             Slider::SliderStyle newState, oldState;

  279.         };

  280.     };

  281. 

  282.     //==============================================================================

  283.     struct SliderTextboxProperty  : public ComponentChoiceProperty<Slider>

  284.     {

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

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

  287.         {

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

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

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

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

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

  293.         }

  294. 

  295.         void setIndex (int newIndex) override

  296.         {

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

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

  299.                                                                  sliderTextBoxPositions[newIndex]),

  300.                                   "Change Slider textbox");

  301.         }

  302. 

  303.         int getIndex() const override

  304.         {

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

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

  307.                     return i;

  308. 

  309.             return -1;

  310.         }

  311. 

  312.     private:

  313.         struct SliderTextBoxChangeAction  : public ComponentUndoableAction<Slider>

  314.         {

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

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

  317.                   newState (newState_)

  318.             {

  319.                 oldState = comp->getTextBoxPosition();

  320.             }

  321. 

  322.             bool perform() override

  323.             {

  324.                 showCorrectTab();

  325.                 getComponent()->setTextBoxStyle (newState,

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

  327.                                                  getComponent()->getTextBoxWidth(),

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

  329.                 changed();

  330.                 return true;

  331.             }

  332. 

  333.             bool undo() override

  334.             {

  335.                 showCorrectTab();

  336.                 getComponent()->setTextBoxStyle (oldState,

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

  338.                                                  getComponent()->getTextBoxWidth(),

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

  340.                 changed();

  341.                 return true;

  342.             }

  343. 

  344.             Slider::TextEntryBoxPosition newState, oldState;

  345.         };

  346.     };

  347. 

  348.     //==============================================================================

  349.     struct SliderTextboxEditableProperty  : public ComponentBooleanProperty<Slider>

  350.     {

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

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

  353.         {

  354.         }

  355. 

  356.         void setState (bool newState) override

  357.         {

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

  359.                               "Change Slider editability");

  360.         }

  361. 

  362.         bool getState() const override

  363.         {

  364.             return component->isTextBoxEditable();

  365.         }

  366. 

  367.     private:

  368.         struct SliderEditableChangeAction  : public ComponentUndoableAction<Slider>

  369.         {

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

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

  372.                   newState (newState_)

  373.             {

  374.                 oldState = comp->isTextBoxEditable();

  375.             }

  376. 

  377.             bool perform() override

  378.             {

  379.                 showCorrectTab();

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

  381.                 changed();

  382.                 return true;

  383.             }

  384. 

  385.             bool undo() override

  386.             {

  387.                 showCorrectTab();

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

  389.                 changed();

  390.                 return true;

  391.             }

  392. 

  393.             bool newState, oldState;

  394.         };

  395.     };

  396. 

  397.     //==============================================================================

  398.     struct SliderCallbackProperty  : public ComponentBooleanProperty<Slider>

  399.     {

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

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

  402.                                                 "Generate SliderListener", s, doc)

  403.         {

  404.         }

  405. 

  406.         void setState (bool newState) override

  407.         {

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

  409.                               "Change button callback");

  410.         }

  411. 

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

  413. 

  414.         struct SliderCallbackChangeAction  : public ComponentUndoableAction<Slider>

  415.         {

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

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

  418.                   newState (newState_)

  419.             {

  420.                 oldState = needsSliderListener (comp);

  421.             }

  422. 

  423.             bool perform() override

  424.             {

  425.                 showCorrectTab();

  426.                 setNeedsSliderListener (getComponent(), newState);

  427.                 changed();

  428.                 return true;

  429.             }

  430. 

  431.             bool undo() override

  432.             {

  433.                 showCorrectTab();

  434.                 setNeedsSliderListener (getComponent(), oldState);

  435.                 changed();

  436.                 return true;

  437.             }

  438. 

  439.             bool newState, oldState;

  440.         };

  441.     };

  442. 

  443.     //==============================================================================

  444.     struct SliderTextboxSizeProperty  : public ComponentTextProperty<Slider>

  445.     {

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

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

  448.                                              12, false, slider, doc),

  449.               isWidth (isWidth_)

  450.         {

  451.         }

  452. 

  453.         void setText (const String& newText) override

  454.         {

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

  456.                               "Change Slider textbox size");

  457.         }

  458. 

  459.         String getText() const override

  460.         {

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

  462.                                    : component->getTextBoxHeight());

  463.         }

  464. 

  465.     private:

  466.         const bool isWidth;

  467. 

  468.         struct SliderBoxSizeChangeAction  : public ComponentUndoableAction<Slider>

  469.         {

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

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

  472.                   isWidth (isWidth_),

  473.                   newSize (newSize_)

  474.             {

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

  476.                                   : comp->getTextBoxHeight();

  477.             }

  478. 

  479.             bool perform() override

  480.             {

  481.                 showCorrectTab();

  482.                 Slider& c = *getComponent();

  483. 

  484.                 if (isWidth)

  485.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  486.                                        ! c.isTextBoxEditable(),

  487.                                        newSize,

  488.                                        c.getTextBoxHeight());

  489.                 else

  490.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  491.                                        ! c.isTextBoxEditable(),

  492.                                        c.getTextBoxWidth(),

  493.                                        newSize);

  494.                 changed();

  495.                 return true;

  496.             }

  497. 

  498.             bool undo() override

  499.             {

  500.                 showCorrectTab();

  501.                 Slider& c = *getComponent();

  502. 

  503.                 if (isWidth)

  504.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  505.                                        ! c.isTextBoxEditable(),

  506.                                        oldSize,

  507.                                        c.getTextBoxHeight());

  508.                 else

  509.                     c.setTextBoxStyle (c.getTextBoxPosition(),

  510.                                        ! c.isTextBoxEditable(),

  511.                                        c.getTextBoxWidth(),

  512.                                        oldSize);

  513.                 changed();

  514.                 return true;

  515.             }

  516. 

  517.             bool isWidth;

  518.             int newSize, oldSize;

  519.         };

  520.     };

  521. 

  522.     //==============================================================================

  523.     struct SliderRangeProperty  : public ComponentTextProperty<Slider>

  524.     {

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

  526.                              const String& name, int rangeParam_)

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

  528.               rangeParam (rangeParam_)

  529.         {

  530.         }

  531. 

  532.         void setText (const String& newText) override

  533.         {

  534.             double state [3];

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

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

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

  538. 

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

  540. 

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

  542.                               "Change Slider range");

  543.         }

  544. 

  545.         String getText() const override

  546.         {

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

  548.             {

  549.                 switch (rangeParam)

  550.                 {

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

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

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

  554.                     default:    jassertfalse; break;

  555.                 }

  556.             }

  557. 

  558.             return {};

  559.         }

  560. 

  561.     private:

  562.         const int rangeParam;

  563. 

  564.         struct SliderRangeChangeAction  : public ComponentUndoableAction<Slider>

  565.         {

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

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

  568.             {

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

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

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

  572. 

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

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

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

  576.             }

  577. 

  578.             bool perform() override

  579.             {

  580.                 showCorrectTab();

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

  582.                 changed();

  583.                 return true;

  584.             }

  585. 

  586.             bool undo() override

  587.             {

  588.                 showCorrectTab();

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

  590.                 changed();

  591.                 return true;

  592.             }

  593. 

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

  595.         };

  596.     };

  597. 

  598.     //==============================================================================

  599.     struct SliderSkewProperty  : public ComponentTextProperty<Slider>

  600.     {

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

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

  603.         {

  604.         }

  605. 

  606.         void setText (const String& newText) override

  607.         {

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

  609. 

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

  611.                               "Change Slider skew");

  612.         }

  613. 

  614.         String getText() const override

  615.         {

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

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

  618. 

  619.             return {};

  620.         }

  621. 

  622.         struct SliderSkewChangeAction  : public ComponentUndoableAction<Slider>

  623.         {

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

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

  626.             {

  627.                 newValue = newValue_;

  628.                 oldValue = comp->getSkewFactor();

  629.             }

  630. 

  631.             bool perform() override

  632.             {

  633.                 showCorrectTab();

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

  635.                 changed();

  636.                 return true;

  637.             }

  638. 

  639.             bool undo() override

  640.             {

  641.                 showCorrectTab();

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

  643.                 changed();

  644.                 return true;

  645.             }

  646. 

  647.             double newValue, oldValue;

  648.         };

  649.     };

  650. 

  651.     //==============================================================================

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

  653.     {

  654.         switch (style)

  655.         {

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

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

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

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

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

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

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

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

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

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

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

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

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

  669.             default:                                    jassertfalse; break;

  670.         }

  671. 

  672.         return {};

  673.     }

  674. 

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

  676.     {

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

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

  679.                 return sliderStyleTypes[i];

  680. 

  681.         jassertfalse;

  682.         return Slider::LinearHorizontal;

  683.     }

  684. 

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

  686.     {

  687.         switch (pos)

  688.         {

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

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

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

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

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

  694.             default:                    jassertfalse; break;

  695.         }

  696. 

  697.         return {};

  698.     }

  699. 

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

  701.     {

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

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

  704.                 return sliderTextBoxPositions[i];

  705. 

  706.         jassertfalse;

  707.         return Slider::TextBoxLeft;

  708.     }

  709. };