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

	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(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</std::string,>

		ct = m_controls.find(controlName);

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

}

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

void ToolOptionsBox::updateStatus()

{

	QMap<string, *="" tooloptioncontrol="">::iterator it;</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, 200);

	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(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() != "") {

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

	m_panel->addControl(control);

	hLayout()->addSpacing(5);

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

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

			string item = toString(*it);

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

}

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

class IconViewField : public QWidget

{

	QPixmap m_pixmap;

public:

	IconViewField(QWidget *parent = 0, QPixmap pixmap = QPixmap())

		: QWidget(parent), m_pixmap(pixmap)

	{

		setMinimumSize(21, 25);

	}

protected:

	void paintEvent(QPaintEvent *e)

	{

		QPainter p(this);

		// La pixmap e' alta 17 px, il widget 23. Per centrarla faccio il draw a 3 px.

		p.drawPixmap(QRect(0, 3, 21, 17), m_pixmap);

	}

};

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

ArrowToolOptionsBox::ArrowToolOptionsBox(QWidget *parent, TTool *tool, TPropertyGroup *pg,

										 TFrameHandle *frameHandle, TObjectHandle *objHandle, TXsheetHandle *xshHandle,

										 ToolHandle *toolHandle)

	: ToolOptionsBox(parent), m_pg(pg), 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);

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

	/* --- Layout --- */

	QHBoxLayout *mainLay = m_layout;

	{

		mainLay->addWidget(m_currentStageObjectCombo, 0);

		mainLay->addWidget(m_chooseActiveAxisCombo, 0);

		mainLay->addWidget(m_mainStackedWidget, 0);

		{

			//Position

			QFrame *posFrame = new QFrame(this);

			QHBoxLayout *posLay = new QHBoxLayout();

			posLay->setMargin(0);

			posLay->setSpacing(3);

			posFrame->setLayout(posLay);

			m_mainStackedWidget->addWidget(posFrame);

			{

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

				posLay->addSpacing(3);

				posLay->addWidget(m_motionPathPosField, 0);

				QHBoxLayout *ewLay = new QHBoxLayout();

				ewLay->setMargin(0);

				ewLay->setSpacing(0);

				{

					ewLay->addWidget(m_ewPosLabel, 0);

					ewLay->addWidget(m_ewPosField, 0);

					ewLay->addWidget(m_lockEWPosCheckbox, 0);

				}

				posLay->addLayout(ewLay, 0);

				posLay->addSpacing(3);

				QHBoxLayout *nsLay = new QHBoxLayout();

				nsLay->setMargin(0);

				nsLay->setSpacing(0);

				{

					nsLay->addWidget(m_nsPosLabel, 0);

					nsLay->addWidget(m_nsPosField, 0);

					nsLay->addWidget(m_lockNSPosCheckbox, 0);

				}

				posLay->addLayout(nsLay, 0);

				posLay->addSpacing(3);

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

				posLay->addWidget(m_zField, 0);

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

				posLay->addWidget(m_noScaleZField, 0);

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

				QHBoxLayout *soLay = new QHBoxLayout();

				soLay->setMargin(0);

				soLay->setSpacing(0);

				{

					soLay->addWidget(m_soLabel, 0);

					soLay->addWidget(m_soField, 0);

				}

				posLay->addLayout(soLay, 0);

				posLay->addStretch(1);

			}

			//Rotation

			QFrame *rotFrame = new QFrame(this);

			QHBoxLayout *rotLay = new QHBoxLayout();

			rotLay->setMargin(0);

			rotLay->setSpacing(3);

			rotFrame->setLayout(rotLay);

			m_mainStackedWidget->addWidget(rotFrame);

			{

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

				rotLay->addWidget(m_rotationField, 0);

				rotLay->addStretch(1);

			}

			//Scale

			QFrame *scaleFrame = new QFrame(this);

			QHBoxLayout *scaleLay = new QHBoxLayout();

			scaleLay->setMargin(0);

			scaleLay->setSpacing(3);

			scaleFrame->setLayout(scaleLay);

			m_mainStackedWidget->addWidget(scaleFrame);

			{

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

				scaleLay->addSpacing(3);

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

				scaleLay->addWidget(m_globalScaleField, 0);

				scaleLay->addSpacing(3);

				QHBoxLayout *hLay = new QHBoxLayout();

				hLay->setMargin(0);

				hLay->setSpacing(0);

				{

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

					hLay->addWidget(m_scaleHField, 0);

					hLay->addWidget(m_lockScaleHCheckbox, 0);

				}

				scaleLay->addLayout(hLay, 0);

				QHBoxLayout *vLay = new QHBoxLayout();

				vLay->setMargin(0);

				vLay->setSpacing(0);

				{

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

					vLay->addWidget(m_scaleVField, 0);

					vLay->addWidget(m_lockScaleVCheckbox, 0);

				}

				scaleLay->addLayout(vLay, 0);

				scaleLay->addSpacing(3);

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

				scaleLay->addWidget(m_maintainCombo, 0);

				scaleLay->addStretch(1);

			}

			//Shear

			QFrame *shearFrame = new QFrame(this);

			QHBoxLayout *shearLay = new QHBoxLayout();

			shearLay->setMargin(0);

			shearLay->setSpacing(3);

			shearFrame->setLayout(shearLay);

			m_mainStackedWidget->addWidget(shearFrame);

			{

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

				shearLay->addSpacing(3);

				QHBoxLayout *hLay = new QHBoxLayout();

				hLay->setMargin(0);

				hLay->setSpacing(0);

				{

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

					hLay->addWidget(m_shearHField, 0);

					hLay->addWidget(m_lockShearHCheckbox, 0);

				}

				shearLay->addLayout(hLay, 0);

				QHBoxLayout *vLay = new QHBoxLayout();

				vLay->setMargin(0);

				vLay->setSpacing(0);

				{

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

					vLay->addWidget(m_shearVField, 0);

					vLay->addWidget(m_lockShearVCheckbox, 0);

				}

				shearLay->addLayout(vLay, 0);

				shearLay->addStretch(1);

			}

			//Center Position

			QFrame *centerPosFrame = new QFrame(this);

			QHBoxLayout *centerPosLay = new QHBoxLayout();

			centerPosLay->setMargin(0);

			centerPosLay->setSpacing(3);

			centerPosFrame->setLayout(centerPosLay);

			m_mainStackedWidget->addWidget(centerPosFrame);

			{

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

				centerPosLay->addSpacing(3);

				QHBoxLayout *ewLay = new QHBoxLayout();

				ewLay->setMargin(0);

				ewLay->setSpacing(0);

				{

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

					ewLay->addWidget(m_ewCenterField, 0);

					ewLay->addWidget(m_lockEWCenterCheckbox, 0);

				}

				centerPosLay->addLayout(ewLay, 0);

				QHBoxLayout *nsLay = new QHBoxLayout();

				nsLay->setMargin(0);

				nsLay->setSpacing(0);

				{

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

					nsLay->addWidget(m_nsCenterField, 0);

					nsLay->addWidget(m_lockNSCenterCheckbox, 0);

				}

				centerPosLay->addLayout(nsLay, 0);

				centerPosLay->addStretch(1);

			}

		}

		mainLay->addStretch(1);

		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() != "") {

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

			string item = toString(*it);

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

	m_ewPosField->updateStatus();

	m_nsPosField->updateStatus();

	m_zField->updateStatus();

	m_noScaleZField->updateStatus();