void TKeyframeSelection::setKeyframes() {
  TApp *app                   = TApp::instance();
  TXsheetHandle *xsheetHandle = app->getCurrentXsheet();
  TXsheet *xsh                = xsheetHandle->getXsheet();
  TStageObjectId cameraId     = xsh->getStageObjectTree()->getCurrentCameraId();
  if (isEmpty()) return;
  Position pos         = *m_positions.begin();
  int row              = pos.first;
  int col              = pos.second;
  TStageObjectId id    = col < 0 ? cameraId : TStageObjectId::ColumnId(col);
  TStageObject *pegbar = xsh->getStageObject(id);
  if (!pegbar) return;
  if (pegbar->isKeyframe(row)) {
    TStageObject::Keyframe key = pegbar->getKeyframe(row);
    pegbar->removeKeyframeWithoutUndo(row);
    UndoRemoveKeyFrame *undo =
        new UndoRemoveKeyFrame(id, row, key, xsheetHandle);
    undo->setObjectHandle(app->getCurrentObject());
    TUndoManager::manager()->add(undo);
  } else {
    pegbar->setKeyframeWithoutUndo(row);
    UndoSetKeyFrame *undo = new UndoSetKeyFrame(id, row, xsheetHandle);
    undo->setObjectHandle(app->getCurrentObject());
    TUndoManager::manager()->add(undo);
  }
  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
  TApp::instance()->getCurrentObject()->notifyObjectIdChanged(false);
}

void Stage::visit(Visitor &visitor, const VisitArgs &args) {
  ToonzScene *scene        = args.m_scene;
  TXsheet *xsh             = args.m_xsh;
  int row                  = args.m_row;
  int col                  = args.m_col;
  const OnionSkinMask *osm = args.m_osm;
  bool camera3d            = args.m_camera3d;
  int xsheetLevel          = args.m_xsheetLevel;
  bool isPlaying           = args.m_isPlaying;

  StageBuilder sb;
  sb.m_vs                 = &visitor.m_vs;
  TStageObjectId cameraId = xsh->getStageObjectTree()->getCurrentCameraId();
  TStageObject *camera    = xsh->getStageObject(cameraId);
  TAffine cameraAff       = camera->getPlacement(row);
  double z                = camera->getZ(row);
  sb.m_cameraPlacement    = ZPlacement(cameraAff, z);
  sb.m_camera3d           = camera3d;
  sb.m_currentColumnIndex = col;
  sb.m_xsheetLevel        = xsheetLevel;
  sb.m_onionSkinMask      = *osm;
  Player::m_onionSkinFrontSize = 0;
  Player::m_onionSkinBackSize  = 0;
  sb.addFrame(sb.m_players, scene, xsh, row, 0, args.m_onlyVisible,
              args.m_checkPreviewVisibility);

  updateOnionSkinSize(sb.m_players);

  sb.visit(sb.m_players, visitor, isPlaying);
}

//-----------------------------------------------------------------------------
// data <- xsheet
void TKeyframeData::setKeyframes(std::set<Position> positions, TXsheet *xsh)
{
	if (positions.empty())
		return;

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

	std::set<Position>::iterator it = positions.begin();
	int r0 = it->first;
	int c0 = it->second;
	for (++it; it != positions.end(); ++it) {
		r0 = std::min(r0, it->first);
		c0 = std::min(c0, it->second);
	}

	for (it = positions.begin(); it != positions.end(); ++it) {
		int row = it->first;
		int col = it->second;
		TStageObject *pegbar = xsh->getStageObject(col >= 0 ? TStageObjectId::ColumnId(col) : cameraId);
		assert(pegbar);
		m_isPegbarsCycleEnabled[col] = pegbar->isCycleEnabled();
		if (pegbar->isKeyframe(row)) {
			Position p(row - r0, col - c0);
			TStageObject::Keyframe k = pegbar->getKeyframe(row);
			m_keyData[p] = k;
		}
	}
}

bool ViewerKeyframeNavigator::hasPrev() const {
  TStageObject *pegbar = getStageObject();
  if (!pegbar) return false;
  int r0, r1;
  pegbar->getKeyframeRange(r0, r1);
  return r0 <= r1 && getCurrentFrame() > r0;
}

void TColumnDataElement::storeColumn(TXsheet *xsh, int index, int fxFlags)
{
	if (index < 0)
		return;

	bool doClone = (fxFlags & eDoClone);
	bool resetFxDagPositions = (fxFlags & eResetFxDagPositions);

	// Fetch the specified column (if none, return)
	TStageObject *obj = xsh->getStageObject(TStageObjectId::ColumnId(index));
	assert(obj);

	TXshColumn *column = xsh->getColumn(index);
	if (!column)
		return;

	TFx *fx = column->getFx();
	TPointD dagPos;

	if (fx)
		dagPos = fx->getAttributes()->getDagNodePos();
	if (doClone)
		column = column->clone(); // Zerary fxs clone the associated fx (drawn levels do not)
	if (fx && !resetFxDagPositions)
		column->getFx()->getAttributes()->setDagNodePos(dagPos);

	m_column = column;
	storeObject(obj->getId(), xsh);
}

void SkeletonTool::magicLink(int index)
{
	if (index < 0 || index >= (int)m_magicLinks.size())
		return;
	HookData h0 = m_magicLinks[index].m_h0;
	HookData h1 = m_magicLinks[index].m_h1;
	TTool::Application *app = TTool::getApplication();
	TXsheet *xsh = app->getCurrentXsheet()->getXsheet();
	int columnIndex = app->getCurrentColumn()->getColumnIndex();
	TStageObjectId id = TStageObjectId::ColumnId(columnIndex);
	TStageObject *obj = xsh->getStageObject(id);

	int parentColumnIndex = h1.m_columnIndex;
	TStageObjectId parentId = TStageObjectId::ColumnId(parentColumnIndex);
	std::string parentHandle = h1.getHandle();

	std::string handle = "";
	if (h0.m_columnIndex < 0) {
		handle = obj->getHandle();
	} else {
		handle = h0.getHandle();
	}

	//TUndoManager *undoManager = TUndoManager::manager();
	//undoManager->beginBlock();
	TStageObjectCmd::setHandle(id, handle, app->getCurrentXsheet());
	TStageObjectCmd::setParent(id, parentId, parentHandle, app->getCurrentXsheet());
	//undoManager->endBlock();
}

bool ViewerKeyframeNavigator::isFullKeyframe() const
{
	TStageObject *pegbar = getStageObject();
	if (!pegbar)
		return false;
	return pegbar->isFullKeyframe(getCurrentFrame());
}

	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 TApp::onSplineChanged()
{
	if (m_currentObject->isSpline()) {
		TXsheet *xsh = m_currentXsheet->getXsheet();
		TStageObject *currentObject = xsh->getStageObject(m_currentObject->getObjectId());
		currentObject->setOffset(currentObject->getOffset()); //invalidate currentObject
	}
}

void TStageObjectDataElement::storeObject(const TStageObjectId &objId, TXsheet *xsh)
{
	// Search the object in the xsheet (false = don't create a new one)
	TStageObject *obj = xsh->getStageObjectTree()->getStageObject(objId, false);
	assert(obj);

	m_params = obj->getParams();
	m_dagPos = obj->getDagNodePos();
}

void TCameraDataElement::storeCamera(const TStageObjectId &selectedObj, TXsheet *xsh)
{
	TStageObject *obj = xsh->getStageObjectTree()->getStageObject(selectedObj, false);
	assert(obj);

	m_params = obj->getParams();
	m_camera = *(obj->getCamera());
	m_dagPos = obj->getDagNodePos();
}

void TCellKeyframeSelection::selectCellKeyframe(int row, int col) {
  m_cellSelection->selectCell(row, col);
  TXsheet *xsh = m_xsheetHandle->getXsheet();
  TStageObjectId id =
      col < 0 ? TStageObjectId::CameraId(0) : TStageObjectId::ColumnId(col);
  TStageObject *stObj = xsh->getStageObject(id);
  m_keyframeSelection->clear();
  if (stObj->isKeyframe(row)) m_keyframeSelection->select(row, col);
}

void TApp::onObjectSwitched() {
  if (m_currentObject->isSpline()) {
    TXsheet *xsh = m_currentXsheet->getXsheet();
    TStageObject *currentObject =
        xsh->getStageObject(m_currentObject->getObjectId());
    TStageObjectSpline *ps = currentObject->getSpline();
    m_currentObject->setSplineObject(ps);
  } else
    m_currentObject->setSplineObject(0);
  onImageChanged();
}

void StageBuilder::addFrame(PlayerSet &players, ToonzScene *scene, TXsheet *xsh,
                            int row, int level, bool includeUnvisible,
                            bool checkPreviewVisibility) {
  int columnCount        = xsh->getColumnCount();
  unsigned int maskCount = m_masks.size();

  std::vector<std::pair<double, int>> shuffle;
  for (int c = 0; c < columnCount; c++) {
    TXshColumnP column = xsh->getColumn(c);
    assert(column);
    TStageObject *pegbar = xsh->getStageObject(TStageObjectId::ColumnId(c));
    double columnSO      = pegbar->getSO(row);
    shuffle.push_back(std::make_pair(columnSO, c));
  }
  std::stable_sort(shuffle.begin(), shuffle.end(), StackingOrder());

  for (int i = 0; i < columnCount; i++) {
    int c = shuffle[i].second;
    if (CameraTestCheck::instance()->isEnabled() && c != m_currentColumnIndex)
      continue;
    if (level == 0) {
      // m_isCurrentColumn = (c == m_currentColumnIndex);
      m_ancestorColumnIndex = c;
    }
    TXshColumn *column = xsh->getColumn(c);
    bool isMask        = false;
    if (column && !column->isEmpty()) {
      if (!column->isPreviewVisible() && checkPreviewVisibility) continue;
      if (column->isCamstandVisible() ||
          includeUnvisible)  // se l'"occhietto" non e' chiuso
      {
        if (column->isMask())  // se e' una maschera (usate solo in tab pro)
        {
          isMask = true;
          std::vector<int> saveMasks;
          saveMasks.swap(m_masks);
          int maskIndex   = m_maskPool.size();
          PlayerSet *mask = new PlayerSet();
          m_maskPool.push_back(mask);
          addCellWithOnionSkin(*mask, scene, xsh, row, c, level);
          std::stable_sort(mask->begin(), mask->end(), PlayerLt());
          saveMasks.swap(m_masks);
          m_masks.push_back(maskIndex);
        } else
          addCellWithOnionSkin(players, scene, xsh, row, c, level);
      }
    }
    if (!isMask) {
      while (m_masks.size() > maskCount) m_masks.pop_back();
    }
  }
  if (level == 0) std::stable_sort(players.begin(), players.end(), PlayerLt());
}

    static inline bool isMeshDeformed(TXsheet *xsh, TStageObject *obj,
                                      const ImagePainter::VisualSettings *vs) {
      const TStageObjectId &parentId = obj->getParent();
      if (parentId.isColumn() && obj->getParentHandle()[0] != 'H') {
        TStageObject *parentObj = xsh->getStageObject(parentId);
        if (!parentObj->getPlasticSkeletonDeformation()) return false;

        TXshColumn *parentCol = xsh->getColumn(parentId.getIndex());
        return (parentCol->getColumnType() == TXshColumn::eMeshType) &&
               (parentCol != vs->m_plasticVisualSettings.m_showOriginalColumn);
      }

      return false;
    }

void addShowHideStageObjectCmd(QMenu *menu, const TStageObjectId &id,
                               bool isShow) {
  TXsheet *xsh         = TApp::instance()->getCurrentXsheet()->getXsheet();
  TStageObject *pegbar = xsh->getStageObject(id);
  QString cmdStr;
  if (id.isCamera())
    cmdStr = (isShow ? "Show " : "Hide ") +
             QString::fromStdString(pegbar->getName());
  else
    cmdStr = (isShow ? "Show Column" : "Hide Column") +
             QString::fromStdString(pegbar->getName());
  QAction *showHideAction = new QAction(cmdStr, menu);
  showHideAction->setData((int)id.getCode());
  menu->addAction(showHideAction);
}

void TCellKeyframeSelection::selectCellsKeyframes(int r0, int c0, int r1,
                                                  int c1) {
  m_cellSelection->selectCells(r0, c0, r1, c1);
  TXsheet *xsh = m_xsheetHandle->getXsheet();
  m_xsheetHandle->getXsheet();
  if (r1 < r0) std::swap(r0, r1);
  if (c1 < c0) std::swap(c0, c1);
  m_keyframeSelection->clear();
  int r, c;
  for (c = c0; c <= c1; c++)
    for (r = r0; r <= r1; r++) {
      TStageObjectId id =
          c < 0 ? TStageObjectId::CameraId(0) : TStageObjectId::ColumnId(c);
      TStageObject *stObj = xsh->getStageObject(id);
      if (stObj->isKeyframe(r)) m_keyframeSelection->select(r, c);
    }
}

void StageSchematicScene::updateScene()
{
	clearAllItems();

	QPointF firstPos = sceneRect().center();
	m_nextNodePos = TPointD(firstPos.x(), firstPos.y());

	TStageObjectTree *pegTree = m_xshHandle->getXsheet()->getStageObjectTree();

	m_nodeTable.clear();
	m_GroupTable.clear();
	m_groupEditorTable.clear();
	m_gridDimension = pegTree->getDagGridDimension();

	QMap<int, QList<TStageObject *>> groupedObj;
	QMap<int, QList<SchematicNode *>> editedGroup;
	// in order to draw the position-specified nodes first
	QList<int> modifiedNodeIds;
	for (int i = 0; i < pegTree->getStageObjectCount(); i++) {
		TStageObject *pegbar = pegTree->getStageObject(i);
		if (pegbar->getDagNodePos() == TConst::nowhere)
			modifiedNodeIds.push_back(i);
		else
			modifiedNodeIds.push_front(i);
	}

	for (int i = 0; i < modifiedNodeIds.size(); i++) {
		TStageObject *pegbar = pegTree->getStageObject(modifiedNodeIds.at(i));
		if (pegbar->isGrouped() && !pegbar->isGroupEditing()) {
			groupedObj[pegbar->getGroupId()].push_back(pegbar);
			continue;
		}
		StageSchematicNode *node = addStageSchematicNode(pegbar);
		if (node != 0) {
			m_nodeTable[pegbar->getId()] = node;
			if (pegbar->isGrouped())
				editedGroup[pegbar->getEditingGroupId()].append(node);
		}
	}

	//Motion Path
	m_splineTable.clear();
	for (int i = 0; i < pegTree->getSplineCount(); i++) {
		TStageObjectSpline *spline = pegTree->getSpline(i);
		StageSchematicSplineNode *node = addSchematicSplineNode(spline);
		if (node != 0) {
			m_splineTable[spline] = node;
			connect(node, SIGNAL(currentObjectChanged(const TStageObjectId &, bool)), this,
					SLOT(onCurrentObjectChanged(const TStageObjectId &, bool)));
		}
	}

TStageObjectId TColumnDataElement::restoreColumn(TXsheet *xsh, int index, int fxFlags, bool copyPosition) const
{
	bool doClone = (fxFlags & eDoClone);
	bool resetFxDagPositions = (fxFlags & eResetFxDagPositions);

	TXshColumn *column = m_column.getPointer();

	// The xsheet 'changes' if a new column is inserted. If it was already there, no.
	bool xsheetChange = false;
	if (column && column->getXsheet() && column->getXsheet() != xsh)
		xsheetChange = true;

	// Insert a column at the specified index. If a column was stored, insert that one.
	TPointD dagPos = TConst::nowhere;
	if (column) {
		if (column->getFx())
			dagPos = column->getFx()->getAttributes()->getDagNodePos();
		if (doClone)
			column = column->clone();
		xsh->insertColumn(index, column);
	} else
		xsh->insertColumn(index); // Create a new one otherwise

	if (!resetFxDagPositions && dagPos != TConst::nowhere) {
		// Don't accept the default position (fx object)
		TXshColumn *restoredColumn = xsh->getColumn(index);
		restoredColumn->getFx()->getAttributes()->setDagNodePos(dagPos);
	}

	// Retrieve the newly inserted column stage object
	TStageObject *obj = xsh->getStageObject(TStageObjectId::ColumnId(index));
	assert(obj);
	obj->assignParams(m_params, doClone); // Assign the stored params

	if (copyPosition)
		obj->setDagNodePos(m_dagPos);

	// Clone the associated curve if any
	if (xsheetChange && obj->getSpline()) {
		TStageObjectSpline *srcSpl = obj->getSpline();
		TStageObjectSpline *dstSpl = xsh->getStageObjectTree()->createSpline();
		dstSpl->addRef();
		dstSpl->setStroke(new TStroke(*srcSpl->getStroke()));
		obj->setSpline(dstSpl);
	}

	int gridType = xsh->getStageObjectTree()->getDagGridDimension();
	obj->setIsOpened(gridType == 0); // gridType is 0 if the node is opened, 1 if closed
									 // see StageSchematicScene::GridDimension
									 // TODO: Should be made PUBLIC!!

	xsh->updateFrameCount();
	return obj->getId();
}

TStageObjectId TCameraDataElement::restoreCamera(TXsheet *xsh, bool copyPosition) const
{
	TStageObjectTree *tree = xsh->getStageObjectTree();

	// Search the first unused camera id in the xsheet
	int index = 0;
	while (tree->getStageObject(TStageObjectId::CameraId(index), false))
		++index;

	// Create the new camera object and assign stored data
	TStageObject *newCamera = tree->getStageObject(TStageObjectId::CameraId(index), true);
	newCamera->assignParams(m_params);
	*(newCamera->getCamera()) = m_camera;

	if (copyPosition)
		newCamera->setDagNodePos(m_dagPos);

	return newCamera->getId();
}