// TnzCore includes

#include "tstream.h"

// TnzBase includes

#include "toutputproperties.h"

#include "tfx.h"

#include "tparamcontainer.h"

#include "tparamset.h"

#include "tfxattributes.h"

// TnzLib includes

#include "toonz/fxdag.h"

#include "toonz/txshchildlevel.h"

#include "toonz/txshcell.h"

#include "toonz/observer.h"

#include "toonz/controlpointobserver.h"

#include "toonz/tcolumnfx.h"

#include "toonz/tcolumnfxset.h"

#include "toonz/txshlevelcolumn.h"

#include "toonz/txshpalettecolumn.h"

#include "toonz/txshzeraryfxcolumn.h"

#include "toonz/txshsoundcolumn.h"

#include "toonz/sceneproperties.h"

#include "toonz/toonzscene.h"

#include "toonz/columnfan.h"

#include "toonz/txshleveltypes.h"

#include "toonz/txshnoteset.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/stage.h"

#include "toonz/textureutils.h"

#include "xshhandlemanager.h"

#include "orientation.h"

#include "toonz/txsheet.h"

using namespace std;

DEFINE_CLASS_CODE(TXsheet, 18)

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

namespace {

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

string getColumnDefaultName(TXsheet *xsh, int col, QString oldName) {

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

  if (column) {

    TXshLevelColumn *lc = column->getLevelColumn();

    if (lc) {

      int r0, r1;

      if (lc->getRange(r0, r1)) {

        TXshCell cell = lc->getCell(r0);

        assert(!cell.isEmpty());

        TXshLevel *level = cell.m_level.getPointer();

        if (level) {

          bool isNumber = true;

          oldName.right(oldName.size() - 3).toInt(&isNumber);

          if (oldName.left(3) == "Col" && isNumber)

            return ::to_string(level->getName());

          else

            return "";

        }

      }

    }

  }

  return "Col" + std::to_string(col + 1);

}

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

void setColumnName(TXsheet *xsh, int col) {

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

  QString oldName   = QString::fromStdString(obj->getName());

  string name       = getColumnDefaultName(xsh, col, oldName);

  if (!name.empty()) obj->setName(name);

}

}  // namespace

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

// TXsheetImp

struct TXsheet::TXsheetImp {

  unsigned long m_id;  //!< The xsheet instance's unique identifier

  TColumnSetT<txshcolumn> m_columnSet;</txshcolumn>

  TStageObjectTree *m_pegTree;

  FxDag *m_fxDag;

  int m_frameCount;

  int m_soloColumn;

  int m_viewColumn;

  TSoundTrackP m_mixedSound;

  ColumnFan m_columnFans[Orientations::COUNT];

  XshHandleManager *m_handleManager;

  ToonzScene *m_scene;

public:

  TXsheetImp();

  ~TXsheetImp();

  static inline unsigned long newIdentifier() {

    static unsigned long currentId = 0;

    return ++currentId;

  }

  void copyFoldedState();

private:

  void initColumnFans();

  // not implemented

  TXsheetImp(const TXsheetImp &);

  TXsheetImp &operator=(const TXsheetImp &);

};

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

TXsheet::SoundProperties::SoundProperties()

    : m_fromFrame(-1), m_toFrame(-1), m_frameRate(-1), m_isPreview(false) {}

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

TXsheet::SoundProperties::~SoundProperties() {}

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

inline bool TXsheet::SoundProperties::operator==(

    const SoundProperties &c) const {

  return m_fromFrame == c.m_fromFrame && m_toFrame == c.m_toFrame &&

         m_frameRate == c.m_frameRate && m_isPreview == c.m_isPreview;

}

inline bool TXsheet::SoundProperties::operator!=(

    const SoundProperties &c) const {

  return !(*this == c);

}

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

TXsheet::TXsheetImp::TXsheetImp()

    : m_id(newIdentifier())

    , m_pegTree(new TStageObjectTree)

    , m_handleManager(0)

    , m_fxDag(new FxDag())

    , m_frameCount(0)

    , m_soloColumn(-1)

    , m_viewColumn(-1)

    , m_mixedSound(0)

    , m_scene(0) {

  initColumnFans();

}

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

TXsheet::TXsheetImp::~TXsheetImp() {

  assert(m_pegTree);

  assert(m_fxDag);

  assert(m_handleManager);

  delete m_pegTree;

  delete m_fxDag;

  delete m_handleManager;

}

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

void TXsheet::TXsheetImp::initColumnFans() {

  for (auto o : Orientations::all()) {

    int index = o->dimension(PredefinedDimension::INDEX);

    m_columnFans[index].setDimension(o->dimension(PredefinedDimension::LAYER));

  }

}

void TXsheet::TXsheetImp::copyFoldedState() {

  for (int i = 1; i < Orientations::COUNT; i++)

    m_columnFans[i].copyFoldedStateFrom(m_columnFans[0]);

}

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

// TXsheet

TXsheet::TXsheet()

    : TSmartObject(m_classCode)

    , m_player(0)

    , m_imp(new TXsheet::TXsheetImp)

    , m_notes(new TXshNoteSet()) {

  // extern TSyntax::Grammar *createXsheetGrammar(TXsheet*);

  m_soundProperties      = new TXsheet::SoundProperties();

  m_imp->m_handleManager = new XshHandleManager(this);

  m_imp->m_pegTree->setHandleManager(m_imp->m_handleManager);

  m_imp->m_pegTree->createGrammar(this);

}

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

TXsheet::~TXsheet() {

  texture_utils::invalidateTextures(this);

  assert(m_imp);

  if (m_notes) delete m_notes;

  if (m_soundProperties) delete m_soundProperties;

}

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

unsigned long TXsheet::id() const { return m_imp->m_id; }

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

int TXsheet::getFrameCount() const { return m_imp->m_frameCount; }

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

const TXshCell &TXsheet::getCell(int row, int col) const {

  return getCell(CellPosition(row, col));

}

const TXshCell &TXsheet::getCell(const CellPosition &pos) const {

  static const TXshCell emptyCell;

  TXshColumnP column = m_imp->m_columnSet.getColumn(pos.layer());

  if (!column) return emptyCell;

  TXshCellColumn *xshColumn = column->getCellColumn();

  if (!xshColumn) return emptyCell;

  return xshColumn->getCell(pos.frame());

}

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

bool TXsheet::setCell(int row, int col, const TXshCell &cell) {

  if (row < 0 || col < 0) return false;

  bool wasColumnEmpty = isColumnEmpty(col);

  TXshCellColumn *cellColumn;

  if (!cell.isEmpty()) {

    TXshLevel *level = cell.m_level.getPointer();

    assert(level);

    int levelType               = level->getType();

    TXshColumn::ColumnType type = TXshColumn::eLevelType;

    if (levelType == SND_XSHLEVEL)

      type = TXshColumn::eSoundType;

    else if (levelType == SND_TXT_XSHLEVEL)

      type = TXshColumn::eSoundTextType;

    else if (levelType == PLT_XSHLEVEL)

      type = TXshColumn::ePaletteType;

    else if (levelType == ZERARYFX_XSHLEVEL)

      type = TXshColumn::eZeraryFxType;

    else if (levelType == MESH_XSHLEVEL)

      type = TXshColumn::eMeshType;

    cellColumn = touchColumn(col, type)->getCellColumn();

  } else {

    TXshColumn *column = getColumn(col);

    cellColumn         = column ? column->getCellColumn() : 0;

  }

  if (!cellColumn || cellColumn->isLocked()) return false;

  cellColumn->setXsheet(this);

  if (!cellColumn->setCell(row, cell)) {

    if (wasColumnEmpty) {

      removeColumn(col);

      insertColumn(col);

    }

    return false;

  }

  TFx *fx = cellColumn->getFx();

  if (wasColumnEmpty && fx && fx->getOutputConnectionCount() == 0 &&

      cellColumn->getPaletteColumn() == 0)

    getFxDag()->addToXsheet(fx);

  if (cell.isEmpty())

    updateFrameCount();

  else if (row >= m_imp->m_frameCount)

    m_imp->m_frameCount = row + 1;

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

  return true;

}

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

void TXsheet::getCells(int row, int col, int rowCount, TXshCell cells[]) const {

  static const TXshCell emptyCell;

  int i;

  TXshColumnP column = m_imp->m_columnSet.getColumn(col);

  if (!column) {

    for (i = 0; i < rowCount; i++) cells[i] = emptyCell;

    return;

  }

  TXshCellColumn *xshColumn = column->getCellColumn();

  if (!xshColumn) {

    for (i = 0; i < rowCount; i++) cells[i] = emptyCell;

    return;

  }

  xshColumn->getCells(row, rowCount, cells);

}

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

bool TXsheet::setCells(int row, int col, int rowCount, const TXshCell cells[]) {

  static const TXshCell emptyCell;

  int i = 0;

  while (i < rowCount && cells[i].isEmpty()) i++;

  // inserito da Elisa verso novembre 2009.

  // cosi' ha il difetto che se assegno celle vuote non fa nulla

  // per ora lo commento. bisogna indagare se questo rompe qualcosa

  // ho modificato il seguito per gestire il caso in cui i>=rowCount

  // => niente livelli dentro cells

  // if(i>=rowCount)

  //  return false;

  TXshColumn::ColumnType type = TXshColumn::eLevelType;

  if (i < rowCount) {

    TXshLevel *level = cells[i].m_level.getPointer();

    int levelType    = level->getType();

    if (levelType == SND_XSHLEVEL)

      type = TXshColumn::eSoundType;

    else if (levelType == SND_TXT_XSHLEVEL)

      type = TXshColumn::eSoundTextType;

    else if (levelType == PLT_XSHLEVEL)

      type = TXshColumn::ePaletteType;

    else if (levelType == ZERARYFX_XSHLEVEL)

      type = TXshColumn::eZeraryFxType;

    else if (levelType == MESH_XSHLEVEL)

      type = TXshColumn::eMeshType;

  }

  bool wasColumnEmpty    = isColumnEmpty(col);

  TXshCellColumn *column = touchColumn(col, type)->getCellColumn();

  if (!column) return false;

  int oldColRowCount = column->getMaxFrame() + 1;

  bool ret           = column->setCells(row, rowCount, cells);

  if (!ret || column->isLocked()) {

    if (wasColumnEmpty) {

      removeColumn(col);

      insertColumn(col);

    }

    return false;

  }

  int newColRowCount = column->getMaxFrame() + 1;

  TFx *fx = column->getFx();

  if (wasColumnEmpty && fx && fx->getOutputConnectionCount() == 0)

    getFxDag()->addToXsheet(fx);

  column->setXsheet(this);

  if (newColRowCount > m_imp->m_frameCount)

    m_imp->m_frameCount = newColRowCount;

  else {

    if (oldColRowCount == m_imp->m_frameCount &&

        newColRowCount < m_imp->m_frameCount)

      updateFrameCount();

  }

  return true;

}

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

void TXsheet::insertCells(int row, int col, int rowCount) {

  TXshColumnP column = m_imp->m_columnSet.getColumn(col);

  if (!column || column->isLocked()) return;

  TXshCellColumn *xshColumn = column->getCellColumn();

  if (!xshColumn) return;

  xshColumn->insertEmptyCells(row, rowCount);

  // aggiorno il frame count

  int fc = xshColumn->getMaxFrame() + 1;

  if (fc > m_imp->m_frameCount) m_imp->m_frameCount = fc;

}

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

void TXsheet::removeCells(int row, int col, int rowCount) {

  TXshColumnP column = m_imp->m_columnSet.getColumn(col);

  if (!column || column->isLocked()) return;

  TXshCellColumn *xshCellColumn = column->getCellColumn();

  if (!xshCellColumn) return;

  int oldColRowCount = xshCellColumn->getMaxFrame() + 1;

  xshCellColumn->removeCells(row, rowCount);

  // aggiornamento framecount

  if (oldColRowCount == m_imp->m_frameCount) updateFrameCount();

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

}

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

void TXsheet::clearCells(int row, int col, int rowCount) {

  const TXshColumnP &column = m_imp->m_columnSet.getColumn(col);

  if (!column || column->isLocked()) return;

  TXshCellColumn *xshCellColumn = column->getCellColumn();

  if (!xshCellColumn) return;

  int oldColRowCount = xshCellColumn->getMaxFrame() + 1;

  xshCellColumn->clearCells(row, rowCount);

  // aggiornamento framecount

  if (oldColRowCount == m_imp->m_frameCount) updateFrameCount();

}

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

void TXsheet::clearAll() {

  int c0 = 0, c1 = m_imp->m_columnSet.getColumnCount() - 1;

  int r0 = 0, r1 = getFrameCount() - 1;

  m_imp->m_columnSet.clear();

  if (m_imp->m_pegTree) {

    delete m_imp->m_pegTree;

    m_imp->m_pegTree = new TStageObjectTree();

    m_imp->m_pegTree->setHandleManager(m_imp->m_handleManager);

    m_imp->m_pegTree->createGrammar(this);

  }

  if (m_imp->m_fxDag) {

    delete m_imp->m_fxDag;

    m_imp->m_fxDag = new FxDag();

  }

  m_imp->m_frameCount = 0;

  m_imp->m_mixedSound = 0;

}

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

int TXsheet::getCellRange(int col, int &r0, int &r1) const {

  r0                 = 0;

  r1                 = -1;

  TXshColumnP column = m_imp->m_columnSet.getColumn(col);

  if (!column) return 0;

  TXshCellColumn *cellColumn = column->getCellColumn();

  if (!cellColumn) return 0;

  return cellColumn->getRange(r0, r1);

}

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

int TXsheet::getMaxFrame(int col) const {

  TXshColumnP column = m_imp->m_columnSet.getColumn(col);

  if (!column) return 0;

  return column->getMaxFrame();

}

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

bool TXsheet::isColumnEmpty(int col) const {

  TXshColumnP column = m_imp->m_columnSet.getColumn(col);

  return column ? column->isEmpty() : true;

}

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

void TXsheet::getUsedLevels(set<txshlevel *=""> &levels) const {</txshlevel>

  set<const *="" txsheet=""> visitedXshs;</const>

  vector<const *="" txsheet=""> todoXshs;</const>

  visitedXshs.insert(this);

  todoXshs.push_back(this);

  while (!todoXshs.empty()) {

    const TXsheet *xsh = todoXshs.back();

    todoXshs.pop_back();

    int c0 = 0, c1 = xsh->getColumnCount() - 1;

    for (int c = c0; c <= c1; ++c) {

      TXshColumnP column = const_cast<txsheet *="">(xsh)->getColumn(c);</txsheet>

      if (!column) continue;

      TXshCellColumn *cellColumn = column->getCellColumn();

      if (!cellColumn) continue;

      int r0, r1;

      if (!cellColumn->getRange(r0, r1)) continue;

      TXshLevel *level = 0;

      for (int r = r0; r <= r1; r++) {

        TXshCell cell = cellColumn->getCell(r);

        if (cell.isEmpty() || !cell.m_level) continue;

        if (level != cell.m_level.getPointer()) {

          level = cell.m_level.getPointer();

          levels.insert(level);

          if (level->getChildLevel()) {

            TXsheet *childXsh = level->getChildLevel()->getXsheet();

            if (visitedXshs.count(childXsh) == 0) {

              visitedXshs.insert(childXsh);

              todoXshs.push_back(childXsh);

            }

          }

        }

      }

    }

  }

}

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

bool TXsheet::isLevelUsed(TXshLevel *level) const {

  set<txshlevel *=""> levels;</txshlevel>

  getUsedLevels(levels);

  return levels.count(level) > 0;

}

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

TStageObject *TXsheet::getStageObject(const TStageObjectId &id) const {

  assert(id != TStageObjectId::NoneId);

  return m_imp->m_pegTree->getStageObject(id);

}

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

TStageObjectTree *TXsheet::getStageObjectTree() const {

  return m_imp->m_pegTree;

}

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

TAffine TXsheet::getPlacement(const TStageObjectId &id, int frame) const {

  assert(id != TStageObjectId::NoneId);

  return m_imp->m_pegTree->getStageObject(id)->getPlacement(frame);

}

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

double TXsheet::getZ(const TStageObjectId &id, int frame) const {

  assert(id != TStageObjectId::NoneId);

  return m_imp->m_pegTree->getStageObject(id)->getZ(frame);

}

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

double TXsheet::getNoScaleZ(const TStageObjectId &id) const {

  assert(id != TStageObjectId::NoneId);

  return m_imp->m_pegTree->getStageObject(id)->getNoScaleZ();

}

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

TAffine TXsheet::getParentPlacement(const TStageObjectId &id, int frame) const {

  assert(id != TStageObjectId::NoneId);

  return m_imp->m_pegTree->getStageObject(id)->getParentPlacement(frame);

}

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

TPointD TXsheet::getCenter(const TStageObjectId &id, int frame) const {

  assert(id != TStageObjectId::NoneId);

  return m_imp->m_pegTree->getStageObject(id)->getCenter(frame);

}

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

void TXsheet::setCenter(const TStageObjectId &id, int frame,

                        const TPointD ¢er) {

  assert(id != TStageObjectId::NoneId);

  m_imp->m_pegTree->getStageObject(id)->setCenter(frame, center);

}

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

TStageObjectId TXsheet::getStageObjectParent(const TStageObjectId &id) {

  assert(id != TStageObjectId::NoneId);

  return m_imp->m_pegTree->getStageObject(id)->getParent();

}

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

void TXsheet::setStageObjectParent(const TStageObjectId &id,

                                   const TStageObjectId &parentId) {

  assert(id != TStageObjectId::NoneId);

  m_imp->m_pegTree->getStageObject(id)->setParent(parentId);

}

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

bool TXsheet::hasChildren(const TStageObjectId &id) const {

  assert(id != TStageObjectId::NoneId);

  return m_imp->m_pegTree->getStageObject(id)->hasChildren();

}

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

TAffine TXsheet::getCameraAff(int frame) const {

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

  TAffine cameraAff       = getPlacement(cameraId, frame);

  double cameraZ          = getZ(cameraId, frame);

  TAffine aff             = cameraAff * TScale((1000 + cameraZ) / 1000);

  return aff;

}

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

void TXsheet::reverseCells(int r0, int c0, int r1, int c1) {

  int rowCount = r1 - r0;

  if (rowCount < 0 || c1 - c0 < 0) return;

  for (int j = c0; j <= c1; j++) {

    int i1, i2;

    for (i1 = r0, i2 = r1; i1 < i2; i1++, i2--) {

      TXshCell app1 = getCell(CellPosition(i1, j));

      TXshCell app2 = getCell(CellPosition(i2, j));

      setCell(i1, j, app2);

      setCell(i2, j, app1);

    }

  }

}

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

void TXsheet::swingCells(int r0, int c0, int r1, int c1) {

  int rowCount = r1 - r0;

  if (rowCount < 0 || c1 - c0 < 0) return;

  int r0Mod = r1 + 1;

  for (int c = c0; c <= c1; ++c) insertCells(r0Mod, c, rowCount);

  for (int j = c0; j <= c1; j++) {

    for (int i1 = r0Mod, i2 = r1 - 1; i2 >= r0; i1++, i2--) {

      TXshCell cell = getCell(CellPosition(i2, j));

      setCell(i1, j, cell);

    }

  }

}

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

bool TXsheet::incrementCells(int r0, int c0, int r1, int c1,

                             vector<std::pair<trect, txshcell="">> &forUndo) {</std::pair<trect,>

  for (int j = c0; j <= c1; j++) {

    int i = r0;

    while (getCell(CellPosition(i, j)).isEmpty() && i <= r1 - 1) i++;

    for (; i <= r1 - 1; i++) {

      if (getCell(CellPosition(i + 1, j)).isEmpty()) break;

      const TXshCell &ce1 = getCell(CellPosition(i, j)),

                     &ce2 = getCell(CellPosition(i + 1, j));

      if (ce2.getSimpleLevel() != ce1.getSimpleLevel() ||

          ce2.getFrameId().getNumber() < ce1.getFrameId().getNumber())

        return false;

    }

    i = r0;

    while (getCell(CellPosition(i, j)).isEmpty() && i <= r1 - 1) i++;

    int count;

    for (; i <= r1 - 1; i++) {

      count = 1;

      if (getCell(CellPosition(i + 1, j)).isEmpty()) continue;

      int frame1 = getCell(CellPosition(i, j)).getFrameId().getNumber();

      if (frame1 == -1) break;

      while (!getCell(CellPosition(i + 1, j)).isEmpty() &&

             getCell(CellPosition(i + 1, j)).getFrameId().getNumber() ==

                 getCell(CellPosition(i, j)).getFrameId().getNumber())

        i++, count++;

      int frame2 = getCell(CellPosition(i + 1, j)).getFrameId().getNumber();

      if (frame2 == -1) break;

      if (frame1 + count == frame2)

        continue;

      else if (frame1 + count < frame2)  // add

      {

        int numCells = frame2 - frame1 - count;

        insertCells(i + 1, j, numCells);

        forUndo.push_back(std::pair<trect, txshcell="">(</trect,>

            TRect(i + 1, j, i + 1 + numCells - 1, j), TXshCell()));

        for (int k = 1; k <= numCells; k++)

          setCell(i + k, j, getCell(CellPosition(i, j)));

        i += numCells;

        r1 += numCells;

      } else  // remove

      {

        int numCells = count - frame2 + frame1;

        i            = i - numCells;

        forUndo.push_back(

            std::pair<trect, txshcell="">(TRect(i + 1, j, i + 1 + numCells - 1, j),</trect,>

                                       getCell(CellPosition(i + 1, j))));

        removeCells(i + 1, j, numCells);

        r1 -= numCells;

      }

    }

  }

  return true;

}

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

void TXsheet::duplicateCells(int r0, int c0, int r1, int c1, int upTo) {

  assert(upTo >= r1 + 1);

  int chunk = r1 - r0 + 1;

  for (int j = c0; j <= c1; j++) {

    insertCells(r1 + 1, j, upTo - (r1 + 1) + 1);

    for (int i = r1 + 1; i <= upTo; i++)

      setCell(i, j, getCell(CellPosition(r0 + ((i - (r1 + 1)) % chunk), j)));

  }

}

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

void TXsheet::stepCells(int r0, int c0, int r1, int c1, int type) {

  int nr = r1 - r0 + 1;

  int nc = c1 - c0 + 1;

  if (nr < 1 || nc <= 0) return;

  int size = nr * nc;

  std::unique_ptr<txshcell[]> cells(new TXshCell[size]);</txshcell[]>

  if (!cells) return;

  // salvo il contenuto delle celle in cells

  int k = 0;

  for (int r = r0; r <= r1; r++)

    for (int c = c0; c <= c1; c++) {

      cells[k++] = getCell(CellPosition(r, c));

    }

  int nrows = nr * (type - 1);

  for (int c = c0; c <= c1; ++c) insertCells(r1 + 1, c, nrows);

  for (int j = c0; j <= c1; j++) {

    int i, k;

    for (i = r0, k = j - c0; k < size; k += nc) {

      for (int i1 = 0; i1 < type; i1++) {

        if (cells[k].isEmpty())

          clearCells(i + i1, j);

        else

          setCell(i + i1, j, cells[k]);

      }

      i += type;  // dipende dal tipo di step (2 o 3 per ora)

    }

  }

}

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

void TXsheet::increaseStepCells(int r0, int c0, int &r1, int c1) {

  int c, size = r1 - r0 + 1;

  QList<int> ends;</int>

  for (c = c0; c <= c1; c++) {

    int r = r0, i = 0, rEnd = r1;

    while (r <= rEnd) {

      TXshCell cell = getCell(CellPosition(r, c));

      if (!cell.isEmpty()) {

        insertCells(r, c);

        setCell(r, c, cell);

        rEnd++;

        r++;

        while (cell == getCell(CellPosition(r, c)) && r <= rEnd) r++;

      } else

        r++;

      i++;

    }

    ends.append(rEnd);

  }

  if (ends.isEmpty()) return;

  // controllo se devo cambiare la selezione

  bool allIncreaseIsEqual = true;

  for (c = 0; c < ends.size() - 1 && allIncreaseIsEqual; c++)

    allIncreaseIsEqual       = allIncreaseIsEqual && ends[c] == ends[c + 1];

  if (allIncreaseIsEqual) r1 = ends[0];

}

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

void TXsheet::decreaseStepCells(int r0, int c0, int &r1, int c1) {

  int c, size = r1 - r0 + 1;

  QList<int> ends;</int>

  for (c = c0; c <= c1; c++) {

    int r = r0, i = 0, rEnd = r1;

    while (r <= rEnd) {

      TXshCell cell = getCell(CellPosition(r, c));

      if (!cell.isEmpty()) {

        r++;

        bool removed = false;

        while (cell == getCell(CellPosition(r, c)) && r <= rEnd) {

          if (!removed) {

            removed = true;

            removeCells(r, c);

            rEnd--;

          } else

            r++;

        }

      } else

        r++;

      i++;

    }

    ends.append(rEnd);

  }

  if (ends.isEmpty()) return;

  // controllo se devo cambiare la selezione

  bool allDecreaseIsEqual = true;

  for (c = 0; c < ends.size() - 1 && allDecreaseIsEqual; c++)

    allDecreaseIsEqual       = allDecreaseIsEqual && ends[c] == ends[c + 1];

  if (allDecreaseIsEqual) r1 = ends[0];

}

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

void TXsheet::eachCells(int r0, int c0, int r1, int c1, int type) {

  int nr = r1 - r0 + 1;

  int nc = c1 - c0 + 1;

  if (nr < type || nc <= 0) return;

  int newRows = nr % type ? nr / type + 1 : nr / type;

  int size = newRows * nc;

  assert(size > 0);

  std::unique_ptr<txshcell[]> cells(new TXshCell[size]);</txshcell[]>

  assert(cells);

  int i, j, k;

  for (j = r0, i = 0; i < size;

       j += type)  // in cells copio il contenuto delle celle che mi interessano

  {

    for (k = c0; k <= c1; k++, i++) cells[i] = getCell(CellPosition(j, k));

  }

  int c;

  for (c = c0; c <= c1; ++c) removeCells(r0 + newRows, c, nr - newRows);

  for (i = r0, k = 0; i < r0 + newRows && k < size; i++)

    for (j = c0; j <= c1; j++) {

      //----110523 iwasawa

      // Eachでできた空きセルに、操作前のセルの中身が残ってしまう不具合を修正

      if (cells[k].isEmpty())

        clearCells(i, j);

      else

        setCell(i, j, cells[k]);

      k++;

    }

}

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

/*! force cells order in n-steps. returns the row amount after process

 */

int TXsheet::reframeCells(int r0, int r1, int col, int type) {

  // Row amount in the selection

  int nr = r1 - r0 + 1;

  if (nr < 1) return 0;

  QVector<txshcell> cells;</txshcell>

  cells.clear();

  for (int r = r0; r <= r1; r++) {

    if (cells.size() == 0 || cells.last() != getCell(CellPosition(r, col)))

      cells.push_back(getCell(CellPosition(r, col)));

  }

  if (cells.empty()) return 0;

  // row amount after n-step

  int nrows = cells.size() * type;

  // if needed, insert cells

  if (nr < nrows) {

    insertCells(r1 + 1, col, nrows - nr);

  }

  // if needed, remove cells

  else if (nr > nrows) {

    removeCells(r0 + nrows, col, nr - nrows);