#include "tools/tool.h"

// TnzTools includes

#include "tools/toolcommandids.h"

#include "tools/toolhandle.h"

#include "tools/cursors.h"

#include "tools/tooloptions.h"

#include "tools/toolutils.h"

// TnzQt includes

#include "toonzqt/icongenerator.h"

// TnzLib includes

#include "toonzqt/menubarcommand.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txshleveltypes.h"

#include "toonz/levelproperties.h"

#include "toonz/toonzscene.h"

#include "toonz/sceneproperties.h"

#include "toonz/preferences.h"

#include "toonz/tscenehandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/tframehandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tpalettehandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/txshcell.h"

#include "toonz/tstageobject.h"

#include "toonz/tstageobjectspline.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/dpiscale.h"

#include "toonz/palettecontroller.h"

#include "toonz/tonionskinmaskhandle.h"

// TnzCore includes

#include "tvectorimage.h"

#include "timagecache.h"

#include "tstroke.h"

#include "tcolorstyles.h"

#include "ttoonzimage.h"

#include "trasterimage.h"

#include "strokeselection.h"

#include "tundo.h"

#include "toonzvectorbrushtool.h"

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

//    Local namespace

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

namespace {

// Global variables

typedef std::pair<std::string, ttool::tooltargettype=""> ToolKey;</std::string,>

typedef std::map<toolkey, *="" ttool=""> ToolTable;</toolkey,>

ToolTable *toolTable = 0;

std::set<std::string> *toolNames = 0;</std::string>

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

// Local classes

struct DummyTool final : public TTool {

  ToolType getToolType() const override {

    return TTool::LevelReadTool;

  }  // Test level type

  ToolTargetType getTargetType() const {

    return TTool::NoTarget;

  }  // Works on nothing

  int getCursorId() const override {

    return ToolCursor::ForbiddenCursor;

  }  // Forbids everything

  DummyTool() : TTool("T_Dummy") {}

} theDummyTool;

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

class ToolSelector {

  std::string m_toolName;

public:

  ToolSelector(std::string toolName) : m_toolName(toolName) {}

  void selectTool() {

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

    if (app) app->getCurrentTool()->setTool(QString::fromStdString(m_toolName));

  }

};

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

// Local functions

TFrameId getNewFrameId(TXshSimpleLevel *sl, int row) {

  TFrameId fid(row + 1);

  if (sl->isFid(fid)) {

    fid = TFrameId(fid.getNumber(), 'a');

    while (fid.getLetter() < 'z' && sl->isFid(fid))

      fid = TFrameId(fid.getNumber(), fid.getLetter() + 1);

  }

  return fid;

}

TFrameId getDesiredFId(TXshCellColumn *column, int r0, TXshSimpleLevel *sl,

                       int row, TFrameId &maxFId) {

  // search upper cells in the current column and return the next fids to be

  // inserted if the maximum fid has no suffix it returns next number, otherwise

  // returns next suffix.

  maxFId = TFrameId(0);

  // in case inserting a new frame on the top

  if (row <= r0) return TFrameId(1);

  TFrameId neighborFId;

  for (int r = row - 1; r >= r0; r--) {

    if (sl != column->getCell(r).getSimpleLevel()) continue;

    TFrameId tmpFId = column->getCell(r).getFrameId();

    if (neighborFId.isEmptyFrame()) neighborFId = tmpFId;

    if (maxFId < tmpFId) maxFId = tmpFId;

  }

  if (maxFId.getLetter() && maxFId.getLetter() < 'z' && maxFId == neighborFId)

    return TFrameId(maxFId.getNumber(), maxFId.getLetter() + 1);

  else

    return TFrameId(maxFId.getNumber() + 1);

}

}  // namespace

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

//    TTool  static members

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

TTool::Application *TTool::m_application   = 0;

std::set<tframeid> TTool::m_selectedFrames = std::set<tframeid>();</tframeid></tframeid>

bool TTool::m_isLevelCreated               = false;

bool TTool::m_isFrameCreated               = false;

bool TTool::m_isLevelRenumbererd           = false;

// m_cellsData

// brutto brutto. fix quick & dirty del baco #6213 (undo con animation sheet)

// bisogna ripensare la logica degli undo e del touchImage

// m_cellsData viene inizializzato nel touchImage() in modalita' animation sheet

// contiene una o due terne che rappresentano range di celle (dell'xsheet)

// modificate dall'inserimento

// di un nuovo frame: [r0,r1,type].

// type = 0 : vecchio (cella[r0-1]) => nuovo

// type = 1 : vuoto => vecchio (cella[r0-1])

// type = 2 : vuoto => nuovo

// cfr. il codice di TTool::touchImage()

// ToolUtils::TToolUndo::removeLevelAndFrameIfNeeded()

std::vector<ttool::cellops> TTool::m_cellsData;</ttool::cellops>

std::vector<tframeid> TTool::m_oldFids;</tframeid>

std::vector<tframeid> TTool::m_newFids;</tframeid>

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

//    TTool  implementation

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

TTool::TTool(std::string name)

    : m_name(name)

    , m_viewer(0)

    , m_targetType(NoTarget)

    , m_enabled(true)

    , m_active(false)

    , m_picking(false) {}

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

TTool *TTool::getTool(std::string toolName, ToolTargetType targetType) {

  if (!toolTable) return 0;

  ToolTable::iterator it =

      toolTable->find(std::make_pair(toolName, targetType));

  if (it == toolTable->end()) return 0;

  return it->second;

}

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

void TTool::bind(int targetType) {

  m_targetType = targetType;

  if (!toolTable) toolTable = new ToolTable();

  if (!toolNames) toolNames = new std::set<std::string>();</std::string>

  std::string name = getName();

  if (toolNames->count(name) == 0) {

    toolNames->insert(name);

    // Initialize with the dummy tool

    toolTable->insert(

        std::make_pair(std::make_pair(name, ToonzImage), &theDummyTool));

    toolTable->insert(

        std::make_pair(std::make_pair(name, VectorImage), &theDummyTool));

    toolTable->insert(

        std::make_pair(std::make_pair(name, RasterImage), &theDummyTool));

    toolTable->insert(

        std::make_pair(std::make_pair(name, MeshImage), &theDummyTool));

    ToolSelector *toolSelector = new ToolSelector(name);

    CommandManager::instance()->setHandler(

        name.c_str(), new CommandHandlerHelper<toolselector>(</toolselector>

                          toolSelector, &ToolSelector::selectTool));

  }

  if (targetType & ToonzImage)

    (*toolTable)[std::make_pair(name, ToonzImage)] = this;

  if (targetType & VectorImage)

    (*toolTable)[std::make_pair(name, VectorImage)] = this;

  if (targetType & RasterImage)

    (*toolTable)[std::make_pair(name, RasterImage)] = this;

  if (targetType & MeshImage)

    (*toolTable)[std::make_pair(name, MeshImage)] = this;

}

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

ToolOptionsBox *TTool::createOptionsBox() {

  TPaletteHandle *currPalette =

      m_application->getPaletteController()->getCurrentLevelPalette();

  ToolHandle *currTool = m_application->getCurrentTool();

  return new GenericToolOptionsBox(0, this, currPalette, 0, currTool);

}

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

double TTool::getPixelSize() const {

  return m_viewer ? m_viewer->getPixelSize() : 1.0;

}

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

TXshCell TTool::getImageCell() {

  assert(m_application);

  TXshCell result;

  TFrameHandle *currentFrame    = m_application->getCurrentFrame();

  TXshLevelHandle *currentLevel = m_application->getCurrentLevel();

  if (currentFrame->isEditingLevel()) {

    if (TXshLevel *xl = currentLevel->getLevel()) {

      if (TXshSimpleLevel *sl = xl->getSimpleLevel()) {

        result.m_level   = xl;

        result.m_frameId = currentFrame->getFid();

      }

    }

  } else {

    if (TXsheet *xsh = m_application->getCurrentXsheet()->getXsheet()) {

      if (!m_application->getCurrentObject()->isSpline()) {

        int row = currentFrame->getFrame();

        int col = m_application->getCurrentColumn()->getColumnIndex();

        result = xsh->getCell(row, col);

      }

    }

  }

  return result;

}

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

TImage *TTool::getImage(bool toBeModified, int subsampling) {

  assert(m_application);

  if (m_application->getCurrentFrame()->isPlaying())

    toBeModified =

        false;  // In playback mode, you are not going to modify images

                // Probably useless - tools are disabled when playing...

  const TXshCell &cell = getImageCell();

  if (cell.isEmpty()) {

    TObjectHandle *currentObject = m_application->getCurrentObject();

    return currentObject->isSpline() ? currentObject->getSplineImage()

                                     : (TImage *)0;

  } else

    return cell.getImage(toBeModified, subsampling).getPointer();

}

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

TImage *TTool::touchImage() {

  if (!m_application) return 0;

  m_cellsData.clear();

  m_oldFids.clear();

  m_newFids.clear();

  m_isLevelCreated     = false;

  m_isFrameCreated     = false;

  m_isLevelRenumbererd = false;

  Preferences *pref    = Preferences::instance();

  bool isAutoCreateEnabled        = pref->isAutoCreateEnabled();

  bool animationSheetEnabled      = pref->isAnimationSheetEnabled();

  bool isAutoStretchEnabled       = pref->isAutoStretchEnabled();

  bool isAutoRenumberEnabled      = pref->isAutorenumberEnabled();

  bool isCreateInHoldCellsEnabled = pref->isCreationInHoldCellsEnabled();

  TFrameHandle *currentFrame    = m_application->getCurrentFrame();

  TXshLevelHandle *currentLevel = m_application->getCurrentLevel();

  if (currentFrame->isEditingLevel()) {

    // Editing level

    // no level => return 0

    TXshLevel *xl = currentLevel->getLevel();

    if (!xl) return 0;

    TXshSimpleLevel *sl = xl->getSimpleLevel();

    if (!sl || sl->isEmpty()) return 0;

    TFrameId fid = currentFrame->getFid();

    TImageP img  = sl->getFrame(fid, true);

    if (!img) {

      // no drawing found

      if (sl->isSubsequence() || sl->isReadOnly() || !isAutoCreateEnabled)

        return 0;

      // create a new drawing

      img = sl->createEmptyFrame();

      sl->setFrame(fid, img);

      currentLevel->notifyLevelChange();

      m_isFrameCreated = true;

    }

    return img.getPointer();

  }

  //- - - - editing xsheet case starts here - - - -

  if (m_application->getCurrentObject()->isSpline()) return 0;

  TSceneHandle *currentScene = m_application->getCurrentScene();

  ToonzScene *scene          = currentScene->getScene();

  int row                    = currentFrame->getFrame();

  int col = m_application->getCurrentColumn()->getColumnIndex();

  if (col < 0) return 0;

  TXsheetHandle *currentXsheet = m_application->getCurrentXsheet();

  TXsheet *xsh                 = currentXsheet->getXsheet();

  if (!xsh) return 0;

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

  TXshSimpleLevel *sl = cell.getSimpleLevel();

  if (sl) {

    // current cell is not empty

    if (isCreateInHoldCellsEnabled && row > 0 &&

        xsh->getCell(row - 1, col) == xsh->getCell(row, col)) {

      // CreateInHoldCells is enabled and the current cell is a "hold".

      // We must create a new drawing.

      // measure the hold length (starting from the current row) : r0-r1

      int r0 = row, r1 = row;

      if (isAutoStretchEnabled)

        while (xsh->getCell(r1 + 1, col) == cell) r1++;

      // find the proper frameid (possibly addisng suffix, in order to avoid a

      // fid already used)

      // find the proper frameid

      TFrameId fid;

      TXshCellColumn *column = xsh->getColumn(col)->getCellColumn();

      if (isAutoRenumberEnabled && column) {

        TFrameId maxFid;

        if (animationSheetEnabled) {

          fid    = TFrameId(row + 1);

          maxFid = TFrameId(row);

        } else {

          int r_begin, r_end;

          column->getRange(r_begin, r_end);

          fid = getDesiredFId(column, r_begin, sl, row, maxFid);

        }

        // renumber fids

        sl->getFids(m_oldFids);

        m_isLevelRenumbererd = ToolUtils::renumberForInsertFId(

            sl, fid, maxFid, scene->getTopXsheet());

        if (m_isLevelRenumbererd) sl->getFids(m_newFids);

      } else

        fid = (animationSheetEnabled) ? getNewFrameId(sl, row)

                                      : sl->index2fid(sl->getFrameCount());

      // create the new drawing

      TImageP img      = sl->createEmptyFrame();

      m_isFrameCreated = true;

      // insert the drawing in the level

      sl->setFrame(fid, img);

      // update the cell

      cell = TXshCell(sl, fid);

      // update the xsheet (change the current cell and possibly all the

      // following "hold")

      for (int r = r0; r <= r1; r++) xsh->setCell(r, col, cell);

      // notify

      currentXsheet->notifyXsheetChanged();

      currentScene->notifyCastChange();

      currentLevel->notifyLevelChange();

      m_cellsData.push_back({r0, r1, CellOps::ExistingToNew});

    }

    // if the level does not contain a frame in the current cell

    // (i.e. drawing on the cell with red numbers)

    else if (!sl->isFid(cell.getFrameId())) {

      // no drawing found

      if (sl->isSubsequence() || sl->isReadOnly() || !isAutoCreateEnabled)

        return 0;

      // create a new drawing

      TImageP img = sl->createEmptyFrame();

      sl->setFrame(cell.getFrameId(), img);

      currentXsheet->notifyXsheetChanged();

      currentLevel->notifyLevelChange();

      m_isFrameCreated = true;

      return img.getPointer();

    }

    // we've found the image. return it.

    return cell.getImage(true).getPointer();

  }

  // current cell is empty.

  if (!isAutoCreateEnabled) return 0;

  // get the column range

  int r0, r1;

  xsh->getCellRange(col, r0, r1);

  // in case the column is not empty

  if (r0 <= r1) {

    // We must create a new drawing in the column level and possibly add "holds"

    // find the last not-empty cell before the current one (a) and the first

    // after (b)

    int a = row - 1, b = row + 1;

    while (a >= r0 && xsh->getCell(a, col).isEmpty()) a--;

    while (b <= r1 && xsh->getCell(b, col).isEmpty()) b++;

    // find the level we must attach to

    if (a >= r0) {

      // there is a not-empty cell before the current one

      sl = xsh->getCell(a, col).getSimpleLevel();

    } else if (b <= r1) {

      sl = xsh->getCell(b, col).getSimpleLevel();

    }

    if (sl && !sl->isSubsequence() && !sl->isReadOnly()) {

      // note: sl should be always !=0 (the column is not empty)

      // if - for some reason - it is == 0 or it is not editable,

      // then we skip to empty-column behaviour

      // create the drawing

      // find the proper frameid

      TFrameId fid;

      TXshCellColumn *column = xsh->getColumn(col)->getCellColumn();

      if (isAutoRenumberEnabled && column) {

        TFrameId maxFid(row);

        fid = (animationSheetEnabled)

                  ? TFrameId(row + 1)

                  : getDesiredFId(column, r0, sl, row, maxFid);

        sl->getFids(m_oldFids);

        m_isLevelRenumbererd = ToolUtils::renumberForInsertFId(

            sl, fid, maxFid, scene->getTopXsheet());

        if (m_isLevelRenumbererd) sl->getFids(m_newFids);

      } else

        fid = (animationSheetEnabled) ? getNewFrameId(sl, row)

                                      : sl->index2fid(sl->getFrameCount());

      // create the new drawing

      TImageP img      = sl->createEmptyFrame();

      m_isFrameCreated = true;

      // insert the drawing in the level

      sl->setFrame(fid, img);

      // update the cell

      cell = TXshCell(sl, fid);

      xsh->setCell(row, col, cell);

      // create holds

      if (!isAutoStretchEnabled) {

        m_cellsData.push_back({row, row, CellOps::BlankToNew});

      } else {

        if (a >= r0) {

          // create a hold before : [a+1, row-1]

          TXshCell aCell = xsh->getCell(a, col);

          for (int i = a + 1; i < row; i++) xsh->setCell(i, col, aCell);

          m_cellsData.push_back({a + 1, row - 1, CellOps::BlankToExisting});

          if (b <= r1 && xsh->getCell(b, col).getSimpleLevel() == sl) {

            // create also a hold after

            for (int i = row + 1; i < b; i++) xsh->setCell(i, col, cell);

            m_cellsData.push_back({row, b - 1, CellOps::BlankToNew});

          } else {

            m_cellsData.push_back({row, row, CellOps::BlankToNew});

          }

        } else if (b <= r1) {

          // create a hold after

          for (int i = row + 1; i < b; i++) xsh->setCell(i, col, cell);

          m_cellsData.push_back({row, b - 1, CellOps::BlankToNew});

        }

      }

      // notify & return

      currentXsheet->notifyXsheetChanged();

      currentScene->notifyCastChange();

      currentLevel->notifyLevelChange();

      return cell.getImage(true).getPointer();

    }

  }

  // - - - - empty column case starts here - - - -

  // autoCreate is enabled: we must create a new level

  int levelType    = pref->getDefLevelType();

  TXshLevel *xl    = scene->createNewLevel(levelType);

  sl               = xl->getSimpleLevel();

  m_isLevelCreated = true;

  // create the drawing

  TFrameId fid = animationSheetEnabled ? getNewFrameId(sl, row) : TFrameId(1);

  TImageP img  = sl->createEmptyFrame();

  m_isFrameCreated = true;

  sl->setFrame(fid, img);

  cell = TXshCell(sl, fid);

  xsh->setCell(row, col, cell);

  m_cellsData.push_back({row, row, CellOps::BlankToNew});  // vuoto => nuovo

  currentXsheet->notifyXsheetChanged();

  currentScene->notifyCastChange();

  currentLevel->notifyLevelChange();

  return img.getPointer();

}

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

void TTool::updateToolsPropertiesTranslation() {

  ToolTable::iterator tt, tEnd(toolTable->end());

  for (tt = toolTable->begin(); tt != tEnd; ++tt)

    tt->second->updateTranslation();

}

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

void TTool::invalidate(const TRectD &rect) {

  if (m_viewer) {

    if (rect.isEmpty())

      m_viewer->GLInvalidateAll();

    else {

      TPointD dpiScale(1, 1);

      TXshSimpleLevel *sl =

          getApplication()->getCurrentLevel()->getSimpleLevel();

      if (sl) dpiScale = getCurrentDpiScale(sl, getCurrentFid());

      m_viewer->GLInvalidateRect(getCurrentColumnMatrix() *

                                 TScale(dpiScale.x, dpiScale.y) * rect);

    }

  }

}

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

int TTool::pick(const TPointD &p) {

  if (!m_viewer) return 0;

  m_picking = true;

  int ret   = m_viewer->pick(p);

  m_picking = false;

  return ret;

}

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

TXsheet *TTool::getXsheet() const {

  if (!m_application) return 0;

  return m_application->getCurrentXsheet()->getXsheet();

}

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

int TTool::getFrame() {

  if (!m_application) return 0;

  return m_application->getCurrentFrame()->getFrame();

}

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

int TTool::getColumnIndex() {

  if (!m_application) return 0;

  return m_application->getCurrentColumn()->getColumnIndex();

}

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

TStageObjectId TTool::getObjectId() {

  if (!m_application) return TStageObjectId();

  return m_application->getCurrentObject()->getObjectId();

}

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

TTool::Application *TTool::getApplication() {

  if (m_application == 0)

    assert(!"you MUST call the TTool::setApplication function in the main of the program!");

  return m_application;

}

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

/*! Notify change of current image: update icon and notify level change.

    If current object is a spline commit spline chenged.

    If current mode is EditingLevel touch current frame.

*/

void TTool::notifyImageChanged() {

  onImageChanged();

  if (!m_application) return;

  m_application->getCurrentScene()->setDirtyFlag(true);

  if (m_application->getCurrentFrame()->isEditingLevel()) {

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

    if (!xl) return;

    TXshSimpleLevel *sl = xl->getSimpleLevel();

    if (!sl) return;

    TFrameId fid = m_application->getCurrentFrame()->getFid();

    sl->touchFrame(fid);

    // sl->setDirtyFlag(true);

    IconGenerator::instance()->invalidate(sl, fid);

    IconGenerator::instance()->invalidateSceneIcon();

  } else {

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

    if (!xsh) return;

    TObjectHandle *currentObject = m_application->getCurrentObject();

    if (currentObject->isSpline()) {

      m_application->getCurrentObject()->commitSplineChanges();

      TStageObject *pegbar = xsh->getStageObject(currentObject->getObjectId());

      IconGenerator::instance()->invalidate(pegbar->getSpline());

    } else {

      int row = m_application->getCurrentFrame()->getFrame();

      int col = m_application->getCurrentColumn()->getColumnIndex();

      if (col < 0) return;

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

      TXshSimpleLevel *sl = cell.getSimpleLevel();

      if (sl) {

        IconGenerator::instance()->invalidate(sl, cell.m_frameId);

        sl->touchFrame(cell.m_frameId);

        IconGenerator::instance()->invalidateSceneIcon();

      }

    }

  }

  m_application->getCurrentLevel()->notifyLevelChange();

}

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

/*! Notify change of image in \b fid: update icon and notify level change.

 */

void TTool::notifyImageChanged(const TFrameId &fid) {

  onImageChanged();

  if (!m_application) return;

  m_application->getCurrentScene()->setDirtyFlag(true);

  if (m_application->getCurrentFrame()->isEditingLevel()) {

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

    if (!xl) return;

    TXshSimpleLevel *sl = xl->getSimpleLevel();

    if (!sl) return;

    sl->setDirtyFlag(true);

    IconGenerator::instance()->invalidate(sl, fid);

    IconGenerator::instance()->invalidateSceneIcon();

  } else {

    int row = m_application->getCurrentFrame()->getFrame();

    int col = m_application->getCurrentColumn()->getColumnIndex();

    if (col < 0) return;

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

    if (!xsh) return;

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

    TXshSimpleLevel *sl = cell.getSimpleLevel();

    if (sl) {

      IconGenerator::instance()->invalidate(sl, fid);

      IconGenerator::instance()->invalidateSceneIcon();

      sl->setDirtyFlag(true);

    }

  }

  m_application->getCurrentLevel()->notifyLevelChange();

}

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

TFrameId TTool::getCurrentFid() const {

  if (!m_application) return TFrameId();

  TFrameHandle *fh = m_application->getCurrentFrame();

  if (fh->isEditingLevel()) return fh->getFid();

  int row = m_application->getCurrentFrame()->getFrame();

  int col = m_application->getCurrentColumn()->getColumnIndex();

  TXshCell cell =

      m_application->getCurrentXsheet()->getXsheet()->getCell(row, col);

  if (cell.isEmpty()) return TFrameId::NO_FRAME;

  return cell.getFrameId();

}

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

TAffine TTool::getCurrentColumnMatrix() const {

  return getColumnMatrix(m_application->getCurrentColumn()->getColumnIndex());

}

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

TAffine TTool::getCurrentColumnParentMatrix() const {

  if (!m_application) return TAffine();

  TFrameHandle *fh = m_application->getCurrentFrame();

  if (fh->isEditingLevel()) return TAffine();

  int frame       = fh->getFrame();

  int columnIndex = m_application->getCurrentColumn()->getColumnIndex();

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

  TStageObjectId parentId =

      xsh->getStageObjectParent(TStageObjectId::ColumnId(columnIndex));

  return xsh->getPlacement(parentId, frame);

}

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

TAffine TTool::getCurrentObjectParentMatrix() const {

  if (!m_application) return TAffine();

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

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

  TStageObjectId currentObjectId =

      m_application->getCurrentObject()->getObjectId();

  if (currentObjectId == TStageObjectId::NoneId) return TAffine();

  TStageObjectId parentId = xsh->getStageObjectParent(currentObjectId);

  if (parentId == TStageObjectId::NoneId)

    return TAffine();

  else

    return xsh->getPlacement(parentId, frame);

}

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

TAffine TTool::getColumnMatrix(int columnIndex) const {

  if (!m_application) return TAffine();

  TFrameHandle *fh = m_application->getCurrentFrame();

  if (fh->isEditingLevel()) return TAffine();

  int frame    = fh->getFrame();

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

  TStageObjectId columnObjId =

      (columnIndex >= 0)

          ? TStageObjectId::ColumnId(columnIndex)

          : TStageObjectId::CameraId(xsh->getCameraColumnIndex());

  TAffine columnPlacement = xsh->getPlacement(columnObjId, frame);

  double columnZ          = xsh->getZ(columnObjId, frame);

  TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();

  TStageObject *camera    = xsh->getStageObject(cameraId);

  TAffine cameraPlacement = camera->getPlacement(frame);

  double cameraZ          = camera->getZ(frame);

  TStageObject *object = xsh->getStageObject(columnObjId);

  TAffine placement;

  TStageObject::perspective(placement, cameraPlacement, cameraZ,

                            columnPlacement, columnZ,

                            object->getGlobalNoScaleZ());

  return placement;

}

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

TAffine TTool::getCurrentObjectParentMatrix2() const {

  TTool::Application *app = m_application;

  TFrameHandle *fh        = app->getCurrentFrame();

  if (fh->isEditingLevel()) return TAffine();

  int frame               = fh->getFrame();

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

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

  double objZ             = xsh->getZ(id, frame);

  TStageObjectId parentId = xsh->getStageObjectParent(id);

  if (parentId == TStageObjectId::NoneId) return TAffine();

  id                   = parentId;

  TAffine objPlacement = xsh->getPlacement(id, frame);

  TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();

  TStageObject *camera    = xsh->getStageObject(cameraId);

  TAffine cameraPlacement = camera->getPlacement(frame);

  double cameraZ          = camera->getZ(frame);

  TAffine placement;

  TStageObject::perspective(placement, cameraPlacement, cameraZ, objPlacement,

                            objZ, 0);

  return placement;

}

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

void TTool::updateMatrix() {

  assert(m_application);

  if (m_application->getCurrentObject()->isSpline())

    setMatrix(getCurrentObjectParentMatrix2());

  else

    setMatrix(getCurrentColumnMatrix());

}

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

void TTool::resetInputMethod() {

  if (m_viewer) m_viewer->resetInputMethod();

}

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

bool TTool::isColumnLocked(int columnIndex) const {

  if (columnIndex < 0) return false;

  TXsheet *xsh       = getXsheet();

  TXshColumn *column = xsh->getColumn(columnIndex);

  if (!column) return false;

  return column->isLocked();

}

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

QString TTool::updateEnabled() {

  int rowIndex    = m_application->getCurrentFrame()->getFrame();

  int columnIndex = m_application->getCurrentColumn()->getColumnIndex();

  return updateEnabled(rowIndex, columnIndex);

}

QString TTool::updateEnabled(int rowIndex, int columnIndex) {

  // Disable every tool during playback

  if (m_application->getCurrentFrame()->isPlaying())

    return (enable(false), QString());

  // Release Generic tools at once

  int toolType   = getToolType();

  int targetType = getTargetType();

  if (toolType == TTool::GenericTool) return (enable(true), QString());

  // Retrieve vars and view modes

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

  TXshColumn *column = (columnIndex >= 0) ? xsh->getColumn(columnIndex) : 0;

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

  TXshSimpleLevel *sl = xl ? xl->getSimpleLevel() : 0;

  int levelType       = sl ? sl->getType() : NO_XSHLEVEL;

  // If not in Level editor, let's use our current cell from the xsheet to

  // find the nearest level before it

  if (levelType == NO_XSHLEVEL &&

      !m_application->getCurrentFrame()->isEditingLevel()) {

    TXshCell cell = xsh->getCell(rowIndex, columnIndex);

    xl            = cell.isEmpty() ? 0 : (TXshLevel *)(&cell.m_level);

    sl            = cell.isEmpty() ? 0 : cell.getSimpleLevel();

    levelType     = cell.isEmpty() ? NO_XSHLEVEL : cell.m_level->getType();

  }

  if (Preferences::instance()->isAutoCreateEnabled()) {

    // If not in Level editor, let's use our current cell from the xsheet to

    // find the nearest level before it

    if (levelType == NO_XSHLEVEL &&

        !m_application->getCurrentFrame()->isEditingLevel()) {

      int r0, r1;

      xsh->getCellRange(columnIndex, r0, r1);

      for (int r = std::min(r1, rowIndex); r > r0; r--) {

        TXshCell cell = xsh->getCell(r, columnIndex);

        if (cell.isEmpty()) continue;

        xl        = (TXshLevel *)(&cell.m_level);

        sl        = cell.getSimpleLevel();

        levelType = cell.m_level->getType();

        break;

      }

    }

    // If the current tool does not match the current type, check for

    // a version of the same tool that does

    {

      TTool *tool = this;