#include "tparamset.h"

#include "tdoubleparam.h"

#include "texception.h"

#include "tstream.h"

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

class TRangeParamImp {

public:

  TRangeParamImp(const DoublePair &v)

      : m_min(new TDoubleParam(v.first)), m_max(new TDoubleParam(v.second)) {}

  TRangeParamImp(const TRangeParamImp &src)

      : m_min(src.m_min->clone()), m_max(src.m_max->clone()) {}

  ~TRangeParamImp() {}

  TDoubleParamP m_min, m_max;

};

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

PERSIST_IDENTIFIER(TRangeParam, "rangeParam")

TRangeParam::TRangeParam(const DoublePair &v) : m_data(new TRangeParamImp(v)) {

  addParam(m_data->m_min, "min");

  addParam(m_data->m_max, "max");

}

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

TRangeParam::TRangeParam(const TRangeParam &src)

    : TParamSet(src.getName()), m_data(new TRangeParamImp(*src.m_data)) {

  addParam(m_data->m_min, "min");

  addParam(m_data->m_max, "max");

}

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

TRangeParam::~TRangeParam() { delete m_data; }

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

void TRangeParam::copy(TParam *src) {

  TRangeParam *p = dynamic_cast<trangeparam *="">(src);</trangeparam>

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

  setName(src->getName());

  m_data->m_min->copy(p->m_data->m_min.getPointer());

  m_data->m_max->copy(p->m_data->m_max.getPointer());

}

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

DoublePair TRangeParam::getDefaultValue() const {

  return DoublePair(m_data->m_min->getDefaultValue(),

                    m_data->m_max->getDefaultValue());

}

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

DoublePair TRangeParam::getValue(double frame) const {

  return DoublePair(m_data->m_min->getValue(frame),

                    m_data->m_max->getValue(frame));

}

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

bool TRangeParam::setValue(double frame, const DoublePair &v) {

  beginParameterChange();

  m_data->m_min->setValue(frame, v.first);

  m_data->m_max->setValue(frame, v.second);

  endParameterChange();

  return true;

}

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

void TRangeParam::setDefaultValue(const DoublePair &v) {

  m_data->m_min->setDefaultValue(v.first);

  m_data->m_max->setDefaultValue(v.second);

}

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

void TRangeParam::loadData(TIStream &is) {

  std::string childName;

  while (is.openChild(childName)) {

    if (childName == "min")

      m_data->m_min->loadData(is);

    else if (childName == "max")

      m_data->m_max->loadData(is);

    else

      throw TException("unknown tag");

    is.closeChild();

  }

}

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

void TRangeParam::saveData(TOStream &os) {

  os.openChild("min");

  m_data->m_min->saveData(os);

  os.closeChild();

  os.openChild("max");

  m_data->m_max->saveData(os);

  os.closeChild();

}

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

TDoubleParamP &TRangeParam::getMin() { return m_data->m_min; }

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

TDoubleParamP &TRangeParam::getMax() { return m_data->m_max; }

#ifdef BUTTA

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

int TRangeParam::getNextKeyframe(double frame) const {

  int f_min = m_data->m_min->getNextKeyframe(frame);

  int f_max = m_data->m_max->getNextKeyframe(frame);

  if (f_min <= f_max && f_min != -1)

    return f_min;

  else {

    if (f_max != -1)

      return f_max;

    else

      return -1;

  }

}

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

int TRangeParam::getPrevKeyframe(double frame) const {

  int f_min = m_data->m_min->getPrevKeyframe(frame);

  int f_max = m_data->m_max->getPrevKeyframe(frame);

  if (f_min >= f_max)

    return f_min;

  else

    return f_max;

}

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

void TRangeParam::deleteKeyframe(double frame, bool undoing) {

  m_data->m_min->deleteKeyframe(frame, undoing);

  m_data->m_max->deleteKeyframe(frame, undoing);

}

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

bool TRangeParam::isKeyframe(double frame) const {

  bool min, max;

  min = m_data->m_min->isKeyframe(frame);

  max = m_data->m_max->isKeyframe(frame);

  return (min || max);

}

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

#endif