#pragma once

#ifndef TNOTANIMATABLEPARAM_H

#define TNOTANIMATABLEPARAM_H

#include <memory></memory>

#include "tparam.h"

#include "tparamchange.h"

#include "tfilepath.h"

#include "texception.h"

#include "tundo.h"

#include "tconvert.h"

#include <set></set>

#include <qfont></qfont>

#undef DVAPI

#undef DVVAR

#ifdef TPARAM_EXPORTS

#define DVAPI DV_EXPORT_API

#define DVVAR DV_EXPORT_VAR

#else

#define DVAPI DV_IMPORT_API

#define DVVAR DV_IMPORT_VAR

#endif

//-----------------------------------------------------------------------------

//  TNotAnimatableParamChange

//-----------------------------------------------------------------------------

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable : 4251)

#endif

template <class t=""></class>

class TNotAnimatableParamChange final : public TParamChange {

  T m_oldValue;

  T m_newValue;

public:

  TNotAnimatableParamChange(TParam *param, const T &oldValue, const T &newValue,

                            bool undoing)

      : TParamChange(param, TParamChange::m_minFrame, TParamChange::m_maxFrame,

                     false, false, undoing)

      , m_oldValue(oldValue)

      , m_newValue(newValue) {}

  TParamChange *clone() const {

    return new TNotAnimatableParamChange<t>(*this);</t>

  }

  TUndo *createUndo() const;

};

//-----------------------------------------------------------------------------

//  TNotAnimatableParamChangeUndo

//-----------------------------------------------------------------------------

template <class t=""></class>

class TNotAnimatableParamChangeUndo final : public TUndo {

public:

  TNotAnimatableParamChangeUndo(TParam *param, const T &oldValue,

                                const T &newValue);

  ~TNotAnimatableParamChangeUndo();

  void undo() const override;

  void redo() const override;

  int getSize() const override;

private:

  TParam *m_param;

  T m_oldValue;

  T m_newValue;

};

//-----------------------------------------------------------------------------

//  TNotAnimatableParamObserver

//-----------------------------------------------------------------------------

template <class t=""></class>

class TNotAnimatableParamObserver : public TParamObserver {

public:

  TNotAnimatableParamObserver() {}

  void onChange(const TParamChange &) override = 0;

  void onChange(const TNotAnimatableParamChange<t> &change) {</t>

    onChange(static_cast<const &="" tparamchange="">(change));</const>

  }

};

typedef TNotAnimatableParamObserver<int> TIntParamObserver;</int>

typedef TNotAnimatableParamObserver<bool> TBoolParamObserver;</bool>

typedef TNotAnimatableParamObserver<tfilepath> TFilePathParamObserver;</tfilepath>

//-----------------------------------------------------------------------------

//    TNotAnimatableParam base class

//-----------------------------------------------------------------------------

using std::set;

template <class t=""></class>

class DVAPI TNotAnimatableParam : public TParam {

  T m_defaultValue, m_value;

protected:

  set<tnotanimatableparamobserver<t> *> m_observers;</tnotanimatableparamobserver<t>

  set<tparamobserver *=""> m_paramObservers;</tparamobserver>

public:

  TNotAnimatableParam(T def = T())

      : TParam(), m_defaultValue(def), m_value(def){};

  TNotAnimatableParam(const TNotAnimatableParam &src)

      : TParam(src.getName())

      , m_defaultValue(src.getDefaultValue())

      , m_value(src.getValue()){};

  ~TNotAnimatableParam(){};

  T getValue() const { return m_value; }

  T getDefaultValue() const { return m_defaultValue; }

  void setValue(T v, bool undoing = false) {

    if (m_value == v) return;

    TNotAnimatableParamChange<t> change(this, m_value, v, undoing);</t>

    m_value = v;

    for (typename std::set<tnotanimatableparamobserver<t> *>::iterator obsIt =</tnotanimatableparamobserver<t>

             m_observers.begin();

         obsIt != m_observers.end(); ++obsIt)

      (*obsIt)->onChange(change);

    for (std::set<tparamobserver *="">::iterator parObsIt =</tparamobserver>

             m_paramObservers.begin();

         parObsIt != m_paramObservers.end(); ++parObsIt)

      (*parObsIt)->onChange(change);

  }

  void setDefaultValue(T value) { m_defaultValue = value; }

  void copy(TParam *src) override {

    TNotAnimatableParam<t> *p = dynamic_cast<tnotanimatableparam<t> *>(src);</tnotanimatableparam<t></t>

    if (!p) throw TException("invalid source for copy");

    setName(src->getName());

    m_defaultValue = p->m_defaultValue;

    m_value        = p->m_value;

  }

  void reset(bool undoing = false) { setValue(m_defaultValue, undoing); }

  void addObserver(TParamObserver *observer) override {

    TNotAnimatableParamObserver<t> *obs =</t>

        dynamic_cast<tnotanimatableparamobserver<t> *>(observer);</tnotanimatableparamobserver<t>

    if (obs)

      m_observers.insert(obs);

    else

      m_paramObservers.insert(observer);

  }

  void removeObserver(TParamObserver *observer) override {

    TNotAnimatableParamObserver<t> *obs =</t>

        dynamic_cast<tnotanimatableparamobserver<t> *>(observer);</tnotanimatableparamobserver<t>

    if (obs)

      m_observers.erase(obs);

    else

      m_paramObservers.erase(observer);

  }

  bool isAnimatable() const override { return false; }

  bool isKeyframe(double) const override { return false; }

  void deleteKeyframe(double) override {}

  void clearKeyframes() override {}

  void assignKeyframe(double, const TSmartPointerT<tparam> &, double,</tparam>

                      bool) override {}

  std::string getValueAlias(double, int) override {

    using namespace std;

    return to_string(getValue());

  }

  bool hasKeyframes() const override { return 0; };

  void getKeyframes(std::set<double> &) const override{};</double>

  int getNextKeyframe(double) const override { return -1; };

  int getPrevKeyframe(double) const override { return -1; };

};

//=========================================================

//

//  class TIntParam

//

//=========================================================

#ifdef _WIN32

template class DVAPI TNotAnimatableParam<int>;</int>

class TIntParam;

template class DVAPI TPersistDeclarationT<tintparam>;</tintparam>

#endif

class DVAPI TIntParam final : public TNotAnimatableParam<int> {</int>

  PERSIST_DECLARATION(TIntParam);

  int minValue, maxValue;

  bool m_isWheelEnabled;

public:

  TIntParam(int v = int())

      : TNotAnimatableParam<int>(v)</int>

      , minValue(-(std::numeric_limits<int>::max)())</int>

      , maxValue((std::numeric_limits<int>::max)())</int>

      , m_isWheelEnabled(false) {}

  TIntParam(const TIntParam &src) : TNotAnimatableParam<int>(src) {}</int>

  TParam *clone() const override { return new TIntParam(*this); }

  void loadData(TIStream &is) override;

  void saveData(TOStream &os) override;

  void enableWheel(bool on);

  bool isWheelEnabled() const;

  void setValueRange(int min, int max);

  bool getValueRange(int &min, int &max) const;

};

DEFINE_PARAM_SMARTPOINTER(TIntParam, int)

//=========================================================

//

//  class TBoolParam

//

//=========================================================

#ifdef _WIN32

template class DVAPI TNotAnimatableParam<bool>;</bool>

class TBoolParam;

template class DVAPI TPersistDeclarationT<tboolparam>;</tboolparam>

#endif

class DVAPI TBoolParam final : public TNotAnimatableParam<bool> {</bool>

  PERSIST_DECLARATION(TBoolParam);

public:

  TBoolParam(bool v = bool()) : TNotAnimatableParam<bool>(v) {}</bool>

  TBoolParam(const TBoolParam &src) : TNotAnimatableParam<bool>(src) {}</bool>

  TParam *clone() const override { return new TBoolParam(*this); }

  void loadData(TIStream &is) override;

  void saveData(TOStream &os) override;

};

DEFINE_PARAM_SMARTPOINTER(TBoolParam, bool)

//=========================================================

//

//  class TFilePathParam

//

//=========================================================

#ifdef _WIN32

template class DVAPI TNotAnimatableParam<tfilepath>;</tfilepath>

class TFilePathParam;

template class DVAPI TPersistDeclarationT<tfilepathparam>;</tfilepathparam>

#endif

class DVAPI TFilePathParam final : public TNotAnimatableParam<tfilepath> {</tfilepath>

  PERSIST_DECLARATION(TFilePathParam);

public:

  TFilePathParam(const TFilePath &v = TFilePath())

      : TNotAnimatableParam<tfilepath>(v) {}</tfilepath>

  TFilePathParam(const TFilePathParam &src)

      : TNotAnimatableParam<tfilepath>(src) {}</tfilepath>

  TParam *clone() const override { return new TFilePathParam(*this); }

  void loadData(TIStream &is) override;

  void saveData(TOStream &os) override;

};

DEFINE_PARAM_SMARTPOINTER(TFilePathParam, TFilePath)

//=========================================================

//

//  class TStringParam

//

//=========================================================

#ifdef _WIN32

template class DVAPI TNotAnimatableParam<std::wstring>;</std::wstring>

class TStringParam;

template class DVAPI TPersistDeclarationT<tstringparam>;</tstringparam>

#endif

class DVAPI TStringParam final : public TNotAnimatableParam<std::wstring> {</std::wstring>

  PERSIST_DECLARATION(TStringParam);

  bool m_multiLine = false;

public:

  TStringParam(std::wstring v = L"") : TNotAnimatableParam<std::wstring>(v) {}</std::wstring>

  TStringParam(const TStringParam &src)

      : TNotAnimatableParam<std::wstring>(src) {}</std::wstring>

  TParam *clone() const override { return new TStringParam(*this); }

  void loadData(TIStream &is) override;

  void saveData(TOStream &os) override;

  void setMultiLineEnabled(bool enable) { m_multiLine = enable; }

  bool isMultiLineEnabled() { return m_multiLine; }

};

DEFINE_PARAM_SMARTPOINTER(TStringParam, std::wstring)

//=========================================================

//

//  class TEnumParam

//

//=========================================================

class TEnumParamImp;

class DVAPI TEnumParam final : public TNotAnimatableParam<int> {</int>

  PERSIST_DECLARATION(TEnumParam)

public:

  TEnumParam(const int &v, const std::string &caption);

  TEnumParam();

  TEnumParam(const TEnumParam &src);

  ~TEnumParam();

  TParam *clone() const override { return new TEnumParam(*this); }

  void copy(TParam *src) override;

  void setValue(int v, bool undoing = false);

  void setValue(const std::string &caption, bool undoing = false);

  void addItem(const int &item, const std::string &caption);

  int getItemCount() const;

  void getItem(int i, int &item, std::string &caption) const;

  // TPersist methods

  void loadData(TIStream &is) override;

  void saveData(TOStream &os) override;

private:

  std::unique_ptr<tenumparamimp> m_imp;</tenumparamimp>

};

typedef TEnumParam TIntEnumParam;

typedef TNotAnimatableParamObserver<tintenumparam> TIntEnumParamObserver;</tintenumparam>

DVAPI_PARAM_SMARTPOINTER(TIntEnumParam)

class DVAPI TIntEnumParamP final

    : public TDerivedSmartPointerT<tintenumparam, tparam=""> {</tintenumparam,>

public:

  TIntEnumParamP(TIntEnumParam *p = 0) : DerivedSmartPointer(p) {}

  TIntEnumParamP(int v, const std::string &caption)

      : DerivedSmartPointer(new TEnumParam(v, caption)) {}

  TIntEnumParamP(TParamP &p) : DerivedSmartPointer(p) {}

  TIntEnumParamP(const TParamP &p) : DerivedSmartPointer(p) {}

  operator TParamP() const { return TParamP(m_pointer); }

};

//------------------------------------------------------------------------------

//=========================================================

//

//  class TNADoubleParam   //is a not animatable double param

//

//=========================================================

#ifdef _WIN32

template class DVAPI TNotAnimatableParam<double>;</double>

class TNADoubleParam;

template class DVAPI TPersistDeclarationT<tnadoubleparam>;</tnadoubleparam>

#endif

class DVAPI TNADoubleParam final : public TNotAnimatableParam<double> {</double>

  PERSIST_DECLARATION(TNADoubleParam);

public:

  TNADoubleParam(double v = double())

      : TNotAnimatableParam<double>(v), m_min(0.), m_max(100.) {}</double>

  TNADoubleParam(const TNADoubleParam &src)

      : TNotAnimatableParam<double>(src) {}</double>

  TParam *clone() const override { return new TNADoubleParam(*this); }

  void setValueRange(double min, double max) {

    m_min = min;

    m_max = max;

  }

  void setValue(double v, bool undoing = false) {

    notMoreThan(m_max, v);

    notLessThan(m_min, v);

    TNotAnimatableParam<double>::setValue(v, undoing);</double>

  }

  bool getValueRange(double &min, double &max) const {

    min = m_min;

    max = m_max;

    return min < max;

  }

  void loadData(TIStream &is) override;

  void saveData(TOStream &os) override;

private:

  double m_min, m_max;

};

DEFINE_PARAM_SMARTPOINTER(TNADoubleParam, double)

//=========================================================

//

//  class TFontParam

//

//=========================================================

#ifdef _WIN32

template class DVAPI TNotAnimatableParam<std::wstring>;</std::wstring>

class TFontParam;

template class DVAPI TPersistDeclarationT<tfontparam>;</tfontparam>

#endif

class DVAPI TFontParam final : public TNotAnimatableParam<std::wstring> {</std::wstring>

  PERSIST_DECLARATION(TFontParam);

public:

  TFontParam(std::wstring v = QFont().toString().toStdWString())

      : TNotAnimatableParam<std::wstring>(v) {}</std::wstring>

  TFontParam(const TFontParam &src) : TNotAnimatableParam<std::wstring>(src) {}</std::wstring>

  TParam *clone() const override { return new TFontParam(*this); }

  void loadData(TIStream &is) override;

  void saveData(TOStream &os) override;

};

DEFINE_PARAM_SMARTPOINTER(TFontParam, std::wstring)

//-----------------------------------------------------------------------------

//  TNotAnimatableParamChangeUndo

//-----------------------------------------------------------------------------

template <class t=""></class>

TNotAnimatableParamChangeUndo<t>::TNotAnimatableParamChangeUndo(</t>

    TParam *param, const T &oldValue, const T &newValue)

    : m_param(param), m_oldValue(oldValue), m_newValue(newValue) {

  m_param->addRef();

}

//-----------------------------------------------------------------------------

template <class t=""></class>

TNotAnimatableParamChangeUndo<t>::~TNotAnimatableParamChangeUndo() {</t>

  m_param->release();

}

//-----------------------------------------------------------------------------

template <class t=""></class>

void TNotAnimatableParamChangeUndo<t>::undo() const {</t>

  TNotAnimatableParam<t> *p = dynamic_cast<tnotanimatableparam<t> *>(m_param);</tnotanimatableparam<t></t>

  p->setValue(m_oldValue, true);

}

//-----------------------------------------------------------------------------

template <class t=""></class>

void TNotAnimatableParamChangeUndo<t>::redo() const {</t>

  TNotAnimatableParam<t> *p = dynamic_cast<tnotanimatableparam<t> *>(m_param);</tnotanimatableparam<t></t>

  p->setValue(m_newValue, true);

}

//-----------------------------------------------------------------------------

template <class t=""></class>

int TNotAnimatableParamChangeUndo<t>::getSize() const {</t>

  return sizeof(*this);

}

//-----------------------------------------------------------------------------

//  TNotAnimatableParamChange

//-----------------------------------------------------------------------------

template <class t=""></class>

TUndo *TNotAnimatableParamChange<t>::createUndo() const {</t>

  return new TNotAnimatableParamChangeUndo<t>(m_param, m_oldValue, m_newValue);</t>

}

//-----------------------------------------------------------------------------

#ifdef _MSC_VER

#pragma warning(pop)

#endif

#endif