#include "tools/tool.h"

#include "tools/toolutils.h"

#include "tools/cursors.h"

#include "toonz/tframehandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/tscenehandle.h"

#include "toonzqt/selectioncommandids.h"

#include "toonzqt/selection.h"

#include "tproperty.h"

#include "tdata.h"

#include "tconvert.h"

#include "tgl.h"

#include "tstroke.h"

#include "tvectorimage.h"

#include "toonz/hook.h"

#include "toonz/txshlevel.h"

#include "toonz/toonzscene.h"

#include "toonz/txsheet.h"

#include "toonz/txshcell.h"

#include "toonz/txshcolumn.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/levelproperties.h"

#include "toonz/txsheethandle.h"

#include "tw/keycodes.h"

#include <qmessagebox></qmessagebox>

#include <math.h></math.h>

// For Qt translation support

#include <qcoreapplication></qcoreapplication>

using namespace ToolUtils;

class TrackerTool;

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

namespace

{

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

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

// TrackerRegionSelection

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

// Ancora da definire.

// under construction

class TrackerRegionSelection : public TSelection

{

	TXshLevelP m_level;

	std::set<std::pair<int, int="">> m_objtp; // objtp: 1=ObjectId 2=Tracker Region Index</std::pair<int,>

	TrackerTool *m_tool;

public:

	TrackerRegionSelection() : m_tool(0)

	{

	}

	void setTool(TrackerTool *tool) { m_tool = tool; }

	TSelection *clone() const { return new TrackerRegionSelection(*this); }

	void setLevel(const TXshLevelP &level) { m_level = level; }

	void select(int objectId, int trackerRegionIndex)

	{

		m_objtp.insert(std::make_pair(objectId, trackerRegionIndex));

	}

	void deselect(int objectId, int trackerRegionIndex)

	{

		m_objtp.erase(std::make_pair(objectId, trackerRegionIndex));

	}

	bool isSelected(int objectId, int trackerRegionIndex) const

	{

		return m_objtp.count(std::make_pair(objectId, trackerRegionIndex)) > 0;

	}

	void invertSelection(int objectId, int trackerRegionIndex)

	{

		if (isSelected(objectId, trackerRegionIndex))

			deselect(objectId, trackerRegionIndex);

		else

			select(objectId, trackerRegionIndex);

	}

	bool isEmpty() const

	{

		return m_objtp.empty();

	}

	void selectNone() { m_objtp.clear(); }

	HookSet *getHookSet() const

	{

		TXshLevel *xl = TTool::getApplication()->getCurrentLevel()->getLevel();

		//TXshLevel *xl = m_level.getPointer();

		if (!xl)

			return 0;

		return xl->getHookSet();

	}

	TDataP getData() { return TDataP(); }

	TDataP cutData() { return TDataP(); }

	TDataP clearData()

	{

		/*

    //HookData *data = new HookData();

    HookSet *hookSet = getHookSet();

		TFrameId fid = TTool::getApplication()->getCurrentFrame()->getFid();

    if(!hookSet) return TDataP();

    for(int i=0;i<hookset->getHookCount();i++)</hookset->

      {

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

       if(!hook || hook->isEmpty()) continue;

       if(isSelected(i,1) && isSelected(i,2))

         hookSet->clearHook(hook);

       else if(isSelected(i,2))

         hook->setBPos(fid, hook->getAPos(fid));

       else if(isSelected(i,1))

         hook->setAPos(fid, hook->getBPos(fid));

      }

		makeCurrent();

    return TDataP(); */

	}

	TDataP pasteData(const TDataP &data) { return TDataP(); }

	void resetData(const TDataP &data, bool insert) {}

	bool select(const TSelection *s)

	{

		if (const TrackerRegionSelection *hs = dynamic_cast<const *="" trackerregionselection="">(s)) {</const>

			m_level = hs->m_level;

			m_objtp = hs->m_objtp;

			return true;

		} else

			return false;

	}

	void enableCommands();

	void convertToRegion();

};

} // namespace

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

//  TrackerTool class declaration

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

class TrackerTool : public TTool

{

	Q_DECLARE_TR_FUNCTIONS(TrackerTool)

	TrackerRegionSelection m_selection;

	TPointD m_firstPos, m_lastPos;

	int m_hookSelectedIndex;

	int m_lastHookSelectedIndex;

	bool m_deselectArmed;

	bool m_newObjectAdded; // serve al buttonUp per sapere se l'ultima tracker region

						   // aggiunta è un oggetto nuovo oppure no

	TPropertyGroup m_prop;

	TDoubleProperty m_toolSizeWidth;

	TDoubleProperty m_toolSizeHeight;

	TIntProperty m_toolPosX;

	TIntProperty m_toolPosY;

	TRectD m_shapeBBox;

	bool m_buttonDown;

	bool m_dragged;

	bool m_picked;

	TPointD m_pos; // posizione del mouse

	TPointD m_oldPos;

	int m_what;

	enum { Outside,

		   Inside,

		   P00,

		   P01,

		   P10,

		   P11,

		   P1M,

		   PM1,

		   P0M,

		   PM0,

		   ADD_OBJECT,

		   NormalHook };

public:

	TrackerTool();

	ToolType getToolType() const { return TTool::LevelReadTool; }

	void updateTranslation();

	TrackerObjectsSet *getTrackerObjectsSet() const;

	HookSet *getHookSet() const;

	void draw();

	void deleteSelectedTrackerRegion();

	void leftButtonDown(const TPointD &pos, const TMouseEvent &e);

	void leftButtonDrag(const TPointD &pos, const TMouseEvent &e);

	void leftButtonUp(const TPointD &pos, const TMouseEvent &);

	void mouseMove(const TPointD &pos, const TMouseEvent &e);

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

	// bool moveCursor(const TPointD &pos){}

	void onEnter();

	void onLeave();

	void onActivate();

	void onDeactivate();

	void onImageChanged()

	{

	}

	void reset();

	TPropertyGroup *getProperties(int targetType) { return &m_prop; }

	void onSelectionChanged() { invalidate(); }

	bool onPropertyChanged(std::string propertyName);

	bool select(const TSelection *) { return false; }

	bool pick(int &hookIndex, const TPointD &pos);

	int getCursorId() const;

} trackerTool;

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

//  TrackerTool implementation

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

TrackerTool::TrackerTool()

	: TTool("T_Tracker"), m_hookSelectedIndex(-1), m_lastHookSelectedIndex(-1), m_deselectArmed(false), m_toolSizeWidth("Width:", 0, 1000, 10) //W_ToolOptions

	  ,

	  m_toolSizeHeight("Height:", 0, 1000, 10) //W_ToolOptions

	  ,

	  m_toolPosX("X:", -9000, 9000, 10) //W_ToolOptions

	  ,

	  m_toolPosY("Y:", -9000, 9000, 10) //W_ToolOptions

	  ,

	  m_shapeBBox(), m_buttonDown(false), m_dragged(false), m_oldPos(TPointD(0, 0)), m_newObjectAdded(false)

{

	bind(TTool::CommonLevels);

	m_prop.bind(m_toolSizeWidth);

	m_prop.bind(m_toolSizeHeight);

	m_prop.bind(m_toolPosX);

	m_prop.bind(m_toolPosY);

	m_selection.setTool(this);

}

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

void TrackerTool::updateTranslation()

{

	m_toolSizeWidth.setQStringName(tr("Width:"));

	m_toolSizeHeight.setQStringName(tr("Height:"));

	m_toolPosX.setQStringName(tr("X:"));

	m_toolPosY.setQStringName(tr("Y:"));

}

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

TrackerObjectsSet *TrackerTool::getTrackerObjectsSet() const

{

	HookSet *hookSet = getHookSet();

	if (!hookSet)

		return 0;

	return hookSet->getTrackerObjectsSet();

}

HookSet *TrackerTool::getHookSet() const

{

	TXshLevel *xl = TTool::getApplication()->getCurrentLevel()->getLevel();

	if (!xl)

		return 0;

	return xl->getHookSet();

}

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

void TrackerTool::draw()

{

	HookSet *hookSet = getHookSet();

	if (!hookSet)

		return;

	if (hookSet->getHookCount() <= m_hookSelectedIndex)

		m_hookSelectedIndex = -1;

	TFrameId fid = getCurrentFid();

	int selectedObjectId;

	if (m_hookSelectedIndex >= 0 && hookSet->getHook(m_hookSelectedIndex))

		selectedObjectId = hookSet->getHook(m_hookSelectedIndex)->getTrackerObjectId();

	else

		selectedObjectId = -1;

	int i = 0;

	double pixelSize = getPixelSize();

	std::vector<trectd> balloons; // this is used to avoid balloons overlapping</trectd>

	// draw hooks

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

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

		if (!hook || hook->isEmpty())

			continue;

		assert(hook);

		// Se l'Hook ha una TrackerRegion allora la disegno

		if (hook->getTrackerObjectId() >= 0) {

			TRectD rect;

			rect = hook->getTrackerRegion(fid);

			TPixel32 textColor(127, 127, 127);

			TPixel32 trackerObjectColor(0, 0, 0);

			if (hook->getTrackerObjectId() == selectedObjectId) {

				if (m_hookSelectedIndex == i) {

					TPixel32 frameColor(127, 127, 127);

					drawSquare(0.5 * (rect.getP01() + rect.getP11()), pixelSize * 4, frameColor); // scalaY

					drawSquare(0.5 * (rect.getP11() + rect.getP10()), pixelSize * 4, frameColor); // scalaX

					drawSquare(rect.getP00(), pixelSize * 4, frameColor);						  // scala

					drawSquare(rect.getP10(), pixelSize * 4, frameColor);						  // ridimensiona

					trackerObjectColor = TPixel32(183, 227, 0);

					textColor = TPixel32(155, 213, 219);

				} else {

					textColor = TPixel32(183, 227, 0);

					trackerObjectColor = TPixel32(155, 213, 219);

				}

			} else

				trackerObjectColor = TPixel32(0, 0, 0);

			tglColor(trackerObjectColor);

			tglDrawRect(rect);

			tglColor(textColor);

			glPushMatrix();

			glTranslated(hook->getPos(fid).x, hook->getPos(fid).y, 0);

			glScaled(pixelSize, pixelSize, 1);

			int objectId = hook->getTrackerObjectId();

			char *objectChar = (char *)malloc(2);

			objectChar[0] = (char)(objectId + 65);

			objectChar[1] = '\0';

			std::string text(objectChar);

			tglDrawText(TPointD(-15, 10), text);

			glPopMatrix();

		}

		TPointD p0 = hook->getAPos(fid);

		TPointD p1 = hook->getBPos(fid);

		bool linked = p0 == p1;

		drawHook(p0, linked ? ToolUtils::NormalHook : ToolUtils::PassHookA, m_hookSelectedIndex == i);

		std::string hookName = toString(i + 1);

		TPixel32 balloonColor(200, 220, 205, 200);

		TPoint balloonOffset(20, 20);

		drawBalloon(p0, hookName, balloonColor, balloonOffset, false, &balloons);

		if (!linked) {

			drawHook(p1, PassHookB, m_selection.isSelected(i, 2));

			drawBalloon(p1, hookName, balloonColor, balloonOffset, false, &balloons);

		}

	}

}

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

bool TrackerTool::pick(int &hookIndex, const TPointD &pos)

{

	double minDistance = -1;

	m_what = Outside;

	HookSet *hookSet = getHookSet();

	if (!hookSet)

		return false;

	TFrameId fid = getCurrentFid();

	double pixelSize = getPixelSize();

	int i = 0;

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

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

		if (!hook || hook->isEmpty())

			continue;

		int trackerObjectId = hook->getTrackerObjectId();

		if (trackerObjectId < 0) // se non è una trackeRregion

		{

			TPointD hookPos = hook->getPos(fid);

			TRectD overArea = TRectD(hookPos.x - 20 * pixelSize, hookPos.y - 20 * pixelSize,

									 hookPos.x + 20 * pixelSize, hookPos.y + 20 * pixelSize);

			if (overArea.contains(pos)) {

				hookIndex = i; //setto l'indice dell'hook

				m_what = NormalHook;

				return true;

			}

		} else {

			/*

			TrackerObjectsSet *trackerObjectsSet = getTrackerObjectsSet();

			if(!trackerObjectsSet) return false;

			TrackerObject *trackerObject = trackerObjectsSet->getObjectFromIndex(i);

			int j=0;

			for(j=0;j<(int)trackerObject->getHooksCount();j++)

			{*/

			TPointD centerPos = hook->getPos(fid);

			double width = hook->getTrackerRegionWidth();

			double height = hook->getTrackerRegionHeight();

			double distance = tdistance2(centerPos, pos);

			TPointD localPos = pos - centerPos;

			TRectD rect = hook->getTrackerRegion(fid);

			TRectD overArea = TRectD(rect.getP00().x - 4 * pixelSize, rect.getP00().y - 4 * pixelSize,

									 rect.getP11().x + 4 * pixelSize, rect.getP11().y + 4 * pixelSize);

			// se pos è all'interno del'area sensibile del rettangolo

			if (overArea.contains(pos)) {

				if (distance < minDistance || minDistance == -1) {

					minDistance = distance;

					hookIndex = i;

					m_what = Inside;

					// scale Y Area

					double x = 0.5 * (rect.getP01().x + rect.getP11().x); //ascissa punto medio

					TPointD my = TPointD(x, rect.getP11().y);

					TRectD scaleYArea = TRectD(my.x - 4 * pixelSize, my.y - 4 * pixelSize, my.x + 4 * pixelSize, my.y + 4 * pixelSize);

					if (scaleYArea.contains(pos))

						m_what = PM1;

					// scale X Area

					double y = 0.5 * (rect.getP11().y + rect.getP10().y); //ordinata punto medio

					TPointD mx = TPointD(rect.getP10().x, y);

					TRectD scaleXArea = TRectD(mx.x - 4 * pixelSize, mx.y - 4 * pixelSize, mx.x + 4 * pixelSize, mx.y + 4 * pixelSize);

					if (scaleXArea.contains(pos))

						m_what = P1M;

					// resize area (scale X and Y)

					TRectD resizeArea = TRectD(rect.getP10().x - 4 * pixelSize, rect.getP10().y - 4 * pixelSize,

											   rect.getP10().x + 4 * pixelSize, rect.getP10().y + 4 * pixelSize);

					if (resizeArea.contains(pos))

						m_what = P10;

					// scale area

					TRectD scaleArea = TRectD(rect.getP00().x - 4 * pixelSize, rect.getP00().y - 4 * pixelSize,

											  rect.getP00().x + 4 * pixelSize, rect.getP00().y + 4 * pixelSize);

					if (scaleArea.contains(pos))

						m_what = P00;

				}

			}

			//}

		}

	}

	return (minDistance != -1);

}

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

void TrackerTool::leftButtonDown(const TPointD &pos, const TMouseEvent &e)

{

	m_buttonDown = true;

	m_picked = true;

	TXshLevel *xl = TTool::getApplication()->getCurrentLevel()->getLevel();

	if (!xl)

		return;

	m_selection.setLevel(xl);

	m_firstPos = m_lastPos = pos;

	m_deselectArmed = false;

	m_oldPos = pos;

	double pixelSize = getPixelSize();

	HookSet *hookSet = xl->getHookSet();

	if (!hookSet)

		return;

	TrackerObjectsSet *trackerObjectsSet = getTrackerObjectsSet();

	TFrameId fid = getCurrentFid();

	if (!trackerObjectsSet)

		return;

	if (pick(m_hookSelectedIndex, pos)) {

		if (m_what == NormalHook) {

			invalidate();

			return;

		}

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

		if (!hook)

			return;

		m_selection.selectNone();

		m_selection.select(m_hookSelectedIndex, m_hookSelectedIndex);

		m_toolSizeWidth.setValue(hook->getTrackerRegionWidth());

		m_toolSizeHeight.setValue(hook->getTrackerRegionHeight());

		m_toolPosX.setValue(hook->getPos(fid).x);

		m_toolPosY.setValue(hook->getPos(fid).y);

		m_toolSizeWidth.notifyListeners();

		m_toolSizeHeight.notifyListeners();

		m_toolPosX.notifyListeners();

		m_toolPosY.notifyListeners();

	} else {

		m_selection.selectNone();

		if (xl->getSimpleLevel() && !xl->getSimpleLevel()->isReadOnly()) {

			TFrameId fid = getCurrentFid();

			m_what = P10;

			// Se non è selezionato alcun oggetto allora aggiungo un nuovo oggetto e a questo

			// aggiungo una trackerRegion

			int trackerObjectId;

			if (m_hookSelectedIndex == -1 || hookSet->getHook(m_hookSelectedIndex) == 0) {

				trackerObjectId = trackerObjectsSet->addObject();

				m_newObjectAdded = true;

			} else

				trackerObjectId = hookSet->getHook(m_hookSelectedIndex)->getTrackerObjectId();

			// se l'oggetto selezionato è un semplice Hook (senza region)

			// allora creo un nuovo hook con region

			if (trackerObjectId == -1) {

				trackerObjectId = trackerObjectsSet->addObject();

				m_newObjectAdded = true;

			}

			// aggiungo un Hook all'oggetto selezionato

			Hook *newHook = hookSet->addHook();

			if (newHook) {

				newHook->setTrackerObjectId(trackerObjectId);

				newHook->setAPos(fid, pos);

				newHook->setTrackerRegionHeight(pixelSize * 10);

				newHook->setTrackerRegionWidth(pixelSize * 10);

				// setto l'indice della trackerRegion corrente

				m_hookSelectedIndex = newHook->getId(); // hookSet->getHookCount()-1;

			} else {

				if (hookSet->getHookCount() >= 20)

					QMessageBox::warning(0, "TrackerTool Error", "Hooks number must be at most 20");

				m_hookSelectedIndex = -1;

			}

		}

	}

	m_selection.makeCurrent();

	invalidate();

	return;

}

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

void TrackerTool::leftButtonDrag(const TPointD &pp, const TMouseEvent &e)

{

	if (!m_buttonDown)

		return;

	if (m_hookSelectedIndex < 0 && m_what != NormalHook)

		return;

	HookSet *hookSet = getHookSet();

	if (!hookSet)

		return;

	assert(hookSet->getHook(m_hookSelectedIndex) != 0);

	TrackerObjectsSet *trackerObjectsSet = getTrackerObjectsSet();

	TFrameId fid = getCurrentFid();

	if (!trackerObjectsSet)

		return;

	if (m_dragged == false) {

		m_dragged = true;

	}

	TXshLevel *xl = TTool::getApplication()->getCurrentLevel()->getLevel();

	if (xl->getSimpleLevel() && xl->getSimpleLevel()->isReadOnly() && m_what != Inside && m_what != NormalHook)

		return;

	if (m_dragged == true) {

		Hook *hook = new Hook();

		hook = getHookSet()->getHook(m_hookSelectedIndex);

		if (!hook || hook->isEmpty())

			return;

		TPointD deltaPos = pp - m_oldPos;

		m_oldPos = pp;

		double newWidth = hook->getTrackerRegionWidth();

		double newHeight = hook->getTrackerRegionHeight();

		TAffine aff;

		const double epsilon = 1e-2;

		TPointD posCenter = hook->getPos(fid);

		double a = norm2(pp - posCenter);

		double b = norm2(pp - deltaPos - posCenter);

		switch (m_what) {

		case Inside: //Traslazione

			hook->setAPos(fid, hook->getPos(fid) + deltaPos);

			break;

		case NormalHook: //Traslazione Hook

		{

			hook->setAPos(fid, hook->getPos(fid) + deltaPos);

			invalidate();

			return;

		}

		case P00: // Scalatura

		{

			if (a <= epsilon || b <= epsilon)

				return;

			aff = TScale(posCenter, sqrt(a / b));

			TRectD rect = hook->getTrackerRegion(fid);

			TPointD av(hook->getTrackerRegion(fid).getP00());

			TPointD av2(hook->getTrackerRegion(fid).getP11());

			av = aff * av;

			av2 = aff * av2;

			rect = TRectD(av, av2);

			newWidth = rect.getLx();

			newHeight = rect.getLy();

			break;

		}

		case P10: // Scalatura X e Y

		{

			TPointD pos = hook->getPos(fid);

			TPointD diffPos = pp - pos;

			int signumx = 1;

			int signumy = 1;

			if (diffPos.x < 0)

				signumx = -1;

			if (diffPos.y < 0)

				signumy = -1;

			newWidth = fabs(hook->getTrackerRegionWidth() + 2 * signumx * deltaPos.x);

			newHeight = fabs(hook->getTrackerRegionHeight() + 2 * signumy * deltaPos.y);

			//double newWidth = fabs(2*diffPos.x-fabs(2*signumx*deltaPos.x));

			//double newHeight = fabs(2*diffPos.y-fabs(2*signumy*deltaPos.y));

			break;

		}

		case P1M: // Ridimensiono X

		{

			TRectD rect = hook->getTrackerRegion(fid);

			rect = rect.enlarge(deltaPos.x, 0);

			newWidth = rect.getLx();

			break;

		}

		case PM1: // Ridimensiono Y

		{

			TRectD rect = hook->getTrackerRegion(fid);

			rect = rect.enlarge(0, deltaPos.y);

			newHeight = rect.getLy();

			break;

		}

		default:

			break;

		}

		if (newWidth > m_toolSizeWidth.getRange().second ||

			newHeight > m_toolSizeHeight.getRange().second)

			return;

		hook->setTrackerRegionWidth(newWidth);

		hook->setTrackerRegionHeight(newHeight);

		m_toolSizeWidth.setValue(hook->getTrackerRegionWidth());

		m_toolSizeHeight.setValue(hook->getTrackerRegionHeight());

		m_toolPosX.setValue(hook->getPos(fid).x);

		m_toolPosY.setValue(hook->getPos(fid).y);

		m_toolPosX.notifyListeners();

		m_toolPosY.notifyListeners();

		m_toolSizeWidth.notifyListeners();

		m_toolSizeHeight.notifyListeners();

	}

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

	//app->getCurrentScene()->getScene()->getXsheet()->getPegbarTree()->invalidateAll();

	invalidate();

}

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

void TrackerTool::leftButtonUp(const TPointD &pos, const TMouseEvent &)

{

	// note: apparently sometimes (when the user triple-clicks) we receive this event twice

	if (!m_buttonDown)

		return;

	// se clicco su una TrackerRegion già selezionato lo deseleziono (per permettere

	// poi l'aggiunta di un nuovo TrackerObject

	if (m_dragged == false &&

		m_hookSelectedIndex == m_lastHookSelectedIndex) {

		m_hookSelectedIndex = -1;

	}

	if (m_newObjectAdded) {

		m_hookSelectedIndex = -1;

		m_newObjectAdded = false;

		// emit signal in order to update schematic

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

	}

	m_lastHookSelectedIndex = m_hookSelectedIndex;

	m_dragged = false;

	m_buttonDown = false;

	TXshLevel *xl = TTool::getApplication()->getCurrentLevel()->getLevel();

	if (!xl || !xl->getSimpleLevel())

		return;

	xl->getSimpleLevel()->getProperties()->setDirtyFlag(true);

	//m_selection.selectNone();

	return;

}

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

void TrackerTool::deleteSelectedTrackerRegion()

{

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

	TXshLevel *xl = app->getCurrentLevel()->getLevel();

	HookSet *hookSet = xl->getHookSet();

	if (!xl || !xl->getSimpleLevel() || !hookSet || xl->getSimpleLevel()->isReadOnly())

		return;

	//HookUndo *undo = new HookUndo(xl->getSimpleLevel());

	TFrameId fid = getCurrentFid();

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

	m_hookSelectedIndex = -1;

	if (!hook || hook->isEmpty())

		return;

	hookSet->clearHook(hook);

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

	app->getCurrentScene()->getScene()->getXsheet()->getStageObjectTree()->invalidateAll();

	invalidate();

	// emit signal in order to update schematic

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

	/*

	int a = m_selectedObjectId;

	int b = m_selectedTrackerRegionIndex;

	if(m_selectedObjectId<0 ||m_selectedTrackerRegionIndex<0) return;

	TrackerObjectsSet *trackerObjectsSet = getTrackerObjectsSet();

	TFrameId fid = getCurrentFid();

  if(!trackerObjectsSet) return;

	TrackerObject *trackerObject= trackerObjectsSet->getObject(m_selectedObjectId);

	if(trackerObject==NULL) return;

	if(trackerObject->getHooksCount()==0)

	{

		trackerObjectsSet->removeObject(m_selectedObjectId);

		m_selectedObjectId = -1;

		m_selectedTrackerRegionIndex = -1;

		return;

	}

	trackerObject->removeHook(m_selectedTrackerRegionIndex);

	m_selectedTrackerRegionIndex = trackerObject->getHooksCount()-1;

  invalidate(); */

}

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

void TrackerTool::mouseMove(const TPointD &pos, const TMouseEvent &e)

{

	m_picked = true;

	if (m_dragged == false) {

		int hookSelectedIndex;

		pick(hookSelectedIndex, pos);

		if (hookSelectedIndex < 0) {

			m_pos = pos;

			m_picked = false;

		}

		invalidate();

	}

}

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

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

{

	HookSet *hookSet = getHookSet();

	if (!hookSet || m_hookSelectedIndex < 0)

		return false;

	TFrameId fid = getCurrentFid();

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

	if (!hook || hook->isEmpty())

		return false;

	if (propertyName == "Width:") {

		double width = m_toolSizeWidth.getValue();

		hook->setTrackerRegionWidth(width);

	}

	if (propertyName == "Height:") {

		double height = m_toolSizeHeight.getValue();

		hook->setTrackerRegionHeight(height);

	}

	if (propertyName == "X:") {

		double x = m_toolPosX.getValue();

		TPointD pos = hook->getPos(fid);

		pos.x = x;

		hook->setAPos(fid, pos);

	}

	if (propertyName == "Y:") {

		double y = m_toolPosY.getValue();

		TPointD pos = hook->getPos(fid);

		pos.y = y;

		hook->setAPos(fid, pos);

	}

	invalidate();

	return true;

}

void TrackerTool::reset()

{

	m_hookSelectedIndex = -1;

}

int TrackerTool::getCursorId() const

{

	switch (m_what) {

	case Outside:

		return ToolCursor::TrackerCursor;

	case Inside:

		return ToolCursor::MoveCursor;

	case NormalHook:

		return ToolCursor::MoveCursor;

	case P00:

		return ToolCursor::ScaleCursor;

	case P01:

		return ToolCursor::MoveCursor;

	case P10:

		return ToolCursor::ScaleCursor;

	case P1M:

		return ToolCursor::ScaleHCursor;

	case PM1:

		return ToolCursor::ScaleVCursor;

	case ADD_OBJECT:

		return ToolCursor::SplineEditorCursorAdd;

	default:

		return ToolCursor::TrackerCursor;

	}

	return ToolCursor::TrackerCursor;

}

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

{

	TXshLevel *xl = TTool::getApplication()->getCurrentLevel()->getLevel();

	if (!xl)

		return false;

	HookSet *hookSet = xl->getHookSet();

	if (!hookSet)

		return false;

	TFrameId fid = getCurrentFid();

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

	if (!hook || hook->isEmpty())

		return false;

	TPointD hookPos = hook->getPos(fid);

	TPointD delta(0, 0);

	double pixelSize = getPixelSize();

	if (key == TwConsts::TK_UpArrow)

		delta.y = 1;

	else if (key == TwConsts::TK_DownArrow)

		delta.y = -1;

	else if (key == TwConsts::TK_LeftArrow)

		delta.x = -1;

	else if (key == TwConsts::TK_RightArrow)

		delta.x = 1;

	else if (key == TwConsts::TK_PageUp) //converto in Hook

		hook->setTrackerObjectId(-1);

	else if (key == TwConsts::TK_PageDown) // converto in trackerRegion

	{

		TrackerObjectsSet *trackerObjectsSet = getTrackerObjectsSet();

		if (!trackerObjectsSet)

			return false;

		int trackerObjectId = hook->getTrackerObjectId();

		if (trackerObjectId != -1)

			return false;

		trackerObjectId = trackerObjectsSet->addObject();

		hook->setTrackerObjectId(trackerObjectId);

		hook->setTrackerRegionHeight(pixelSize * 20);

		hook->setTrackerRegionWidth(pixelSize * 20);

	} else

		return false;

	hookPos += delta;

	hook->setAPos(fid, hookPos);

	//TTool::getApplication()->getCurrentTool()->getTool()->notifyImageChanged();

	//  TNotifier::instance()->notify(TLevelChange());

	return true;

}

// bool moveCursor(const TPointD &pos){}

void TrackerTool::onEnter()

{

	HookSet *hookSet = getHookSet();

	if (!hookSet || hookSet->getHookCount() <= m_hookSelectedIndex)

		m_hookSelectedIndex = -1;

}

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

void TrackerTool::onLeave()

{

	TrackerObjectsSet *trackerObjectsSet = getTrackerObjectsSet();

	if (trackerObjectsSet)

		trackerObjectsSet->clearAll();

}

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

void TrackerTool::onActivate()