KParameter.cpp

Go to the documentation of this file.

namespace krotos
{
    KParameter::AudioListenerObject::AudioListenerObject(std::shared_ptr<KParameter> parameterToListenTo,
                                                         std::function<void(float)> onChangeFunction)
        : parameter(parameterToListenTo), onChange(std::move(onChangeFunction))
    {
        jassert(onChange != nullptr && parameterToListenTo != nullptr);
        if (auto parameterPtr = parameter.lock())
        {
            parameterPtr->addListener(this);
        }
    }
 
    KParameter::AudioListenerObject::~AudioListenerObject()
    {
        if (auto parameterPtr = parameter.lock())
        {
            parameterPtr->removeListener(this);
        }
    }
 
    void KParameter::AudioListenerObject::parameterValueChanged(int, float newValue)
    {
        if (onChange)
        {
            if (auto parameterPtr = parameter.lock())
            {
                onChange(parameterPtr->convertFrom0to1(newValue));
            }
        }
    }
 
    KParameter::AsyncListenerObject::AsyncListenerObject(std::shared_ptr<KParameter> parameterToListenTo,
                                                         std::function<void(float)> onChangeFunction)
        : parameter(parameterToListenTo), onChange(std::move(onChangeFunction))
    {
        jassert(onChange != nullptr && parameterToListenTo != nullptr);
        if (auto parameterPtr = parameter.lock())
        {
            parameterPtr->addListener(this);
        }
    }
 
    KParameter::AsyncListenerObject::~AsyncListenerObject()
    {
        if (auto parameterPtr = parameter.lock())
        {
            parameterPtr->removeListener(this);
        }
        masterReference.clear();
    }
 
    void KParameter::AsyncListenerObject::parameterValueChanged(int, float newValue)
    {
        lastValue = newValue;
 
        if (MessageManager::getInstance()->isThisTheMessageThread())
        {
            cancelPendingUpdate();
            handleAsyncUpdate();
        }
        else
        {
            triggerAsyncUpdate();
        }
    }
 
    void KParameter::AsyncListenerObject::handleAsyncUpdate()
    {
        WeakReference<KParameter::AsyncListenerObject> kParamListener(this);
        if (onChange != nullptr && kParamListener)
        {
            if (auto parameterPtr = parameter.lock())
            {
                onChange(parameterPtr->convertFrom0to1(lastValue));
            }
        }
    }
 
    KParameter::KParameter(const String& parameterID, const String& parameterName,
                           const NormalisableRange<float>& normalisableRange, float defaultValue,
                           const String& parameterLabel,
                           std::function<String(float value, int maximumStringLength)> stringFromValue,
                           std::function<float(const String& text)> valueFromString)
        : RangedAudioParameter(parameterID, parameterName, parameterLabel, AudioProcessorParameter::genericParameter),
          m_range(normalisableRange), m_value(defaultValue), m_normalisedValue(m_range.convertTo0to1(defaultValue)),
          m_defaultValue(defaultValue), m_stringFromValueFunction(stringFromValue),
          m_valueFromStringFunction(valueFromString)
    {
        if (m_stringFromValueFunction == nullptr)
        {
            auto numDecimalPlacesToDisplay = [this] {
                int numDecimalPlaces = 7;
                if (m_range.interval != 0.0f)
                {
                    if (approximatelyEqual(std::abs(m_range.interval - std::floor(m_range.interval)), 0.0f))
                        return 0;
 
                    auto v = std::abs(roundToInt(m_range.interval * pow(10, numDecimalPlaces)));
                    while ((v % 10) == 0 && numDecimalPlaces > 0)
                    {
                        --numDecimalPlaces;
                        v /= 10;
                    }
                }
 
                return numDecimalPlaces;
            }();
 
            m_stringFromValueFunction = [numDecimalPlacesToDisplay](float v, int length) {
                String asText(v, numDecimalPlacesToDisplay);
                return length > 0 ? asText.substring(0, length) : asText;
            };
        }
 
        if (m_valueFromStringFunction == nullptr)
            m_valueFromStringFunction = [](const String& text) { return text.getFloatValue(); };
    }
 
    void KParameter::parameterValueChanged(int /*parameterIndex*/, float newValue)
    {
        if (m_normalisedValue != newValue)
            setValueNotifyingHost(newValue);
    }
 
    float KParameter::get() const { return m_value; }
 
    void KParameter::set(float newValue)
    {
        if (std::isnan(newValue) == false)
        {
            auto normalised = convertTo0to1(newValue);
            if (m_attachedParameter)
                m_attachedParameter->setValueNotifyingHost(normalised);
            else
                setValueNotifyingHost(normalised);
        }
        else
        {
            jassertfalse; // new param value is NaN, shouldn't get here
        }
    }
 
    void KParameter::notifyListeners() { sendValueChangedMessageToListeners(getValue()); }
 
    void KParameter::attach(GenericParameter* p)
    {
        jassert(p != nullptr);
 
        if (m_attachedParameter)
            detach();
 
        p->link(this);
        p->addListener(this);
        p->setValueNotifyingHost(getValue());
 
        m_attachedParameter = p;
    }
 
    void KParameter::detach()
    {
        if (m_attachedParameter)
        {
            m_attachedParameter->removeListener(this);
            m_attachedParameter->unlink();
            m_attachedParameter = nullptr;
        }
    }
 
    GenericParameter* KParameter::getAttachedParameter()
    {
        // This parameter can only be attached to a GUI element if it is currently
        // attached to a GenericParameter.
        jassert(m_attachedParameter != nullptr);
 
        return m_attachedParameter;
    }
 
    const NormalisableRange<float>& KParameter::getNormalisableRange() const { return m_range; }
 
    float KParameter::getValue() const { return m_normalisedValue; }
 
    bool KParameter::isOn() const { return m_normalisedValue > 0.5f; };
 
    void KParameter::setValue(float newValue)
    {
        m_normalisedValue = newValue;
        m_value = convertFrom0to1(newValue);
    }
 
    float KParameter::getDefaultValue() const { return convertTo0to1(m_defaultValue); }
 
    String KParameter::getText(float value, int length) const
    {
        return m_stringFromValueFunction(convertFrom0to1(value), length);
    }
 
    float KParameter::getValueForText(const String& text) const
    {
        return convertTo0to1(m_valueFromStringFunction(text));
    }
} // namespace krotos