#include "plastictool.h"

// TnzTools includes

#include "tooloptionscontrols.h"

#include "tools/toolcommandids.h"

// TnzQt includes

#include "toonzqt/selection.h"

#include "toonzqt/tselectionhandle.h"

#include "toonzqt/dvmimedata.h"

#include "toonzqt/dvdialog.h"

#include "toonzqt/selectioncommandids.h"

// TnzLib includes

#include "toonz/tframehandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tonionskinmaskhandle.h"

#include "toonz/tstageobject.h"

#include "toonz/doubleparamcmd.h"

#include "toonz/palettecontroller.h"

#include "toonz/txshsimplelevel.h"

// TnzExt includes

#include "ext/plasticskeleton.h"

#include "ext/plasticdeformerstorage.h"

// TnzCore includes

#include "tgl.h"

#include "tundo.h"

#include "tfunctorinvoker.h"

// Qt includes

#include <qapplication></qapplication>

#include <qstring></qstring>

#include <qtoolbar></qtoolbar>

#include <qpushbutton></qpushbutton>

#include <qlabel></qlabel>

#include <qclipboard></qclipboard>

// tcg includes

#include "tcg/tcg_macros.h"

#include "tcg/tcg_point_ops.h"

#include "tcg/tcg_list.h"

#include "tcg/tcg_iterator_ops.h"

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

//    Local namespace

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

namespace {

static const double l_dmax = (std::numeric_limits<double>::max)();</double>

}  // namespace

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

//    PlasticToolLocals namespace

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

using namespace PlasticToolLocals;

namespace PlasticToolLocals {

PlasticTool l_plasticTool;

bool l_suspendParamsObservation = false;

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

TPointD projection(const PlasticSkeleton &skeleton, int e, const TPointD &pos) {

  const PlasticSkeleton::edge_type &ed = skeleton.edge(e);

  const TPointD &p0 = skeleton.vertex(ed.vertex(0)).P();

  const TPointD &p1 = skeleton.vertex(ed.vertex(1)).P();

  return tcg::point_ops::projection(pos, p0, tcg::point_ops::direction(p0, p1));

}

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

double frame() {

  return TTool::getApplication()->getCurrentFrame()->getFrame();

}

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

int row() { return int(frame()) + 1; }

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

int column() {

  return TTool::getApplication()->getCurrentColumn()->getColumnIndex();

}

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

void setCell(int row, int col) {

  TTool::Application *app = TTool::getApplication();

  app->getCurrentFrame()->setCurrentFrame(row);

  app->getCurrentColumn()->setColumnIndex(col);

}

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

TXshColumn *xshColumn() {

  TXsheet *xsh = TTool::getApplication()->getCurrentXsheet()->getXsheet();

  return xsh->getColumn(column());

}

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

TStageObject *stageObject() {

  TXsheet *xsh = TTool::getApplication()->getCurrentXsheet()->getXsheet();

  return xsh->getStageObject(TStageObjectId::ColumnId(column()));

}

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

const TXshCell &xshCell() {

  TXsheet *xsh = TTool::getApplication()->getCurrentXsheet()->getXsheet();

  return xsh->getCell(frame(), column());

}

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

int skeletonId() {

  TStageObject *obj                      = stageObject();

  const PlasticSkeletonDeformationP &def = obj->getPlasticSkeletonDeformation();

  return def ? def->skeletonId(obj->paramsTime(frame()))

             : 1;  // 1 (not -1) is intended.

}  // Means '' (empty string)

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

double sdFrame() { return stageObject()->paramsTime(frame()); }

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

void setKeyframe(TDoubleParamP ¶m, double frame) {

  if (!param->isKeyframe(frame)) {

    KeyframeSetter setter(param.getPointer(), -1,

                          false);  // Not placing undos through this setter

    setter.createKeyframe(frame);

  }

}

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

void setKeyframe(SkVD *vd, double frame) {

  // vd->setKeyframe(frame);                          // Nope. In fact...

  // Keyframe set is performed with a special tool that is NOT AVAILABLE in

  // TnzExt

  // (thus, not available to m_sd). It deals with specifying the correct

  // interpolation

  // type (by user preference, which is TnzLib stuff), etc...

  // Traverse vd's parameters. In case they don't have a keyframe at current

  // frame, add one.

  for (int p = 0; p < SkVD::PARAMS_COUNT; ++p)

    setKeyframe(vd->m_params[p], frame);

}

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

void setKeyframe(const PlasticSkeletonDeformationP &sd, double frame) {

  // NOTE: The skeleton ids parameter is NOT affected

  SkD::vd_iterator vdt, vdEnd;

  sd->vertexDeformations(vdt, vdEnd);

  for (; vdt != vdEnd; ++vdt) setKeyframe((*vdt).second, frame);

}

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

void invalidateXsheet() {

  TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged();

  stageObject()->updateKeyframes();

  l_plasticTool.storeDeformation();

  l_plasticTool.invalidate();

}

}  // namespace PlasticToolLocals

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

//    Mime  definitions

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

struct PlasticSkeletonPMime final : public DvMimeData {

  PlasticSkeletonP m_skeleton;

public:

  PlasticSkeletonPMime(const PlasticSkeletonP &skeleton)

      : m_skeleton(skeleton) {}

  DvMimeData *clone() const override {

    return new PlasticSkeletonPMime(m_skeleton);

  }

  void releaseData() override { m_skeleton = PlasticSkeletonP(); }

};

struct SkDPMime final : public DvMimeData {

  SkDP m_sd;

public:

  SkDPMime(const SkDP &sd) : m_sd(sd) {}

  DvMimeData *clone() const override { return new SkDPMime(m_sd); }

  void releaseData() override { m_sd = SkDP(); }

};

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

//    Undo  definitions

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

// NOTE: Some of the following UNDOs have complex and dynamic contents, and I

// don't want to

//       trace their size thoroughly. So, I'll follow this guideline: given the

//       standard

//       100 MB undos pool, how many undos of one specific type I'd want the

//       pool to be able

//       to store?

namespace {

class SetVertexNameUndo final : public TUndo {

  int m_row, m_col;  //!< Xsheet coordinates

  int m_v;           //!< Changed vertex

public:

  mutable QString m_oldName, m_newName;  //!< Vertex names

  mutable SkVD

      m_oldVd;  //!< Old Vertex deformation (SHARE-OWNED, rather than CLONED)

public:

  SetVertexNameUndo(int v, const QString &newName)

      : m_row(::row()), m_col(::column()), m_v(v), m_newName(newName) {

    const PlasticSkeletonP &skeleton = l_plasticTool.skeleton();

    const PlasticSkeletonVertex &vx  = skeleton->vertex(v);

    m_oldName = vx.name();

  }

  int getSize() const override {

    return sizeof(*this);

  }  // sizeof this is roughly ok

  void redo() const override {

    PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

    // Store the vertex deformation before it's released (possibly destroyed)

    {

      const SkDP &sd = l_plasticTool.deformation();

      TCG_ASSERT(sd, return );

      const SkVD *vd = sd->vertexDeformation(m_oldName);

      TCG_ASSERT(vd, return );

      m_oldVd = *vd;

    }

    if (m_v >= 0) l_plasticTool.setSkeletonSelection(m_v);

    l_plasticTool.setVertexName(m_newName);

    ::invalidateXsheet();

  }

  void undo() const override {

    PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

    const SkDP &sd = l_plasticTool.deformation();

    TCG_ASSERT(sd, return );

    if (m_v >= 0) l_plasticTool.setSkeletonSelection(m_v);

    l_plasticTool.setVertexName(m_oldName);

    // Restore the vertex deformation.

    SkVD *vd = sd->vertexDeformation(m_oldName);

    assert(vd);

    *vd = m_oldVd;

    ::invalidateXsheet();

  }

};

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

class PasteDeformationUndo final : public TUndo {

  int m_col;              //!< Affected column

  SkDP m_oldSd, m_newSd;  //!< The skeleton deformations

public:

  PasteDeformationUndo(const SkDP &newSd)

      : m_col(column())

      , m_oldSd(stageObject()->getPlasticSkeletonDeformation())

      , m_newSd(newSd) {}

  int getSize() const override { return 1 << 20; }

  void redo() const override {

    TTool::getApplication()->getCurrentColumn()->setColumnIndex(m_col);

    stageObject()->setPlasticSkeletonDeformation(m_newSd);

    ::invalidateXsheet();

  }

  void undo() const override {

    TTool::getApplication()->getCurrentColumn()->setColumnIndex(m_col);

    stageObject()->setPlasticSkeletonDeformation(m_oldSd);

    ::invalidateXsheet();

  }

};

}  // namespace

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

//    PlasticTool::TemporaryActivation  implementation

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

PlasticTool::TemporaryActivation::TemporaryActivation(int row, int col)

    : m_activate(!l_plasticTool.isActive()) {

  if (m_activate) l_plasticTool.onActivate();

  ::setCell(row, col);

}

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

PlasticTool::TemporaryActivation::~TemporaryActivation() {

  if (m_activate) l_plasticTool.onDeactivate();

}

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

//    PlasticToolOptionsBox::SkelIdComboBox  definition

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

class PlasticToolOptionsBox::SkelIdsComboBox final : public QComboBox {

public:

  SkelIdsComboBox(QWidget *parent = 0) : QComboBox(parent) {

    updateSkeletonsList();

  }

  void updateSkeletonsList();

  void updateCurrentSkeleton();

};

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

void PlasticToolOptionsBox::SkelIdsComboBox::updateSkeletonsList() {

  clear();

  const SkDP &sd = l_plasticTool.deformation();

  if (!sd) return;

  QStringList skeletonsList;

  SkD::skelId_iterator st, sEnd;

  sd->skeletonIds(st, sEnd);

  for (; st != sEnd; ++st) skeletonsList.push_back(QString::number(*st));

  QComboBox::insertItems(0, skeletonsList);

  updateCurrentSkeleton();

}

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

void PlasticToolOptionsBox::SkelIdsComboBox::updateCurrentSkeleton() {

  setCurrentIndex(findText(QString::number(::skeletonId())));

}

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

//    PlasticToolOptionsBox  implementation

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

PlasticToolOptionsBox::PlasticToolOptionsBox(QWidget *parent, TTool *tool,

                                             TPaletteHandle *pltHandle,

                                             ToolHandle *toolHandle)

    : GenericToolOptionsBox(parent, tool, pltHandle, PlasticTool::MODES_COUNT,

                            toolHandle)

    , m_tool(tool)

    , m_subToolbars(new GenericToolOptionsBox *[PlasticTool::MODES_COUNT])

//, m_subToolbarActions(new QAction*[PlasticTool::MODES_COUNT])

{

  struct locals {

    static inline QWidget *newSpace(QWidget *parent = 0) {

      QWidget *space = new QWidget(parent);

      space->setFixedWidth(TOOL_OPTIONS_LEFT_MARGIN);

      return space;

    }

  };

  setObjectName("toolOptionsPanel");

  // Create Mesh button

  QPushButton *meshifyButton = new QPushButton(tr("Create Mesh"));

  // Add skeleton id-related widgets

  QLabel *skelIdLabel = new QLabel(tr("Skeleton:"));

  m_skelIdComboBox    = new SkelIdsComboBox;

  m_addSkelButton     = new QPushButton("+");  // Connected in the show event

  m_removeSkelButton  = new QPushButton("-");  // Connected in the show event

  // Add sub-options for each mode group

  for (int m = 0; m != PlasticTool::MODES_COUNT; ++m)

    m_subToolbars[m] =

        new GenericToolOptionsBox(0, tool, pltHandle, m, 0, false);

  meshifyButton->setFixedHeight(20);

  int buttonWidth = fontMetrics().width(meshifyButton->text()) + 20;

  meshifyButton->setFixedWidth(buttonWidth);

  QAction *meshifyAction =

      CommandManager::instance()->getAction("A_ToolOption_Meshify");

  meshifyButton->addAction(meshifyAction);

  skelIdLabel->setFixedHeight(20);

  m_skelIdComboBox->setFixedWidth(50);

  m_addSkelButton->setFixedSize(20, 20);

  m_removeSkelButton->setFixedSize(20, 20);

  for (int m = 0; m != PlasticTool::MODES_COUNT; ++m)

    m_subToolbars[m]->setContentsMargins(0, 0, 0, 0);

  /*- Layout -*/

  // Add created widgets to the toolbar (in reverse order since we're inserting

  // at 0)

  m_layout->insertWidget(0, m_removeSkelButton);

  m_layout->insertWidget(0, m_addSkelButton);

  m_layout->insertWidget(0, m_skelIdComboBox);

  m_layout->insertWidget(0, skelIdLabel);

  m_layout->insertWidget(0, locals::newSpace(this));

  m_layout->insertWidget(0, meshifyButton);

  m_layout->insertWidget(0, locals::newSpace(this));

  for (int m = 0; m != PlasticTool::MODES_COUNT; ++m)

    m_layout->insertWidget(m_layout->count() - 1, m_subToolbars[m], 1);

  bool ret = true;

  ret      = ret && connect(meshifyButton, SIGNAL(clicked()), meshifyAction,

                       SLOT(trigger()));

  assert(ret);

  // Add Animation mode fields corresponding to vertex properties

  GenericToolOptionsBox *animateOptionsBox =

      m_subToolbars[PlasticTool::ANIMATE_IDX];

  // Adjust some specific controls first

  {

    ToolOptionTextField *minAngleField = static_cast<tooloptiontextfield *="">(</tooloptiontextfield>

        animateOptionsBox->control("minAngle"));

    assert(minAngleField);

    minAngleField->setFixedWidth(40);

    ToolOptionTextField *maxAngleField = static_cast<tooloptiontextfield *="">(</tooloptiontextfield>

        animateOptionsBox->control("maxAngle"));

    assert(maxAngleField);

    maxAngleField->setFixedWidth(40);

  }

  // Distance

  ToolOptionParamRelayField *distanceField = new ToolOptionParamRelayField(

      &l_plasticTool, &l_plasticTool.m_distanceRelay);

  distanceField->setGlobalKey(&l_plasticTool.m_globalKey,

                              &l_plasticTool.m_relayGroup);

  ClickableLabel *distanceLabel = new ClickableLabel(tr("Distance"));

  distanceLabel->setFixedHeight(20);

  // Angle

  ToolOptionParamRelayField *angleField = new ToolOptionParamRelayField(

      &l_plasticTool, &l_plasticTool.m_angleRelay);

  angleField->setGlobalKey(&l_plasticTool.m_globalKey,

                           &l_plasticTool.m_relayGroup);

  ClickableLabel *angleLabel = new ClickableLabel(tr("Angle"));

  angleLabel->setFixedHeight(20);

  // SO

  ToolOptionParamRelayField *soField =

      new ToolOptionParamRelayField(&l_plasticTool, &l_plasticTool.m_soRelay);

  soField->setGlobalKey(&l_plasticTool.m_globalKey,

                        &l_plasticTool.m_relayGroup);

  ClickableLabel *soLabel = new ClickableLabel(tr("SO"));

  soLabel->setFixedHeight(20);

  QHBoxLayout *animateLayout = animateOptionsBox->hLayout();

  animateLayout->insertWidget(0, soField);

  animateLayout->insertWidget(0, soLabel);

  animateLayout->insertWidget(0, angleField);

  animateLayout->insertWidget(0, angleLabel);

  animateLayout->insertWidget(0, distanceField);

  animateLayout->insertWidget(0, distanceLabel);

  ret = ret && connect(distanceLabel, SIGNAL(onMousePress(QMouseEvent *)),

                       distanceField, SLOT(receiveMousePress(QMouseEvent *)));

  ret = ret && connect(distanceLabel, SIGNAL(onMouseMove(QMouseEvent *)),

                       distanceField, SLOT(receiveMouseMove(QMouseEvent *)));

  ret = ret && connect(distanceLabel, SIGNAL(onMouseRelease(QMouseEvent *)),

                       distanceField, SLOT(receiveMouseRelease(QMouseEvent *)));

  ret = ret && connect(angleLabel, SIGNAL(onMousePress(QMouseEvent *)),

                       angleField, SLOT(receiveMousePress(QMouseEvent *)));

  ret = ret && connect(angleLabel, SIGNAL(onMouseMove(QMouseEvent *)),

                       angleField, SLOT(receiveMouseMove(QMouseEvent *)));

  ret = ret && connect(angleLabel, SIGNAL(onMouseRelease(QMouseEvent *)),

                       angleField, SLOT(receiveMouseRelease(QMouseEvent *)));

  ret = ret && connect(soLabel, SIGNAL(onMousePress(QMouseEvent *)), soField,

                       SLOT(receiveMousePress(QMouseEvent *)));

  ret = ret && connect(soLabel, SIGNAL(onMouseMove(QMouseEvent *)), soField,

                       SLOT(receiveMouseMove(QMouseEvent *)));

  ret = ret && connect(soLabel, SIGNAL(onMouseRelease(QMouseEvent *)), soField,

                       SLOT(receiveMouseRelease(QMouseEvent *)));

  assert(ret);

  onPropertyChanged();

}

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

void PlasticToolOptionsBox::showEvent(QShowEvent *se) {

  bool ret = true;

  ret = ret && connect(&l_plasticTool, SIGNAL(skelIdsListChanged()),

                       SLOT(onSkelIdsListChanged()));

  ret = ret && connect(&l_plasticTool, SIGNAL(skelIdChanged()),

                       SLOT(onSkelIdChanged()));

  ret = ret && connect(m_skelIdComboBox, SIGNAL(activated(int)),

                       SLOT(onSkelIdEdited()));

  ret = ret &&

        connect(m_addSkelButton, SIGNAL(released()), SLOT(onAddSkeleton()));

  ret = ret && connect(m_removeSkelButton, SIGNAL(released()),

                       SLOT(onRemoveSkeleton()));

  assert(ret);

  m_skelIdComboBox->updateSkeletonsList();

}

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

void PlasticToolOptionsBox::hideEvent(QHideEvent *he) {

  disconnect(&l_plasticTool, 0, this, 0);

  disconnect(m_skelIdComboBox, 0, this, 0);

  disconnect(m_addSkelButton, 0, this, 0);

  disconnect(m_removeSkelButton, 0, this, 0);

}

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

void PlasticToolOptionsBox::onPropertyChanged() {

  // Fetch current mode index

  TPropertyGroup *pGroup = m_tool->getProperties(PlasticTool::MODES_COUNT);

  assert(pGroup);

  TEnumProperty *prop =

      dynamic_cast<tenumproperty *="">(pGroup->getProperty("mode"));</tenumproperty>

  assert(prop);

  int mode = prop->getIndex();

  // Show the specified mode options, hide all the others

  for (int m = 0; m != PlasticTool::MODES_COUNT; ++m)

    m_subToolbars[m]->setVisible(m == mode);

}

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

void PlasticToolOptionsBox::onSkelIdsListChanged() {

  m_skelIdComboBox->updateSkeletonsList();

}

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

void PlasticToolOptionsBox::onSkelIdChanged() {

  m_skelIdComboBox->updateCurrentSkeleton();

}

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

void PlasticToolOptionsBox::onSkelIdEdited() {

  int skelId = m_skelIdComboBox->currentText().toInt();

  if (skelId == ::skeletonId()) return;

  if (!l_plasticTool.deformation()) return;

  l_plasticTool.editSkelId_undo(skelId);

}

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

void PlasticToolOptionsBox::onAddSkeleton() {

  if (l_plasticTool.isEnabled())

    l_plasticTool.addSkeleton_undo(new PlasticSkeleton);

}

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

void PlasticToolOptionsBox::onRemoveSkeleton() {

  if (l_plasticTool.isEnabled() && l_plasticTool.deformation())

    l_plasticTool.removeSkeleton_withKeyframes_undo(::skeletonId());

}

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

//    PlasticTool  implementation

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

PlasticTool::PlasticTool()

    : TTool(T_Plastic)

    , m_skelId(-(std::numeric_limits<int>::max)())</int>

    , m_propGroup(new TPropertyGroup[MODES_COUNT + 1])

    , m_mode("mode")

    , m_vertexName("vertexName", L"")

    , m_interpolate("interpolate", false)

    , m_snapToMesh("snapToMesh", false)

    , m_thickness("Thickness", 1, 100, 5)

    , m_rigidValue("rigidValue")

    , m_globalKey("globalKeyframe", true)

    , m_keepDistance("keepDistance", true)

    , m_minAngle("minAngle", L"")

    , m_maxAngle("maxAngle", L"")

    , m_distanceRelay("distanceRelay")

    , m_angleRelay("angleRelay")

    , m_soRelay("soRelay")

    , m_skelIdRelay("skelIdRelay")

    , m_pressedPos(TConsts::napd)

    , m_dragged(false)

    , m_svHigh(-1)

    , m_seHigh(-1)

    , m_mvHigh(-1)

    , m_meHigh(-1)

    , m_rigidityPainter(createRigidityPainter())

    , m_showSkeletonOS(true)

    , m_recompileOnMouseRelease(false) {

  // And now, a little trick about tool binding

  bind(TTool::AllImages);   // Attach the tool to all types :)

  bind(TTool::MeshLevels);  // But disable it for all but meshes :0

  // This little trick is needed to associate the tool to common levels (the

  // toolbar must appear), in

  // order to make them meshable.

  // Bind properties to the appropriate property group (needed by the automatic

  // toolbar builder)

  m_propGroup[MODES_COUNT].bind(m_mode);

  m_propGroup[MODES_COUNT].bind(m_vertexName);

  m_propGroup[RIGIDITY_IDX].bind(m_thickness);

  m_propGroup[RIGIDITY_IDX].bind(m_rigidValue);

  m_propGroup[BUILD_IDX].bind(m_interpolate);

  m_propGroup[BUILD_IDX].bind(m_snapToMesh);

  m_propGroup[ANIMATE_IDX].bind(m_globalKey);

  m_propGroup[ANIMATE_IDX].bind(m_keepDistance);

  m_propGroup[ANIMATE_IDX].bind(m_minAngle);

  m_propGroup[ANIMATE_IDX].bind(m_maxAngle);

  m_relayGroup.bind(m_distanceRelay);

  m_relayGroup.bind(m_angleRelay);

  m_relayGroup.bind(m_soRelay);

  m_mode.setId("SkeletonMode");

  m_vertexName.setId("VertexName");

  m_interpolate.setId("Interpolate");

  m_snapToMesh.setId("SnapToMesh");

  m_thickness.setId("Thickness");

  m_rigidValue.setId("RigidValue");

  m_globalKey.setId("GlobalKey");

  m_keepDistance.setId("KeepDistance");

  m_minAngle.setId("MinAngle");

  m_maxAngle.setId("MaxAngle");

  m_distanceRelay.setId("DistanceRelay");

  m_angleRelay.setId("AngleRelay");

  m_soRelay.setId("SoRelay");

  m_skelIdRelay.setId("SkelIdRelay");

  // Attach to selections

  m_svSel.setView(this);

  m_mvSel.setView(this), m_meSel.setView(this);

}

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

PlasticTool::~PlasticTool() {

  if (m_sd) m_sd->removeObserver(this);

}

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

TTool::ToolType PlasticTool::getToolType() const {

  switch (m_mode.getIndex()) {

  case MESH_IDX:

  case RIGIDITY_IDX:

    return TTool::LevelWriteTool;

  case BUILD_IDX:

  case ANIMATE_IDX:

    return TTool::ColumnTool;

  }

  assert(false);

  return TTool::GenericTool;

}

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

void PlasticTool::updateTranslation() {

  m_mode.setQStringName(tr("Mode:"));

  m_mode.deleteAllValues();

  m_mode.addValue(tr("Edit Mesh").toStdWString());

  m_mode.addValue(tr("Paint Rigid").toStdWString());

  m_mode.addValue(tr("Build Skeleton").toStdWString());

  m_mode.addValue(tr("Animate").toStdWString());

  m_mode.setIndex(BUILD_IDX);

  m_vertexName.setQStringName(tr("Vertex Name:"));

  m_interpolate.setQStringName(tr("Allow Stretching"));

  m_snapToMesh.setQStringName(tr("Snap To Mesh"));

  m_thickness.setQStringName(tr("Thickness"));

  m_rigidValue.setQStringName("");

  m_rigidValue.deleteAllValues();

  m_rigidValue.addValue(tr("Rigid").toStdWString());

  m_rigidValue.addValue(tr("Flex").toStdWString());

  m_globalKey.setQStringName(tr("Global Key"));

  m_keepDistance.setQStringName(tr("Keep Distance"));

  m_minAngle.setQStringName(tr("Angle Bounds"));

  m_maxAngle.setQStringName("");

}

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

ToolOptionsBox *PlasticTool::createOptionsBox() {

  // Create the options box

  TPaletteHandle *currPalette =

      TTool::getApplication()->getPaletteController()->getCurrentLevelPalette();

  ToolHandle *currTool = m_application->getCurrentTool();

  PlasticToolOptionsBox *optionsBox =

      new PlasticToolOptionsBox(0, this, currPalette, currTool);

  // Connect it to receive m_mode notifications

  m_mode.addListener(optionsBox);

  return optionsBox;

}

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

PlasticSkeletonP PlasticTool::skeleton() const {

  return m_sd ? m_sd->skeleton(::sdFrame()) : PlasticSkeletonP();

}

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

PlasticSkeleton &PlasticTool::deformedSkeleton() {

  return m_deformedSkeleton([this](PlasticSkeleton &deformedSkeleton) {

    updateDeformedSkeleton(deformedSkeleton);

  });

}

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

void PlasticTool::touchSkeleton() {

  touchDeformation();

  int skelId = ::skeletonId();

  if (!m_sd->skeleton(skelId)) {

    m_sd->attach(skelId, new PlasticSkeleton);

    emit skelIdsListChanged();

  }

}

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

void PlasticTool::touchDeformation() {

  if (m_sd) return;

  // Store a new deformation in the column's stage object

  stageObject()->setPlasticSkeletonDeformation(new PlasticSkeletonDeformation);

  storeDeformation();  // Builds the deformed skeleton too

}

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

void PlasticTool::storeDeformation() {

  const SkDP &sd = stageObject()->getPlasticSkeletonDeformation();

  if (m_sd != sd) {

    clearSkeletonSelections();

    if (m_sd) {

      m_sd->removeObserver(this);

      m_skelIdRelay.setParam(TDoubleParamP());

    }

    // Store the deformation, retrieving it from current column stage object

    m_sd = sd;

    if (m_sd) {

      m_sd->addObserver(this);

      m_skelIdRelay.setParam(m_sd->skeletonIdsParam());

    }

    m_skelIdRelay.notifyListeners();

  }

  storeSkeletonId();

  if (m_mode.getIndex() == ANIMATE_IDX)

    m_deformedSkeleton.invalidate();  // Store the deformed skeleton too

  emit skelIdsListChanged();

}

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

void PlasticTool::storeSkeletonId() {

  int skelId = m_sd ? m_sd->skeletonIdsParam()->getValue(::sdFrame())

                    : -(std::numeric_limits<int>::max)();</int>

  if (m_skelId != skelId) {

    m_skelId = skelId;

    clearSkeletonSelections();

    emit skelIdChanged();

  }

}

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

void PlasticTool::updateDeformedSkeleton(PlasticSkeleton &deformedSkeleton) {

  if (m_sd)

    m_sd->storeDeformedSkeleton(::skeletonId(), ::sdFrame(), deformedSkeleton);

  else

    deformedSkeleton.clear();

}

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

void PlasticTool::onFrameSwitched() {

  storeSkeletonId();

  storeMeshImage();

  switch (m_mode.getIndex()) {

  case ANIMATE_IDX:

    m_deformedSkeleton.invalidate();

  }

  // Update the relays' current frame

  double frame = ::sdFrame();

  m_distanceRelay.frame() = frame;

  m_angleRelay.frame()    = frame;

  m_soRelay.frame()       = frame;

  m_skelIdRelay.frame()   = frame;

  m_distanceRelay.notifyListeners();

  m_angleRelay.notifyListeners();

  m_soRelay.notifyListeners();

  m_skelIdRelay.notifyListeners();

}

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

void PlasticTool::onColumnSwitched() {

  switch (m_mode.getIndex()) {

  case MESH_IDX:

  case BUILD_IDX:

  case RIGIDITY_IDX:

    m_pvs.m_showOriginalColumn = xshColumn();