// 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/doubleparamcmd.h"

#include "toonz/preferences.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 (!actions().isEmpty() && actions()[0]->isCheckable() &&

      actions()[0]->isChecked() != check)

    actions()[0]->setChecked(check);

  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(bool checked) {

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

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

  if (!isInVisibleViewer(this)) return;

  if (isChecked() == checked) return;

  setChecked(checked);

  m_property->setValue(checked);

  notifyTool();

}

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

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);

  // calculate maximum text length which includes length for decimals (for now

  // it's fixed to 2) and period

  int textMaxLength = std::max(QString::number((int)range.first).length(),

                               QString::number((int)range.second).length()) +

                      m_lineEdit->getDecimals() + 1;

  QString txt;

  // set the maximum width of the widget according to the text length (with 5

  // pixels margin)

  txt.fill('0', textMaxLength);

  int widgetWidth = fontMetrics().width(txt) + 5;

  m_lineEdit->parentWidget()->setMaximumWidth(widgetWidth);

  // set the maximum width of the slider to 250 pixels

  setMaximumWidth(250 + widgetWidth);

  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) {

  m_property->addListener(this);

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

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

  setRange(range.first, range.second);

  // calculate maximum text length which includes length for decimals (for now

  // it's fixed to 2) and period

  int textMaxLength = std::max(QString::number((int)range.first).length(),

                               QString::number((int)range.second).length()) +

                      m_leftLineEdit->getDecimals() + 1;

  QString txt;

  // set the maximum width of the widget according to the text length (with 5

  // pixels margin)

  txt.fill('0', textMaxLength);

  int widgetWidth = fontMetrics().width(txt) + 5;

  m_leftLineEdit->setFixedWidth(widgetWidth);

  m_rightLineEdit->setFixedWidth(widgetWidth);

  m_leftMargin  = widgetWidth + 12;

  m_rightMargin = widgetWidth + 12;

  // set the maximum width of the slider to 300 pixels

  setMaximumWidth(300 + m_leftMargin + m_rightMargin);

  setLeftText(leftName);

  setRightText(rightName);

  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);

  setMaximumWidth(300);

  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);

  setMaximumWidth(300);

  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;

  int maxWidth = 0;

  clear();

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

    QString itemStr = QString::fromStdWString(*it);

    addItem(itemStr);

    int tmpWidth                      = fontMetrics().width(itemStr);

    if (tmpWidth > maxWidth) maxWidth = tmpWidth;

  }

  // set the maximum width according to the longest item with 25 pixels for

  // arrow button and margin

  setMaximumWidth(maxWidth + 25);

  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 (Preferences::instance()->getDropdownShortcutsCycleOptions()) {

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

    int theIndex                                = currentIndex() + 1;

    if (theIndex >= (int)range.size()) theIndex = 0;

    doOnActivated(theIndex);

  } else {

    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;

  bool cycleOptions =

      Preferences::instance()->getDropdownShortcutsCycleOptions();

  // 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) {

    QString iconName = QString::fromStdWString(*it);

    QAction *action  = addItem(createQIcon(iconName.toUtf8()));

    // make the tooltip text

    iconName = iconName.replace('_', ' ');

    iconName = iconName.left(1).toUpper() + iconName.mid(1);

    action->setToolTip(iconName);

  }

  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(bool)), 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();