#include "filmstripcommand.h"
#include "tapp.h"
#include "toonz/palettecontroller.h"
#include "toonz/txshlevelhandle.h"
#include "toonz/txsheethandle.h"
#include "toonz/tscenehandle.h"
#include "toonz/tpalettehandle.h"
#include "toonz/tframehandle.h"
#include "tinbetween.h"
#include "tvectorimage.h"
#include "ttoonzimage.h"
#include "toonzqt/selection.h"
#include "toonzqt/dvdialog.h"
#include "drawingdata.h"
#include "toonzqt/strokesdata.h"
#include "toonzqt/rasterimagedata.h"
#include "timagecache.h"
#include "tools/toolutils.h"
#include "toonzqt/icongenerator.h"

#include "tundo.h"
#include "toonz/txshsimplelevel.h"
#include "toonz/txshchildlevel.h"
#include "toonz/txshsoundlevel.h"
#include "toonz/txshpalettelevel.h"
#include "toonz/txshpalettecolumn.h"
#include "toonz/txshsoundcolumn.h"
#include "toonz/txsheet.h"
#include "toonz/txshcell.h"
#include "toonz/toonzscene.h"
#include "toonz/levelset.h"
#include "toonz/txshleveltypes.h"
#include "toonz/toonzimageutils.h"
#include "toonz/trasterimageutils.h"
#include "toonz/tcamera.h"
#include "toonz/preferences.h"
#include "trop.h"
#include "tools/toolhandle.h"
#include "tools/rasterselection.h"
#include "tools/strokeselection.h"

#include "toonzqt/gutil.h"

#include "historytypes.h"

#include <QApplication>
#include <QClipboard>

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

TFrameId operator+(const TFrameId &fid, int d) {
  return TFrameId(fid.getNumber() + d, fid.getLetter(), fid.getZeroPadding(),
                  fid.getStartSeqInd());
}

//-----------------------------------------------------------------------------
/*
void doUpdateXSheet(TXshSimpleLevel *sl, std::vector<TFrameId> oldFids,
                    std::vector<TFrameId> newFids, TXsheet *xsh,
                    std::vector<TXshChildLevel *> &childLevels) {
  for (int c = 0; c < xsh->getColumnCount(); ++c) {
    int r0, r1;
    int n = xsh->getCellRange(c, r0, r1);
    if (n > 0) {
      bool changed = false;
      std::vector<TXshCell> cells(n);
      xsh->getCells(r0, c, n, &cells[0]);
      for (int i = 0; i < n; i++) {
        TXshCell currCell = cells[i];
        // check the sub xsheets too
        if (!cells[i].isEmpty() &&
            cells[i].m_level->getType() == CHILD_XSHLEVEL) {
          TXshChildLevel *level = cells[i].m_level->getChildLevel();
          // make sure we haven't already checked the level
          if (level && std::find(childLevels.begin(), childLevels.end(),
                                 level) == childLevels.end()) {
            childLevels.push_back(level);
            TXsheet *subXsh = level->getXsheet();
            doUpdateXSheet(sl, oldFids, newFids, subXsh, childLevels);
          }
        }
        for (int j = 0; j < oldFids.size(); j++) {
          if (oldFids.at(j) == newFids.at(j)) continue;
          TXshCell tempCell(sl, oldFids.at(j));
          bool sameSl  = tempCell.getSimpleLevel() == currCell.getSimpleLevel();
          bool sameFid = tempCell.getFrameId() == currCell.getFrameId();
          if (sameSl && sameFid) {
            TXshCell newCell(sl, newFids.at(j));
            cells[i] = newCell;
            changed  = true;
            break;
          }
        }
      }
      if (changed) {
        xsh->setCells(r0, c, n, &cells[0]);
        TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();
      }
    }
  }
}
*/
//-----------------------------------------------------------------------------

static void updateXSheet(TXshSimpleLevel *sl, std::vector<TFrameId> oldFids,
                         std::vector<TFrameId> newFids) {
  std::vector<TXshChildLevel *> childLevels;
  TXsheet *xsh =
      TApp::instance()->getCurrentScene()->getScene()->getTopXsheet();
  bool changed =
      ToolUtils::doUpdateXSheet(sl, oldFids, newFids, xsh, childLevels);
  if (changed) TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();
}

//=============================================================================
// makeSpaceForFid
// se necessario renumera gli altri fid del livello in modo che
// framesToInsert siano liberi
// n.b. modifica
//-----------------------------------------------------------------------------

void makeSpaceForFids(TXshSimpleLevel *sl,
                      const std::set<TFrameId> &framesToInsert) {
  std::vector<TFrameId> fids;
  std::vector<TFrameId> oldFids;
  sl->getFids(fids);
  sl->getFids(oldFids);
  std::set<TFrameId>::const_iterator it;
  std::set<TFrameId> touchedFids;
  for (it = framesToInsert.begin(); it != framesToInsert.end(); ++it) {
    // devo inserire fid
    TFrameId fid(*it);
    std::vector<TFrameId>::iterator j;
    // controllo che non ci sia gia'
    j = fids.begin();
    while (j = std::find(j, fids.end(), fid), j != fids.end()) {
      // c'e' gia' un fid. faccio fid -> fid + 1
      touchedFids.insert(fid);
      fid = fid + 1;
      touchedFids.insert(fid);
      *j = fid;
      // adesso devo controllare che il nuovo fid non ci sia gia' nella
      // parte restante dell'array fids
      ++j;
    }
  }
  if (!touchedFids.empty()) {
    if (Preferences::instance()->isSyncLevelRenumberWithXsheetEnabled())
      updateXSheet(sl, oldFids, fids);
    sl->renumber(fids);
    sl->setDirtyFlag(true);
  }
}

//=============================================================================
namespace {
//-----------------------------------------------------------------------------

void copyFramesWithoutUndo(TXshSimpleLevel *sl, std::set<TFrameId> &frames) {
  QClipboard *clipboard = QApplication::clipboard();
  TXsheet *xsh          = TApp::instance()->getCurrentXsheet()->getXsheet();
  DrawingData *data     = new DrawingData();
  data->setLevelFrames(sl, frames);
  clipboard->setMimeData(data, QClipboard::Clipboard);
}

//-----------------------------------------------------------------------------
// frames is a selected frames in the film strip
bool pasteAreasWithoutUndo(const QMimeData *data, TXshSimpleLevel *sl,
                           std::set<TFrameId> &frames, TTileSet **tileSet,
                           std::map<TFrameId, std::set<int>> &indices) {
  // paste between the same level must keep the palette unchanged
  // Not emitting PaletteChanged signal can avoid the update of color model
  bool paletteHasChanged = true;

  if (const StrokesData *strokesData =
          dynamic_cast<const StrokesData *>(data)) {
    std::set<TFrameId>::iterator it;
    for (it = frames.begin(); it != frames.end(); ++it) {
      TImageP img = sl->getFrame(*it, true);
      if (!img) {
        img = sl->createEmptyFrame();
        sl->setFrame(*it, img);
      }
      TVectorImageP vi = img;
      TToonzImageP ti  = img;
      TRasterImageP ri = img;
      if (vi) {
        std::set<int> imageIndices;
        strokesData->getImage(vi, imageIndices, true);
        indices[*it] = imageIndices;
      } else if (ti) {
        ToonzImageData *toonzImageData = strokesData->toToonzImageData(ti);
        return pasteAreasWithoutUndo(toonzImageData, sl, frames, tileSet,
                                     indices);
      } else if (ri) {
        double dpix, dpiy;
        ri->getDpi(dpix, dpiy);
        if (dpix == 0 || dpiy == 0) {
          TPointD dpi = sl->getScene()->getCurrentCamera()->getDpi();
          dpix        = dpi.x;
          dpiy        = dpi.y;
          ri->setDpi(dpix, dpiy);
        }
        FullColorImageData *fullColorImageData =
            strokesData->toFullColorImageData(ri);
        return pasteAreasWithoutUndo(fullColorImageData, sl, frames, tileSet,
                                     indices);
      }
    }
  }
  // when pasting the copied area selected with the selection tool
  else if (const RasterImageData *rasterImageData =
               dynamic_cast<const RasterImageData *>(data)) {
    std::set<TFrameId>::iterator it;
    for (it = frames.begin(); it != frames.end(); ++it) {
      if ((sl->getType() == PLI_XSHLEVEL || sl->getType() == TZP_XSHLEVEL) &&
          dynamic_cast<const FullColorImageData *>(rasterImageData)) {
        DVGui::error(QObject::tr(
            "The copied selection cannot be pasted in the current drawing."));
        return false;
      }
      // obtain the image data to be pasted
      TImageP img = sl->getFrame(*it, true);
      if (!img) {
        img = sl->createEmptyFrame();
        sl->setFrame(*it, img);
      }
      TToonzImageP ti  = img;
      TRasterImageP ri = img;
      TVectorImageP vi = img;
      // pasting TLV
      if (ti) {
        TRasterP ras;
        double dpiX, dpiY;
        std::vector<TRectD> rects;
        std::vector<TStroke> strokes;
        std::vector<TStroke> originalStrokes;
        TAffine affine;

        // style will be merged in getData() if the palettes are different
        int styleCountBeforePasteImage = ti->getPalette()->getStyleCount();

        rasterImageData->getData(ras, dpiX, dpiY, rects, strokes,
                                 originalStrokes, affine, ti->getPalette());

        if (styleCountBeforePasteImage == ti->getPalette()->getStyleCount())
          paletteHasChanged = false;

        double imgDpiX, imgDpiY;
        ti->getDpi(imgDpiX, imgDpiY);
        TScale sc(imgDpiX / dpiX, imgDpiY / dpiY);
        affine *= sc;
        int i;
        TRectD boxD;
        if (rects.size() > 0) boxD   = rects[0];
        if (strokes.size() > 0) boxD = strokes[0].getBBox();
        for (i = 0; i < rects.size(); i++) boxD += rects[i];
        for (i     = 0; i < strokes.size(); i++) boxD += strokes[i].getBBox();
        boxD       = affine * boxD;
        TRect box  = ToonzImageUtils::convertWorldToRaster(boxD, ti);
        TPoint pos = box.getP00();

        if (pos.x < 0) pos.x = 0;
        if (pos.y < 0) pos.y = 0;

        if (*tileSet == 0)
          *tileSet = new TTileSetCM32(ti->getRaster()->getSize());
        if (box.overlaps(ti->getRaster()->getBounds()))
          (*tileSet)->add(ti->getRaster(), box);
        else
          (*tileSet)->add(0);
        TRasterCM32P app = ras;
        if (app) {
          TRop::over(ti->getRaster(), app, pos, affine);
          ToolUtils::updateSaveBox(sl, *it);
        }
      } else if (ri) {
        if (!ri->getPalette())
          ri->setPalette(TApp::instance()
                             ->getPaletteController()
                             ->getDefaultPalette(sl->getType())
                             ->clone());
        TRasterP ras;
        double dpiX = 0, dpiY = 0;
        double imgDpiX = 0, imgDpiY = 0;
        std::vector<TRectD> rects;
        std::vector<TStroke> strokes;
        std::vector<TStroke> originalStrokes;
        TAffine affine;

        TPointD cameraDpi;

        ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();
        if (scene) {
          TCamera *camera = scene->getCurrentCamera();
          cameraDpi       = camera->getDpi();
          if (cameraDpi.x == 0.0 ||
              cameraDpi.y == 0.0)  // it should never happen. just in case...
            return false;
        } else
          return false;

        rasterImageData->getData(ras, dpiX, dpiY, rects, strokes,
                                 originalStrokes, affine, ri->getPalette());
        if (dpiX == 0 || dpiY == 0) {
          dpiX = cameraDpi.x;
          dpiY = cameraDpi.y;
        }

        ri->getDpi(imgDpiX, imgDpiY);
        if (imgDpiX == 0 || imgDpiY == 0) {
          imgDpiX = cameraDpi.x;
          imgDpiY = cameraDpi.y;
        }
        TScale sc(imgDpiX / dpiX, imgDpiY / dpiY);
        affine *= sc;
        int i;
        TRectD boxD;
        if (rects.size() > 0) boxD   = rects[0];
        if (strokes.size() > 0) boxD = strokes[0].getBBox();
        for (i = 0; i < rects.size(); i++) boxD += rects[i];
        for (i     = 0; i < strokes.size(); i++) boxD += strokes[i].getBBox();
        boxD       = affine * boxD;
        TRect box  = TRasterImageUtils::convertWorldToRaster(boxD, ri);
        TPoint pos = box.getP00();
        if (*tileSet == 0)
          *tileSet = new TTileSetFullColor(ri->getRaster()->getSize());
        if (box.overlaps(ri->getRaster()->getBounds()))
          (*tileSet)->add(ri->getRaster(), box);
        else
          (*tileSet)->add(0);
        TRasterCM32P app = ras;
        if (app)
          TRop::over(ri->getRaster(), app, ri->getPalette(), pos, affine);
        else
          TRop::over(ri->getRaster(), ras, pos, affine);
      } else if (vi) {
        StrokesData *strokesData =
            rasterImageData->toStrokesData(sl->getScene());
        return pasteAreasWithoutUndo(strokesData, sl, frames, tileSet, indices);
      }
    }
  } else
    return false;

  if (paletteHasChanged)
    TApp::instance()
        ->getPaletteController()
        ->getCurrentLevelPalette()
        ->notifyPaletteChanged();

  invalidateIcons(sl, frames);
  sl->setDirtyFlag(true);
  TApp::instance()->getCurrentLevel()->notifyLevelChange();

  return true;
}

//-----------------------------------------------------------------------------
// Se insert == true incolla i frames nel livello inserendoli, se necessario
// spostando
// verso il basso i preesistenti. Altrimenti incolla i frames sostituendoli.
// il parametro clone images si mette a false quando questa funzione viene usata
// per un undo/redo.

bool pasteFramesWithoutUndo(const DrawingData *data, TXshSimpleLevel *sl,
                            std::set<TFrameId> &frames,
                            DrawingData::ImageSetType setType, bool cloneImages,
                            bool &keepOriginalPalette, bool isRedo = false) {
  if (!data || (frames.empty() && setType != DrawingData::OVER_FRAMEID))
    return false;

  bool isPaste = data->getLevelFrames(sl, frames, setType, cloneImages,
                                      keepOriginalPalette, isRedo);
  if (!isPaste) return false;

  if (keepOriginalPalette)
    invalidateIcons(sl, frames);
  else {
    std::vector<TFrameId> sl_fids;
    sl->getFids(sl_fids);
    invalidateIcons(sl, sl_fids);
  }
  sl->setDirtyFlag(true);
  TApp::instance()->getCurrentLevel()->notifyLevelChange();
  TApp::instance()
      ->getPaletteController()
      ->getCurrentLevelPalette()
      ->notifyPaletteChanged();

  return true;
}

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

// "Svuota" i frames: i frames vengono buttati e al loro posto
// vengono inseriti frames vuoti.
std::map<TFrameId, QString> clearFramesWithoutUndo(
    const TXshSimpleLevelP &sl, const std::set<TFrameId> &frames) {
  std::map<TFrameId, QString> clearedFrames;
  if (!sl || frames.empty()) return clearedFrames;

  std::set<TFrameId>::const_iterator it;
  for (it = frames.begin(); it != frames.end(); ++it) {
    TFrameId frameId = *it;
    /* UINT にキャストしたらだめだろ */
    // QString id =
    // "clearFrames"+QString::number((UINT)sl.getPointer())+"-"+QString::number(it->getNumber());
    QString id = "clearFrames" + QString::number((uintptr_t)sl.getPointer()) +
                 "-" + QString::number(it->getNumber());
    TImageCache::instance()->add(id, sl->getFrame(frameId, false));
    clearedFrames[frameId] = id;
    // empty frame must be created BEFORE erasing frame or it may initialize
    // palette.
    TImageP emptyFrame = sl->createEmptyFrame();
    sl->eraseFrame(frameId);
    sl->setFrame(*it, emptyFrame);
  }
  invalidateIcons(sl.getPointer(), frames);
  TApp::instance()->getCurrentLevel()->notifyLevelChange();
  sl->setDirtyFlag(true);
  return clearedFrames;
}

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

// Rimuove i frames dal livello
void removeFramesWithoutUndo(const TXshSimpleLevelP &sl,
                             const std::set<TFrameId> &frames) {
  if (!sl || frames.empty()) return;
  std::set<TFrameId>::const_iterator it;
  for (it = frames.begin(); it != frames.end(); ++it) sl->eraseFrame(*it);
  removeIcons(sl.getPointer(), frames);
  sl->setDirtyFlag(true);
  TApp::instance()->getCurrentLevel()->notifyLevelChange();
}

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

void cutFramesWithoutUndo(TXshSimpleLevel *sl, std::set<TFrameId> &frames) {
  std::map<TFrameId, QString> imageSet;

  HookSet *levelHooks   = sl->getHookSet();
  int currentFrameIndex = TApp::instance()->getCurrentFrame()->getFrameIndex();
  std::set<TFrameId>::const_iterator it;
  int i = 0;
  for (it = frames.begin(); it != frames.end(); ++it, i++) {
    TFrameId frameId = *it;
    // QString id =
    // "cutFrames"+QString::number((UINT)sl)+"-"+QString::number(it->getNumber());
    QString id = "cutFrames" + QString::number((uintptr_t)sl) + "-" +
                 QString::number(it->getNumber());
    TImageCache::instance()->add(id, sl->getFrame(frameId, false));
    imageSet[frameId] = id;
  }
  removeIcons(sl, frames);

  sl->setDirtyFlag(true);

  QClipboard *clipboard = QApplication::clipboard();
  DrawingData *data     = new DrawingData();
  data->setFrames(imageSet, sl, *levelHooks);
  clipboard->setMimeData(data, QClipboard::Clipboard);

  for (it = frames.begin(); it != frames.end(); ++it, i++) {
    sl->eraseFrame(*it);
  }

  std::vector<TFrameId> newFids;
  sl->getFids(newFids);
  // Devo settare i nuovi fids al frame handle prima di mandare la notifica di
  // cambiamento del livello
  TApp::instance()->getCurrentFrame()->setFrameIds(newFids);
  TApp::instance()->getCurrentFrame()->setFrameIndex(currentFrameIndex);
  TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();
  sl->setDirtyFlag(true);
  TApp::instance()->getCurrentLevel()->notifyLevelChange();
}

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

std::map<TFrameId, QString> deleteFramesWithoutUndo(
    TXshSimpleLevel *sl, std::set<TFrameId> &frames) {
  std::map<TFrameId, QString> imageSet;
  if (!sl || frames.empty()) return imageSet;

  int currentFrameIndex = TApp::instance()->getCurrentFrame()->getFrameIndex();
  std::set<TFrameId>::const_iterator it;
  int i = 0;
  for (it = frames.begin(); it != frames.end(); ++it, i++) {
    TFrameId frameId = *it;
    QString id       = "deleteFrames" + QString::number((uintptr_t)sl) + "-" +
                 QString::number(it->getNumber());
    TImageCache::instance()->add(id, sl->getFrame(frameId, false));
    imageSet[frameId] = id;
  }
  removeIcons(sl, frames);

  sl->setDirtyFlag(true);

  for (it = frames.begin(); it != frames.end(); ++it, i++) {
    sl->eraseFrame(*it);
  }

  std::vector<TFrameId> newFids;
  sl->getFids(newFids);

  TApp::instance()->getCurrentFrame()->setFrameIds(newFids);
  TApp::instance()->getCurrentFrame()->setFrameIndex(currentFrameIndex);
  TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();
  sl->setDirtyFlag(true);
  TApp::instance()->getCurrentLevel()->notifyLevelChange();
  return imageSet;
}

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

void insertNotEmptyframes(const TXshSimpleLevelP &sl,
                          const std::map<TFrameId, QString> &framesToInsert) {
  if (framesToInsert.empty() || !sl) return;
  std::vector<TFrameId> fids;
  sl->getFids(fids);
  std::set<TFrameId> frames;
  for (auto const &frame : framesToInsert) {
    frames.insert(frame.first);
  }
  makeSpaceForFids(sl.getPointer(), frames);

  for (auto const &frame : framesToInsert) {
    TImageP img = TImageCache::instance()->get(frame.second, false);
    TImageCache::instance()->remove(frame.second);
    assert(img);
    sl->setFrame(frame.first, img);
  }
  invalidateIcons(sl.getPointer(), frames);
  sl->setDirtyFlag(true);
  TApp::instance()->getCurrentLevel()->notifyLevelChange();
}

//=============================================================================
// PasteRasterAreasUndo
//-----------------------------------------------------------------------------

class PasteRasterAreasUndo final : public TUndo {
  TXshSimpleLevelP m_level;
  std::set<TFrameId> m_frames;
  TTileSet *m_tiles;
  RasterImageData *m_data;
  TPaletteP m_oldPalette;
  TPaletteP m_newPalette;
  bool m_isFrameInserted;

public:
  PasteRasterAreasUndo(TXshSimpleLevel *sl, const std::set<TFrameId> &frames,
                       TTileSet *tiles, RasterImageData *data, TPalette *plt,
                       bool isFrameInserted)
      : TUndo()
      , m_level(sl)
      , m_frames(frames)
      , m_tiles(tiles)
      , m_oldPalette(plt->clone())
      , m_isFrameInserted(isFrameInserted) {
    m_data = data->clone();
    assert(m_tiles->getTileCount() == m_frames.size());
  }

  ~PasteRasterAreasUndo() {
    if (m_tiles) delete m_tiles;
    if (m_data) delete m_data;
  }

  void onAdd() override { m_newPalette = m_level->getPalette()->clone(); }

  void undo() const override {
    if (!m_level || m_frames.empty()) return;
    std::set<TFrameId> frames = m_frames;

    if (m_isFrameInserted) {
      // Faccio remove dei frame incollati
      removeFramesWithoutUndo(m_level, frames);
    } else {
      std::set<TFrameId>::const_iterator it;
      int i                        = 0;
      TTileSetCM32 *tileSetCM      = dynamic_cast<TTileSetCM32 *>(m_tiles);
      TTileSetFullColor *tileSetFC = dynamic_cast<TTileSetFullColor *>(m_tiles);
      for (it = m_frames.begin(); it != m_frames.end(); it++, i++) {
        TImageP image = m_level->getFrame(*it, true);
        if (!image) continue;
        TRasterImageP ri(image);
        TToonzImageP ti(image);
        if (tileSetCM) {
          const TTileSetCM32::Tile *tile = tileSetCM->getTile(i);
          if (!tile) continue;
          TRasterCM32P tileRas;
          tile->getRaster(tileRas);
          assert(ti);
          ti->getRaster()->copy(tileRas, tile->m_rasterBounds.getP00());
          ToolUtils::updateSaveBox(m_level, *it);
        } else if (tileSetFC) {
          const TTileSetFullColor::Tile *tile = tileSetFC->getTile(i);
          if (!tile) continue;
          TRasterP tileRas;
          tile->getRaster(tileRas);
          assert(ri);
          ri->getRaster()->copy(tileRas, tile->m_rasterBounds.getP00());
        }
      }
    }
    // Setto la vecchia paletta al livello
    if (m_oldPalette.getPointer()) {
      m_level->getPalette()->assign(m_oldPalette->clone());
      TApp::instance()
          ->getPaletteController()
          ->getCurrentLevelPalette()
          ->notifyPaletteChanged();
    }

    invalidateIcons(m_level.getPointer(), m_frames);
    TApp::instance()->getCurrentLevel()->notifyLevelChange();
  }

  void redo() const override {
    if (!m_level || m_frames.empty()) return;
    if (m_isFrameInserted) {
      assert(m_frames.size() == 1);
      TImageP img = m_level->createEmptyFrame();
      m_level->setFrame(*m_frames.begin(), img);
    }

    std::set<TFrameId> frames = m_frames;

    std::set<TFrameId>::const_iterator it;
    for (it = m_frames.begin(); it != m_frames.end(); it++) {
      TImageP image    = m_level->getFrame(*it, true);
      TRasterImageP ri = image;
      TToonzImageP ti  = image;
      if (ti) {
        TRasterP ras;
        double dpiX, dpiY;
        std::vector<TRectD> rects;
        std::vector<TStroke> strokes;
        std::vector<TStroke> originalStrokes;
        TAffine affine;
        m_data->getData(ras, dpiX, dpiY, rects, strokes, originalStrokes,
                        affine, ti->getPalette());
        double imgDpiX, imgDpiY;
        ti->getDpi(imgDpiX, imgDpiY);
        TScale sc(imgDpiX / dpiX, imgDpiY / dpiY);
        affine *= sc;

        int i;
        TRectD boxD;
        if (rects.size() > 0) boxD   = rects[0];
        if (strokes.size() > 0) boxD = strokes[0].getBBox();
        for (i = 0; i < rects.size(); i++) boxD += rects[i];
        for (i     = 0; i < strokes.size(); i++) boxD += strokes[i].getBBox();
        boxD       = affine * boxD;
        TRect box  = ToonzImageUtils::convertWorldToRaster(boxD, ti);
        TPoint pos = box.getP00();
        TRasterCM32P app = ras;
        TRop::over(ti->getRaster(), app, pos, affine);
        ToolUtils::updateSaveBox(m_level, *it);
      } else if (ri) {
        if (!ri->getPalette())
          ri->setPalette(TApp::instance()
                             ->getPaletteController()
                             ->getDefaultPalette(m_level->getType())
                             ->clone());
        TRasterP ras;
        double dpiX, dpiY;
        std::vector<TRectD> rects;
        std::vector<TStroke> strokes;
        std::vector<TStroke> originalStrokes;
        TAffine affine;
        m_data->getData(ras, dpiX, dpiY, rects, strokes, originalStrokes,
                        affine, ri->getPalette());
        double imgDpiX, imgDpiY;
        if (dpiX == 0 && dpiY == 0) {
          ToonzScene *scene = TApp::instance()->getCurrentScene()->getScene();
          if (scene) {
            TCamera *camera = scene->getCurrentCamera();
            TPointD dpi     = camera->getDpi();
            dpiX            = dpi.x;
            dpiY            = dpi.y;
          } else
            return;
        }
        ri->getDpi(imgDpiX, imgDpiY);
        TScale sc(imgDpiX / dpiX, imgDpiY / dpiY);
        affine *= sc;
        int i;
        TRectD boxD;
        if (rects.size() > 0) boxD   = rects[0];
        if (strokes.size() > 0) boxD = strokes[0].getBBox();
        for (i = 0; i < rects.size(); i++) boxD += rects[i];
        for (i     = 0; i < strokes.size(); i++) boxD += strokes[i].getBBox();
        boxD       = affine * boxD;
        TRect box  = TRasterImageUtils::convertWorldToRaster(boxD, ri);
        TPoint pos = box.getP00();
        TRasterCM32P app = ras;
        if (app)
          TRop::over(ri->getRaster(), app, ri->getPalette(), pos, affine);
        else
          TRop::over(ri->getRaster(), ras, pos, affine);
      }
    }

    if (m_newPalette.getPointer()) {
      m_level->getPalette()->assign(m_newPalette->clone());
      TApp::instance()
          ->getPaletteController()
          ->getCurrentLevelPalette()
          ->notifyPaletteChanged();
    }

    invalidateIcons(m_level.getPointer(), m_frames);
    TApp::instance()->getCurrentLevel()->notifyLevelChange();
  }

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

  QString getHistoryString() override {
    QString str = QObject::tr("Paste  : Level %1 : Frame ")
                      .arg(QString::fromStdWString(m_level->getName()));

    std::set<TFrameId>::const_iterator it;
    for (it = m_frames.begin(); it != m_frames.end(); it++) {
      if (it != m_frames.begin()) str += QString(", ");
      str += QString::number((*it).getNumber());
    }

    return str;
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

//=============================================================================
// PasteVectorAreasUndo
//-----------------------------------------------------------------------------

class PasteVectorAreasUndo final : public TUndo {
  TXshSimpleLevelP m_level;
  std::set<TFrameId> m_frames;
  std::map<TFrameId, std::set<int>> m_indices;
  StrokesData *m_data;
  TPaletteP m_oldPalette;
  TPaletteP m_newPalette;
  bool m_isFrameInserted;

public:
  PasteVectorAreasUndo(TXshSimpleLevel *sl, const std::set<TFrameId> &frames,
                       std::map<TFrameId, std::set<int>> &indices,
                       StrokesData *data, TPalette *plt, bool isFrameInserted)
      : TUndo()
      , m_level(sl)
      , m_frames(frames)
      , m_indices(indices)
      , m_oldPalette(plt->clone())
      , m_isFrameInserted(isFrameInserted) {
    m_data = data->clone();
  }

  ~PasteVectorAreasUndo() {
    if (m_data) delete m_data;
  }

  void onAdd() override { m_newPalette = m_level->getPalette()->clone(); }

  void undo() const override {
    if (!m_level || m_frames.empty()) return;

    std::set<TFrameId> frames = m_frames;

    if (m_isFrameInserted) {
      // Faccio remove dei frame incollati
      removeFramesWithoutUndo(m_level, frames);
    } else {
      std::set<TFrameId>::const_iterator it;
      for (it = m_frames.begin(); it != m_frames.end(); it++) {
        TVectorImageP img = m_level->getFrame(*it, true);
        assert(img);
        if (!img) continue;
        std::map<TFrameId, std::set<int>>::const_iterator mapIt =
            m_indices.find(*it);
        if (mapIt == m_indices.end()) continue;
        std::set<int> imageIndices = mapIt->second;
        ;
        std::set<int>::const_iterator it2 = imageIndices.end();
        while (it2 != imageIndices.begin()) {
          it2--;
          img->removeStroke(*it2);
        }
      }
    }

    // Setto la vecchia paletta al livello
    if (m_oldPalette.getPointer()) {
      m_level->getPalette()->assign(m_oldPalette->clone());
      TApp::instance()
          ->getPaletteController()
          ->getCurrentLevelPalette()
          ->notifyPaletteChanged();
    }

    invalidateIcons(m_level.getPointer(), m_frames);
    TApp::instance()->getCurrentLevel()->notifyLevelChange();
  }

  void redo() const override {
    if (!m_level || m_frames.empty()) return;

    if (m_isFrameInserted) {
      assert(m_frames.size() == 1);
      TVectorImageP img = m_level->createEmptyFrame();
      m_level->setFrame(*m_frames.begin(), img);
    }

    std::set<TFrameId> frames = m_frames;
    std::set<TFrameId>::const_iterator it;
    for (it = m_frames.begin(); it != m_frames.end(); it++) {
      TVectorImageP img = m_level->getFrame(*it, true);
      assert(img);
      if (!img) continue;
      std::set<int> app;
      m_data->getImage(img, app, true);
    }

    if (m_newPalette.getPointer()) {
      m_level->getPalette()->assign(m_newPalette->clone());
      TApp::instance()
          ->getPaletteController()
          ->getCurrentLevelPalette()
          ->notifyPaletteChanged();
    }

    invalidateIcons(m_level.getPointer(), m_frames);
    TApp::instance()->getCurrentLevel()->notifyLevelChange();
  }

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

  QString getHistoryString() override {
    QString str = QObject::tr("Paste  : Level %1 : Frame ")
                      .arg(QString::fromStdWString(m_level->getName()));

    std::set<TFrameId>::const_iterator it;
    for (it = m_frames.begin(); it != m_frames.end(); it++) {
      if (it != m_frames.begin()) str += QString(", ");
      str += QString::number((*it).getNumber());
    }

    return str;
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

/*//=============================================================================
// PasteAreasUndo
//-----------------------------------------------------------------------------

class PasteAreasUndo final : public TUndo
{
  TXshSimpleLevelP m_level;
  std::set<TFrameId> m_frames;
        TPaletteP m_oldPalette;
        TPaletteP m_newPalette;
        bool m_isFrameInserted;

public:
  PasteAreasUndo(TXshSimpleLevel *sl, const std::set<TFrameId> &frames, bool
isFrameInserted)
      : TUndo()
      , m_level(sl)
                        , m_frames(frames)
                        , m_isFrameInserted(isFrameInserted)
        {
                m_oldPalette = m_level->getPalette()->clone();
                if(!m_isFrameInserted)
                {
                        std::set<TFrameId>::iterator it;
                        for(it=m_frames.begin(); it!=m_frames.end(); it++)
                        {
                                TImageP img = m_level->getFrame(*it,true);
                                TImageCache::instance()->add("PasteAreasUndoOld"+QString::number((UINT)this)+QString::number((*it).getNumber()),
img->cloneImage());
                        }
                }
  }

        void onAdd()
        {
                m_newPalette = m_level->getPalette()->clone();
                std::set<TFrameId>::iterator it;
                for(it=m_frames.begin(); it!=m_frames.end(); it++)
                {
                        TImageP img = m_level->getFrame(*it,true);
                        TImageCache::instance()->add("PasteAreasUndoNew"+QString::number((UINT)this)+QString::number((*it).getNumber()),
img->cloneImage());
                }
        }

  ~PasteAreasUndo() {
                std::set<TFrameId>::const_iterator it;

                if(!m_isFrameInserted)
                {
                        for(it=m_frames.begin(); it!=m_frames.end(); it++)
                                TImageCache::instance()->remove("PasteAreasUndoOld"+QString::number((UINT)this)+QString::number((*it).getNumber()));
                }
                for(it=m_frames.begin(); it!=m_frames.end(); it++)
                        TImageCache::instance()->remove("PasteAreasUndoNew"+QString::number((UINT)this)+QString::number((*it).getNumber()));
  }

        void undo() const
        {
                std::set<TFrameId> frames = m_frames;

                if(m_isFrameInserted)
                {
                        // Faccio remove dei frame incollati
                        removeFramesWithoutUndo(m_level, frames);
                }
                else
                {
                        std::set<TFrameId>::const_iterator it;
                        for(it=m_frames.begin(); it!=m_frames.end(); it++)
                        {
                                TImageP img =
TImageCache::instance()->get("PasteAreasUndoOld"+QString::number((UINT)this)+QString::number((*it).getNumber()),true);
                                assert(img);
                                m_level->setFrame(*it,img);
                        }
                }

                //Setto la vecchia paletta al livello
                if(m_oldPalette.getPointer())
                {
                        m_level->getPalette()->assign(m_oldPalette->clone());
      TApp::instance()->getPaletteController()->getCurrentLevelPalette()->notifyPaletteChanged();
                }

    invalidateIcons(m_level.getPointer(), m_frames);
                TApp::instance()->getCurrentLevel()->notifyLevelChange();
  }

  void redo() const
        {
                if(!m_level || m_frames.empty()) return;

    std::set<TFrameId> frames = m_frames;

                std::set<TFrameId>::const_iterator it;
                for(it=m_frames.begin(); it!=m_frames.end(); it++)
                {
                        TImageP img =
TImageCache::instance()->get("PasteAreasUndoNew"+QString::number((UINT)this)+QString::number((*it).getNumber()),true);
                        if(!img) continue;
                        m_level->setFrame(*it, img, true);
                }

                if(m_newPalette.getPointer())
                {
      m_level->getPalette()->assign(m_newPalette->clone());
      TApp::instance()->getPaletteController()->getCurrentLevelPalette()->notifyPaletteChanged();
                }

                invalidateIcons(m_level.getPointer(), m_frames);
                TApp::instance()->getCurrentLevel()->notifyLevelChange();
  }

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

//=============================================================================
// PasteFramesUndo
//-----------------------------------------------------------------------------

class PasteFramesUndo final : public TUndo {
  TXshSimpleLevelP m_sl;
  std::set<TFrameId> m_frames;
  std::vector<TFrameId> m_oldLevelFrameId;
  TPaletteP m_oldPalette;
  DrawingData *m_oldData;
  DrawingData *m_newData;
  DrawingData::ImageSetType m_setType;
  HookSet *m_oldLevelHooks;
  bool m_updateXSheet;
  bool m_keepOriginalPalette;

public:
  PasteFramesUndo(TXshSimpleLevel *sl, const std::set<TFrameId> &frames,
                  const std::vector<TFrameId> &oldLevelFrameId,
                  TPaletteP oldPalette, DrawingData::ImageSetType setType,
                  HookSet *oldLevelHooks, bool keepOriginalPalette,
                  DrawingData *oldData = 0)
      : m_sl(sl)
      , m_frames(frames)
      , m_oldLevelFrameId(oldLevelFrameId)
      , m_oldPalette(oldPalette)
      , m_setType(setType)
      , m_keepOriginalPalette(keepOriginalPalette)
      , m_oldData(oldData)
      , m_oldLevelHooks(oldLevelHooks) {
    QClipboard *clipboard = QApplication::clipboard();
    QMimeData *data       = cloneData(clipboard->mimeData());
    m_newData             = dynamic_cast<DrawingData *>(data);
    assert(m_newData);
    m_updateXSheet =
        Preferences::instance()->isSyncLevelRenumberWithXsheetEnabled();
  }

  ~PasteFramesUndo() {
    if (m_oldData) m_oldData->releaseData();
    if (m_newData) m_newData->releaseData();
  }

  void undo() const override {
    TSelection *selection = TSelection::getCurrent();
    if (selection) selection->selectNone();
    std::set<TFrameId> frames = m_frames;

    // Faccio remove dei frame incollati
    if (m_setType != DrawingData::OVER_SELECTION)
      removeFramesWithoutUndo(m_sl, frames);

    // Renumero i frame con i vecchi fids
    if (m_setType == DrawingData::INSERT) {
      assert(m_sl->getFrameCount() == m_oldLevelFrameId.size());
      if (m_updateXSheet) {
        std::vector<TFrameId> newFrames;
        m_sl->getFids(newFrames);
        updateXSheet(m_sl.getPointer(), newFrames, m_oldLevelFrameId);
      }
      m_sl->renumber(m_oldLevelFrameId);
      m_sl->setDirtyFlag(true);
      TApp::instance()
          ->getPaletteController()
          ->getCurrentLevelPalette()
          ->notifyPaletteChanged();
      TApp::instance()->getCurrentLevel()->notifyLevelChange();
    }

    // Reinserisco i vecchi frame che ho sovrascritto
    if (m_setType != DrawingData::INSERT) {
      std::set<TFrameId> framesToModify;
      m_oldData->getFrames(framesToModify);

      bool dummy = true;
      // Incollo i frames sovrascrivendoli
      pasteFramesWithoutUndo(m_oldData, m_sl.getPointer(), framesToModify,
                             DrawingData::OVER_SELECTION, true, dummy);
    }

    // Setto la vecchia paletta al livello
    if (m_oldPalette.getPointer()) {
      TPalette *levelPalette = m_sl->getPalette();
      if (levelPalette) levelPalette->assign(m_oldPalette.getPointer());

      TApp *app = TApp::instance();
      if (app->getCurrentLevel()->getLevel() == m_sl.getPointer())
        app->getPaletteController()
            ->getCurrentLevelPalette()
            ->notifyPaletteChanged();
    }

    // update all icons
    std::vector<TFrameId> sl_fids;
    m_sl.getPointer()->getFids(sl_fids);
    invalidateIcons(m_sl.getPointer(), sl_fids);

    *m_sl->getHookSet() = *m_oldLevelHooks;
  }

  void redo() const override {
    if (!m_sl || m_frames.empty()) return;
    TSelection *selection = TSelection::getCurrent();
    if (selection) selection->selectNone();
    std::set<TFrameId> frames = m_frames;

    bool keepOriginalPalette = m_keepOriginalPalette;
    pasteFramesWithoutUndo(m_newData, m_sl.getPointer(), frames, m_setType,
                           true, keepOriginalPalette, true);
  }

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

  QString getHistoryString() override {
    QString str = QObject::tr("Paste  : Level %1 : Frame ")
                      .arg(QString::fromStdWString(m_sl->getName()));

    std::set<TFrameId>::const_iterator it;
    for (it = m_frames.begin(); it != m_frames.end(); it++) {
      if (it != m_frames.begin()) str += QString(", ");
      str += QString::number((*it).getNumber());
    }

    return str;
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

//=============================================================================
// ClearFramesUndo
//-----------------------------------------------------------------------------

class ClearFramesUndo final : public TUndo {
  TXshSimpleLevel *m_sl;
  std::set<TFrameId> m_frames;
  DrawingData *m_oldData;
  DrawingData *m_newData;

public:
  ClearFramesUndo(TXshSimpleLevel *sl, std::set<TFrameId> &frames,
                  DrawingData *oldData, DrawingData *newData)
      : m_sl(sl), m_frames(frames), m_oldData(oldData), m_newData(newData) {}

  ~ClearFramesUndo() {
    if (m_oldData) m_oldData->releaseData();
    if (m_newData) m_newData->releaseData();
  }

  void pasteFramesFromData(const DrawingData *data) const {
    std::set<TFrameId> frames = m_frames;

    bool dummy = true;
    // Incollo i frames sovrascrivendoli
    pasteFramesWithoutUndo(data, m_sl, frames, DrawingData::OVER_SELECTION,
                           true, dummy);
  }

  void undo() const override { pasteFramesFromData(m_oldData); }

  // OSS.: Non posso usare il metodo "clearFramesWithoutUndo(...)" perche'
  //  genera un NUOVO frame vuoto, perdendo quello precedente e le eventuali
  //  modifiche che ad esso possono essere state fatte successivamente.
  void redo() const override { pasteFramesFromData(m_newData); }

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

  QString getHistoryString() override {
    QString str = QObject::tr("Clear Frames  : Level %1 : Frame ")
                      .arg(QString::fromStdWString(m_sl->getName()));

    std::set<TFrameId>::const_iterator it;
    for (it = m_frames.begin(); it != m_frames.end(); it++) {
      if (it != m_frames.begin()) str += QString(", ");
      str += QString::number((*it).getNumber());
    }

    return str;
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

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

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

class CutFramesUndo final : public TUndo {
  TXshSimpleLevel *m_sl;
  std::set<TFrameId> m_framesCutted;
  std::vector<TFrameId> m_oldFrames;
  DrawingData *m_newData;

public:
  CutFramesUndo(TXshSimpleLevel *sl, std::set<TFrameId> &framesCutted,
                std::vector<TFrameId> &oldFrames)
      : m_sl(sl), m_framesCutted(framesCutted), m_oldFrames(oldFrames) {
    QClipboard *clipboard = QApplication::clipboard();
    QMimeData *data       = cloneData(clipboard->mimeData());
    m_newData             = dynamic_cast<DrawingData *>(data);
    assert(m_newData);
  }

  ~CutFramesUndo() {
    if (m_newData) m_newData->releaseData();
  }

  void undo() const override {
    std::set<TFrameId> frames = m_framesCutted;
    bool dummy                = true;
    pasteFramesWithoutUndo(m_newData, m_sl, frames, DrawingData::OVER_SELECTION,
                           true, dummy);
    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();
  }

  void redo() const override {
    // Prendo il clipboard corrente.
    QClipboard *clipboard  = QApplication::clipboard();
    QMimeData *currentData = cloneData(clipboard->mimeData());

    std::set<TFrameId> frames = m_framesCutted;
    cutFramesWithoutUndo(m_sl, frames);

    // Setto il clipboard corrente
    clipboard->setMimeData(currentData, QClipboard::Clipboard);
  }

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

  QString getHistoryString() override {
    QString str = QObject::tr("Cut Frames  : Level %1 : Frame ")
                      .arg(QString::fromStdWString(m_sl->getName()));

    std::set<TFrameId>::const_iterator it;
    for (it = m_framesCutted.begin(); it != m_framesCutted.end(); it++) {
      if (it != m_framesCutted.begin()) str += QString(", ");
      str += QString::number((*it).getNumber());
    }

    return str;
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

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

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

class DeleteFramesUndo final : public TUndo {
  TXshSimpleLevel *m_sl;
  std::set<TFrameId> m_framesDeleted;
  std::vector<TFrameId> m_oldFrames;
  DrawingData *m_oldData;

public:
  DeleteFramesUndo(TXshSimpleLevel *sl, std::set<TFrameId> &framesCutted,
                   std::vector<TFrameId> &oldFrames, DrawingData *oldData)
      : m_sl(sl)
      , m_framesDeleted(framesCutted)
      , m_oldFrames(oldFrames)
      , m_oldData(oldData) {}

  ~DeleteFramesUndo() {
    if (m_oldData) m_oldData->releaseData();
  }

  void undo() const override {
    std::set<TFrameId> frames = m_framesDeleted;
    bool dummy                = true;
    pasteFramesWithoutUndo(m_oldData, m_sl, frames, DrawingData::OVER_SELECTION,
                           true, dummy);
    TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();
  }

  void redo() const override {
    std::set<TFrameId> frames = m_framesDeleted;
    deleteFramesWithoutUndo(m_sl, frames);
  }

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

  QString getHistoryString() override {
    QString str = QObject::tr("Delete Frames  : Level %1 : Frame ")
                      .arg(QString::fromStdWString(m_sl->getName()));

    std::set<TFrameId>::const_iterator it;
    for (it = m_framesDeleted.begin(); it != m_framesDeleted.end(); it++) {
      if (it != m_framesDeleted.begin()) str += QString(", ");
      str += QString::number((*it).getNumber());
    }

    return str;
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

}  // namespace

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

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

namespace {
//-----------------------------------------------------------------------------

class AddFramesUndo final : public TUndo {
  TXshSimpleLevelP m_level;
  std::set<TFrameId> m_insertedFids;
  std::vector<TFrameId> m_oldFids;
  bool m_updateXSheet;

public:
  AddFramesUndo(const TXshSimpleLevelP &level,
                const std::set<TFrameId> insertedFids,
                std::vector<TFrameId> oldFids)
      : m_level(level), m_insertedFids(insertedFids), m_oldFids(oldFids) {
    m_updateXSheet =
        Preferences::instance()->isSyncLevelRenumberWithXsheetEnabled();
  }

  void undo() const override {
    removeFramesWithoutUndo(m_level, m_insertedFids);
    if (m_updateXSheet) {
      std::vector<TFrameId> newFrames;
      m_level->getFids(newFrames);
      updateXSheet(m_level.getPointer(), newFrames, m_oldFids);
    }
    m_level->renumber(m_oldFids);
    m_level->setDirtyFlag(true);

    TApp *app = TApp::instance();
    app->getCurrentScene()->setDirtyFlag(true);
    app->getCurrentLevel()->notifyLevelChange();
  }

  void redo() const override {
    makeSpaceForFids(m_level.getPointer(), m_insertedFids);

    for (auto const &fid : m_insertedFids) {
      m_level->setFrame(fid, m_level->createEmptyFrame());
      IconGenerator::instance()->invalidate(m_level.getPointer(), fid);
    }
    m_level->setDirtyFlag(true);

    TApp *app = TApp::instance();
    app->getCurrentScene()->setDirtyFlag(true);
    app->getCurrentLevel()->notifyLevelChange();
  }

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

  QString getHistoryString() override {
    QString str = QObject::tr("Add Frames  : Level %1 : Frame ")
                      .arg(QString::fromStdWString(m_level->getName()));

    std::set<TFrameId>::const_iterator it;
    for (it = m_insertedFids.begin(); it != m_insertedFids.end(); it++) {
      if (it != m_insertedFids.begin()) str += QString(", ");
      str += QString::number((*it).getNumber());
    }

    return str;
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

QString getNextLetter(const QString &letter) {
  // 空なら a を返す
  if (letter.isEmpty()) return QString('a');
  // 1文字かつ z または Z ならEmptyを返す
  if (letter == 'z' || letter == 'Z') return QString();
  QByteArray byteArray = letter.toUtf8();
  // それ以外の場合、最後の文字をとにかく１進めて返す
  byteArray.data()[byteArray.size() - 1]++;
  return QString::fromUtf8(byteArray);
};

}  // namespace

//=============================================================================
// AddFrames
//-----------------------------------------------------------------------------

void FilmstripCmd::addFrames(TXshSimpleLevel *sl, int start, int end,
                             int step) {
  if (start < 1 || step < 1 || start > end || !sl || sl->isSubsequence() ||
      sl->isReadOnly())
    return;

  std::vector<TFrameId> oldFids;
  sl->getFids(oldFids);

  TFrameId tmplFid;
  if (!oldFids.empty()) tmplFid = oldFids.front();

  std::set<TFrameId> fidsToInsert;
  int frame = 0;
  for (frame = start; frame <= end; frame += step)
    fidsToInsert.insert(TFrameId(frame, "", tmplFid.getZeroPadding(),
                                 tmplFid.getStartSeqInd()));

  makeSpaceForFids(sl, fidsToInsert);

  for (auto const &fid : fidsToInsert) {
    sl->setFrame(fid, sl->createEmptyFrame());
    IconGenerator::instance()->invalidate(sl, fid);
  }
  sl->setDirtyFlag(true);

  AddFramesUndo *undo = new AddFramesUndo(sl, fidsToInsert, oldFids);
  TUndoManager::manager()->add(undo);

  TApp *app = TApp::instance();
  app->getCurrentScene()->setDirtyFlag(true);
  app->getCurrentLevel()->notifyLevelChange();
}

//=============================================================================
// RenumberUndo
//-----------------------------------------------------------------------------

namespace {

class RenumberUndo final : public TUndo {
  TXshSimpleLevelP m_level;
  std::vector<TFrameId> m_fids;
  std::map<TFrameId, TFrameId> m_mapOldFrameId;
  bool m_updateXSheet = false;

public:
  RenumberUndo(const TXshSimpleLevelP &level, const std::vector<TFrameId> &fids,
               bool forceCallUpdateXSheet = false)
      : m_level(level), m_fids(fids) {
    assert(m_level);
    std::vector<TFrameId> oldFids;
    m_level->getFids(oldFids);
    assert(oldFids.size() == m_fids.size());
    int i;
    for (i = 0; i < m_fids.size(); i++) {
      if (m_fids[i] != oldFids[i]) m_mapOldFrameId[m_fids[i]] = oldFids[i];
    }
    m_updateXSheet =
        Preferences::instance()->isSyncLevelRenumberWithXsheetEnabled() ||
        forceCallUpdateXSheet;
  }
  void renumber(std::vector<TFrameId> fids) const {
    if (m_updateXSheet) {
      std::vector<TFrameId> oldFrames;
      m_level->getFids(oldFrames);
      updateXSheet(m_level.getPointer(), oldFrames, fids);
    }
    m_level->renumber(fids);
    TSelection *selection = TSelection::getCurrent();
    if (selection) selection->selectNone();
    m_level->setDirtyFlag(true);
    TApp::instance()->getCurrentLevel()->notifyLevelChange();
  }
  void undo() const override {
    std::vector<TFrameId> fids;
    m_level->getFids(fids);
    assert(fids.size() == m_fids.size());
    int i;
    for (i = 0; i < fids.size(); i++) {
      if (m_mapOldFrameId.count(fids[i]) > 0) {
        std::map<TFrameId, TFrameId>::const_iterator it;
        it = m_mapOldFrameId.find(fids[i]);
        assert(it != m_mapOldFrameId.end());
        if (it != m_mapOldFrameId.end()) fids[i] = TFrameId(it->second);
      }
    }
    renumber(fids);
  }
  void redo() const override { renumber(m_fids); }
  int getSize() const override {
    return sizeof(*this) + sizeof(TFrameId) * m_fids.size();
  }

  QString getHistoryString() override {
    return QObject::tr("Renumber  : Level %1")
        .arg(QString::fromStdWString(m_level->getName()));
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

}  // namespace

//=============================================================================
// Renumber
//-----------------------------------------------------------------------------

void FilmstripCmd::renumber(
    TXshSimpleLevel *sl,
    const std::vector<std::pair<TFrameId, TFrameId>> &table,
    bool forceCallUpdateXSheet) {
  if (!sl || sl->isSubsequence() || sl->isReadOnly()) return;
  if (table.empty()) return;

  // table:src->dst; check that src is a fid of the level
  std::vector<std::pair<TFrameId, TFrameId>>::const_iterator it;
  for (it = table.begin(); it != table.end(); ++it) {
    TFrameId srcFid = it->first;
    if (!sl->isFid(srcFid)) {
      // todo: error messages
      return;
    }
  }

  // tmp contains all the level fids that are not affected by the renumbering
  std::vector<TFrameId> fids, rfids, oldFrames;
  sl->getFids(fids);
  sl->getFids(oldFrames);
  std::set<TFrameId> tmp;
  for (int i = 0; i < (int)fids.size(); i++) tmp.insert(fids[i]);
  for (it = table.begin(); it != table.end(); ++it) tmp.erase(it->first);

  // fids contain the new numbering of all the level drawings
  // (note: fids can be not ordered)
  for (int i = 0; i < (int)fids.size(); i++) {
    TFrameId srcFid = fids[i];
    for (it = table.begin(); it != table.end() && it->first != srcFid; ++it) {
    }
    if (it != table.end()) {
      // srcFid is affected by the renumbering
      TFrameId tarFid = it->second;
      // make sure that srcFid has not been used. add a letter if this is needed
      if (tmp.count(tarFid) > 0) {
        do {
          tarFid =
              TFrameId(tarFid.getNumber(), getNextLetter(tarFid.getLetter()),
                       tarFid.getZeroPadding(), tarFid.getStartSeqInd());
        } while (!tarFid.getLetter().isEmpty() && tmp.count(tarFid) > 0);
        if (tarFid.getLetter().isEmpty()) {
          // todo: error message
          return;
        }
      }
      tmp.insert(tarFid);
      fids[i] = tarFid;
    }
  }

  TUndoManager::manager()->add(
      new RenumberUndo(sl, fids, forceCallUpdateXSheet));
  if (Preferences::instance()->isSyncLevelRenumberWithXsheetEnabled() ||
      forceCallUpdateXSheet) {
    updateXSheet(sl, oldFrames, fids);
  }
  sl->renumber(fids);
  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
  TApp::instance()->getCurrentLevel()->notifyLevelChange();

  /*
int i;
std::set<TFrameId>::iterator it2;
it2=frames.begin();
std::set<TFrameId> newFrames;
for (i=0; i<frames.size(); i++, it2++)
newFrames.insert(TFrameId(startFrame+(i*stepFrame),it2->getLetter()));
assert(frames.size()==newFrames.size());
frames.swap(newFrames);
*/
}

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

void FilmstripCmd::renumber(TXshSimpleLevel *sl, std::set<TFrameId> &frames,
                            int startFrame, int stepFrame) {
  if (!sl || sl->isSubsequence() || sl->isReadOnly()) return;
  assert(startFrame > 0 && stepFrame > 0);
  if (startFrame <= 0 || stepFrame <= 0 || frames.empty()) return;

  std::vector<TFrameId> fids;
  std::vector<TFrameId> oldFrames;
  sl->getFids(oldFrames);
  sl->getFids(fids);

  std::set<TFrameId> modifiedFids;

  // tmp contiene i frames del livello, meno quelli da renumerare
  std::set<TFrameId> tmp(fids.begin(), fids.end());
  std::set<TFrameId>::const_iterator it;
  for (it = frames.begin(); it != frames.end(); ++it) tmp.erase(*it);

  int frame                         = startFrame;
  std::vector<TFrameId>::iterator j = fids.begin();
  for (it = frames.begin(); it != frames.end(); ++it) {
    TFrameId srcFid(*it);
    TFrameId dstFid(frame, "", srcFid.getZeroPadding(),
                    srcFid.getStartSeqInd());
    frame += stepFrame;
    // faccio il controllo su tmp e non su fids. considera:
    // fids = [1,2,3,4], renumber = [2->3,3->5]
    if (tmp.count(dstFid) > 0) {
      DVGui::error(("can't renumber: frame conflict"));
      return;
    }
    j = std::find(j, fids.end(), srcFid);
    // i frames selezionati fanno parte del livello sl. Quindi:
    assert(j != fids.end());
    assert(srcFid == *j);
    if (j == fids.end()) continue;  // per sicurezza
    int k = std::distance(fids.begin(), j);
    if (srcFid != dstFid) {
      modifiedFids.insert(srcFid);
      modifiedFids.insert(dstFid);
      *j = dstFid;
      ++j;
    }
  }
  TUndoManager::manager()->add(new RenumberUndo(sl, fids));
  if (Preferences::instance()->isSyncLevelRenumberWithXsheetEnabled()) {
    updateXSheet(sl, oldFrames, fids);
  }
  sl->renumber(fids);
  sl->setDirtyFlag(true);
  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
  int i;
  std::set<TFrameId>::iterator it2;
  it2 = frames.begin();
  std::set<TFrameId> newFrames;
  for (i = 0; i < frames.size(); i++, it2++)
    newFrames.insert(TFrameId(startFrame + (i * stepFrame), it2->getLetter(),
                              it2->getZeroPadding(), it2->getStartSeqInd()));
  assert(frames.size() == newFrames.size());
  frames.swap(newFrames);

  TApp::instance()->getCurrentLevel()->notifyLevelChange();
}

//=============================================================================
// copy
//-----------------------------------------------------------------------------

void FilmstripCmd::copy(TXshSimpleLevel *sl, std::set<TFrameId> &frames) {
  if (!sl || frames.empty()) return;
  copyFramesWithoutUndo(sl, frames);
}

//=============================================================================
// paste
//-----------------------------------------------------------------------------

void FilmstripCmd::paste(TXshSimpleLevel *sl, std::set<TFrameId> &frames) {
  if (!sl || sl->isReadOnly() || frames.empty()) return;

  std::vector<TFrameId> oldLevelFrameId;
  sl->getFids(oldLevelFrameId);

  TPaletteP oldPalette;
  if (TPalette *pal = sl->getPalette()) oldPalette = pal->clone();

  QClipboard *clipboard = QApplication::clipboard();
  QMimeData *data       = cloneData(clipboard->mimeData());
  // when pasting the filmstrip frames
  DrawingData *drawingData = dynamic_cast<DrawingData *>(data);
  if (drawingData) {
    if (sl->isSubsequence()) return;

    // keep the chosen option of "Keep Original Palette" and reproduce it in
    // undo
    bool keepOriginalPalette;

    HookSet *oldLevelHooks = new HookSet();
    *oldLevelHooks         = *sl->getHookSet();

    bool isPaste =
        pasteFramesWithoutUndo(drawingData, sl, frames, DrawingData::INSERT,
                               true, keepOriginalPalette);
    if (!isPaste) return;
    TUndoManager::manager()->add(new PasteFramesUndo(
        sl, frames, oldLevelFrameId, oldPalette, DrawingData::INSERT,
        oldLevelHooks, keepOriginalPalette));
  }
  // when pasting the copied part of the image which is selected with the
  // selection tool
  else {
    bool isFrameToInsert =
        (frames.size() == 1) ? !sl->isFid((*frames.begin())) : false;
    TTileSet *tileSet = 0;
    std::map<TFrameId, std::set<int>> indices;
    TUndo *undo      = 0;
    TPaletteP plt    = sl->getPalette()->clone();
    QImage clipImage = clipboard->image();

    FullColorImageData *fullColorData =
        dynamic_cast<FullColorImageData *>(data);

    if ((!clipImage.isNull() || fullColorData) &&
        sl->getType() != OVL_XSHLEVEL) {
      DVGui::error(QObject::tr(
          "Can't paste full raster data on a non full raster level."));
      return;
    }

    TXsheet *xsh           = TApp::instance()->getCurrentXsheet()->getXsheet();
    ToolHandle *toolHandle = TApp::instance()->getCurrentTool();
    if (toolHandle->getTool()->getName() == "T_Selection") {
      TSelection *ts      = toolHandle->getTool()->getSelection();
      RasterSelection *rs = dynamic_cast<RasterSelection *>(ts);
      StrokeSelection *ss = dynamic_cast<StrokeSelection *>(ts);
      if (rs) {
        toolHandle->getTool()->onActivate();
        rs->pasteSelection();
        return;
      }
      if (ss) {
        toolHandle->getTool()->onActivate();
        ss->paste();
        return;
      }
    }

    if (sl->getType() == OVL_XSHLEVEL && !clipImage.isNull()) {
      // This stuff is only if we have a pasted image from outside Tahoma
      if (sl->getResolution().lx < clipImage.width() ||
          sl->getResolution().ly < clipImage.height()) {
        clipImage =
            clipImage.scaled(sl->getResolution().lx, sl->getResolution().ly,
                             Qt::KeepAspectRatio);
      }

      // create variables to go into the Full Color Image data
      std::vector<TRectD> rects;
      const std::vector<TStroke> strokes;
      const std::vector<TStroke> originalStrokes;
      TAffine aff;
      TRasterP ras = rasterFromQImage(clipImage);
      rects.push_back(TRectD(0.0 - clipImage.width() / 2,
                             0.0 - clipImage.height() / 2,
                             clipImage.width() / 2, clipImage.height() / 2));
      FullColorImageData *qimageData = new FullColorImageData();

      TDimension dim = sl->getResolution();

      qimageData->setData(ras, plt, 120.0, 120.0, dim, rects, strokes,
                          originalStrokes, aff);
      data = qimageData;
      // end of pasted from outside Tahoma stuff
      // rasterImageData holds all the info either way now.
    }

    bool isPaste = pasteAreasWithoutUndo(data, sl, frames, &tileSet, indices);
    RasterImageData *rasterImageData = dynamic_cast<RasterImageData *>(data);
    StrokesData *strokesData         = dynamic_cast<StrokesData *>(data);

    if (rasterImageData && tileSet)
      undo = new PasteRasterAreasUndo(sl, frames, tileSet, rasterImageData,
                                      plt.getPointer(), isFrameToInsert);
    if (strokesData && tileSet) {
      TImageP img      = sl->getFrame(*frames.begin(), false);
      TRasterImageP ri = img;
      TToonzImageP ti  = img;
      assert(img);
      if (ti)
        undo = new PasteRasterAreasUndo(sl, frames, tileSet,
                                        strokesData->toToonzImageData(ti),
                                        plt.getPointer(), isFrameToInsert);
      else if (ri) {
        double dpix, dpiy;
        ri->getDpi(dpix, dpiy);
        if (dpix == 0 || dpiy == 0) {
          TPointD dpi = sl->getScene()->getCurrentCamera()->getDpi();
          dpix        = dpi.x;
          dpiy        = dpi.y;
          ri->setDpi(dpix, dpiy);
        }
        undo = new PasteRasterAreasUndo(sl, frames, tileSet,
                                        strokesData->toFullColorImageData(ri),
                                        plt.getPointer(), isFrameToInsert);
      }
    }
    if (strokesData && !indices.empty())
      undo = new PasteVectorAreasUndo(sl, frames, indices, strokesData,
                                      plt.getPointer(), isFrameToInsert);
    if (rasterImageData && !indices.empty())
      undo = new PasteVectorAreasUndo(
          sl, frames, indices, rasterImageData->toStrokesData(sl->getScene()),
          plt.getPointer(), isFrameToInsert);
    if (!isPaste) return;
    if (undo) TUndoManager::manager()->add(undo);
  }
}

//=============================================================================
// merge
//-----------------------------------------------------------------------------

void FilmstripCmd::merge(TXshSimpleLevel *sl, std::set<TFrameId> &frames) {
  if (!sl || sl->isReadOnly() || sl->isSubsequence()) return;

  std::vector<TFrameId> oldLevelFrameId;
  sl->getFids(oldLevelFrameId);
  TPaletteP oldPalette = sl->getPalette()->clone();
  std::set<TFrameId> frameIdToChange;

  QClipboard *clipboard = QApplication::clipboard();
  if (const DrawingData *drawingData =
          dynamic_cast<const DrawingData *>(clipboard->mimeData())) {
    drawingData->getFrames(frameIdToChange);
    DrawingData *data = new DrawingData();
    data->setLevelFrames(sl, frameIdToChange);
    HookSet *oldLevelHooks = new HookSet();
    *oldLevelHooks         = *sl->getHookSet();

    bool keepOriginalPalette = true;

    bool isPaste = pasteFramesWithoutUndo(drawingData, sl, frames,
                                          DrawingData::OVER_FRAMEID, true,
                                          keepOriginalPalette);
    if (!isPaste) return;
    TUndoManager::manager()->add(new PasteFramesUndo(
        sl, frames, oldLevelFrameId, oldPalette, DrawingData::OVER_FRAMEID,
        oldLevelHooks, keepOriginalPalette, data));
  }
}

//=============================================================================
// pasteInto
//-----------------------------------------------------------------------------

void FilmstripCmd::pasteInto(TXshSimpleLevel *sl, std::set<TFrameId> &frames) {
  if (!sl || sl->isReadOnly() || sl->isSubsequence()) return;

  std::vector<TFrameId> oldLevelFrameId;
  sl->getFids(oldLevelFrameId);

  TPaletteP oldPalette;
  if (TPalette *pal = sl->getPalette()) oldPalette = pal->clone();

  QClipboard *clipboard = QApplication::clipboard();
  if (const DrawingData *drawingData =
          dynamic_cast<const DrawingData *>(clipboard->mimeData())) {
    DrawingData *data = new DrawingData();
    data->setLevelFrames(sl, frames);

    HookSet *oldLevelHooks = new HookSet();
    *oldLevelHooks         = *sl->getHookSet();

    bool keepOriginalPalette = true;
    bool isPaste             = pasteFramesWithoutUndo(drawingData, sl, frames,
                                          DrawingData::OVER_SELECTION, true,
                                          keepOriginalPalette);
    if (!isPaste) return;

    TUndoManager::manager()->add(new PasteFramesUndo(
        sl, frames, oldLevelFrameId, oldPalette, DrawingData::OVER_SELECTION,
        oldLevelHooks, keepOriginalPalette, data));
  }
}

//=============================================================================
// cut
//-----------------------------------------------------------------------------

void FilmstripCmd::cut(TXshSimpleLevel *sl, std::set<TFrameId> &frames) {
  if (!sl || frames.empty() || sl->isSubsequence() || sl->isReadOnly()) return;

  std::set<TFrameId> framesToCut = frames;
  std::vector<TFrameId> oldFrames;
  sl->getFids(oldFrames);
  cutFramesWithoutUndo(sl, frames);
  TUndoManager::manager()->add(new CutFramesUndo(sl, framesToCut, oldFrames));
}

//=============================================================================
// delete
//-----------------------------------------------------------------------------

void FilmstripCmd::deleteFrames(TXshSimpleLevel *sl,
                                std::set<TFrameId> &frames) {
  // make sure there are actual drawing frames to deal with.
  if (!sl || frames.empty() || sl->isSubsequence() || sl->isReadOnly()) return;

  // still checking that the level is editable.
  if (sl->isReadOnly()) {
    std::set<TFrameId> editableFrames = sl->getEditableRange();
    if (editableFrames.empty()) return;

    // Browse all the frames and return if some frames are not editable
    std::set<TFrameId>::const_iterator it;
    for (it = frames.begin(); it != frames.end(); ++it) {
      TFrameId frameId = *it;
      if (editableFrames.count(frameId) == 0) return;
    }
  }

  std::set<TFrameId> framesToDelete = frames;
  std::vector<TFrameId> oldFrames;
  sl->getFids(oldFrames);

  // set up the drawing data that will be necessary to undo the delete.
  HookSet *levelHooks = sl->getHookSet();
  std::map<TFrameId, QString> imageSet = deleteFramesWithoutUndo(sl, frames);
  DrawingData *oldData = new DrawingData();
  oldData->setFrames(imageSet, sl, *levelHooks);

  TUndoManager::manager()->add(
      new DeleteFramesUndo(sl, framesToDelete, oldFrames, oldData));
}

//=============================================================================
// clear
//-----------------------------------------------------------------------------

void FilmstripCmd::clear(TXshSimpleLevel *sl, std::set<TFrameId> &frames) {
  if (!sl || frames.empty()) return;

  if (sl->isReadOnly()) {
    std::set<TFrameId> editableFrames = sl->getEditableRange();
    if (editableFrames.empty()) return;

    // Browser all the frames and return if some frames are not editable
    std::set<TFrameId>::const_iterator it;
    for (it = frames.begin(); it != frames.end(); ++it) {
      TFrameId frameId = *it;
      if (editableFrames.count(frameId) == 0) return;
    }
  }

  HookSet *levelHooks          = sl->getHookSet();
  std::set<TFrameId> oldFrames = frames;
  std::map<TFrameId, QString> clearedFrames =
      clearFramesWithoutUndo(sl, frames);
  DrawingData *oldData = new DrawingData();
  oldData->setFrames(clearedFrames, sl, *levelHooks);
  DrawingData *newData = new DrawingData();
  newData->setLevelFrames(sl, frames);
  frames.clear();
  TUndoManager::manager()->add(
      new ClearFramesUndo(sl, oldFrames, oldData, newData));
}

//-----------------------------------------------------------------------------
namespace {
//-----------------------------------------------------------------------------

void insertEmptyFilmstripFrames(const TXshSimpleLevelP &sl,
                                const std::set<TFrameId> &frames) {
  if (!sl || frames.empty()) return;
  makeSpaceForFids(sl.getPointer(), frames);
  std::set<TFrameId>::const_iterator it;
  for (it = frames.begin(); it != frames.end(); ++it)
    sl->setFrame(*it, sl->createEmptyFrame());
  invalidateIcons(sl.getPointer(), frames);
  sl->setDirtyFlag(true);
  //  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
  TApp::instance()->getCurrentLevel()->notifyLevelChange();
}

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

class UndoInsertEmptyFrames final : public TUndo {
  TXshSimpleLevelP m_level;
  std::vector<TFrameId> m_oldFrames;
  std::set<TFrameId> m_frames;
  bool m_updateXSheet;

public:
  UndoInsertEmptyFrames(const TXshSimpleLevelP &level,
                        std::set<TFrameId> frames,
                        std::vector<TFrameId> oldFrames)
      : m_level(level), m_frames(frames), m_oldFrames(oldFrames) {
    if (m_level->getType() == TZP_XSHLEVEL) {
      std::set<TFrameId>::iterator it;
      for (it = m_frames.begin(); it != m_frames.end(); it++) {
        TToonzImageP img = m_level->getFrame(*it, true);
        // TImageCache::instance()->add("UndoInsertEmptyFrames"+QString::number((UINT)this),
        // img);
        TImageCache::instance()->add(
            "UndoInsertEmptyFrames" + QString::number((uintptr_t) this), img);
      }
    }
    m_updateXSheet =
        Preferences::instance()->isSyncLevelRenumberWithXsheetEnabled();
  }

  ~UndoInsertEmptyFrames() {
    // TImageCache::instance()->remove("UndoInsertEmptyFrames"+QString::number((UINT)this));
    TImageCache::instance()->remove("UndoInsertEmptyFrames" +
                                    QString::number((uintptr_t) this));
  }

  void undo() const override {
    removeFramesWithoutUndo(m_level, m_frames);
    assert(m_oldFrames.size() == m_level->getFrameCount());
    if (m_updateXSheet) {
      std::vector<TFrameId> newFrames;
      m_level->getFids(newFrames);
      updateXSheet(m_level.getPointer(), newFrames, m_oldFrames);
    }
    m_level->renumber(m_oldFrames);
    m_level->setDirtyFlag(true);
    TApp::instance()->getCurrentLevel()->notifyLevelChange();
  }

  void redo() const override {
    if (!m_level || m_frames.empty()) return;
    if (m_level->getType() == PLI_XSHLEVEL)
      FilmstripCmd::insert(m_level.getPointer(), m_frames, false);
    else if (m_level->getType() == TZP_XSHLEVEL) {
      makeSpaceForFids(m_level.getPointer(), m_frames);
      std::set<TFrameId>::const_iterator it;
      // TToonzImageP image =
      // (TToonzImageP)TImageCache::instance()->get("UndoInsertEmptyFrames"+QString::number((UINT)this),
      // true);
      TToonzImageP image = (TToonzImageP)TImageCache::instance()->get(
          "UndoInsertEmptyFrames" + QString::number((uintptr_t) this), true);
      if (!image) return;
      for (it = m_frames.begin(); it != m_frames.end(); ++it)
        m_level->setFrame(*it, image);
      invalidateIcons(m_level.getPointer(), m_frames);
      m_level->setDirtyFlag(true);
      TApp::instance()->getCurrentLevel()->notifyLevelChange();
    }
  }

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

  QString getHistoryString() override {
    return QObject::tr("Insert  : Level %1")
        .arg(QString::fromStdWString(m_level->getName()));
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

}  // namespace

//=============================================================================
// insert
//-----------------------------------------------------------------------------

void FilmstripCmd::insert(TXshSimpleLevel *sl, const std::set<TFrameId> &frames,
                          bool withUndo) {
  if (frames.empty() || !sl || sl->isSubsequence() || sl->isReadOnly()) return;
  std::vector<TFrameId> oldFrames;
  if (withUndo) sl->getFids(oldFrames);

  insertEmptyFilmstripFrames(sl, frames);
  if (withUndo)
    TUndoManager::manager()->add(
        new UndoInsertEmptyFrames(sl, frames, oldFrames));
  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
}

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

//-----------------------------------------------------------------------------
namespace {
//-----------------------------------------------------------------------------

void performReverse(const TXshSimpleLevelP &sl,
                    const std::set<TFrameId> &frames) {
  if (!sl || frames.empty()) return;

  std::vector<TFrameId> fids;
  std::vector<TFrameId> oldFrames;
  sl->getFids(oldFrames);
  sl->getFids(fids);
  int i = 0, j = (int)fids.size() - 1;
  for (;;) {
    while (i < j && frames.count(fids[i]) == 0) i++;
    while (i < j && frames.count(fids[j]) == 0) j--;
    if (i >= j) break;
    std::swap(fids[i], fids[j]);
    i++;
    j--;
  }
  if (Preferences::instance()->isSyncLevelRenumberWithXsheetEnabled()) {
    updateXSheet(sl.getPointer(), oldFrames, fids);
  }
  sl->renumber(fids);
  sl->setDirtyFlag(true);
  //  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
  TApp::instance()->getCurrentLevel()->notifyLevelChange();
}

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

class FilmstripReverseUndo final : public TUndo {
  TXshSimpleLevelP m_level;
  std::set<TFrameId> m_frames;

public:
  FilmstripReverseUndo(TXshSimpleLevelP level, std::set<TFrameId> frames)
      : m_level(level), m_frames(frames) {}

  void undo() const override { performReverse(m_level, m_frames); }
  void redo() const override { performReverse(m_level, m_frames); }
  int getSize() const override { return sizeof *this; }

  QString getHistoryString() override {
    return QObject::tr("Reverse  : Level %1")
        .arg(QString::fromStdWString(m_level->getName()));
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

}  // namespace

//=============================================================================
// reverse
//-----------------------------------------------------------------------------

void FilmstripCmd::reverse(TXshSimpleLevel *sl, std::set<TFrameId> &frames) {
  if (!sl || sl->isSubsequence() || sl->isReadOnly()) return;
  performReverse(sl, frames);
  TUndoManager::manager()->add(new FilmstripReverseUndo(sl, frames));
  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
}

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

//-----------------------------------------------------------------------------
namespace {
//-----------------------------------------------------------------------------

void performSwing(const TXshSimpleLevelP &sl,
                  const std::set<TFrameId> &frames) {
  if (!sl) return;
  int count = frames.size() - 1;
  if (count <= 0) return;  // niente swing con un solo frame
  TFrameId lastFid     = *frames.rbegin();
  TFrameId insertPoint = lastFid + 1;
  std::set<TFrameId> framesToInsert;
  int i;
  for (i = 0; i < count; i++) framesToInsert.insert(insertPoint + i);

  std::vector<TImage *> clonedImages;
  std::set<TFrameId>::const_reverse_iterator k;
  k = frames.rbegin();
  for (++k; k != frames.rend(); ++k) {
    TImageP img = sl->getFrame(*k, false);
    clonedImages.push_back(img ? img->cloneImage() : 0);
  }

  makeSpaceForFids(sl.getPointer(), framesToInsert);
  assert(count == (int)clonedImages.size());
  for (i = 0; i < count && (int)i < (int)clonedImages.size(); i++) {
    TImage *img = clonedImages[i];
    if (img) sl->setFrame(insertPoint + i, img);
  }
  invalidateIcons(sl.getPointer(), framesToInsert);
  sl->setDirtyFlag(true);
  //  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
  TApp::instance()->getCurrentLevel()->notifyLevelChange();
}

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

class FilmstripSwingUndo final : public TUndo {
  TXshSimpleLevelP m_level;
  std::set<TFrameId> m_frames;
  std::set<TFrameId> m_newFrames;

public:
  FilmstripSwingUndo(const TXshSimpleLevelP &level,
                     const std::set<TFrameId> &frames)
      : m_level(level), m_frames(frames) {
    int count = frames.size() - 1;
    if (count <= 0) return;  // niente swing con un solo frame
    TFrameId lastFid     = *frames.rbegin();
    TFrameId insertPoint = lastFid + 1;
    std::set<TFrameId> framesToInsert;
    int i;
    for (i = 0; i < count; i++) m_newFrames.insert(insertPoint + i);
  }

  void undo() const override {
    TSelection *selection = TSelection::getCurrent();
    if (selection) selection->selectNone();
    removeFramesWithoutUndo(m_level, m_newFrames);
  }
  void redo() const override {
    TSelection *selection = TSelection::getCurrent();
    if (selection) selection->selectNone();
    performSwing(m_level, m_frames);
  }
  int getSize() const override { return sizeof *this; }

  QString getHistoryString() override {
    return QObject::tr("Swing  : Level %1")
        .arg(QString::fromStdWString(m_level->getName()));
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

}  // namespace

//=============================================================================
// swing
//-----------------------------------------------------------------------------

void FilmstripCmd::swing(TXshSimpleLevel *sl, std::set<TFrameId> &frames) {
  if (!sl || sl->isSubsequence() || sl->isReadOnly()) return;
  performSwing(sl, frames);
  TUndoManager::manager()->add(new FilmstripSwingUndo(sl, frames));
  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
}

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

//-----------------------------------------------------------------------------
namespace {
//-----------------------------------------------------------------------------

void stepFilmstripFrames(const TXshSimpleLevelP &sl,
                         const std::set<TFrameId> &frames, int step = 2) {
  if (!sl || frames.empty() || step < 2) return;
  std::vector<TFrameId> fids;
  std::set<TFrameId> changedFids;
  std::vector<int> insertIndices;
  std::vector<TFrameId> oldFrames;
  sl->getFids(oldFrames);
  sl->getFids(fids);
  int i, offset = 0;
  for (i = 0; i < (int)fids.size(); i++) {
    bool frameToStep = (frames.count(fids[i]) > 0);
    if (offset > 0) {
      changedFids.insert(fids[i]);
      fids[i] = fids[i] + offset;
      changedFids.insert(fids[i]);
    }
    if (frameToStep) {
      insertIndices.push_back(i);
      offset += step - 1;
    }
  }
  if (Preferences::instance()->isSyncLevelRenumberWithXsheetEnabled()) {
    updateXSheet(sl.getPointer(), oldFrames, fids);
  }
  sl->renumber(fids);
  for (i = 0; i < (int)insertIndices.size(); i++) {
    int j        = insertIndices[i];
    TFrameId fid = fids[j];
    TImageP img  = sl->getFrame(fid, false);
    if (img) {
      int h;
      for (h = 1; h < step; h++) {
        sl->setFrame(fid + h, img->cloneImage());
        changedFids.insert(fid + h);
      }
    }
  }
  invalidateIcons(sl.getPointer(), changedFids);
  sl->setDirtyFlag(true);
  TApp::instance()->getCurrentLevel()->notifyLevelChange();
}

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

class StepFilmstripUndo final : public TUndo {
  TXshSimpleLevelP m_level;
  std::set<TFrameId> m_insertedFrames;
  std::set<TFrameId> m_frames;
  std::vector<TFrameId> m_oldFrames;
  int m_step;
  bool m_updateXSheet;

public:
  StepFilmstripUndo(const TXshSimpleLevelP &level,
                    const std::set<TFrameId> &frames, int step)
      : m_level(level), m_frames(frames), m_step(step) {
    assert(m_level);
    m_level->getFids(m_oldFrames);
    int d = 0;
    std::set<TFrameId>::const_iterator it;
    for (it = frames.begin(); it != frames.end(); ++it)
      for (int j = 1; j < step; j++) m_insertedFrames.insert(*it + (++d));
    m_updateXSheet =
        Preferences::instance()->isSyncLevelRenumberWithXsheetEnabled();
  }

  void undo() const override {
    removeFramesWithoutUndo(m_level, m_insertedFrames);
    std::set<TFrameId>::const_iterator it = m_frames.begin();
    if (m_updateXSheet) {
      std::vector<TFrameId> newFrames;
      m_level->getFids(newFrames);
      updateXSheet(m_level.getPointer(), newFrames, m_oldFrames);
    }
    m_level->renumber(m_oldFrames);
    TSelection *selection = TSelection::getCurrent();
    if (selection) selection->selectNone();
    m_level->setDirtyFlag(true);
    TApp::instance()->getCurrentLevel()->notifyLevelChange();
  }
  void redo() const override {
    TSelection *selection = TSelection::getCurrent();
    if (selection) selection->selectNone();
    stepFilmstripFrames(m_level, m_frames, m_step);
  }
  int getSize() const override { return sizeof *this; }

  QString getHistoryString() override {
    return QObject::tr("Step %1  : Level %2")
        .arg(QString::number(m_step))
        .arg(QString::fromStdWString(m_level->getName()));
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

}  // namespace

//=============================================================================
// step
//-----------------------------------------------------------------------------

void FilmstripCmd::step(TXshSimpleLevel *sl, std::set<TFrameId> &frames,
                        int step) {
  if (!sl || sl->isSubsequence() || sl->isReadOnly()) return;
  QApplication::setOverrideCursor(Qt::WaitCursor);
  StepFilmstripUndo *undo = new StepFilmstripUndo(sl, frames, step);
  stepFilmstripFrames(sl, frames, step);
  TUndoManager::manager()->add(undo);
  frames.clear();
  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
  QApplication::restoreOverrideCursor();
}

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

//-----------------------------------------------------------------------------
namespace {
//-----------------------------------------------------------------------------

std::map<TFrameId, QString> eachFilmstripFrames(
    const TXshSimpleLevelP &sl, const std::set<TFrameId> &frames, int each) {
  if (frames.empty() || !sl || each < 2) return std::map<TFrameId, QString>();
  std::vector<TFrameId> framesToDelete;
  std::set<TFrameId>::const_iterator it;
  int k = 0;
  for (it = frames.begin(); it != frames.end(); ++it, ++k)
    if ((k % each) > 0) framesToDelete.push_back(*it);
  int i = 0;
  std::vector<TFrameId>::reverse_iterator fit;
  std::map<TFrameId, QString> cutFrames;

  for (fit = framesToDelete.rbegin(); fit != framesToDelete.rend(); ++fit) {
    TImageP img = sl->getFrame(*fit, false);
    if (img) {
      // QString id =
      // "eachFrames"+QString::number((UINT)sl.getPointer())+"-"+QString::number(fit->getNumber());
      QString id = "eachFrames" + QString::number((uintptr_t)sl.getPointer()) +
                   "-" + QString::number(fit->getNumber());
      TImageCache::instance()->add(id, img);

      cutFrames[*fit] = id;
    }
    sl->eraseFrame(*fit);  // toglie da cache?
    IconGenerator::instance()->remove(sl.getPointer(), *fit);
  }

  TApp::instance()->getCurrentLevel()->notifyLevelChange();
  return cutFrames;
}

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

class EachFilmstripUndo final : public TUndo {
  TXshSimpleLevelP m_level;
  std::set<TFrameId> m_frames;
  std::map<TFrameId, QString> m_cutFrames;
  int m_each;

public:
  EachFilmstripUndo(const TXshSimpleLevelP &level, int each,
                    const std::set<TFrameId> &frames,
                    std::map<TFrameId, QString> deletedFrames)
      : m_level(level)
      , m_cutFrames(deletedFrames)
      , m_each(each)
      , m_frames(frames) {}
  ~EachFilmstripUndo() {
    std::map<TFrameId, QString>::iterator it = m_cutFrames.begin();
    for (; it != m_cutFrames.end(); ++it)
      TImageCache::instance()->remove(it->second);
  }
  void undo() const override {
    TSelection *selection = TSelection::getCurrent();
    if (selection) selection->selectNone();
    insertNotEmptyframes(m_level, m_cutFrames);
  }
  void redo() const override {
    TSelection *selection = TSelection::getCurrent();
    if (selection) selection->selectNone();
    eachFilmstripFrames(m_level, m_frames, m_each);
  }
  int getSize() const override { return sizeof *this; }

  QString getHistoryString() override {
    return QObject::tr("Each %1  : Level %2")
        .arg(QString::number(m_each))
        .arg(QString::fromStdWString(m_level->getName()));
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

}  // namespace

//=============================================================================
// each
//-----------------------------------------------------------------------------

void FilmstripCmd::each(TXshSimpleLevel *sl, std::set<TFrameId> &frames,
                        int each) {
  if (!sl || sl->isSubsequence() || sl->isReadOnly()) return;
  std::map<TFrameId, QString> deletedFrames =
      eachFilmstripFrames(sl, frames, each);
  TUndoManager::manager()->add(
      new EachFilmstripUndo(sl, each, frames, deletedFrames));
  frames.clear();
  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
}

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

//-----------------------------------------------------------------------------
namespace {
//-----------------------------------------------------------------------------

class UndoDuplicateDrawing final : public TUndo {
  TXshSimpleLevelP m_level;
  std::set<TFrameId> m_frameInserted;
  std::vector<TFrameId> m_oldFrames;
  std::set<TFrameId> m_framesForRedo;
  bool m_updateXSheet;

public:
  UndoDuplicateDrawing(const TXshSimpleLevelP &level,
                       const std::vector<TFrameId> oldFrames,
                       std::set<TFrameId> frameInserted,
                       std::set<TFrameId> framesForRedo)
      : m_level(level)
      , m_oldFrames(oldFrames)
      , m_frameInserted(frameInserted)
      , m_framesForRedo(framesForRedo) {
    m_updateXSheet =
        Preferences::instance()->isSyncLevelRenumberWithXsheetEnabled();
  }

  void undo() const override {
    assert(m_level);
    removeFramesWithoutUndo(m_level, m_frameInserted);
    if (m_updateXSheet) {
      std::vector<TFrameId> newFrames;
      m_level->getFids(newFrames);
      updateXSheet(m_level.getPointer(), newFrames, m_oldFrames);
    }
    m_level->renumber(m_oldFrames);
    m_level->setDirtyFlag(true);
    TApp::instance()->getCurrentLevel()->notifyLevelChange();
  }
  void redo() const override {
    std::set<TFrameId> framesForRedo = m_framesForRedo;
    FilmstripCmd::duplicate(m_level.getPointer(), framesForRedo, false);
  }
  int getSize() const override { return sizeof(*this); }

  QString getHistoryString() override {
    return QObject::tr("Duplicate  : Level %1")
        .arg(QString::fromStdWString(m_level->getName()));
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

}  // namespace

//=============================================================================
// duplicate
//-----------------------------------------------------------------------------

void FilmstripCmd::duplicateFrameWithoutUndo(TXshSimpleLevel *sl,
                                             TFrameId srcFrame,
                                             TFrameId targetFrame) {
  if (srcFrame.isNoFrame() || targetFrame.isNoFrame()) return;
  if (srcFrame.isEmptyFrame()) return;

  std::set<TFrameId> frames;

  frames.insert(srcFrame);
  DrawingData *data = new DrawingData();
  data->setLevelFrames(sl, frames);

  frames.clear();
  frames.insert(targetFrame);

  bool keepOriginalPalette = true;

  pasteFramesWithoutUndo(data, sl, frames, DrawingData::OVER_SELECTION, true,
                         keepOriginalPalette);
}

void FilmstripCmd::duplicate(TXshSimpleLevel *sl, std::set<TFrameId> &frames,
                             bool withUndo) {
  if (frames.empty() || !sl || sl->isSubsequence() || sl->isReadOnly()) return;

  TFrameId insertPoint = (*frames.rbegin()) + 1;

  std::map<TFrameId, QString> framesToInsert;
  std::set<TFrameId> newFrames;
  int i = 0;
  for (auto const &fid : frames) {
    TImageP img      = sl->getFrame(fid, false);
    TImageP imgClone = (img) ? img->cloneImage() : 0;
    QString id       = "dupFrames" + QString::number((uintptr_t)sl) + "-" +
                 QString::number(fid.getNumber());
    TImageCache::instance()->add(id, imgClone);
    framesToInsert[insertPoint + i] = id;
    newFrames.insert(insertPoint + i);
    i++;
  }
  std::vector<TFrameId> oldFrames;
  sl->getFids(oldFrames);
  insertNotEmptyframes(sl, framesToInsert);
  if (withUndo)
    TUndoManager::manager()->add(
        new UndoDuplicateDrawing(sl, oldFrames, newFrames, frames));
  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
}

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

//-----------------------------------------------------------------------------
namespace {
//-----------------------------------------------------------------------------

void moveToSceneFrames(TXshLevel *level, const std::set<TFrameId> &frames) {
  if (frames.empty() || !level) return;

  TXsheetHandle *xh = TApp::instance()->getCurrentXsheet();
  TXsheet *xsh      = xh->getXsheet();
  int row           = 0;
  int col           = xsh->getFirstFreeColumnIndex();
  std::set<TFrameId>::const_iterator it;
  if (level->getPaletteLevel()) {
    TXshPaletteColumn *column = new TXshPaletteColumn;
    xsh->insertColumn(col, column);
  }
  for (it = frames.begin(); it != frames.end(); ++it) {
    xsh->setCell(row, col, TXshCell(level, *it));
    ++row;
  }
  xh->notifyXsheetChanged();
}

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

class MoveLevelToSceneUndo final : public TUndo {
  std::wstring m_levelName;
  int m_col;
  std::set<TFrameId> m_fids;

public:
  MoveLevelToSceneUndo(std::wstring levelName, int col, std::set<TFrameId> fids)
      : m_levelName(levelName), m_col(col), m_fids(fids) {}

  void undo() const override {
    TApp *app         = TApp::instance();
    TXsheet *xsh      = app->getCurrentXsheet()->getXsheet();
    ToonzScene *scene = app->getCurrentScene()->getScene();
    TXshLevel *xl     = scene->getLevelSet()->getLevel(m_levelName);
    if (xl->getPaletteLevel()) xsh->removeColumn(m_col);
    xsh->clearCells(0, m_col, m_fids.size());
    app->getCurrentXsheet()->notifyXsheetChanged();
  }
  void redo() const override {
    TApp *app         = TApp::instance();
    ToonzScene *scene = app->getCurrentScene()->getScene();
    TXshLevel *xl     = scene->getLevelSet()->getLevel(m_levelName);
    if (!xl) return;
    moveToSceneFrames(xl, m_fids);
  }
  int getSize() const override { return sizeof *this; }

  QString getHistoryString() override {
    return QObject::tr("Move Level to Scene  : Level %1")
        .arg(QString::fromStdWString(m_levelName));
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

}  // namespace

//=============================================================================
// moveToScene
//-----------------------------------------------------------------------------

void FilmstripCmd::moveToScene(TXshLevel *sl, std::set<TFrameId> &frames) {
  if (frames.empty() || !sl) return;

  TXsheetHandle *xh = TApp::instance()->getCurrentXsheet();
  TXsheet *xsh      = xh->getXsheet();
  int row           = 0;
  int col           = xsh->getFirstFreeColumnIndex();
  std::set<TFrameId>::const_iterator it;
  for (it = frames.begin(); it != frames.end(); ++it) {
    xsh->setCell(row, col, TXshCell(sl, *it));
    ++row;
  }
  xh->notifyXsheetChanged();
  TUndoManager::manager()->add(
      new MoveLevelToSceneUndo(sl->getName(), col, frames));
  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
}

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

void FilmstripCmd::moveToScene(TXshSimpleLevel *sl) {
  std::vector<TFrameId> fids;
  sl->getFids(fids);
  std::set<TFrameId> fidsSet(fids.begin(), fids.end());
  moveToScene(sl, fidsSet);
}

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

void FilmstripCmd::moveToScene(TXshPaletteLevel *pl) {
  if (!pl) return;
  std::set<TFrameId> fidsSet;
  fidsSet.insert(TFrameId(1));

  TXsheetHandle *xh         = TApp::instance()->getCurrentXsheet();
  TXsheet *xsh              = xh->getXsheet();
  int row                   = 0;
  int col                   = xsh->getFirstFreeColumnIndex();
  TXshPaletteColumn *column = new TXshPaletteColumn;
  xsh->insertColumn(col, column);
  std::set<TFrameId>::const_iterator it;
  for (it = fidsSet.begin(); it != fidsSet.end(); ++it) {
    xsh->setCell(row, col, TXshCell(pl, *it));
    ++row;
  }
  xh->notifyXsheetChanged();
  TUndoManager::manager()->add(
      new MoveLevelToSceneUndo(pl->getName(), col, fidsSet));
  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
}

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

void FilmstripCmd::moveToScene(TXshSoundLevel *sl) {
  std::vector<TFrameId> fids;
  sl->getFids(fids);
  std::set<TFrameId> fidsSet(fids.begin(), fids.end());
  moveToScene(sl, fidsSet);
}

//=============================================================================
// UndoInbetween
//-----------------------------------------------------------------------------

namespace {

class UndoInbetween final : public TUndo {
  TXshSimpleLevelP m_level;
  std::vector<TFrameId> m_fids;
  std::vector<TVectorImageP> m_images;
  FilmstripCmd::InbetweenInterpolation m_interpolation;

public:
  UndoInbetween(TXshSimpleLevel *xl, std::vector<TFrameId> fids,
                FilmstripCmd::InbetweenInterpolation interpolation)
      : m_level(xl), m_fids(fids), m_interpolation(interpolation) {
    std::vector<TFrameId>::iterator it = fids.begin();
    // mi salvo tutte le immagine
    for (; it != fids.end(); ++it)
      m_images.push_back(m_level->getFrame(
          *it, false));  // non si fa clone perche' il livello subito dopo
                         // rilascia queste immagini a causa dell'inbetweener
  }

  void undo() const override {
    UINT levelSize = m_fids.size() - 1;
    for (UINT count = 1; count != levelSize; count++) {
      TVectorImageP vImage = m_images[count];
      m_level->setFrame(m_fids[count], vImage);
      IconGenerator::instance()->invalidate(m_level.getPointer(),
                                            m_fids[count]);
    }

    TApp::instance()->getCurrentLevel()->notifyLevelChange();
  }

  void redo() const override {
    TFrameId fid0 = *m_fids.begin();
    TFrameId fid1 = *(--m_fids.end());
    FilmstripCmd::inbetweenWithoutUndo(m_level.getPointer(), fid0, fid1,
                                       m_interpolation);
  }

  int getSize() const override {
    assert(!m_images.empty());
    return m_images.size() * m_images.front()->getStrokeCount() * 100;
  }

  QString getHistoryString() override {
    QString str = QObject::tr("Inbetween  : Level %1,  ")
                      .arg(QString::fromStdWString(m_level->getName()));
    switch (m_interpolation) {
    case FilmstripCmd::II_Linear:
      str += QString("Linear Interpolation");
      break;
    case FilmstripCmd::II_EaseIn:
      str += QString("Ease In Interpolation");
      break;
    case FilmstripCmd::II_EaseOut:
      str += QString("Ease Out Interpolation");
      break;
    case FilmstripCmd::II_EaseInOut:
      str += QString("Ease In-Out Interpolation");
      break;
    }
    return str;
  }
  int getHistoryType() override { return HistoryType::FilmStrip; }
};

}  // namespace

//=============================================================================
// inbetween
//-----------------------------------------------------------------------------

void FilmstripCmd::inbetweenWithoutUndo(
    TXshSimpleLevel *sl, const TFrameId &fid0, const TFrameId &fid1,
    FilmstripCmd::InbetweenInterpolation interpolation) {
  if (!sl) return;
  std::vector<TFrameId> fids;
  sl->getFids(fids);
  std::vector<TFrameId>::iterator it;
  it = std::find(fids.begin(), fids.end(), fid0);
  if (it == fids.end()) return;
  int ia = std::distance(fids.begin(), it);
  it     = std::find(fids.begin(), fids.end(), fid1);
  if (it == fids.end()) return;
  int ib = std::distance(fids.begin(), it);
  if (ib - ia < 2) return;

  TVectorImageP img0 = sl->getFrame(fid0, false);
  TVectorImageP img1 = sl->getFrame(fid1, false);
  if (!img0 || !img1) return;

  enum TInbetween::TweenAlgorithm algorithm;
  switch (interpolation) {
  case II_Linear:
    algorithm = TInbetween::LinearInterpolation;
    break;
  case II_EaseIn:
    algorithm = TInbetween::EaseInInterpolation;
    break;
  case II_EaseOut:
    algorithm = TInbetween::EaseOutInterpolation;
    break;
  case II_EaseInOut:
    algorithm = TInbetween::EaseInOutInterpolation;
    break;
  }

  TInbetween inbetween(img0, img1);
  int i;
  for (i = ia + 1; i < ib; i++) {
    double t = (double)(i - ia) / (double)(ib - ia);
    double s = TInbetween::interpolation(t, algorithm);

    TVectorImageP vi = inbetween.tween(s);
    sl->setFrame(fids[i], vi);
    IconGenerator::instance()->invalidate(sl, fids[i]);
  }
  sl->setDirtyFlag(true);
  TApp::instance()->getCurrentLevel()->notifyLevelChange();
}

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

void FilmstripCmd::inbetween(
    TXshSimpleLevel *sl, const TFrameId &fid0, const TFrameId &fid1,
    FilmstripCmd::InbetweenInterpolation interpolation) {
  std::vector<TFrameId> fids;
  std::vector<TFrameId> levelFids;
  sl->getFids(levelFids);
  for (auto const &fid : levelFids) {
    int curFid = fid.getNumber();
    if (fid0.getNumber() <= curFid && curFid <= fid1.getNumber())
      fids.push_back(fid);
  }

  TUndoManager::manager()->add(new UndoInbetween(sl, fids, interpolation));

  inbetweenWithoutUndo(sl, fid0, fid1, interpolation);
  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
}

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

void FilmstripCmd::renumberDrawing(TXshSimpleLevel *sl, const TFrameId &oldFid,
                                   const TFrameId &desiredNewFid) {
  if (oldFid == desiredNewFid) return;
  std::vector<TFrameId> fids;
  std::vector<TFrameId> oldFrames;
  sl->getFids(oldFrames);
  sl->getFids(fids);
  std::vector<TFrameId>::iterator it =
      std::find(fids.begin(), fids.end(), oldFid);
  if (it == fids.end()) return;
  TFrameId newFid = desiredNewFid;
  while (std::find(fids.begin(), fids.end(), newFid) != fids.end()) {
    QString nextLetter = getNextLetter(newFid.getLetter());
    if (nextLetter.isEmpty()) return;
    newFid = TFrameId(newFid.getNumber(), nextLetter);
  }
  *it = newFid;
  if (Preferences::instance()->isSyncLevelRenumberWithXsheetEnabled()) {
    updateXSheet(sl, oldFrames, fids);
  }
  sl->renumber(fids);
  sl->setDirtyFlag(true);

  TApp::instance()->getCurrentXsheet()->notifyXsheetChanged();
  TApp::instance()->getCurrentLevel()->notifyLevelChange();
  TApp::instance()->getCurrentScene()->setDirtyFlag(true);
}