// TnzCore includes

#include "tfilepath.h"

#include "tfiletype.h"

#include "tstream.h"

#include "tsystem.h"

#include "timagecache.h"

#include "tpixelutils.h"

#include "tropcm.h"

#include "timageinfo.h"

#include "timage_io.h"

#include "tlevel_io.h"

#include "tofflinegl.h"

#include "tgl.h"

#include "tvectorrenderdata.h"

#include "tstroke.h"

#include "tthreadmessage.h"

#include "tpalette.h"

#include "trasterimage.h"

#include "tvectorimage.h"

#include "ttoonzimage.h"

#include "tmeshimage.h"

// TnzExt includes

#include "ext/meshutils.h"

// TnzLib includes

#include "toonz/toonzscene.h"

#include "toonz/sceneproperties.h"

#include "toonz/txsheet.h"

#include "toonz/tscenehandle.h"

#include "toonz/txshlevel.h"

#include "toonz/txshleveltypes.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txshchildlevel.h"

#include "toonz/tstageobjectspline.h"

#include "toonz/preferences.h"

#include "toonz/sceneresources.h"

#include "toonz/stage2.h"

// TnzQt includes

#include "toonzqt/gutil.h"

#include "toonzqt/icongenerator.h"

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

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

//

//    Local namespace

//

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

namespace

{

const TDimension IconSize(80, 60);

TDimension FilmstripIconSize(0, 0);

//Access name-based storage

std::set<std::string> iconsMap;</std::string>

typedef std::set<std::string>::iterator IconIterator;</std::string>

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

//Returns true if the image request was already submitted.

bool getIcon(const std::string &iconName, QPixmap &pix, TXshSimpleLevel *simpleLevel = 0)

{

	IconIterator it;

	it = iconsMap.find(iconName);

	if (it != iconsMap.end()) {

		TImageP im = TImageCache::instance()->get(iconName, false);

		TToonzImage *timgp = dynamic_cast<ttoonzimage *="">(im.getPointer());</ttoonzimage>

		if (simpleLevel && timgp) {

			IconGenerator::Settings settings = IconGenerator::instance()->getSettings();

			TRaster32P icon(timgp->getSize());

			icon->clear();

			icon->fill((settings.m_blackBgCheck) ? TPixel::Black : TPixel::White);

			if (settings.m_transparencyCheck ||

				settings.m_inkIndex != -1 ||

				settings.m_paintIndex != -1) {

				TRop::CmappedQuickputSettings s;

				s.m_globalColorScale = TPixel32::Black;

				s.m_inksOnly = false;

				s.m_transparencyCheck = settings.m_transparencyCheck;

				s.m_blackBgCheck = settings.m_blackBgCheck;

				s.m_inkIndex = settings.m_inkIndex;

				s.m_paintIndex = settings.m_paintIndex;

				Preferences::instance()->getTranspCheckData(s.m_transpCheckBg, s.m_transpCheckInk, s.m_transpCheckPaint);

				TRop::quickPut(icon, timgp->getRaster(), simpleLevel->getPalette(), TAffine(), s);

			} else

				TRop::quickPut(icon, timgp->getRaster(), simpleLevel->getPalette(), TAffine());

			pix = rasterToQPixmap(icon, false);

			return true;

		}

		TRasterImageP img = static_cast<trasterimagep>(im);</trasterimagep>

		if (!img) {

			pix = QPixmap();

			return true;

		}

		assert(!(TRasterGR8P)img->getRaster());

		const TRaster32P &ras = img->getRaster();

		pix = rasterToQPixmap(ras, false);

		return true;

	}

	return false;

}

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

void setIcon(const std::string &iconName, const TRaster32P &icon)

{

	if (iconsMap.find(iconName) != iconsMap.end())

		TImageCache::instance()->add(iconName, TRasterImageP(icon), true);

}

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

/*! Cache icon data in TToonzImage format if ToonzImageIconRenderer generates them

*/

void setIcon_TnzImg(const std::string &iconName, const TRasterCM32P &icon)

{

	if (iconsMap.find(iconName) != iconsMap.end())

		TImageCache::instance()->add(iconName, TToonzImageP(icon, TRect(icon->getSize())), true);

}

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

void removeIcon(const std::string &iconName)

{

	IconIterator it;

	it = iconsMap.find(iconName);

	if (it != iconsMap.end()) {

		TImageCache::instance()->remove(iconName);

	}

	iconsMap.erase(iconName);

}

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

bool isUnpremultiplied(const TRaster32P &r)

{

	int lx = r->getLx();

	int y = r->getLy();

	r->lock();

	while (--y >= 0) {

		TPixel32 *pix = r->pixels(y);

		TPixel32 *endPix = pix + lx;

		while (pix < endPix) {

			if (pix->r > pix->m ||

				pix->g > pix->m ||

				pix->b > pix->m) {

				r->unlock();

				return true;

			}

			++pix;

		}

	}

	r->unlock();

	return false;

}

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

void makeChessBackground(const TRaster32P &ras)

{

	ras->lock();

	const TPixel32 gray1(230, 230, 230, 255), gray2(180, 180, 180, 255);

	int lx = ras->getLx(), ly = ras->getLy();

	for (int y = 0; y != ly; ++y) {

		TPixel32 *pix = ras->pixels(y), *lineEnd = pix + lx;

		int yCol = (y & 4);

		for (int x = 0; pix != lineEnd; ++x, ++pix)

			if (pix->m != 255)

				*pix = overPix((x & 4) == yCol ? gray1 : gray2, *pix);

	}

	ras->unlock();

}

} // namespace

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

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

//

//    Image-to-Icon convertion methods

//

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

namespace

{

TRaster32P convertToIcon(

	TVectorImageP vimage,

	int frame,

	const TDimension &iconSize,

	const IconGenerator::Settings &settings)

{

	if (!vimage)

		return TRaster32P();

	TPalette *plt = vimage->getPalette()->clone();

	if (!plt)

		return TRaster32P();

	plt->setFrame(frame);

	TOfflineGL *glContext = IconGenerator::instance()->getOfflineGLContext();

	// l'immagine e' contenuta dentro imageBox (aggiungo un piccolo margine anche

	// per evitare problemi con immagini vuote)

	TRectD imageBox;

	{

		QMutexLocker sl(vimage->getMutex());

		imageBox = vimage->getBBox().enlarge(.1);

	}

	TPointD imageCenter = (imageBox.getP00() + imageBox.getP11()) * 0.5;

	// calcolo una matrice di trasformazione che sposti l'immagine dentro l'icona.

	// il fattore di scala e' scelto in modo che l'immagine sia interamente

	// contenuta nell'icona (con un margine di 'margin' pixel)

	const int margin = 10;

	double scx = (iconSize.lx - margin) / imageBox.getLx();

	double scy = (iconSize.ly - margin) / imageBox.getLy();

	double sc = std::min(scx, scy);

	// aggiungo la traslazione: il punto centrale dell'immagine va nel punto

	// centrale della pixmap

	TPointD iconCenter(iconSize.lx * 0.5, iconSize.ly * 0.5);

	TAffine aff = TScale(sc).place(imageCenter, iconCenter);

	// RenderData

	TVectorRenderData rd(

		aff,

		TRect(iconSize),

		plt,

		0, true);

	rd.m_tcheckEnabled = settings.m_transparencyCheck;

	rd.m_blackBgEnabled = settings.m_blackBgCheck;

	rd.m_drawRegions = !settings.m_inksOnly;

	rd.m_inkCheckEnabled = settings.m_inkIndex != -1;

	rd.m_paintCheckEnabled = settings.m_paintIndex != -1;

	rd.m_colorCheckIndex = rd.m_inkCheckEnabled ? settings.m_inkIndex : settings.m_paintIndex;

	rd.m_isIcon = true;

	// disegno l'immagine

	glContext->makeCurrent();

	glContext->clear(rd.m_blackBgEnabled ? TPixel::Black : TPixel32::White);

	glContext->draw(vimage, rd);

	TRaster32P ras(iconSize);

	glContext->getRaster(ras);

	glContext->doneCurrent();

	delete plt;

	return ras;

}

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

TRaster32P convertToIcon(

	TToonzImageP timage,

	int frame,

	const TDimension &iconSize,

	const IconGenerator::Settings &settings)

{

	if (!timage)

		return TRaster32P();

	TPalette *plt = timage->getPalette();

	if (!plt)

		return TRaster32P();

	plt->setFrame(frame);

	TRasterCM32P rasCM32 = timage->getRaster();

	if (!rasCM32.getPointer())

		return TRaster32P();

	int lx = rasCM32->getSize().lx;

	int ly = rasCM32->getSize().ly;

	int iconLx = iconSize.lx, iconLy = iconSize.ly;

	if (std::max(double(lx) / iconSize.lx, double(ly) / iconSize.ly) == double(ly) / iconSize.ly)

		iconLx = tround((double(lx) * iconSize.ly) / ly);

	else

		iconLy = tround((double(ly) * iconSize.lx) / lx);

	TDimension iconSize2 = TDimension(iconLx, iconLy); // dimensione dell'icona con aspectRatio esatto

	TRaster32P icon(iconSize2);

	icon->clear();

	icon->fill(settings.m_blackBgCheck ? TPixel::Black : TPixel::White);

	TDimension dim = rasCM32->getSize();

	if (dim != iconSize2) {

		TRasterCM32P auxCM32(icon->getSize());

		auxCM32->clear();

		TRop::makeIcon(auxCM32, rasCM32);

		rasCM32 = auxCM32;

	}

	if (settings.m_transparencyCheck ||

		settings.m_inksOnly ||

		settings.m_inkIndex != -1 ||

		settings.m_paintIndex != -1) {

		TRop::CmappedQuickputSettings s;

		s.m_globalColorScale = TPixel32::Black;

		s.m_inksOnly = settings.m_inksOnly;

		s.m_transparencyCheck = settings.m_transparencyCheck;

		s.m_blackBgCheck = settings.m_blackBgCheck;

		s.m_inkIndex = settings.m_inkIndex;

		s.m_paintIndex = settings.m_paintIndex;

		Preferences::instance()->getTranspCheckData(s.m_transpCheckBg, s.m_transpCheckInk, s.m_transpCheckPaint);

		TRop::quickPut(icon, rasCM32, timage->getPalette(), TAffine(), s);

	} else

		TRop::quickPut(icon, rasCM32, timage->getPalette(), TAffine());

	assert(iconSize2.lx <= iconSize.lx && iconSize2.ly <= iconSize.ly);

	TRaster32P outIcon(iconSize);

	outIcon->clear();

	int dx = (outIcon->getLx() - icon->getLx()) / 2;

	int dy = (outIcon->getLy() - icon->getLy()) / 2;

	assert(dx >= 0 && dy >= 0);

	TRect box = outIcon->getBounds().enlarge(-dx, -dy);

	TRop::copy(outIcon->extract(box), icon);

	return outIcon;

}

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

TRaster32P convertToIcon(

	TRasterImageP rimage,

	const TDimension &iconSize)

{

	if (!rimage)

		return TRaster32P();

	TRasterP ras = rimage->getRaster();

	if (!(TRaster32P)ras && !(TRasterGR8P)ras)

		return TRaster32P();

	if (ras->getSize() == iconSize)

		return ras;

	TRaster32P icon(iconSize);

	icon->fill(TPixel32(235, 235, 235));

	double sx = (double)icon->getLx() / ras->getLx();

	double sy = (double)icon->getLy() / ras->getLy();

	double sc = sx < sy ? sx : sy;

	TAffine aff = TScale(sc).place(ras->getCenterD(), icon->getCenterD());

	TRop::resample(icon, ras, aff, TRop::Bilinear);

	TRop::addBackground(icon, TPixel32::White);

	return icon;

}

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

TRaster32P convertToIcon(

	TMeshImageP mi,

	int frame,

	const TDimension &iconSize,

	const IconGenerator::Settings &settings)

{

	if (!mi)

		return TRaster32P();

	TOfflineGL *glContext = IconGenerator::instance()->getOfflineGLContext();

	// l'immagine e' contenuta dentro imageBox (aggiungo un piccolo margine anche

	// per evitare problemi con immagini vuote)

	TRectD imageBox;

	imageBox = mi->getBBox().enlarge(.1);

	TPointD imageCenter(0.5 * (imageBox.getP00() + imageBox.getP11()));

	// calcolo una matrice di trasformazione che sposti l'immagine dentro l'icona.

	// il fattore di scala e' scelto in modo che l'immagine sia interamente

	// contenuta nell'icona (con un margine di 'margin' pixel)

	const int margin = 10;

	double scx = (iconSize.lx - margin) / imageBox.getLx();

	double scy = (iconSize.ly - margin) / imageBox.getLy();

	double sc = std::min(scx, scy);

	// aggiungo la traslazione: il punto centrale dell'immagine va nel punto

	// centrale della pixmap

	TPointD iconCenter(iconSize.lx * 0.5, iconSize.ly * 0.5);

	TAffine aff = TScale(sc).place(imageCenter, iconCenter);

	// disegno l'immagine

	glContext->makeCurrent();

	glContext->clear(settings.m_blackBgCheck ? TPixel::Black : TPixel32::White);

	glPushAttrib(GL_ENABLE_BIT | GL_COLOR_BUFFER_BIT);

	glEnable(GL_BLEND);

	glEnable(GL_LINE_SMOOTH);

	glPushMatrix();

	tglMultMatrix(aff);

	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

	glColor4f(0.0f, 1.0f, 0.0f, 0.7f);

	tglDrawEdges(*mi);

	glPopMatrix();

	glPopAttrib();

	TRaster32P ras(iconSize);

	glContext->getRaster(ras);

	glContext->doneCurrent();

	return ras;

}

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

TRaster32P convertToIcon(

	TImageP image,

	int frame,

	const TDimension &iconSize,

	const IconGenerator::Settings &settings)

{

	TRasterImageP ri(image);

	if (ri)

		return convertToIcon(ri, iconSize);

	TToonzImageP ti(image);

	if (ti)

		return convertToIcon(ti, frame, iconSize, settings);

	TVectorImageP vi(image);

	if (vi)

		return convertToIcon(vi, frame, iconSize, settings);

	TMeshImageP mi(image);

	if (mi)

		return convertToIcon(mi, frame, iconSize, settings);

	return TRaster32P();

}

} // namespace

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

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

//

//    IconRenderer class

//

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

class IconRenderer : public TThread::Runnable

{

	TRaster32P m_icon;

	TDimension m_iconSize;

	std::string m_id;

	bool m_started;

	bool m_terminated;

public:

	IconRenderer(const std::string &id, const TDimension &iconSize);

	virtual ~IconRenderer();

	virtual void run() = 0;

	void setIcon(const TRaster32P &icon) { m_icon = icon; }

	TRaster32P getIcon() const { return m_icon; }

	TDimension getIconSize() { return m_iconSize; }

	const std::string &getId() const { return m_id; }

	bool &hasStarted() { return m_started; }

	bool &wasTerminated() { return m_terminated; }

};

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

IconRenderer::IconRenderer(const std::string &id, const TDimension &iconSize)

	: m_icon(), m_iconSize(iconSize), m_id(id), m_started(false), m_terminated(false)

{

	connect(this, SIGNAL(started(TThread::RunnableP)), IconGenerator::instance(), SLOT(onStarted(TThread::RunnableP)));

	connect(this, SIGNAL(finished(TThread::RunnableP)), IconGenerator::instance(), SLOT(onFinished(TThread::RunnableP)));

	connect(this, SIGNAL(canceled(TThread::RunnableP)), IconGenerator::instance(), SLOT(onCanceled(TThread::RunnableP)),

			Qt::QueuedConnection);

	connect(this, SIGNAL(terminated(TThread::RunnableP)), IconGenerator::instance(), SLOT(onTerminated(TThread::RunnableP)),

			Qt::QueuedConnection);

}

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

IconRenderer::~IconRenderer()

{

}

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

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

//

//    Specific icon renderers

//

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

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

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

//    VectorImageIconRenderer class

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

class VectorImageIconRenderer : public IconRenderer

{

	TVectorImageP m_vimage;

	TXshSimpleLevelP m_sl;

	TFrameId m_fid;

	IconGenerator::Settings m_settings;

public:

	VectorImageIconRenderer(

		const std::string &id,

		const TDimension &iconSize,

		TXshSimpleLevelP sl,

		const TFrameId &fid,

		const IconGenerator::Settings &settings)

		: IconRenderer(id, iconSize), m_vimage(), m_sl(sl), m_fid(fid), m_settings(settings) {}

	VectorImageIconRenderer(

		const std::string &id,

		const TDimension &iconSize,

		TVectorImageP vimage,

		const IconGenerator::Settings &settings)

		: IconRenderer(id, iconSize), m_vimage(vimage), m_sl(0), m_fid(-1), m_settings(settings) {}

	TRaster32P generateRaster(const TDimension &iconSize) const;

	void run();

};

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

TRaster32P VectorImageIconRenderer::generateRaster(const TDimension &iconSize) const

{

	TVectorImageP vimage;

	int frame = 0;

	if (!m_vimage) {

		assert(m_sl);

		if (!m_sl->isFid(m_fid))

			return TRaster32P();

		TImageP image = m_sl->getFrameIcon(m_fid);

		if (!image)

			return TRaster32P();

		vimage = (TVectorImageP)image;

		if (!vimage)

			return TRaster32P();

		frame = m_sl->guessIndex(m_fid);

	} else

		vimage = m_vimage;

	assert(vimage);

	TRaster32P ras(convertToIcon(vimage, frame, iconSize, m_settings));

	return ras;

}

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

void VectorImageIconRenderer::run()

{

	try {

		TRaster32P ras(generateRaster(getIconSize()));

		if (ras)

			setIcon(ras);

	} catch (...) {

	}

}

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

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

//    SplineImageIconRenderer class

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

class SplineIconRenderer : public IconRenderer

{

	TStageObjectSpline *m_spline;

public:

	SplineIconRenderer(const std::string &id, const TDimension &iconSize, TStageObjectSpline *spline)

		: IconRenderer(id, iconSize), m_spline(spline) {}

	TRaster32P generateRaster(const TDimension &iconSize) const;

	void run();

};

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

TRaster32P SplineIconRenderer::generateRaster(const TDimension &iconSize) const

{

	//get the glContext

	TOfflineGL *glContext = IconGenerator::instance()->getOfflineGLContext();

	glContext->makeCurrent();

	glContext->clear(TPixel32::White);

	const TStroke *stroke = m_spline->getStroke();

	assert(stroke);

	if (!stroke)

		return TRaster32P();

	TRectD sbbox = stroke->getBBox();

	glColor3d(0, 0, 0);

	double scaleX = 1, scaleY = 1;

	if (sbbox.getLx() > 0.0)

		scaleX = (double)iconSize.lx / sbbox.getLx();

	if (sbbox.getLy() > 0.0)

		scaleY = (double)iconSize.ly / sbbox.getLy();

	double scale = 0.8 * std::min(scaleX, scaleY);

	TPointD centerStroke = 0.5 * (sbbox.getP00() + sbbox.getP11());

	TPointD centerPixmap(iconSize.lx * 0.5, iconSize.ly * 0.5);

	glPushMatrix();

	tglMultMatrix(TScale(scale).place(centerStroke, centerPixmap));

	int n = 50;

	glBegin(GL_LINE_STRIP);

	for (int i = 0; i < n; i++)

		tglVertex(stroke->getPoint((double)i / (double)(n - 1)));

	glEnd();

	glPopMatrix();

	TRaster32P ras(iconSize);

	glContext->getRaster(ras);

	glContext->doneCurrent();

	return ras;

}

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

void SplineIconRenderer::run()

{

	TRaster32P raster = generateRaster(getIconSize());

	if (raster)

		setIcon(raster);

}

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

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

//    RasterImageIconRenderer class

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

class RasterImageIconRenderer : public IconRenderer

{

	TXshSimpleLevelP m_sl;

	TFrameId m_fid;

public:

	RasterImageIconRenderer(

		const std::string &id,

		const TDimension &iconSize,

		TXshSimpleLevelP sl,

		const TFrameId &fid)

		: IconRenderer(id, iconSize),

		  m_sl(sl),

		  m_fid(fid) {}

	void run();

};

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

void RasterImageIconRenderer::run()

{

	if (!m_sl->isFid(m_fid))

		return;

	TImageP image = m_sl->getFrameIcon(m_fid);

	if (!image)

		return;

	TRasterImageP rimage = (TRasterImageP)image;

	assert(rimage);

	TRaster32P icon(convertToIcon(rimage, getIconSize()));

	if (icon)

		setIcon(icon);

}

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

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

//    ToonzImageIconRenderer class

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

class ToonzImageIconRenderer : public IconRenderer

{

	TXshSimpleLevelP m_sl;

	TFrameId m_fid;

	IconGenerator::Settings m_settings;

	TRasterCM32P m_tnzImgIcon;

public:

	ToonzImageIconRenderer(

		const std::string &id,

		const TDimension &iconSize,

		TXshSimpleLevelP sl,

		const TFrameId &fid,

		const IconGenerator::Settings &settings)

		: IconRenderer(id, iconSize), m_sl(sl), m_fid(fid), m_settings(settings), m_tnzImgIcon(0) {}

	void run();

	void setIcon_TnzImg(const TRasterCM32P &timgp) { m_tnzImgIcon = timgp; }

	TRasterCM32P getIcon_TnzImg() const { return m_tnzImgIcon; }

};

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

void ToonzImageIconRenderer::run()

{

	if (!m_sl->isFid(m_fid))

		return;

	TImageP image = m_sl->getFrameIcon(m_fid);

	if (!image)

		return;

	TRasterImageP rimage(image);

	if (rimage) {

		TRaster32P icon(convertToIcon(rimage, getIconSize()));

		if (icon)

			setIcon(icon);

		return;

	}

	TToonzImageP timage = (TToonzImageP)image;

	TDimension iconSize(getIconSize());

	if (!timage) {

		TRaster32P p(iconSize.lx, iconSize.ly);

		p->fill(TPixelRGBM32::Yellow);

		setIcon(p);

		return;

	}

	TRasterCM32P rasCM32 = timage->getRaster();

	if (!rasCM32.getPointer())

		return;

	int lx = rasCM32->getSize().lx;

	int ly = rasCM32->getSize().ly;

	int iconLx = iconSize.lx, iconLy = iconSize.ly;

	TRaster32P icon(iconSize);

	icon->fill(m_settings.m_blackBgCheck ? TPixel::Black : TPixel::White);

	if (lx != iconLx && ly != iconLy) {

		// The icons stored in the tlv file don't have the required size.

		// Fetch the original and iconize it.

		image = m_sl->getFrame(m_fid, ImageManager::dontPutInCache, 0); // 0 uses the level properties' subsampling

		if (!image)

			return;

		timage = (TToonzImageP)image;

		if (!timage) {

			TRaster32P p(iconSize.lx, iconSize.ly);

			p->fill(TPixelRGBM32::Yellow);

			setIcon(p);

			return;

		}

		rasCM32 = timage->getRaster();

		if (!rasCM32.getPointer())

			return;

		TRasterCM32P auxCM32(icon->getSize());

		auxCM32->clear();

		TRop::makeIcon(auxCM32, rasCM32);

		rasCM32 = auxCM32;

	}

	if (!m_sl->getPalette())

		return;

	TPaletteP plt = m_sl->getPalette()->clone();

	if (!plt)

		return;

	int frame = m_sl->guessIndex(m_fid);

	plt->setFrame(frame);

	setIcon_TnzImg(rasCM32);

}

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

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

//    MeshImageIconRenderer class

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

class MeshImageIconRenderer : public IconRenderer

{

	TMeshImageP m_image;

	TXshSimpleLevelP m_sl;

	TFrameId m_fid;

	IconGenerator::Settings m_settings;

public:

	MeshImageIconRenderer(

		const std::string &id,

		const TDimension &iconSize,

		TXshSimpleLevelP sl,

		const TFrameId &fid,

		const IconGenerator::Settings &settings)

		: IconRenderer(id, iconSize), m_image(), m_sl(sl), m_fid(fid), m_settings(settings) {}

	MeshImageIconRenderer(

		const std::string &id,

		const TDimension &iconSize,

		TMeshImageP image,

		const IconGenerator::Settings &settings)

		: IconRenderer(id, iconSize), m_image(image), m_sl(0), m_fid(-1), m_settings(settings) {}

	TRaster32P generateRaster(const TDimension &iconSize) const;

	void run();

};

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

TRaster32P MeshImageIconRenderer::generateRaster(const TDimension &iconSize) const

{

	TMeshImageP mi;

	int frame = 0;

	if (!m_image) {

		assert(m_sl);

		if (!m_sl->isFid(m_fid))

			return TRaster32P();

		TImageP image = m_sl->getFrameIcon(m_fid);

		if (!image)

			return TRaster32P();

		mi = (TMeshImageP)image;

		if (!mi)

			return TRaster32P();

		frame = m_sl->guessIndex(m_fid);

	} else

		mi = m_image;

	assert(mi);

	return convertToIcon(mi, frame, iconSize, m_settings);

}