#include "toonzqt/functionsegmentviewer.h"

// TnzQt includes

#include "toonzqt/intfield.h"

#include "toonzqt/filefield.h"

#include "toonzqt/doublefield.h"

#include "toonzqt/expressionfield.h"

#include "toonzqt/dvdialog.h"

#include "tw/stringtable.h"

#include "toonzqt/functionsheet.h"

#include "toonzqt/functionpanel.h"

// TnzLib includes

#include "toonz/doubleparamcmd.h"

#include "toonz/txsheetexpr.h"

#include "toonz/txsheet.h"

#include "toonz/txsheethandle.h"

// TnzBase includes

#include "tdoubleparam.h"

#include "tdoublekeyframe.h"

#include "texpression.h"

#include "tunit.h"

// TnzCore includes

#include "tconvert.h"

// Qt includes

#include <qgridlayout></qgridlayout>

#include <qlabel></qlabel>

#include <qstackedwidget></qstackedwidget>

#include <qgroupbox></qgroupbox>

#include <qcombobox></qcombobox>

#include <qpushbutton></qpushbutton>

#include <qintvalidator></qintvalidator>

#include <qtextedit></qtextedit>

using namespace DVGui;

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

LineEdit *createField()

{

	LineEdit *field = new LineEdit();

	/*

  field->setMaximumWidth(100);

  field->setFixedHeight(100);

  field->setMinimumHeight(100);

  */

	return field;

}

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

FunctionSegmentPage::FunctionSegmentPage(FunctionSegmentViewer *parent)

	: QWidget(parent), m_viewer(parent)

{

}

FunctionSegmentPage::~FunctionSegmentPage()

{

}

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

class FunctionEmptySegmentPage : public FunctionSegmentPage

{

public:

	FunctionEmptySegmentPage(FunctionSegmentViewer *parent = 0)

		: FunctionSegmentPage(parent)

	{

	}

	void refresh() {}

	void apply() {}

	void init(int segmentLength) {}

};

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

SpeedInOutSegmentPage::SpeedInOutSegmentPage(FunctionSegmentViewer *parent)

	: FunctionSegmentPage(parent)

{

	m_speed0xFld = new LineEdit("0");

	m_speed0yFld = new DVGui::MeasuredDoubleLineEdit();

	m_speed1xFld = new LineEdit("0");

	m_speed1yFld = new DVGui::MeasuredDoubleLineEdit();

	m_firstSpeedFld = new DVGui::MeasuredDoubleLineEdit();

	m_lastSpeedFld = new DVGui::MeasuredDoubleLineEdit();

	//----layout

	QGridLayout *mainLayout = new QGridLayout();

	mainLayout->setHorizontalSpacing(5);

	mainLayout->setVerticalSpacing(5);

	mainLayout->setMargin(2);

	{

		mainLayout->addWidget(new QLabel(tr("First Speed:")), 0, 0, Qt::AlignRight | Qt::AlignVCenter);

		mainLayout->addWidget(m_firstSpeedFld, 0, 1, 1, 2);

		mainLayout->addWidget(new QLabel(tr("Handle:")), 1, 0, Qt::AlignRight | Qt::AlignVCenter);

		mainLayout->addWidget(m_speed0yFld, 1, 1);

		mainLayout->addWidget(new QLabel(tr("/")), 1, 2);

		mainLayout->addWidget(m_speed0xFld, 1, 3);

		mainLayout->addWidget(new QLabel(tr("Last Speed:")), 2, 0, Qt::AlignRight | Qt::AlignVCenter);

		mainLayout->addWidget(m_lastSpeedFld, 2, 1, 1, 2);

		mainLayout->addWidget(new QLabel(tr("Handle:")), 3, 0, Qt::AlignRight | Qt::AlignVCenter);

		mainLayout->addWidget(m_speed1yFld, 3, 1);

		mainLayout->addWidget(new QLabel(tr("/")), 3, 2);

		mainLayout->addWidget(m_speed1xFld, 3, 3);

	}

	mainLayout->setColumnStretch(0, 0);

	mainLayout->setColumnStretch(1, 1);

	mainLayout->setColumnStretch(2, 0);

	mainLayout->setColumnStretch(3, 1);

	setLayout(mainLayout);

	bool ret = connect(m_speed0xFld, SIGNAL(editingFinished()), this, SLOT(onFirstHandleXChanged()));

	ret = ret && connect(m_speed0yFld, SIGNAL(editingFinished()), this, SLOT(onFirstHandleYChanged()));

	ret = ret && connect(m_firstSpeedFld, SIGNAL(editingFinished()), this, SLOT(onFirstSpeedChanged()));

	ret = ret && connect(m_speed1xFld, SIGNAL(editingFinished()), this, SLOT(onLastHandleXChanged()));

	ret = ret && connect(m_speed1yFld, SIGNAL(editingFinished()), this, SLOT(onLastHandleYChanged()));

	ret = ret && connect(m_lastSpeedFld, SIGNAL(editingFinished()), this, SLOT(onLastSpeedChanged()));

	assert(ret);

}

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

void SpeedInOutSegmentPage::onFirstHandleXChanged()

{

	double x = m_speed0xFld->text().toDouble();

	/*--- 前のSegmentが存在して、Linkしていて、SpeedIn/Outでない場合、

		  Speedを保持してハンドルの長さを変える。---*/

	int segmentIndex = getViewer()->getSegmentIndex();

	if (segmentIndex > 0) /*--- 前のSegmentが存在している条件 ---*/

	{

		TDoubleKeyframe kf = getCurve()->getKeyframe(segmentIndex);

		/*--- Linkしていて、SpeedIn/Outでない場合の条件 ---*/

		if (kf.m_linkedHandles && kf.m_prevType != TDoubleKeyframe::SpeedInOut) {

			double speed = m_firstSpeedFld->getValue();

			m_speed0yFld->setValue(x * speed);

			return;

		}

	}

	/*--- 条件から外れる場合 ---*/

	double y = m_speed0yFld->getValue();

	if (x != 0.0)

		m_firstSpeedFld->setValue(y / x);

	else

		m_firstSpeedFld->setText(tr("---"));

}

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

void SpeedInOutSegmentPage::onFirstHandleYChanged()

{

	double y = m_speed0yFld->getValue();

	/*--- 前のSegmentが存在して、Linkしていて、SpeedIn/Outでない場合、

	Speedを保持してハンドルの長さを変える。---*/

	int segmentIndex = getViewer()->getSegmentIndex();

	if (segmentIndex > 0) /*--- 前のSegmentが存在している条件 ---*/

	{

		TDoubleKeyframe kf = getCurve()->getKeyframe(segmentIndex);

		/*--- Linkしていて、SpeedIn/Outでない場合の条件 ---*/

		if (kf.m_linkedHandles && kf.m_prevType != TDoubleKeyframe::SpeedInOut) {

			double speed = m_firstSpeedFld->getValue();

			if (!areAlmostEqual(speed, 0.0, 0.001))

				m_speed0xFld->setText(QString::number(y / speed, 'f', 1));

			else

				m_speed0xFld->setText(QString::number(0, 'f', 1));

			return;

		}

	}

	/*--- 条件から外れる場合 ---*/

	double x = m_speed0xFld->text().toDouble();

	if (x != 0.0)

		m_firstSpeedFld->setValue(y / x);

	else

		m_firstSpeedFld->setText(tr("---"));

}

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

void SpeedInOutSegmentPage::onFirstSpeedChanged()

{

	/*--- Speedを変えた場合は、Valueを変える。 ---*/

	double speed = m_firstSpeedFld->getValue();

	double x = m_speed0xFld->text().toDouble();

	m_speed0yFld->setValue(speed * x);

}

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

void SpeedInOutSegmentPage::onLastHandleXChanged()

{

	double x = m_speed1xFld->text().toDouble();

	/*--- 後のSegmentが存在して、Linkしていて、SpeedIn/Outでない場合、

		 Speedを保持してハンドルの長さを変える。 ---*/

	int segmentIndex = getViewer()->getSegmentIndex();

	TDoubleParam *curve = getCurve();

	if (curve && curve->getKeyframeCount() >= 3 && segmentIndex < curve->getKeyframeCount() - 2) /*--- 後のSegmentが存在している条件 ---*/

	{

		TDoubleKeyframe kf = getCurve()->getKeyframe(segmentIndex + 1);

		/*--- Linkしていて、SpeedIn/Outでない場合の条件 ---*/

		if (kf.m_linkedHandles && kf.m_type != TDoubleKeyframe::SpeedInOut) {

			double speed = m_lastSpeedFld->getValue();

			m_speed1yFld->setValue(x * speed);

			return;

		}

	}

	/*--- 条件から外れる場合 ---*/

	double y = m_speed1yFld->getValue();

	if (x != 0.0)

		m_lastSpeedFld->setValue(y / x);

	else

		m_lastSpeedFld->setText(tr("---"));

}

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

void SpeedInOutSegmentPage::onLastHandleYChanged()

{

	double y = m_speed1yFld->getValue();

	/*--- 後のSegmentが存在して、Linkしていて、SpeedIn/Outでない場合、

	Speedを保持してハンドルの長さを変える。 ---*/

	int segmentIndex = getViewer()->getSegmentIndex();

	TDoubleParam *curve = getCurve();

	if (curve && curve->getKeyframeCount() >= 3 && segmentIndex < curve->getKeyframeCount() - 2) /*--- 後のSegmentが存在している条件 ---*/

	{

		TDoubleKeyframe kf = getCurve()->getKeyframe(segmentIndex + 1);

		/*--- Linkしていて、SpeedIn/Outでない場合の条件 ---*/

		if (kf.m_linkedHandles && kf.m_type != TDoubleKeyframe::SpeedInOut) {

			double speed = m_lastSpeedFld->getValue();

			std::cout << "speed: " << speed << std::endl;

			if (!areAlmostEqual(speed, 0.0, 0.001))

				m_speed1xFld->setText(QString::number(y / speed, 'f', 1));

			else

				m_speed1xFld->setText(QString::number(0, 'f', 1));

			return;

		}

	}

	/*--- 条件から外れる場合 ---*/

	double x = m_speed1xFld->text().toDouble();

	if (x != 0.0)

		m_lastSpeedFld->setValue(y / x);

	else

		m_lastSpeedFld->setText(tr("---"));

}

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

void SpeedInOutSegmentPage::onLastSpeedChanged()

{

	/*--- Speedを変えた場合は、Valueを変える。 ---*/

	double speed = m_lastSpeedFld->getValue();

	double x = m_speed1xFld->text().toDouble();

	m_speed1yFld->setValue(speed * x);

}

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

void SpeedInOutSegmentPage::refresh()

{

	TDoubleParam *curve = getCurve();

	int kIndex = getViewer()->getSegmentIndex();

	if (!curve || kIndex < 0 || kIndex + 1 >= curve->getKeyframeCount())

		return;

	if (curve->getKeyframe(kIndex).m_type != TDoubleKeyframe::SpeedInOut)

		return;

	std::string measureName = curve->getMeasureName();

	if (measureName == "zdepth")

		measureName = "zdepth.handle";

	else if (measureName == "zdepth.cam")

		measureName = "zdepth.cam.handle";

	TPointD speedOut = curve->getSpeedOut(kIndex);

	m_speed0xFld->setText(QString::number(speedOut.x, 'f', 1));

	m_speed0yFld->setMeasure(measureName);

	m_speed0yFld->setValue(speedOut.y);

	m_firstSpeedFld->setMeasure(measureName);

	if (speedOut.x != 0.0)

		m_firstSpeedFld->setValue(speedOut.y / speedOut.x);

	else

		m_firstSpeedFld->setText(tr("---"));

	TPointD speedIn = curve->getSpeedIn(kIndex + 1);

	m_speed1xFld->setText(QString::number(speedIn.x, 'f', 1));

	m_speed1yFld->setMeasure(measureName);

	m_speed1yFld->setValue(speedIn.y);

	m_lastSpeedFld->setMeasure(measureName);

	if (speedIn.x != 0.0)

		m_lastSpeedFld->setValue(speedIn.y / speedIn.x);

	else

		m_lastSpeedFld->setText(tr("---"));

	/*--- キーフレームがリンク、かつ隣がSpeedIn/Outでないとき、

		Speed入力BoxをDisableする。それ以外の場合はEnableする ---*/

	//PrevKey

	if (kIndex > 0 && curve->getKeyframe(kIndex).m_linkedHandles && curve->getKeyframe(kIndex).m_prevType != TDoubleKeyframe::SpeedInOut)

		m_firstSpeedFld->setEnabled(false);

	else

		m_firstSpeedFld->setEnabled(true);

	//NextKey

	if (curve->getKeyframeCount() >= 3 && kIndex < curve->getKeyframeCount() - 2 && curve->getKeyframe(kIndex + 1).m_linkedHandles && curve->getKeyframe(kIndex + 1).m_type != TDoubleKeyframe::SpeedInOut)

		m_lastSpeedFld->setEnabled(false);

	else

		m_lastSpeedFld->setEnabled(true);

}

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

void SpeedInOutSegmentPage::init(int segmentLength)

{

	TDoubleParam *curve = getCurve();

	if (!curve)

		return;

	m_speed0xFld->setText(QString::number((double)segmentLength / 3.0));

	m_speed0yFld->setMeasure(curve->getMeasureName());

	m_speed0yFld->setValue(0);

	m_firstSpeedFld->setMeasure(curve->getMeasureName());

	m_firstSpeedFld->setValue(0);

	m_speed1xFld->setText(QString::number(-(double)segmentLength / 3.0));

	m_speed1yFld->setMeasure(curve->getMeasureName());

	m_speed1yFld->setValue(0);

	m_lastSpeedFld->setMeasure(curve->getMeasureName());

	m_lastSpeedFld->setValue(0);

}

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

void SpeedInOutSegmentPage::getGuiValues(TPointD &speedIn, TPointD &speedOut)

{

	speedOut.x = m_speed0xFld->text().toDouble();

	speedOut.y = m_speed0yFld->getValue();

	speedIn.x = m_speed1xFld->text().toDouble();

	speedIn.y = m_speed1yFld->getValue();

}

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

EaseInOutSegmentPage::EaseInOutSegmentPage(bool isPercentage, FunctionSegmentViewer *parent)

	: FunctionSegmentPage(parent), m_fieldScale(isPercentage ? 100.0 : 1.0), m_isPercentage(isPercentage)

{

	std::string measureName = isPercentage ? "percentage" : "";

	m_ease0Fld = new DVGui::MeasuredDoubleLineEdit();

	m_ease0Fld->setMeasure(measureName);

	m_ease1Fld = new DVGui::MeasuredDoubleLineEdit();

	m_ease1Fld->setMeasure(measureName);

	m_ease0Fld->setText("0");

	m_ease1Fld->setText("0");

	//----layout

	QGridLayout *mainLayout = new QGridLayout();

	mainLayout->setSpacing(5);

	mainLayout->setMargin(2);

	{

		mainLayout->addWidget(new QLabel(tr("Ease In:")), 0, 0, Qt::AlignRight | Qt::AlignVCenter);

		mainLayout->addWidget(m_ease0Fld, 0, 1);

		mainLayout->addWidget(new QLabel(tr("Ease Out:")), 1, 0, Qt::AlignRight | Qt::AlignVCenter);

		mainLayout->addWidget(m_ease1Fld, 1, 1);

	}

	mainLayout->setColumnStretch(0, 0);

	mainLayout->setColumnStretch(1, 1);

	setLayout(mainLayout);

}

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

void EaseInOutSegmentPage::refresh()

{

	TDoubleParam *curve = getCurve();

	if (!curve)

		return;

	TDoubleKeyframe kf0 = curve->getKeyframeAt(getR0());

	TDoubleKeyframe kf1 = curve->getKeyframeAt(getR1());

	m_ease0Fld->setValue(kf0.m_speedOut.x / m_fieldScale);

	m_ease1Fld->setValue(-kf1.m_speedIn.x / m_fieldScale);

}

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

void EaseInOutSegmentPage::onEase0Changed()

{

	TDoubleParam *curve = getCurve();

	int kIndex = getViewer()->getSegmentIndex();

	if (!curve || kIndex < 0)

		return;

	KeyframeSetter setter(curve, kIndex);

	setter.setEaseOut(m_ease0Fld->getValue() * m_fieldScale);

}

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

void EaseInOutSegmentPage::onEase1Changed()

{

	TDoubleParam *curve = getCurve();

	int kIndex = getViewer()->getSegmentIndex();

	if (!curve || kIndex < 0)

		return;

	KeyframeSetter setter(curve, kIndex + 1);

	setter.setEaseIn(-m_ease1Fld->getValue() * m_fieldScale);

}

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

void EaseInOutSegmentPage::init(int segmentLength)

{

	TDoubleParam *curve = getCurve();

	if (!curve)

		return;

	int kIndex = getViewer()->getSegmentIndex();

	/*---- 既にあるSegment上でTypeを切り替えたとき ----*/

	if (0 <= kIndex && kIndex < curve->getKeyframeCount() - 1) {

		TDoubleKeyframe keyFrame = curve->getKeyframe(kIndex);

		TDoubleKeyframe nextKeyFrame = curve->getKeyframe(kIndex + 1);

		double ease0 = 0, ease1 = 0;

		/*--- EaseInOut(Frame)からEaseIO(%)に切り替えたとき ---*/

		if (keyFrame.m_type == TDoubleKeyframe::EaseInOut && m_isPercentage) {

			// absolute -> percentage

			ease0 = keyFrame.m_speedOut.x / (double)segmentLength;

			ease1 = -nextKeyFrame.m_speedIn.x / (double)segmentLength;

			ease0 = tcrop(ease0, 0.0, 1.0);

			ease1 = tcrop(ease1, 0.0, 1.0 - ease0);

		}

		//*--- EaseIO(%)からEaseInOut(Frame)に切り替えたとき ---*/

		else if (keyFrame.m_type == TDoubleKeyframe::EaseInOutPercentage && !m_isPercentage) {

			// percentage -> absolute

			ease0 = keyFrame.m_speedOut.x * 0.01 * (double)segmentLength;

			ease1 = -nextKeyFrame.m_speedIn.x * 0.01 * (double)segmentLength;

			ease0 = tcrop(ease0, 0.0, (double)segmentLength);

			ease1 = tcrop(ease1, 0.0, (double)segmentLength - ease0);

		} else {

			ease1 = ease0 = ((m_isPercentage) ? 1.0 : (double)segmentLength) / 3.0;

		}

		if (!m_isPercentage) {

			ease0 = floor(ease0 + 0.5);

			ease1 = floor(ease1 + 0.5);

		}

		m_ease0Fld->setValue(ease0);

		m_ease1Fld->setValue(ease1);

	} else {

		double value = ((m_isPercentage) ? 1.0 : (double)segmentLength) / 3.0;

		if (!m_isPercentage)

			value = floor(value + 0.5);

		m_ease0Fld->setValue(value);

		m_ease1Fld->setValue(value);

	}

}

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

void EaseInOutSegmentPage::getGuiValues(TPointD &easeIn, TPointD &easeOut)

{

	easeOut.x = m_ease0Fld->getValue() * m_fieldScale;

	easeOut.y = 0;

	easeIn.x = -m_ease1Fld->getValue() * m_fieldScale;

	easeIn.y = 0;

}

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

FunctionExpressionSegmentPage::FunctionExpressionSegmentPage(FunctionSegmentViewer *parent)

	: FunctionSegmentPage(parent)

{

	m_expressionFld = new DVGui::ExpressionField();

	m_expressionFld->setFixedHeight(21);

	QLabel *unitLabel = new QLabel(tr("Unit:"));

	unitLabel->setAlignment(Qt::AlignRight | Qt::AlignVCenter);

	m_unitFld = createField();

	m_unitFld->setFixedWidth(40);

	m_unitFld->setText("inch");

	//---- layout

	QVBoxLayout *mainLayout = new QVBoxLayout();

	mainLayout->setSpacing(2);

	mainLayout->setMargin(2);

	{

		mainLayout->addSpacing(3);

		mainLayout->addWidget(new QLabel(tr("Expression:")));

		mainLayout->addWidget(m_expressionFld);

		mainLayout->addSpacing(3);

		QHBoxLayout *unitLay = new QHBoxLayout();

		{

			unitLay->addWidget(unitLabel);

			unitLay->addWidget(m_unitFld);

			unitLay->addStretch();

		}

		mainLayout->addLayout(unitLay);

	}

	setLayout(mainLayout);

}

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

void FunctionExpressionSegmentPage::refresh()

{

	TDoubleParam *curve = getCurve();

	if (!curve) {

		m_expressionFld->setGrammar(0);

		return;

	}

	TDoubleKeyframe kf0 = curve->getKeyframeAt(getR0());

	std::string expression = kf0.m_expressionText;

	bool oldBlockSignalsStatus = m_expressionFld->blockSignals(true);

	m_expressionFld->setGrammar(curve->getGrammar());

	m_expressionFld->setExpression(expression);

	m_expressionFld->blockSignals(oldBlockSignalsStatus);

	std::wstring unitName = toWideString(kf0.m_unitName);

	if (unitName == L"" && curve->getMeasure())

		unitName = curve->getMeasure()->getCurrentUnit()->getDefaultExtension();

	oldBlockSignalsStatus = m_unitFld->blockSignals(true);

	m_unitFld->setText(QString::fromStdWString(unitName));

	m_unitFld->blockSignals(oldBlockSignalsStatus);

}

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

void FunctionExpressionSegmentPage::init(int segmentLength)

{

	TDoubleParam *curve = getCurve();

	if (!curve) {

		m_expressionFld->setGrammar(0);

		m_expressionFld->setEnabled(false);

		return;

	}

	m_expressionFld->setEnabled(true);

	m_expressionFld->setGrammar(curve->getGrammar());

	int kIndex = getViewer()->getSegmentIndex();

	/*--- すでにあるカーブをExpressionに切り替えた場合 ---*/

	if (kIndex >= 0) {

		TDoubleKeyframe keyFrame = curve->getKeyframe(kIndex);

		double value = curve->getValue(keyFrame.m_frame);

		const TUnit *unit = 0;

		if (curve->getMeasure())

			unit = curve->getMeasure()->getCurrentUnit();

		if (unit)

			value = unit->convertTo(value);

		m_expressionFld->setExpression(QString::number(value).toStdString());

		/*--- unitがある場合だけUnitを表示 ---*/

		if (unit)

			m_unitFld->setText(QString::fromStdWString(unit->getDefaultExtension()));

		else

			m_unitFld->setText("");

	} else {

		m_expressionFld->setExpression("0");

		std::wstring unitName = L"inch";

		if (curve->getMeasure())

			unitName = curve->getMeasure()->getCurrentUnit()->getDefaultExtension();

		m_unitFld->setText(QString::fromStdWString(unitName));

	}

}

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

void FunctionExpressionSegmentPage::apply()

{

	TDoubleParam *curve = getCurve();

	if (!curve)

		return;

	int kIndex = getViewer()->getSegmentIndex();

	if (kIndex < 0)

		return;

	std::string expressionText = m_expressionFld->getExpression();

	TExpression expr;

	expr.setGrammar(curve->getGrammar());

	expr.setText(expressionText);

	if (dependsOn(expr, curve)) {

		DVGui::warning(tr("There is a circular reference in the definition of the interpolation."));

		return;

	}

	std::string unitName = m_unitFld->text().toStdString();

	KeyframeSetter setter(curve, kIndex);

	setter.setExpression(m_expressionFld->getExpression());

	setter.setUnitName(unitName);

	/*

  TDoubleKeyframe kf0 = curve->getKeyframeAt(getR0());

  kf0.m_expressionText = m_expressionFld->getExpression();

  kf0.m_unitName = m_unitFld->text().toStdString();

  curve->setKeyframe(kf0);

  wstring unitExtension = m_unitFld->text().toStdWString();

  TMeasure *curveMeasure = curve->getMeasure();

  if(curveMeasure)

  {

    TUnit *unit = curveMeasure->getUnit(unitExtension);

    if(unit)

      curveMeasure->setCurrentUnit(unit);

    else

    {

      unitExtension = curveMeasure->getCurrentUnit()->getDefaultExtension();

      m_unitFld->setText(QString::fromStdWString(unitExtension));

    }

  }

  else

    m_unitFld->setText("");

*/

}

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

/*! return false if a circular reference is occured

*/

bool FunctionExpressionSegmentPage::getGuiValues(std::string &expressionText,

												 std::string &unitName)

{

	expressionText = m_expressionFld->getExpression();

	//checking a circular reference

	TDoubleParam *curve = getCurve();

	TExpression expr;

	expr.setGrammar(curve->getGrammar());

	expr.setText(expressionText);

	if (dependsOn(expr, curve)) {

		DVGui::warning(tr("There is a circular reference in the definition of the interpolation."));

		return false;

	}

	unitName = m_unitFld->text().toStdString();

	if (m_expressionFld->hasFocus())

		m_expressionFld->clearFocus();

	return true;

}

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

class FileSegmentPage : public FunctionSegmentPage

{

	DVGui::FileField *m_fileFld;

	LineEdit *m_fieldIndexFld;

	LineEdit *m_measureFld;

public:

	FileSegmentPage(FunctionSegmentViewer *parent = 0) : FunctionSegmentPage(parent)

	{

		m_fileFld = new DVGui::FileField(this);

		m_fileFld->setFileMode(QFileDialog::ExistingFile);

		QStringList filters;

		filters.append("dat");

		filters.append("txt");

		m_fileFld->setFilters(filters);

		m_fieldIndexFld = new LineEdit(this);

		QIntValidator *intValidator = new QIntValidator(1, 100, this);

		m_fieldIndexFld->setValidator(intValidator);

		m_measureFld = new LineEdit(this);

		m_measureFld->setText("inch");

		//----layout

		QVBoxLayout *mainLayout = new QVBoxLayout();

		mainLayout->setSpacing(5);

		mainLayout->setMargin(2);

		{

			mainLayout->addWidget(new QLabel(tr("File Path:")), 0);

			mainLayout->addWidget(m_fileFld);

			QGridLayout *bottomLay = new QGridLayout();

			bottomLay->setSpacing(5);

			bottomLay->setMargin(0);

			{

				bottomLay->addWidget(new QLabel(tr("Column:")), 0, 0, Qt::AlignRight | Qt::AlignVCenter);

				bottomLay->addWidget(m_fieldIndexFld, 0, 1);

				bottomLay->addWidget(new QLabel(tr("Unit:")), 1, 0, Qt::AlignRight | Qt::AlignVCenter);

				bottomLay->addWidget(m_measureFld, 1, 1);

			}

			bottomLay->setColumnStretch(0, 0);

			bottomLay->setColumnStretch(1, 1);

			mainLayout->addLayout(bottomLay);

		}

		setLayout(mainLayout);

	}

	void refresh()

	{

		TDoubleKeyframe kf;

		TDoubleParam *curve = getCurve();

		if (curve)

			kf = curve->getKeyframeAt(getR0());

		if (curve && kf.m_isKeyframe) {

			TFilePath path;

			int fieldIndex = 0;

			std::string unitName = "";

			if (kf.m_type == TDoubleKeyframe::File) {

				path = kf.m_fileParams.m_path;

				fieldIndex = kf.m_fileParams.m_fieldIndex;

				if (fieldIndex < 0)

					fieldIndex = 0;

				unitName = kf.m_unitName;

				if (unitName == "") {

					TMeasure *measure = curve->getMeasure();

					if (measure) {

						const TUnit *unit = measure->getCurrentUnit();

						if (unit)

							unitName = toString(unit->getDefaultExtension());

					}

				}

			}

			m_fileFld->setPath(QString::fromStdWString(path.getWideString()));

			m_fieldIndexFld->setText(QString::number(fieldIndex + 1));

			m_measureFld->setText(QString::fromStdString(unitName));

		}

	}

	void init(int segmentLength)

	{

		TDoubleParam *curve = getCurve();

		if (!curve)

			return;

		TMeasure *measure = curve->getMeasure();

		std::string unitName = "";

		if (measure) {

			const TUnit *unit = measure->getCurrentUnit();

			if (unit)

				unitName = toString(unit->getDefaultExtension());

		}

		m_measureFld->setText(QString::fromStdString(unitName));

		m_fileFld->setPath("");

		m_fieldIndexFld->setText("");

	}

	void apply()

	{

		TDoubleParam *curve = getCurve();

		if (!curve)

			return;

		int kIndex = getViewer()->getSegmentIndex();

		if (kIndex < 0)

			return;

		QString stringPath = m_fileFld->getPath();

		if (stringPath == "")

			return;

		stringPath.replace("\\", "\\\\");

		TDoubleKeyframe::FileParams fileParams;

		fileParams.m_path = TFilePath(stringPath.toStdWString());

		fileParams.m_fieldIndex = qMax(0, m_fieldIndexFld->text().toInt() - 1);

		std::string unitName = m_measureFld->text().toStdString();

		KeyframeSetter setter(curve, kIndex);

		setter.setFile(fileParams);

		setter.setUnitName(unitName);

	}

	void getGuiValues(TDoubleKeyframe::FileParams &fileParam, std::string &unitName)

	{

		QString stringPath = m_fileFld->getPath();

		stringPath.replace("\\", "\\\\");

		fileParam.m_path = TFilePath(stringPath.toStdWString());

		fileParam.m_fieldIndex = qMax(0, m_fieldIndexFld->text().toInt() - 1);

		unitName = m_measureFld->text().toStdString();

	}

};

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

SimilarShapeSegmentPage::SimilarShapeSegmentPage(FunctionSegmentViewer *parent)

	: FunctionSegmentPage(parent)

{

	m_expressionFld = new DVGui::ExpressionField();

	m_offsetFld = createField();

	//----layout

	QVBoxLayout *mainLayout = new QVBoxLayout();

	mainLayout->setSpacing(2);

	mainLayout->setMargin(2);

	{

		mainLayout->addSpacing(3);

		mainLayout->addWidget(new QLabel(tr("Reference Curve:")));

		mainLayout->addWidget(m_expressionFld);

		mainLayout->addSpacing(3);

		QHBoxLayout *offLay = new QHBoxLayout();

		{

			offLay->addWidget(new QLabel(tr("Frame Offset:")));

			offLay->addWidget(m_offsetFld);

			offLay->addStretch();

		}

		mainLayout->addLayout(offLay);

	}

	setLayout(mainLayout);

}

void SimilarShapeSegmentPage::refresh()

{

	TDoubleParam *curve = getCurve();

	if (!curve) {

		m_expressionFld->setGrammar(0);

		return;

	}

	TDoubleKeyframe kf0 = curve->getKeyframeAt(getR0());

	std::string expression = kf0.m_expressionText;

	bool oldBlockSignalsStatus = m_expressionFld->blockSignals(true);

	m_expressionFld->setGrammar(curve->getGrammar());

	m_expressionFld->setExpression(expression);

	m_expressionFld->blockSignals(oldBlockSignalsStatus);

	m_offsetFld->setText(QString::number(kf0.m_similarShapeOffset, 'f', 0));

}

void SimilarShapeSegmentPage::init(int segmentLength)

{

	TDoubleParam *curve = getCurve();

	if (!curve) {

		m_expressionFld->setGrammar(0);

		m_expressionFld->setEnabled(false);

		return;

	}

	m_expressionFld->setEnabled(true);

	TDoubleKeyframe kf0 = curve->getKeyframeAt(getR0());

	std::string expression = kf0.m_expressionText;

	bool oldBlockSignalsStatus = m_expressionFld->blockSignals(true);

	m_expressionFld->setGrammar(curve->getGrammar());

	m_expressionFld->setExpression(expression);

	m_expressionFld->blockSignals(oldBlockSignalsStatus);

	m_offsetFld->setText(QString::number(kf0.m_similarShapeOffset, 'f', 0));

}

void SimilarShapeSegmentPage::apply()

{

	TDoubleParam *curve = getCurve();

	if (!curve)

		return;

	int kIndex = getViewer()->getSegmentIndex();