// TnzCore includes

#include "tstroke.h"

#include "tgl.h"

// TnzBase includes

#include "tenv.h"

// TnzLib includes

#include "toonz/tstageobjectcmd.h"

#include "toonz/toonzimageutils.h"

#include "toonz/txshcolumn.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/tstageobjectspline.h"

#include "toonz/toonzscene.h"

#include "toonz/stage.h"

#include "toonz/txshcell.h"

#include "toonz/dpiscale.h"

#include "toonz/skeleton.h"

#include "toonz/tscenehandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tpinnedrangeset.h"

#include "toonz/tframehandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/stageobjectutil.h"

// TnzQt includes

#include "toonzqt/selection.h"

#include "toonzqt/selectioncommandids.h"

// TnzTools includes

#include "tools/tool.h"

#include "tools/cursors.h"

#include "tools/toolutils.h"

#include "tw/keycodes.h"

// Qt includes

#include <qcoreapplication> // Qt translation support</qcoreapplication>

#include <qpainter></qpainter>

#include <qglwidget></qglwidget>

#include <qpainterpath></qpainterpath>

#include <qstring></qstring>

#include <qimage></qimage>

#include <qfont></qfont>

#include <qfontmetrics></qfontmetrics>

#include "skeletonsubtools.h"

#include "skeletontool.h"

using namespace SkeletonSubtools;

TEnv::IntVar SkeletonGlobalKeyFrame("SkeletonToolGlobalKeyFrame", 0);

TEnv::IntVar SkeletonInverseKinematics("SkeletonToolInverseKinematics", 0);

#define BUILD_SKELETON L"Build Skeleton"

#define ANIMATE L"Animate"

#define INVERSE_KINEMATICS L"Inverse Kinematics"

const double alpha = 0.4;

using SkeletonSubtools::HookData;

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

inline std::string removeTrailingH(std::string handle)

{

	if (handle.find("H") == 0)

		return handle.substr(1);

	else

		return handle;

}

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

//

// util

//

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

// return true iff column ancestorIndex is column descentIndex or its parent or the parent of the parent, etc.

bool isAncestorOf(int ancestorIndex, int descendentIndex)

{

	TStageObjectId ancestorId = TStageObjectId::ColumnId(ancestorIndex);

	TStageObjectId descendentId = TStageObjectId::ColumnId(descendentIndex);

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

	while (descendentId != ancestorId && descendentId.isColumn())

		descendentId = xsh->getStageObjectParent(descendentId);

	return descendentId == ancestorId;

}

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

void getHooks(std::vector<hookdata> &hooks, TXsheet *xsh, int row, int col, TPointD dpiScale)</hookdata>

{

	// nota. hook position is in the coordinate system of the parent object.

	// a inch is Stage::inch

	TXshCell cell = xsh->getCell(row, col);

	if (!cell.m_level)

		return;

	TStageObjectId columnId = TStageObjectId::ColumnId(col);

	// handle is the current handle (pivot) of the column. It can be H1,H2,... or A,B,C,...

	std::string handle = xsh->getStageObject(TStageObjectId::ColumnId(col))->getHandle();

	bool handleIsHook = handle.find("H") == 0;

	TAffine aff = xsh->getPlacement(columnId, row);

	// imageDpiAff represent the scale factor between the image and the camera

	// derived by dpi match (i.e. ignoring geometric transformation)

	// cameraPos = imageDpiAff * imagePos

	TAffine imageDpiAff;

	if (cell.m_level->getSimpleLevel())

		imageDpiAff = getDpiAffine(cell.m_level->getSimpleLevel(), cell.m_frameId, true);

	// center (inches)

	TPointD center = xsh->getCenter(columnId, row); // getHooks

	if (handleIsHook)

		center = TPointD(0, 0);

	// add the hook #0 (i.e. the regular center)

	hooks.push_back(HookData(xsh, col, 0, aff * TScale(Stage::inch) * center));

	// add the regular hooks

	HookSet *hookSet = cell.m_level->getHookSet();

	if (hookSet && hookSet->getHookCount() > 0) {

		for (int j = 0; j < hookSet->getHookCount(); j++) {

			Hook *hook = hookSet->getHook(j);

			if (hook && !hook->isEmpty()) {

				TPointD pos = hook->getAPos(cell.m_frameId);

				pos = aff * imageDpiAff * pos;

				hooks.push_back(HookData(xsh, col, j + 1, pos));

			}

		}

	}

}

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

void getConnectedColumns(std::set<int> &connectedColumns, TXsheet *xsh, int col)</int>

{

	TStageObjectId id;

	// insert col and all column ancestors

	id = TStageObjectId::ColumnId(col);

	do {

		connectedColumns.insert(id.getIndex());

		id = xsh->getStageObjectParent(id);

	} while (id.isColumn());

	// for each column

	for (int i = 0; i < xsh->getColumnCount(); i++) {

		id = TStageObjectId::ColumnId(i);

		std::vector<tstageobjectid> stack;</tstageobjectid>

		// find a column ancestor already connected; put all the column ancestors in stack

		while (id.isColumn() && connectedColumns.count(id.getIndex()) == 0) {

			stack.push_back(id);

			id = xsh->getStageObjectParent(id);

		}

		if (id.isColumn()) {

			// the stack is connected

			for (int j = 0; j < (int)stack.size(); j++)

				connectedColumns.insert(stack[j].getIndex());

		}

	}

}

bool canShowBone(Skeleton::Bone *bone, TXsheet *xsh, int row)

{

	TStageObjectId id = bone->getStageObject()->getId();

	if (!xsh->getCell(row, id.getIndex()).isEmpty() && xsh->getColumn(id.getIndex())->isCamstandVisible())

		return true;

	int i;

	for (i = 0; i < bone->getChildCount(); i++) {

		if (canShowBone(bone->getChild(i), xsh, row))

			return true;

	}

	return false;

}

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

HookData::HookData(TXsheet *xsh, int columnIndex, int hookId, const TPointD &pos)

	: m_columnIndex(columnIndex), m_hookId(hookId), m_pos(pos), m_isPivot(false)

{

	std::string handle = xsh->getStageObject(TStageObjectId::ColumnId(columnIndex))->getHandle();

	if (m_hookId == 0) {

		// if the current handle is a hook the the hook#0 should be the default center, i.e. B

		if (handle.find("H") == 0)

			m_name = "B";

		else {

			m_name = handle;

			m_isPivot = true;

		}

	} else {

		m_name = toString(m_hookId);

		m_isPivot = "H" + m_name == handle;

	}

}

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

enum ToolDevice {

	TD_None = -1,

	TD_Translation = 1,

	TD_Rotation,

	TD_Center,

	TD_ChangeParent,

	TD_ChangeDrawing,

	TD_IncrementDrawing,

	TD_DecrementDrawing,

	TD_InverseKinematics,

	TD_Hook = 10000,

	TD_LockStageObject = 20000,

	TD_MagicLink = 30000,

	TD_Test = 100000

};

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

//

// SkeletonTool

//

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

SkeletonTool skeletonTool;

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

SkeletonTool::SkeletonTool()

	: TTool("T_Skeleton"), m_active(false), m_device(TD_None), m_mode("Mode:"), m_showOnlyActiveSkeleton("Show Only Active Skeleton", false), m_globalKeyframes("Global Key", false), m_dragTool(0), m_firstTime(true), m_currentFrame(-1), m_parentProbe(), m_parentProbeEnabled(false), m_otherColumn(-1), m_otherColumnBBoxAff(), m_otherColumnBBox(), m_labelPos(0, 0), m_label("")

{

	bind(TTool::CommonLevels);

	m_prop.bind(m_mode);

	m_prop.bind(m_globalKeyframes);

	m_prop.bind(m_showOnlyActiveSkeleton);

	m_mode.setId("SkeletonMode");

	m_globalKeyframes.setId("GlobalKey");

	m_showOnlyActiveSkeleton.setId("ShowOnlyActiveSkeleton");

	m_mode.addValue(BUILD_SKELETON);

	m_mode.addValue(ANIMATE);

	m_mode.addValue(INVERSE_KINEMATICS);

	m_commandHandler = new CommandHandler();

	m_commandHandler->setTempPinnedSet(&m_temporaryPinnedColumns);

}

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

SkeletonTool::~SkeletonTool()

{

	delete m_dragTool;

}

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

bool SkeletonTool::onPropertyChanged(std::string propertyName)

{

	SkeletonGlobalKeyFrame = (int)(m_globalKeyframes.getValue());

	// SkeletonInverseKinematics=(int)(m_ikEnabled.getValue());

	invalidate();

	return false;

}

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

bool SkeletonTool::isGlobalKeyframesEnabled() const

{

	return m_globalKeyframes.getValue();

}

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

void SkeletonTool::updateTranslation()

{

	// m_ikEnabled.setQStringName(tr("Inverse Kinematics"));

	m_showOnlyActiveSkeleton.setQStringName(tr("Show Only Active Skeleton"));

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

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

}

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

bool SkeletonTool::doesApply() const

{

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

	TXsheet *xsh = app->getCurrentXsheet()->getXsheet();

	assert(xsh);

	TStageObjectId objId = app->getCurrentObject()->getObjectId();

	if (objId.isColumn()) {

		TXshColumn *column = xsh->getColumn(objId.getIndex());

		if (column && column->getSoundColumn())

			return false;

	}

	return true;

}

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

void SkeletonTool::mouseMove(const TPointD &, const TMouseEvent &e)

{

	int selectedDevice = pick(e.m_pos);

	if (selectedDevice != m_device) {

		m_device = selectedDevice;

		invalidate();

	}

}

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

void SkeletonTool::leftButtonDown(const TPointD &ppos, const TMouseEvent &e)

{

	m_otherColumn = -1;

	m_otherColumnBBox = TRectD();

	m_otherColumnBBoxAff = TAffine();

	m_labelPos = TPointD(0, 0);

	m_label = "";

	TUndoManager::manager()->beginBlock();

	if (!doesApply())

		return;

	assert(m_dragTool == 0);

	m_dragTool = 0;

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

	int currentColumnIndex = app->getCurrentColumn()->getColumnIndex();

	TXsheet *xsh = app->getCurrentScene()->getScene()->getXsheet();

	TPointD pos = ppos;

	int selectedDevice = pick(e.m_pos);

	// cambio drawing

	if (selectedDevice == TD_ChangeDrawing ||

		selectedDevice == TD_IncrementDrawing ||

		selectedDevice == TD_DecrementDrawing) {

		int d = 0;

		if (selectedDevice == TD_IncrementDrawing)

			d = 1;

		else if (selectedDevice == TD_DecrementDrawing)

			d = -1;

		m_dragTool = new ChangeDrawingTool(this, d);

		m_dragTool->leftButtonDown(ppos, e);

		return;

	}

	// click su un hook: attacca la colonna corrente tramite quell'hook

	if (TD_Hook <= selectedDevice && selectedDevice < TD_Hook + 50) {

		TXsheet *xsh = app->getCurrentXsheet()->getXsheet();

		TStageObjectId objId = TStageObjectId::ColumnId(currentColumnIndex);

		TPointD p0 = getCurrentColumnMatrix() * TPointD(0, 0);

		HookData hook(xsh, currentColumnIndex, selectedDevice - TD_Hook, p0);

		TStageObjectCmd::setHandle(objId, hook.getHandle(), app->getCurrentXsheet());

		app->getCurrentXsheet()->notifyXsheetChanged();

		invalidate();

		return;

	}

	// magic link

	if (TD_MagicLink <= selectedDevice && selectedDevice < TD_MagicLink + (int)m_magicLinks.size()) {

		magicLink(selectedDevice - TD_MagicLink);

		app->getCurrentXsheet()->notifyXsheetChanged();

		return;

	}

	m_device = selectedDevice;

	bool justSelected = false;

	if (m_device < 0) {

		// nessun gadget cliccato. Eventualmente seleziono la colonna

		std::vector<int> columnIndexes;</int>

		getViewer()->posToColumnIndexes(e.m_pos, columnIndexes, getPixelSize() * 5, false);

		if (!columnIndexes.empty()) {

			int columnIndex;

			columnIndex = columnIndexes.back();

			if (columnIndex >= 0 && columnIndex != currentColumnIndex) {

				if (!isColumnLocked(columnIndex)) {

					pos = getMatrix() * pos;

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

					updateMatrix();

					currentColumnIndex = columnIndex;

					justSelected = true;

					pos = getMatrix().inv() * pos;

				} else {

					m_label = "Column is locked";

					m_labelPos = pos;

				}

			}

		}

	}

	if (m_device < 0) {

		if (m_mode.getValue() == INVERSE_KINEMATICS)

			m_device = TD_InverseKinematics;

		else if (m_mode.getValue() == ANIMATE)

			m_device = TD_Rotation;

	}

	// lock/unlock: modalita IK

	if (TD_LockStageObject <= m_device && m_device < TD_LockStageObject + 1000) {

		int columnIndex = m_device - TD_LockStageObject;

		int frame = app->getCurrentFrame()->getFrame();

		togglePinnedStatus(columnIndex, frame, e.isShiftPressed());

		invalidate();

		m_dragTool = 0;

		return;

	}

	switch (m_device) {

	case TD_Center:

		m_dragTool = new DragCenterTool(this);

		break;

	case TD_Translation:

		m_dragTool = new DragPositionTool(this);

		break;

	case TD_Rotation:

		m_dragTool = new DragRotationTool(this, justSelected);

		break;

	case TD_ChangeParent:

		m_dragTool = new ParentChangeTool(this, getViewer());

		break;

	case TD_InverseKinematics: {

		Skeleton *skeleton = new Skeleton();

		buildSkeleton(*skeleton, currentColumnIndex);

		m_dragTool = new IKTool(this, getViewer(), skeleton, currentColumnIndex);

		break;

	}

	}

	if (m_dragTool) {

		m_dragTool->leftButtonDown(pos, e);

		invalidate();

	}

}

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

void SkeletonTool::leftButtonDrag(const TPointD &pos, const TMouseEvent &e)

{

	if (m_dragTool) {

		m_dragTool->leftButtonDrag(pos, e);

		invalidate();

	}

}

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

void SkeletonTool::leftButtonUp(const TPointD &pos, const TMouseEvent &e)

{

	m_label = "";

	m_labelPos = TPointD(0, 0);

	if (m_dragTool) {

		m_dragTool->leftButtonUp(pos, e);

		delete m_dragTool;

		m_dragTool = 0;

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

		TTool::getApplication()->getCurrentObject()->notifyObjectIdChanged(false); // Keyframes navigator reads this

	}

	if (m_device == TD_IncrementDrawing || m_device == TD_DecrementDrawing || m_device == TD_ChangeDrawing)

		m_device = pick(e.m_pos);

	else

		m_device = -1;

	invalidate();

	TUndoManager::manager()->endBlock();

}

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

bool SkeletonTool::keyDown(int key, TUINT32 flags, const TPoint &pos)

{

	ChangeDrawingTool tool(this, 0);

	if (key == TwConsts::TK_UpArrow)

		tool.changeDrawing(1);

	else if (key == TwConsts::TK_DownArrow)

		tool.changeDrawing(-1);

	else

		return false;

	invalidate();

	return true;

}

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

class TogglePinnedStatusUndo : public TUndo

{

	SkeletonTool *m_tool;

	std::set<int> m_oldTemp, m_newTemp;</int>

	int m_columnIndex, m_oldColumnIndex;

	std::pair<int, int=""> m_newRange, m_oldRange;</int,>

	TAffine m_oldPlacement, m_newPlacement;

	std::vector<std::pair<tstageobjectid, tstageobject::keyframe="">> m_keyframes;</std::pair<tstageobjectid,>

	int m_frame;

public:

	TogglePinnedStatusUndo(SkeletonTool *tool, int frame)

		: m_tool(tool), m_oldTemp(), m_newTemp(), m_columnIndex(-1), m_oldColumnIndex(-1), m_newRange(0, -1), m_oldRange(0, -1), m_frame(frame)

	{

	}

	void addBoneId(const TStageObjectId &id)

	{

		TStageObject *stageObject = getXsheet()->getStageObject(id);

		if (stageObject) {

			TStageObject::Keyframe k = stageObject->getKeyframe(m_frame);

			m_keyframes.push_back(std::make_pair(id, k));

		}

	}

	void setOldRange(int columnIndex, int first, int second, const TAffine &placement)

	{

		m_oldColumnIndex = columnIndex;

		m_oldRange = std::make_pair(first, second);

		m_oldPlacement = placement;

	}

	void setNewRange(int columnIndex, int first, int second, const TAffine &placement)

	{

		m_columnIndex = columnIndex;

		m_newRange = std::make_pair(first, second);

		m_newPlacement = placement;

	}

	void setOldTemp(const std::set<int> &oldTemp) { m_oldTemp = oldTemp; }</int>

	void setNewTemp(const std::set<int> &newTemp) { m_newTemp = newTemp; }</int>

	TStageObject *getStageObject(int columnIndex) const

	{

		return TTool::getApplication()

			->getCurrentXsheet()

			->getXsheet()

			->getStageObject(TStageObjectId::ColumnId(columnIndex));

	}

	TPinnedRangeSet *getRangeSet(int columnIndex) const

	{

		return getStageObject(columnIndex)->getPinnedRangeSet();

	}

	TXsheet *getXsheet() const

	{

		return TTool::getApplication()->getCurrentXsheet()->getXsheet();

	}

	void notify() const

	{

		m_tool->invalidate();

		TXsheet *xsh = getXsheet();

		int index = m_columnIndex;

		if (index < 0)

			index = m_oldColumnIndex;

		if (index >= 0) {

			TStageObjectId id = TStageObjectId::ColumnId(index);

			TStageObjectId parentId;

			while (parentId = xsh->getStageObjectParent(id), parentId.isColumn())

				id = parentId;

			xsh->getStageObject(id)->invalidate();

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

			TTool::getApplication()->getCurrentObject()->notifyObjectIdChanged(false);

		}

	}

	void undo() const

	{

		m_tool->setTemporaryPinnedColumns(m_oldTemp);

		if (m_columnIndex >= 0)

			getRangeSet(m_columnIndex)->removeRange(m_newRange.first, m_newRange.second);

		if (m_oldColumnIndex >= 0) {

			TPinnedRangeSet *rangeSet = getRangeSet(m_oldColumnIndex);

			rangeSet->setRange(m_oldRange.first, m_oldRange.second);

			rangeSet->setPlacement(m_oldPlacement);

		}

		TXsheet *xsh = getXsheet();

		for (int i = 0; i < (int)m_keyframes.size(); i++) {

			TStageObject *stageObject = getXsheet()->getStageObject(m_keyframes[i].first);

			if (!stageObject)

				continue;

			stageObject->removeKeyframeWithoutUndo(m_frame);

			if (m_keyframes[i].second.m_isKeyframe)

				stageObject->setKeyframeWithoutUndo(m_frame, m_keyframes[i].second);

		}

		notify();

	}

	void redo() const

	{

		TXsheet *xsh = getXsheet();

		for (int i = 0; i < (int)m_keyframes.size(); i++) {

			TStageObject *stageObject = getXsheet()->getStageObject(m_keyframes[i].first);

			if (stageObject)

				stageObject->setKeyframeWithoutUndo(m_frame);

		}

		m_tool->setTemporaryPinnedColumns(m_newTemp);

		if (m_oldColumnIndex >= 0)

			getRangeSet(m_oldColumnIndex)->removeRange(m_oldRange.first, m_oldRange.second);

		if (m_columnIndex >= 0) {

			TPinnedRangeSet *rangeSet = getRangeSet(m_columnIndex);

			rangeSet->setRange(m_newRange.first, m_newRange.second);

			rangeSet->setPlacement(m_newPlacement);

		}

		notify();

	}

	int getSize() const

	{

		return sizeof *this;

	}

};

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

void SkeletonTool::togglePinnedStatus(int columnIndex, int frame, bool shiftPressed)

{

	Skeleton skeleton;

	buildSkeleton(skeleton, columnIndex);

	if (!skeleton.getRootBone() || !skeleton.getRootBone()->getStageObject())

		return;

	Skeleton::Bone *bone = skeleton.getBoneByColumnIndex(columnIndex);

	assert(bone);

	if (!bone)

		return;

	TogglePinnedStatusUndo *undo = new TogglePinnedStatusUndo(this, frame);

	for (int i = 0; i < skeleton.getBoneCount(); i++) {

		TStageObject *obj = skeleton.getBone(i)->getStageObject();

		if (obj) {

			undo->addBoneId(obj->getId());

			obj->setKeyframeWithoutUndo(frame);

		}

	}

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

	getApplication()->getCurrentObject()->notifyObjectIdChanged(false);

	undo->setOldTemp(m_temporaryPinnedColumns);

	bool isTemporaryPinned = m_temporaryPinnedColumns.count(columnIndex) > 0;

	if (shiftPressed || isTemporaryPinned) {

		if (isTemporaryPinned)

			m_temporaryPinnedColumns.erase(columnIndex);

		else

			m_temporaryPinnedColumns.insert(columnIndex);

	} else {

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

		TAffine placement = xsh->getPlacement(bone->getStageObject()->getId(), frame);

		TStageObjectId rootId = skeleton.getRootBone()->getStageObject()->getId();

		TAffine rootPlacement = xsh->getPlacement(rootId, frame);

		int pinnedStatus = bone->getPinnedStatus();

		if (pinnedStatus != Skeleton::Bone::PINNED) {

			int oldPinned = -1;

			for (int i = 0; i < skeleton.getBoneCount(); i++) {

				TStageObject *obj = skeleton.getBone(i)->getStageObject();

				if (obj->getPinnedRangeSet()->isPinned(frame)) {

					oldPinned = i;

					break;

				}

			}

			int lastFrame = 1000000;

			if (oldPinned >= 0) {

				assert(skeleton.getBone(oldPinned) != bone);

				TStageObject *obj = skeleton.getBone(oldPinned)->getStageObject();

				const TPinnedRangeSet::Range *range = obj->getPinnedRangeSet()->getRange(frame);

				assert(range && range->first <= frame && frame <= range->second);

				lastFrame = range->second;

				TPinnedRangeSet *rangeSet = obj->getPinnedRangeSet();

				rangeSet->removeRange(frame, range->second);

				obj->invalidate();

				undo->setOldRange(oldPinned, frame, range->second, rangeSet->getPlacement());

			} else {

				for (int i = 0; i < skeleton.getBoneCount(); i++) {

					TStageObject *obj = skeleton.getBone(i)->getStageObject();

					const TPinnedRangeSet::Range *range = obj->getPinnedRangeSet()->getNextRange(frame);

					if (range) {

						assert(range->first > frame);

						if (range->first - 1 < lastFrame)

							lastFrame = range->first - 1;

					}

				}

			}

			TStageObject *obj = bone->getStageObject();

			TPinnedRangeSet *rangeSet = obj->getPinnedRangeSet();

			rangeSet->setRange(frame, lastFrame);

			if (frame == 0) {

				// this code should be moved elsewhere, possibly in the stageobject implementation

				// the idea is to remove the normal

				TStageObject *rootObj = skeleton.getRootBone()->getStageObject();

				rootObj->setStatus(TStageObject::XY);

				placement = rootObj->getPlacement(0).inv() * placement;

				rootObj->setStatus(TStageObject::IK);

				rangeSet->setPlacement(placement);

				rootObj->invalidate();

			}

			undo->setNewRange(bone->getColumnIndex(), frame, lastFrame, rangeSet->getPlacement());

		}

	}

	undo->setNewTemp(m_temporaryPinnedColumns);

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

}

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

void SkeletonTool::drawSkeleton(const Skeleton &skeleton, int row)

{

	bool buildingSkeleton = m_mode.getValue() == BUILD_SKELETON;

	bool ikEnabled = m_mode.getValue() == INVERSE_KINEMATICS;

	TXsheet *xsh = getXsheet();

	std::vector<int> showBoneIndex;</int>

	int i;

	for (i = 0; i < skeleton.getBoneCount(); i++) {

		Skeleton::Bone *bone = skeleton.getBone(i);

		TStageObjectId id = bone->getStageObject()->getId();

		bool canShow = canShowBone(bone, xsh, row);

		if (!canShow)

			continue;

		showBoneIndex.push_back(i);

	}

	bool changingParent = dynamic_cast<parentchangetool *="">(m_dragTool) != 0;</parentchangetool>

	TStageObjectId currentObjectId = TTool::getApplication()->getCurrentObject()->getObjectId();

	std::string currentHandle = xsh->getStageObject(currentObjectId)->getHandle();

	for (i = 0; i < (int)showBoneIndex.size(); i++) {

		Skeleton::Bone *bone = skeleton.getBone(showBoneIndex[i]);

		TStageObjectId id = bone->getStageObject()->getId();

		bool isCurrent = id == currentObjectId;

		if (isCurrent && buildingSkeleton && m_parentProbeEnabled) {

			if (!m_magicLinks.empty()) {

				drawBone(bone->getCenter(), m_magicLinks[0].m_h1.m_pos, false);

			}

			drawBone(bone->getCenter(), m_parentProbe, true);

		} else if (ikEnabled) {

			if (bone->getParent())

				drawIKBone(bone->getCenter(), bone->getParent()->getCenter());

		} else if (bone->getParent() || isCurrent) {

			double pixelSize = getPixelSize();

			TPointD a = bone->getCenter();

			TPointD b, pm;

			if (bone->getParent()) {

				b = bone->getParent()->getCenter();

				pm = (a + b) * 0.5;

			} else {

				pm = b = a + TPointD(0, 60) * pixelSize;

			}

			bool boneIsVisible = false;

			if (buildingSkeleton) {

				boneIsVisible = true;

				if (bone->isSelected())

					drawBone(a, b, true);

				else if (!m_showOnlyActiveSkeleton.getValue())

					drawBone(a, b, false);

				else

					boneIsVisible = false;

			}

			if (boneIsVisible && isCurrent) {

				// draw change parent gadget

				double r = pixelSize * 5;

				if (isPicking()) {

					// int code = TD_ResetParent + bone->getStageObject()->getId().getIndex();

					glPushName(TD_ChangeParent);

					tglDrawDisk(pm, r);

					glPopName();

				} else {

					if (m_device == TD_ChangeParent) {

						glColor4d(0.47 * alpha, 0.6 * alpha, 0.65 * alpha, alpha);

						r *= 1.5;

					} else

						glColor4d(0.37 * alpha, 0.5 * alpha, 0.55 * alpha, alpha);

					glRectd(pm.x - r, pm.y - r, pm.x + r, pm.y + r);

					glColor3d(0, 0, 0);

					tglDrawRect(pm.x - r, pm.y - r, pm.x + r, pm.y + r);

				}

			}

		}

	}

	for (i = 0; i < (int)showBoneIndex.size(); i++) {

		Skeleton::Bone *bone = skeleton.getBone(showBoneIndex[i]);

		if (!m_showOnlyActiveSkeleton.getValue() || bone->isSelected())

			drawJoint(bone->getCenter(),

					  currentObjectId == bone->getStageObject()->getId() &&

						  currentHandle.find("H") != 0);

	}

}

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

void SkeletonTool::getImageBoundingBox(TRectD &bbox, TAffine &aff, int frame, int columnIndex)

{

	TAffine columnAff = getXsheet()->getPlacement(TStageObjectId::ColumnId(columnIndex), frame);

	// TAffine affine = getColumnMatrix(columnIndex);

	TXshCell cell = getXsheet()->getCell(frame, columnIndex);

	TImageP image = cell.getImage(false);

	TToonzImageP ti = image;

	TVectorImageP vi = image;

	if (ti) {

		TAffine imageDpiAff;

		if (cell.m_level->getSimpleLevel())

			imageDpiAff = getDpiAffine(cell.m_level->getSimpleLevel(), cell.m_frameId, true);

		aff = columnAff * imageDpiAff;

		bbox = ToonzImageUtils::convertRasterToWorld(convert(ti->getBBox()), ti) * ti->getSubsampling();

		ToolUtils::drawRect(bbox * ti->getSubsampling(), TPixel32(200, 200, 200), 0x5555);

	} else if (vi) {

		bbox = vi->getBBox();

		aff = columnAff;

	} else {

		bbox = TRectD();

		aff = TAffine();

	}

}

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

void SkeletonTool::drawLevelBoundingBox(int frame, int columnIndex)

{

	TAffine affine = getCurrentColumnMatrix();

	TXshCell cell = getXsheet()->getCell(frame, columnIndex);

	TImageP image = cell.getImage(false);

	TToonzImageP ti = image;

	TVectorImageP vi = image;

	glPushMatrix();

	if (affine != getMatrix())

		tglMultMatrix(getMatrix().inv() * affine);

	if (ti) {

		TPointD dpiScale = getViewer()->getDpiScale();

		glScaled(dpiScale.x, dpiScale.y, 1);

		TRectD bbox = ToonzImageUtils::convertRasterToWorld(convert(ti->getBBox()), ti);

		ToolUtils::drawRect(bbox * ti->getSubsampling(), TPixel32(200, 200, 200), 0x5555);

	}

	if (vi) {

		TRectD bbox = vi->getBBox();

		ToolUtils::drawRect(bbox, TPixel32(200, 200, 200), 0x5555);

	}

	glPopMatrix();

}

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

void SkeletonTool::drawIKJoint(const Skeleton::Bone *bone)

{

	TPointD pos = bone->getCenter();

	const double r0 = 6 * getPixelSize(), r1 = r0 / 3;

	int code = TD_LockStageObject + bone->getColumnIndex();

	glPushName(code);

	glColor3d(0.8, 0.5, 0.05);

	if (bone->getPinnedStatus() != Skeleton::Bone::FREE) {

		if (bone->getPinnedStatus() == Skeleton::Bone::TEMP_PINNED) {

			double r1 = r0 * 0.60;

			glColor3d(60.0 / 255.0, 250.0 / 255.0, 1.0);

			glRectd(pos.x - r0, pos.y - r0, pos.x + r0, pos.y + r0);

			glColor3d(0.78, 0.62, 0);

			glRectd(pos.x - r1, pos.y - r1, pos.x + r1, pos.y + r1);

			glColor3d(0.2, 0.1, 0.05);

			tglDrawRect(pos.x - r0, pos.y - r0, pos.x + r0, pos.y + r0);

			tglDrawRect(pos.x - r1, pos.y - r1, pos.x + r1, pos.y + r1);

		} else {

			glColor3d(0, 175.0 / 255.0, 1.0);

			glRectd(pos.x - r0, pos.y - r0, pos.x + r0, pos.y + r0);

			glColor3d(0.2, 0.1, 0.05);

			tglDrawRect(pos.x - r0, pos.y - r0, pos.x + r0, pos.y + r0);

		}

	} else {

		if (bone->isSelected())

			glColor3d(1, 0.78, 0.19);

		else

			glColor3d(0.78, 0.62, 0);

		tglDrawDisk(pos, r0);

		glColor3d(0.2, 0.1, 0.05);

		tglDrawCircle(pos, r0);

	}