// TnzCore includes

#include "tpalette.h"

#include "tcolorstyles.h"

#include "tundo.h"

// TnzBase includes

#include "tproperty.h"

// TnzLib includes

#include "toonz/palettecontroller.h"

#include "toonz/tpalettehandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/stage2.h"

#include "toonz/stageobjectutil.h"

#include "toonz/doubleparamcmd.h"

// TnzQt includes

#include "toonzqt/gutil.h"

// TnzTools includes

#include "tools/tool.h"

#include "rasterselectiontool.h"

#include "vectorselectiontool.h"

// to enable the increase/decrease shortcuts while hiding the tool option

#include "tools/toolhandle.h"

// to enable shortcuts only when the viewer is focused

#include "tools/tooloptions.h"

// Qt includes

#include <qpainter></qpainter>

#include <qvboxlayout></qvboxlayout>

#include <qmouseevent></qmouseevent>

#include <qaction></qaction>

#include <qlabel></qlabel>

#include <qmainwindow></qmainwindow>

#include <qbuttongroup></qbuttongroup>

#include <qmenu></qmenu>

#include "tooloptionscontrols.h"

using namespace DVGui;

//***********************************************************************************

//    ToolOptionControl  implementation

//***********************************************************************************

ToolOptionControl::ToolOptionControl(TTool *tool, std::string propertyName,

                                     ToolHandle *toolHandle)

    : m_tool(tool), m_propertyName(propertyName), m_toolHandle(toolHandle) {}

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

void ToolOptionControl::notifyTool() {

  m_tool->onPropertyChanged(m_propertyName);

}

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

/*! return true if the control is belonging to the visible combo viewer. very

 * dirty implementation.

*/

bool ToolOptionControl::isInVisibleViewer(QWidget *widget) {

  if (!widget) return false;

  if (widget->isVisible()) return true;

  ToolOptionsBox *parentTOB =

      dynamic_cast<tooloptionsbox *="">(widget->parentWidget());</tooloptionsbox>

  if (!parentTOB) return false;

  ToolOptions *grandParentTO =

      dynamic_cast<tooloptions *="">(parentTOB->parentWidget());</tooloptions>

  if (!grandParentTO) return false;

  // There must be a QFrame between a ComboViewerPanel and a ToolOptions

  QFrame *greatGrandParentFrame =

      dynamic_cast<qframe *="">(grandParentTO->parentWidget());</qframe>

  if (!greatGrandParentFrame) return false;

  return greatGrandParentFrame->isVisible();

}

//***********************************************************************************

//    ToolOptionControl derivative  implementations

//***********************************************************************************

ToolOptionCheckbox::ToolOptionCheckbox(TTool *tool, TBoolProperty *property,

                                       ToolHandle *toolHandle, QWidget *parent)

    : CheckBox(parent)

    , ToolOptionControl(tool, property->getName(), toolHandle)

    , m_property(property) {

  setText(property->getQStringName());

  m_property->addListener(this);

  updateStatus();

  // synchronize the state with the same widgets in other tool option bars

  if (toolHandle)

    connect(this, SIGNAL(clicked(bool)), toolHandle, SIGNAL(toolChanged()));

}

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

void ToolOptionCheckbox::updateStatus() {

  bool check = m_property->getValue();

  if (isChecked() == check) return;

  setCheckState(check ? Qt::Checked : Qt::Unchecked);

}

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

void ToolOptionCheckbox::nextCheckState() {

  QAbstractButton::nextCheckState();

  m_property->setValue(checkState() == Qt::Checked);

  notifyTool();

}

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

void ToolOptionCheckbox::doClick() {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  click();

}

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

ToolOptionSlider::ToolOptionSlider(TTool *tool, TDoubleProperty *property,

                                   ToolHandle *toolHandle)

    : DoubleField()

    , ToolOptionControl(tool, property->getName(), toolHandle)

    , m_property(property) {

  m_property->addListener(this);

  TDoubleProperty::Range range = property->getRange();

  setRange(range.first, range.second);

  updateStatus();

  connect(this, SIGNAL(valueChanged(bool)), SLOT(onValueChanged(bool)));

  // synchronize the state with the same widgets in other tool option bars

  if (toolHandle)

    connect(this, SIGNAL(valueEditedByHand()), toolHandle,

            SIGNAL(toolChanged()));

}

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

void ToolOptionSlider::updateStatus() {

  double v = m_property->getValue();

  if (getValue() == v) return;

  setValue(v);

}

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

void ToolOptionSlider::onValueChanged(bool isDragging) {

  m_property->setValue(getValue());

  notifyTool();

}

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

void ToolOptionSlider::increase() {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  double value = getValue();

  double minValue, maxValue;

  getRange(minValue, maxValue);

  value += 1;

  if (value > maxValue) value = maxValue;

  setValue(value);

  m_property->setValue(getValue());

  notifyTool();

  // update the interface

  repaint();

}

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

void ToolOptionSlider::decrease() {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  double value = getValue();

  double minValue, maxValue;

  getRange(minValue, maxValue);

  value -= 1;

  if (value < minValue) value = minValue;

  setValue(value);

  m_property->setValue(getValue());

  notifyTool();

  // update the interface

  repaint();

}

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

ToolOptionPairSlider::ToolOptionPairSlider(TTool *tool,

                                           TDoublePairProperty *property,

                                           const QString &leftName,

                                           const QString &rightName,

                                           ToolHandle *toolHandle)

    : DoublePairField(0, property->isMaxRangeLimited())

    , ToolOptionControl(tool, property->getName(), toolHandle)

    , m_property(property) {

  setLeftText(leftName);

  setRightText(rightName);

  m_property->addListener(this);

  TDoublePairProperty::Value value = property->getValue();

  TDoublePairProperty::Range range = property->getRange();

  setRange(range.first, range.second);

  updateStatus();

  connect(this, SIGNAL(valuesChanged(bool)), SLOT(onValuesChanged(bool)));

}

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

void ToolOptionPairSlider::updateStatus() {

  TDoublePairProperty::Value value = m_property->getValue();

  setValues(value);

}

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

void ToolOptionPairSlider::onValuesChanged(bool isDragging) {

  m_property->setValue(getValues());

  notifyTool();

  // synchronize the state with the same widgets in other tool option bars

  if (m_toolHandle) m_toolHandle->notifyToolChanged();

}

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

void ToolOptionPairSlider::increaseMaxValue() {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  std::pair<double, double=""> values = getValues();</double,>

  double minValue, maxValue;

  getRange(minValue, maxValue);

  values.second += 1;

  if (values.second > maxValue) values.second = maxValue;

  setValues(values);

  m_property->setValue(getValues());

  notifyTool();

  // update the interface

  repaint();

}

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

void ToolOptionPairSlider::decreaseMaxValue() {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  std::pair<double, double=""> values = getValues();</double,>

  values.second -= 1;

  if (values.second < values.first) values.second = values.first;

  setValues(values);

  m_property->setValue(getValues());

  notifyTool();

  // update the interface

  repaint();

}

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

void ToolOptionPairSlider::increaseMinValue() {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  std::pair<double, double=""> values = getValues();</double,>

  values.first += 1;

  if (values.first > values.second) values.first = values.second;

  setValues(values);

  m_property->setValue(getValues());

  notifyTool();

  // update the interface

  repaint();

}

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

void ToolOptionPairSlider::decreaseMinValue() {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  std::pair<double, double=""> values = getValues();</double,>

  double minValue, maxValue;

  getRange(minValue, maxValue);

  values.first -= 1;

  if (values.first < minValue) values.first = minValue;

  setValues(values);

  m_property->setValue(getValues());

  notifyTool();

  // update the interface

  repaint();

}

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

ToolOptionIntPairSlider::ToolOptionIntPairSlider(TTool *tool,

                                                 TIntPairProperty *property,

                                                 const QString &leftName,

                                                 const QString &rightName,

                                                 ToolHandle *toolHandle)

    : IntPairField(0, property->isMaxRangeLimited())

    , ToolOptionControl(tool, property->getName(), toolHandle)

    , m_property(property) {

  setLeftText(leftName);

  setRightText(rightName);

  m_property->addListener(this);

  TIntPairProperty::Value value = property->getValue();

  TIntPairProperty::Range range = property->getRange();

  setRange(range.first, range.second);

  updateStatus();

  connect(this, SIGNAL(valuesChanged(bool)), SLOT(onValuesChanged(bool)));

}

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

void ToolOptionIntPairSlider::updateStatus() {

  TIntPairProperty::Value value = m_property->getValue();

  setValues(value);

}

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

void ToolOptionIntPairSlider::onValuesChanged(bool isDragging) {

  m_property->setValue(getValues());

  notifyTool();

  // synchronize the state with the same widgets in other tool option bars

  if (m_toolHandle) m_toolHandle->notifyToolChanged();

}

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

void ToolOptionIntPairSlider::increaseMaxValue() {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  std::pair<int, int=""> values = getValues();</int,>

  int minValue, maxValue;

  getRange(minValue, maxValue);

  values.second += 1;

  // a "cross-like shape" of the brush size = 3 is hard to use. so skip it

  if (values.second == 3 && m_tool->isPencilModeActive()) values.second += 1;

  if (values.second > maxValue) values.second = maxValue;

  setValues(values);

  m_property->setValue(getValues());

  notifyTool();

  // update the interface

  repaint();

}

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

void ToolOptionIntPairSlider::decreaseMaxValue() {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  std::pair<int, int=""> values = getValues();</int,>

  values.second -= 1;

  // a "cross-like shape" of the brush size = 3 is hard to use. so skip it

  if (values.second == 3 && m_tool->isPencilModeActive()) values.second -= 1;

  if (values.second < values.first) values.second = values.first;

  setValues(values);

  m_property->setValue(getValues());

  notifyTool();

  // update the interface

  repaint();

}

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

void ToolOptionIntPairSlider::increaseMinValue() {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  std::pair<int, int=""> values = getValues();</int,>

  values.first += 1;

  if (values.first > values.second) values.first = values.second;

  setValues(values);

  m_property->setValue(getValues());

  notifyTool();

  // update the interface

  repaint();

}

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

void ToolOptionIntPairSlider::decreaseMinValue() {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  std::pair<int, int=""> values = getValues();</int,>

  int minValue, maxValue;

  getRange(minValue, maxValue);

  values.first -= 1;

  if (values.first < minValue) values.first = minValue;

  setValues(values);

  m_property->setValue(getValues());

  notifyTool();

  // update the interface

  repaint();

}

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

ToolOptionIntSlider::ToolOptionIntSlider(TTool *tool, TIntProperty *property,

                                         ToolHandle *toolHandle)

    : IntField(0, property->isMaxRangeLimited())

    , ToolOptionControl(tool, property->getName(), toolHandle)

    , m_property(property) {

  m_property->addListener(this);

  TIntProperty::Range range = property->getRange();

  setRange(range.first, range.second);

  updateStatus();

  connect(this, SIGNAL(valueChanged(bool)), SLOT(onValueChanged(bool)));

  // synchronize the state with the same widgets in other tool option bars

  if (toolHandle)

    connect(this, SIGNAL(valueEditedByHand()), toolHandle,

            SIGNAL(toolChanged()));

}

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

void ToolOptionIntSlider::updateStatus() {

  int v = m_property->getValue();

  if (getValue() == v) return;

  setValue(v);

}

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

void ToolOptionIntSlider::increase() {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  int value = getValue();

  int minValue, maxValue;

  getRange(minValue, maxValue);

  value += 1;

  // a "cross-like shape" of the brush size = 3 is hard to use. so skip it

  if (value == 3 && m_tool->isPencilModeActive()) value += 1;

  if (value > maxValue) value = maxValue;

  setValue(value);

  m_property->setValue(getValue());

  notifyTool();

  // update the interface

  repaint();

}

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

void ToolOptionIntSlider::decrease() {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  int value = getValue();

  int minValue, maxValue;

  getRange(minValue, maxValue);

  value -= 1;

  // a "cross-like shape" of the brush size = 3 is hard to use. so skip it

  if (value == 3 && m_tool->isPencilModeActive()) value -= 1;

  if (value < minValue) value = minValue;

  setValue(value);

  m_property->setValue(getValue());

  notifyTool();

  // update the interface

  repaint();

}

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

void ToolOptionIntSlider::onValueChanged(bool isDragging) {

  m_property->setValue(getValue());

  notifyTool();

}

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

ToolOptionCombo::ToolOptionCombo(TTool *tool, TEnumProperty *property,

                                 ToolHandle *toolHandle)

    : QComboBox()

    , ToolOptionControl(tool, property->getName(), toolHandle)

    , m_property(property) {

  setMinimumWidth(65);

  m_property->addListener(this);

  loadEntries();

  setSizeAdjustPolicy(QComboBox::AdjustToContents);

  connect(this, SIGNAL(activated(int)), this, SLOT(onActivated(int)));

  // synchronize the state with the same widgets in other tool option bars

  if (toolHandle)

    connect(this, SIGNAL(activated(int)), toolHandle, SIGNAL(toolChanged()));

}

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

void ToolOptionCombo::loadEntries() {

  TEnumProperty::Range range = m_property->getRange();

  TEnumProperty::Range::iterator it;

  clear();

  for (it = range.begin(); it != range.end(); ++it)

    addItem(QString::fromStdWString(*it));

  updateStatus();

}

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

void ToolOptionCombo::updateStatus() {

  QString value = QString::fromStdWString(m_property->getValue());

  int index     = findText(value);

  if (index >= 0 && index != currentIndex()) setCurrentIndex(index);

}

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

void ToolOptionCombo::onActivated(int index) {

  const TEnumProperty::Range &range = m_property->getRange();

  if (index < 0 || index >= (int)range.size()) return;

  std::wstring item = range[index];

  m_property->setValue(item);

  notifyTool();

}

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

void ToolOptionCombo::doShowPopup() {

  if (isVisible()) showPopup();

}

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

void ToolOptionCombo::doOnActivated(int index) {

  if (m_toolHandle && m_toolHandle->getTool() != m_tool) return;

  // active only if the belonging combo-viewer is visible

  if (!isInVisibleViewer(this)) return;

  // Just move the index if the first item is not "Normal"

  if (itemText(0) != "Normal") {

    onActivated(index);

    setCurrentIndex(index);

    // for updating the cursor

    m_toolHandle->notifyToolChanged();

    return;

  }

  // If the first item of this combo box is "Normal", enable shortcut key toggle

  // can "back and forth" behavior.

  if (currentIndex() == index) {

    // estimating that the "Normal" option is located at the index 0

    onActivated(0);

    setCurrentIndex(0);

  } else {

    onActivated(index);

    setCurrentIndex(index);

  }

  // for updating a cursor without any effect to the tool options

  m_toolHandle->notifyToolCursorTypeChanged();

}

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

ToolOptionPopupButton::ToolOptionPopupButton(TTool *tool,

                                             TEnumProperty *property)

    : PopupButton()

    , ToolOptionControl(tool, property->getName())

    , m_property(property) {

  setObjectName(QString::fromStdString(property->getName()));

  setFixedHeight(20);

  m_property->addListener(this);

  TEnumProperty::Range range = property->getRange();

  TEnumProperty::Range::iterator it;

  for (it = range.begin(); it != range.end(); ++it)

    addItem(createQIconPNG(QString::fromStdWString(*it).toUtf8()));

  setCurrentIndex(0);

  updateStatus();

  connect(this, SIGNAL(activated(int)), this, SLOT(onActivated(int)));

}

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

void ToolOptionPopupButton::updateStatus() {

  int index = m_property->getIndex();

  if (index >= 0 && index != currentIndex()) setCurrentIndex(index);

}

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

void ToolOptionPopupButton::onActivated(int index) {

  const TEnumProperty::Range &range = m_property->getRange();

  if (index < 0 || index >= (int)range.size()) return;

  std::wstring item = range[index];

  m_property->setValue(item);

  notifyTool();

}

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

void ToolOptionPopupButton::doShowPopup() {

  if (isVisible()) showMenu();

}

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

void ToolOptionPopupButton::doSetCurrentIndex(int index) {

  if (isVisible()) setCurrentIndex(index);

}

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

void ToolOptionPopupButton::doOnActivated(int index) {

  if (isVisible()) onActivated(index);

}

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

ToolOptionTextField::ToolOptionTextField(TTool *tool, TStringProperty *property)

    : LineEdit()

    , ToolOptionControl(tool, property->getName())

    , m_property(property) {

  setFixedSize(100, 23);

  m_property->addListener(this);

  updateStatus();

  connect(this, SIGNAL(editingFinished()), SLOT(onValueChanged()));

}

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

void ToolOptionTextField::updateStatus() {

  QString newText = QString::fromStdWString(m_property->getValue());

  if (newText == text()) return;

  setText(newText);

}

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

void ToolOptionTextField::onValueChanged() {

  m_property->setValue(text().toStdWString());

  notifyTool();

  // synchronize the state with the same widgets in other tool option bars

  if (m_toolHandle) m_toolHandle->notifyToolChanged();

}

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

StyleIndexFieldAndChip::StyleIndexFieldAndChip(TTool *tool,

                                               TStyleIndexProperty *property,

                                               TPaletteHandle *pltHandle,

                                               ToolHandle *toolHandle)

    : StyleIndexLineEdit()

    , ToolOptionControl(tool, property->getName(), toolHandle)

    , m_property(property)

    , m_pltHandle(pltHandle) {

  m_property->addListener(this);

  updateStatus();

  connect(this, SIGNAL(textChanged(const QString &)),

          SLOT(onValueChanged(const QString &)));

  setPaletteHandle(pltHandle);

  connect(pltHandle, SIGNAL(colorStyleSwitched()), SLOT(updateColor()));

  connect(pltHandle, SIGNAL(colorStyleChanged()), SLOT(updateColor()));

}

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

void StyleIndexFieldAndChip::updateStatus() {

  QString newText = QString::fromStdWString(m_property->getValue());

  if (newText == text()) return;

  setText(newText);

}

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

void StyleIndexFieldAndChip::onValueChanged(const QString &changedText) {

  QString style;

  if (!QString("current").contains(changedText)) {

    int index      = changedText.toInt();

    TPalette *plt  = m_pltHandle->getPalette();

    int indexCount = plt->getStyleCount();

    if (index > indexCount)

      style = QString::number(indexCount - 1);

    else

      style = text();

  }

  m_property->setValue(style.toStdWString());

  repaint();

  // synchronize the state with the same widgets in other tool option bars

  if (m_toolHandle) m_toolHandle->notifyToolChanged();

}

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

void StyleIndexFieldAndChip::updateColor() { repaint(); }

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

ToolOptionParamRelayField::ToolOptionParamRelayField(

    TTool *tool, TDoubleParamRelayProperty *property, int decimals)

    : MeasuredDoubleLineEdit()

    , ToolOptionControl(tool, property->getName())

    , m_param()

    , m_measure()

    , m_property(property)

    , m_globalKey()

    , m_globalGroup() {

  setFixedSize(70, 20);

  m_property->addListener(this);

  setDecimals(decimals);

  updateStatus();

  connect(this, SIGNAL(valueChanged()), SLOT(onValueChanged()));

}

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

void ToolOptionParamRelayField::setGlobalKey(TBoolProperty *globalKey,

                                             TPropertyGroup *globalGroup) {

  m_globalKey = globalKey, m_globalGroup = globalGroup;

}

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

void ToolOptionParamRelayField::updateStatus() {

  TDoubleParamP param(m_property->getParam());

  if (param != m_param) {

    // Initialize param referencing

    m_param = param.getPointer();

    if (param) {

      m_measure = param->getMeasure();

      setMeasure(m_measure ? m_measure->getName() : "");

      setValue(m_property->getValue());

    }

  }

  if (!param) {

    setEnabled(false);

    m_measure = 0;

    setText("");

    return;

  }

  setEnabled(true);

  TMeasure *measure = param->getMeasure();

  if (measure != m_measure) {

    // Update measure if needed

    m_measure = measure;

    setMeasure(measure ? measure->getName() : "");

  }

  double v = m_property->getValue();

  if (getValue() == v) return;

  // Update value if needed

  setValue(v);

}

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

void ToolOptionParamRelayField::onValueChanged() {

  struct locals {

    static inline void setKeyframe(TDoubleParamRelayProperty *prop) {

      if (!prop) return;

      TDoubleParam *param = prop->getParam().getPointer();

      if (!param) return;

      double frame = prop->frame();

      if (!param->isKeyframe(frame)) {

        KeyframeSetter setter(param, -1, true);

        setter.createKeyframe(frame);

      }

    }

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

    struct SetValueUndo : public TUndo {

      TDoubleParamP m_param;      //!< The referenced param

      double m_oldVal, m_newVal;  //!< Values before and after the set action...

      double m_frame;             //!< ... at this frame

    public:

      SetValueUndo(const TDoubleParamP ¶m, double oldVal, double newVal,

                   double frame)

          : m_param(param)

          , m_oldVal(oldVal)

          , m_newVal(newVal)

          , m_frame(frame) {}

      int getSize() const {

        return sizeof(SetValueUndo) + sizeof(TDoubleParam);

      }

      void undo() const { m_param->setValue(m_frame, m_oldVal); }

      void redo() const { m_param->setValue(m_frame, m_newVal); }

    };

  };

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

  // NOTE: Values are extracted upon entry, since setting a keyframe reverts the

  // lineEdit

  // field value back to the original value (due to feedback from the param

  // itself)...

  double oldVal = m_property->getValue(), newVal = getValue(),

         frame = m_property->frame();

  TDoubleParamP param = m_property->getParam();

  if (!param) return;

  TUndoManager *manager = TUndoManager::manager();

  manager->beginBlock();

  if (m_globalKey && m_globalGroup && m_globalKey->getValue()) {

    // Set a keyframe for each of the TDoubleParam relayed in the globalGroup

    int p, pCount = m_globalGroup->getPropertyCount();

    for (p = 0; p != pCount; ++p) {

      TProperty *prop = m_globalGroup->getProperty(p);

      if (TDoubleParamRelayProperty *relProp =

              dynamic_cast<tdoubleparamrelayproperty *="">(prop))</tdoubleparamrelayproperty>

        locals::setKeyframe(relProp);

    }

  } else {

    // Set a keyframe just for our param

    locals::setKeyframe(m_property);

  }

  // Assign the edited value to the relayed param

  m_property->setValue(newVal);

  notifyTool();

  manager->add(new locals::SetValueUndo(param, oldVal, newVal, frame));

  manager->endBlock();

}