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

// Qt includes

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

#include <qpainter></qpainter>

#include <qglwidget>  // for QGLWidget::convertToGLFormat</qglwidget>

#include <qpainterpath></qpainterpath>

#include <qstring></qstring>

#include <qimage></qimage>

#include <qfont></qfont>

#include <qfontmetrics></qfontmetrics>

#include <qkeyevent></qkeyevent>

#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 if column ancestorIndex is column descentIndex or its parent or

// the parent of the parent, etc.

static 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;

}

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

static void getHooks(std::vector<hookdata> &hooks, TXsheet *xsh, int row,</hookdata>

                     int col, TPointD dpiScale) {

  // note. 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));

      }

    }

  }

}

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

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

                                int col) {

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

    }

  }

}

static 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    = std::to_string(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:"));

  m_mode.setItemUIName(BUILD_SKELETON, tr("Build Skeleton"));

  m_mode.setItemUIName(ANIMATE, tr("Animate"));

  m_mode.setItemUIName(INVERSE_KINEMATICS, tr("Inverse Kinematics"));

}

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

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              = "";

  // This undo block ends in leftButtonUp

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

  // change 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 on a hook: attach the current column via that 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) {

    // No gadget clicked.  Select the column

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

    getViewer()->posToColumnIndexes(e.m_pos, columnIndexes, 5.0, 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();

    if (e.isCtrlPressed() || e.isShiftPressed()) {

      // ctrl + click : toggle pinned center

      // shift + click : toggle temporary pin

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

      invalidate();

      m_dragTool = 0;

      return;

    }

    Skeleton *skeleton = new Skeleton();

    buildSkeleton(*skeleton, currentColumnIndex);

    if (skeleton->getBoneByColumnIndex(columnIndex) ==

        skeleton->getRootBone()) {

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

      m_device = TD_Translation;

    } else

      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(QKeyEvent *event) {

  ChangeDrawingTool tool(this, 0);

  switch (event->key()) {

  case Qt::Key_Up:

    tool.changeDrawing(1);

    break;

  case Qt::Key_Down:

    tool.changeDrawing(-1);

    break;

  default:

    return false;

    break;

  }

  invalidate();

  return true;

}

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

class TogglePinnedStatusUndo final : 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 override {

    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 override {

    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 override { 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;