#include "toonz/palettecmd.h"

// TnzLib includes

#include "toonz/tpalettehandle.h"

#include "toonz/txshlevelhandle.h"

#include "toonz/txsheethandle.h"

#include "toonz/studiopalette.h"

#include "toonz/txsheet.h"

#include "toonz/txshcolumn.h"

#include "toonz/txshcell.h"

#include "toonz/txshlevelcolumn.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/cleanupcolorstyles.h"

#include "toonz/studiopalette.h"

#include "toonz/txshlevel.h"

#include "toonz/toonzscene.h"

#include "toonz/toonzimageutils.h"

#include "toonz/cleanupcolorstyles.h"

#include "toonz/preferences.h"

// TnzCore includes

#include "tpalette.h"

#include "tcolorstyles.h"

#include "tundo.h"

#include "tvectorimage.h"

#include "ttoonzimage.h"

#include "trasterimage.h"

#include "tconvert.h"

#include "tcolorutils.h"

#include "tropcm.h"

#include "tstroke.h"

#include "tregion.h"

#include "tlevel_io.h"

#include "historytypes.h"

// tcg includes

#include "tcg/boost/range_utility.h"

// boost includes

#include <boost bind.hpp=""></boost>

#include <boost counting_range.hpp="" range=""></boost>

#include <boost adaptor="" range="" transformed.hpp=""></boost>

#include <boost adaptor="" filtered.hpp="" range=""></boost>

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

void findPaletteLevels(set<txshsimplelevel *=""> &levels, int &rowIndex, int &columnIndex,</txshsimplelevel>

					   TPalette *palette, TXsheet *xsheet)

{

	rowIndex = columnIndex = -1;

	int columnCount = xsheet->getColumnCount();

	int c;

	for (c = 0; c < columnCount; c++) {

		TXshColumn *column = xsheet->getColumn(c);

		if (!column || column->isEmpty())

			continue;

		TXshLevelColumn *levelColumn = column->getLevelColumn();

		if (!levelColumn || levelColumn->isEmpty())

			continue;

		int r0, r1;

		if (!column->getRange(r0, r1))

			continue;

		int r;

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

			TXshCell cell = levelColumn->getCell(r);

			if (cell.isEmpty())

				continue;

			TXshSimpleLevel *level = cell.getSimpleLevel();

			if (!level || level->getPalette() != palette)

				continue;

			levels.insert(level);

			if (rowIndex < 0) {

				rowIndex = r;

				columnIndex = c;

			}

		}

	}

}

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

namespace

{

bool isStyleUsed(const TVectorImageP vi, int styleId)

{

	int strokeCount = vi->getStrokeCount();

	int i;

	for (i = strokeCount - 1; i >= 0; i--) {

		TStroke *stroke = vi->getStroke(i);

		if (stroke && stroke->getStyle() == styleId)

			return true;

	}

	int regionCount = vi->getRegionCount();

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

		TRegion *region = vi->getRegion(i);

		if (region || region->getStyle() != styleId)

			return true;

	}

	return false;

}

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

bool isStyleUsed(const TToonzImageP vi, int styleId)

{

	TRasterCM32P ras = vi->getRaster();

	for (int y = 0; y < ras->getLy(); y++) {

		TPixelCM32 *pix = ras->pixels(y), *endPix = pix + ras->getLx();

		while (pix < endPix) {

			if (pix->getPaint() == styleId)

				return true;

			if (pix->getInk() == styleId)

				return true;

			pix++;

		}

	}

	return false;

}

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

/*! Return true if one style is used. */

bool areStylesUsed(const TImageP image, const vector<int> styleIds)</int>

{

	int j;

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

		if (isStyleUsed(image, styleIds[j]))

			return true;

	return false;

}

} //namespace

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

bool isStyleUsed(const TImageP image, int styleId)

{

	TVectorImageP vi = image;

	TToonzImageP ti = image;

	if (vi)

		return isStyleUsed(vi, styleId);

	if (ti)

		return isStyleUsed(ti, styleId);

	return false;

}

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

/*! Return true if one style is used. */

bool areStylesUsed(const set<txshsimplelevel *=""> levels, const vector<int> styleIds)</int></txshsimplelevel>

{

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

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

		TXshSimpleLevel *level = *it;

		vector<tframeid> fids;</tframeid>

		level->getFids(fids);

		int i;

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

			TImageP image = level->getFrame(fids[i], true);

			if (areStylesUsed(image, styleIds))

				return true;

		}

	}

	return false;

}

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

//

// arrangeStyles

// srcPage : {a0,a1,...an } ==> dstPage : {b,b+1,...b+n-1}

//

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

/*! \namespace PaletteCmd

		\brief Provides a collection of methods to manage \b TPalette.

*/

namespace

{

class ArrangeStylesUndo : public TUndo

{

	TPaletteHandle *m_paletteHandle;

	TPaletteP m_palette;

	int m_dstPageIndex;

	int m_dstIndexInPage;

	int m_srcPageIndex;

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

public:

	ArrangeStylesUndo(TPaletteHandle *paletteHandle,

					  int dstPageIndex,

					  int dstIndexInPage,

					  int srcPageIndex,

					  const std::set<int> &srcIndicesInPage)</int>

		: m_paletteHandle(paletteHandle), m_dstPageIndex(dstPageIndex), m_dstIndexInPage(dstIndexInPage), m_srcPageIndex(srcPageIndex), m_srcIndicesInPage(srcIndicesInPage)

	{

		m_palette = m_paletteHandle->getPalette();

		assert(m_palette);

		assert(0 <= dstPageIndex && dstPageIndex < m_palette->getPageCount());

		assert(0 <= srcPageIndex && srcPageIndex < m_palette->getPageCount());

		TPalette::Page *dstPage = m_palette->getPage(dstPageIndex);

		assert(dstPage);

		assert(0 <= dstIndexInPage && dstIndexInPage <= dstPage->getStyleCount());

		assert(!srcIndicesInPage.empty());

		TPalette::Page *srcPage = m_palette->getPage(srcPageIndex);

		assert(srcPage);

		assert(0 <= *srcIndicesInPage.begin() && *srcIndicesInPage.rbegin() < srcPage->getStyleCount());

	}

	void undo() const

	{

		TPalette::Page *srcPage = m_palette->getPage(m_srcPageIndex);

		assert(srcPage);

		TPalette::Page *dstPage = m_palette->getPage(m_dstPageIndex);

		assert(dstPage);

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

		int count = m_srcIndicesInPage.size();

		int h = m_dstIndexInPage;

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

		for (i = m_srcIndicesInPage.begin(); i != m_srcIndicesInPage.end(); ++i) {

			if (srcPage == dstPage && (*i) <= h)

				h--;

			else

				break;

		}

		assert(h + count - 1 <= dstPage->getStyleCount());

		int k;

		for (k = 0; k < count; k++) {

			styles.push_back(dstPage->getStyleId(h));

			dstPage->removeStyle(h);

		}

		k = 0;

		for (i = m_srcIndicesInPage.begin(); i != m_srcIndicesInPage.end(); ++i, ++k)

			srcPage->insertStyle(*i, styles[k]);

		m_paletteHandle->notifyPaletteChanged();

	}

	void redo() const

	{

		TPalette::Page *srcPage = m_palette->getPage(m_srcPageIndex);

		assert(srcPage);

		TPalette::Page *dstPage = m_palette->getPage(m_dstPageIndex);

		assert(dstPage);

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

		std::set<int>::const_reverse_iterator i;</int>

		std::vector<int>::iterator j;</int>

		int k = m_dstIndexInPage;

		for (i = m_srcIndicesInPage.rbegin(); i != m_srcIndicesInPage.rend(); ++i) {

			int index = *i;

			if (m_dstPageIndex == m_srcPageIndex && index < k)

				k--;

			styles.push_back(srcPage->getStyleId(index));

			srcPage->removeStyle(index);

		}

		for (j = styles.begin(); j != styles.end(); ++j)

			dstPage->insertStyle(k, *j);

		m_palette->setDirtyFlag(true);

		m_paletteHandle->notifyPaletteChanged();

	}

	int getSize() const { return sizeof *this + m_srcIndicesInPage.size() * sizeof(int); }

	QString getHistoryString()

	{

		return QObject::tr("Arrange Styles  in Palette %1")

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

	}

	int getHistoryType()

	{

		return HistoryType::Palette;

	}

};

} // namespace

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

void PaletteCmd::arrangeStyles(TPaletteHandle *paletteHandle,

							   int dstPageIndex, int dstIndexInPage,

							   int srcPageIndex, const std::set<int> &srcIndicesInPage)</int>

{

	if (dstPageIndex == srcPageIndex && dstIndexInPage == *srcIndicesInPage.begin())

		return;

	ArrangeStylesUndo *undo =

		new ArrangeStylesUndo(paletteHandle, dstPageIndex,

							  dstIndexInPage, srcPageIndex,

							  srcIndicesInPage);

	undo->redo();

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

}

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

//CreateStyle

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

namespace

{

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

class CreateStyleUndo : public TUndo

{

	TPaletteHandle *m_paletteHandle;

	TPaletteP m_palette;

	int m_pageIndex;

	int m_styleId;

	TColorStyle *m_style;

public:

	CreateStyleUndo(

		TPaletteHandle *paletteHandle,

		int pageIndex,

		int styleId)

		: m_paletteHandle(paletteHandle), m_pageIndex(pageIndex), m_styleId(styleId)

	{

		m_palette = m_paletteHandle->getPalette();

		m_style = m_palette->getStyle(m_styleId)->clone();

		assert(m_palette);

		assert(0 <= pageIndex && pageIndex < m_palette->getPageCount());

		assert(0 <= styleId && styleId < m_palette->getStyleCount());

	}

	void undo() const

	{

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

		assert(page);

		int indexInPage = page->search(m_styleId);

		assert(indexInPage >= 0);

		page->removeStyle(indexInPage);

		m_paletteHandle->notifyPaletteChanged();

	}

	void redo() const

	{

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

		assert(page);

		assert(m_palette->getStylePage(m_styleId) == 0);

		int indexInPage = page->addStyle(m_styleId);

		if (indexInPage == -1) {

			indexInPage = page->getStyleCount();

			page->insertStyle(indexInPage, m_style->getMainColor());

			assert(m_styleId == page->getStyleId(indexInPage));

		}

		m_palette->getStyle(m_styleId)->setMainColor(m_style->getMainColor());

		m_palette->getStyle(m_styleId)->setName(m_style->getName());

		m_paletteHandle->notifyPaletteChanged();

	}

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

	QString getHistoryString()

	{

		return QObject::tr("Create Style#%1  in Palette %2")

			.arg(QString::number(m_styleId))

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

	}

	int getHistoryType()

	{

		return HistoryType::Palette;

	}

};

} // namespace

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

void PaletteCmd::createStyle(

	TPaletteHandle *paletteHandle,

	TPalette::Page *page)

{

	int index = paletteHandle->getStyleIndex();

	TPalette *palette = paletteHandle->getPalette();

	int newIndex;

	int UnpagedId = palette->getFirstUnpagedStyle();

	if (UnpagedId != -1 && !palette->isCleanupPalette()) {

		if (index == -1)

			palette->getStyle(UnpagedId)->setMainColor(TPixel32::Black);

		else

			palette->getStyle(UnpagedId)->setMainColor(palette->getStyle(index)->getMainColor());

		newIndex = page->addStyle(UnpagedId);

	} else if (!palette->isCleanupPalette()) {

		if (index == -1)

			newIndex = page->addStyle(TPixel32::Black);

		else {

			TColorStyle *style = palette->getStyle(index);

			TCleanupStyle *cleanupStyle = dynamic_cast<tcleanupstyle *="">(style);</tcleanupstyle>

			if ((cleanupStyle || index == 0) && palette->isCleanupPalette()) {

				TColorCleanupStyle *newCleanupStyle = new TColorCleanupStyle();

				if (cleanupStyle) {

					int i;

					for (i = 0; i < cleanupStyle->getParamCount(); i++)

						newCleanupStyle->setColorParamValue(i, cleanupStyle->getColorParamValue(i));

				}

				newIndex = page->addStyle(newCleanupStyle);

			} else

				newIndex = page->addStyle(style->getMainColor());

		}

	} else /*- CleanupPaletteの場合 -*/

	{

		newIndex = page->addStyle(new TColorCleanupStyle(TPixel32::Red));

	}

	int newStyleId = page->getStyleId(newIndex);

	/*-  StudioPalette上でStyleを追加した場合、GlobalNameを自動で割り振る -*/

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

		TColorStyle *cs = palette->getStyle(newStyleId);

		wstring gname = L"-" + palette->getGlobalName() + L"-" + toWideString(newStyleId);

		cs->setGlobalName(gname);

	}

	page->getStyle(newIndex)->setName(QString("color_%1").arg(newStyleId).toStdWString());

	paletteHandle->setStyleIndex(newStyleId);

	palette->setDirtyFlag(true);

	paletteHandle->notifyPaletteChanged();

	TUndoManager::manager()->add(new CreateStyleUndo(paletteHandle, page->getIndex(), page->getStyleId(newIndex)));

}

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

// addStyles

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

namespace

{

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

// AddStylesUndo

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

class AddStylesUndo : public TUndo

{

	TPaletteP m_palette;

	int m_pageIndex;

	int m_indexInPage;

	std::vector<std::pair<tcolorstyle *,="" int="">> m_styles;</std::pair<tcolorstyle>

	TPaletteHandle *m_paletteHandle;

public:

	// creare DOPO l'inserimento

	AddStylesUndo(

		const TPaletteP &palette,

		int pageIndex,

		int indexInPage,

		int count,

		TPaletteHandle *paletteHandle)

		: m_palette(palette), m_pageIndex(pageIndex), m_indexInPage(indexInPage), m_paletteHandle(paletteHandle)

	{

		assert(m_palette);

		assert(0 <= m_pageIndex && m_pageIndex < m_palette->getPageCount());

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

		assert(page);

		assert(0 <= indexInPage && indexInPage + count <= page->getStyleCount());

		for (int i = 0; i < count; i++) {

			std::pair<tcolorstyle *,="" int=""> p;</tcolorstyle>

			p.second = page->getStyleId(m_indexInPage + i);

			p.first = m_palette->getStyle(p.second)->clone();

			m_styles.push_back(p);

		}

	}

	~AddStylesUndo()

	{

		for (int i = 0; i < (int)m_styles.size(); i++)

			delete m_styles[i].first;

	}

	void undo() const

	{

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

		assert(page);

		int count = m_styles.size();

		int i;

		for (i = count - 1; i >= 0; i--)

			page->removeStyle(m_indexInPage + i);

		m_paletteHandle->notifyPaletteChanged();

	}

	void redo() const

	{

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

		assert(page);

		for (int i = 0; i < (int)m_styles.size(); i++) {

			TColorStyle *cs = m_styles[i].first->clone();

			int styleId = m_styles[i].second;

			assert(m_palette->getStylePage(styleId) == 0);

			m_palette->setStyle(styleId, cs);

			page->insertStyle(m_indexInPage + i, styleId);

		}

		m_paletteHandle->notifyPaletteChanged();

	}

	int getSize() const { return sizeof *this + m_styles.size() * sizeof(TColorStyle); }

	QString getHistoryString()

	{

		return QObject::tr("Add Style  to Palette %1")

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

	}

	int getHistoryType()

	{

		return HistoryType::Palette;

	}

};

} // namespace

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

/*- ドラッグ＆ドロップ時に呼ばれる -*/

void PaletteCmd::addStyles(TPaletteHandle *paletteHandle, int pageIndex,

						   int indexInPage, const std::vector<tcolorstyle *=""> &styles)</tcolorstyle>

{

	TPalette *palette = paletteHandle->getPalette();

	assert(0 <= pageIndex && pageIndex < palette->getPageCount());

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

	assert(page);

	assert(0 <= indexInPage && indexInPage <= page->getStyleCount());

	int count = styles.size();

	for (int i = 0; i < count; i++) {

		page->insertStyle(indexInPage + i, styles[i]->clone());

		/*-- StudioPaletteから持ち込んだ場合、その元の名前をoriginalNameに入れる --*/

		if (styles[i]->getGlobalName() != L"") {

			/*-- もし元のStyleにOriginalNameが無ければ（コピー元がStudioPaletteからということ）--*/

			if (styles[i]->getOriginalName() == L"") {

				/*-- 元のStyleの名前をペースト先のOriginalNameに入れる --*/

				page->getStyle(indexInPage + i)->setOriginalName(styles[i]->getName());

			}

		}

		/*-- それ以外の場合は、clone()でそれぞれの名前をコピーしているので、そのままでOK --*/

	}

	TUndoManager::manager()->add(new AddStylesUndo(palette, pageIndex, indexInPage, count, paletteHandle));

	palette->setDirtyFlag(true);

}

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

// eraseStyles

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

namespace

{

void eraseStylesInLevels(const set<txshsimplelevel *=""> &levels, const vector<int> styleIds)</int></txshsimplelevel>

{

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

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

		TXshSimpleLevel *level = *it;

		vector<tframeid> fids;</tframeid>

		level->getFids(fids);

		int i;

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

			TImageP image = level->getFrame(fids[i], true);

			TVectorImageP vi = image;

			TToonzImageP ti = image;

			if (vi)

				vi->eraseStyleIds(styleIds);

			else if (ti)

				TRop::eraseStyleIds(ti.getPointer(), styleIds);

		}

	}

}

} // namespace

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

void PaletteCmd::eraseStyles(const std::set<txshsimplelevel *=""> &levels,</txshsimplelevel>

							 const std::vector<int> &styleIds)</int>

{

	typedef std::pair<const std::vector<tvectorimagep="" txshsimplelevelp,="">> LevelImages;</const>

	struct Undo : public TUndo {

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

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

		mutable std::map<txshsimplelevelp, std::vector<tvectorimagep="">> m_imagesByLevel;</txshsimplelevelp,>

	public:

		Undo(const std::set<txshsimplelevel *=""> &levels, const std::vector<int> &styleIds)</int></txshsimplelevel>

			: m_levels(levels), m_styleIds(styleIds)

		{

			tcg::substitute(m_imagesByLevel, levels | boost::adaptors::filtered(isVector) | boost::adaptors::transformed(toEmptyLevelImages));

		}

		bool isValid() const { return !m_levels.empty(); }

		void redo() const

		{

			std::for_each(m_imagesByLevel.begin(), m_imagesByLevel.end(), cloneImages);

			eraseStylesInLevels(m_levels, m_styleIds);

		}

		void undo() const

		{

			std::for_each(m_imagesByLevel.begin(), m_imagesByLevel.end(), restoreImages);

		}

		int getSize() const { return 10 << 20; } // At max 10 per 100 MB

	private:

		static bool isVector(const TXshSimpleLevel *level)

		{

			return (assert(level), level->getType() == PLI_XSHLEVEL);

		}

		static LevelImages toEmptyLevelImages(TXshSimpleLevel *level)

		{

			return LevelImages(level, std::vector<tvectorimagep>());</tvectorimagep>

		}

		static void copyStrokeIds(const TVectorImage &src, TVectorImage &dst)

		{

			UINT s, sCount = src.getStrokeCount();

			for (s = 0; s != sCount; ++s)

				dst.getStroke(s)->setId(src.getStroke(s)->getId());

		}

		static TVectorImageP cloneImage(const TXshSimpleLevel &level, int f)

		{

			TVectorImageP src = static_cast<tvectorimagep>(level.getFrame(level.getFrameId(f), false));</tvectorimagep>

			TVectorImageP dst = src->clone();

			copyStrokeIds(*src, *dst);

			return dst;

		}

		static void cloneImages(LevelImages &levelImages)

		{

			tcg::substitute(levelImages.second, boost::counting_range(0, levelImages.first->getFrameCount()) | boost::adaptors::transformed(boost::bind(cloneImage, boost::cref(*levelImages.first), _1)));

		}

		static void restoreImage(const TXshSimpleLevelP &level, int f, const TVectorImageP &vi)

		{

			level->setFrame(level->getFrameId(f), vi.getPointer());

		}

		static void restoreImages(LevelImages &levelImages)

		{

			int f, fCount = tmin(levelImages.first->getFrameCount(), int(levelImages.second.size()));

			for (f = 0; f != fCount; ++f)

				restoreImage(levelImages.first, f, levelImages.second[f]);

		}

	}; // Undo

	if (levels.empty() || styleIds.empty())

		return;

	std::auto_ptr<tundo> undo(new Undo(levels, styleIds));</tundo>

	if (static_cast<undo &="">(*undo).isValid()) {</undo>

		undo->redo();

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

	}

}

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

// addPage

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

namespace

{

class AddPageUndo : public TUndo

{

	TPaletteHandle *m_paletteHandle;

	TPaletteP m_palette;

	int m_pageIndex;

	wstring m_pageName;

	std::vector<std::pair<tcolorstyle *,="" int="">> m_styles;</std::pair<tcolorstyle>

public:

	// creare DOPO l'inserimento

	AddPageUndo(

		TPaletteHandle *paletteHandle,

		int pageIndex,

		wstring pageName)

		: m_paletteHandle(paletteHandle), m_pageIndex(pageIndex), m_pageName(pageName)

	{

		m_palette = m_paletteHandle->getPalette();

		assert(m_palette);

		assert(0 <= m_pageIndex && m_pageIndex < m_palette->getPageCount());

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

		assert(page);

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

			std::pair<tcolorstyle *,="" int=""> p;</tcolorstyle>

			p.first = page->getStyle(i)->clone();

			p.second = page->getStyleId(i);

			m_styles.push_back(p);

		}

	}

	~AddPageUndo()

	{

		for (int i = 0; i < (int)m_styles.size(); i++)

			delete m_styles[i].first;

	}

	void undo() const

	{

		m_palette->erasePage(m_pageIndex);

		m_paletteHandle->notifyPaletteChanged();

	}

	void redo() const

	{

		TPalette::Page *page = m_palette->addPage(m_pageName);

		assert(page);

		assert(page->getIndex() == m_pageIndex);

		for (int i = 0; i < (int)m_styles.size(); i++) {

			TColorStyle *cs = m_styles[i].first->clone();

			int styleId = m_styles[i].second;

			assert(m_palette->getStylePage(styleId) == 0);

			m_palette->setStyle(styleId, cs);

			page->addStyle(styleId);

		};

		m_paletteHandle->notifyPaletteChanged();

	}

	int getSize() const { return sizeof *this + m_styles.size() * sizeof(TColorStyle); }

	QString getHistoryString()

	{

		return QObject::tr("Add Page %1 to Palette %2")

			.arg(QString::fromStdWString(m_pageName))

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

	}

	int getHistoryType()

	{

		return HistoryType::Palette;

	}

};

} // namespace

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

void PaletteCmd::addPage(TPaletteHandle *paletteHandle, wstring name, bool withUndo)

{

	TPalette *palette = paletteHandle->getPalette();

	if (name == L"")

		name = L"page " + toWideString(palette->getPageCount() + 1);

	TPalette::Page *page = palette->addPage(name);

	palette->setDirtyFlag(true);

	paletteHandle->notifyPaletteChanged();

	if (withUndo)

		TUndoManager::manager()->add(new AddPageUndo(paletteHandle, page->getIndex(), name));

}

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

// destroyPage

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

namespace

{

class DestroyPageUndo : public TUndo

{

	TPaletteHandle *m_paletteHandle;

	TPaletteP m_palette;

	int m_pageIndex;

	wstring m_pageName;

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

public:

	DestroyPageUndo(TPaletteHandle *paletteHandle, int pageIndex)

		: m_paletteHandle(paletteHandle), m_pageIndex(pageIndex)

	{

		m_palette = m_paletteHandle->getPalette();

		assert(m_palette);

		assert(0 <= pageIndex && pageIndex < m_palette->getPageCount());

		assert(m_palette->getPageCount() > 1);

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

		assert(page);

		m_pageName = page->getName();

		m_styles.resize(page->getStyleCount());

		for (int i = 0; i < page->getStyleCount(); i++)

			m_styles[i] = page->getStyleId(i);

	}

	void undo() const

	{

		TPalette::Page *page = m_palette->addPage(m_pageName);

		m_palette->movePage(page, m_pageIndex);

		for (int i = 0; i < (int)m_styles.size(); i++)

			page->addStyle(m_styles[i]);

		m_paletteHandle->notifyPaletteChanged();

	}

	void redo() const

	{

		m_palette->erasePage(m_pageIndex);

		m_paletteHandle->notifyPaletteChanged();

	}

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

	QString getHistoryString()

	{

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

			.arg(QString::fromStdWString(m_pageName))

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

	}

	int getHistoryType()

	{

		return HistoryType::Palette;

	}

};

} // namespace

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

void PaletteCmd::destroyPage(TPaletteHandle *paletteHandle, int pageIndex)

{

	TPalette *palette = paletteHandle->getPalette();

	assert(0 <= pageIndex && pageIndex < palette->getPageCount());

	TUndoManager::manager()->add(new DestroyPageUndo(paletteHandle, pageIndex));

	palette->erasePage(pageIndex);

	palette->setDirtyFlag(true);

	paletteHandle->notifyPaletteChanged();

}

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

// ReferenceImage

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

namespace

{

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

// SetReferenceImageUndo

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

class SetReferenceImageUndo : public TUndo

{

	TPaletteP m_palette;

	TPaletteP m_oldPalette, m_newPalette;

	TPaletteHandle *m_paletteHandle;

public:

	SetReferenceImageUndo(TPaletteP palette, TPaletteHandle *paletteHandle)

		: m_palette(palette), m_oldPalette(palette->clone()), m_paletteHandle(paletteHandle)

	{

	}

	void onAdd()

	{

		m_newPalette = m_palette->clone();

	}

	void undo() const

	{

		m_palette->assign(m_oldPalette.getPointer());

		m_paletteHandle->notifyPaletteChanged();

	}

	void redo() const

	{

		m_palette->assign(m_newPalette.getPointer());

		m_paletteHandle->notifyPaletteChanged();

	}

	int getSize() const

	{

		return sizeof(*this) + sizeof(TPalette) * 2;

	}

	QString getHistoryString()

	{

		return QObject::tr("Load Color Model %1  to Palette %2")

			.arg(QString::fromStdString(m_newPalette->getRefImgPath().getLevelName()))

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

	}

	int getHistoryType()

	{

		return HistoryType::Palette;

	}

};

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

// loadRefImage

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

int loadRefImage(TPaletteHandle *paletteHandle, bool replace,

				 TPaletteP levelPalette, const TFilePath &_fp, int &frame, ToonzScene *scene,

				 const std::vector<int> &frames)</int>

{

	bool paletteAlreadyLoaded = false;