// 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 =
		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

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(); }
	void undo() const { const_cast<AddVertexUndo &>(*this).VertexUndo::removeVertex(); }
};

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

class RemoveVertexUndo : public VertexUndo
{
public:
	RemoveVertexUndo(int v)
	{
		assert(v >= 0);
		m_v = v;
	}

	void redo() const { const_cast<RemoveVertexUndo &>(*this).VertexUndo::removeVertex(); }
	void undo() const { const_cast<RemoveVertexUndo &>(*this).VertexUndo::insertVertex(); }
};

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

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

	void redo() const
	{
		const_cast<InsertVertexUndo &>(*this).VertexUndo::insertVertex();
	}

	void undo() const
	{
		TCG_ASSERT(!m_children.empty(), return );

		const_cast<InsertVertexUndo &>(*this).VertexUndo::removeVertex();
	}
};

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

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
															 //!< 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());
		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
	std::vector<TPointD> m_origVxsPos; //!< Original vertex positions
	TPointD m_posShift;				   //!< Vertex positions shift

public:
	MoveVertexUndo_Build(
		const std::vector<int> &vIdxs,
		const std::vector<TPointD> &origVxsPos,
		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>(
			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)
{
	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)
{
	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)));
}

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

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();
	}
	manager->endBlock();

	::invalidateXsheet();
}

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

void PlasticTool::removeSkeleton_undo(int skelId)
{
	TUndo *op = new RemoveSkeletonUndo(skelId);
	TUndoManager::manager()->add(op);

	op->redo();
}

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

void PlasticTool::removeSkeleton_withKeyframes_undo(int skelId)
{
	TUndo *op = new RemoveSkeletonUndo_WithKeyframes(skelId);
	TUndoManager::manager()->add(op);

	op->redo();
}

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

void PlasticTool::editSkelId_undo(int skelId)
{
	TUndo *op = new SetSkeletonIdUndo(skelId);
	TUndoManager::manager()->add(op);

	op->redo();
}

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

void PlasticTool::draw_build()
{
	double pixelSize = getPixelSize();

	// Draw original skeleton
	const PlasticSkeletonP &skeleton = this->skeleton();
	if (skeleton) {
		drawOnionSkinSkeletons_build(pixelSize);
		drawSkeleton(*skeleton, pixelSize);
		drawSelections(m_sd, *skeleton, pixelSize);
	}

	drawHighlights(m_sd, skeleton.getPointer(), pixelSize);

	if (!skeleton || skeleton->vertices().empty() ||
		(m_svSel.hasSingleObject() && m_svHigh < 0 && m_seHigh < 0)) {
		// Draw a handle at current mouse pos (will add a vertex)
		drawSquare(m_pos, HANDLE_SIZE * pixelSize);
	}
}