#ifndef T_PARAM_INCLUDED
#define T_PARAM_INCLUDED
#include "tpersist.h"
#include "tsmartpointer.h"
#include <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
class TParamObserver;
//=========================================================
//! This class is an abstract class and is a generic interface to the features of an object.
/*!
It is used to access to the parameters of an object, with the purpose
to store and retrieve the key features.
*/
class DVAPI TParam : public TSmartObject, public TPersist
{
DECLARE_CLASS_CODE
std::string m_name;
std::string m_description;
std::string m_label;
public:
/*!
The contructor store the name of the parameter and initialize his
interface with I/O through the class TPersist.
*/
TParam(std::string name = "", std::string description = "", std::string label = "")
: TSmartObject(m_classCode), TPersist(), m_name(name), m_description(description),
m_label(label) {}
virtual ~TParam() {}
/*!
Returns the name of the parameter.
*/
std::string getName() const { return m_name; };
/*!
This method sets the name of the parameter to \e name.
*/
void setName(const std::string &name) { m_name = name; };
/*!
Return the description.
*/
std::string getDescription() const { return m_description; }
/*!
Set the description.
*/
void setDescription(const std::string &description) { m_description = description; }
bool hasUILabel() const { return m_label != "" ? true : false; }
void setUILabel(const std::string &l) { m_label = l; };
std::string getUILabel() const { return m_label; };
/*!
This method must be implemented with a clone function, i.e a function that make
a new copy of the parameter.
*/
virtual TParam *clone() const = 0;
/*!
Performs a copy function of the parameter in an existing object.
*/
virtual void copy(TParam *src) = 0;
/*!
An observer is a generic class that takes care and manages of canghes in the parameters.
This method must be implemented with a function that add objects to an observer internal list.
*/
virtual void addObserver(TParamObserver *) = 0;
/*!
Removes \e this from the observer.
\sa addObserver()
*/
virtual void removeObserver(TParamObserver *) = 0;
/*!
This method is used to sets the status changing notification of the parameter. i.e the
observer must take care of the changes.
*/
virtual void enableNotification(bool on) {}
/*!
This method must return \e true if the notification status is enabled.
*/
virtual bool isNotificationEnabled() const { return true; }
/*!
This pure virtual method must return a string with the value of the parameter
and the precision needed.
*/
virtual std::string getValueAlias(double frame, int precision) = 0;
virtual bool isAnimatable() const = 0;
/*!
It must returns \e true if the \e frame is a keyframe.
*/
virtual bool isKeyframe(double frame) const = 0;
/*!
Removes \e frame from the list of the keyframes associated to this parameter.
*/
virtual void deleteKeyframe(double frame) = 0;
/*!
Removes all keyframes from this parameter.
*/
virtual void clearKeyframes() = 0;
/*!
Makes the \e frame associated to this parameter a keyframe
*/
virtual void assignKeyframe(
double frame,
const TSmartPointerT<TParam> &src, double srcFrame,
bool changedOnly = false) = 0;
/*!
This function must be overridden with a method that returns as a reference
a list of keyframes in the form of a standard list.
*/
virtual void getKeyframes(std::set<double> &frames) const {}
/*!
This method must return true if there are keyframes associated to this parameter.
*/
virtual bool hasKeyframes() const { return false; }
/*!
This method must return the index of the keyframe (if any) after the \e frame, otherwiswe
returns -1.
*/
virtual int getNextKeyframe(double frame) const { return -1; }
/*!
This method must return the index of the keyframe (if any) before the \e frame, otherwiswe
returns -1.
*/
virtual int getPrevKeyframe(double frame) const { return -1; }
/*!
This method must returns a frame given the index \e index. A frame is a double value representing
a frame.
*/
virtual double keyframeIndexToFrame(int index) const { return 0.0; }
private:
// not implemented
TParam(const TParam &);
TParam &operator=(const TParam &);
};
//---------------------------------------------------------
#ifdef _WIN32
template class DVAPI TSmartPointerT<TParam>;
#endif
typedef TSmartPointerT<TParam> TParamP;
//=========================================================
#ifdef _WIN32
#define DVAPI_PARAM_SMARTPOINTER(PARAM) \
template class DVAPI TSmartPointerT<PARAM>; \
template class DVAPI TDerivedSmartPointerT<PARAM, TParam>;
#else
#define DVAPI_PARAM_SMARTPOINTER(PARAM)
#endif
#define DEFINE_PARAM_SMARTPOINTER(PARAM, TYPE) \
DVAPI_PARAM_SMARTPOINTER(PARAM) \
\
class DVAPI PARAM##P : public TDerivedSmartPointerT<PARAM, TParam> \
{ \
public: \
PARAM##P(PARAM *p = 0) : DerivedSmartPointer(p) {} \
PARAM##P(TYPE v) : DerivedSmartPointer(new PARAM(v)) {} \
PARAM##P(TParamP &p) : DerivedSmartPointer(p) {} \
PARAM##P(const TParamP &p) : DerivedSmartPointer(p) {} \
operator TParamP() const { return TParamP(m_pointer); } \
};
#endif