#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 final : public TSelection {

  TXshLevelP m_level;

  std::set<std::pair<int, int="">></std::pair<int,>

      m_objtp;  // objtp: 1=ObjectId 2=Tracker Region Index

  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 override { return m_objtp.empty(); }

  void selectNone() override { 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() override;

  void convertToRegion();

};

}  // namespace

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

//  TrackerTool class declaration

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

class TrackerTool final : 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 override { return TTool::LevelReadTool; }

  void updateTranslation() override;

  TrackerObjectsSet *getTrackerObjectsSet() const;

  HookSet *getHookSet() const;

  void draw() override;

  void deleteSelectedTrackerRegion();

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

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

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

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

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

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

  void onEnter() override;

  void onLeave() override;

  void onActivate() override;

  void onDeactivate() override;

  void onImageChanged() override {}

  void reset() override;

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

  void onSelectionChanged() { invalidate(); }

  bool onPropertyChanged(std::string propertyName) override;

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

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

  int getCursorId() const override;

} 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 = std::to_string(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() {}

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

void TrackerTool::onDeactivate() {

  // m_selection.selectNone();

  // TSelection::setCurrent(0);

}

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

TTool *getTrackerToolTool() { return &trackerTool; }

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

void TrackerRegionSelection::enableCommands() {

  enableCommand(m_tool, MI_Clear, &TrackerTool::deleteSelectedTrackerRegion);

  // enableCommand(m_tool, MI_ConvertToRegion,

  // &TrackerRegionSelection::convertToRegion);

}

void TrackerRegionSelection::convertToRegion() {

  int i         = 0;

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

  if (!xl) return;

  HookSet *hookSet = xl->getHookSet();

  if (!hookSet) return;

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

    if (isSelected(i, i)) {

      int trackerObjectId = hookSet->getTrackerObjectsSet()->addObject();

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

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

      hook->setTrackerObjectId(trackerObjectId);

    }

  }

}