// 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 "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 toString(level->getName());

					else

						return "";

				}

			}

		}

	}

	return "Col" + toString(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_columnFan;

	XshHandleManager *m_handleManager;

	ToonzScene *m_scene;

public:

	TXsheetImp();

	~TXsheetImp();

	static inline unsigned long newIdentifier()

	{

		static unsigned long currentId = 0;

		return ++currentId;

	}

private:

	//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)

{

}

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

TXsheet::TXsheetImp::~TXsheetImp()

{

	assert(m_pegTree);

	assert(m_fxDag);

	assert(m_handleManager);

	delete m_pegTree;

	delete m_fxDag;

	delete m_handleManager;

}

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

// 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);

	delete 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

{

	static const TXshCell emptyCell;

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

	if (!column)

		return emptyCell;

	TXshCellColumn *xshColumn = column->getCellColumn();

	if (!xshColumn)

		return emptyCell;

	return xshColumn->getCell(row);

}

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

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(i1, j);

			TXshCell app2 = getCell(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(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(i, j).isEmpty() && i <= r1 - 1)

			i++;

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

			if (getCell(i + 1, j).isEmpty())

				break;

			const TXshCell &ce1 = getCell(i, j), &ce2 = getCell(i + 1, j);

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

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

				return false;

		}

		i = r0;

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

			i++;

		int count;

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

			count = 1;

			if (getCell(i + 1, j).isEmpty())

				continue;

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

			if (frame1 == -1)

				break;

			while (!getCell(i + 1, j).isEmpty() && getCell(i + 1, j).getFrameId().getNumber() == getCell(i, j).getFrameId().getNumber())

				i++, count++;

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

			if (frame2 == -1)

				break;

			if (frame1 + count == frame2)

				continue;

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

			{

				int numCells = frame2 - frame1 - count;

				insertCells(i + 1, j, numCells);

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

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

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

				i += numCells;

				r1 += numCells;

			} else //tolgo

			{

				int numCells = count - frame2 + frame1;

				i = i - numCells;

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

				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(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;

	TXshCell *cells = new TXshCell[size];

	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(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)

		}

	}

	if (cells)

		delete[] cells;

	cells = 0;

}

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

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(r, c);

			if (!cell.isEmpty()) {

				insertCells(r, c);

				setCell(r, c, cell);

				rEnd++;

				r++;

				while (cell == getCell(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(r, c);

			if (!cell.isEmpty()) {

				r++;

				bool removed = false;

				while (cell == getCell(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);

	TXshCell *cells = new TXshCell[size];