// 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 <qlistview></qlistview>

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

  std::string tempPropertyName = m_propertyName;

  if (addToUndo && m_propertyName == "Maximum Gap")

    tempPropertyName = tempPropertyName + "withUndo";

  m_tool->onPropertyChanged(tempPropertyName);

}

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

/*! 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();

}

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

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

                                   ToolHandle *toolHandle)

    : DoubleField()

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

    , m_property(property) {

  setLinearSlider(property->isLinearSlider());

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

  setMinimumWidth(50 + 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(!isDragging);

}

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

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

  setLinearSlider(property->isLinearSlider());

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

  setMinimumWidth(120 + 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();

}

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

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

  setLinearSlider(property->isLinearSlider());

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

  setMinimumWidth(200);

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

}

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

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

                                         ToolHandle *toolHandle)

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

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

    , m_property(property) {

  setLinearSlider(property->isLinearSlider());

  m_property->addListener(this);

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

  setRange(range.first, range.second);

  setMaximumWidth(300);

  setMinimumWidth(50);

  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::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::reloadComboBoxList(std::string id) {

  if (id == "" || m_property->getName() != id) return;

  loadEntries();

}

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

void ToolOptionCombo::loadEntries() {

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

  const TEnumProperty::Items &items = m_property->getItems();

  const int count = m_property->getCount();

  int maxWidth    = 0;

  clear();

  bool hasIcon = false;

  for (int i = 0; i < count; ++i) {

    QString itemStr = QString::fromStdWString(range[i]);

    if (items[i].iconName.isEmpty())

      addItem(items[i].UIName, itemStr);

    else {

      addItem(createQIcon(items[i].iconName.toUtf8()), items[i].UIName,

              itemStr);

      if (!hasIcon) {

        hasIcon = true;

        setIconSize(QSize(18, 18));

        // add margin between items if they are with icons

        setView(new QListView());

        view()->setIconSize(QSize(18, 18));

        setStyleSheet(

            "QComboBox  QAbstractItemView::item{ \

                       margin: 5 0 0 0;\

                      }");

      }

    }

    int tmpWidth = fontMetrics().width(items[i].UIName);

    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 + (hasIcon ? 23 : 0));

  updateStatus();

}

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

void ToolOptionCombo::updateStatus() {

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

  int index     = findData(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();

}

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

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

                                         ToolHandle *toolHandle)

    : QFontComboBox()

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

    , m_property(property) {

  setMaximumWidth(250);

  m_property->addListener(this);

  setSizeAdjustPolicy(QFontComboBox::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()));

  updateStatus();

}

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

void ToolOptionFontCombo::updateStatus() {

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

  int index     = findText(value);

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

}

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

void ToolOptionFontCombo::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();

}

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

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

  const TEnumProperty::Items &items = m_property->getItems();

  const int count                   = m_property->getCount();

  for (int i = 0; i < count; ++i) {

    QAction *action = addItem(createQIcon(items[i].iconName.toUtf8()));

    // make the tooltip text

    action->setToolTip(items[i].UIName);

  }

  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::doSetCurrentIndex(int index) {

  if (isVisible()) setCurrentIndex(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;

  // Aware of both "current" and translated string

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

      !StyleIndexLineEdit::tr("current").contains(changedText)) {

    int index     = changedText.toInt();

    TPalette *plt = m_pltHandle->getPalette();

    if (plt && index > plt->getStyleCount())

      style = QString::number(plt->getStyleCount() - 1);

    else

      style = text();

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

  } else

    m_property->setValue(changedText.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 final : 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();

}

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

//

// Widget specifici di ArrowTool (derivati da ToolOptionControl)

//

// SPOSTA in un file a parte!

using namespace DVGui;

MeasuredValueField::MeasuredValueField(QWidget *parent, QString name)

    : LineEdit(name, parent)

    , m_isGlobalKeyframe(false)

    , m_modified(false)

    , m_errorHighlighting(false)

    , m_precision(2) {

  setObjectName("MeasuredValueField");

  m_value = new TMeasuredValue("length");

  setText(QString::fromStdWString(m_value->toWideString(m_precision)));

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

          SLOT(onTextChanged(const QString &)));

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

  connect(&m_errorHighlightingTimer, SIGNAL(timeout()), this,

          SLOT(errorHighlightingTick()));

}

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

MeasuredValueField::~MeasuredValueField() { delete m_value; }

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

void MeasuredValueField::setMeasure(std::string name) {

  // for reproducing the precision

  int oldPrec = -1;

  delete m_value;

  m_value = new TMeasuredValue(name != "" ? name : "dummy");

  setText(QString::fromStdWString(m_value->toWideString(m_precision)));

}

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

void MeasuredValueField::commit() {

  if (!m_modified && !isReturnPressed()) return;

  // commit is called when the field comes out of focus.

  // mouse drag will call this - return if coming from mouse drag.

  // else undo is set twice

  if (m_mouseEdit) {

    m_mouseEdit = false;

    return;

  }

  int err    = 1;

  bool isSet = m_value->setValue(text().toStdWString(), &err);

  m_modified = false;

  if (err != 0) {

    setText(QString::fromStdWString(m_value->toWideString(m_precision)));

    m_errorHighlighting = 1;

    if (!m_errorHighlightingTimer.isActive())

      m_errorHighlightingTimer.start(40);

  } else {

    if (m_errorHighlightingTimer.isActive()) m_errorHighlightingTimer.stop();

    m_errorHighlighting = 0;

    setStyleSheet("");

  }

  if (!isSet && !isReturnPressed()) return;

  setText(QString::fromStdWString(m_value->toWideString(m_precision)));

  m_modified = false;

  emit measuredValueChanged(m_value);

}

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

void MeasuredValueField::onTextChanged(const QString &) { m_modified = true; }

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

void MeasuredValueField::setValue(double v) {

  if (getValue() == v) return;

  m_value->setValue(TMeasuredValue::MainUnit, v);

  setText(QString::fromStdWString(m_value->toWideString(m_precision)));

}

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

double MeasuredValueField::getValue() const {

  return m_value->getValue(TMeasuredValue::MainUnit);

}

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

void MeasuredValueField::errorHighlightingTick() {

  if (m_errorHighlighting < 0.01) {

    if (m_errorHighlightingTimer.isActive()) m_errorHighlightingTimer.stop();

    m_errorHighlighting = 0;

    setStyleSheet("");

  } else {

    int v               = 255 - (int)(m_errorHighlighting * 255);

    m_errorHighlighting = m_errorHighlighting * 0.8;

    int c               = 255 << 16 | v << 8 | v;

    setStyleSheet(QString("#MeasuredValueField {background-color:#%1}")

                      .arg(c, 6, 16, QLatin1Char('0')));

  }

}

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

void MeasuredValueField::setPrecision(int precision) {

  m_precision = precision;

  setText(QString::fromStdWString(m_value->toWideString(m_precision)));

}

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

void MeasuredValueField::mousePressEvent(QMouseEvent *e) {

  if (!isEnabled()) return;

  if ((e->buttons() == Qt::MiddleButton) || m_labelClicked) {

    m_xMouse        = e->x();

    m_mouseEdit     = true;

    m_originalValue = m_value->getValue(TMeasuredValue::CurrentUnit);

  } else {

    QLineEdit::mousePressEvent(e);

    if (!m_isTyping) {  // only the first click will select all

      selectAll();

      m_isTyping = true;

    }

  }

}

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

void MeasuredValueField::mouseMoveEvent(QMouseEvent *e) {

  if (!isEnabled()) return;

  if ((e->buttons() == Qt::MiddleButton) || m_labelClicked) {

    m_value->modifyValue((e->x() - m_xMouse) / 2);

    setText(QString::fromStdWString(m_value->toWideString(m_precision)));

    m_xMouse = e->x();

    // measuredValueChanged to update the UI, but don't add to undo

    emit measuredValueChanged(m_value, false);

  } else

    QLineEdit::mouseMoveEvent(e);

}

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

void MeasuredValueField::mouseReleaseEvent(QMouseEvent *e) {

  if (!isEnabled()) return;

  // m_mouseEdit will be set false in commit

  if (m_mouseEdit) {

    // This seems redundant, but this is necessary for undo to work

    double valueToRestore = m_value->getValue(TMeasuredValue::CurrentUnit);

    m_value->setValue(TMeasuredValue::CurrentUnit, m_originalValue);

    setText(QString::fromStdWString(m_value->toWideString(m_precision)));

    emit measuredValueChanged(m_value, false);

    // add this to undo

    m_value->setValue(TMeasuredValue::CurrentUnit, valueToRestore);

    setText(QString::fromStdWString(m_value->toWideString(m_precision)));

    emit measuredValueChanged(m_value, true);

    clearFocus();

  } else

    QLineEdit::mouseReleaseEvent(e);

}

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

void MeasuredValueField::focusOutEvent(QFocusEvent *e) {

  DVGui::LineEdit::focusOutEvent(e);

  m_isTyping = false;

}

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