// TnzCore includes

#include "tundo.h"

#include "trandom.h"

#include "tvectorimage.h"

#include "ttoonzimage.h"

#include "trasterimage.h"

#include "tpalette.h"

#include "tsystem.h"

#include "tstream.h"

#include "tconvert.h"

#include "tfilepath_io.h"

// TnzBase includes

#include "tunit.h"

// TnzLib includes

#include "toonz/txsheethandle.h"

#include "toonz/tscenehandle.h"

#include "toonz/tcolumnhandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/tframehandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/txsheet.h"

#include "toonz/txshcell.h"

#include "toonz/txshcolumn.h"

#include "toonz/toonzscene.h"

#include "toonz/levelset.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txshleveltypes.h"

#include "toonz/txshsoundtextcolumn.h"

#include "toonz/txshsoundtextlevel.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/tstageobjectkeyframe.h"

#include "toonz/stageobjectutil.h"

#include "toonz/toonzfolders.h"

#include "toonz/txshchildlevel.h"

#include "toonz/childstack.h"

#include "toonz/tproject.h"

#include "toonz/fxcommand.h"

#include "toonz/tfxhandle.h"

#include "toonz/scenefx.h"

#include "toonz/preferences.h"

#include "toonz/navigationtags.h"

// TnzQt includes

#include "toonzqt/tselectionhandle.h"

#include "toonzqt/gutil.h"

#include "toonzqt/menubarcommand.h"

#include "toonzqt/stageobjectsdata.h"

#include "historytypes.h"

#include "xsheetviewer.h"

// Tnz6 includes

#include "cellselection.h"

#include "columnselection.h"

#include "keyframeselection.h"

#include "celldata.h"

#include "tapp.h"

#include "duplicatepopup.h"

#include "menubarcommandids.h"

#include "columncommand.h"

#include "xshcellviewer.h"  // SetCellMarkUndo

#include "navtageditorpopup.h"

// Qt includes

#include <qclipboard></qclipboard>

// tcg includes

#include "tcg/boost/range_utility.h"

// boost includes

#include <boost bind.hpp=""></boost>

#include <boost bind="" make_adaptable.hpp=""></boost>

#include <boost adaptor="" filtered.hpp="" range=""></boost>

#include <boost adaptor="" range="" transformed.hpp=""></boost>

namespace ba = boost::adaptors;

using namespace std;  // Please, remove

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

//    Local Namespace  stuff

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

namespace {

void getColumns(std::vector<int> &columns) {</int>

  TApp *app    = TApp::instance();

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

  TColumnSelection *selection = dynamic_cast<tcolumnselection *="">(</tcolumnselection>

      app->getCurrentSelection()->getSelection());

  if (selection && selection->isEmpty()) selection = 0;

  if (!selection)  // Se non c'e' selezione inserisco la colonna di camera

    columns.push_back(-1);

  for (int c = 0; c < xsh->getColumnCount(); ++c)

    if (!selection || selection->isColumnSelected(c)) columns.push_back(c);

}

bool isKeyframe(int r, int c) {

  TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();

  TStageObjectId objectId =

      (c == -1) ? TStageObjectId::CameraId(xsh->getCameraColumnIndex())

                : TStageObjectId::ColumnId(c);

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

  assert(object);

  return object->isKeyframe(r);

}

}  // namespace

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

//    InsertSceneFrame  command

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

namespace XshCmd {

class InsertSceneFrameUndo : public TUndo {

protected:

  int m_frame;

public:

  InsertSceneFrameUndo(int frame) : m_frame(frame) {}

  void undo() const override {

    doRemoveSceneFrame(m_frame);

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

  }

  void redo() const override {

    doInsertSceneFrame(m_frame);

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

  }

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

  QString getHistoryString() override {

    return QObject::tr("Insert Frame  at Frame %1")

        .arg(QString::number(m_frame + 1));

  }

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

protected:

  static void doInsertSceneFrame(int frame);

  static void doRemoveSceneFrame(int frame);

};

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

void InsertSceneFrameUndo::doInsertSceneFrame(int frame) {

  TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();

  int c, colsCount = xsh->getColumnCount();

  for (c = -1; c < colsCount; ++c) {

    TStageObjectId objectId;

    if (c == -1)

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

    else {

      objectId = TStageObjectId::ColumnId(c);

      xsh->insertCells(frame, c);

      xsh->setCell(frame, c, xsh->getCell(frame + 1, c));

    }

    if (!xsh->getColumn(c) || xsh->getColumn(c)->isLocked()) continue;

    if (TStageObject *obj = xsh->getStageObject(objectId))

      insertFrame(obj, frame);

  }

  xsh->getNavigationTags()->shiftTags(frame, 1);

}

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

void InsertSceneFrameUndo::doRemoveSceneFrame(int frame) {

  TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();

  for (int c = -1; c != xsh->getColumnCount(); ++c) {

    TStageObjectId objectId;

    if (c == -1)

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

    else {

      objectId = TStageObjectId::ColumnId(c);

      xsh->removeCells(frame, c);

    }

    if (!xsh->getColumn(c) || xsh->getColumn(c)->isLocked()) continue;

    if (TStageObject *pegbar = xsh->getStageObject(objectId))

      removeFrame(pegbar, frame);

  }

  if (xsh->isFrameTagged(frame)) xsh->getNavigationTags()->removeTag(frame);

  xsh->getNavigationTags()->shiftTags(frame, -1);

}

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

static void insertSceneFrame(int frame) {

  InsertSceneFrameUndo *undo = new InsertSceneFrameUndo(frame);

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

  undo->redo();

}

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

class ToggleCurrentTimeIndicatorCommand final : public MenuItemHandler {

public:

  ToggleCurrentTimeIndicatorCommand()

      : MenuItemHandler(MI_ToggleCurrentTimeIndicator) {}

  void execute() override {

    bool currentTimeIndEnabled =

        Preferences::instance()->isCurrentTimelineIndicatorEnabled();

    Preferences::instance()->setValue(currentTimelineEnabled,

                                      !currentTimeIndEnabled);

  }

} toggleCurrentTimeIndicatorComman;

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

class InsertSceneFrameCommand final : public MenuItemHandler {

public:

  InsertSceneFrameCommand() : MenuItemHandler(MI_InsertSceneFrame) {}

  void execute() override {

    int frame = TApp::instance()->getCurrentFrame()->getFrame();

    XshCmd::insertSceneFrame(frame);

  }

} insertSceneFrameCommand;

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

//    RemoveSceneFrame  command

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

class RemoveSceneFrameUndo final : public InsertSceneFrameUndo {

  std::vector<txshcell> m_cells;</txshcell>

  std::vector<tstageobject::keyframe> m_keyframes;</tstageobject::keyframe>

  NavigationTags::Tag m_tag;

public:

  RemoveSceneFrameUndo(int frame) : InsertSceneFrameUndo(frame) {

    // Store cells and TStageObject::Keyframe that will be canceled

    TXsheet *xsh  = TApp::instance()->getCurrentXsheet()->getXsheet();

    int colsCount = xsh->getColumnCount();

    m_cells.resize(colsCount);

    m_keyframes.resize(colsCount + 1);

    m_tag = xsh->getNavigationTags()->getTag(frame);

    // Inserting the eventual camera keyframe at the end

    TStageObject *cameraObj = xsh->getStageObject(

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

    if (cameraObj->isKeyframe(m_frame))

      m_keyframes[colsCount] = cameraObj->getKeyframe(m_frame);

    for (int c = 0; c != colsCount; ++c) {

      // Store cell

      m_cells[c] = xsh->getCell(m_frame, c);

      // Store stage object keyframes

      TStageObject *obj = xsh->getStageObject(TStageObjectId::ColumnId(c));

      if (obj->isKeyframe(m_frame)) m_keyframes[c] = obj->getKeyframe(m_frame);

    }

  }

  void redo() const override { InsertSceneFrameUndo::undo(); }

  void undo() const override {

    TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();

    // Insert an empty frame, need space for our stored stuff

    doInsertSceneFrame(m_frame);

    // Insert cells

    int cellsCount = m_cells.size();

    // Deal with the eventual camera keyframe

    if (m_keyframes[cellsCount].m_isKeyframe) {

      TStageObject *cameraObj = xsh->getStageObject(

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

      cameraObj->setKeyframeWithoutUndo(m_frame, m_keyframes[cellsCount]);

    }

    for (int c = 0; c != cellsCount; ++c) {

      xsh->setCell(m_frame, c, m_cells[c]);

      if (m_keyframes[c].m_isKeyframe) {

        TStageObject *obj = xsh->getStageObject(TStageObjectId::ColumnId(c));

        obj->setKeyframeWithoutUndo(m_frame, m_keyframes[c]);

      }

    }

    // Restore tag if there was one

    if (m_tag.m_frame != -1)

      xsh->getNavigationTags()->addTag(m_tag.m_frame, m_tag.m_label);

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

  }

  int getSize() const override {

    return 10 << 10;

  }  // Gave up exact calculation. Say ~ 10 kB?

  QString getHistoryString() override {

    return QObject::tr("Remove Frame  at Frame %1")

        .arg(QString::number(m_frame + 1));

  }

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

};

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

static void removeSceneFrame(int frame) {

  RemoveSceneFrameUndo *undo = new RemoveSceneFrameUndo(frame);

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

  undo->redo();

}

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

class RemoveSceneFrameCommand final : public MenuItemHandler {

public:

  RemoveSceneFrameCommand() : MenuItemHandler(MI_RemoveSceneFrame) {}

  void execute() override {

    int frame = TApp::instance()->getCurrentFrame()->getFrame();

    XshCmd::removeSceneFrame(frame);

  }

} removeSceneFrameCommand;

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

//    GlobalKeyframeUndo  definition

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

class GlobalKeyframeUndo : public TUndo {

public:

  GlobalKeyframeUndo(int frame) : m_frame(frame) {}

  int getSize() const override {

    return sizeof(*this) + m_columns.size() * sizeof(int);

  }

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

protected:

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

  int m_frame;

protected:

  static void doInsertGlobalKeyframes(int frame,

                                      const std::vector<int> &columns);</int>

  static void doRemoveGlobalKeyframes(int frame,

                                      const std::vector<int> &columns);</int>

};

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

void GlobalKeyframeUndo::doInsertGlobalKeyframes(

    int frame, const std::vector<int> &columns) {</int>

  TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();

  for (const int c : columns) {

    TStageObjectId objectId;

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

    if (column && column->getSoundColumn()) continue;

    if (c == -1)

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

    else

      objectId = TStageObjectId::ColumnId(c);

    TXshColumn *xshColumn = xsh->getColumn(c);

    if (!xshColumn || xshColumn->isLocked() ||

        (xshColumn->isCellEmpty(frame) && !objectId.isCamera()))

      continue;

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

    obj->setKeyframeWithoutUndo(frame);

  }

}

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

void GlobalKeyframeUndo::doRemoveGlobalKeyframes(

    int frame, const std::vector<int> &columns) {</int>

  TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();

  for (const int c : columns) {

    TStageObjectId objectId;

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

    if (column && column->getSoundColumn()) continue;

    if (c == -1)

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

    else

      objectId = TStageObjectId::ColumnId(c);

    if (xsh->getColumn(c) && xsh->getColumn(c)->isLocked()) continue;

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

    obj->removeKeyframeWithoutUndo(frame);

  }

}

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

//    InsertGlobalKeyframe  command

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

class InsertGlobalKeyframeUndo final : public GlobalKeyframeUndo {

public:

  InsertGlobalKeyframeUndo(int frame, const std::vector<int> &columns)</int>

      : GlobalKeyframeUndo(frame) {

    tcg::substitute(

        m_columns,

        columns | ba::filtered(std::not1(boost::make_adaptable<bool, int="">(</bool,>

                      boost::bind(isKeyframe, frame, _1)))));

  }

  void redo() const override {

    doInsertGlobalKeyframes(m_frame, m_columns);

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

  }

  void undo() const override {

    doRemoveGlobalKeyframes(m_frame, m_columns);

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

  }

  QString getHistoryString() override {

    return QObject::tr("Insert Multiple Keys  at Frame %1")

        .arg(QString::number(m_frame + 1));

  }

};

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

static void insertGlobalKeyframe(int frame) {

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

  ::getColumns(columns);

  if (columns.empty()) return;

  TUndo *undo = new InsertGlobalKeyframeUndo(frame, columns);

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

  undo->redo();

}

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

class InsertGlobalKeyframeCommand final : public MenuItemHandler {

public:

  InsertGlobalKeyframeCommand() : MenuItemHandler(MI_InsertGlobalKeyframe) {}

  void execute() override {

    int frame = TApp::instance()->getCurrentFrame()->getFrame();

    XshCmd::insertGlobalKeyframe(frame);

  }

} insertGlobalKeyframeCommand;

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

//    RemoveGlobalKeyframe  command

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

class RemoveGlobalKeyframeUndo final : public GlobalKeyframeUndo {

  std::vector<tstageobject::keyframe> m_keyframes;</tstageobject::keyframe>

public:

  RemoveGlobalKeyframeUndo(int frame, const std::vector<int> &columns)</int>

      : GlobalKeyframeUndo(frame) {

    struct locals {

      static TStageObject::Keyframe getKeyframe(int r, int c) {

        TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();

        TStageObjectId objectId =

            (c == -1) ? TStageObjectId::CameraId(xsh->getCameraColumnIndex())

                      : TStageObjectId::ColumnId(c);

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

        assert(object);

        return object->getKeyframe(r);

      }

    };  // locals

    tcg::substitute(m_columns,

                    columns | ba::filtered(boost::bind(isKeyframe, frame, _1)));

    tcg::substitute(m_keyframes,

                    m_columns | ba::transformed(boost::bind(locals::getKeyframe,

                                                            frame, _1)));

  }

  void redo() const override {

    doRemoveGlobalKeyframes(m_frame, m_columns);

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

  }

  void undo() const override {

    TXsheet *xsh = TApp::instance()->getCurrentXsheet()->getXsheet();

    int c, cCount = int(m_columns.size());

    for (c = 0; c != cCount; ++c) {

      int col = m_columns[c];

      TStageObjectId objectId =

          (col == -1) ? TStageObjectId::CameraId(xsh->getCameraColumnIndex())

                      : TStageObjectId::ColumnId(col);

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

      object->setKeyframeWithoutUndo(m_frame, m_keyframes[c]);

    }

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

  }

  int getSize() const override {

    return GlobalKeyframeUndo::getSize() +

           m_keyframes.size() * sizeof(TStageObject::Keyframe);

  }

  QString getHistoryString() override {

    return QObject::tr("Remove Multiple Keys  at Frame %1")

        .arg(QString::number(m_frame + 1));

  }

};

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

static void removeGlobalKeyframe(int frame) {

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

  ::getColumns(columns);

  if (columns.empty()) return;

  TUndo *undo = new RemoveGlobalKeyframeUndo(frame, columns);

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

  undo->redo();

}

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

class RemoveGlobalKeyframeCommand final : public MenuItemHandler {

public:

  RemoveGlobalKeyframeCommand() : MenuItemHandler(MI_RemoveGlobalKeyframe) {}

  void execute() override {

    int frame = TApp::instance()->getCurrentFrame()->getFrame();

    XshCmd::removeGlobalKeyframe(frame);

  }

} removeGlobalKeyframeCommand;

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

//	Drawing Substitution

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

class DrawingSubtitutionUndo final : public TUndo {

private:

  int m_direction, m_row, m_col;

  TCellSelection::Range m_range;

  bool m_selected;

  std::vector<std::pair<int, int="">> emptyCells;</std::pair<int,>

public:

  DrawingSubtitutionUndo(int dir, TCellSelection::Range range, int row, int col,

                         bool selected)

      : m_direction(dir)

      , m_range(range)

      , m_row(row)

      , m_col(col)

      , m_selected(selected) {

    TXsheet *xsh = TApp::instance()->getCurrentScene()->getScene()->getXsheet();

    int tempCol, tempRow;

    int c = m_range.m_c0;

    int r = m_range.m_r0;

    while (c <= m_range.m_c1) {

      tempCol = c;

      while (r <= m_range.m_r1) {

        tempRow = r;

        if (xsh->getCell(tempRow, tempCol).isEmpty()) {

          emptyCells.push_back(std::make_pair(tempRow, tempCol));

        }

        r++;

      }

      r = m_range.m_r0;

      c++;

    }

  }

  void undo() const override {

    TXsheet *xsh = TApp::instance()->getCurrentScene()->getScene()->getXsheet();

    if (!m_selected) {

      changeDrawing(-m_direction, m_row, m_col);

      TApp::instance()->getCurrentScene()->setDirtyFlag(true);

      TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

      return;

    }

    int col, row;

    int c = m_range.m_c0;

    int r = m_range.m_r0;

    while (c <= m_range.m_c1) {

      col = c;

      while (r <= m_range.m_r1) {

        row        = r;

        bool found = false;

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

          if (emptyCells[i].first == row && emptyCells[i].second == col) {

            xsh->clearCells(row, col);

            found = true;

          }

        }

        if (found) {

          r++;

          continue;

        }

        changeDrawing(-m_direction, row, col);

        r++;

      }

      r = m_range.m_r0;

      c++;

    }

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

  }

  void redo() const override {

    if (!m_selected) {

      changeDrawing(m_direction, m_row, m_col);

      TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

      TApp::instance()->getCurrentScene()->setDirtyFlag(true);

      return;

    }

    int col, row;

    int c = m_range.m_c0;

    int r = m_range.m_r0;

    while (c <= m_range.m_c1) {

      col = c;

      while (r <= m_range.m_r1) {

        row = r;

        changeDrawing(m_direction, row, col);

        r++;

      }

      r = m_range.m_r0;

      c++;

    }

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

  }

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

  QString getHistoryString() override {

    return QObject::tr("Change current drawing %1")

        .arg(QString::number(m_direction));

  }

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

protected:

  static bool changeDrawing(int delta, int row, int col);

  static void setDrawing(const TFrameId &fid, int row, int col, TXshCell cell,

                         TXshLevel *level);

  friend class DrawingSubtitutionGroupUndo;

};

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

class DrawingSubtitutionGroupUndo final : public TUndo {

private:

  int m_direction;

  int m_row;

  int m_col;

  int m_count;

  bool m_selected;

  TCellSelection::Range m_range;

  std::vector<std::pair<int, int="">> emptyCells;</std::pair<int,>

  typedef std::map<std::pair<int, int="">, int> FramesMap;</std::pair<int,>

  FramesMap m_frameRanges;

public:

  DrawingSubtitutionGroupUndo(int dir, int row, int col, bool selected,

                              TCellSelection::Range range)

      : m_direction(dir)

      , m_col(col)

      , m_row(row)

      , m_selected(selected)

      , m_range(range) {

    TXsheet *xsh =

        TTool::getApplication()->getCurrentScene()->getScene()->getXsheet();

    if (!selected) {

      m_range.m_c0 = col;

      m_range.m_r0 = row;

      m_range.m_c1 = col;

      m_range.m_r1 = row;

    }

    for (int c = m_range.m_c0; c <= m_range.m_c1; c++) {

      for (int r = m_range.m_r0; r <= m_range.m_r1; r++) {

        TXshCell baseCell = xsh->getCell(r, c);

        // Find the 1st populated cell in the column

        if (baseCell.isEmpty()) continue;

        FramesMap::key_type frameBaseKey(r, c);

        int frameCount    = 1;

        TXshCell nextCell = xsh->getCell((r + frameCount), c);

        while (nextCell == baseCell ||

               (nextCell.isEmpty() && (r + frameCount) <= m_range.m_r1)) {

          if (nextCell.isEmpty())

            emptyCells.push_back(std::make_pair((r + frameCount), c));

          frameCount++;

          nextCell = xsh->getCell((r + frameCount), c);

        }

        m_frameRanges.insert(std::make_pair(frameBaseKey, 0));

        m_frameRanges[frameBaseKey] = frameCount;

        r = r + (frameCount - 1);  // Skip frames in range we've processed

      }

    }

  }

  void undo() const override {

    TXsheet *xsh =

        TTool::getApplication()->getCurrentScene()->getScene()->getXsheet();

    FramesMap::const_iterator ct;

    for (ct = m_frameRanges.begin(); ct != m_frameRanges.end(); ++ct) {

      int n = 0;

      while (n < ct->second) {

        int row = ct->first.first + n;

        int col = ct->first.second;

        std::vector<std::pair<int, int="">>::const_iterator it;</std::pair<int,>

        bool found = false;

        for (it = emptyCells.begin(); it != emptyCells.end(); ++it) {

          if (it->first == row && it->second == col) {

            xsh->clearCells(row, col);

            found = true;

          }

        }

        if (!found)

          DrawingSubtitutionUndo::changeDrawing(-m_direction, row, col);

        n++;

      }

    }

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

  }

  void redo() const override {

    FramesMap::const_iterator ct;

    for (ct = m_frameRanges.begin(); ct != m_frameRanges.end(); ++ct) {

      int n = 0;

      while (n < ct->second) {

        int row = ct->first.first + n;

        int col = ct->first.second;

        DrawingSubtitutionUndo::changeDrawing(m_direction, row, col);

        n++;

      }

    }

    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();

    TApp::instance()->getCurrentScene()->setDirtyFlag(true);

  }

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

  QString getHistoryString() override {

    return QObject::tr("Change current drawing %1")

        .arg(QString::number(m_direction));

  }

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

};

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

bool DrawingSubtitutionUndo::changeDrawing(int delta, int row, int col) {

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

  TXsheet *xsh            = app->getCurrentScene()->getScene()->getXsheet();

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

  bool usePrevCell        = false;

  if (cell.isEmpty()) {

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

    if (prevCell.isEmpty() || !(prevCell.m_level->getSimpleLevel() ||

                                prevCell.m_level->getChildLevel() ||

                                prevCell.m_level->getSoundTextLevel()))

      return false;

    cell        = prevCell;

    usePrevCell = true;

  } else if (!cell.m_level || !(cell.m_level->getSimpleLevel() ||

                                cell.m_level->getChildLevel() ||

                                cell.m_level->getSoundTextLevel()))

    return false;

  TXshLevel *level = cell.m_level->getSimpleLevel();

  if (!level) level = cell.m_level->getChildLevel();

  if (!level) level = cell.m_level->getSoundTextLevel();

  std::vector<tframeid> fids;</tframeid>

  int framesTextSize = 0;

  int n, index;

  bool usingSoundText = false;

  TFrameId cellFrameId;

  if (cell.m_level->getSimpleLevel())

    cell.m_level->getSimpleLevel()->getFids(fids);

  if (cell.m_level->getChildLevel())

    cell.m_level->getChildLevel()->getFids(fids);

  if (cell.m_level->getSoundTextLevel()) {

    n              = cell.m_level->getSoundTextLevel()->m_framesText.size();

    usingSoundText = true;

  } else

    n = fids.size();

  if (n < 2) return false;

  if (!usingSoundText) {

    std::vector<tframeid>::iterator it;</tframeid>

    it = std::find(fids.begin(), fids.end(), cell.m_frameId);

    if (it == fids.end()) return false;

    index = std::distance(fids.begin(), it);

  } else

    index = cell.getFrameId().getNumber();

  if (usePrevCell) {

    index -= delta;

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

  }

  // if negative direction, add the size to the direction to avoid a negative

  // modulo

  while (delta < 0) delta += n;

  // the index is the remainder

  index = (index + delta) % n;

  assert(index < n);

  // sound text levels can't have a 0 index frame id

  // the index points to a qlist<qstring></qstring>

  // reading 1 below the frameid number

  // and you can't have a -1 index on a qlist

  if (usingSoundText && index == 0) index = n;

  if (!usingSoundText)

    cellFrameId = fids[index];

  else

    cellFrameId = TFrameId(index);

  setDrawing(cellFrameId, row, col, cell, level);

  return true;

}