// TnzLib includes

#include "toonz/tstageobjectcmd.h"

#include "toonz/txsheethandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tfxhandle.h"

#include "toonz/txsheet.h"

#include "toonz/toonzscene.h"

#include "toonz/tstageobjectspline.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/tcamera.h"

#include "toonz/tcolumnfxset.h"

#include "toonz/fxdag.h"

// TnzBase includes

#include "tdoublekeyframe.h"

#include "tfx.h"

// TnzCore includes

#include "tundo.h"

#include "tconvert.h"

#include "historytypes.h"

// Qt includes

#include <qmap></qmap>

#include <qstring></qstring>

namespace {

bool canRemoveFx(const std::set<tfx *=""> &leaves, TFx *fx) {</tfx>

  for (int i = 0; i < fx->getInputPortCount(); i++) {

    TFx *inputFx = fx->getInputPort(i)->getFx();

    if (!inputFx) continue;

    if (leaves.count(inputFx) > 0) continue;

    if (!canRemoveFx(leaves, inputFx)) return false;

  }

  return fx->getInputPortCount() > 0;

}

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

//

// NewCameraUndo

//

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

class NewCameraUndo final : public TUndo {

  TStageObjectId m_cameraId, m_oldCurrentId;

  TStageObject *m_stageObject;

  TXsheetHandle *m_xshHandle;

  TObjectHandle *m_objHandle;

public:

  NewCameraUndo(const TStageObjectId &cameraId, TXsheetHandle *xshHandle,

                TObjectHandle *objHandle)

      : m_cameraId(cameraId)

      , m_stageObject(0)

      , m_xshHandle(xshHandle)

      , m_objHandle(objHandle) {

    assert(cameraId.isCamera());

    TXsheet *xsh  = m_xshHandle->getXsheet();

    m_stageObject = xsh->getStageObject(m_cameraId);

    m_stageObject->addRef();

    m_oldCurrentId = m_objHandle->getObjectId();

  }

  ~NewCameraUndo() { m_stageObject->release(); }

  void undo() const override {

    TXsheet *xsh = m_xshHandle->getXsheet();

    if (m_cameraId == m_objHandle->getObjectId())

      m_objHandle->setObjectId(m_oldCurrentId);

    xsh->getStageObjectTree()->removeStageObject(m_cameraId);

    m_xshHandle->notifyXsheetChanged();

  }

  void redo() const override {

    TXsheet *xsh = m_xshHandle->getXsheet();

    xsh->getStageObjectTree()->insertStageObject(m_stageObject);

    m_objHandle->setObjectId(m_cameraId);

    m_xshHandle->notifyXsheetChanged();

  }

  int getSize() const override { return sizeof(*this); }

  QString getHistoryString() override {

    return QObject::tr("New Camera  %1")

        .arg(QString::fromStdString(m_cameraId.toString()));

  }

  int getHistoryType() override { return HistoryType::Schematic; }

private:

  // not implemented

  NewCameraUndo(const NewCameraUndo &);

  NewCameraUndo &operator=(const NewCameraUndo &);

};

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

//

// NewPegbarUndo

//

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

class NewPegbarUndo final : public TUndo {

  TStageObjectId m_id, m_oldCurrentId;

  TStageObject *m_stageObject;

  TXsheetHandle *m_xshHandle;

  TObjectHandle *m_objHandle;

public:

  NewPegbarUndo(const TStageObjectId &id, TXsheetHandle *xshHandle,

                TObjectHandle *objHandle)

      : m_id(id)

      , m_stageObject(0)

      , m_xshHandle(xshHandle)

      , m_objHandle(objHandle) {

    assert(!id.isTable());

    TXsheet *xsh  = m_xshHandle->getXsheet();

    m_stageObject = xsh->getStageObject(m_id);

    m_stageObject->addRef();

    m_oldCurrentId = m_objHandle->getObjectId();

  }

  ~NewPegbarUndo() { m_stageObject->release(); }

  void undo() const override {

    TXsheet *xsh = m_xshHandle->getXsheet();

    if (m_id == m_objHandle->getObjectId())

      m_objHandle->setObjectId(m_oldCurrentId);

    xsh->getStageObjectTree()->removeStageObject(m_id);

    m_xshHandle->notifyXsheetChanged();

  }

  void redo() const override {

    TXsheet *xsh = m_xshHandle->getXsheet();

    xsh->getStageObjectTree()->insertStageObject(m_stageObject);

    m_objHandle->setObjectId(m_id);

    m_xshHandle->notifyXsheetChanged();

  }

  int getSize() const override { return sizeof(*this); }

  QString getHistoryString() override {

    return QObject::tr("New Pegbar  %1")

        .arg(QString::fromStdString(m_id.toString()));

  }

  int getHistoryType() override { return HistoryType::Schematic; }

private:

  // not implemented

  NewPegbarUndo(const NewPegbarUndo &);

  NewPegbarUndo &operator=(const NewPegbarUndo &);

};

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

//

// SetActiveCameraUndo

//

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

class SetActiveCameraUndo final : public TUndo {

  TStageObjectId m_oldCameraId, m_newCameraId;

  TXsheetHandle *m_xshHandle;

public:

  SetActiveCameraUndo(const TStageObjectId &oldCameraId,

                      const TStageObjectId &newCameraId,

                      TXsheetHandle *xshHandle)

      : m_oldCameraId(oldCameraId)

      , m_newCameraId(newCameraId)

      , m_xshHandle(xshHandle) {}

  void undo() const override {

    TXsheet *xsh = m_xshHandle->getXsheet();

    xsh->getStageObjectTree()->setCurrentCameraId(m_oldCameraId);

    // make the preview camera same as the final camera

    xsh->getStageObjectTree()->setCurrentPreviewCameraId(m_oldCameraId);

    m_xshHandle->notifyXsheetChanged();

  }

  void redo() const override {

    TXsheet *xsh = m_xshHandle->getXsheet();

    xsh->getStageObjectTree()->setCurrentCameraId(m_newCameraId);

    // make the preview camera same as the final camera

    xsh->getStageObjectTree()->setCurrentPreviewCameraId(m_newCameraId);

    m_xshHandle->notifyXsheetChanged();

  }

  int getSize() const override { return sizeof(*this); }

  QString getHistoryString() override {

    return QObject::tr("Set Active Camera  %1 > %2")

        .arg(QString::fromStdString(m_oldCameraId.toString()))

        .arg(QString::fromStdString(m_newCameraId.toString()));

  }

  int getHistoryType() override { return HistoryType::Schematic; }

};

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

//

// RemoveSplineUndo

//

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

class RemoveSplineUndo final : public TUndo {

  TStageObjectId m_id;

  TStageObjectSpline *m_spline;

  std::vector<tstageobjectid> m_ids;</tstageobjectid>

  TXsheetHandle *m_xshHandle;

public:

  RemoveSplineUndo(TStageObjectSpline *spline, TXsheetHandle *xshHandle)

      : m_spline(spline), m_xshHandle(xshHandle) {

    m_spline->addRef();

    TStageObjectTree *pegbarTree =

        m_xshHandle->getXsheet()->getStageObjectTree();

    for (int i = 0; i < pegbarTree->getStageObjectCount(); i++) {

      TStageObject *pegbar = pegbarTree->getStageObject(i);

      if (pegbar->getSpline() == m_spline) m_ids.push_back(pegbar->getId());

    }

  }

  ~RemoveSplineUndo() { m_spline->release(); }

  void undo() const override {

    TXsheet *xsh = m_xshHandle->getXsheet();

    xsh->getStageObjectTree()->insertSpline(m_spline);

    for (int i = 0; i < (int)m_ids.size(); i++) {

      TStageObject *pegbar = xsh->getStageObject(m_ids[i]);

      assert(pegbar);

      pegbar->setSpline(m_spline);

    }

    m_xshHandle->notifyXsheetChanged();

  }

  void redo() const override {

    TXsheet *xsh = m_xshHandle->getXsheet();

    for (int i = 0; i < (int)m_ids.size(); i++) {

      TStageObject *pegbar = xsh->getStageObject(m_ids[i]);

      assert(pegbar);

      pegbar->setSpline(0);

    }

    xsh->getStageObjectTree()->removeSpline(m_spline);

    m_xshHandle->notifyXsheetChanged();

  }

  int getSize() const override {

    return sizeof *this + sizeof(TStageObjectSpline) +

           sizeof(TStageObjectId) * m_ids.size();

  }

  QString getHistoryString() override {

    return QObject::tr("Remove Spline  %1")

        .arg(QString::fromStdString(m_id.toString()));

  }

  int getHistoryType() override { return HistoryType::Schematic; }

};

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

//

// NewSplineUndo

//

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

class NewSplineUndo final : public TUndo {

  TStageObjectId m_id;

  TStageObjectSpline *m_spline;

  TXsheetHandle *m_xshHandle;

public:

  NewSplineUndo(const TStageObjectId &id, TStageObjectSpline *spline,

                TXsheetHandle *xshHandle)

      : m_id(id), m_spline(spline), m_xshHandle(xshHandle) {

    m_spline->addRef();

  }

  ~NewSplineUndo() { m_spline->release(); }

  void undo() const override {

    TXsheet *xsh         = m_xshHandle->getXsheet();

    TStageObject *pegbar = xsh->getStageObject(m_id);

    assert(pegbar);

    pegbar->setSpline(0);

    xsh->getStageObjectTree()->removeSpline(m_spline);

    m_xshHandle->notifyXsheetChanged();

  }

  void redo() const override {

    TXsheet *xsh = m_xshHandle->getXsheet();

    xsh->getStageObjectTree()->insertSpline(m_spline);

    TStageObject *pegbar = xsh->getStageObject(m_id);

    assert(pegbar);

    pegbar->setSpline(m_spline);

    m_xshHandle->notifyXsheetChanged();

  }

  int getSize() const override {

    return sizeof *this + sizeof(TStageObjectSpline);

  }

  QString getHistoryString() override {

    return QObject::tr("New Motion Path  %1")

        .arg(QString::fromStdString(m_spline->getName()));

  }

  int getHistoryType() override { return HistoryType::Schematic; }

};

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

//

// SplineLinkUndo

//

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

class SplineLinkUndo final : public TUndo {

  TStageObjectId m_id;

  TStageObjectSpline *m_spline;

  TXsheetHandle *m_xshHandle;

public:

  SplineLinkUndo(const TStageObjectId &id, TStageObjectSpline *spline,

                 TXsheetHandle *xshHandle)

      : m_id(id), m_spline(spline), m_xshHandle(xshHandle) {

    m_spline->addRef();

  }

  ~SplineLinkUndo() { m_spline->release(); }

  void undo() const override {

    TStageObject *object = m_xshHandle->getXsheet()->getStageObject(m_id);

    object->setSpline(0);

    m_xshHandle->notifyXsheetChanged();

  }

  void redo() const override {

    TStageObject *object = m_xshHandle->getXsheet()->getStageObject(m_id);

    object->setSpline(m_spline);

    m_xshHandle->notifyXsheetChanged();

  }

  int getSize() const override {

    return sizeof *this + sizeof(TStageObjectSpline);

  }

  QString getHistoryString() override {

    return QObject::tr("Link Motion Path  %1 > %2")

        .arg(QString::fromStdString(m_spline->getName()))

        .arg(QString::fromStdString(m_id.toString()));

  }

  int getHistoryType() override { return HistoryType::Schematic; }

};

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

//

// DeleteSplineLinkUndo

//

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

class RemoveSplineLinkUndo final : public TUndo {

  TStageObjectId m_id;

  TStageObjectSpline *m_spline;

  TXsheetHandle *m_xshHandle;

  TObjectHandle *m_objHandle;

public:

  RemoveSplineLinkUndo(const TStageObjectId &id, TStageObjectSpline *spline,

                       TXsheetHandle *xshHandle, TObjectHandle *objHandle)

      : m_id(id)

      , m_spline(spline)

      , m_xshHandle(xshHandle)

      , m_objHandle(objHandle) {

    m_spline->addRef();

  }

  ~RemoveSplineLinkUndo() { m_spline->release(); }

  void undo() const override {

    TXsheet *xsh              = m_xshHandle->getXsheet();

    TStageObjectTree *objTree = xsh->getStageObjectTree();

    TStageObject *object      = objTree->getStageObject(m_id, false);

    if (!object) return;

    object->setSpline(m_spline);

    if (m_objHandle->getObjectId() == m_id) m_objHandle->setIsSpline(true);

    m_xshHandle->notifyXsheetChanged();

  }

  void redo() const override {

    TXsheet *xsh              = m_xshHandle->getXsheet();

    TStageObjectTree *objTree = xsh->getStageObjectTree();

    TStageObject *object      = objTree->getStageObject(m_id, false);

    if (!object) return;

    object->setSpline(0);

    if (m_objHandle->getObjectId() == m_id) m_objHandle->setIsSpline(false);

    m_xshHandle->notifyXsheetChanged();

  }

  int getSize() const override {

    return sizeof *this + sizeof(TStageObjectSpline);

  }

};

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

//

// RemovePegbarNodeUndo

//

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

class RemovePegbarNodeUndo final : public TUndo {

  TStageObjectId m_objId;

  TXshColumnP m_column;

  TStageObjectParams *m_params;

  QList<tstageobjectid> m_linkedObj;</tstageobjectid>

  TXsheetHandle *m_xshHandle;

public:

  RemovePegbarNodeUndo(TStageObjectId id, TXsheetHandle *xshHandle)

      : TUndo(), m_objId(id), m_xshHandle(xshHandle), m_column(0) {

    TXsheet *xsh      = xshHandle->getXsheet();

    TStageObject *obj = xsh->getStageObject(id);

    assert(obj);

    m_params = obj->getParams();

    if (id.isColumn()) m_column = xsh->getColumn(id.getIndex());

  }

  ~RemovePegbarNodeUndo() { delete m_params; }

  void setLinkedObjects(const QList<tstageobjectid> &linkedObj) {</tstageobjectid>

    m_linkedObj = linkedObj;

  }

  void undo() const override {

    // reinsert Object

    TXsheet *xsh = m_xshHandle->getXsheet();

    if (m_objId.isColumn() && m_column)

      xsh->insertColumn(m_objId.getIndex(), m_column.getPointer());

    TStageObject *obj = xsh->getStageObject(m_objId);

    obj->assignParams(m_params);

    obj->setParent(m_params->m_parentId);

    int i, linkCount = m_linkedObj.size();

    for (i = 0; i < linkCount; i++) {

      TStageObject *linkedObj = xsh->getStageObject(m_linkedObj[i]);

      assert(linkedObj);

      linkedObj->setParent(m_objId);

    }

    m_xshHandle->notifyXsheetChanged();

    xsh->notifyStageObjectAdded(m_objId);

  }

  void redo() const override {

    TXsheet *xsh     = m_xshHandle->getXsheet();

    int pegbarsCount = xsh->getStageObjectTree()->getStageObjectCount();

    int i;

    for (i = 0; i < pegbarsCount; ++i) {

      TStageObject *other = xsh->getStageObjectTree()->getStageObject(i);

      if (other->getId() == m_objId) continue;

      if (other->getParent() == m_objId)

        other->setParent(xsh->getStageObjectParent(m_objId));

    }

    if (m_objId.isColumn())

      xsh->removeColumn(m_objId.getIndex());

    else

      xsh->getStageObjectTree()->removeStageObject(m_objId);

    m_xshHandle->notifyXsheetChanged();

  }

  int getSize() const override {

    return sizeof *this + sizeof(TStageObjectParams) + sizeof(m_xshHandle);

  }

  QString getHistoryString() override {

    return QObject::tr("Remove Object  %1")

        .arg(QString::fromStdString(m_objId.toString()));

  }

  int getHistoryType() override { return HistoryType::Schematic; }

};

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

//

// RemoveColumnsUndo

//

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

class RemoveColumnsUndo final : public TUndo {

  std::vector<tfx *=""> m_deletedFx;</tfx>

  std::vector<tfx *=""> m_terminalFx;</tfx>

  QMap<tstageobjectid, *="" qlist<tfxport="">> m_columnFxConnections;</tstageobjectid,>

  QList<tfx *=""> m_notTerminalColumns;</tfx>

  TXsheetHandle *m_xshHandle;

public:

  RemoveColumnsUndo(

      const std::vector<tfx *=""> &deletedFx, const std::vector<tfx *=""> &terminalFx,</tfx></tfx>

      const QMap<tstageobjectid, *="" qlist<tfxport="">> columnFxConnections,</tstageobjectid,>

      const QList<tfx *=""> ¬TerminalColumns, TXsheetHandle *xshHandle)</tfx>

      : TUndo()

      , m_deletedFx(deletedFx)

      , m_terminalFx(terminalFx)

      , m_columnFxConnections(columnFxConnections)

      , m_notTerminalColumns(notTerminalColumns)

      , m_xshHandle(xshHandle) {

    int i;

    for (i = 0; i < (int)m_deletedFx.size(); i++) m_deletedFx[i]->addRef();

  }

  ~RemoveColumnsUndo() {

    int i;

    for (i = 0; i < (int)m_deletedFx.size(); i++) m_deletedFx[i]->release();

  }

  void undo() const override {

    TXsheet *xsh        = m_xshHandle->getXsheet();

    TFxSet *terminalFxs = xsh->getFxDag()->getTerminalFxs();

    TFxSet *internalFxs = xsh->getFxDag()->getInternalFxs();

    int i;

    for (i = 0; i < (int)m_deletedFx.size(); i++)

      internalFxs->addFx(m_deletedFx[i]);

    for (i = 0; i < (int)m_terminalFx.size(); i++)

      terminalFxs->addFx(m_terminalFx[i]);

    QMap<tstageobjectid, *="" qlist<tfxport="">>::const_iterator it;</tstageobjectid,>

    for (it = m_columnFxConnections.begin(); it != m_columnFxConnections.end();

         it++) {

      TStageObjectId id      = it.key();

      QList<tfxport *=""> ports = it.value();</tfxport>

      TXshColumnP column     = xsh->getColumn(id.getIndex());

      assert(column);

      int j;

      for (j = 0; j < ports.size(); j++) ports[j]->setFx(column->getFx());

    }

    for (i = 0; i < m_notTerminalColumns.size(); i++)

      terminalFxs->removeFx(m_notTerminalColumns[i]);

    m_xshHandle->notifyXsheetChanged();

    xsh->notifyFxAdded(m_deletedFx);

  }

  void redo() const override {

    TXsheet *xsh        = m_xshHandle->getXsheet();

    TFxSet *terminalFxs = xsh->getFxDag()->getTerminalFxs();

    TFxSet *internalFxs = xsh->getFxDag()->getInternalFxs();

    int i;

    for (i = 0; i < (int)m_deletedFx.size(); i++)

      internalFxs->removeFx(m_deletedFx[i]);

    for (i = 0; i < (int)m_terminalFx.size(); i++)

      terminalFxs->removeFx(m_terminalFx[i]);

    m_xshHandle->notifyXsheetChanged();

  }

  int getSize() const override {

    return sizeof *this + m_deletedFx.size() * sizeof(TFx) +

           m_terminalFx.size() * sizeof(TFx) +

           m_columnFxConnections.size() *

               (sizeof(TStageObjectId) + 10 * sizeof(TFxPort)) +

           m_notTerminalColumns.size() * sizeof(TFx) + sizeof(TXsheetHandle);

  }

  QString getHistoryString() override {

    QString str = QObject::tr("Remove Column  ");

    QMap<tstageobjectid, *="" qlist<tfxport="">>::const_iterator it;</tstageobjectid,>

    for (it = m_columnFxConnections.begin(); it != m_columnFxConnections.end();

         it++) {

      TStageObjectId id = it.key();

      if (it != m_columnFxConnections.begin())

        str += QString::fromStdString(", ");

      str += QString::fromStdString(id.toString());

    }

    return str;

  }

  int getHistoryType() override { return HistoryType::Schematic; }

};

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

//

// UndoGroup

//

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

class UndoGroup final : public TUndo {

  QList<tstageobjectid> m_ids;</tstageobjectid>

  int m_groupId;

  QList<int> m_positions;</int>

  TXsheetHandle *m_xshHandle;

public:

  UndoGroup(const QList<tstageobjectid> &ids, int groupId,</tstageobjectid>

            const QList<int> &positions, TXsheetHandle *xshHandle)</int>

      : m_ids(ids)

      , m_groupId(groupId)

      , m_positions(positions)

      , m_xshHandle(xshHandle) {}

  ~UndoGroup() {}

  void undo() const override {

    assert(m_ids.size() == m_positions.size());

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

    int i;

    for (i = 0; i < m_ids.size(); i++) {

      TStageObject *obj = pegTree->getStageObject(m_ids[i], false);

      if (obj) {

        obj->removeGroupName(m_positions[i]);

        obj->removeGroupId(m_positions[i]);

      }

    }

    m_xshHandle->notifyXsheetChanged();

  }

  void redo() const override {

    assert(m_ids.size() == m_positions.size());

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

    int i;

    for (i = 0; i < m_ids.size(); i++) {

      TStageObject *obj = pegTree->getStageObject(m_ids[i], false);

      if (obj) {

        obj->setGroupId(m_groupId, m_positions[i]);

        obj->setGroupName(L"Group " + std::to_wstring(m_groupId),

                          m_positions[i]);

      }

    }

    m_xshHandle->notifyXsheetChanged();

  }

  int getSize() const override { return sizeof *this; }

};

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

//

// UndoUngroup

//

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

class UndoUngroup final : public TUndo {

  QList<tstageobjectid> m_objsId;</tstageobjectid>

  QList<int> m_positions;</int>

  int m_groupId;

  std::wstring m_groupName;

  TXsheetHandle *m_xshHandle;

public:

  UndoUngroup(const QList<tstageobject *=""> &objs, TXsheetHandle *xshHandle)</tstageobject>

      : m_xshHandle(xshHandle) {

    assert(objs.size() > 0);

    int i;

    for (i = 0; i < objs.size(); i++) {

      m_objsId.append(objs[i]->getId());

      if (i == 0) {

        m_groupId   = objs[i]->getGroupId();

        m_groupName = objs[i]->getGroupName(false);

      }

    }

  }

  ~UndoUngroup() {}

  void setStackPositions(const QList<int> &positions) {</int>

    m_positions = positions;

  }

  void undo() const override {

    assert(m_objsId.size() == m_positions.size());

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

    if (!objTree) return;

    int i;

    for (i = 0; i < m_objsId.size(); i++) {

      TStageObject *obj = objTree->getStageObject(m_objsId[i], false);

      if (!obj) continue;

      obj->setGroupId(m_groupId, m_positions[i]);

      obj->setGroupName(m_groupName, m_positions[i]);

    }

    m_xshHandle->notifyXsheetChanged();

  }

  void redo() const override {

    assert(m_objsId.size() == m_positions.size());

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

    if (!objTree) return;

    int i;

    for (i = 0; i < m_objsId.size(); i++) {

      TStageObject *obj = objTree->getStageObject(m_objsId[i], false);

      if (!obj) continue;

      obj->removeGroupName(m_positions[i]);

      obj->removeGroupId(m_positions[i]);

    }

    m_xshHandle->notifyXsheetChanged();

  }

  int getSize() const override { return sizeof *this; }

};

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

//

// UndoRenameGroup

//

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

class UndoRenameGroup final : public TUndo {

  QList<tstageobject *=""> m_objs;</tstageobject>

  QList<int> m_positions;</int>

  std::wstring m_oldGroupName;

  std::wstring m_newGroupName;

  TXsheetHandle *m_xshHandle;

public:

  UndoRenameGroup(const QList<tstageobject *=""> &objs,</tstageobject>

                  const QList<int> &positions, const std::wstring &newName,</int>

                  const std::wstring &oldName, TXsheetHandle *xshHandle)

      : m_objs(objs)

      , m_newGroupName(newName)

      , m_oldGroupName(oldName)

      , m_xshHandle(xshHandle)

      , m_positions(positions) {

    assert(objs.size() > 0);

    int i;

    for (i = 0; i < m_objs.size(); i++) m_objs[i]->addRef();

  }

  ~UndoRenameGroup() {

    int i;

    for (i = 0; i < m_objs.size(); i++) m_objs[i]->release();

  }

  void undo() const override {

    assert(m_objs.size() == m_positions.size());

    int i;

    for (i = 0; i < m_objs.size(); i++) {

      m_objs[i]->removeGroupName(m_positions[i]);

      m_objs[i]->setGroupName(m_oldGroupName, m_positions[i]);

    }

    m_xshHandle->notifyXsheetChanged();

  }

  void redo() const override {

    assert(m_objs.size() == m_positions.size());

    int i;

    for (i = 0; i < m_objs.size(); i++) {

      m_objs[i]->removeGroupName(m_positions[i]);

      m_objs[i]->setGroupName(m_newGroupName, m_positions[i]);

    }

    m_xshHandle->notifyXsheetChanged();

  }

  int getSize() const override { return sizeof *this; }

};

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

//

// UndoStatusChange

//

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

class UndoStatusChange final : public TUndo {

  TStageObject *m_obj;

  TStageObject::Status m_oldStatus, m_newStatus;

  TXsheetHandle *m_xshHandle;

public:

  UndoStatusChange(TStageObject *obj, TXsheetHandle *xshHandle)

      : m_obj(obj), m_xshHandle(xshHandle) {

    m_obj->addRef();

    // devo fare addref della spline altimenti crasha in uscita

    // m_obj non fa addref della spline a lui associata, e quindi crasha perche'

    // la spline viene distrutta

    // prima di m_obj... sarebbe piu' corretto fare addref della spline quando

    // viene settata all'oggetto

    // piuttosto che farla qui?

    TStageObjectSpline *spline = m_obj->getSpline();

    if (spline) spline->addRef();

    m_oldStatus = m_obj->getStatus();

  }

  ~UndoStatusChange() {

    TStageObjectSpline *spline = m_obj->getSpline();

    m_obj->release();

    if (spline) spline->release();

  }

  void onAdd() override { m_newStatus = m_obj->getStatus(); }

  void undo() const override {

    m_obj->setStatus(m_oldStatus);

    m_xshHandle->notifyXsheetChanged();

  }

  void redo() const override {

    m_obj->setStatus(m_newStatus);

    m_xshHandle->notifyXsheetChanged();

  }

  int getSize() const override { return sizeof *this; }

};

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

//

// removePegbarNode

//

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

void removeStageObjectNode(const TStageObjectId &id, TXsheetHandle *xshHandle,

                           TObjectHandle *objHandle, TFxHandle *fxHandle,

                           bool doUndo = true) {

  TXsheet *xsh         = xshHandle->getXsheet();

  TStageObject *pegbar = xsh->getStageObject(id);

  // Lacamera corrente e il tavolo non si devono rimuovere

  if (id.isTable() ||

      (id.isCamera() && xsh->getStageObjectTree()->getCurrentCameraId() == id))

    return;

  if (id.isCamera() && xsh->getCameraColumnIndex() == id.getIndex())

    xsh->setCameraColumnIndex(

        xsh->getStageObjectTree()->getCurrentCameraId().getIndex());

  // stacco tutti i figli e li attacco al padre

  QList<tstageobjectid> linkedObjects;</tstageobjectid>

  int pegbarsCount = xsh->getStageObjectTree()->getStageObjectCount();

  int i;

  for (i = 0; i < pegbarsCount; ++i) {

    TStageObject *other = xsh->getStageObjectTree()->getStageObject(i);

    if (other == pegbar) continue;

    if (other->getParent() == id) {

      other->setParent(pegbar->getParent());

      linkedObjects.push_back(other->getId());

    }

  }

  if (id == objHandle->getObjectId())

    objHandle->setObjectId(TStageObjectId::TableId);

  RemovePegbarNodeUndo *undo = new RemovePegbarNodeUndo(id, xshHandle);

  undo->setLinkedObjects(linkedObjects);

  if (id.isColumn())

    xsh->removeColumn(id.getIndex());

  else

    xsh->getStageObjectTree()->removeStageObject(id);

  if (doUndo)

    TUndoManager::manager()->add(undo);

  else

    delete undo;

}

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

//

// removeColumns

//

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

void removeColumns(const QVector<int> &columnIndexes, TXsheetHandle *xshHandle,</int>

                  TObjectHandle *objHandle, TFxHandle *fxHandle,

                  bool doUndo = true) {

  TXsheet *xsh = xshHandle->getXsheet();

  int i;

  QMap<tstageobjectid, *="" qlist<tfxport="">> columnFxConnection;</tstageobjectid,>

  std::set<tfx *=""> leafesFx;</tfx>

  QList<tfx *=""> notTerminalColumns;</tfx>

  for (i = columnIndexes.size() - 1; i >= 0; i--) {

    TStageObjectId id  = TStageObjectId::ColumnId(columnIndexes[i]);

    TXshColumnP column = xsh->getColumn(id.getIndex());

    if (!column) continue;

    TFx *columnFx = column->getFx();

    if (!columnFx) continue;

    int j;

    for (j = 0; j < columnFx->getOutputConnectionCount(); j++)

      columnFxConnection[id].append(columnFx->getOutputConnection(j));

    leafesFx.insert(columnFx);

    if (!xsh->getFxDag()->getTerminalFxs()->containsFx(columnFx))

      notTerminalColumns.append(columnFx);

  }

  std::vector<tfx *=""> fxsToKill;</tfx>

  std::vector<tfx *=""> terminalFxsToKill;</tfx>

  TFxSet *fxSet = xsh->getFxDag()->getInternalFxs();

  for (i = 0; i < fxSet->getFxCount(); i++) {

    TFx *fx = fxSet->getFx(i);

    if (canRemoveFx(leafesFx, fx)) {

      fxsToKill.push_back(fx);

      if (xsh->getFxDag()->getTerminalFxs()->containsFx(fx))

        terminalFxsToKill.push_back(fx);

    }

  }

  if (doUndo) {

    RemoveColumnsUndo *undo =

        new RemoveColumnsUndo(fxsToKill, terminalFxsToKill, columnFxConnection,

                              notTerminalColumns, xshHandle);

    TUndoManager::manager()->add(undo);

  }

  for (i = 0; i < (int)fxsToKill.size(); i++) {

    TFx *fx = fxsToKill[i];