#pragma once

#ifndef TPARAMSET_H

#define TPARAMSET_H

#include "tparam.h"

#include "tparamchange.h"

#include "tgeometry.h"

#include "tpixel.h"

#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

// forward declaration

class TParamSetImp;

class TParamSetChange final : public TParamChange {

public:

  std::vector<tparamchange *=""> m_paramChanges;</tparamchange>

public:

  TParamSetChange(TParam *param, double firstAffectedFrame,

                  double lastAffectedFrame,

                  const std::vector<tparamchange *=""> ¶mChanges)</tparamchange>

      : TParamChange(param, firstAffectedFrame, lastAffectedFrame, true, false,

                     false)

      , m_paramChanges(paramChanges) {}

  ~TParamSetChange() { clearPointerContainer(m_paramChanges); }

  TParamChange *clone() const { return new TParamSetChange(*this); }

};

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

#ifdef _MSC_VER

#pragma warning(push)

#pragma warning(disable : 4251)

#endif

class DVAPI TParamSet : public TParam {

  PERSIST_DECLARATION(TParamSet)

public:

  TParamSet(std::string name = "");

  TParamSet(const TParamSet &src);

  ~TParamSet();

  void addParam(const TParamP ¶m, const std::string &name);

  void insertParam(const TParamP ¶m, const std::string &name, int index);

  void removeParam(const TParamP ¶m);

  void removeAllParam();

  int getParamCount() const;

  TParamP getParam(int index) const;

  std::string getParamName(int index) const;

  int getParamIdx(const std::string &name) const;

  void getAnimatableParams(std::vector<tparamp> ¶ms, bool recursive = true);</tparamp>

  void addObserver(TParamObserver *observer) override;

  void removeObserver(TParamObserver *observer) override;

  void beginParameterChange();

  void endParameterChange();

  void enableDragging(bool on);

  void enableNotification(bool on) override;

  bool isNotificationEnabled() const override;

  bool isAnimatable() const override { return true; }

  bool isKeyframe(double frame) const override;

  void deleteKeyframe(double frame) override;

  void clearKeyframes() override;

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

                      double srcFrame, bool changedOnly = false) override;

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

  int getKeyframeCount() const;

  double keyframeIndexToFrame(int index) const override;

  TParam *clone() const override;

  void copy(TParam *src) override;

  void loadData(TIStream &) override;

  void saveData(TOStream &) override;

  int getNextKeyframe(double frame) const override;

  int getPrevKeyframe(double frame) const override;

  bool hasKeyframes() const override;

  std::string getValueAlias(double frame, int precision) override;

private:

  TParamSetImp *m_imp = nullptr;

};

#ifdef _MSC_VER

#pragma warning(pop)

#endif

#ifdef _WIN32

template class DVAPI TSmartPointerT<tparamset>;</tparamset>

template class DVAPI TDerivedSmartPointerT<tparamset, tparam="">;</tparamset,>

#endif

typedef TDerivedSmartPointerT<tparamset, tparam=""> TParamSetP;</tparamset,>

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

class TPointParamObserver {

public:

  TPointParamObserver() {}

  virtual ~TPointParamObserver() {}

  virtual void onChange(const TParamChange &) = 0;

};

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

#ifdef _WIN32

class TPointParam;

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

#endif

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

class TPointParamImp;

class TDoubleParamP;

class DVAPI TPointParam final : public TParamSet {

  PERSIST_DECLARATION(TPointParam)

  TPointParamImp *m_data;

  bool m_from_plugin;

public:

  TPointParam(const TPointD &p = TPointD(), bool from_plugin = false);

  TPointParam(const TPointParam &src);

  ~TPointParam();

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

  void copy(TParam *src) override;

  TPointD getDefaultValue() const;

  TPointD getValue(double frame) const;

  bool setValue(double frame, const TPointD &p);

  void setDefaultValue(const TPointD &p);

  void loadData(TIStream &is) override;

  void saveData(TOStream &os) override;

  TDoubleParamP &getX();

  TDoubleParamP &getY();

  bool isFromPlugin() const { return m_from_plugin; }

};

DEFINE_PARAM_SMARTPOINTER(TPointParam, TPointD)

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

#ifdef _WIN32

class TPixelParam;

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

#endif

class TPixelParamObserver {

public:

  TPixelParamObserver() {}

  virtual ~TPixelParamObserver() {}

  virtual void onChange(const TParamChange &) = 0;

};

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

class TPixelParamImp;

class DVAPI TPixelParam final : public TParamSet {

  PERSIST_DECLARATION(TPixelParam)

  TPixelParamImp *m_data;

public:

  TPixelParam(const TPixel32 &pix = TPixel32::Black);

  TPixelParam(const TPixelParam &);

  ~TPixelParam();

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

  void copy(TParam *src) override;

  TPixel32 getDefaultValue() const;

  TPixelD getValueD(double frame) const;

  TPixel32 getValue(double frame) const;

  TPixel32 getValue(double frame, bool linear, double colorSpaceGamma) const;

  TPixel64 getValue64(double frame) const;

  TPixel32 getPremultipliedValue(double frame) const;

  void setDefaultValue(const TPixel32 &pix);

  bool setValueD(double frame, const TPixelD &pix);

  bool setValue(double frame, const TPixel32 &pix);

  bool setValue64(double frame, const TPixel64 &pix);

  void enableMatte(bool on);

  bool isMatteEnabled() const;

  void loadData(TIStream &is) override;

  void saveData(TOStream &os) override;

  TDoubleParamP &getRed();

  TDoubleParamP &getGreen();

  TDoubleParamP &getBlue();

  TDoubleParamP &getMatte();

};

DEFINE_PARAM_SMARTPOINTER(TPixelParam, TPixel32)

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

class TRangeParamObserver {

public:

  TRangeParamObserver() {}

  virtual ~TRangeParamObserver() {}

  virtual void onChange(const TParamChange &) = 0;

};

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

#ifdef _WIN32

class TRangeParam;

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

#endif

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

class TRangeParamImp;

class TDoubleParamP;

class DVAPI TRangeParam final : public TParamSet {

  PERSIST_DECLARATION(TRangeParam)

  TRangeParamImp *m_data;

public:

  TRangeParam(const DoublePair &range = DoublePair(0, 0));

  TRangeParam(const TRangeParam &src);

  ~TRangeParam();

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

  void copy(TParam *src) override;

  DoublePair getDefaultValue() const;

  DoublePair getValue(double frame) const;

  bool setValue(double frame, const DoublePair &v);

  void setDefaultValue(const DoublePair &v);

  void loadData(TIStream &is) override;

  void saveData(TOStream &os) override;

  int getKeyframeCount() const;

  TDoubleParamP &getMin();

  TDoubleParamP &getMax();

};

DEFINE_PARAM_SMARTPOINTER(TRangeParam, DoublePair)

#endif