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

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

  m_toolHandle->notifyToolCursorTypeChanged();

}

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

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

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

}

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

void ToolOptionSlider::increase(double step) {

  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 += step;

  if (value > maxValue) value = maxValue;

  setValue(value);

  m_property->setValue(getValue());

  notifyTool();

  // update the interface

  repaint();

}

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

void ToolOptionSlider::increaseFractional() { increase(0.06); }

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

void ToolOptionSlider::decrease(double step) {

  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 -= step;

  if (value < minValue) value = minValue;

  setValue(value);

  m_property->setValue(getValue());

  notifyTool();

  // update the interface

  repaint();

}

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

void ToolOptionSlider::decreaseFractional() { decrease(0.06); }

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

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

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

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

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

  setLinearSlider(property->isLinearSlider());

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

        // add margin between items if they are with icons

        setView(new QListView());

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

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

}

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

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 (m_property->indexOf(L"Normal") != 0) {

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

}

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

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

}

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

void ToolOptionFontCombo::doShowPopup() {

  if (!isInVisibleViewer(this)) return;

  if (Preferences::instance()->getDropdownShortcutsCycleOptions()) {

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

    int theIndex                      = currentIndex() + 1;

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

    onActivated(theIndex);

    setCurrentIndex(theIndex);

  } else {

    if (isVisible()) showPopup();

  }

}

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

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