#include "tools/tooloptions.h"

// TnzTools includes

#include "tools/tool.h"

#include "tools/toolhandle.h"

#include "tools/toolcommandids.h"

#include "selectiontool.h"

#include "vectorselectiontool.h"

#include "rasterselectiontool.h"

#include "brushtool.h"

#include "fullcolorbrushtool.h"

#include "tooloptionscontrols.h"

//#include "rgbpickertool.h"

#include "rulertool.h"

// TnzQt includes

#include "toonzqt/dvdialog.h"

#include "toonzqt/menubarcommand.h"

#include "toonzqt/gutil.h"

#include "toonzqt/dvscrollwidget.h"

// iwsw commented out temporarily

//#include "toonzqt/ghibli_3dlut_converter.h"

// TnzLib includes

#include "toonz/tobjecthandle.h"

#include "toonz/tstageobject.h"

#include "toonz/txsheethandle.h"

#include "toonz/tstageobjectspline.h"

#include "toonz/tframehandle.h"

#include "toonz/palettecontroller.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/preferences.h"

#include "toonz/tstageobjecttree.h"

// TnzCore includes

#include "tproperty.h"

#include "tenv.h"

// Qt includes

#include <qpainter></qpainter>

#include <qtoolbar></qtoolbar>

#include <qdockwidget></qdockwidget>

#include <qhboxlayout></qhboxlayout>

#include <qcombobox></qcombobox>

#include <qlabel></qlabel>

#include <qpushbutton></qpushbutton>

#include <qtoolbutton></qtoolbutton>

#include <qresizeevent></qresizeevent>

#include <qlist></qlist>

#include <qsignalmapper></qsignalmapper>

#include <qpushbutton></qpushbutton>

#include <qpropertyanimation></qpropertyanimation>

#include <qeasingcurve></qeasingcurve>

#include <qstackedwidget></qstackedwidget>

// tcg includes

#include "tcg/tcg_deleter_types.h"

TEnv::IntVar ArrowGlobalKeyFrame("EditToolGlobalKeyFrame", 0);

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

// ToolOptionToolBar

ToolOptionToolBar::ToolOptionToolBar(QWidget *parent) : QToolBar(parent) {

  setObjectName("toolOptionsPanel");

  setMaximumHeight(25);

}

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

void ToolOptionToolBar::addSpacing(int width) {

  QWidget *spaceW = new QWidget(this);

  spaceW->setFixedWidth(width);

  addWidget(spaceW);

}

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

// ToolOptionsBox

ToolOptionsBox::ToolOptionsBox(QWidget *parent) : QFrame(parent) {

  setObjectName("toolOptionsPanel");

  setStyleSheet("#toolOptionsPanel {border: 0px; margin: 1px;}");

  setFrameStyle(QFrame::StyledPanel);

  setFixedHeight(26);

  m_layout = new QHBoxLayout;

  m_layout->setMargin(0);

  m_layout->setSpacing(5);

  m_layout->addSpacing(5);

  setLayout(m_layout);

}

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

ToolOptionsBox::~ToolOptionsBox() {

  std::for_each(m_controls.begin(), m_controls.end(),

                tcg::deleter<tooloptioncontrol>());</tooloptioncontrol>

  std::for_each(m_labels.begin(), m_labels.end(), tcg::deleter<qlabel>());</qlabel>

}

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

QLabel *ToolOptionsBox::addLabel(QString name) {

  QLabel *label = new QLabel(name);

  label->setFixedHeight(20);

  m_layout->addWidget(label);

  m_labels[name.toStdString()] = label;

  return label;

}

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

void ToolOptionsBox::addLabel(std::string propName, QLabel *label) {

  m_labels[propName] = label;

}

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

void ToolOptionsBox::addSeparator() {

  DVGui::Separator *separator = new DVGui::Separator();

  separator->setOrientation(false);

  separator->setFixedWidth(17);

  m_layout->addWidget(separator, 0);

}

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

void ToolOptionsBox::addControl(ToolOptionControl *control) {

  m_controls[control->propertyName()] = control;

}

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

ToolOptionControl *ToolOptionsBox::control(

    const std::string &controlName) const {

  QMap<std::string, *="" tooloptioncontrol="">::const_iterator ct =</std::string,>

      m_controls.find(controlName);

  return (ct == m_controls.end()) ? 0 : ct.value();

}

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

void ToolOptionsBox::updateStatus() {

  QMap<std::string, *="" tooloptioncontrol="">::iterator it;</std::string,>

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

    it.value()->updateStatus();

}

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

// ToolOptionControlBuilder

ToolOptionControlBuilder::ToolOptionControlBuilder(ToolOptionsBox *panel,

                                                   TTool *tool,

                                                   TPaletteHandle *pltHandle,

                                                   ToolHandle *toolHandle)

    : m_panel(panel)

    , m_tool(tool)

    , m_pltHandle(pltHandle)

    , m_toolHandle(toolHandle)

    , m_singleValueWidgetType(SLIDER)

    , m_enumWidgetType(COMBOBOX) {}

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

QLabel *ToolOptionControlBuilder::addLabel(TProperty *p) {

  QLabel *label = new QLabel(p->getQStringName());

  hLayout()->addWidget(label, 0);

  return label;

}

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

void ToolOptionControlBuilder::visit(TDoubleProperty *p) {

  QLabel *label = addLabel(p);

  m_panel->addLabel(p->getName(), label);

  ToolOptionSlider *control = new ToolOptionSlider(m_tool, p, m_toolHandle);

  hLayout()->addWidget(control, 100);

  // storing the control in the map for updating values later

  m_panel->addControl(control);

  CommandManager *cm = CommandManager::instance();

  if (p->getName() == "Size:") {

    QAction *a;

    a = cm->getAction("A_IncreaseMaxBrushThickness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(increase()));

    a = cm->getAction("A_DecreaseMaxBrushThickness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(decrease()));

  }

  if (p->getName() == "Hardness:") {

    QAction *a;

    a = cm->getAction("A_IncreaseBrushHardness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(increase()));

    a = cm->getAction("A_DecreaseBrushHardness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(decrease()));

  }

  hLayout()->addSpacing(5);

}

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

void ToolOptionControlBuilder::visit(TDoublePairProperty *p) {

  QLabel *label = addLabel(p);

  m_panel->addLabel(p->getName(), label);

  ToolOptionPairSlider *control = new ToolOptionPairSlider(

      m_tool, p, QObject::tr("Min:"), QObject::tr("Max:"), m_toolHandle);

  hLayout()->addWidget(control, 150);

  m_panel->addControl(control);

  if (p->getName() == "Size:" || p->getName() == "Size") {

    CommandManager *cm = CommandManager::instance();

    QAction *a;

    a = cm->getAction("A_IncreaseMaxBrushThickness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(increaseMaxValue()));

    a = cm->getAction("A_DecreaseMaxBrushThickness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(decreaseMaxValue()));

    a = cm->getAction("A_IncreaseMinBrushThickness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(increaseMinValue()));

    a = cm->getAction("A_DecreaseMinBrushThickness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(decreaseMinValue()));

  }

  hLayout()->addSpacing(5);

}

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

void ToolOptionControlBuilder::visit(TIntPairProperty *p) {

  QLabel *label = addLabel(p);

  m_panel->addLabel(p->getName(), label);

  ToolOptionIntPairSlider *control = new ToolOptionIntPairSlider(

      m_tool, p, QObject::tr("Min:"), QObject::tr("Max:"), m_toolHandle);

  hLayout()->addWidget(control, 100);

  m_panel->addControl(control);

  if (p->getName() == "Size:") {

    CommandManager *cm = CommandManager::instance();

    QAction *a;

    a = cm->getAction("A_IncreaseMaxBrushThickness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(increaseMaxValue()));

    a = cm->getAction("A_DecreaseMaxBrushThickness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(decreaseMaxValue()));

    a = cm->getAction("A_IncreaseMinBrushThickness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(increaseMinValue()));

    a = cm->getAction("A_DecreaseMinBrushThickness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(decreaseMinValue()));

  }

  hLayout()->addSpacing(5);

}

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

void ToolOptionControlBuilder::visit(TIntProperty *p) {

  QLabel *label = addLabel(p);

  m_panel->addLabel(p->getName(), label);

  ToolOptionIntSlider *control =

      new ToolOptionIntSlider(m_tool, p, m_toolHandle);

  if (m_singleValueWidgetType == FIELD) {

    control->enableSlider(false);

    control->setFixedWidth(45);

  }

  hLayout()->addWidget(control, 100);

  m_panel->addControl(control);

  if (p->getName() == "Size:") {

    CommandManager *cm = CommandManager::instance();

    QAction *a;

    a = cm->getAction("A_IncreaseMaxBrushThickness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(increase()));

    a = cm->getAction("A_DecreaseMaxBrushThickness");

    control->addAction(a);

    QObject::connect(a, SIGNAL(triggered()), control, SLOT(decrease()));

  }

  hLayout()->addSpacing(5);

}

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

void ToolOptionControlBuilder::visit(TBoolProperty *p) {

  ToolOptionCheckbox *control = new ToolOptionCheckbox(m_tool, p, m_toolHandle);

  hLayout()->addWidget(control, 0);

  m_panel->addControl(control);

  if (p->getId() != "") {

    std::string actionName = "A_ToolOption_" + p->getId();

    QAction *a = CommandManager::instance()->getAction(actionName.c_str());

    if (a) {

      control->addAction(a);

      QObject::connect(a, SIGNAL(triggered()), control, SLOT(doClick()));

    }

  }

  hLayout()->addSpacing(5);

}

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

void ToolOptionControlBuilder::visit(TStringProperty *p) {

  QLabel *label = addLabel(p);

  m_panel->addLabel(p->getName(), label);

  ToolOptionTextField *control = new ToolOptionTextField(m_tool, p);

  m_panel->addControl(control);

  hLayout()->addWidget(control);

  hLayout()->addSpacing(5);

}

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

void ToolOptionControlBuilder::visit(TEnumProperty *p) {

  QWidget *widget;

  ToolOptionControl *control;

  switch (m_enumWidgetType) {

  case POPUPBUTTON: {

    ToolOptionPopupButton *obj = new ToolOptionPopupButton(m_tool, p);

    obj->setToolTip(p->getQStringName());

    control = obj;

    widget  = obj;

    break;

  }

  case COMBOBOX:

  default: {

    QLabel *label = addLabel(p);

    m_panel->addLabel(p->getName(), label);

    ToolOptionCombo *obj = new ToolOptionCombo(m_tool, p, m_toolHandle);

    control              = obj;

    widget               = obj;

    break;

  }

  }

  hLayout()->addWidget(widget, 100);

  m_panel->addControl(control);

  hLayout()->addSpacing(5);

  if (p->getId() != "") {

    std::string actionName = "A_ToolOption_" + p->getId();

    QAction *a = CommandManager::instance()->getAction(actionName.c_str());

    if (a) {

      widget->addAction(a);

      QObject::connect(a, SIGNAL(triggered()), widget, SLOT(doShowPopup()));

    }

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

    TEnumProperty::Range::iterator it;

    QSignalMapper *signalMapper = 0;

    int index                   = 0;

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

      std::string item           = ::to_string(*it);

      std::string itemActionName = actionName + ":" + item;

      a = CommandManager::instance()->getAction(itemActionName.c_str());

      if (a) {

        widget->addAction(a);

        if (signalMapper == 0) {

          signalMapper = new QSignalMapper(widget);

          QObject::connect(signalMapper, SIGNAL(mapped(int)), widget,

                           SLOT(doOnActivated(int)));

        }

        QObject::connect(a, SIGNAL(triggered()), signalMapper, SLOT(map()));

        signalMapper->setMapping(a, index);

      }

    }

  }

}

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

void ToolOptionControlBuilder::visit(TStyleIndexProperty *p) {

  QLabel *label = addLabel(p);

  m_panel->addLabel(p->getName(), label);

  StyleIndexFieldAndChip *chip =

      new StyleIndexFieldAndChip(m_tool, p, m_pltHandle, m_toolHandle);

  hLayout()->addWidget(chip, 0);

  m_panel->addControl(chip);

}

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

void ToolOptionControlBuilder::visit(TPointerProperty *p) {

  assert(!"not implemented");

}

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

// GenericToolOptionsBox

GenericToolOptionsBox::GenericToolOptionsBox(QWidget *parent, TTool *tool,

                                             TPaletteHandle *pltHandle,

                                             int propertyGroupIdx,

                                             ToolHandle *toolHandle)

    : ToolOptionsBox(parent) {

  setObjectName("toolOptionsPanel");

  ToolOptionControlBuilder builder(this, tool, pltHandle, toolHandle);

  if (tool && tool->getProperties(propertyGroupIdx))

    tool->getProperties(propertyGroupIdx)->accept(builder);

  m_layout->addStretch(1);

}

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

ArrowToolOptionsBox::ArrowToolOptionsBox(

    QWidget *parent, TTool *tool, TPropertyGroup *pg, TFrameHandle *frameHandle,

    TObjectHandle *objHandle, TXsheetHandle *xshHandle, ToolHandle *toolHandle)

    : ToolOptionsBox(parent)

    , m_pg(pg)

    , m_splined(false)

    , m_tool(tool)

    , m_frameHandle(frameHandle)

    , m_objHandle(objHandle)

    , m_xshHandle(xshHandle) {

  setFrameStyle(QFrame::StyledPanel);

  setObjectName("toolOptionsPanel");

  setFixedHeight(26);

  m_mainStackedWidget = new QStackedWidget(this);

  /* --- General Parts --- */

  // enable to choose target pegbar with combobox

  m_currentStageObjectCombo = new QComboBox(this);

  TEnumProperty *activeAxisProp =

      dynamic_cast<tenumproperty *="">(m_pg->getProperty("Active Axis"));</tenumproperty>

  if (activeAxisProp)

    m_chooseActiveAxisCombo =

        new ToolOptionCombo(m_tool, activeAxisProp, toolHandle);

  TEnumProperty *autoSelectProp =

      dynamic_cast<tenumproperty *="">(m_pg->getProperty("Auto Select Column"));</tenumproperty>

  if (autoSelectProp)

    m_pickCombo = new ToolOptionCombo(m_tool, autoSelectProp, toolHandle);

  /* --- Position --- */

  m_motionPathPosField =

      new PegbarChannelField(m_tool, TStageObject::T_Path, "field", frameHandle,

                             objHandle, xshHandle, this);

  m_ewPosField =

      new PegbarChannelField(m_tool, TStageObject::T_X, "field", frameHandle,

                             objHandle, xshHandle, this);

  m_nsPosField =

      new PegbarChannelField(m_tool, TStageObject::T_Y, "field", frameHandle,

                             objHandle, xshHandle, this);

  m_zField = new PegbarChannelField(m_tool, TStageObject::T_Z, "field",

                                    frameHandle, objHandle, xshHandle, this);

  m_noScaleZField = new NoScaleField(m_tool, "field");

  m_ewPosLabel    = new QLabel(tr("E/W:"), this);

  m_nsPosLabel    = new QLabel(tr("N/S:"), this);

  // Lock E/W

  TBoolProperty *lockProp =

      dynamic_cast<tboolproperty *="">(m_pg->getProperty("Lock Position E/W"));</tboolproperty>

  if (lockProp)

    m_lockEWPosCheckbox =

        new ToolOptionCheckbox(m_tool, lockProp, toolHandle, this);

  // Lock N/S

  lockProp =

      dynamic_cast<tboolproperty *="">(m_pg->getProperty("Lock Position N/S"));</tboolproperty>

  if (lockProp)

    m_lockNSPosCheckbox =

        new ToolOptionCheckbox(m_tool, lockProp, toolHandle, this);

  // stacking order

  m_soLabel = new QLabel(tr("SO:"), this);

  m_soField = new PegbarChannelField(m_tool, TStageObject::T_SO, "field",

                                     frameHandle, objHandle, xshHandle, this);

  /* --- Rotation --- */

  m_rotationField =

      new PegbarChannelField(m_tool, TStageObject::T_Angle, "field",

                             frameHandle, objHandle, xshHandle, this);

  /* --- Scale --- */

  m_globalScaleField =

      new PegbarChannelField(m_tool, TStageObject::T_Scale, "field",

                             frameHandle, objHandle, xshHandle, this);

  m_scaleHField =

      new PegbarChannelField(m_tool, TStageObject::T_ScaleX, "field",

                             frameHandle, objHandle, xshHandle, this);

  m_scaleVField =

      new PegbarChannelField(m_tool, TStageObject::T_ScaleY, "field",

                             frameHandle, objHandle, xshHandle, this);

  TEnumProperty *scaleConstraintProp =

      dynamic_cast<tenumproperty *="">(m_pg->getProperty("Scale Constraint:"));</tenumproperty>

  if (scaleConstraintProp)

    m_maintainCombo =

        new ToolOptionCombo(m_tool, scaleConstraintProp, toolHandle);

  // Lock Scale H

  lockProp = dynamic_cast<tboolproperty *="">(m_pg->getProperty("Lock Scale H"));</tboolproperty>

  if (lockProp)

    m_lockScaleHCheckbox =

        new ToolOptionCheckbox(m_tool, lockProp, toolHandle, this);

  // Lock Scale V

  lockProp = dynamic_cast<tboolproperty *="">(m_pg->getProperty("Lock Scale V"));</tboolproperty>

  if (lockProp)

    m_lockScaleVCheckbox =

        new ToolOptionCheckbox(m_tool, lockProp, toolHandle, this);

  /* --- Shear --- */

  m_shearHField =

      new PegbarChannelField(m_tool, TStageObject::T_ShearX, "field",

                             frameHandle, objHandle, xshHandle, this);

  m_shearVField =

      new PegbarChannelField(m_tool, TStageObject::T_ShearY, "field",

                             frameHandle, objHandle, xshHandle, this);

  // Lock Shear H

  lockProp = dynamic_cast<tboolproperty *="">(m_pg->getProperty("Lock Shear H"));</tboolproperty>

  if (lockProp)

    m_lockShearHCheckbox =

        new ToolOptionCheckbox(m_tool, lockProp, toolHandle, this);

  // Lock Scale V

  lockProp = dynamic_cast<tboolproperty *="">(m_pg->getProperty("Lock Shear V"));</tboolproperty>

  if (lockProp)

    m_lockShearVCheckbox =

        new ToolOptionCheckbox(m_tool, lockProp, toolHandle, this);

  /* --- Center Position --- */

  m_ewCenterField =

      new PegbarCenterField(m_tool, 0, "field", objHandle, xshHandle, this);

  m_nsCenterField =

      new PegbarCenterField(m_tool, 1, "field", objHandle, xshHandle, this);

  // Lock E/W Center

  lockProp =

      dynamic_cast<tboolproperty *="">(m_pg->getProperty("Lock Center E/W"));</tboolproperty>

  if (lockProp)

    m_lockEWCenterCheckbox =

        new ToolOptionCheckbox(m_tool, lockProp, toolHandle, this);

  // Lock N/S Center

  lockProp =

      dynamic_cast<tboolproperty *="">(m_pg->getProperty("Lock Center N/S"));</tboolproperty>

  if (lockProp)

    m_lockNSCenterCheckbox =

        new ToolOptionCheckbox(m_tool, lockProp, toolHandle, this);

  TBoolProperty *prop =

      dynamic_cast<tboolproperty *="">(m_pg->getProperty("Global Key"));</tboolproperty>

  if (prop)

    m_globalKey = new ToolOptionCheckbox(m_tool, prop, toolHandle, this);

  m_lockEWPosCheckbox->setObjectName("EditToolLockButton");

  m_lockNSPosCheckbox->setObjectName("EditToolLockButton");

  m_lockEWCenterCheckbox->setObjectName("EditToolLockButton");

  m_lockNSCenterCheckbox->setObjectName("EditToolLockButton");

  m_lockScaleHCheckbox->setObjectName("EditToolLockButton");

  m_lockScaleVCheckbox->setObjectName("EditToolLockButton");

  m_lockShearHCheckbox->setObjectName("EditToolLockButton");

  m_lockShearVCheckbox->setObjectName("EditToolLockButton");

  m_lockEWPosCheckbox->setText("");

  m_lockNSPosCheckbox->setText("");

  m_lockEWCenterCheckbox->setText("");

  m_lockNSCenterCheckbox->setText("");

  m_lockScaleHCheckbox->setText("");

  m_lockScaleVCheckbox->setText("");

  m_lockShearHCheckbox->setText("");

  m_lockShearVCheckbox->setText("");

  m_zField->setPrecision(4);

  m_noScaleZField->setPrecision(4);

  bool splined                        = isCurrentObjectSplined();

  if (splined != m_splined) m_splined = splined;

  setSplined(m_splined);

  const int ITEM_SPACING  = 10;

  const int LABEL_SPACING = 3;

  /* --- Layout --- */

  /* --- Layout --- */

  QHBoxLayout *mainLay = m_layout;

  {

    mainLay->addWidget(m_currentStageObjectCombo, 0);

    mainLay->addWidget(m_chooseActiveAxisCombo, 0);

    addSeparator();

    mainLay->addWidget(m_mainStackedWidget, 1);

    {

      // Position

      QFrame *posFrame    = new QFrame(this);

      QHBoxLayout *posLay = new QHBoxLayout();

      posLay->setMargin(0);

      posLay->setSpacing(0);

      posFrame->setLayout(posLay);

      m_mainStackedWidget->addWidget(posFrame);

      {

        posLay->addWidget(new QLabel(tr("Position"), this), 0);

        posLay->addSpacing(ITEM_SPACING);

        posLay->addWidget(m_motionPathPosField, 0);

        posLay->addWidget(m_ewPosLabel, 0);

        posLay->addSpacing(LABEL_SPACING);

        posLay->addWidget(m_ewPosField, 10);

        posLay->addWidget(m_lockEWPosCheckbox, 0);

        posLay->addSpacing(ITEM_SPACING);

        posLay->addWidget(m_nsPosLabel, 0);

        posLay->addSpacing(LABEL_SPACING);

        posLay->addWidget(m_nsPosField, 10);

        posLay->addWidget(m_lockNSPosCheckbox, 0);

        posLay->addSpacing(ITEM_SPACING);

        posLay->addWidget(new QLabel(tr("Z:"), this), 0);

        posLay->addSpacing(LABEL_SPACING);

        posLay->addWidget(m_zField, 10);

        posLay->addSpacing(LABEL_SPACING);

        posLay->addWidget(new QLabel(tr("("), this), 0);

        posLay->addWidget(m_noScaleZField, 10);

        posLay->addWidget(new QLabel(tr(")"), this), 0);

        posLay->addSpacing(ITEM_SPACING);

        posLay->addWidget(m_soLabel, 0);

        posLay->addWidget(m_soField, 10);

        posLay->addStretch(1);

      }

      // Rotation

      QFrame *rotFrame    = new QFrame(this);

      QHBoxLayout *rotLay = new QHBoxLayout();

      rotLay->setMargin(0);

      rotLay->setSpacing(0);

      rotFrame->setLayout(rotLay);

      m_mainStackedWidget->addWidget(rotFrame);

      {

        rotLay->addWidget(new QLabel(tr("Rotation"), this), 0);

        rotLay->addSpacing(ITEM_SPACING);

        rotLay->addWidget(m_rotationField, 10);

        rotLay->addStretch(1);

      }

      // Scale

      QFrame *scaleFrame    = new QFrame(this);

      QHBoxLayout *scaleLay = new QHBoxLayout();

      scaleLay->setMargin(0);

      scaleLay->setSpacing(0);

      scaleFrame->setLayout(scaleLay);

      m_mainStackedWidget->addWidget(scaleFrame);

      {

        scaleLay->addWidget(new QLabel(tr("Scale"), this), 0);

        scaleLay->addSpacing(ITEM_SPACING);

        scaleLay->addWidget(new QLabel(tr("Global:"), this), 0);

        scaleLay->addSpacing(LABEL_SPACING);

        scaleLay->addWidget(m_globalScaleField, 10);

        scaleLay->addSpacing(ITEM_SPACING);

        scaleLay->addWidget(new QLabel(tr("H:"), this), 0);

        scaleLay->addSpacing(LABEL_SPACING);

        scaleLay->addWidget(m_scaleHField, 10);

        scaleLay->addWidget(m_lockScaleHCheckbox, 0);

        scaleLay->addSpacing(ITEM_SPACING);

        scaleLay->addWidget(new QLabel(tr("V:"), this), 0);

        scaleLay->addSpacing(LABEL_SPACING);

        scaleLay->addWidget(m_scaleVField, 10);

        scaleLay->addWidget(m_lockScaleVCheckbox, 0);

        scaleLay->addSpacing(ITEM_SPACING);

        scaleLay->addWidget(new QLabel(tr("Maintain:"), this), 0);

        scaleLay->addSpacing(LABEL_SPACING);

        scaleLay->addWidget(m_maintainCombo, 0);

        scaleLay->addStretch(1);

      }

      // Shear

      QFrame *shearFrame    = new QFrame(this);

      QHBoxLayout *shearLay = new QHBoxLayout();

      shearLay->setMargin(0);

      shearLay->setSpacing(0);

      shearFrame->setLayout(shearLay);

      m_mainStackedWidget->addWidget(shearFrame);

      {

        shearLay->addWidget(new QLabel(tr("Shear"), this), 0);

        shearLay->addSpacing(ITEM_SPACING);

        shearLay->addWidget(new QLabel(tr("H:"), this), 0);

        shearLay->addSpacing(LABEL_SPACING);

        shearLay->addWidget(m_shearHField, 10);

        shearLay->addWidget(m_lockShearHCheckbox, 0);

        shearLay->addSpacing(ITEM_SPACING);

        shearLay->addWidget(new QLabel(tr("V:"), this), 0);

        shearLay->addSpacing(LABEL_SPACING);

        shearLay->addWidget(m_shearVField, 10);

        shearLay->addWidget(m_lockShearVCheckbox, 0);

        shearLay->addSpacing(ITEM_SPACING);

        shearLay->addStretch(1);

      }

      // Center Position

      QFrame *centerPosFrame    = new QFrame(this);

      QHBoxLayout *centerPosLay = new QHBoxLayout();

      centerPosLay->setMargin(0);

      centerPosLay->setSpacing(0);

      centerPosFrame->setLayout(centerPosLay);

      m_mainStackedWidget->addWidget(centerPosFrame);

      {

        centerPosLay->addWidget(new QLabel(tr("Center Position"), this), 0);

        centerPosLay->addSpacing(ITEM_SPACING);

        centerPosLay->addWidget(new QLabel(tr("E/W:"), this), 0);

        centerPosLay->addSpacing(LABEL_SPACING);

        centerPosLay->addWidget(m_ewCenterField, 10);

        centerPosLay->addWidget(m_lockEWCenterCheckbox, 0);

        centerPosLay->addSpacing(ITEM_SPACING);

        centerPosLay->addWidget(new QLabel(tr("N/S:"), this), 0);

        centerPosLay->addSpacing(LABEL_SPACING);

        centerPosLay->addWidget(m_nsCenterField, 10);

        centerPosLay->addWidget(m_lockNSCenterCheckbox, 0);

        centerPosLay->addStretch(1);

      }

    }

    addSeparator();

    mainLay->addWidget(m_globalKey, 0);

    mainLay->addSpacing(5);

    QHBoxLayout *pickLay = new QHBoxLayout();

    pickLay->setMargin(0);

    pickLay->setSpacing(0);

    mainLay->addLayout(pickLay, 0);

    {

      pickLay->addWidget(new QLabel(tr("Pick:"), this), 0);

      pickLay->addWidget(m_pickCombo, 0);

    }

  }

  /* --- signal-slot connections --- */

  // swap page when the active axis is changed

  connect(m_chooseActiveAxisCombo, SIGNAL(currentIndexChanged(int)),

          m_mainStackedWidget, SLOT(setCurrentIndex(int)));

  // when the current stage object is changed via combo box, then switch the

  // current stage object in the scene

  connect(m_currentStageObjectCombo, SIGNAL(activated(int)), this,

          SLOT(onCurrentStageObjectComboActivated(int)));

  /* --- Assigning shortcut keys --- */

  if (activeAxisProp->getId() != "") {

    std::string actionName = "A_ToolOption_" + activeAxisProp->getId();

    QAction *a = CommandManager::instance()->getAction(actionName.c_str());

    if (a) {

      m_chooseActiveAxisCombo->addAction(a);

      QObject::connect(a, SIGNAL(triggered()), m_chooseActiveAxisCombo,

                       SLOT(doShowPopup()));

    }

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

    TEnumProperty::Range::iterator it;

    QSignalMapper *signalMapper = 0;

    int index                   = 0;

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

      std::string item           = ::to_string(*it);

      std::string itemActionName = actionName + ":" + item;

      a = CommandManager::instance()->getAction(itemActionName.c_str());

      if (a) {

        m_chooseActiveAxisCombo->addAction(a);

        if (signalMapper == 0) {

          signalMapper = new QSignalMapper(m_chooseActiveAxisCombo);

          QObject::connect(signalMapper, SIGNAL(mapped(int)),

                           m_chooseActiveAxisCombo, SLOT(doOnActivated(int)));

        }

        QObject::connect(a, SIGNAL(triggered()), signalMapper, SLOT(map()));

        signalMapper->setMapping(a, index);

      }

    }

  }

  if (scaleConstraintProp) {

    m_scaleHField->onScaleTypeChanged(m_maintainCombo->currentIndex());

    m_scaleVField->onScaleTypeChanged(m_maintainCombo->currentIndex());

    connect(m_maintainCombo, SIGNAL(currentIndexChanged(int)), m_scaleHField,

            SLOT(onScaleTypeChanged(int)));

    connect(m_maintainCombo, SIGNAL(currentIndexChanged(int)), m_scaleVField,

            SLOT(onScaleTypeChanged(int)));

  }

}

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

void ArrowToolOptionsBox::showEvent(QShowEvent *) {

  connect(m_frameHandle, SIGNAL(frameSwitched()), SLOT(onFrameSwitched()));

  // if some stage object is added/removed, then reflect it to the combobox

  connect(m_xshHandle, SIGNAL(xsheetSwitched()), this,

          SLOT(updateStageObjectComboItems()));

  connect(m_xshHandle, SIGNAL(xsheetChanged()), this,

          SLOT(updateStageObjectComboItems()));

  // If the current stage object is switched, then synchronize it to the

  // combobox

  connect(m_objHandle, SIGNAL(objectSwitched()), this,

          SLOT(syncCurrentStageObjectComboItem()));

  // update the item list in m_currentStageObjectCombo

  updateStageObjectComboItems();

}

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

void ArrowToolOptionsBox::hideEvent(QShowEvent *) {

  disconnect(m_frameHandle, SIGNAL(frameSwitched()), this,

             SLOT(onFrameSwitched()));

  disconnect(m_xshHandle, SIGNAL(xsheetSwitched()), this,

             SLOT(updateStageObjectComboItems()));

  disconnect(m_xshHandle, SIGNAL(xsheetChanged()), this,

             SLOT(updateStageObjectComboItems()));

  disconnect(m_objHandle, SIGNAL(objectSwitched()), this,

             SLOT(syncCurrentStageObjectComboItem()));

}

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

void ArrowToolOptionsBox::setSplined(bool on) {

  m_splined = on;

  // Activate on selecting spline

  m_motionPathPosField->setVisible(on);

  // DEactivate on selecting spline

  m_ewPosField->setVisible(!on);

  m_nsPosField->setVisible(!on);

  m_ewPosLabel->setVisible(!on);

  m_nsPosLabel->setVisible(!on);

  m_lockEWPosCheckbox->setVisible(!on);

  m_lockNSPosCheckbox->setVisible(!on);

}

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

bool ArrowToolOptionsBox::isCurrentObjectSplined() const {

  TStageObjectId objId = m_objHandle->getObjectId();

  return m_xshHandle->getXsheet()->getStageObject(objId)->getSpline() != 0;

}

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

void ArrowToolOptionsBox::updateStatus() {

  // General

  m_chooseActiveAxisCombo->updateStatus();

  m_pickCombo->updateStatus();

  // Position

  m_motionPathPosField->updateStatus();