#include "tools/tooloptions.h"

// TnzTools includes

#include "tools/tool.h"

#include "tools/toolhandle.h"

#include "tools/toolcommandids.h"

#include "edittool.h"

#include "selectiontool.h"

#include "vectorselectiontool.h"

#include "rasterselectiontool.h"

#include "toonzrasterbrushtool.h"

#include "fullcolorbrushtool.h"

#include "toonzvectorbrushtool.h"

#include "tooloptionscontrols.h"

//#include "rgbpickertool.h"

#include "rulertool.h"

#include "shifttracetool.h"

// TnzQt includes

#include "toonzqt/dvdialog.h"

#include "toonzqt/menubarcommand.h"

#include "toonzqt/gutil.h"

#include "toonzqt/dvscrollwidget.h"

#include "toonzqt/lutcalibrator.h"

#include "toonzqt/viewcommandids.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/tpalettehandle.h"

#include "toonz/palettecontroller.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/preferences.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/mypaintbrushstyle.h"

#include "toonz/tonionskinmaskhandle.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 <qpropertyanimation></qpropertyanimation>

#include <qeasingcurve></qeasingcurve>

#include <qstackedwidget></qstackedwidget>

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, bool isScrollable)

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

  if (isScrollable) {

    QHBoxLayout *hLayout = new QHBoxLayout;

    hLayout->setMargin(0);

    hLayout->setSpacing(0);

    setLayout(hLayout);

    // Build the scroll widget vin which the toolbar will be placed

    DvScrollWidget *scrollWidget = new DvScrollWidget;

    hLayout->addWidget(scrollWidget);

    // In the scrollable layout we add a widget of 24 height

    // which contains the tooloptionBar. This is necessary

    // to make the hboxlayout adjust the bar's vertical position.

    QWidget *toolContainer = new QWidget;

    scrollWidget->setWidget(toolContainer);

    toolContainer->setSizePolicy(QSizePolicy::MinimumExpanding,

                                 QSizePolicy::Fixed);

    toolContainer->setFixedHeight(24);

    toolContainer->setObjectName("toolOptionsPanel");

    toolContainer->setLayout(m_layout);

  } else

    setLayout(m_layout);

}

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

ToolOptionsBox::~ToolOptionsBox() {

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

                std::default_delete<tooloptioncontrol>());</tooloptioncontrol>

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

                std::default_delete<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);

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

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

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

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

  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 FONTCOMBOBOX: {

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

      QLabel *label = addLabel(p);

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

    }

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

    control                  = obj;

    widget                   = obj;

    break;

  }

  case COMBOBOX:

  default: {

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

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

}

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

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,

                                             bool scrollable)

    : ToolOptionsBox(parent, scrollable) {

  setObjectName("toolOptionsPanel");

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

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

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

  m_layout->addStretch(1);

}

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

// show 17x17 icon without style dependency

class SimpleIconViewField : public DraggableIconView {

  QIcon m_icon;

public:

  SimpleIconViewField(const QString &iconName, const QString &toolTipStr = "",

                      QWidget *parent = 0)

      : DraggableIconView(parent), m_icon(createQIcon(iconName.toUtf8())) {

    setMinimumSize(18, 18);

    setToolTip(toolTipStr);

  }

protected:

  void paintEvent(QPaintEvent *e) {

    QPainter p(this);

    p.drawPixmap(QRect(0, 2, 18, 18), m_icon.pixmap(18, 18));

  }

};

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

ArrowToolOptionsBox::ArrowToolOptionsBox(

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

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

    : ToolOptionsBox(parent, true)

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

  EditTool *editTool = dynamic_cast<edittool *="">(tool);</edittool>

  m_axisOptionWidgets = new QWidget *[AllAxis];

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

  m_pickWidget = new QWidget(this);

  /* --- 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_zLabel             = new ClickableLabel(tr("Z:"), this);

  m_motionPathPosLabel = new ClickableLabel(tr("Position:"), this);

  m_ewPosLabel         = new ClickableLabel(tr("X:"), this);

  m_nsPosLabel         = new ClickableLabel(tr("Y:"), this);

  // Lock X

  TBoolProperty *lockProp =

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

  if (lockProp)

    m_lockEWPosCheckbox =

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

  // Lock Y

  lockProp =

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

  if (lockProp)

    m_lockNSPosCheckbox =

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

  // stacking order

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

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

                                     frameHandle, objHandle, xshHandle, this);

  /* --- Rotation --- */

  m_rotationLabel = new ClickableLabel(tr("Rotation:"), this);

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

  m_globalScaleLabel = new ClickableLabel(tr("Global:"), this);

  m_scaleHLabel      = new ClickableLabel(tr("H:"), this);

  m_scaleVLabel      = new ClickableLabel(tr("V:"), 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);

  m_shearHLabel = new ClickableLabel(tr("H:"), this);

  m_shearVLabel = new ClickableLabel(tr("V:"), 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);

  m_ewCenterLabel = new ClickableLabel(tr("X:"), this);

  m_nsCenterLabel = new ClickableLabel(tr("Y:"), this);

  // Lock X Center

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

  if (lockProp)

    m_lockEWCenterCheckbox =

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

  // Lock Y Center

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

  if (lockProp)

    m_lockNSCenterCheckbox =

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

  TBoolProperty *globalKeyProp =

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

  if (globalKeyProp)

    m_globalKey =

        new ToolOptionCheckbox(m_tool, globalKeyProp, 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);

  m_hFlipButton = new QPushButton(this);

  m_vFlipButton = new QPushButton(this);

  m_leftRotateButton  = new QPushButton(this);

  m_rightRotateButton = new QPushButton(this);

  m_hFlipButton->setFixedSize(QSize(20, 20));

  m_vFlipButton->setFixedSize(QSize(20, 20));

  m_leftRotateButton->setFixedSize(QSize(20, 20));

  m_rightRotateButton->setFixedSize(QSize(20, 20));

  m_hFlipButton->setIcon(createQIcon("fliphoriz"));

  m_hFlipButton->setIconSize(QSize(20, 20));

  m_vFlipButton->setIcon(createQIcon("flipvert"));

  m_vFlipButton->setIconSize(QSize(20, 20));

  m_leftRotateButton->setIcon(createQIcon("rotateleft"));

  m_leftRotateButton->setIconSize(QSize(20, 20));

  m_rightRotateButton->setIcon(createQIcon("rotateright"));

  m_rightRotateButton->setIconSize(QSize(20, 20));

  m_hFlipButton->setToolTip(tr("Flip Object Horizontally"));

  m_vFlipButton->setToolTip(tr("Flip Object Vertically"));

  m_leftRotateButton->setToolTip(tr("Rotate Object Left"));

  m_rightRotateButton->setToolTip(tr("Rotate Object Right"));

  bool splined = isCurrentObjectSplined();

  if (splined != m_splined) m_splined = splined;

  setSplined(m_splined);

  const int ITEM_SPACING  = 10;

  const int LABEL_SPACING = 3;

  /* --- Layout --- */

  QHBoxLayout *mainLay = m_layout;

  {

    mainLay->addWidget(m_currentStageObjectCombo, 0);

    mainLay->addWidget(m_chooseActiveAxisCombo, 0);

    // Pick combobox only available on "All" axis mode

    QHBoxLayout *pickLay = new QHBoxLayout();

    pickLay->setMargin(0);

    pickLay->setSpacing(0);

    {

      pickLay->addSpacing(5);

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

      pickLay->addWidget(m_pickCombo, 0);

    }

    m_pickWidget->setLayout(pickLay);

    mainLay->addWidget(m_pickWidget, 0);

    addSeparator();

    {

      // Position

      QFrame *posFrame    = new QFrame(this);

      QHBoxLayout *posLay = new QHBoxLayout();

      posLay->setMargin(0);

      posLay->setSpacing(0);

      posFrame->setLayout(posLay);

      {

        posLay->addWidget(

            new SimpleIconViewField("edit_position", tr("Position"), this), 0);

        posLay->addSpacing(LABEL_SPACING * 2);

        posLay->addWidget(m_motionPathPosLabel, 0);

        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(m_zLabel, 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->addSpacing(ITEM_SPACING);

        posLay->addWidget(new DVGui::Separator("", this, false));

        posLay->addStretch(1);

      }

      m_axisOptionWidgets[Position] = posFrame;

      mainLay->addWidget(m_axisOptionWidgets[Position], 0);

      // Rotation

      QFrame *rotFrame    = new QFrame(this);

      QHBoxLayout *rotLay = new QHBoxLayout();

      rotLay->setMargin(0);

      rotLay->setSpacing(0);

      rotFrame->setLayout(rotLay);

      {

        rotLay->addWidget(

            new SimpleIconViewField("edit_rotation", tr("Rotation"), this), 0);

        rotLay->addSpacing(LABEL_SPACING * 2);

        rotLay->addWidget(m_rotationLabel, 0);

        rotLay->addSpacing(LABEL_SPACING);

        rotLay->addWidget(m_rotationField, 10);

        rotLay->addWidget(m_leftRotateButton);

        rotLay->addWidget(m_rightRotateButton);

        rotLay->addSpacing(ITEM_SPACING);

        rotLay->addWidget(new DVGui::Separator("", this, false));

        rotLay->addStretch(1);

      }

      m_axisOptionWidgets[Rotation] = rotFrame;

      mainLay->addWidget(m_axisOptionWidgets[Rotation], 0);

      // Scale

      QFrame *scaleFrame    = new QFrame(this);

      QHBoxLayout *scaleLay = new QHBoxLayout();

      scaleLay->setMargin(0);

      scaleLay->setSpacing(0);

      scaleFrame->setLayout(scaleLay);

      {

        scaleLay->addWidget(

            new SimpleIconViewField("edit_scale", tr("Scale"), this), 0);

        scaleLay->addSpacing(LABEL_SPACING * 2);

        scaleLay->addWidget(m_globalScaleLabel, 0);

        scaleLay->addSpacing(LABEL_SPACING);

        scaleLay->addWidget(m_globalScaleField, 10);

        scaleLay->addSpacing(ITEM_SPACING);

        scaleLay->addWidget(m_scaleHLabel, 0);

        scaleLay->addSpacing(LABEL_SPACING);

        scaleLay->addWidget(m_scaleHField, 10);

        scaleLay->addWidget(m_hFlipButton);

        scaleLay->addWidget(m_lockScaleHCheckbox, 0);

        scaleLay->addSpacing(ITEM_SPACING);

        scaleLay->addWidget(m_scaleVLabel, 0);

        scaleLay->addSpacing(LABEL_SPACING);

        scaleLay->addWidget(m_scaleVField, 10);

        scaleLay->addWidget(m_vFlipButton);

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

        scaleLay->addWidget(new DVGui::Separator("", this, false));

        scaleLay->addStretch(1);

      }

      m_axisOptionWidgets[Scale] = scaleFrame;

      mainLay->addWidget(m_axisOptionWidgets[Scale], 0);

      // Shear

      QFrame *shearFrame    = new QFrame(this);

      QHBoxLayout *shearLay = new QHBoxLayout();

      shearLay->setMargin(0);

      shearLay->setSpacing(0);

      shearFrame->setLayout(shearLay);

      {

        shearLay->addWidget(

            new SimpleIconViewField("edit_shear", tr("Shear"), this), 0);

        shearLay->addSpacing(LABEL_SPACING * 2);

        shearLay->addWidget(m_shearHLabel, 0);

        shearLay->addSpacing(LABEL_SPACING);

        shearLay->addWidget(m_shearHField, 10);

        shearLay->addWidget(m_lockShearHCheckbox, 0);

        shearLay->addSpacing(ITEM_SPACING);

        shearLay->addWidget(m_shearVLabel, 0);

        shearLay->addSpacing(LABEL_SPACING);

        shearLay->addWidget(m_shearVField, 10);

        shearLay->addWidget(m_lockShearVCheckbox, 0);

        shearLay->addSpacing(ITEM_SPACING);

        shearLay->addWidget(new DVGui::Separator("", this, false));

        shearLay->addStretch(1);

      }

      m_axisOptionWidgets[Shear] = shearFrame;

      mainLay->addWidget(m_axisOptionWidgets[Shear], 0);

      // Center Position

      QFrame *centerPosFrame    = new QFrame(this);

      QHBoxLayout *centerPosLay = new QHBoxLayout();

      centerPosLay->setMargin(0);

      centerPosLay->setSpacing(0);

      centerPosFrame->setLayout(centerPosLay);

      {

        centerPosLay->addWidget(

            new SimpleIconViewField("edit_center", tr("Center Position"), this),

            0);

        centerPosLay->addSpacing(LABEL_SPACING * 2);

        centerPosLay->addWidget(m_ewCenterLabel, 0);

        centerPosLay->addSpacing(LABEL_SPACING);

        centerPosLay->addWidget(m_ewCenterField, 10);

        centerPosLay->addWidget(m_lockEWCenterCheckbox, 0);

        centerPosLay->addSpacing(ITEM_SPACING);

        centerPosLay->addWidget(m_nsCenterLabel, 0);

        centerPosLay->addSpacing(LABEL_SPACING);

        centerPosLay->addWidget(m_nsCenterField, 10);

        centerPosLay->addWidget(m_lockNSCenterCheckbox, 0);

        centerPosLay->addSpacing(ITEM_SPACING);

        centerPosLay->addWidget(new DVGui::Separator("", this, false));

        centerPosLay->addStretch(1);

      }

      m_axisOptionWidgets[CenterPosition] = centerPosFrame;

      mainLay->addWidget(m_axisOptionWidgets[CenterPosition], 0);

    }

    mainLay->addWidget(m_globalKey, 0);

    mainLay->addSpacing(ITEM_SPACING);

  }

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

  // swap page when the active axis is changed

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

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

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

  }

  // enables adjusting value by dragging on the label

  connectLabelAndField(m_motionPathPosLabel, m_motionPathPosField);

  connectLabelAndField(m_ewPosLabel, m_ewPosField);

  connectLabelAndField(m_nsPosLabel, m_nsPosField);

  connectLabelAndField(m_zLabel, m_zField);

  connectLabelAndField(m_soLabel, m_soField);

  connectLabelAndField(m_rotationLabel, m_rotationField);

  connectLabelAndField(m_globalScaleLabel, m_globalScaleField);

  connectLabelAndField(m_scaleHLabel, m_scaleHField);

  connectLabelAndField(m_scaleVLabel, m_scaleVField);

  connectLabelAndField(m_shearHLabel, m_shearHField);

  connectLabelAndField(m_shearVLabel, m_shearVField);

  connectLabelAndField(m_ewCenterLabel, m_ewCenterField);

  connectLabelAndField(m_nsCenterLabel, m_nsCenterField);

  onCurrentAxisChanged(activeAxisProp->getIndex());

  connect(m_hFlipButton, SIGNAL(clicked()), SLOT(onFlipHorizontal()));

  connect(m_vFlipButton, SIGNAL(clicked()), SLOT(onFlipVertical()));

  connect(m_leftRotateButton, SIGNAL(clicked()), SLOT(onRotateLeft()));

  connect(m_rightRotateButton, SIGNAL(clicked()), SLOT(onRotateRight()));

  connect(editTool, SIGNAL(clickFlipHorizontal()), SLOT(onFlipHorizontal()));

  connect(editTool, SIGNAL(clickFlipVertical()), SLOT(onFlipVertical()));

  connect(editTool, SIGNAL(clickRotateLeft()), SLOT(onRotateLeft()));

  connect(editTool, SIGNAL(clickRotateRight()), SLOT(onRotateRight()));

}

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

// enables adjusting value by dragging on the label

void ArrowToolOptionsBox::connectLabelAndField(ClickableLabel *label,

                                               MeasuredValueField *field) {

  connect(label, SIGNAL(onMousePress(QMouseEvent *)), field,

          SLOT(receiveMousePress(QMouseEvent *)));

  connect(label, SIGNAL(onMouseMove(QMouseEvent *)), field,

          SLOT(receiveMouseMove(QMouseEvent *)));

  connect(label, SIGNAL(onMouseRelease(QMouseEvent *)), field,

          SLOT(receiveMouseRelease(QMouseEvent *)));

}

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

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