#include "toonzqt/styleselection.h"

// TnzQt includes

#include "toonzqt/dvdialog.h"

#include "toonzqt/gutil.h"

#include "toonzqt/selectioncommandids.h"

#include "styledata.h"

// TnzLib includes

#include "toonz/tpalettehandle.h"

#include "toonz/tscenehandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/studiopalette.h"

#include "toonz/palettecmd.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/cleanupcolorstyles.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/levelproperties.h"

// TnzCore includes

#include "tcolorstyles.h"

#include "tpixelutils.h"

#include "tundo.h"

#include "tconvert.h"

#include "../toonz/menubarcommandids.h"

#include "historytypes.h"

// Qt includes

#include <qapplication></qapplication>

#include <qclipboard></qclipboard>

#include <qbytearray></qbytearray>

#include <qbuffer></qbuffer>

using namespace DVGui;

enum StyleType {

	NORMALSTYLE,

	STUDIOSTYLE,

	LINKEDSTYLE

};

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

namespace

{

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

void copyStylesWithoutUndo(TPalette *palette, TPaletteHandle *pltHandle, int pageIndex,

						   std::set<int> *styleIndicesInPage)</int>

{

	if (!palette || pageIndex < 0)

		return;

	int n = styleIndicesInPage->size();

	if (n == 0)

		return;

	TPalette::Page *page = palette->getPage(pageIndex);

	assert(page);

	StyleData *data = new StyleData();

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

	for (it = styleIndicesInPage->begin(); it != styleIndicesInPage->end(); ++it) {

		int indexInPage = *it;

		int styleId = page->getStyleId(indexInPage);

		TColorStyle *style = page->getStyle(indexInPage);

		if (!style)

			continue;

		TColorStyle *newStyle = style->clone();

		data->addStyle(styleId, newStyle);

	}

	QApplication::clipboard()->setMimeData(data);

}

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

/*! Paste styles contained in \b data in the end of current palette page.

		Add to styleIndicesInPage pasted styles index.

*/

bool pasteStylesDataWithoutUndo(TPalette *palette, TPaletteHandle *pltHandle, const StyleData *data, int indexInPage,

								int pageIndex, std::set<int> *styleIndicesInPage)</int>

{

	if (!palette)

		palette = pltHandle->getPalette();

	if (!palette)

		return false;

	// page = pagina corrente

	TPalette::Page *page = palette->getPage(pageIndex);

	if (!data)

		return false;

	// comincio a fare paste

	int i;

	int styleId = 0;

	for (i = 0; i < data->getStyleCount(); i++) {

		styleId = data->getStyleIndex(i);

		TColorStyle *style = data->getStyle(i)->clone();

		// Se la palette e' di cleanup gli stili devono essere 8.

		if (palette->isCleanupPalette() && palette->getStyleInPagesCount() >= 8) {

			delete style;

			break;

		}

		if (palette->getStylePage(styleId) < 0) {

			// styleId non e' utilizzato: uso quello

			// (cut/paste utilizzato per spostare stili)

			palette->setStyle(styleId, style);

		} else {

			// styleId e' gia' utilizzato. ne devo prendere un altro

			styleId = palette->getFirstUnpagedStyle();

			if (styleId >= 0)

				palette->setStyle(styleId, style);

			else

				styleId = palette->addStyle(style);

		}

		//check the type of the original(copied) style

		// If the original is NormalStyle

		if (style->getGlobalName() == L"") {

			// 1. If pasting normal style to level palette, do nothing

			if (palette->getGlobalName() == L"") {

			}

			// 2. If pasting normal style to studio palette, add a new link and make it linkable

			else {

				std::wstring gname = L"-" + palette->getGlobalName() + L"-" + toWideString(styleId);

				style->setGlobalName(gname);

			}

		}

		// If the original is StudioPaletteStyle

		else if (style->getOriginalName() == L"") {

			// 3. If pasting StudioPaletteStyle to level palette, set the style name into the original name.

			// 4. If pasting StudioPaletteStyle to studio palette, set the style name into the original name and keep the link.

			style->setOriginalName(style->getName());

		}

		// If the original is linked style, do nothing

		else {

		}

		// move in the page

		// inserisco lo stile nella pagina

		int index = indexInPage + i;

		page->insertStyle(index, styleId);

		// e lo seleziono

		if (styleIndicesInPage)

			styleIndicesInPage->insert(index);

	}

	if (palette == pltHandle->getPalette())

		pltHandle->setStyleIndex(styleId);

	pltHandle->notifyPaletteChanged();

	pltHandle->notifyColorStyleSwitched();

	return true;

}

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

/*! Paste styles contained in application data after current style. Clear styleIndicesInPage

		and add to it pasted styles. If currentStyleIndex == -1 take paletteHandle current style.

*/

bool pasteStylesWithoutUndo(TPalette *palette, TPaletteHandle *pltHandle, int pageIndex,

							std::set<int> *styleIndicesInPage)</int>

{

	if (!palette)

		palette = pltHandle->getPalette();

	// page = pagina corrente

	TPalette::Page *page = palette->getPage(pageIndex);

	assert(page);

	// cerco il punto di inserimento (dopo lo stile corrente)

	int currentStyleIndex = pltHandle->getStyleIndex();

	int indexInPage = page->search(currentStyleIndex) + 1;

	const StyleData *data = dynamic_cast<const *="" styledata="">(QApplication::clipboard()->mimeData());</const>

	if (!data)

		return false;

	// cancello la selezione

	if (styleIndicesInPage)

		styleIndicesInPage->clear();

	return pasteStylesDataWithoutUndo(palette, pltHandle, data, indexInPage, pageIndex, styleIndicesInPage);

}

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

void deleteStylesWithoutUndo(TPalette *palette, TPaletteHandle *pltHandle, int pageIndex,

							 std::set<int> *styleIndicesInPage, int fir = 0)</int>

{

	if (!palette)

		palette = pltHandle->getPalette();

	int n = styleIndicesInPage->size();

	if (n == 0)

		return;

	TPalette::Page *page = palette->getPage(pageIndex);

	assert(page);

	int currentStyleIndexInPage = page->search(pltHandle->getStyleIndex());

	bool mustChangeCurrentStyle =

		currentStyleIndexInPage >= 0 && styleIndicesInPage->count(currentStyleIndexInPage) > 0;

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

	for (it = styleIndicesInPage->rbegin(); it != styleIndicesInPage->rend(); ++it) {

		int j = *it;

		int styleId = page->getStyleId(j);

		if (styleId < 2) {

			error(QObject::tr("It is not possible to delete the style #") + QString::number(styleId));

		} else {

			if (styleId == pltHandle->getStyleIndex())

				pltHandle->setStyleIndex(1);

			palette->setStyle(styleId, TPixel32::Red);

			page->removeStyle(j);

		}

	}

	styleIndicesInPage->clear();

	if (mustChangeCurrentStyle) {

		// ho cancellato lo stile corrente

		if (currentStyleIndexInPage < page->getStyleCount()) {

			// posso fare in modo che lo stile selezionato sia nella stessa posizione

			pltHandle->setStyleIndex(page->getStyleId(currentStyleIndexInPage));

		} else if (page->getStyleCount() > 0) {

			// almeno faccio in modo che sia nella stessa pagina

			int styleId = page->getStyleId(page->getStyleCount() - 1);

			pltHandle->setStyleIndex(styleId);

		} else {

			// seleziono lo stile #1 (che c'e' sempre). n.b. questo puo' comportare un cambio pagina

			pltHandle->setStyleIndex(1);

		}

	}

	//This function is used in undo and redo. So do not activate dirtyflag.

	pltHandle->notifyColorStyleChanged(false, false);

	pltHandle->notifyPaletteChanged();

}

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

void cutStylesWithoutUndo(TPalette *palette, TPaletteHandle *pltHandle, int pageIndex,

						  std::set<int> *styleIndicesInPage)</int>

{

	copyStylesWithoutUndo(palette, pltHandle, pageIndex, styleIndicesInPage);

	deleteStylesWithoutUndo(palette, pltHandle, pageIndex, styleIndicesInPage);

}

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

void insertStylesWithoutUndo(TPalette *palette, TPaletteHandle *pltHandle, int pageIndex,

							 std::set<int> *styleIndicesInPage)</int>

{

	if (!palette)

		palette = pltHandle->getPalette();

	if (!palette)

		return;

	TPalette::Page *page = palette->getPage(pageIndex);

	if (!page)

		return;

	const StyleData *data = dynamic_cast<const *="" styledata="">(QApplication::clipboard()->mimeData());</const>

	if (!data)

		return;

	int styleId = 0;

	// comincio a fare paste

	std::set<int>::iterator it = styleIndicesInPage->begin();</int>

	int i;

	for (i = 0; i < data->getStyleCount(); i++, it++) {

		styleId = data->getStyleIndex(i);

		TColorStyle *style = data->getStyle(i)->clone();

		palette->setStyle(styleId, style);

		// inserisco lo stile nella pagina

		int index = *it;

		page->insertStyle(index, styleId);

	}

	if (palette == pltHandle->getPalette())

		pltHandle->setStyleIndex(styleId);

	pltHandle->notifyColorStyleChanged(false);

	pltHandle->notifyPaletteChanged();

}

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

// PasteStylesUndo

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

class PasteStylesUndo : public TUndo

{

	TStyleSelection *m_selection;

	int m_oldStyleIndex;

	int m_pageIndex;

	std::set<int> m_styleIndicesInPage;</int>

	TPaletteP m_palette;

	QMimeData *m_data;

public:

	PasteStylesUndo(TStyleSelection *selection, int oldStyleIndex, QMimeData *data)

		: m_selection(selection), m_oldStyleIndex(oldStyleIndex), m_data(data)

	{

		m_pageIndex = m_selection->getPageIndex();

		m_styleIndicesInPage = m_selection->getIndicesInPage();

		m_palette = m_selection->getPaletteHandle()->getPalette();

	}

	~PasteStylesUndo()

	{

		delete m_data;

	}

	void undo() const

	{

		TPaletteHandle *paletteHandle = m_selection->getPaletteHandle();

		std::set<int> styleIndicesInPage = m_styleIndicesInPage;</int>

		cutStylesWithoutUndo(m_palette.getPointer(), paletteHandle, m_pageIndex, &styleIndicesInPage);

		m_selection->selectNone();

		m_selection->makeCurrent();

		//Setto l'indice corrente.

		if (m_palette.getPointer() == paletteHandle->getPalette())

			paletteHandle->setStyleIndex(m_oldStyleIndex);

	}

	void redo() const

	{

		//Se e' la paletta corrente setto l'indice corrente.

		TPaletteHandle *paletteHandle = m_selection->getPaletteHandle();

		if (m_palette.getPointer() == paletteHandle->getPalette())

			paletteHandle->setStyleIndex(m_oldStyleIndex);

		TPalette::Page *page = m_palette->getPage(m_pageIndex);

		assert(page);

		int indexInPage = page->search(m_oldStyleIndex) + 1;

		const StyleData *data = dynamic_cast<const *="" styledata="">(m_data);</const>

		assert(data);

		std::set<int> styleIndicesInPage;</int>

		pasteStylesDataWithoutUndo(m_palette.getPointer(), paletteHandle, data, indexInPage, m_pageIndex, &styleIndicesInPage);

		//Se e' la paletta corrente aggiorno la selezione

		if (m_selection && m_palette.getPointer() == paletteHandle->getPalette()) {

			m_selection->selectNone();

			m_selection->select(m_pageIndex);

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

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

				m_selection->select(m_pageIndex, *it, true);

			m_selection->makeCurrent();

		}

	}

	int getSize() const

	{

		return sizeof(*this);

	}

	QString getHistoryString()

	{

		return QObject::tr("Paste Style  in Palette : %1")

			.arg(QString::fromStdWString(m_palette->getPaletteName()));

	}

	int getHistoryType()

	{

		return HistoryType::Palette;

	}

};

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

// DeleteStylesUndo

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

class DeleteStylesUndo : public TUndo

{

	TStyleSelection *m_selection;

	int m_pageIndex;

	std::set<int> m_styleIndicesInPage;</int>

	QMimeData *m_data;

	TPaletteP m_palette;

public:

	DeleteStylesUndo(TStyleSelection *selection, QMimeData *data)

		: m_selection(selection), m_data(data)

	{

		m_pageIndex = m_selection->getPageIndex();

		m_styleIndicesInPage = m_selection->getIndicesInPage();

		m_palette = m_selection->getPaletteHandle()->getPalette();

	}

	void setStyleIndicesInPage(const std::set<int> &styleIndicesInPage)</int>

	{

		m_styleIndicesInPage = styleIndicesInPage;

	}

	void setPageIndex(int pageIndex)

	{

		m_pageIndex = pageIndex;

	}

	~DeleteStylesUndo()

	{

		delete m_data;

	}

	void undo() const

	{

		TPaletteHandle *paletteHandle = m_selection->getPaletteHandle();

		//Prendo il data corrente

		QClipboard *clipboard = QApplication::clipboard();

		QMimeData *currentData = cloneData(clipboard->mimeData());

		//Setto il vecchio data

		clipboard->setMimeData(cloneData(m_data), QClipboard::Clipboard);

		std::set<int> styleIndicesInPage = m_styleIndicesInPage;</int>

		insertStylesWithoutUndo(m_palette.getPointer(), paletteHandle, m_pageIndex, &styleIndicesInPage);

		if (m_selection && m_palette.getPointer() == paletteHandle->getPalette()) {

			m_selection->selectNone();

			m_selection->select(m_pageIndex);

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

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

				m_selection->select(m_pageIndex, *it, true);

			m_selection->makeCurrent();

		}

		//Rimetto il data corrente.

		clipboard->setMimeData(currentData, QClipboard::Clipboard);

		//do not activate dirty flag here in case that the m_palette is not current when undo

		paletteHandle->notifyColorStyleChanged(false, false);

	}

	void redo() const

	{

		std::set<int> styleIndicesInPage = m_styleIndicesInPage;</int>

		deleteStylesWithoutUndo(m_palette.getPointer(), m_selection->getPaletteHandle(), m_pageIndex, &styleIndicesInPage);

		if (m_selection) {

			m_selection->selectNone();

			m_selection->makeCurrent();

		}

	}

	int getSize() const

	{

		return sizeof(*this);

	}

	QString getHistoryString()

	{

		return QObject::tr("Delete Style  from Palette : %1")

			.arg(QString::fromStdWString(m_palette->getPaletteName()));

	}

	int getHistoryType()

	{

		return HistoryType::Palette;

	}

};

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

// CutStylesUndo

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

class CutStylesUndo : public TUndo

{

	TStyleSelection *m_selection;

	int m_pageIndex;

	std::set<int> m_styleIndicesInPage;</int>

	QMimeData *m_oldData; //!< data before cut

	QMimeData *m_data;	//!< data containing cut styles

	TPaletteP m_palette;

public:

	CutStylesUndo(TStyleSelection *selection, QMimeData *data, QMimeData *oldData)

		: m_selection(selection), m_oldData(oldData), m_data(data)

	{

		m_pageIndex = m_selection->getPageIndex();

		m_styleIndicesInPage = m_selection->getIndicesInPage();

		m_palette = m_selection->getPaletteHandle()->getPalette();

	}

	~CutStylesUndo()

	{

		delete m_oldData;

		delete m_data;

	}

	void undo() const

	{

		TPaletteHandle *paletteHandle = m_selection->getPaletteHandle();

		// Setto il data del cut

		QClipboard *clipboard = QApplication::clipboard();

		clipboard->setMimeData(cloneData(m_data), QClipboard::Clipboard);

		std::set<int> styleIndicesInPage = m_styleIndicesInPage;</int>

		insertStylesWithoutUndo(m_palette.getPointer(), paletteHandle, m_pageIndex, &styleIndicesInPage);

		if (m_selection && m_palette.getPointer() == paletteHandle->getPalette()) {

			m_selection->selectNone();

			m_selection->select(m_pageIndex);

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

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

				m_selection->select(m_pageIndex, *it, true);

			m_selection->makeCurrent();

		}

		//Setto il che c'era prima del cut

		clipboard->setMimeData(cloneData(m_oldData), QClipboard::Clipboard);

	}

	void redo() const

	{

		std::set<int> styleIndicesInPage = m_styleIndicesInPage;</int>

		cutStylesWithoutUndo(m_palette.getPointer(), m_selection->getPaletteHandle(), m_pageIndex, &styleIndicesInPage);

		m_selection->selectNone();

		m_selection->makeCurrent();

	}

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

	QString getHistoryString()

	{

		return QObject::tr("Cut Style  from Palette : %1")

			.arg(QString::fromStdWString(m_palette->getPaletteName()));

	}

	int getHistoryType()

	{

		return HistoryType::Palette;

	}

};

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

} // namespace

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

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

// TStyleSelection

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

TStyleSelection::TStyleSelection()

	: m_paletteHandle(0), m_xsheetHandle(0), m_pageIndex(-1), m_levelHandle(0)

{

}

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

TStyleSelection::~TStyleSelection()

{

}

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

void TStyleSelection::enableCommands()

{

	if (m_paletteHandle && m_paletteHandle->getPalette() && !m_paletteHandle->getPalette()->isCleanupPalette()) {

		enableCommand(this, MI_Cut, &TStyleSelection::cutStyles);

		enableCommand(this, MI_Copy, &TStyleSelection::copyStyles);

		enableCommand(this, MI_Paste, &TStyleSelection::pasteStyles);

		enableCommand(this, MI_PasteValues, &TStyleSelection::pasteStylesValue);

		enableCommand(this, MI_PasteColors, &TStyleSelection::pasteStylesColor);

		enableCommand(this, MI_PasteNames, &TStyleSelection::pasteStylesName);

		//available only for level palette

		if (m_paletteHandle->getPalette()->getGlobalName() == L"")

			enableCommand(this, MI_GetColorFromStudioPalette, &TStyleSelection::getBackOriginalStyle);

	}

	enableCommand(this, MI_Clear, &TStyleSelection::deleteStyles);

	enableCommand(this, MI_EraseUnusedStyles, &TStyleSelection::eraseUnsedStyle);

	enableCommand(this, MI_BlendColors, &TStyleSelection::blendStyles);

}

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

void TStyleSelection::select(int pageIndex)

{

	m_pageIndex = pageIndex;

	m_styleIndicesInPage.clear();

}

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

void TStyleSelection::select(int pageIndex, int styleIndexInPage, bool on)

{

	if (on) {

		if (pageIndex != m_pageIndex)

			m_styleIndicesInPage.clear();

		m_pageIndex = pageIndex;

		m_styleIndicesInPage.insert(styleIndexInPage);

	} else if (pageIndex == m_pageIndex)

		m_styleIndicesInPage.erase(styleIndexInPage);

}

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

bool TStyleSelection::isSelected(int pageIndex, int id) const

{

	return m_pageIndex == pageIndex &&

		   m_styleIndicesInPage.find(id) != m_styleIndicesInPage.end();

}

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

bool TStyleSelection::isPageSelected(int pageIndex) const

{

	return m_pageIndex == pageIndex;

}

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

bool TStyleSelection::canHandleStyles()

{

	TPalette *palette = getPalette();

	if (!palette)

		return false;

	TPalette::Page *page = palette->getPage(m_pageIndex);

	if (!page)

		return false;

	if ((isSelected(m_pageIndex, 0) && page->getStyleId(0) == 0) ||

		(isSelected(m_pageIndex, 1) && page->getStyleId(1) == 1))

		return false;

	return true;

}

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

void TStyleSelection::selectNone()

{

	m_pageIndex = -1;

	m_styleIndicesInPage.clear();

	notifyView();

}

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

bool TStyleSelection::isEmpty() const

{

	return m_pageIndex < 0 && m_styleIndicesInPage.empty();

}

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

int TStyleSelection::getStyleCount() const

{

	return m_styleIndicesInPage.size();

}

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

void TStyleSelection::cutStyles()

{

	if (isEmpty())

		return;

	QClipboard *clipboard = QApplication::clipboard();

	QMimeData *oldData = cloneData(clipboard->mimeData());

	if (!canHandleStyles()) {

		error(QObject::tr("It is not possible to delete styles #0 and #1."));

		return;

	}

	TPalette *palette = m_paletteHandle->getPalette();

	if (!palette)

		return;

	if (palette->isLocked())

		return;

	StyleData *data = new StyleData();

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

	TPalette::Page *page = palette->getPage(m_pageIndex);

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

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

		int j = *it;

		int styleId = page->getStyleId(j);

		if (styleId < 0)

			continue;

		TColorStyle *style = page->getStyle(j)->clone();

		data->addStyle(styleId, style);

		styleIds.push_back(page->getStyleId(*it));

	}

	std::auto_ptr<tundo> undo(new CutStylesUndo(this, data, oldData));</tundo>

	if (m_xsheetHandle) {

		if (eraseStylesInDemand(palette, styleIds, m_xsheetHandle) == 0)

			return;

	}

	palette->setDirtyFlag(true);

	cutStylesWithoutUndo(palette, m_paletteHandle, m_pageIndex, &m_styleIndicesInPage);

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

}

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

void TStyleSelection::copyStyles()

{

	if (isEmpty())

		return;

	copyStylesWithoutUndo(m_paletteHandle->getPalette(), m_paletteHandle, m_pageIndex, &m_styleIndicesInPage);

}

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

void TStyleSelection::pasteStyles()

{

	TPalette *palette = getPalette();

	// se non c'e' palette o pagina corrente esco

	if (!palette || m_pageIndex < 0)

		return;

	if (palette->isLocked())

		return;

	TPalette::Page *page = palette->getPage(m_pageIndex);

	if (!page)

		return;

	if (isSelected(m_pageIndex, 0) && page->getStyleId(0) == 0) {

		error(QObject::tr("Can't paste styles there"));

		return;

	}

	int oldStyleIndex = m_paletteHandle->getStyleIndex();

	QClipboard *clipboard = QApplication::clipboard();

	QMimeData *oldData = cloneData(clipboard->mimeData());

	pasteStylesWithoutUndo(m_paletteHandle->getPalette(), m_paletteHandle, m_pageIndex, &m_styleIndicesInPage);

	palette->setDirtyFlag(true);

	TUndoManager::manager()->add(new PasteStylesUndo(this, oldStyleIndex, oldData));

}

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

void TStyleSelection::deleteStyles()

{

	TPalette *palette = getPalette();

	if (!palette || m_pageIndex < 0)

		return;

	if (palette->isLocked())

		return;

	if (!canHandleStyles()) {

		error(QObject::tr("It is not possible to delete styles #0 and #1."));

		return;

	}

	if (getStyleCount() == 0)

		return;

	StyleData *data = new StyleData();

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

	TPalette::Page *page = palette->getPage(m_pageIndex);

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

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

		int j = *it;

		int styleId = page->getStyleId(j);

		if (styleId < 0)

			continue;

		TColorStyle *style = page->getStyle(j)->clone();

		data->addStyle(styleId, style);

		styleIds.push_back(page->getStyleId(*it));

	}

	TUndoScopedBlock undoBlock;

	if (m_xsheetHandle) {

		if (eraseStylesInDemand(palette, styleIds, m_xsheetHandle) == 0) // Could add an undo

			return;

	}

	std::auto_ptr<tundo> undo(new DeleteStylesUndo(this, data));</tundo>

	deleteStylesWithoutUndo(m_paletteHandle->getPalette(), m_paletteHandle, m_pageIndex, &m_styleIndicesInPage);

	palette->setDirtyFlag(true);

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

}

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

void TStyleSelection::eraseUnsedStyle()

{

	std::set<txshsimplelevel *=""> levels;</txshsimplelevel>

	int row, column, i, j;

	TPalette *palette = m_paletteHandle->getPalette();

	findPaletteLevels(levels, row, column, palette, m_xsheetHandle->getXsheet());

	//Verifico quali stili sono usati e quali no

	std::map<int, bool=""> usedStyleIds;</int,>

	int pageCount = palette->getPageCount();

	std::set<txshsimplelevel *="">::const_iterator it = levels.begin();</txshsimplelevel>

	for (it; it != levels.end(); it++) {

		TXshSimpleLevel *level = *it;

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

		level->getFids(fids);

		int m, i, j;

		for (m = 0; m < (int)fids.size(); m++) {

			TImageP image = level->getFrame(fids[m], false);

			if (!image)

				continue;

			for (i = 0; i < pageCount; i++) {

				TPalette::Page *page = palette->getPage(i);

				assert(page);

				for (j = 0; j < page->getStyleCount(); j++) {

					int styleId = page->getStyleId(j);

					if (m != 0 && usedStyleIds[styleId])

						continue;

					if (i == 0 && j == 0) //Il primo stile della prima pagina non deve essere mai cancellato

					{

						usedStyleIds[styleId] = true;

						continue;

					}

					usedStyleIds[styleId] = isStyleUsed(image, styleId);

				}

			}

		}

	}

	TUndoManager::manager()->beginBlock();

	//Butto gli stili non usati

	for (i = 0; i < pageCount; i++) {

		//Variabili usate per l'undo

		std::set<int> styleIndicesInPage;</int>

		StyleData *data = new StyleData();

		TPalette::Page *page = palette->getPage(i);

		assert(page);

		for (j = 0; j < page->getStyleCount(); j++) {

			int styleId = page->getStyleId(j);

			if (usedStyleIds[styleId])

				continue;

			styleIndicesInPage.insert(j);

			data->addStyle(styleId, page->getStyle(j)->clone());

		}

		//Se styleIndicesInPage e' vuoto ci sono stili da cancellare.

		if (styleIndicesInPage.empty()) {

			delete data;

			continue;

		}

		//Cancello gli stili

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

		for (it = styleIndicesInPage.rbegin(); it != styleIndicesInPage.rend(); ++it)

			page->removeStyle(*it);

		//Undo

		DeleteStylesUndo *undo = new DeleteStylesUndo(this, data);

		undo->setPageIndex(i);

		undo->setStyleIndicesInPage(styleIndicesInPage);

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

	}

	TUndoManager::manager()->endBlock();

	m_paletteHandle->setStyleIndex(1);

}

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

namespace

{

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

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

// UndoPasteValues

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

class UndoPasteValues : public TUndo

{

	TStyleSelection *m_selection;

	TPaletteHandle *m_paletteHandle;

	int m_pageIndex;

	TPaletteP m_palette;

	bool m_pasteName;

	bool m_pasteColor;

	class Item

	{

	public:

		int m_index;

		TColorStyle *m_oldStyle;

		TColorStyle *m_newStyle;

		Item(int index, const TColorStyle *oldStyle, const TColorStyle *newStyle)

			: m_index(index), m_oldStyle(oldStyle->clone()), m_newStyle(newStyle->clone())

		{

		}

		Item(int index, const TColorStyle *newStyle)

			: m_index(index), m_oldStyle(0), m_newStyle(newStyle->clone())

		{

		}

		~Item()

		{

			delete m_oldStyle;

			delete m_newStyle;

		}

	};

	std::vector<item *=""> m_items;</item>

	std::vector<item *=""> m_itemsInserted;</item>

	TPalette *getPalette() const { return m_palette.getPointer(); }

public:

	UndoPasteValues(TStyleSelection *selection, bool pasteName, bool pasteColor = true)

		: m_selection(selection), m_pasteName(pasteName), m_pasteColor(pasteColor)