51daab8588
* removed unused tcleanuppreprocessor.cpp and .h Signed-off-by: Jeremy Bullock <jcbullock@gmail.com> * removed unused directory lzodriver Signed-off-by: Jeremy Bullock <jcbullock@gmail.com> * OpenToonz changes as of 11-11-20 Co-authored-by: Sean Kuehl <teddscottfelt@gmail.com>
483 lines
14 KiB
C++
483 lines
14 KiB
C++
#pragma once
|
|
|
|
#ifndef TNOTANIMATABLEPARAM_H
|
|
#define TNOTANIMATABLEPARAM_H
|
|
|
|
#include <memory>
|
|
|
|
#include "tparam.h"
|
|
#include "tparamchange.h"
|
|
#include "tfilepath.h"
|
|
#include "texception.h"
|
|
#include "tundo.h"
|
|
#include "tconvert.h"
|
|
|
|
#include <set>
|
|
#include <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 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);
|
|
}
|
|
TUndo *createUndo() const;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// TNotAnimatableParamChangeUndo
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
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 TNotAnimatableParamObserver : public TParamObserver {
|
|
public:
|
|
TNotAnimatableParamObserver() {}
|
|
|
|
void onChange(const TParamChange &) override = 0;
|
|
void onChange(const TNotAnimatableParamChange<T> &change) {
|
|
onChange(static_cast<const TParamChange &>(change));
|
|
}
|
|
};
|
|
|
|
typedef TNotAnimatableParamObserver<int> TIntParamObserver;
|
|
typedef TNotAnimatableParamObserver<bool> TBoolParamObserver;
|
|
typedef TNotAnimatableParamObserver<TFilePath> TFilePathParamObserver;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// TNotAnimatableParam base class
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
class DVAPI TNotAnimatableParam : public TParam {
|
|
T m_defaultValue, m_value;
|
|
|
|
protected:
|
|
std::set<TNotAnimatableParamObserver<T> *> m_observers;
|
|
std::set<TParamObserver *> m_paramObservers;
|
|
|
|
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);
|
|
m_value = v;
|
|
for (typename std::set<TNotAnimatableParamObserver<T> *>::iterator obsIt =
|
|
m_observers.begin();
|
|
obsIt != m_observers.end(); ++obsIt)
|
|
(*obsIt)->onChange(change);
|
|
for (std::set<TParamObserver *>::iterator parObsIt =
|
|
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);
|
|
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 =
|
|
dynamic_cast<TNotAnimatableParamObserver<T> *>(observer);
|
|
if (obs)
|
|
m_observers.insert(obs);
|
|
else
|
|
m_paramObservers.insert(observer);
|
|
}
|
|
void removeObserver(TParamObserver *observer) override {
|
|
TNotAnimatableParamObserver<T> *obs =
|
|
dynamic_cast<TNotAnimatableParamObserver<T> *>(observer);
|
|
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,
|
|
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{};
|
|
int getNextKeyframe(double) const override { return -1; };
|
|
int getPrevKeyframe(double) const override { return -1; };
|
|
};
|
|
|
|
//=========================================================
|
|
//
|
|
// class TIntParam
|
|
//
|
|
//=========================================================
|
|
|
|
#ifdef _WIN32
|
|
template class DVAPI TNotAnimatableParam<int>;
|
|
class TIntParam;
|
|
template class DVAPI TPersistDeclarationT<TIntParam>;
|
|
#endif
|
|
|
|
class DVAPI TIntParam final : public TNotAnimatableParam<int> {
|
|
PERSIST_DECLARATION(TIntParam);
|
|
int minValue, maxValue;
|
|
bool m_isWheelEnabled;
|
|
|
|
public:
|
|
TIntParam(int v = int())
|
|
: TNotAnimatableParam<int>(v)
|
|
, minValue(-(std::numeric_limits<int>::max)())
|
|
, maxValue((std::numeric_limits<int>::max)())
|
|
, m_isWheelEnabled(false) {}
|
|
TIntParam(const TIntParam &src) : TNotAnimatableParam<int>(src) {}
|
|
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>;
|
|
class TBoolParam;
|
|
template class DVAPI TPersistDeclarationT<TBoolParam>;
|
|
#endif
|
|
|
|
class DVAPI TBoolParam final : public TNotAnimatableParam<bool> {
|
|
PERSIST_DECLARATION(TBoolParam);
|
|
|
|
public:
|
|
TBoolParam(bool v = bool()) : TNotAnimatableParam<bool>(v) {}
|
|
TBoolParam(const TBoolParam &src) : TNotAnimatableParam<bool>(src) {}
|
|
|
|
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>;
|
|
class TFilePathParam;
|
|
template class DVAPI TPersistDeclarationT<TFilePathParam>;
|
|
#endif
|
|
|
|
class DVAPI TFilePathParam final : public TNotAnimatableParam<TFilePath> {
|
|
PERSIST_DECLARATION(TFilePathParam);
|
|
|
|
public:
|
|
TFilePathParam(const TFilePath &v = TFilePath())
|
|
: TNotAnimatableParam<TFilePath>(v) {}
|
|
TFilePathParam(const TFilePathParam &src)
|
|
: TNotAnimatableParam<TFilePath>(src) {}
|
|
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>;
|
|
class TStringParam;
|
|
template class DVAPI TPersistDeclarationT<TStringParam>;
|
|
#endif
|
|
|
|
class DVAPI TStringParam final : public TNotAnimatableParam<std::wstring> {
|
|
PERSIST_DECLARATION(TStringParam);
|
|
|
|
bool m_multiLine = false;
|
|
|
|
public:
|
|
TStringParam(std::wstring v = L"") : TNotAnimatableParam<std::wstring>(v) {}
|
|
TStringParam(const TStringParam &src)
|
|
: TNotAnimatableParam<std::wstring>(src) {}
|
|
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> {
|
|
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;
|
|
};
|
|
|
|
typedef TEnumParam TIntEnumParam;
|
|
|
|
typedef TNotAnimatableParamObserver<TIntEnumParam> TIntEnumParamObserver;
|
|
|
|
DVAPI_PARAM_SMARTPOINTER(TIntEnumParam)
|
|
|
|
class DVAPI TIntEnumParamP final
|
|
: public TDerivedSmartPointerT<TIntEnumParam, TParam> {
|
|
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>;
|
|
class TNADoubleParam;
|
|
template class DVAPI TPersistDeclarationT<TNADoubleParam>;
|
|
#endif
|
|
|
|
class DVAPI TNADoubleParam final : public TNotAnimatableParam<double> {
|
|
PERSIST_DECLARATION(TNADoubleParam);
|
|
|
|
public:
|
|
TNADoubleParam(double v = double())
|
|
: TNotAnimatableParam<double>(v), m_min(0.), m_max(100.) {}
|
|
TNADoubleParam(const TNADoubleParam &src)
|
|
: TNotAnimatableParam<double>(src) {}
|
|
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);
|
|
}
|
|
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>;
|
|
class TFontParam;
|
|
template class DVAPI TPersistDeclarationT<TFontParam>;
|
|
#endif
|
|
|
|
class DVAPI TFontParam final : public TNotAnimatableParam<std::wstring> {
|
|
PERSIST_DECLARATION(TFontParam);
|
|
|
|
public:
|
|
TFontParam(std::wstring v = QFont().toString().toStdWString())
|
|
: TNotAnimatableParam<std::wstring>(v) {}
|
|
TFontParam(const TFontParam &src) : TNotAnimatableParam<std::wstring>(src) {}
|
|
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>
|
|
TNotAnimatableParamChangeUndo<T>::TNotAnimatableParamChangeUndo(
|
|
TParam *param, const T &oldValue, const T &newValue)
|
|
: m_param(param), m_oldValue(oldValue), m_newValue(newValue) {
|
|
m_param->addRef();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
TNotAnimatableParamChangeUndo<T>::~TNotAnimatableParamChangeUndo() {
|
|
m_param->release();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
void TNotAnimatableParamChangeUndo<T>::undo() const {
|
|
TNotAnimatableParam<T> *p = dynamic_cast<TNotAnimatableParam<T> *>(m_param);
|
|
p->setValue(m_oldValue, true);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
void TNotAnimatableParamChangeUndo<T>::redo() const {
|
|
TNotAnimatableParam<T> *p = dynamic_cast<TNotAnimatableParam<T> *>(m_param);
|
|
p->setValue(m_newValue, true);
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
int TNotAnimatableParamChangeUndo<T>::getSize() const {
|
|
return sizeof(*this);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// TNotAnimatableParamChange
|
|
//-----------------------------------------------------------------------------
|
|
|
|
template <class T>
|
|
TUndo *TNotAnimatableParamChange<T>::createUndo() const {
|
|
return new TNotAnimatableParamChangeUndo<T>(m_param, m_oldValue, m_newValue);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#ifdef _MSC_VER
|
|
#pragma warning(pop)
|
|
#endif
|
|
|
|
#endif
|