#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>

#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 _WIN32

#pragma warning(push)

#pragma warning(disable : 4251)

#endif

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

class TNotAnimatableParamChange : 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 : public TUndo

{

public:

	TNotAnimatableParamChangeUndo(TParam *param,

								  const T &oldValue,

								  const T &newValue);

	~TNotAnimatableParamChangeUndo();

	void undo() const;

	void redo() const;

	int getSize() const;

private:

	TParam *m_param;

	T m_oldValue;

	T m_newValue;

};

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

//  TNotAnimatableParamObserver

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

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

class TNotAnimatableParamObserver : public TParamObserver

{

public:

	TNotAnimatableParamObserver() {}

	virtual void onChange(const TParamChange &) = 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 = m_observers.begin();</tnotanimatableparamobserver<t>

			 obsIt != m_observers.end();

			 ++obsIt)

			(*obsIt)->onChange(change);

		for (std::set<tparamobserver *="">::iterator parObsIt = m_paramObservers.begin();</tparamobserver>

			 parObsIt != m_paramObservers.end();

			 ++parObsIt)

			(*parObsIt)->onChange(change);

	}

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

	void copy(TParam *src)

	{

		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)

	{

		TNotAnimatableParamObserver<t> *obs = dynamic_cast<tnotanimatableparamobserver<t> *>(observer);</tnotanimatableparamobserver<t></t>

		if (obs)

			m_observers.insert(obs);

		else

			m_paramObservers.insert(observer);

	}

	void removeObserver(TParamObserver *observer)

	{

		TNotAnimatableParamObserver<t> *obs = dynamic_cast<tnotanimatableparamobserver<t> *>(observer);</tnotanimatableparamobserver<t></t>

		if (obs)

			m_observers.erase(obs);

		else

			m_paramObservers.erase(observer);

	}

	bool isAnimatable() const { return false; }

	bool isKeyframe(double) const { return false; }

	void deleteKeyframe(double) {}

	void clearKeyframes() {}

	void assignKeyframe(

		double,

		const TSmartPointerT<tparam> &, double,</tparam>

		bool) {}

	std::string getValueAlias(double, int)

	{

		return toString(getValue());

	}

	bool hasKeyframes() const { return 0; };

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

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

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

};

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

//

//  class TIntParam

//

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

#ifdef _WIN32

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

class TIntParam;

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

#endif

class DVAPI TIntParam : 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)()), m_isWheelEnabled(false) {}</int>

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

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

	void loadData(TIStream &is);

	void saveData(TOStream &os);

	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 : 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 { return new TBoolParam(*this); }

	void loadData(TIStream &is);

	void saveData(TOStream &os);

};

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 : 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 { return new TFilePathParam(*this); }

	void loadData(TIStream &is);

	void saveData(TOStream &os);

};

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 : public TNotAnimatableParam<std::wstring></std::wstring>

{

	PERSIST_DECLARATION(TStringParam);

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 { return new TStringParam(*this); }

	void loadData(TIStream &is);

	void saveData(TOStream &os);

};

DEFINE_PARAM_SMARTPOINTER(TStringParam, std::wstring)

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

//

//  class TEnumParam

//

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

class TEnumParamImp;

class DVAPI TEnumParam : 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 { return new TEnumParam(*this); }

	void copy(TParam *src);

	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);

	void saveData(TOStream &os);

private:

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

};

typedef TEnumParam TIntEnumParam;

typedef TNotAnimatableParamObserver<tintenumparam> TIntEnumParamObserver;</tintenumparam>

DVAPI_PARAM_SMARTPOINTER(TIntEnumParam)

class DVAPI TIntEnumParamP : 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 : 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 { 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);

	void saveData(TOStream &os);

private:

	double m_min, m_max;

};

DEFINE_PARAM_SMARTPOINTER(TNADoubleParam, double)

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

//  TNotAnimatableParamChangeUndo

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

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

TNotAnimatableParamChangeUndo<t>::TNotAnimatableParamChangeUndo(TParam *param,</t>

																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 _WIN32

#pragma warning(pop)

#endif

#endif