// TnzCore includes

#include "tundo.h"

// TnzExt includes

#include "ext/plasticdeformerstorage.h"

// TnzLib includes

#include "toonz/txshcell.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txsheethandle.h"

#include "toonz/stage.h"

// tcg includes

#include "tcg/tcg_point_ops.h"

#include "tcg/tcg_algorithm.h"

#include "tcg/tcg_function_types.h"

#include "tcg/tcg_iterator_ops.h"

#include "plastictool.h"

using namespace PlasticToolLocals;

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

//    Local namespace  stuff

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

namespace

{

TPointD closestMeshVertexPos(const TPointD &pos, double *distance = 0)

{

	const TXshCell &imageCell = TTool::getImageCell();

	TXshSimpleLevel *sl = imageCell.getSimpleLevel();

	assert(sl);

	TMeshImageP mi(TTool::getImage(false));

	assert(mi);

	// Retrieve *level* dpi

	// NOTE: This is different than current IMAGE's dpi. An image is actually displayed with

	//       its level owner's dpi, RATHER than its own.

	const TPointD &dpi = sl->getDpi(imageCell.getFrameId());

	assert(dpi.x > 0.0 && dpi.y > 0.0);

	// Cast pos to image coordinates

	const TPointD pos_mesh(pos.x * (dpi.x / Stage::inch), pos.y * (dpi.y / Stage::inch));

	// Retrieve the closest vertex to pos_mesh

	const std::pair<double, plastictool::meshindex=""> &closest =</double,>

		PlasticToolLocals::closestVertex(*mi, pos_mesh);

	const TPointD &vxPos_mesh = mi->meshes()[closest.second.m_meshIdx]->vertex(closest.second.m_idx).P();

	if (distance)

		*distance = tmin(Stage::inch / dpi.x, Stage::inch / dpi.y) * closest.first;

	// Cast it back to world coordinates

	return TPointD(vxPos_mesh.x * (Stage::inch / dpi.x), vxPos_mesh.y * (Stage::inch / dpi.y));

}

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

TPointD closestSkeletonVertexPos(const TPointD &pos)

{

	struct locals {

		static inline double dist2(const TPointD &pos, const PlasticSkeletonVertex &vx)

		{

			return tcg::point_ops::dist2(pos, vx.P());

		}

	};

	const PlasticSkeletonP &skeleton = l_plasticTool.skeleton();

	if (!skeleton || skeleton->empty())

		return TConsts::napd;

	const PlasticSkeleton::vertices_container &vertices = skeleton->vertices();

	return tcg::min_transform(vertices.begin(), vertices.end(),

							  tcg::bind1st(&locals::dist2, pos))

		->P();

}

} // namespace

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

//    Undo  definitions

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

namespace

{

class VertexUndo : public TUndo

{

protected:

	int m_row, m_col; //!< Xsheet coordinates

	int m_v, m_vParent;			//!< Indices of the added vertex and its parent

	PlasticSkeletonVertex m_vx; //!< Added vertex

	std::vector<int> m_children; //!< Children of the vertex to insert</int>

public:

	VertexUndo() : m_row(::row()), m_col(::column()), m_v(-1), m_vParent(-1) {}

	int getSize() const { return sizeof(*this); } // sizeof this is roughly ok

	void storeChildren(const PlasticSkeleton &skeleton, const PlasticSkeletonVertex &vx)

	{

		m_children.clear();

		// Traverse vx's edges and build its children table

		PlasticSkeletonVertex::edges_const_iterator et, eEnd(vx.edgesEnd());

		for (et = vx.edgesBegin(); et != eEnd; ++et) {

			int vChild = skeleton.edge(*et).vertex(1);

			if (vChild == vx.getIndex())

				continue;

			m_children.push_back(vChild);

		}

	}

	void addVertex()

	{

		assert(m_vx.edges().empty());

		// Load the right skeleton by moving to the stored xsheet pos

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		const PlasticSkeletonP &skeleton = l_plasticTool.skeleton();

		TCG_ASSERT(skeleton || m_vParent < 0, return );

		// Perform addition

		l_plasticTool.setSkeletonSelection(m_vParent);

		l_plasticTool.addVertex(m_vx);

		// Store data to invert the operation

		assert(l_plasticTool.skeletonVertexSelection().hasSingleObject());

		m_v = l_plasticTool.skeletonVertexSelection();

	}

	void insertVertex()

	{

		if (m_children.empty()) {

			addVertex();

			return;

		}

		assert(m_vx.edges().empty());

		TCG_ASSERT(m_vParent >= 0, return );

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		const PlasticSkeletonP &skeleton = l_plasticTool.skeleton();

		TCG_ASSERT(skeleton, return );

		// Perform insertion

		l_plasticTool.insertVertex(m_vx, m_vParent, m_children);

		// Store data to invert the operation

		assert(l_plasticTool.skeletonVertexSelection().hasSingleObject());

		m_v = l_plasticTool.skeletonVertexSelection();

	}

	void removeVertex()

	{

		TCG_ASSERT(m_v >= 0, return );

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		const PlasticSkeletonP &skeleton = l_plasticTool.skeleton();

		TCG_ASSERT(skeleton, return );

		// Store data to invert the operation

		{

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

			m_vParent = vx.parent();

			m_vx = PlasticSkeletonVertex(vx.P());

			storeChildren(*skeleton, vx);

		}

		// Perform removal

		if (m_v > 0) {

			l_plasticTool.setSkeletonSelection(m_v);

			l_plasticTool.removeVertex();

		} else

			l_plasticTool.removeSkeleton(::skeletonId());

	}

};

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

class AddVertexUndo : public VertexUndo

{

public:

	AddVertexUndo(int vParent, const PlasticSkeletonVertex &vx)

	{

		m_vParent = vParent, m_vx = vx;

		assert(m_vx.edges().empty());

	}

	void redo() const { const_cast<addvertexundo &="">(*this).VertexUndo::addVertex(); }</addvertexundo>

	void undo() const { const_cast<addvertexundo &="">(*this).VertexUndo::removeVertex(); }</addvertexundo>

};

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

class RemoveVertexUndo : public VertexUndo

{

public:

	RemoveVertexUndo(int v)

	{

		assert(v >= 0);

		m_v = v;

	}

	void redo() const { const_cast<removevertexundo &="">(*this).VertexUndo::removeVertex(); }</removevertexundo>

	void undo() const { const_cast<removevertexundo &="">(*this).VertexUndo::insertVertex(); }</removevertexundo>

};

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

class InsertVertexUndo : public VertexUndo

{

public:

	InsertVertexUndo(int e, const PlasticSkeletonVertex &vx)

	{

		const PlasticSkeleton &skeleton = *l_plasticTool.skeleton();

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

		m_vParent = ed.vertex(0), m_vx = vx;

		std::vector<int>(1, ed.vertex(1)).swap(m_children);</int>

	}

	void redo() const

	{

		const_cast<insertvertexundo &="">(*this).VertexUndo::insertVertex();</insertvertexundo>

	}

	void undo() const

	{

		TCG_ASSERT(!m_children.empty(), return );

		const_cast<insertvertexundo &="">(*this).VertexUndo::removeVertex();</insertvertexundo>

	}

};

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

class AddSkeletonUndo : public TUndo

{

protected:

	int m_row, m_col; //!< Xsheet coordinates

	int m_skelId;				 //!< The added skeleton's id

	PlasticSkeletonP m_skeleton; //!< A COPY of the added skeleton

public:

	AddSkeletonUndo(int skelId, const PlasticSkeletonP &skeletonCopy)

		: m_row(::row()), m_col(::column()), m_skelId(skelId), m_skeleton(skeletonCopy) {}

	// This is not correct... it's tough to build the right one! We're like storing the whole

	// cleared deformation! So, I guess 1 MB (100 of these in the standard undos pool)

	// is a reasonable estimate...

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

	void redo() const

	{

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		l_plasticTool.addSkeleton(m_skelId, new PlasticSkeleton(*m_skeleton));

		::invalidateXsheet();

	}

	void undo() const

	{

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		l_plasticTool.removeSkeleton(m_skelId);

	}

};

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

class RemoveSkeletonUndo : public AddSkeletonUndo

{

public:

	RemoveSkeletonUndo(int skelId) : AddSkeletonUndo(skelId, l_plasticTool.skeleton()) {}

	void redo() const { AddSkeletonUndo::undo(); }

	void undo() const { AddSkeletonUndo::redo(); }

};

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

class RemoveSkeletonUndo_WithKeyframes : public RemoveSkeletonUndo

{

	mutable std::vector<tdoublekeyframe> m_skelIdsKeyframes; //!< Skeleton Ids param curve keyframes</tdoublekeyframe>

															 //!< for m_skelId

public:

	RemoveSkeletonUndo_WithKeyframes(int skelId) : RemoveSkeletonUndo(skelId) {}

	void redo() const

	{

		// Erase all keyframes corresponding to m_skelId from sd's skeleton ids curve

		const SkDP &sd = l_plasticTool.deformation();

		TCG_ASSERT(sd, return );

		const TDoubleParamP &skelIdsParam = sd->skeletonIdsParam();

		if (skelIdsParam->getKeyframeCount() > 0) {

			double frame;

			for (int k = 0; k >= 0; k = skelIdsParam->getNextKeyframe(frame)) {

				const TDoubleKeyframe &kf = skelIdsParam->getKeyframe(k);

				frame = kf.m_frame;

				if (m_skelId == (int)kf.m_value) {

					m_skelIdsKeyframes.push_back(kf);

					skelIdsParam->deleteKeyframe(frame);

				}

			}

		}

		RemoveSkeletonUndo::redo(); // Invalidates the xsheet

	}

	void undo() const

	{

		l_plasticTool.touchDeformation(); // Skeleton removal could have destroyed the sd

		// Restore saved keyframes to sd's skelIdsParam curve

		const SkDP &sd = l_plasticTool.deformation();

		assert(sd);

		const TDoubleParamP &skelIdsParam = sd->skeletonIdsParam();

		std::vector<tdoublekeyframe>::iterator kt, kEnd(m_skelIdsKeyframes.end());</tdoublekeyframe>

		for (kt = m_skelIdsKeyframes.begin(); kt != kEnd; ++kt)

			skelIdsParam->setKeyframe(*kt);

		m_skelIdsKeyframes.clear();

		RemoveSkeletonUndo::undo(); // Invalidates the xsheet

	}

};

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

class SetSkeletonIdUndo : public TUndo

{

	int m_row, m_col; //!< Xsheet coordinates

	int m_skelId;					 //!< The new skeleton id value

	mutable TDoubleKeyframe m_oldKf; //!< Old keyframe values for skelIds parameter

	mutable bool m_added1stKeyframe; //!< Whether the redo() added the first skelIds keyframe

public:

	SetSkeletonIdUndo(int skelId)

		: m_row(::row()), m_col(::column()), m_skelId(skelId) {}

	int getSize() const { return sizeof(*this); }

	void redo() const

	{

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		const SkDP &sd = l_plasticTool.deformation();

		TCG_ASSERT(sd, return );

		const TDoubleParamP &skelIdsParam = sd->skeletonIdsParam();

		double frame = ::frame();

		m_oldKf = skelIdsParam->getKeyframeAt(frame);

		m_added1stKeyframe = false;

		if (frame > 0.0 && (skelIdsParam->getKeyframeCount() == 0 ||

							skelIdsParam->getKeyframe(0).m_frame >= frame)) {

			// Put a keyframe at the previous cell to preserve values before current frame

			TDoubleKeyframe kf(frame - 1.0, skelIdsParam->getDefaultValue());

			kf.m_type = TDoubleKeyframe::Constant;

			skelIdsParam->setKeyframe(kf);

			m_added1stKeyframe = true;

		}

		TDoubleKeyframe kf(frame, m_skelId);

		kf.m_type = TDoubleKeyframe::Constant;

		skelIdsParam->setKeyframe(kf);

		// No need to invoke PlasticTool::storeSkeletonId() - automatic through onChange()

	}

	void undo() const

	{

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		const SkDP &sd = l_plasticTool.deformation();

		TCG_ASSERT(sd, return );

		const TDoubleParamP &skelIdsParam = sd->skeletonIdsParam();

		if (m_oldKf.m_isKeyframe)

			skelIdsParam->setKeyframe(m_oldKf);

		else

			skelIdsParam->deleteKeyframe(m_oldKf.m_frame);

		if (m_added1stKeyframe) {

			const TDoubleKeyframe &kf = skelIdsParam->getKeyframe(0);

			assert(kf.m_value == skelIdsParam->getDefaultValue());

			if (kf.m_value == skelIdsParam->getDefaultValue())

				skelIdsParam->deleteKeyframe(kf.m_frame);

		}

	}

};

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

class MoveVertexUndo_Build : public TUndo

{

	int m_row, m_col; //!< Xsheet coordinates

	std::vector<int> m_vIdxs;		   //!< Moved vertices</int>

	std::vector<tpointd> m_origVxsPos; //!< Original vertex positions</tpointd>

	TPointD m_posShift;				   //!< Vertex positions shift

public:

	MoveVertexUndo_Build(

		const std::vector<int> &vIdxs,</int>

		const std::vector<tpointd> &origVxsPos,</tpointd>

		const TPointD &posShift)

		: m_row(::row()), m_col(::column()), m_vIdxs(vIdxs), m_origVxsPos(origVxsPos), m_posShift(posShift)

	{

		assert(m_vIdxs.size() == m_origVxsPos.size());

	}

	int getSize() const { return int(sizeof(*this) + m_vIdxs.size() * (sizeof(int) + 2 * sizeof(TPointD))); }

	void redo() const

	{

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		l_plasticTool.setSkeletonSelection(m_vIdxs);

		l_plasticTool.moveVertex_build(m_origVxsPos, m_posShift);

		::stageObject()->invalidate(); // Should be a TStageObject's implementation detail ...

		l_plasticTool.invalidate();

	}

	void undo() const

	{

		PlasticTool::TemporaryActivation tempActivate(m_row, m_col);

		l_plasticTool.setSkeletonSelection(m_vIdxs);

		l_plasticTool.moveVertex_build(m_origVxsPos, TPointD());

		::stageObject()->invalidate(); // Should be a TStageObject's implementation detail ...

		l_plasticTool.invalidate();

	}

};

} // namespace

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

//    PlasticTool  functions

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

void PlasticTool::mouseMove_build(const TPointD &pos, const TMouseEvent &me)

{

	// Track mouse position

	m_pos = pos; // Needs to be done now - ensures m_pos is valid

	m_svHigh = m_seHigh = -1; // Reset highlighted primitives

	double d, highlightRadius = getPixelSize() * HIGHLIGHT_DISTANCE;

	const PlasticSkeletonP &skeleton = this->skeleton();

	if (skeleton) {

		// Search nearest skeleton entities

		// Look for nearest vertex

		int v = skeleton->closestVertex(pos, &d);

		if (v >= 0 && d < highlightRadius)

			m_svHigh = v;

		else {

			// Look for nearest edge

			int e = skeleton->closestEdge(pos, &d);

			if (e >= 0 && d < highlightRadius)

				m_seHigh = e;

		}

	}

	if (m_svHigh < 0 && m_seHigh < 0) {

		// No highlighted skeleton primitive. Mouse position may be

		// a candidate for vertex addition - snap to mesh if required

		if (m_snapToMesh.getValue()) {

			const TPointD &mvPos = ::closestMeshVertexPos(pos, &d); // No need to check against closest skeleton vertex,

																	// since vertex highlighting kicks in at the same time

			if (d < highlightRadius)								// the snapping would take place.

				m_pos = mvPos;

		}

	}

	invalidate();

}

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

void PlasticTool::leftButtonDown_build(const TPointD &pos, const TMouseEvent &me)

{

	// Track mouse position

	m_pressedPos = m_pos = pos;

	// Update selections

	{

		const PlasticSkeletonP &skel = skeleton();

		if (m_svHigh >= 0) {

			PlasticVertexSelection vSel(me.isShiftPressed() ? PlasticVertexSelection(branchSelection(m_svHigh)) : PlasticVertexSelection(m_svHigh));

			if (me.isCtrlPressed())

				toggleSkeletonSelection(vSel);

			else if (!m_svSel.contains(vSel))

				setSkeletonSelection(vSel);

		} else if (m_seHigh >= 0) {

			// Insert a vertex in the edge

			TUndo *op = new InsertVertexUndo(m_seHigh, PlasticSkeletonVertex(

														   projection(*skel, m_seHigh, m_pos)));

			TUndoManager::manager()->add(op);

			op->redo();

		} else if (!skel || skel->empty() || m_svSel.hasSingleObject()) {

			// Snap to mesh if required

			if (m_snapToMesh.getValue()) {

				double d, highlightRadius = getPixelSize() * HIGHLIGHT_DISTANCE;

				const TPointD &mvPos = ::closestMeshVertexPos(pos, &d); // Again, no need to check against closest

																		// skeleton vertex.

				if (d < highlightRadius)

					m_pos = mvPos;

			}

			// Add a new vertex

			TUndo *op = new AddVertexUndo(m_svSel, PlasticSkeletonVertex(m_pos));

			TUndoManager::manager()->add(op);

			op->redo();

			assert(skeleton());

		} else

			setSkeletonSelection(-1);

	}

	// Start move vertex operation

	if (!m_svSel.isEmpty()) {

		struct locals {

			static TPointD vertexPos(const PlasticSkeleton &skel, int v)

			{

				return skel.vertex(v).P();

			}

		};

		const PlasticSkeletonP &skel = skeleton();

		assert(skel);

		// Adjust mouse press to the selected skeleton vertex, if necessary

		if (m_svSel.hasSingleObject())

			m_pressedPos = skel->vertex(m_svSel).P();

		// Store original vertex positions

		m_pressedVxsPos = std::vector<tpointd>(</tpointd>

			tcg::make_cast_it(m_svSel.objects().begin(), tcg::bind1st(&locals::vertexPos, *skel)),

			tcg::make_cast_it(m_svSel.objects().end(), tcg::bind1st(&locals::vertexPos, *skel)));

	}

	invalidate();

}

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

void PlasticTool::leftButtonDrag_build(const TPointD &pos, const TMouseEvent &me)

{

	// Track mouse position

	if (m_snapToMesh.getValue()) {

		const TPointD &mvPos = ::closestMeshVertexPos(pos),

					  &svPos = ::closestSkeletonVertexPos(mvPos);

		if (tcg::point_ops::dist(mvPos, svPos) > getPixelSize()) // 1) If said distance is sub-pixel, the user

			m_pos = mvPos;										 //    just cannot see the assignment - so it's not safe.

	}															 // 2) The moveVertex_build() below manipulates m_pos

	else														 //    (not how m_pressedPos is subtracted), so !=

		m_pos = pos;											 //    is not a choice.

	moveVertex_build(m_pressedVxsPos, m_pos - m_pressedPos);

	invalidate();

}

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

void PlasticTool::leftButtonUp_build(const TPointD &pos, const TMouseEvent &me)

{

	// Track mouse position

	if (m_snapToMesh.getValue()) {

		const TPointD &mvPos = ::closestMeshVertexPos(pos),

					  &svPos = ::closestSkeletonVertexPos(mvPos);

		if (tcg::point_ops::dist(mvPos, svPos) > getPixelSize()) // Same as above

			m_pos = mvPos;

	} else

		m_pos = pos;

	if (!m_svSel.isEmpty() && m_dragged) {

		TUndoManager::manager()->add(new MoveVertexUndo_Build(

			m_svSel.objects(), m_pressedVxsPos, m_pos - m_pressedPos));

		::stageObject()->invalidate(); // Should be a TStageObject's implementation detail ...

		invalidate();				   // .. it's that it caches placement data and we must

	}								   // invalidate it. Gross. Can't we do anything about it?

}

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

void PlasticTool::addContextMenuActions_build(QMenu *menu)

{

	bool ret = true;

	if (!m_svSel.isEmpty()) {

		QAction *deleteVertex = menu->addAction(tr("Delete Vertex"));

		ret = ret && connect(deleteVertex, SIGNAL(triggered()), &l_plasticTool, SLOT(deleteSelectedVertex_undo()));

		menu->addSeparator();

	}

	assert(ret);

}

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

void PlasticTool::moveVertex_build(const std::vector<tpointd> &origVxsPos, const TPointD &posShift)</tpointd>

{

	if (!m_svSel.isEmpty()) {

		const PlasticSkeletonP &skeleton = this->skeleton();

		// Move selected vertices

		int v, vCount = int(m_svSel.objects().size());

		for (v = 0; v != vCount; ++v)

			skeleton->moveVertex(m_svSel.objects()[v], origVxsPos[v] + posShift);

		// Deformation must be recompiled

		PlasticDeformerStorage::instance()->invalidateSkeleton(

			m_sd.getPointer(), ::skeletonId(), PlasticDeformerStorage::ALL);

		if (m_mode.getIndex() == ANIMATE_IDX)

			storeDeformation(); // Rebuild deformed skeleton - default values have changed

	}

}

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

void PlasticTool::addVertex(const PlasticSkeletonVertex &vx)

{

	touchSkeleton();

	const PlasticSkeletonP &skeleton = this->skeleton();

	l_suspendParamsObservation = true; // Some vertex parameters change during insert

	assert(m_svSel.isEmpty() || m_svSel.hasSingleObject()); // Could there be no parent (inserting the root)

	setSkeletonSelection(skeleton->addVertex(vx, m_svSel));

	l_suspendParamsObservation = false;

	onChange(); // Update once after add

	// NOTE: Root addition does NOT currently add channels, so the above onChange() is

	// quite necessary to cover that case too!

	// Xsheet change notification is necessary to inform the Function Editor that new

	// channels (the vertex deformation ones) have been introduced

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

	PlasticDeformerStorage::instance()->invalidateSkeleton(

		m_sd.getPointer(), ::skeletonId(), PlasticDeformerStorage::ALL);

}

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

void PlasticTool::insertVertex(const PlasticSkeletonVertex &vx,

							   int parent, const std::vector<int> &children)</int>

{

	const PlasticSkeletonP &skeleton = this->skeleton();

	assert(skeleton);

	l_suspendParamsObservation = true; // Some vertex parameters change during insert.

	setSkeletonSelection(skeleton->insertVertex(vx, parent, children));

	l_suspendParamsObservation = false;

	onChange(); // Update once after insertion

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

	PlasticDeformerStorage::instance()->invalidateSkeleton(

		m_sd.getPointer(), ::skeletonId(), PlasticDeformerStorage::ALL);

}

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

void PlasticTool::insertVertex(const PlasticSkeletonVertex &vx, int e)

{

	const PlasticSkeletonP &skeleton = this->skeleton();

	assert(skeleton);

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

	insertVertex(vx, ed.vertex(0), std::vector<int>(1, skeleton->edge(e).vertex(1)));</int>

}

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

void PlasticTool::removeVertex()

{

	const PlasticSkeletonP &skeleton = this->skeleton();

	assert(skeleton && m_svSel.hasSingleObject() && m_svSel > 0);

	l_suspendParamsObservation = true; // Some vertex parameters change during removal.

									   // We need to avoid updating WHILE removing.

	skeleton->removeVertex(m_svSel);

	PlasticDeformerStorage::instance()->invalidateSkeleton(

		m_sd.getPointer(), ::skeletonId(), PlasticDeformerStorage::ALL);

	l_suspendParamsObservation = false;

	onChange();

	clearSkeletonSelections(); // Remove mesh references - could be invalidated...

	// Xsheet change notification is necessary to inform the Function Editor that some

	// channels (the vertex deformation ones) have been removed

	TTool::getApplication()->getCurrentXsheet()->notifyXsheetChanged(); // NOTE: This COULD invoke invalidate()...

	// Rebuild the stage object's keyframes table

	stageObject()->updateKeyframes();

}

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

int PlasticTool::addSkeleton(const PlasticSkeletonP &skeleton)

{

	assert(TTool::isEnabled());

	touchDeformation();

	int skelId;

	{

		if (m_sd->empty())

			skelId = 1;

		else {

			// Get the first unused skeleton id in m_sd

			SkD::skelId_iterator st, sEnd;

			m_sd->skeletonIds(st, sEnd);

			for (skelId = 1; st != sEnd && skelId == *st; ++skelId, ++st)

				;

		}

	}

	addSkeleton(skelId, skeleton);

	return skelId;

}

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

void PlasticTool::addSkeleton(int skelId, const PlasticSkeletonP &skeleton)

{

	assert(TTool::isEnabled());

	touchDeformation();

	m_sd->attach(skelId, skeleton.getPointer());

	emit skelIdsListChanged();

}

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

void PlasticTool::removeSkeleton(int skelId)

{

	// Remove the entire deformation

	clearSkeletonSelections();

	if (m_sd) {

		m_sd->detach(skelId);

		if (m_sd->empty())

			stageObject()->setPlasticSkeletonDeformation(PlasticSkeletonDeformationP());

		::invalidateXsheet(); // Updates m_sd

		emit skelIdsListChanged();

	}

}

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

void PlasticTool::deleteSelectedVertex_undo()

{

	if (m_svSel.isEmpty())

		return;

	TUndoManager *manager = TUndoManager::manager();

	if (m_svSel.contains(0)) {

		TUndo *op = new RemoveSkeletonUndo(::skeletonId());

		manager->add(op);

		op->redo();

	} else {

		typedef PlasticVertexSelection::objects_container objects_container;

		objects_container vertexIdxs = m_svSel.objects(); // Each undo will reset the vertex selection,

														  // so we need a copy

		manager->beginBlock();

		{

			objects_container::const_iterator vit, viEnd = vertexIdxs.end();

			for (vit = vertexIdxs.begin(); vit != viEnd; ++vit) {

				TUndo *op = new RemoveVertexUndo(*vit);

				manager->add(op);

				op->redo();

			}

		}

		manager->endBlock();

	}

}

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

int PlasticTool::addSkeleton_undo(const PlasticSkeletonP &skeleton)

{

	int skelId;

	TUndoManager *manager = TUndoManager::manager();

	manager->beginBlock();

	{

		skelId = l_plasticTool.addSkeleton(skeleton);

		assert(l_plasticTool.deformation());

		TUndo *addUndo = new AddSkeletonUndo(skelId, new PlasticSkeleton(*skeleton));

		manager->add(addUndo);

		TUndo *setIdUndo = new SetSkeletonIdUndo(skelId);

		manager->add(setIdUndo);

		setIdUndo->redo();

	}

	manager->endBlock();

	::invalidateXsheet();

	return skelId;

}

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

void PlasticTool::addSkeleton_undo(int skelId, const PlasticSkeletonP &skeleton)

{

	TUndoManager *manager = TUndoManager::manager();

	manager->beginBlock();

	{

		l_plasticTool.addSkeleton(skelId, skeleton);

		assert(l_plasticTool.deformation());

		TUndo *addUndo = new AddSkeletonUndo(skelId, new PlasticSkeleton(*skeleton));

		manager->add(addUndo);

		TUndo *setIdUndo = new SetSkeletonIdUndo(skelId);

		manager->add(setIdUndo);

		setIdUndo->redo();

	}