#include <memory></memory>

#include "cellselection.h"

#include "cellkeyframeselection.h"

#include "keyframeselection.h"

#include "keyframedata.h"

// Tnz6 includes

#include "tapp.h"

#include "duplicatepopup.h"

#include "overwritepopup.h"

#include "selectionutils.h"

#include "columnselection.h"

#include "reframepopup.h"

// TnzQt includes

#include "toonzqt/tselectionhandle.h"

#include "toonzqt/gutil.h"

#include "historytypes.h"

// TnzLib includes

#include "toonz/txshcell.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/levelset.h"

#include "toonz/tstageobject.h"

#include "toonz/toonzscene.h"

#include "toonz/txsheethandle.h"

#include "toonz/tscenehandle.h"

#include "toonz/tobjecthandle.h"

#include "toonz/stageobjectutil.h"

#include "toonz/hook.h"

#include "toonz/levelproperties.h"

#include "toonz/childstack.h"

#include "toonz/tframehandle.h"

#include "toonz/tcolumnhandle.h"

// TnzCore includes

#include "tsystem.h"

#include "tundo.h"

#include "tmsgcore.h"

#include "trandom.h"

#include "tpalette.h"

// Qt includes

#include <qlabel></qlabel>

#include <qpushbutton></qpushbutton>

#include <qmainwindow></qmainwindow>

// tcg includes

#include "tcg/tcg_macros.h"

// STD includes

#include <ctime></ctime>

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

//    Reverse Cells  command

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

namespace {

class ReverseUndo final : public TUndo {

  int m_r0, m_c0, m_r1, m_c1;

public:

  ReverseUndo(int r0, int c0, int r1, int c1)

      : m_r0(r0), m_c0(c0), m_r1(r1), m_c1(c1) {}

  void redo() const override;

  void undo() const override { redo(); }  // Reverse is idempotent :)

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

  QString getHistoryString() override { return QObject::tr("Reverse"); }

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

};

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

void ReverseUndo::redo() const {

  TCG_ASSERT(m_r1 >= m_r0 && m_c1 >= m_c0, return );

  TApp::instance()->getCurrentXsheet()->getXsheet()->reverseCells(m_r0, m_c0,

                                                                  m_r1, m_c1);

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

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

}

}  // namespace

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

void TCellSelection::reverseCells() {

  if (isEmpty() || areAllColSelectedLocked()) return;

  TUndo *undo =

      new ReverseUndo(m_range.m_r0, m_range.m_c0, m_range.m_r1, m_range.m_c1);

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

  undo->redo();

}

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

//    Swing Cells  command

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

namespace {

class SwingUndo final : public TUndo {

  int m_r0, m_c0, m_r1, m_c1;

public:

  SwingUndo(int r0, int c0, int r1, int c1)

      : m_r0(r0), m_c0(c0), m_r1(r1), m_c1(c1) {}

  void redo() const override;

  void undo() const override;

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

  QString getHistoryString() override { return QObject::tr("Swing"); }

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

};

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

void SwingUndo::redo() const {

  TApp::instance()->getCurrentXsheet()->getXsheet()->swingCells(m_r0, m_c0,

                                                                m_r1, m_c1);

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

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

}

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

void SwingUndo::undo() const {

  TCG_ASSERT(m_r1 >= m_r0 && m_c1 >= m_c0, return );

  for (int c = m_c0; c <= m_c1; ++c)

    TApp::instance()->getCurrentXsheet()->getXsheet()->removeCells(m_r1 + 1, c,

                                                                   m_r1 - m_r0);

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

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

}

}  // namespace

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

void TCellSelection::swingCells() {

  if (isEmpty() || areAllColSelectedLocked()) return;

  TUndo *undo =

      new SwingUndo(m_range.m_r0, m_range.m_c0, m_range.m_r1, m_range.m_c1);

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

  undo->redo();

}

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

//    Increment Cells  command

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

namespace {

class IncrementUndo final : public TUndo {

  int m_r0, m_c0, m_r1, m_c1;

  mutable std::vector<std::pair<trect, txshcell="">> m_undoCells;</std::pair<trect,>

public:

  mutable bool m_ok;

public:

  IncrementUndo(int r0, int c0, int r1, int c1)

      : m_r0(r0), m_c0(c0), m_r1(r1), m_c1(c1), m_ok(true) {}

  void redo() const override;

  void undo() const override;

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

  QString getHistoryString() override { return QObject::tr("Autoexpose"); }

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

};

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

void IncrementUndo::redo() const {

  TCG_ASSERT(m_r1 >= m_r0 && m_c1 >= m_c0, return );

  m_undoCells.clear();

  m_ok = TApp::instance()->getCurrentXsheet()->getXsheet()->incrementCells(

      m_r0, m_c0, m_r1, m_c1, m_undoCells);

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

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

}

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

void IncrementUndo::undo() const {

  TCG_ASSERT(m_r1 >= m_r0 && m_c1 >= m_c0 && m_ok, return );

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

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

    const TRect &r = m_undoCells[i].first;

    int size       = r.x1 - r.x0 + 1;

    if (m_undoCells[i].second.isEmpty())

      xsh->removeCells(r.x0, r.y0, size);

    else {

      xsh->insertCells(r.x0, r.y0, size);

      for (int j = 0; j < size; ++j)

        xsh->setCell(r.x0 + j, r.y0, m_undoCells[i].second);

    }

  }

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

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

}

}  // namespace

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

void TCellSelection::incrementCells() {

  if (isEmpty() || areAllColSelectedLocked()) return;

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

  std::unique_ptr<incrementundo> undo(new IncrementUndo(</incrementundo>

      m_range.m_r0, m_range.m_c0, m_range.m_r1, m_range.m_c1));

  if (undo->redo(), !undo->m_ok) {

    DVGui::error(

        QObject::tr("Invalid selection: each selected column must contain one "

                    "single level with increasing frame numbering."));

    return;

  }

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

}

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

//    Random Cells  command

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

namespace {

class RandomUndo final : public TUndo {

  int m_r0, m_c0, m_r1, m_c1;

  std::vector<int> m_shuffle;  //!< Shuffled indices</int>

  std::vector<int> m_elffuhs;  //!< Inverse shuffle indices</int>

public:

  RandomUndo(int r0, int c0, int r1, int c1);

  void shuffleCells(int row, int col, const std::vector<int> &data) const;</int>

  void redo() const override;

  void undo() const override;

  int getSize() const override {

    return sizeof(*this) + 2 * sizeof(int) * m_shuffle.size();

  }

  QString getHistoryString() override { return QObject::tr("Random"); }

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

};

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

RandomUndo::RandomUndo(int r0, int c0, int r1, int c1)

    : m_r0(r0), m_c0(c0), m_r1(r1), m_c1(c1) {

  TCG_ASSERT(m_r1 >= m_r0 && m_c1 >= m_c0, return );

  int r, rowCount = r1 - r0 + 1;

  std::vector<std::pair<unsigned int="" int,="">> rndTable(rowCount);</std::pair<unsigned>

  TRandom rnd(std::time(0));  // Standard seeding

  for (r = 0; r < rowCount; ++r) rndTable[r] = std::make_pair(rnd.getUInt(), r);

  std::sort(rndTable.begin(), rndTable.end());  // Random sort shuffle

  m_shuffle.resize(rowCount);

  m_elffuhs.resize(rowCount);

  for (r = 0; r < rowCount; ++r) {

    m_shuffle[r]                  = rndTable[r].second;

    m_elffuhs[rndTable[r].second] = r;

  }

}

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

void RandomUndo::shuffleCells(int row, int col,

                              const std::vector<int> &data) const {</int>

  int rowCount = data.size();

  assert(rowCount > 0);

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

  std::vector<txshcell> bCells(rowCount), aCells(rowCount);</txshcell>

  xsh->getCells(row, col, rowCount, &bCells[0]);

  for (int i = 0; i < rowCount; ++i) aCells[data[i]] = bCells[i];

  xsh->setCells(row, col, rowCount, &aCells[0]);

}

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

void RandomUndo::undo() const {

  for (int c = m_c0; c <= m_c1; ++c) shuffleCells(m_r0, c, m_elffuhs);

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

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

}

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

void RandomUndo::redo() const {

  for (int c = m_c0; c <= m_c1; ++c) shuffleCells(m_r0, c, m_shuffle);

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

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

}

}  // namespace

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

void TCellSelection::randomCells() {

  if (isEmpty() || areAllColSelectedLocked()) return;

  TUndo *undo =

      new RandomUndo(m_range.m_r0, m_range.m_c0, m_range.m_r1, m_range.m_c1);

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

  undo->redo();

}

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

//    Step Cells  command

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

namespace {

class StepUndo final : public TUndo {

  int m_r0, m_c0, m_r1, m_c1;

  int m_rowsCount, m_colsCount;

  int m_step;

  int m_newRows;

  std::unique_ptr<txshcell[]> m_cells;</txshcell[]>

public:

  StepUndo(int r0, int c0, int r1, int c1, int step);

  void redo() const override;

  void undo() const override;

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

  QString getHistoryString() override {

    return QObject::tr("Step %1").arg(QString::number(m_step));

  }

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

};

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

StepUndo::StepUndo(int r0, int c0, int r1, int c1, int step)

    : m_r0(r0)

    , m_c0(c0)

    , m_r1(r1)

    , m_c1(c1)

    , m_rowsCount(r1 - r0 + 1)

    , m_colsCount(c1 - c0 + 1)

    , m_step(step)

    , m_newRows(m_rowsCount * (step - 1))

    , m_cells(new TXshCell[m_rowsCount * m_colsCount]) {

  assert(m_rowsCount > 0 && m_colsCount > 0 && step > 0);

  assert(m_cells);

  int k = 0;

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

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

      m_cells[k++] =

          TApp::instance()->getCurrentXsheet()->getXsheet()->getCell(r, c);

}

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

void StepUndo::redo() const {

  TCG_ASSERT(m_rowsCount > 0 && m_colsCount > 0, return );

  TApp::instance()->getCurrentXsheet()->getXsheet()->stepCells(m_r0, m_c0, m_r1,

                                                               m_c1, m_step);

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

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

}

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

void StepUndo::undo() const {

  TCG_ASSERT(m_rowsCount > 0 && m_colsCount > 0 && m_cells, return );

  TApp *app    = TApp::instance();

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

  for (int c = m_c0; c <= m_c1; ++c) xsh->removeCells(m_r1 + 1, c, m_newRows);

  int k = 0;

  for (int r = m_r0; r <= m_r1; ++r)

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

      if (m_cells[k].isEmpty())

        xsh->clearCells(r, c);

      else

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

      k++;

    }

  app->getCurrentXsheet()->notifyXsheetChanged();

  app->getCurrentScene()->setDirtyFlag(true);

}

}  // namespace

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

void TCellSelection::stepCells(int step) {

  if (isEmpty() || areAllColSelectedLocked()) return;

  TUndo *undo = new StepUndo(m_range.m_r0, m_range.m_c0, m_range.m_r1,

                             m_range.m_c1, step);

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

  undo->redo();

  m_range.m_r1 += (step - 1) * m_range.getRowCount();

}

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

//    Each Cells  command

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

namespace {

class EachUndo final : public TUndo {

  int m_r0, m_c0, m_r1, m_c1;

  int m_rowsCount, m_colsCount;

  int m_each;

  int m_newRows;

  std::unique_ptr<txshcell[]> m_cells;</txshcell[]>

public:

  EachUndo(int r0, int c0, int r1, int c1, int each);

  void redo() const override;

  void undo() const override;

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

  QString getHistoryString() override {

    return QObject::tr("Each %1").arg(QString::number(m_each));

  }

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

};

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

EachUndo::EachUndo(int r0, int c0, int r1, int c1, int each)

    : m_r0(r0)

    , m_c0(c0)

    , m_r1(r1)

    , m_c1(c1)

    , m_rowsCount(r1 - r0 + 1)

    , m_colsCount(c1 - c0 + 1)

    , m_each(each)

    , m_newRows((m_rowsCount % each) ? m_rowsCount / each + 1

                                     : m_rowsCount / each)

    , m_cells(new TXshCell[m_rowsCount * m_colsCount]) {

  assert(m_rowsCount > 0 && m_colsCount > 0 && each > 0);

  assert(m_cells);

  int k = 0;

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

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

      m_cells[k++] =

          TApp::instance()->getCurrentXsheet()->getXsheet()->getCell(r, c);

}

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

void EachUndo::redo() const {

  TCG_ASSERT(m_rowsCount > 0 && m_colsCount > 0, return );

  TApp::instance()->getCurrentXsheet()->getXsheet()->eachCells(m_r0, m_c0, m_r1,

                                                               m_c1, m_each);

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

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

}

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

void EachUndo::undo() const {

  TCG_ASSERT(m_rowsCount > 0 && m_colsCount > 0 && m_cells, return );

  TApp *app    = TApp::instance();

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

  for (int c = m_c0; c <= m_c1; ++c)

    xsh->insertCells(m_r0 + m_newRows, c, m_rowsCount - m_newRows);

  int k = 0;

  for (int r = m_r0; r <= m_r1; ++r)

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

      if (m_cells[k].isEmpty())

        xsh->clearCells(r, c);

      else

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

      k++;

    }

  app->getCurrentXsheet()->notifyXsheetChanged();

  app->getCurrentScene()->setDirtyFlag(true);

}

}  // namespace

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

void TCellSelection::eachCells(int each) {

  if (isEmpty() || areAllColSelectedLocked()) return;

  TUndo *undo = new EachUndo(m_range.m_r0, m_range.m_c0, m_range.m_r1,

                             m_range.m_c1, each);

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

  undo->redo();

  m_range.m_r1 = m_range.m_r0 + (m_range.m_r1 - m_range.m_r0 + each) / each - 1;

}

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

//    Reframe command : 強制的にNコマ打ちにする

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

namespace {

class ReframeUndo final : public TUndo {

  int m_r0, m_r1;

  int m_type;

  int m_nr;

  int m_withBlank;

  std::unique_ptr<txshcell[]> m_cells;</txshcell[]>

public:

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

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

  ReframeUndo(int r0, int r1, std::vector<int> columnIndeces, int type,</int>

              int withBlank = -1);

  ~ReframeUndo();

  void undo() const override;

  void redo() const override;

  void repeat() const;

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

  QString getHistoryString() override {

    if (m_withBlank == -1)

      return QObject::tr("Reframe to %1's").arg(QString::number(m_type));

    else

      return QObject::tr("Reframe to %1's with %2 blanks")

          .arg(QString::number(m_type))

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

  }

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

};

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

ReframeUndo::ReframeUndo(int r0, int r1, std::vector<int> columnIndeces,</int>

                         int type, int withBlank)

    : m_r0(r0)

    , m_r1(r1)

    , m_type(type)

    , m_nr(0)

    , m_columnIndeces(columnIndeces)

    , m_withBlank(withBlank) {

  m_nr = m_r1 - m_r0 + 1;

  assert(m_nr > 0);

  m_cells.reset(new TXshCell[m_nr * (int)m_columnIndeces.size()]);

  assert(m_cells);

  int k = 0;

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

    for (int c     = 0; c < (int)m_columnIndeces.size(); c++)

      m_cells[k++] = TApp::instance()->getCurrentXsheet()->getXsheet()->getCell(

          r, m_columnIndeces[c]);

  m_newRows.clear();

}

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

ReframeUndo::~ReframeUndo() {}

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

void ReframeUndo::undo() const {

  TApp *app    = TApp::instance();

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

  int rowCount = m_r1 - m_r0;

  if (rowCount < 0 || m_columnIndeces.size() < 1) return;

  for (int c = 0; c < m_columnIndeces.size(); c++) {

    /*-- コマンド後に縮んだカラムはその分引き伸ばす --*/

    if (m_newRows[c] < m_nr)

      xsh->insertCells(m_r0 + m_newRows[c], m_columnIndeces[c],

                       m_nr - m_newRows[c]);

    /*-- コマンド後に延びたカラムはその分縮める --*/

    else if (m_newRows[c] > m_nr)

      xsh->removeCells(m_r1 + 1, m_columnIndeces[c], m_newRows[c] - m_nr);

  }

  if (m_cells) {

    int k = 0;

    for (int r = m_r0; r <= m_r1; r++)

      for (int c = 0; c < m_columnIndeces.size(); c++) {

        if (m_cells[k].isEmpty())

          xsh->clearCells(r, m_columnIndeces[c]);

        else

          xsh->setCell(r, m_columnIndeces[c], m_cells[k]);

        k++;

      }

  }

  app->getCurrentXsheet()->notifyXsheetChanged();

}

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

void ReframeUndo::redo() const {

  if (m_r1 - m_r0 < 0 || m_columnIndeces.size() < 1) return;

  TApp *app = TApp::instance();

  for (int c = 0; c < m_columnIndeces.size(); c++)

    app->getCurrentXsheet()->getXsheet()->reframeCells(

        m_r0, m_r1, m_columnIndeces[c], m_type, m_withBlank);

  app->getCurrentXsheet()->notifyXsheetChanged();

}

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

void ReframeUndo::repeat() const {}

}  // namespace

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

void TCellSelection::reframeCells(int count) {

  if (isEmpty() || areAllColSelectedLocked()) return;

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

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

  ReframeUndo *undo =

      new ReframeUndo(m_range.m_r0, m_range.m_r1, colIndeces, count);

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

    int nrows = TApp::instance()->getCurrentXsheet()->getXsheet()->reframeCells(

        m_range.m_r0, m_range.m_r1, c, count);

    undo->m_newRows.push_back(nrows);

  }

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

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

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

}

void TColumnSelection::reframeCells(int count) {

  if (isEmpty()) return;

  int rowCount =

      TApp::instance()->getCurrentXsheet()->getXsheet()->getFrameCount();

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

  std::set<int>::const_iterator it;</int>

  for (it = m_indices.begin(); it != m_indices.end(); it++)

    colIndeces.push_back(*it);

  ReframeUndo *undo = new ReframeUndo(0, rowCount - 1, colIndeces, count);

  for (int c = 0; c < (int)colIndeces.size(); c++) {

    int nrows = TApp::instance()->getCurrentXsheet()->getXsheet()->reframeCells(

        0, rowCount - 1, colIndeces[c], count);

    undo->m_newRows.push_back(nrows);

  }

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

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

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

}

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

void TCellSelection::reframeWithEmptyInbetweens() {

  if (isEmpty() || areAllColSelectedLocked()) return;

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

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

  // destruction of m_reframePopup will be done along with the main window

  if (!m_reframePopup) m_reframePopup = new ReframePopup();

  int ret                             = m_reframePopup->exec();

  if (ret == QDialog::Rejected) return;

  int step, blank;

  m_reframePopup->getValues(step, blank);

  ReframeUndo *undo =

      new ReframeUndo(m_range.m_r0, m_range.m_r1, colIndeces, step, blank);

  int maximumRow = 0;

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

    int nrows = TApp::instance()->getCurrentXsheet()->getXsheet()->reframeCells(

        m_range.m_r0, m_range.m_r1, c, step, blank);

    undo->m_newRows.push_back(nrows);

    if (maximumRow < nrows) maximumRow = nrows;

  }

  if (maximumRow == 0) {

    delete undo;

    return;

  }

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

  // select reframed range

  selectCells(m_range.m_r0, m_range.m_c0, m_range.m_r0 + maximumRow - 1,

              m_range.m_c1);

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

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

}

void TColumnSelection::reframeWithEmptyInbetweens() {

  if (isEmpty()) return;

  int rowCount =

      TApp::instance()->getCurrentXsheet()->getXsheet()->getFrameCount();

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

  std::set<int>::const_iterator it;</int>

  for (it = m_indices.begin(); it != m_indices.end(); it++)

    colIndeces.push_back(*it);

  if (!m_reframePopup) m_reframePopup = new ReframePopup();

  int ret                             = m_reframePopup->exec();

  if (ret == QDialog::Rejected) return;

  int step, blank;

  m_reframePopup->getValues(step, blank);

  ReframeUndo *undo = new ReframeUndo(0, rowCount - 1, colIndeces, step, blank);

  bool commandExecuted = false;

  for (int c = 0; c < (int)colIndeces.size(); c++) {

    int nrows = TApp::instance()->getCurrentXsheet()->getXsheet()->reframeCells(

        0, rowCount - 1, colIndeces[c], step, blank);

    undo->m_newRows.push_back(nrows);

    if (nrows > 0) commandExecuted = true;

  }

  if (!commandExecuted) {

    delete undo;

    return;

  }

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

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

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

}

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

//    Reset Step Cells  command

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

namespace {

class ResetStepUndo final : public TUndo {

  int m_r0, m_c0, m_r1, m_c1;

  int m_rowsCount, m_colsCount;

  std::unique_ptr<txshcell[]> m_cells;</txshcell[]>

  QMap<int, int=""> m_insertedCells;  //!< Count of inserted cells, by column</int,>

public:

  ResetStepUndo(int r0, int c0, int r1, int c1);

  void redo() const override;

  void undo() const override;

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

};

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

ResetStepUndo::ResetStepUndo(int r0, int c0, int r1, int c1)

    : m_r0(r0)

    , m_c0(c0)

    , m_r1(r1)

    , m_c1(c1)

    , m_rowsCount(m_r1 - m_r0 + 1)

    , m_colsCount(m_c1 - m_c0 + 1)

    , m_cells(new TXshCell[m_rowsCount * m_colsCount]) {

  assert(m_rowsCount > 0 && m_colsCount > 0);

  assert(m_cells);

  TApp *app = TApp::instance();

  int k = 0;

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

    TXshCell prevCell;

    m_insertedCells[c] = 0;

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

      const TXshCell &cell =

          app->getCurrentXsheet()->getXsheet()->getCell(r, c);

      m_cells[k++] = cell;

      if (prevCell != cell) {

        prevCell = cell;

        m_insertedCells[c]++;

      }

    }

  }

}

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

void ResetStepUndo::redo() const {

  TCG_ASSERT(m_rowsCount > 0 && m_colsCount > 0, return );

  TApp::instance()->getCurrentXsheet()->getXsheet()->resetStepCells(m_r0, m_c0,

                                                                    m_r1, m_c1);

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

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

}

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

void ResetStepUndo::undo() const {

  TApp *app    = TApp::instance();

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

  int k = 0;

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

    xsh->removeCells(m_r0, c, m_insertedCells[c]);

    xsh->insertCells(m_r0, c, m_rowsCount);

    for (int r = m_r0; r <= m_r1; ++r) xsh->setCell(r, c, m_cells[k++]);

  }

  app->getCurrentXsheet()->notifyXsheetChanged();

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

}