#include "toonzqt/paramfield.h"

#include "toonzqt/gutil.h"

#include "toonzqt/fxsettings.h"

#include "toonzqt/intfield.h"

#include "toonzqt/spectrumfield.h"

#include "toonzqt/colorfield.h"

#include "toonzqt/doublepairfield.h"

#include "toonzqt/tonecurvefield.h"

#include "toonzqt/checkbox.h"

#include "toonzqt/menubarcommand.h"

#include "tdoubleparam.h"

#include "tnotanimatableparam.h"

#include "tparamset.h"

#include "tw/stringtable.h"

#include <qstring></qstring>

#include <qhboxlayout></qhboxlayout>

#include <qlabel></qlabel>

#include <qpainter></qpainter>

#include <qcombobox></qcombobox>

#include <qfontcombobox></qfontcombobox>

#include <qkeyevent></qkeyevent>

using namespace DVGui;

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

/*! FxSettingsに共通のUndo

 */

class FxSettingsUndo : public TUndo {

protected:

  TFxHandle *m_fxHandle;

  QString m_name;

public:

  FxSettingsUndo(QString name, TFxHandle *fxHandle)

      : m_name(name), m_fxHandle(fxHandle) {}

  int getSize() const override { return sizeof(*this); }

  int getHistoryType() override { return HistoryType::Fx; }

};

class AnimatableFxSettingsUndo : public FxSettingsUndo {

protected:

  bool m_wasKeyframe;

  int m_frame;

public:

  AnimatableFxSettingsUndo(QString name, int frame, TFxHandle *fxHandle)

      : FxSettingsUndo(name, fxHandle), m_frame(frame) {}

  QString getHistoryString() override {

    QString str = QObject::tr("Modify Fx Param : %1").arg(m_name);

    if (m_wasKeyframe)

      str += QString("  Frame : %1").arg(QString::number(m_frame + 1));

    else

      str += QString("  (Default Value)");

    return str;

  }

};

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

/*! MeasuredDoubleParamField Undo

 */

class MeasuredDoubleParamFieldUndo final : public AnimatableFxSettingsUndo {

  TDoubleParamP m_param;

  double m_oldValue, m_newValue;

public:

  MeasuredDoubleParamFieldUndo(const TDoubleParamP param, QString name,

                               int frame, TFxHandle *fxHandle)

      : AnimatableFxSettingsUndo(name, frame, fxHandle), m_param(param) {

    m_oldValue    = param->getValue(frame);

    m_newValue    = m_oldValue;

    m_wasKeyframe = m_param->isKeyframe(frame);

  }

  void onAdd() override { m_newValue = m_param->getValue(m_frame); }

  void undo() const override {

    if (!m_wasKeyframe)

      m_param->setDefaultValue(m_oldValue);

    else

      m_param->setValue(m_frame, m_oldValue);

    if (m_fxHandle) {

      m_fxHandle->notifyFxChanged();

    }

  }

  void redo() const override {

    if (!m_wasKeyframe)

      m_param->setDefaultValue(m_newValue);

    else

      m_param->setValue(m_frame, m_newValue);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

};

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

/*! RangeParamField Undo

 */

class RangeParamFieldUndo final : public AnimatableFxSettingsUndo {

  TRangeParamP m_param;

  DoublePair m_oldValue, m_newValue;

public:

  RangeParamFieldUndo(const TRangeParamP param, QString name, int frame,

                      TFxHandle *fxHandle)

      : AnimatableFxSettingsUndo(name, frame, fxHandle), m_param(param) {

    m_oldValue    = param->getValue(frame);

    m_newValue    = m_oldValue;

    m_wasKeyframe = m_param->isKeyframe(frame);

  }

  void onAdd() override { m_newValue = m_param->getValue(m_frame); }

  void undo() const override {

    if (!m_wasKeyframe)

      m_param->setDefaultValue(m_oldValue);

    else

      m_param->setValue(m_frame, m_oldValue);

    if (m_fxHandle) {

      m_fxHandle->notifyFxChanged();

    }

  }

  void redo() const override {

    if (!m_wasKeyframe)

      m_param->setDefaultValue(m_newValue);

    else

      m_param->setValue(m_frame, m_newValue);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

};

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

/*! PixelParamField Undo

 */

class PixelParamFieldUndo final : public AnimatableFxSettingsUndo {

  TPixelParamP m_param;

  TPixel32 m_oldValue, m_newValue;

public:

  PixelParamFieldUndo(const TPixelParamP param, QString name, int frame,

                      TFxHandle *fxHandle)

      : AnimatableFxSettingsUndo(name, frame, fxHandle), m_param(param) {

    m_oldValue    = param->getValue(frame);

    m_newValue    = m_oldValue;

    m_wasKeyframe = m_param->isKeyframe(frame);

  }

  void onAdd() override { m_newValue = m_param->getValue(m_frame); }

  void undo() const override {

    if (!m_wasKeyframe)

      m_param->setDefaultValue(m_oldValue);

    else

      m_param->setValue(m_frame, m_oldValue);

    if (m_fxHandle) {

      m_fxHandle->notifyFxChanged();

    }

  }

  void redo() const override {

    if (!m_wasKeyframe)

      m_param->setDefaultValue(m_newValue);

    else

      m_param->setValue(m_frame, m_newValue);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

};

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

/*! PointParamField Undo

 */

class PointParamFieldUndo final : public AnimatableFxSettingsUndo {

  TPointParamP m_param;

  TPointD m_oldValue, m_newValue;

public:

  PointParamFieldUndo(const TPointParamP param, QString name, int frame,

                      TFxHandle *fxHandle)

      : AnimatableFxSettingsUndo(name, frame, fxHandle), m_param(param) {

    m_oldValue    = param->getValue(frame);

    m_newValue    = m_oldValue;

    m_wasKeyframe = m_param->isKeyframe(frame);

  }

  void onAdd() override { m_newValue = m_param->getValue(m_frame); }

  void undo() const override {

    if (!m_wasKeyframe)

      m_param->setDefaultValue(m_oldValue);

    else

      m_param->setValue(m_frame, m_oldValue);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  void redo() const override {

    if (!m_wasKeyframe)

      m_param->setDefaultValue(m_newValue);

    else

      m_param->setValue(m_frame, m_newValue);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

};

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

/*! EnumParamField Undo

 */

class EnumParamFieldUndo final : public FxSettingsUndo {

  TIntEnumParamP m_param;

  std::string m_oldString, m_newString;

public:

  EnumParamFieldUndo(const TIntEnumParamP param, std::string oldString,

                     std::string newString, QString name, TFxHandle *fxHandle)

      : FxSettingsUndo(name, fxHandle)

      , m_param(param)

      , m_oldString(oldString)

      , m_newString(newString) {}

  void undo() const override {

    m_param->setValue(m_oldString);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  void redo() const override {

    m_param->setValue(m_newString);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  QString getHistoryString() override {

    QString str = QObject::tr("Modify Fx Param : %1 : %2 -> %3")

                      .arg(m_name)

                      .arg(QString::fromStdString(m_oldString))

                      .arg(QString::fromStdString(m_newString));

    return str;

  }

};

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

/*! IntParamFieldのUndo

 */

class IntParamFieldUndo final : public FxSettingsUndo {

  TIntParamP m_param;

  int m_oldValue, m_newValue;

public:

  IntParamFieldUndo(const TIntParamP param, QString name, TFxHandle *fxHandle)

      : FxSettingsUndo(name, fxHandle), m_param(param) {

    m_oldValue = param->getValue();

    m_newValue = m_oldValue;

  }

  void onAdd() override { m_newValue = m_param->getValue(); }

  void undo() const override {

    m_param->setValue(m_oldValue);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  void redo() const override {

    m_param->setValue(m_newValue);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  QString getHistoryString() override {

    QString str = QObject::tr("Modify Fx Param : %1 : %2 -> %3")

                      .arg(m_name)

                      .arg(QString::number(m_oldValue))

                      .arg(QString::number(m_newValue));

    return str;

  }

};

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

/*! BoolParamFieldのUndo

 */

class BoolParamFieldUndo final : public FxSettingsUndo {

  TBoolParamP m_param;

  bool m_newState;

public:

  BoolParamFieldUndo(const TBoolParamP param, QString name, TFxHandle *fxHandle)

      : FxSettingsUndo(name, fxHandle), m_param(param) {

    m_newState = param->getValue();

  }

  void undo() const override {

    m_param->setValue(!m_newState);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  void redo() const override {

    m_param->setValue(m_newState);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  QString getHistoryString() override {

    QString str = QObject::tr("Modify Fx Param : ");

    if (m_newState)

      str += QObject::tr("ON : %1").arg(m_name);

    else

      str += QObject::tr("OFF : %1").arg(m_name);

    return str;

  }

};

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

/*! SpectrumParamFieldのUndo

 */

class SpectrumParamFieldUndo final : public AnimatableFxSettingsUndo {

  TSpectrumParamP m_param;

  TSpectrum m_oldSpectrum, m_newSpectrum;

public:

  SpectrumParamFieldUndo(const TSpectrumParamP param, QString name, int frame,

                         TFxHandle *fxHandle)

      : AnimatableFxSettingsUndo(name, frame, fxHandle), m_param(param) {

    m_oldSpectrum = param->getValue(frame);

    m_newSpectrum = m_oldSpectrum;

    m_wasKeyframe = m_param->isKeyframe(frame);

  }

  void onAdd() override { m_newSpectrum = m_param->getValue(m_frame); }

  void undo() const override {

    if (!m_wasKeyframe)

      m_param->setDefaultValue(m_oldSpectrum);

    else

      m_param->setValue(m_frame, m_oldSpectrum);

    if (m_fxHandle) {

      m_fxHandle->notifyFxChanged();

    }

  }

  void redo() const override {

    if (!m_wasKeyframe)

      m_param->setDefaultValue(m_newSpectrum);

    else

      m_param->setValue(m_frame, m_newSpectrum);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

};

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

/*! SpectrumParamField Undo

        ※

   SpectrumParamFieldは、表示更新時にactualParamとcurrentParamのKeyの数が

        一致していなくてはならないので、２つ同時に変更する必要が有る。

*/

class SpectrumParamFieldAddRemoveKeyUndo final : public FxSettingsUndo {

  TSpectrumParamP m_actualParam;

  TSpectrumParamP m_currentParam;

  TSpectrum::ColorKey m_key;

  int m_index;

  bool m_isAddUndo;

public:

  SpectrumParamFieldAddRemoveKeyUndo(const TSpectrumParamP actualParam,

                                     const TSpectrumParamP currentParam,

                                     TSpectrum::ColorKey key, int index,

                                     bool isAddUndo, QString name,

                                     TFxHandle *fxHandle)

      : FxSettingsUndo(name, fxHandle)

      , m_actualParam(actualParam)

      , m_currentParam(currentParam)

      , m_key(key)

      , m_index(index)

      , m_isAddUndo(isAddUndo) {}

  void removeKeys() const {

    m_actualParam->removeKey(m_index);

    m_currentParam->removeKey(m_index);

  }

  void addKeys() const {

    m_actualParam->insertKey(m_index, m_key.first, m_key.second);

    m_currentParam->insertKey(m_index, m_key.first, m_key.second);

  }

  void undo() const override {

    if (m_isAddUndo)

      removeKeys();

    else

      addKeys();

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  void redo() const override {

    if (m_isAddUndo)

      addKeys();

    else

      removeKeys();

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  QString getHistoryString() override {

    QString str =

        QObject::tr("Modify Fx Param : %1 : %2 Key")

            .arg(m_name)

            .arg((m_isAddUndo) ? QObject::tr("Add") : QObject::tr("Remove"));

    return str;

  }

};

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

/*! StringParamField Undo

 */

class StringParamFieldUndo final : public FxSettingsUndo {

  TStringParamP m_param;

  std::wstring m_oldValue, m_newValue;

public:

  StringParamFieldUndo(const TStringParamP param, QString name,

                       TFxHandle *fxHandle)

      : FxSettingsUndo(name, fxHandle), m_param(param) {

    m_oldValue = param->getValue();

    m_newValue = m_oldValue;

  }

  void onAdd() override { m_newValue = m_param->getValue(); }

  void undo() const override {

    m_param->setValue(m_oldValue);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  void redo() const override {

    m_param->setValue(m_newValue);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  QString getHistoryString() override {

    QString str = QObject::tr("Modify Fx Param : %1 : %2 -> %3")

                      .arg(m_name)

                      .arg(QString::fromStdWString(m_oldValue))

                      .arg(QString::fromStdWString(m_newValue));

    return str;

  }

};

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

/*! FontParamFieldUndo

 */

class FontParamFieldUndo final : public FxSettingsUndo {

  TFontParamP m_param;

  std::wstring m_oldValue, m_newValue;

public:

  FontParamFieldUndo(const TFontParamP param, QString name, TFxHandle *fxHandle)

      : FxSettingsUndo(name, fxHandle), m_param(param) {

    m_oldValue = param->getValue();

    m_newValue = m_oldValue;

  }

  void onAdd() override { m_newValue = m_param->getValue(); }

  void undo() const override {

    m_param->setValue(m_oldValue);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  void redo() const override {

    m_param->setValue(m_newValue);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  QString getHistoryString() override {

    QString str = QObject::tr("Modify Fx Param : %1").arg(m_name);

    return str;

  }

};

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

/*! ToneCurveParamField Undo

 */

class ToneCurveParamFieldUndo final : public AnimatableFxSettingsUndo {

  TToneCurveParamP m_param;

  QList<tpointd> m_oldPoints, m_newPoints;</tpointd>

public:

  ToneCurveParamFieldUndo(const TToneCurveParamP param, QString name, int frame,

                          TFxHandle *fxHandle)

      : AnimatableFxSettingsUndo(name, frame, fxHandle), m_param(param) {

    m_oldPoints   = param->getValue(frame);

    m_newPoints   = m_oldPoints;

    m_wasKeyframe = m_param->isKeyframe(frame);

  }

  void onAdd() override { m_newPoints = m_param->getValue(m_frame); }

  void undo() const override {

    if (!m_wasKeyframe)

      m_param->setDefaultValue(m_oldPoints);

    else

      m_param->setValue(m_frame, m_oldPoints);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  void redo() const override {

    if (!m_wasKeyframe)

      m_param->setDefaultValue(m_newPoints);

    else

      m_param->setValue(m_frame, m_newPoints);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

};

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

/*! ToneCurveParamField Undo

        ※

   ToneCurveParamFieldは、表示更新時にactualParamとcurrentParamのPointの数が

        一致していなくてはならないので、２つ同時に変更する必要が有る。

*/

class ToneCurveParamFieldAddRemovePointUndo final : public FxSettingsUndo {

  TToneCurveParamP m_actualParam;

  TToneCurveParamP m_currentParam;

  QList<tpointd> m_value;</tpointd>

  int m_index;

  bool m_isAddUndo;

public:

  ToneCurveParamFieldAddRemovePointUndo(const TToneCurveParamP actualParam,

                                        const TToneCurveParamP currentParam,

                                        QList<tpointd> value, int index,</tpointd>

                                        bool isAddUndo, QString name,

                                        TFxHandle *fxHandle)

      : FxSettingsUndo(name, fxHandle)

      , m_actualParam(actualParam)

      , m_currentParam(currentParam)

      , m_value(value)

      , m_index(index)

      , m_isAddUndo(isAddUndo) {}

  void removePoints() const {

    m_actualParam->removeValue(0, m_index);

    m_currentParam->removeValue(0, m_index);

  }

  void addPoints() const {

    m_actualParam->addValue(0, m_value, m_index);

    m_currentParam->addValue(0, m_value, m_index);

  }

  void undo() const override {

    if (m_isAddUndo)

      removePoints();

    else

      addPoints();

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  void redo() const override {

    if (m_isAddUndo)

      addPoints();

    else

      removePoints();

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  QString getHistoryString() override {

    QString str =

        QObject::tr("Modify Fx Param : %1 : %2 Point")

            .arg(m_name)

            .arg((m_isAddUndo) ? QObject::tr("Add") : QObject::tr("Remove"));

    return str;

  }

};

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

/*! ToneCurveParamField Undo (Linearのトグル)

 */

class ToneCurveParamFieldToggleLinearUndo final : public FxSettingsUndo {

  TToneCurveParamP m_actualParam;

  TToneCurveParamP m_currentParam;

  bool m_newState;

public:

  ToneCurveParamFieldToggleLinearUndo(const TToneCurveParamP actualParam,

                                      const TToneCurveParamP currentParam,

                                      QString name, TFxHandle *fxHandle)

      : FxSettingsUndo(name, fxHandle)

      , m_actualParam(actualParam)

      , m_currentParam(currentParam) {

    m_newState = actualParam->isLinear();

  }

  void undo() const override {

    m_actualParam->setIsLinear(!m_newState);

    m_currentParam->setIsLinear(!m_newState);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  void redo() const override {

    m_actualParam->setIsLinear(m_newState);

    m_currentParam->setIsLinear(m_newState);

    if (m_fxHandle) m_fxHandle->notifyFxChanged();

  }

  QString getHistoryString() override {

    QString str = QObject::tr("Modify Fx Param : ");

    if (m_newState)

      str += QObject::tr("%1 : Linear ON").arg(m_name);

    else

      str += QObject::tr("%1 : Linear OFF").arg(m_name);

    return str;

  }

};

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

// ParamField

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

ParamField::ParamField(QWidget *parent, QString paramName, const TParamP ¶m,

                       bool addEmptyLabel)

    : QWidget(parent)

    , m_paramName(paramName)

    , m_interfaceName(param->hasUILabel()

                          ? QString::fromStdString(param->getUILabel())

                          : paramName)

    , m_description(QString::fromStdString(param->getDescription())) {

  QString str;

  m_layout = new QHBoxLayout(this);

  m_layout->setMargin(0);

  m_layout->setSpacing(5);

}

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

ParamField::~ParamField() {}

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

TFxHandle *ParamField::m_fxHandleStat = 0;

void ParamField::setFxHandle(TFxHandle *fxHandle) {

  ParamField::m_fxHandleStat = fxHandle;

}

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

// ParamFieldKeyToggle

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

ParamFieldKeyToggle::ParamFieldKeyToggle(QWidget *parent, std::string name)

    : QWidget(parent), m_status(NOT_ANIMATED), m_highlighted(false) {

  setFixedSize(20, 20);

}

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

void ParamFieldKeyToggle::setStatus(Status status) {

  m_status = status;

  update();

}

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

void ParamFieldKeyToggle::setStatus(bool hasKeyframes, bool isKeyframe,

                                    bool hasBeenChanged) {

  if (!hasKeyframes)

    setStatus(NOT_ANIMATED);

  else if (hasBeenChanged)

    setStatus(MODIFIED);

  else if (isKeyframe)

    setStatus(KEYFRAME);

  else

    setStatus(NOT_KEYFRAME);

}

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

ParamFieldKeyToggle::Status ParamFieldKeyToggle::getStatus() const {

  return m_status;

}

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

void ParamFieldKeyToggle::paintEvent(QPaintEvent *e) {

  QIcon icon;

  const int iconSize = 20;

  const int radius   = 2;

  // Create rounded rect for key button states

  QPainter p(this);

  p.setRenderHint(p.Antialiasing, true);

  QPainterPath path;

  path.addRoundedRect(

      QRectF(0.5, 0.5, 19, 19), radius,

      radius);  // Nudge rect by half pixel so QPen looks pixel perfect

  QPen pen = QColor(0, 0, 0, 0);

  p.setPen(pen);

  switch (m_status) {

  case NOT_ANIMATED:

    pen = QColor(getKeyBorderOffColor());

    p.setPen(pen);

    p.fillPath(path, getKeyOffColor());

    m_pixmap = QPixmap(createQIcon("key_off").pixmap(

        iconSize, iconSize, QIcon::Normal, QIcon::Off));

    icon.addPixmap(m_pixmap);

    icon.paint(&p, QRect(0, 0, iconSize, iconSize));

    break;

  case KEYFRAME:

    pen = QColor(getKeyBorderOnColor());

    p.setPen(pen);

    p.fillPath(path, getKeyOnColor());

    m_pixmap =

        QPixmap(createQIcon("key_on", true)

                    .pixmap(iconSize, iconSize, QIcon::Normal, QIcon::Off));

    icon.addPixmap(m_pixmap);

    icon.paint(&p, QRect(0, 0, iconSize, iconSize));

    break;

  case MODIFIED:

    pen = QColor(getKeyBorderModifiedColor());

    p.setPen(pen);

    p.fillPath(path, getKeyModifiedColor());

    m_pixmap =

        QPixmap(createQIcon("key_modified", true)

                    .pixmap(iconSize, iconSize, QIcon::Normal, QIcon::Off));

    icon.addPixmap(m_pixmap);

    icon.paint(&p, QRect(0, 0, iconSize, iconSize));

    break;

  default:

    pen = QColor(getKeyBorderInbetweenColor());

    p.setPen(pen);

    p.fillPath(path, getKeyInbetweenColor());

    m_pixmap =

        QPixmap(createQIcon("key_on", true)

                    .pixmap(iconSize, iconSize, QIcon::Normal, QIcon::Off));

    icon.addPixmap(m_pixmap);

    icon.paint(&p, QRect(0, 0, iconSize, iconSize));

    break;

  }

  p.drawPath(path);

  if (m_highlighted) {

    pen = QColor(getKeyBorderHighlightColor());

    p.setPen(pen);

    p.fillPath(path, getKeyHighlightColor());

    p.drawPath(path);

  }

  p.end();

}

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

void ParamFieldKeyToggle::mousePressEvent(QMouseEvent *e) { emit keyToggled(); }

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

void ParamFieldKeyToggle::enterEvent(QEvent *) {

  m_highlighted = true;

  update();

}

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

void ParamFieldKeyToggle::leaveEvent(QEvent *) {

  m_highlighted = false;

  update();

}

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

// MeasuredDoubleParamField

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

MeasuredDoubleParamField::MeasuredDoubleParamField(QWidget *parent,

                                                   QString name,

                                                   const TDoubleParamP ¶m)

    : AnimatedParamField<double, tdoubleparamp="">(parent, name, param) {</double,>

  QString str;

  m_paramName = str.fromStdString(param->getName());

  m_measuredDoubleField = new MeasuredDoubleField(this, false);

  m_measuredDoubleField->setSizePolicy(QSizePolicy::Expanding,

                                       QSizePolicy::Minimum);

  m_measuredDoubleField->setMeasure(param->getMeasureName());

  m_measuredDoubleField->setValue(param->getValue(m_frame));

  m_measuredDoubleField->setDecimals(3);

  double min = 0, max = 100, step = 1;

  param->getValueRange(min, max, step);

  assert(min < max);

  m_measuredDoubleField->setRange(min, max);

  //----layout

  m_layout->addWidget(m_keyToggle);

  m_layout->addWidget(m_measuredDoubleField);

  setLayout(m_layout);

  //----signal-slot connection

  bool ret = connect(m_measuredDoubleField, SIGNAL(valueChanged(bool)),

                     SLOT(onChange(bool)));

  ret = ret && connect(m_keyToggle, SIGNAL(keyToggled()), SLOT(onKeyToggled()));

  assert(ret);

}

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

void MeasuredDoubleParamField::updateField(double value) {

  m_measuredDoubleField->setValue(value);

}

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

void MeasuredDoubleParamField::onChange(bool dragging) {

  if (dragging) return;

  TDoubleParamP doubleParam = m_actualParam;

  TUndo *undo = 0;

  /*-- Undoを登録する条件：

          値が変更されていて、かつ

          キーフレーム上か、または、まだキーフレームが無い

          （すなわち、実際にシーンの情報を変えることになる）場合

  --*/

  if (doubleParam &&

      doubleParam->getValue(m_frame) != m_measuredDoubleField->getValue() &&

      (m_actualParam->isKeyframe(m_frame) ||

       !m_actualParam.getPointer()->hasKeyframes()))

    undo = new MeasuredDoubleParamFieldUndo(

        doubleParam, m_interfaceName, m_frame, ParamField::m_fxHandleStat);

  setValue(m_measuredDoubleField->getValue());

  if (undo) TUndoManager::manager()->add(undo);

}

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

void MeasuredDoubleParamField::onKeyToggled() { onKeyToggle(); }

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

void MeasuredDoubleParamField::setPrecision(int precision) {

  double min, max;

  m_measuredDoubleField->getRange(min, max);

  m_measuredDoubleField->setDecimals(precision);

  // update slider

  m_measuredDoubleField->setRange(min, max);

}

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

// MeasuredRangeParamField

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

MeasuredRangeParamField::MeasuredRangeParamField(QWidget *parent, QString name,

                                                 const TRangeParamP ¶m)

    : AnimatedParamField<doublepair, trangeparamp="">(parent, name, param) {</doublepair,>

  QString str;

  m_paramName = str.fromStdString(param->getName());

  m_valueField = new MeasuredDoublePairField(this);

  m_valueField->setLabelsEnabled(false);

  m_valueField->setMeasure(param->getMin()->getMeasureName());

  m_valueField->setSizePolicy(QSizePolicy::Expanding, QSizePolicy::Minimum);

  double a, b, c, min, max;

  param->getMin()->getValueRange(a, b, c);

  min = a;

  param->getMax()->getValueRange(a, b, c);

  max = b;