// TnzCore includes

#include "tpalette.h"

#include "tcolorstyles.h"

#include "tundo.h"

// TnzBase includes

#include "tproperty.h"

// TnzLib includes

#include "toonz/palettecontroller.h"

#include "toonz/tpalettehandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/stage2.h"

#include "toonz/stageobjectutil.h"

#include "toonz/doubleparamcmd.h"

// TnzQt includes

#include "toonzqt/gutil.h"

// TnzTools includes

#include "tools/tool.h"

#include "rasterselectiontool.h"

#include "vectorselectiontool.h"

// to enable the increase/decrease shortcuts while hiding the tool option

#include "tools/toolhandle.h"

// to enable shortcuts only when the viewer is focused

#include "tools/tooloptions.h"

// Qt includes

#include <qpainter></qpainter>

#include <qvboxlayout></qvboxlayout>

#include <qmouseevent></qmouseevent>

#include <qaction></qaction>

#include <qlabel></qlabel>

#include <qmainwindow></qmainwindow>

#include <qbuttongroup></qbuttongroup>

#include <qmenu></qmenu>

#include "tooloptionscontrols.h"

using namespace DVGui;

//***********************************************************************************

//    ToolOptionControl  implementation

//***********************************************************************************

ToolOptionControl::ToolOptionControl(TTool *tool, std::string propertyName, ToolHandle *toolHandle)

	: m_tool(tool), m_propertyName(propertyName), m_toolHandle(toolHandle)

{

}

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

void ToolOptionControl::notifyTool()

{

	m_tool->onPropertyChanged(m_propertyName);

}

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

/*! return true if the control is belonging to the visible combo viewer. very dirty implementation.

*/

bool ToolOptionControl::isInVisibleViewer(QWidget *widget)

{

	if (!widget)

		return false;

	if (widget->isVisible())

		return true;

	ToolOptionsBox *parentTOB = dynamic_cast<tooloptionsbox *="">(widget->parentWidget());</tooloptionsbox>

	if (!parentTOB)

		return false;

	ToolOptions *grandParentTO = dynamic_cast<tooloptions *="">(parentTOB->parentWidget());</tooloptions>

	if (!grandParentTO)

		return false;

	//There must be a QFrame between a ComboViewerPanel and a ToolOptions

	QFrame *greatGrandParentFrame = dynamic_cast<qframe *="">(grandParentTO->parentWidget());</qframe>

	if (!greatGrandParentFrame)

		return false;

	return greatGrandParentFrame->isVisible();

}

//***********************************************************************************

//    ToolOptionControl derivative  implementations

//***********************************************************************************

ToolOptionCheckbox::ToolOptionCheckbox(TTool *tool, TBoolProperty *property, ToolHandle *toolHandle,

									   QWidget *parent)

	: CheckBox(parent), ToolOptionControl(tool, property->getName(), toolHandle), m_property(property)

{

	setText(property->getQStringName());

	m_property->addListener(this);

	updateStatus();

	// synchronize the state with the same widgets in other tool option bars

	if (toolHandle)

		connect(this, SIGNAL(clicked(bool)), toolHandle, SIGNAL(toolChanged()));

}

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

void ToolOptionCheckbox::updateStatus()

{

	bool check = m_property->getValue();

	if (isChecked() == check)

		return;

	setCheckState(check ? Qt::Checked : Qt::Unchecked);

}

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

void ToolOptionCheckbox::nextCheckState()

{

	QAbstractButton::nextCheckState();

	m_property->setValue(checkState() == Qt::Checked);

	notifyTool();

}

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

void ToolOptionCheckbox::doClick()

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	click();

}

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

ToolOptionSlider::ToolOptionSlider(TTool *tool, TDoubleProperty *property, ToolHandle *toolHandle)

	: DoubleField(), ToolOptionControl(tool, property->getName(), toolHandle), m_property(property)

{

	m_property->addListener(this);

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

	setRange(range.first, range.second);

	updateStatus();

	connect(this, SIGNAL(valueChanged(bool)), SLOT(onValueChanged(bool)));

	// synchronize the state with the same widgets in other tool option bars

	if (toolHandle)

		connect(this, SIGNAL(valueEditedByHand()), toolHandle, SIGNAL(toolChanged()));

}

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

void ToolOptionSlider::updateStatus()

{

	double v = m_property->getValue();

	if (getValue() == v)

		return;

	setValue(v);

}

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

void ToolOptionSlider::onValueChanged(bool isDragging)

{

	m_property->setValue(getValue());

	notifyTool();

}

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

void ToolOptionSlider::increase()

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	double value = getValue();

	double minValue, maxValue;

	getRange(minValue, maxValue);

	value += 1;

	if (value > maxValue)

		value = maxValue;

	setValue(value);

	m_property->setValue(getValue());

	notifyTool();

	//update the interface

	repaint();

}

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

void ToolOptionSlider::decrease()

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	double value = getValue();

	double minValue, maxValue;

	getRange(minValue, maxValue);

	value -= 1;

	if (value < minValue)

		value = minValue;

	setValue(value);

	m_property->setValue(getValue());

	notifyTool();

	//update the interface

	repaint();

}

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

ToolOptionPairSlider::ToolOptionPairSlider(TTool *tool, TDoublePairProperty *property,

										   const QString &leftName, const QString &rightName,

										   ToolHandle *toolHandle)

	: DoublePairField(0, property->isMaxRangeLimited()), ToolOptionControl(tool, property->getName(), toolHandle), m_property(property)

{

	setLeftText(leftName);

	setRightText(rightName);

	m_property->addListener(this);

	TDoublePairProperty::Value value = property->getValue();

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

	setRange(range.first, range.second);

	updateStatus();

	connect(this, SIGNAL(valuesChanged(bool)), SLOT(onValuesChanged(bool)));

}

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

void ToolOptionPairSlider::updateStatus()

{

	TDoublePairProperty::Value value = m_property->getValue();

	setValues(value);

}

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

void ToolOptionPairSlider::onValuesChanged(bool isDragging)

{

	m_property->setValue(getValues());

	notifyTool();

	// synchronize the state with the same widgets in other tool option bars

	if (m_toolHandle)

		m_toolHandle->notifyToolChanged();

}

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

void ToolOptionPairSlider::increaseMaxValue()

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	std::pair<double, double=""> values = getValues();</double,>

	double minValue, maxValue;

	getRange(minValue, maxValue);

	values.second += 1;

	if (values.second > maxValue)

		values.second = maxValue;

	setValues(values);

	m_property->setValue(getValues());

	notifyTool();

	//update the interface

	repaint();

}

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

void ToolOptionPairSlider::decreaseMaxValue()

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	std::pair<double, double=""> values = getValues();</double,>

	values.second -= 1;

	if (values.second < values.first)

		values.second = values.first;

	setValues(values);

	m_property->setValue(getValues());

	notifyTool();

	//update the interface

	repaint();

}

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

void ToolOptionPairSlider::increaseMinValue()

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	std::pair<double, double=""> values = getValues();</double,>

	values.first += 1;

	if (values.first > values.second)

		values.first = values.second;

	setValues(values);

	m_property->setValue(getValues());

	notifyTool();

	//update the interface

	repaint();

}

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

void ToolOptionPairSlider::decreaseMinValue()

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	std::pair<double, double=""> values = getValues();</double,>

	double minValue, maxValue;

	getRange(minValue, maxValue);

	values.first -= 1;

	if (values.first < minValue)

		values.first = minValue;

	setValues(values);

	m_property->setValue(getValues());

	notifyTool();

	//update the interface

	repaint();

}

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

ToolOptionIntPairSlider::ToolOptionIntPairSlider(TTool *tool, TIntPairProperty *property,

												 const QString &leftName, const QString &rightName,

												 ToolHandle *toolHandle)

	: IntPairField(0, property->isMaxRangeLimited()), ToolOptionControl(tool, property->getName(), toolHandle), m_property(property)

{

	setLeftText(leftName);

	setRightText(rightName);

	m_property->addListener(this);

	TIntPairProperty::Value value = property->getValue();

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

	setRange(range.first, range.second);

	updateStatus();

	connect(this, SIGNAL(valuesChanged(bool)), SLOT(onValuesChanged(bool)));

}

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

void ToolOptionIntPairSlider::updateStatus()

{

	TIntPairProperty::Value value = m_property->getValue();

	setValues(value);

}

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

void ToolOptionIntPairSlider::onValuesChanged(bool isDragging)

{

	m_property->setValue(getValues());

	notifyTool();

	// synchronize the state with the same widgets in other tool option bars

	if (m_toolHandle)

		m_toolHandle->notifyToolChanged();

}

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

void ToolOptionIntPairSlider::increaseMaxValue()

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	std::pair<int, int=""> values = getValues();</int,>

	int minValue, maxValue;

	getRange(minValue, maxValue);

	values.second += 1;

	// a "cross-like shape" of the brush size = 3 is hard to use. so skip it

	if (values.second == 3 && m_tool->isPencilModeActive())

		values.second += 1;

	if (values.second > maxValue)

		values.second = maxValue;

	setValues(values);

	m_property->setValue(getValues());

	notifyTool();

	//update the interface

	repaint();

}

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

void ToolOptionIntPairSlider::decreaseMaxValue()

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	std::pair<int, int=""> values = getValues();</int,>

	values.second -= 1;

	// a "cross-like shape" of the brush size = 3 is hard to use. so skip it

	if (values.second == 3 && m_tool->isPencilModeActive())

		values.second -= 1;

	if (values.second < values.first)

		values.second = values.first;

	setValues(values);

	m_property->setValue(getValues());

	notifyTool();

	//update the interface

	repaint();

}

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

void ToolOptionIntPairSlider::increaseMinValue()

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	std::pair<int, int=""> values = getValues();</int,>

	values.first += 1;

	if (values.first > values.second)

		values.first = values.second;

	setValues(values);

	m_property->setValue(getValues());

	notifyTool();

	//update the interface

	repaint();

}

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

void ToolOptionIntPairSlider::decreaseMinValue()

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	std::pair<int, int=""> values = getValues();</int,>

	int minValue, maxValue;

	getRange(minValue, maxValue);

	values.first -= 1;

	if (values.first < minValue)

		values.first = minValue;

	setValues(values);

	m_property->setValue(getValues());

	notifyTool();

	//update the interface

	repaint();

}

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

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

										 ToolHandle *toolHandle)

	: IntField(0, property->isMaxRangeLimited()), ToolOptionControl(tool, property->getName(), toolHandle), m_property(property)

{

	m_property->addListener(this);

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

	setRange(range.first, range.second);

	updateStatus();

	connect(this, SIGNAL(valueChanged(bool)), SLOT(onValueChanged(bool)));

	// synchronize the state with the same widgets in other tool option bars

	if (toolHandle)

		connect(this, SIGNAL(valueEditedByHand()), toolHandle, SIGNAL(toolChanged()));

}

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

void ToolOptionIntSlider::updateStatus()

{

	int v = m_property->getValue();

	if (getValue() == v)

		return;

	setValue(v);

}

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

void ToolOptionIntSlider::increase()

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	int value = getValue();

	int minValue, maxValue;

	getRange(minValue, maxValue);

	value += 1;

	// a "cross-like shape" of the brush size = 3 is hard to use. so skip it

	if (value == 3 && m_tool->isPencilModeActive())

		value += 1;

	if (value > maxValue)

		value = maxValue;

	setValue(value);

	m_property->setValue(getValue());

	notifyTool();

	//update the interface

	repaint();

}

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

void ToolOptionIntSlider::decrease()

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	int value = getValue();

	int minValue, maxValue;

	getRange(minValue, maxValue);

	value -= 1;

	// a "cross-like shape" of the brush size = 3 is hard to use. so skip it

	if (value == 3 && m_tool->isPencilModeActive())

		value -= 1;

	if (value < minValue)

		value = minValue;

	setValue(value);

	m_property->setValue(getValue());

	notifyTool();

	//update the interface

	repaint();

}

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

void ToolOptionIntSlider::onValueChanged(bool isDragging)

{

	m_property->setValue(getValue());

	notifyTool();

}

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

ToolOptionCombo::ToolOptionCombo(TTool *tool, TEnumProperty *property, ToolHandle *toolHandle)

	: QComboBox(), ToolOptionControl(tool, property->getName(), toolHandle), m_property(property)

{

	setMinimumWidth(65);

	m_property->addListener(this);

	loadEntries();

	setSizeAdjustPolicy(QComboBox::AdjustToContents);

	connect(this, SIGNAL(activated(int)), this, SLOT(onActivated(int)));

	// synchronize the state with the same widgets in other tool option bars

	if (toolHandle)

		connect(this, SIGNAL(activated(int)), toolHandle, SIGNAL(toolChanged()));

}

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

void ToolOptionCombo::loadEntries()

{

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

	TEnumProperty::Range::iterator it;

	clear();

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

		addItem(QString::fromStdWString(*it));

	updateStatus();

}

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

void ToolOptionCombo::updateStatus()

{

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

	int index = findText(value);

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

		setCurrentIndex(index);

}

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

void ToolOptionCombo::onActivated(int index)

{

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

	if (index < 0 || index >= (int)range.size())

		return;

	std::wstring item = range[index];

	m_property->setValue(item);

	notifyTool();

}

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

void ToolOptionCombo::doShowPopup()

{

	if (isVisible())

		showPopup();

}

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

void ToolOptionCombo::doOnActivated(int index)

{

	if (m_toolHandle && m_toolHandle->getTool() != m_tool)

		return;

	// active only if the belonging combo-viewer is visible

	if (!isInVisibleViewer(this))

		return;

	// Just move the index if the first item is not "Normal"

	if (itemText(0) != "Normal") {

		onActivated(index);

		setCurrentIndex(index);

		//for updating the cursor

		m_toolHandle->notifyToolChanged();

		return;

	}

	// If the first item of this combo box is "Normal", enable shortcut key toggle can "back and forth" behavior.

	if (currentIndex() == index) {

		// estimating that the "Normal" option is located at the index 0

		onActivated(0);

		setCurrentIndex(0);

	} else {

		onActivated(index);

		setCurrentIndex(index);

	}

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

	m_toolHandle->notifyToolCursorTypeChanged();

}

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

ToolOptionPopupButton::ToolOptionPopupButton(TTool *tool, TEnumProperty *property)

	: PopupButton(), ToolOptionControl(tool, property->getName()), m_property(property)

{

	setObjectName(QString::fromStdString(property->getName()));

	setFixedHeight(20);

	m_property->addListener(this);

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

	TEnumProperty::Range::iterator it;

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

		addItem(createQIconPNG(QString::fromStdWString(*it).toUtf8()));

	setCurrentIndex(0);

	updateStatus();

	connect(this, SIGNAL(activated(int)), this, SLOT(onActivated(int)));

}

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

void ToolOptionPopupButton::updateStatus()

{

	int index = m_property->getIndex();

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

		setCurrentIndex(index);

}

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

void ToolOptionPopupButton::onActivated(int index)

{

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

	if (index < 0 || index >= (int)range.size())

		return;

	std::wstring item = range[index];

	m_property->setValue(item);

	notifyTool();

}

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

void ToolOptionPopupButton::doShowPopup()

{

	if (isVisible())

		showMenu();

}

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

void ToolOptionPopupButton::doSetCurrentIndex(int index)

{

	if (isVisible())

		setCurrentIndex(index);

}

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

void ToolOptionPopupButton::doOnActivated(int index)

{

	if (isVisible())

		onActivated(index);

}

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

ToolOptionTextField::ToolOptionTextField(TTool *tool, TStringProperty *property)

	: LineEdit(), ToolOptionControl(tool, property->getName()), m_property(property)

{

	setFixedSize(100, 23);

	m_property->addListener(this);

	updateStatus();

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

}

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

void ToolOptionTextField::updateStatus()

{

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

	if (newText == text())

		return;

	setText(newText);

}

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

void ToolOptionTextField::onValueChanged()

{

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

	notifyTool();

	// synchronize the state with the same widgets in other tool option bars

	if (m_toolHandle)

		m_toolHandle->notifyToolChanged();

}

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

StyleIndexFieldAndChip::StyleIndexFieldAndChip(TTool *tool, TStyleIndexProperty *property, TPaletteHandle *pltHandle,

											   ToolHandle *toolHandle)

	: StyleIndexLineEdit(), ToolOptionControl(tool, property->getName(), toolHandle), m_property(property), m_pltHandle(pltHandle)

{

	m_property->addListener(this);

	updateStatus();

	connect(this, SIGNAL(textChanged(const QString &)), SLOT(onValueChanged(const QString &)));

	setPaletteHandle(pltHandle);

	connect(pltHandle, SIGNAL(colorStyleSwitched()), SLOT(updateColor()));

	connect(pltHandle, SIGNAL(colorStyleChanged()), SLOT(updateColor()));

}

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

void StyleIndexFieldAndChip::updateStatus()

{

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

	if (newText == text())

		return;

	setText(newText);

}

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

void StyleIndexFieldAndChip::onValueChanged(const QString &changedText)

{

	QString style;

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

		int index = changedText.toInt();

		TPalette *plt = m_pltHandle->getPalette();

		int indexCount = plt->getStyleCount();

		if (index > indexCount)

			style = QString::number(indexCount - 1);

		else

			style = text();

	}

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

	repaint();

	// synchronize the state with the same widgets in other tool option bars

	if (m_toolHandle)

		m_toolHandle->notifyToolChanged();

}

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

void StyleIndexFieldAndChip::updateColor()

{

	repaint();

}

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

ToolOptionParamRelayField::ToolOptionParamRelayField(

	TTool *tool, TDoubleParamRelayProperty *property, int decimals)

	: MeasuredDoubleLineEdit(), ToolOptionControl(tool, property->getName()), m_param(), m_measure(), m_property(property), m_globalKey(), m_globalGroup()

{

	setFixedSize(70, 20);

	m_property->addListener(this);

	setDecimals(decimals);

	updateStatus();

	connect(this, SIGNAL(valueChanged()), SLOT(onValueChanged()));

}

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

void ToolOptionParamRelayField::setGlobalKey(TBoolProperty *globalKey, TPropertyGroup *globalGroup)

{

	m_globalKey = globalKey, m_globalGroup = globalGroup;

}

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

void ToolOptionParamRelayField::updateStatus()

{

	TDoubleParamP param(m_property->getParam());

	if (param != m_param) {

		// Initialize param referencing

		m_param = param.getPointer();

		if (param) {

			m_measure = param->getMeasure();

			setMeasure(m_measure ? m_measure->getName() : "");

			setValue(m_property->getValue());

		}

	}

	if (!param) {

		setEnabled(false);

		m_measure = 0;

		setText("");

		return;

	}

	setEnabled(true);

	TMeasure *measure = param->getMeasure();

	if (measure != m_measure) {

		// Update measure if needed

		m_measure = measure;

		setMeasure(measure ? measure->getName() : "");

	}

	double v = m_property->getValue();

	if (getValue() == v)

		return;

	// Update value if needed

	setValue(v);