#include "toonz/tstageobject.h"

// TnzLib includes

#include "toonz/tstageobjecttree.h"

#include "toonz/tstageobjectspline.h"

#include "toonz/txsheet.h"

#include "toonz/observer.h"

#include "toonz/txshlevelcolumn.h"

#include "toonz/txshcell.h"

#include "toonz/stage.h"

#include "toonz/tcamera.h"

#include "toonz/doubleparamcmd.h"

#include "toonz/tpinnedrangeset.h"

// TnzExt includes

#include "ext/plasticskeleton.h"

#include "ext/plasticskeletondeformation.h"

#include "ext/plasticdeformerstorage.h"

// TnzCore includes

#include "tstream.h"

#include "tstroke.h"

#include "tconvert.h"

#include "tundo.h"

#include "tconst.h"

// Qt includes

#include <qmetaobject></qmetaobject>

// STD includes

#include <fstream></fstream>

#include <set></set>

using namespace std;

//

// Per un problema su alcune macchine, solo Release.

// il problema si verifica ruotando gli oggetti sul camera stand

//

#ifdef _MSC_VER

#pragma optimize("", off)

#endif

static TAffine makeRotation(double ang) { return TRotation(ang); }

#ifdef _MSC_VER

#pragma optimize("", on)

#endif

DEFINE_CLASS_CODE(TStageObject, 102)

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

//    Local namespace

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

namespace {

enum StageObjectType {

  NONE   = 0,

  CAMERA = 1,

  TABLE  = 2,

  PEGBAR = 5,

  COLUMN = 6

};

const int StageObjectTypeShift = 28;

const int StageObjectMaxIndex  = ((1 << StageObjectTypeShift) - 1);

const int StageObjectIndexMask = ((1 << StageObjectTypeShift) - 1);

}  // namespace

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

//    TStageObjectParams  implementation

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

TStageObjectParams::TStageObjectParams() : m_spline(0), m_noScaleZ(0) {}

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

TStageObjectParams::TStageObjectParams(TStageObjectParams *data)

    : m_id(data->m_id)

    , m_parentId(data->m_parentId)

    , m_children(data->m_children)

    , m_keyframes(data->m_keyframes)

    , m_cycleEnabled(data->m_cycleEnabled)

    , m_spline(data->m_spline)

    , m_status(data->m_status)

    , m_handle(data->m_handle)

    , m_parentHandle(data->m_parentHandle)

    , m_x(data->m_x)

    , m_y(data->m_y)

    , m_z(data->m_z)

    , m_so(data->m_so)

    , m_rot(data->m_rot)

    , m_scalex(data->m_scalex)

    , m_scaley(data->m_scaley)

    , m_scale(data->m_scale)

    , m_posPath(data->m_posPath)

    , m_shearx(data->m_shearx)

    , m_sheary(data->m_sheary)

    , m_skeletonDeformation(data->m_skeletonDeformation)

    , m_noScaleZ(data->m_noScaleZ)

    , m_center(data->m_center)

    , m_offset(data->m_offset)

    , m_name(data->m_name)

    , m_isOpened(data->m_isOpened)

    , m_pinnedRangeSet(data->m_pinnedRangeSet->clone()) {}

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

TStageObjectParams::~TStageObjectParams() { delete m_pinnedRangeSet; }

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

TStageObjectParams *TStageObjectParams::clone() {

  return new TStageObjectParams(this);

}

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

// Utility Functions

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

TStageObjectId toStageObjectId(string s) {

  if (s == "None")

    return TStageObjectId::NoneId;

  else if (s == "Table")

    return TStageObjectId::TableId;

  else if (isInt(s)) {

    TStageObjectId id;

    id.setCode(std::stoi(s));

    return id;

  } else if (s.length() > 3) {

    if (s.substr(0, 3) == "Col")

      return TStageObjectId::ColumnId(std::stoi(s.substr(3)) - 1);

    else if (s.substr(0, 3) == "Peg")

      return TStageObjectId::PegbarId(std::stoi(s.substr(3)) - 1);

    else if (s.length() > 6 && s.substr(0, 6) == "Camera")

      return TStageObjectId::CameraId(std::stoi(s.substr(6)) - 1);

  }

  return TStageObjectId::NoneId;

}

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

ostream &operator<<(ostream &out, const TStageObjectId &id) {

  return out << id.toString();

}

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

//    TStageObjectId  implementation

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

TStageObjectId::TStageObjectId() : m_id(NONE << StageObjectTypeShift) {}

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

TStageObjectId::~TStageObjectId() {}

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

bool TStageObjectId::isCamera() const {

  return m_id >> StageObjectTypeShift == CAMERA;

}

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

bool TStageObjectId::isTable() const {

  return m_id >> StageObjectTypeShift == TABLE;

}

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

bool TStageObjectId::isPegbar() const {

  return m_id >> StageObjectTypeShift == PEGBAR;

}

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

bool TStageObjectId::isColumn() const {

  return m_id >> StageObjectTypeShift == COLUMN;

}

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

const TStageObjectId TStageObjectId::NoneId(NONE << StageObjectTypeShift);

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

const TStageObjectId TStageObjectId::TableId(TABLE << StageObjectTypeShift);

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

const TStageObjectId TStageObjectId::CameraId(int index) {

  assert(0 <= index && index <= StageObjectMaxIndex);

  return TStageObjectId(CAMERA << StageObjectTypeShift | index);

}

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

const TStageObjectId TStageObjectId::PegbarId(int index) {

  assert(0 <= index && index <= StageObjectMaxIndex);

  return TStageObjectId(PEGBAR << StageObjectTypeShift | index);

}

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

const TStageObjectId TStageObjectId::ColumnId(int index) {

  assert(0 <= index && index <= StageObjectMaxIndex);

  return TStageObjectId(COLUMN << StageObjectTypeShift | index);

}

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

string TStageObjectId::toString() const {

  int index = m_id & StageObjectIndexMask;

  string shortName;

  switch (m_id >> StageObjectTypeShift) {

  case NONE:

    shortName = "None";

    break;

  case CAMERA:

    shortName = "Camera" + std::to_string(index + 1);

    break;

  case TABLE:

    shortName = "Table";

    break;

  case PEGBAR:

    shortName = "Peg" + std::to_string(index + 1);

    break;

  case COLUMN:

    shortName = "Col" + std::to_string(index + 1);

    break;

  default:

    shortName = "BadPegbar";

  }

  return shortName;

}

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

int TStageObjectId::getIndex() const { return m_id & StageObjectIndexMask; }

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

namespace {  // TStageObject Utility

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

TDoubleKeyframe withFrame(TDoubleKeyframe k, double frame) {

  k.m_frame = frame;

  return k;

}

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

bool setKeyframe(const TDoubleParamP ¶m, const TDoubleKeyframe &kf,

                 int frame, const double &easeIn, const double &easeOut) {

  if (!kf.m_isKeyframe) return false;

  TDoubleKeyframe kfCopy = kf;

  kfCopy.m_frame = frame;

  if (easeIn >= 0.0) kfCopy.m_speedIn = TPointD(-easeIn, kfCopy.m_speedIn.y);

  if (easeOut >= 0.0) kfCopy.m_speedOut = TPointD(easeOut, kfCopy.m_speedOut.y);

  param->setKeyframe(kfCopy);

  return true;

}

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

void setkey(const TDoubleParamP ¶m, int frame) {

  KeyframeSetter setter(param.getPointer(), -1, false);

  setter.createKeyframe(frame);

}

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

void updateUnit(TDoubleParam *param) {

  for (int i = 0; i < param->getKeyframeCount(); i++) {

    TDoubleKeyframe k = param->getKeyframe(i);

    k.m_value /= Stage::inch;

    param->setKeyframe(i, k);

  }

}

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

string convertTo4InchCenterUnits(string handle) {

  // per convenzione un handle del tipo 'a'..'z' utilizza

  // la vecchia convenzione per i centri (4 inch invece di 8)

  if (handle.length() == 1 && 'A' <= handle[0] && handle[0] <= 'Z' &&

      handle[0] != 'B')

    return string(1, handle[0] + 'a' - 'A');

  else

    return handle;

}

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

TPointD updateDagPosition(const TPointD &pos, const VersionNumber &tnzVersion) {

  if (tnzVersion < VersionNumber(1, 16)) return TConst::nowhere;

  return pos;

}

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

// Update the passed stage object keyframe and keyframe type specification with

// a new keyframe. Returns true if specifications match, false otherwise.

bool touchEaseAndCompare(const TDoubleKeyframe &kf,

                         TStageObject::Keyframe &stageKf,

                         TDoubleKeyframe::Type &type) {

  bool initialization = (type == TDoubleKeyframe::None);

  if (initialization) type = kf.m_type;

  if (kf.m_type != type || (kf.m_type != TDoubleKeyframe::SpeedInOut &&

                            kf.m_type != TDoubleKeyframe::EaseInOut &&

                            (kf.m_prevType != TDoubleKeyframe::None &&

                             kf.m_prevType != TDoubleKeyframe::SpeedInOut &&

                             kf.m_prevType != TDoubleKeyframe::EaseInOut))) {

    stageKf.m_easeIn  = -1.0;

    stageKf.m_easeOut = -1.0;

    return false;

  }

  double easeIn = -kf.m_speedIn.x;

  if (initialization)

    stageKf.m_easeIn = easeIn;

  else if (stageKf.m_easeIn != easeIn)

    stageKf.m_easeIn = -1.0;

  double easeOut = kf.m_speedOut.x;

  if (initialization)

    stageKf.m_easeOut = easeOut;

  else if (stageKf.m_easeOut != easeOut)

    stageKf.m_easeOut = -1.0;

  return true;

}

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

}  // namespace

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

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

//    TStageObject::LazyData  implementation

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

TStageObject::LazyData::LazyData() : m_time(-1.0) {}

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

//    TStageObject  implementation

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

TStageObject::TStageObject(TStageObjectTree *tree, TStageObjectId id)

    : m_tree(tree)

    , m_id(id)

    , m_parent(0)

    , m_name("")

    , m_isOpened(false)

    , m_spline(0)

    , m_status(XY)

    , m_x(new TDoubleParam())

    , m_y(new TDoubleParam())

    , m_z(new TDoubleParam())

    , m_so(new TDoubleParam())

    , m_rot(new TDoubleParam())

    , m_scalex(new TDoubleParam(1.0))

    , m_scaley(new TDoubleParam(1.0))

    , m_scale(new TDoubleParam(1.0))

    , m_posPath(new TDoubleParam())

    , m_shearx(new TDoubleParam())

    , m_sheary(new TDoubleParam())

    , m_center()

    , m_offset()

    , m_cycleEnabled(false)

    , m_handle("B")

    , m_parentHandle("B")

    , m_dagNodePos(TConst::nowhere)

    , m_camera(0)

    , m_locked(false)

    , m_noScaleZ(0)

    , m_pinnedRangeSet(0)

    , m_ikflag(0)

    , m_groupSelector(-1) {

  // NOTA: per le unita' di misura controlla anche tooloptions.cpp

  m_x->setName("W_X");

  m_x->setMeasureName("length.x");

  m_x->addObserver(this);

  m_y->setName("W_Y");

  m_y->setMeasureName("length.y");

  m_y->addObserver(this);

  m_z->setName("W_Z");

  m_z->setMeasureName(id.isCamera() ? "zdepth.cam" : "zdepth");

  m_z->addObserver(this);

  m_so->setName("W_SO");

  m_so->addObserver(this);

  m_rot->setName("W_Rotation");

  m_rot->setMeasureName("angle");

  m_rot->addObserver(this);

  m_scalex->setName("W_ScaleH");

  m_scalex->setMeasureName("scale");

  m_scalex->addObserver(this);

  m_scaley->setName("W_ScaleV");

  m_scaley->setMeasureName("scale");

  m_scaley->addObserver(this);

  m_scale->setName("W_Scale");

  m_scale->setMeasureName("scale");

  m_scale->addObserver(this);

  m_shearx->setName("W_ShearH");

  m_shearx->setMeasureName("shear");

  m_shearx->addObserver(this);

  m_sheary->setName("W_ShearV");

  m_sheary->setMeasureName("shear");

  m_sheary->addObserver(this);

  m_posPath->setName("posPath");

  m_posPath->setMeasureName("percentage2");

  m_posPath->addObserver(this);

  m_tree->setGrammar(m_x);

  m_tree->setGrammar(m_y);

  m_tree->setGrammar(m_z);

  m_tree->setGrammar(m_so);

  m_tree->setGrammar(m_rot);

  m_tree->setGrammar(m_scalex);

  m_tree->setGrammar(m_scaley);

  m_tree->setGrammar(m_scale);

  m_tree->setGrammar(m_shearx);

  m_tree->setGrammar(m_sheary);

  m_tree->setGrammar(m_posPath);

  if (id.isCamera()) m_camera = new TCamera();

  m_pinnedRangeSet = new TPinnedRangeSet();

}

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

TStageObject::~TStageObject() {

  if (m_spline) {

    if (m_posPath) m_spline->removeParam(m_posPath.getPointer());

    m_spline->release();

  }

  if (m_x) m_x->removeObserver(this);

  if (m_y) m_y->removeObserver(this);

  if (m_z) m_z->removeObserver(this);

  if (m_so) m_so->removeObserver(this);

  if (m_rot) m_rot->removeObserver(this);

  if (m_scalex) m_scalex->removeObserver(this);

  if (m_scaley) m_scaley->removeObserver(this);

  if (m_scale) m_scale->removeObserver(this);

  if (m_shearx) m_shearx->removeObserver(this);

  if (m_sheary) m_sheary->removeObserver(this);

  if (m_posPath) m_posPath->removeObserver(this);

  if (m_skeletonDeformation) {

    PlasticDeformerStorage::instance()->releaseDeformationData(

        m_skeletonDeformation.getPointer());

    m_skeletonDeformation->removeObserver(this);

  }

  delete m_camera;

  delete m_pinnedRangeSet;

}

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

const TStageObject::LazyData &TStageObject::lazyData() const {

  return m_lazyData([this](LazyData &ld) { this->update(ld); });

}

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

TStageObject::LazyData &TStageObject::lazyData() {

  return const_cast<lazydata &="">(</lazydata>

      static_cast<const &="" tstageobject="">(*this).lazyData());</const>

}

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

void TStageObject::update(LazyData &ld) const {

  if (ld.m_time >= 0.0) invalidate(ld);

  updateKeyframes(ld);

}

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

void TStageObject::onChange(const class TParamChange &c) {

  // Rationale: Since a stage object holds many parameters (or par references),

  // it may receive multiple notifications at the same time - but it should

  // actually refresh its data only ONCE for 'em all.

  // Even worse, the stage object may be notified for EACH touched key of just

  // one of its parameters. This means this function gets called A LOT.

  // Thus, we're just SCHEDULING for a data refresh. The actual refresh happens

  // whenever the scheduled data is accessed.

  if (c.m_keyframeChanged)

    m_lazyData.invalidate();  // Both invalidate placement AND keyframes

  else

    invalidate();  // Invalidate placement only

}

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

TStageObjectId TStageObject::getId() const { return m_id; }

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

double TStageObject::paramsTime(double t) const {

  const KeyframeMap &keyframes = lazyData().m_keyframes;

  if (m_cycleEnabled && keyframes.size() > 1) {

    int firstT = keyframes.begin()->first;

    if (t <= firstT) return t;

    int lastT  = keyframes.rbegin()->first;

    int tRange = lastT - firstT + 1;

    assert(tRange > 0);

    int it    = tfloor(t);

    double ft = t - it;

    return firstT + ((it - firstT) % tRange) + ft;

  } else

    return t;

}

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

void TStageObject::setName(const std::string &name) {

  m_name = (name == m_id.toString()) ? std::string() : name;

}

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

string TStageObject::getName() const {

  if (m_name != "") return m_name;

  if (!m_id.isColumn()) return m_id.toString();

  return "Col" + std::to_string(m_id.getIndex() + 1);

}

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

string TStageObject::getFullName() const {

  string name = getName();

  if (m_id.isColumn()) {

    if (name.find("Col") == 0 && name.length() > 3 &&

        name.find_first_not_of("0123456789", 3) == string::npos)

      return name;

    else

      return name + " (" + std::to_string(m_id.getIndex() + 1) + ")";

  } else

    return name;

}

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

void TStageObject::setParent(const TStageObjectId &parentId) {

  assert(m_tree);

  TStageObject *newParent = 0;

  if (parentId != TStageObjectId::NoneId) {

    newParent = m_tree->getStageObject(parentId);

    assert(newParent);

    // cerco di evitare i cicli

    TStageObject *p = newParent;

    while (p->m_parent) {

      if (p->m_parent->getId() == getId()) return;

      p = p->m_parent;

    }

  } else {

    if (!m_id.isCamera() && !m_id.isTable()) {

      newParent = m_tree->getStageObject(TStageObjectId::TableId);

      assert(newParent);

    }

  }

  if (m_parent) m_parent->m_children.remove(this);

  m_parent = newParent;

  if (m_parent) m_parent->m_children.insert(m_parent->m_children.end(), this);

  invalidate();

#ifndef NDEBUG

  if (m_id.isCamera()) {

  } else if (m_id.isTable()) {

    assert(m_parent == 0);

  } else if (m_id.isColumn()) {

    assert(m_parent &&

           (m_parent->m_id.isTable() || m_parent->m_id.isColumn() ||

            m_parent->m_id.isPegbar() || m_parent->m_id.isCamera()));

  } else if (m_id.isPegbar()) {

    assert(m_parent && (m_parent->m_id.isTable() || m_parent->m_id.isCamera() ||

                        m_parent->m_id.isPegbar()));

  } else {

    assert(0);

  }

#endif

}

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

void TStageObject::detachFromParent() {

  if (m_parent) m_parent->m_children.remove(this);

  m_parent = 0;

  invalidate();

}

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

void TStageObject::attachChildrenToParent(const TStageObjectId &parentId) {

  while (!m_children.empty()) {

    TStageObject *son = *m_children.begin();

    if (son) son->setParent(parentId);

  }

}

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

TStageObjectId TStageObject::getParent() const {

  return m_parent ? m_parent->m_id : TStageObjectId();

}

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

bool TStageObject::isAncestor(TStageObject *stageObject) const {

  if (!stageObject) return false;

  if (stageObject == (TStageObject *)m_parent)

    return true;

  else if (m_parent == 0)

    return false;

  else

    return m_parent->isAncestor(stageObject);

}

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

TStageObjectSpline *TStageObject::getSpline() const { return m_spline; }

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

void TStageObject::doSetSpline(TStageObjectSpline *spline) {

  TDoubleParam *param = m_posPath.getPointer();

  bool uppkEnabled    = isUppkEnabled();

  if (!spline) {

    if (uppkEnabled && m_spline) m_spline->removeParam(param);

    if (m_spline) m_spline->release();

    m_spline = 0;

    enablePath(false);

  } else {

    if (m_spline != spline) {

      if (m_spline && uppkEnabled) m_spline->removeParam(param);

      if (m_spline) m_spline->release();

      m_spline = spline;

      m_spline->addRef();

      if (m_spline && uppkEnabled) m_spline->addParam(param);

    }

    if (!isPathEnabled()) enablePath(true);

  }

}

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

void TStageObject::setSpline(TStageObjectSpline *spline) {

  doSetSpline(spline);

  TNotifier::instance()->notify(TXsheetChange());

  TNotifier::instance()->notify(TStageChange());

  invalidate();

}

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

void TStageObject::setStatus(Status status) {

  if (m_status == status) return;

  bool oldPathEnabled = isPathEnabled();

  bool oldUppkEnabled = isUppkEnabled();

  m_status            = status;

  bool pathEnabled    = isPathEnabled();

  bool uppkEnabled    = isUppkEnabled();

  if (pathEnabled) {

    if (!m_spline)

      doSetSpline(m_tree->createSpline());

    else if (oldUppkEnabled != uppkEnabled) {

      TDoubleParam *param = getParam(T_Path);

      if (uppkEnabled)

        m_spline->addParam(param);

      else

        m_spline->removeParam(param);

    }

  } else {

    doSetSpline(0);

  }

  invalidate();

}

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

void TStageObject::enableAim(bool enabled) {

  setStatus((Status)((m_status & ~STATUS_MASK) | (enabled ? PATH_AIM : PATH)));

}

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

void TStageObject::enablePath(bool enabled) {

  if (isPathEnabled() != enabled) setStatus(enabled ? PATH : XY);

}

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

void TStageObject::enableUppk(bool enabled) {

  assert(isPathEnabled());

  setStatus((Status)((m_status & ~UPPK_MASK) | (enabled ? UPPK_MASK : 0)));

}

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

void TStageObject::setCenter(double frame, const TPointD ¢er) {

  TPointD c = center - getHandlePos(m_handle, (int)frame);

  TAffine aff   = computeLocalPlacement(frame);

  TPointD delta = aff * c - aff * m_center;

  m_center      = c;

  m_offset += delta;

  invalidate();

}

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

TPointD TStageObject::getCenter(double frame) const {

  return m_center + getHandlePos(m_handle, (int)frame);

}

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

TPointD TStageObject::getOffset() const { return m_offset; }

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

void TStageObject::setOffset(const TPointD &off) {

  m_offset = off;

  invalidate();

}

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

void TStageObject::getCenterAndOffset(TPointD ¢er, TPointD &offset) const {

  center = m_center;

  offset = m_offset;

}

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

void TStageObject::setCenterAndOffset(const TPointD ¢er,

                                      const TPointD &offset) {

  m_center = center;

  m_offset = offset;

  invalidate();

}

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

void TStageObject::setHandle(const std::string &s) {

  m_handle = s;

  if (!s.empty() && s[0] == 'H') m_offset = m_center = TPointD();

  invalidate();

}

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

void TStageObject::setParentHandle(const std::string &s) {

  m_parentHandle = s;

  invalidate();

}

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

TPointD TStageObject::getHandlePos(string handle, int row) const {

  double unit = 8;

  if (handle == "")

    return TPointD();

  else if (handle.length() > 1 && handle[0] == 'H')

    return m_tree->getHandlePos(m_id, handle, row);

  else if (handle.length() == 1 && 'A' <= handle[0] && handle[0] <= 'Z')

    return TPointD(unit * (handle[0] - 'B'), 0);

  else if (handle.length() == 1 && 'a' <= handle[0] && handle[0] <= 'z')

    return TPointD(0.5 * unit * (handle[0] - 'b'), 0);

  else

    return TPointD(0, 0);

}

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

bool TStageObject::isKeyframe(int frame) const {

  const KeyframeMap &keyframes = lazyData().m_keyframes;

  return keyframes.find(frame) != keyframes.end();

}

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

bool TStageObject::is52FullKeyframe(int frame) const {

  return m_rot->isKeyframe(frame) && m_x->isKeyframe(frame) &&

         m_y->isKeyframe(frame) && m_z->isKeyframe(frame) &&

         m_posPath->isKeyframe(frame) && m_scalex->isKeyframe(frame) &&

         m_scaley->isKeyframe(frame) && m_shearx->isKeyframe(frame) &&

         m_sheary->isKeyframe(frame);

}

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

bool TStageObject::isFullKeyframe(int frame) const {

  return m_rot->isKeyframe(frame) && m_x->isKeyframe(frame) &&

         m_y->isKeyframe(frame) && m_z->isKeyframe(frame) &&

         m_so->isKeyframe(frame) && m_posPath->isKeyframe(frame) &&

         m_scalex->isKeyframe(frame) && m_scaley->isKeyframe(frame) &&

         m_scale->isKeyframe(frame) && m_shearx->isKeyframe(frame) &&

         m_sheary->isKeyframe(frame);

}

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

TStageObject::Keyframe TStageObject::getKeyframe(int frame) const {

  const KeyframeMap &keyframes = lazyData().m_keyframes;

  std::map<int, tstageobject::keyframe="">::const_iterator it;</int,>

  it = keyframes.find(frame);

  if (it == keyframes.end()) {

    TStageObject::Keyframe k;

    k.m_channels[TStageObject::T_Angle]  = m_rot->getValue(frame);

    k.m_channels[TStageObject::T_X]      = m_x->getValue(frame);

    k.m_channels[TStageObject::T_Y]      = m_y->getValue(frame);

    k.m_channels[TStageObject::T_Z]      = m_z->getValue(frame);

    k.m_channels[TStageObject::T_SO]     = m_so->getValue(frame);

    k.m_channels[TStageObject::T_ScaleX] = m_scalex->getValue(frame);

    k.m_channels[TStageObject::T_ScaleY] = m_scaley->getValue(frame);

    k.m_channels[TStageObject::T_Scale]  = m_scale->getValue(frame);

    k.m_channels[TStageObject::T_Path]   = m_posPath->getValue(frame);

    k.m_channels[TStageObject::T_ShearX] = m_shearx->getValue(frame);

    k.m_channels[TStageObject::T_ShearY] = m_sheary->getValue(frame);

    if (m_skeletonDeformation)

      m_skeletonDeformation->getKeyframeAt(frame, k.m_skeletonKeyframe);

    k.m_isKeyframe = false;

    return k;

  } else

    return it->second;

}

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

void TStageObject::setKeyframeWithoutUndo(int frame,

                                          const TStageObject::Keyframe &k) {

  KeyframeMap &keyframes = lazyData().m_keyframes;

  bool keyWasSet = false;

  keyWasSet = ::setKeyframe(m_rot, k.m_channels[TStageObject::T_Angle], frame,

                            k.m_easeIn, k.m_easeOut) ||

              keyWasSet;

  keyWasSet = ::setKeyframe(m_x, k.m_channels[TStageObject::T_X], frame,

                            k.m_easeIn, k.m_easeOut) ||

              keyWasSet;

  keyWasSet = ::setKeyframe(m_y, k.m_channels[TStageObject::T_Y], frame,

                            k.m_easeIn, k.m_easeOut) ||