#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"

#include "toonzqt/gutil.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 "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;

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

static 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 final : public FunctionSegmentPage {

public:

  FunctionEmptySegmentPage(FunctionSegmentViewer *parent = 0)

      : FunctionSegmentPage(parent) {}

  void refresh() override {}

  void apply() override {}

  void init(int segmentLength) override {}

};

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

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 Out:")), 0, 0,

                          Qt::AlignRight | Qt::AlignVCenter);

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

    mainLayout->addWidget(new QLabel(tr("Ease In:")), 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 = ::to_wstring(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 occurred

 */

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;

}

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

FileSegmentPage::FileSegmentPage(FunctionSegmentViewer *parent)

    : FunctionSegmentPage(parent) {

  // Force decoding the path since the file interporation

  // currently accepts only absolute paths.

  m_fileFld = new DVGui::FileField(this, QString(), false, false, false);

  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 FileSegmentPage::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 = ::to_string(unit->getDefaultExtension());

        }

      }

    }

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

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

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

  }

}

void FileSegmentPage::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 = ::to_string(unit->getDefaultExtension());

  }

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

  m_fileFld->setPath("");

  m_fieldIndexFld->setText("");

}

void FileSegmentPage::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 = std::max(0, m_fieldIndexFld->text().toInt() - 1);

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

  KeyframeSetter setter(curve, kIndex);

  setter.setFile(fileParams);

  setter.setUnitName(unitName);

}

void FileSegmentPage::getGuiValues(TDoubleKeyframe::FileParams &fileParam,

                                   std::string &unitName) {

  QString stringPath = m_fileFld->getPath();

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

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

  fileParam.m_fieldIndex = std::max(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();

  if (kIndex < 0) return;

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

  TExpression expr;

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

  expr.setText(expressionText);

  if (!expr.isValid()) {

    DVGui::warning(

        tr("There is a syntax error in the definition of the interpolation."));

    return;

  }

  if (dependsOn(expr, curve)) {

    DVGui::warning(

        tr("There is a circular reference in the definition of the "

           "interpolation."));

    return;

  }

  KeyframeSetter setter(curve, kIndex);

  setter.setSimilarShape(m_expressionFld->getExpression(),

                         m_offsetFld->text().toDouble());

}

void SimilarShapeSegmentPage::getGuiValues(std::string &expressionText,

                                           double &similarShapeOffset) {

  expressionText     = m_expressionFld->getExpression();

  similarShapeOffset = m_offsetFld->text().toDouble();

}

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

FunctionSegmentViewer::FunctionSegmentViewer(QWidget *parent,

                                             FunctionSheet *sheet,

                                             FunctionPanel *panel)