#include "plastictool.h"

// TnzTools includes

#include "tw/keycodes.h" // Obsolete by now... still currently used though

#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_function_types.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 : public DvMimeData {

	PlasticSkeletonP m_skeleton;

public:

	PlasticSkeletonPMime(const PlasticSkeletonP &skeleton)

		: m_skeleton(skeleton) {}

	virtual DvMimeData *clone() const { return new PlasticSkeletonPMime(m_skeleton); }

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

};

struct SkDPMime : public DvMimeData {

	SkDP m_sd;

public:

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

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

	virtual void releaseData() { 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 : 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 { return sizeof(*this); } // sizeof this is roughly ok

	void redo() const

	{

		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

	{

		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 : 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 { return 1 << 20; }

	void redo() const

	{

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

		stageObject()->setPlasticSkeletonDeformation(m_newSd);

		::invalidateXsheet();

	}

	void undo() const

	{

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

	: GenericToolOptionsBox(parent, tool, pltHandle, PlasticTool::MODES_COUNT), 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;

		}

	};

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

	meshifyButton->setFixedHeight(20);

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

	QLabel *distanceLabel = new QLabel(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);

	QLabel *angleLabel = new QLabel(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);

	QLabel *soLabel = new QLabel(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);

	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)()), 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)</int>

{

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

	PlasticToolOptionsBox *optionsBox = new PlasticToolOptionsBox(0, this, currPalette);

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

{

	typedef tcg::function

						  &PlasticTool::updateDeformedSkeleton> Func;

	return m_deformedSkeleton(tcg::bind1st(Func(), *this));

}

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

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

	}

	storeDeformation();

	storeMeshImage();

}

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

void PlasticTool::onXsheetChanged()

{

	onColumnSwitched();

	TTool::updateEnabled(); // Current cell may no longer be a mesh one (or viceversa),

} // so tool enabled status must be updated.

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

void PlasticTool::onChange()

{

	// Since parameters are typically coupled, we could pass multiple, consecutive times in

	// this notification function. We have to employ counter-measures to prevent multiple

	// calls from affecting performance.

	static bool refresh = false; // Accessible from locals since static

	struct locals {

		struct RefreshFunctor : public TFunctorInvoker::BaseFunctor {

			void operator()()