LabelReadoutSlider.h

Go to the documentation of this file.

/*
 *  File:       LabelReadoutSlider.h
 *
 *  Version:    1.0.0
 *
 *  Created:    01/07/2020
 *
 *  This file is part of WECore.
 *
 *  WECore is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  WECore is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with WECore.  If not, see <http://www.gnu.org/licenses/>.
 *
 */
 
#pragma once
 
#include "../JuceLibraryCode/JuceHeader.h"
#include "General/ParameterDefinition.h"
 
namespace WECore::JUCEPlugin {
 
    class SliderLabelUpdater : public juce::Slider {
    public:
    explicit SliderLabelUpdater(const juce::String& componentName) : Slider(componentName) {}
        virtual ~SliderLabelUpdater() = default;
 
        virtual void mouseEnter(const juce::MouseEvent& event) override {
            Slider::mouseEnter(event);
            _updateLabel(event);
        }
 
        virtual void mouseMove(const juce::MouseEvent& event) override {
            Slider::mouseMove(event);
            _updateLabel(event);
        }
 
        virtual void mouseExit(const juce::MouseEvent& event) override {
            Slider::mouseExit(event);
            _resetLabel();
        }
 
        virtual void mouseDoubleClick(const juce::MouseEvent& event) override {
            Slider::mouseDoubleClick(event);
            _updateLabel(event);
        }
 
        virtual void mouseDrag(const juce::MouseEvent& event) override {
            Slider::mouseDrag(event);
            _updateLabel(event);
        }
 
        virtual void mouseWheelMove(const juce::MouseEvent& event,
                                    const juce::MouseWheelDetails& wheel) override {
            Slider::mouseWheelMove(event, wheel);
            _updateLabel(event);
        }
    private:
        virtual void _updateLabel(const juce::MouseEvent& event) = 0;
 
        virtual void _resetLabel() = 0;
    };
 
    template <class T>
    class LabelReadoutSlider : public SliderLabelUpdater {
    public:
        explicit LabelReadoutSlider(const juce::String& componentName) : SliderLabelUpdater(componentName),
                                                                         _isRunning(false),
                                                                         _valueToString([](T value) { return juce::String(value, 2); }) {}
 
        virtual ~LabelReadoutSlider() = default;
 
        inline void start(juce::Label* targetLabel, juce::String defaultText);
        inline void start(juce::TextButton* targetButton, juce::String defaultText);
        inline void stop();
 
        void setValueToString(std::function<juce::String(T)> valueToString) { _valueToString = valueToString; }
 
    protected:
        std::function<void(const juce::String&)> _targetCallback;
        bool _isRunning;
        std::function<juce::String(T)> _valueToString;
 
    private:
        juce::String _defaultText;
 
        static std::function<void(const juce::String&)> _labelToCallback(juce::Label* label) {
            return [label](const juce::String& text) { label->setText(text, juce::dontSendNotification); };
        }
 
        static std::function<void(const juce::String&)> _textButtonToCallback(juce::TextButton* button) {
            return [button](const juce::String& text) { button->setButtonText(text); };
        }
 
        inline virtual void _updateLabel(const juce::MouseEvent& event) override;
 
        inline virtual void _resetLabel() override;
    };
 
    template <class T>
    void LabelReadoutSlider<T>::start(juce::Label* targetLabel, juce::String defaultText) {
        _targetCallback = _labelToCallback(targetLabel);
        _defaultText = defaultText;
        _isRunning = true;
    }
 
    template <class T>
    void LabelReadoutSlider<T>::start(juce::TextButton* targetButton, juce::String defaultText) {
        _targetCallback = _textButtonToCallback(targetButton);
        _defaultText = defaultText;
        _isRunning = true;
    }
 
    template <class T>
    void LabelReadoutSlider<T>::stop() {
        _isRunning = false;
    }
 
    template <class T>
    void LabelReadoutSlider<T>::_updateLabel(const juce::MouseEvent& /*event*/) {
        if (_isRunning) {
            _targetCallback(_valueToString(getValue()));
        }
    }
 
    template <class T>
    void LabelReadoutSlider<T>::_resetLabel() {
        if (_isRunning) {
            _targetCallback(_defaultText);
        }
    }
}