AutomatableModel.h

Go to the documentation of this file.

/*
 * AutomatableModel.h - declaration of class AutomatableModel
 *
 * Copyright (c) 2007-2014 Tobias Doerffel <tobydox/at/users.sourceforge.net>
 *
 * This file is part of LMMS - https://lmms.io
 *
 * This program 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 2 of the License, or (at your option) any later version.
 *
 * This program 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 this program (see COPYING); if not, write to the
 * Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301 USA.
 *
 */
 
#ifndef LMMS_AUTOMATABLE_MODEL_H
#define LMMS_AUTOMATABLE_MODEL_H
 
#include <cmath>
#include <QMap>
#include <QMutex>
 
#include "JournallingObject.h"
#include "Model.h"
#include "TimePos.h"
#include "ValueBuffer.h"
#include "ModelVisitor.h"
 
 
namespace lmms
{
 
// simple way to map a property of a view to a model
#define mapPropertyFromModelPtr(type,getfunc,setfunc,modelname) \
        public:                                                 \
            type getfunc() const                                \
            {                                                   \
                return (type) modelname->value();               \
            }                                                   \
        public slots:                                           \
            void setfunc( const type val )                      \
            {                                                   \
                modelname->setValue( val );                     \
            }
 
#define mapPropertyFromModel(type,getfunc,setfunc,modelname)    \
        public:                                                 \
            type getfunc() const                                \
            {                                                   \
                return (type) modelname.value();                \
            }                                                   \
        public slots:                                           \
            void setfunc( const type val )                      \
            {                                                   \
                modelname.setValue( (float) val );              \
            }
 
// use this to make subclasses visitable
#define MODEL_IS_VISITABLE \
    void accept(ModelVisitor& v) override { v.visit(*this); } \
    void accept(ConstModelVisitor& v) const override { v.visit(*this); }
 
 
 
class ControllerConnection;
 
class LMMS_EXPORT AutomatableModel : public Model, public JournallingObject
{
    Q_OBJECT
public:
    enum class ScaleType
    {
        Linear,
        Logarithmic,
        Decibel
    };
 
 
    ~AutomatableModel() override;
 
    // Implement those by using the MODEL_IS_VISITABLE macro
    virtual void accept(ModelVisitor& v) = 0;
    virtual void accept(ConstModelVisitor& v) const = 0;
 
public:
    template<class Target>
    Target* dynamicCast(bool doThrow = false)
    {
        DCastVisitor<Target> vis; accept(vis);
        if (doThrow && !vis.result) { Q_ASSERT(false); }
        return vis.result;
    }

    template<class Target>
    const Target* dynamicCast(bool doThrow = false) const
    {
        ConstDCastVisitor<Target> vis; accept(vis);
        if (doThrow && !vis.result) { Q_ASSERT(false); }
        return vis.result;
    }
 
    bool isAutomated() const;
    bool isAutomatedOrControlled() const
    {
        return isAutomated() || m_controllerConnection != nullptr;
    }
 
    ControllerConnection* controllerConnection() const
    {
        return m_controllerConnection;
    }
 
 
    void setControllerConnection( ControllerConnection* c );
 
 
    template<class T>
    static T castValue( const float v )
    {
        return (T)( v );
    }
 
    template<bool>
    static bool castValue( const float v )
    {
        return (std::round(v) != 0);
    }
 
 
    template<class T>
    inline T value( int frameOffset = 0 ) const
    {
        // TODO
        // The `m_value` should only be updated whenever the Controller value changes,
        // instead of the Model calling `controller->currentValue()` every time.
        // This becomes even worse in the case of linked Models, where it has to
        // loop through the list of all links.
 
        if (m_useControllerValue)
        {
            if (m_controllerConnection)
            {
                return castValue<T>(controllerValue(frameOffset));
            }
            for (auto next = m_nextLink; next != this; next = next->m_nextLink)
            {
                if (next->controllerConnection() && next->useControllerValue())
                {
                    return castValue<T>(fittedValue(next->controllerValue(frameOffset)));
                }
            }
        }
        return castValue<T>( m_value );
    }
 
    float controllerValue( int frameOffset ) const;

    ValueBuffer * valueBuffer();
 
    template<class T>
    T initValue() const
    {
        return castValue<T>( m_initValue );
    }
 
    bool isAtInitValue() const
    {
        return m_value == m_initValue;
    }
 
    template<class T>
    T minValue() const
    {
        return castValue<T>( m_minValue );
    }
 
    template<class T>
    T maxValue() const
    {
        return castValue<T>( m_maxValue );
    }
 
    template<class T>
    T step() const
    {
        return castValue<T>( m_step );
    }

    float scaledValue( float value ) const;
    float inverseScaledValue( float value ) const;
 
    void setInitValue( const float value );
 
    void setValue(const float value, const bool isAutomated = false);
 
    void incValue( int steps )
    {
        setValue( m_value + steps * m_step );
    }
 
    float range() const
    {
        return m_range;
    }
 
    void setRange( const float min, const float max, const float step = 1 );
    void setScaleType( ScaleType sc ) {
        m_scaleType = sc;
    }
    void setScaleLogarithmic( bool setToTrue = true )
    {
        setScaleType( setToTrue ? ScaleType::Logarithmic : ScaleType::Linear );
    }
    bool isScaleLogarithmic() const
    {
        return m_scaleType == ScaleType::Logarithmic;
    }
 
    void setStep( const float step );
 
    float centerValue() const
    {
        return m_centerValue;
    }
 
    void setCenterValue( const float centerVal )
    {
        m_centerValue = centerVal;
    }

    void linkToModel(AutomatableModel* model);
    size_t countLinks() const;

    virtual void saveSettings(QDomDocument& doc, QDomElement& element, const QString& name);

    virtual void loadSettings(const QDomElement& element, const QString& name);
 
    QString nodeName() const override
    {
        return "automatablemodel";
    }
 
    virtual QString displayValue( const float val ) const = 0;
 
    bool isLinked() const
    {
        return m_nextLink != this;
    }
 
    // a way to track changed values in the model and avoid using signals/slots - useful for speed-critical code.
    // note that this method should only be called once per period since it resets the state of the variable - so if your model
    // has to be accessed by more than one object, then this function shouldn't be used.
    bool isValueChanged()
    {
        if( m_valueChanged || valueBuffer() )
        {
            m_valueChanged = false;
            return true;
        }
        return false;
    }
 
    float globalAutomationValueAt( const TimePos& time );
 
    void setStrictStepSize( const bool b )
    {
        m_hasStrictStepSize = b;
    }
 
    static void incrementPeriodCounter()
    {
        ++s_periodCounter;
    }
 
    static void resetPeriodCounter()
    {
        s_periodCounter = 0;
    }
 
    bool useControllerValue() const
    {
        return m_useControllerValue;
    }
 
public slots:
    virtual void reset();
    void unlink();
    void unlinkControllerConnection();
    void setUseControllerValue(bool b = true);
 
 
protected:
    AutomatableModel(
                        const float val = 0,
                        const float min = 0,
                        const float max = 0,
                        const float step = 0,
                        Model* parent = nullptr,
                        const QString& displayName = QString(),
                        bool defaultConstructed = false );
    float fittedValue( float value ) const;
 
 
private:
    // dynamicCast implementation
    template<class Target>
    struct DCastVisitor : public ModelVisitor
    {
        Target* result = nullptr;
        void visit(Target& tar) { result = &tar; }
    };
 
    // dynamicCast implementation
    template<class Target>
    struct ConstDCastVisitor : public ConstModelVisitor
    {
        const Target* result = nullptr;
        void visit(const Target& tar) { result = &tar; }
    };
 
    static bool mustQuoteName(const QString &name);
 
    void saveSettings( QDomDocument& doc, QDomElement& element ) override
    {
        saveSettings( doc, element, "value" );
    }
 
    void loadSettings( const QDomElement& element ) override
    {
        loadSettings( element, "value" );
    }
 
    void setValueInternal(const float value);

    AutomatableModel* getLastLinkedModel() const;

    bool isLinkedToModel(AutomatableModel* model) const;
    
    template<class T> T logToLinearScale(T value) const;

    template<class T> void roundAt(T& value, const T& where) const;
 
 
    ScaleType m_scaleType; 
    float m_value;
    float m_initValue;
    float m_minValue;
    float m_maxValue;
    float m_step;
    float m_range;
    float m_centerValue;
 
    bool m_valueChanged;
    float m_oldValue; 
 
    // used to determine if step size should be applied strictly (ie. always)
    // or only when value set from gui (default)
    bool m_hasStrictStepSize;

    AutomatableModel* m_nextLink;
 

    ControllerConnection* m_controllerConnection;
 
 
    ValueBuffer m_valueBuffer;
    long m_lastUpdatedPeriod;
    static long s_periodCounter;
 
    bool m_hasSampleExactData;
 
    // prevent several threads from attempting to write the same vb at the same time
    QMutex m_valueBufferMutex;
 
    bool m_useControllerValue;
 
signals:
    void initValueChanged( float val );
    void destroyed( lmms::jo_id_t id );
 
} ;
 
 
 
 
template <typename T> class LMMS_EXPORT TypedAutomatableModel : public AutomatableModel
{
public:
    using AutomatableModel::AutomatableModel;
    T value( int frameOffset = 0 ) const
    {
        return AutomatableModel::value<T>( frameOffset );
    }
 
    T initValue() const
    {
        return AutomatableModel::initValue<T>();
    }
 
    T minValue() const
    {
        return AutomatableModel::minValue<T>();
    }
 
    T maxValue() const
    {
        return AutomatableModel::maxValue<T>();
    }
};
 
 
// some typed AutomatableModel-definitions
 
class LMMS_EXPORT FloatModel : public TypedAutomatableModel<float>
{
    Q_OBJECT
    MODEL_IS_VISITABLE
public:
    FloatModel( float val = 0, float min = 0, float max = 0, float step = 0,
                Model * parent = nullptr,
                const QString& displayName = QString(),
                bool defaultConstructed = false ) :
        TypedAutomatableModel( val, min, max, step, parent, displayName, defaultConstructed )
    {
    }
    float getRoundedValue() const;
    int getDigitCount() const;
    QString displayValue( const float val ) const override;
} ;
 
 
class LMMS_EXPORT IntModel : public TypedAutomatableModel<int>
{
    Q_OBJECT
    MODEL_IS_VISITABLE
public:
    IntModel( int val = 0, int min = 0, int max = 0,
                Model* parent = nullptr,
                const QString& displayName = QString(),
                bool defaultConstructed = false ) :
        TypedAutomatableModel( val, min, max, 1, parent, displayName, defaultConstructed )
    {
    }
    QString displayValue( const float val ) const override;
} ;
 
 
class LMMS_EXPORT BoolModel : public TypedAutomatableModel<bool>
{
    Q_OBJECT
    MODEL_IS_VISITABLE
public:
    BoolModel( const bool val = false,
                Model* parent = nullptr,
                const QString& displayName = QString(),
                bool defaultConstructed = false ) :
        TypedAutomatableModel( val, false, true, 1, parent, displayName, defaultConstructed )
    {
    }
    QString displayValue( const float val ) const override;
} ;
 
using AutomatedValueMap = QMap<AutomatableModel*, float>;
 
} // namespace lmms
 
#endif // LMMS_AUTOMATABLE_MODEL_H