#include "toonz/txshsimplelevel.h"

#include "imagebuilders.h"

// TnzLib includes

#include "toonz/txshleveltypes.h"

#include "toonz/imagemanager.h"

#include "toonz/studiopalette.h"

#include "toonz/hook.h"

#include "toonz/toonzscene.h"

#include "toonz/levelproperties.h"

#include "toonz/levelupdater.h"

#include "toonz/fullcolorpalette.h"

#include "toonz/preferences.h"

#include "toonz/stage.h"

#include "toonz/textureutils.h"

#include "toonz/levelset.h"

// TnzBase includes

#include "tenv.h"

// TnzCore includes

#include "trasterimage.h"

#include "tvectorimage.h"

#include "tmeshimage.h"

#include "timagecache.h"

#include "tofflinegl.h"

#include "tvectorgl.h"

#include "tvectorrenderdata.h"

#include "tropcm.h"

#include "tpixelutils.h"

#include "timageinfo.h"

#include "tlogger.h"

#include "tstream.h"

#include "tsystem.h"

#include "tcontenthistory.h"

// Qt includes

#include <qdir></qdir>

#include <qregexp></qregexp>

#include <qmessagebox></qmessagebox>

#include "../common/psdlib/psd.h"

namespace bc = boost::container;

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

//    Global stuff

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

DEFINE_CLASS_CODE(TXshSimpleLevel, 20)

PERSIST_IDENTIFIER(TXshSimpleLevel, "level")

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

//    Local namespace stuff

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

namespace

{

int idBaseCode = 1;

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

struct CompatibilityStruct {

	int writeMask, neededMask, forbiddenMask;

};

CompatibilityStruct compatibility =

	{

		0x00F1, // mask written.   Note: Student main must be 0x00F2

				//                 Note: the 0x00F0 part is currently not used.

		0x0000, // mandatory mask: loaded levels MUST have a mask with these bits set

				//                 Note: if mandatory mask != 0 then no old level (without mask)

				//                       can be loaded

				//                 Note: this mask is currently not used.

		0x000E  // forbidden mask: loaded levels MUST NOT have a mask with these bits set

		//

};

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

inline std::string rasterized(std::string id) { return id + "_rasterized"; }

inline std::string filled(std::string id) { return id + "_filled"; }

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

QString getCreatorString()

{

	QString creator =

		QString::fromStdString(TEnv::getApplicationName()) + " " +

		QString::fromStdString(TEnv::getApplicationVersion()) +

		" CM(" + QString::number(compatibility.writeMask, 16) + ")";

	return creator;

}

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

bool checkCreatorString(const QString &creator)

{

	int mask = 0;

	if (creator != "") {

		QRegExp rx("CM\\([0-9A-Fa-f]*\\)");

		int pos = rx.indexIn(creator);

		int len = rx.matchedLength();

		if (pos >= 0 && len >= 4) {

			QString v;

			if (len > 4)

				v = creator.mid(pos + 3, len - 4);

			bool ok = true;

			mask = v.toInt(&ok, 16);

		}

	}

	return (mask & compatibility.neededMask) == compatibility.neededMask &&

		   (mask & compatibility.forbiddenMask) == 0;

}

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

bool isAreadOnlyLevel(const TFilePath &path)

{

	if (path.isEmpty() || !path.isAbsolute())

		return false;

	if (path.getDots() == "." || (path.getDots() == ".." && (path.getType() == "tlv" || path.getType() == "tpl"))) {

		if (!TSystem::doesExistFileOrLevel(path))

			return false;

		TFileStatus fs(path);

		return !fs.isWritable();

	}

	/*- 処理が重くなるので、連番ファイルは全てfalseを返す -*/

	/*

  else if(path.getDots() == "..")

  {

    TFilePath dir = path.getParentDir();

    QDir qDir(QString::fromStdWString(dir.getWideString()));

    QString levelName = QRegExp::escape(QString::fromStdWString(path.getWideName()));

    QString levelType = QString::fromStdString(path.getType());

    QString exp(levelName+".[0-9]{1,4}."+levelType);

    QRegExp regExp(exp);

    QStringList list = qDir.entryList(QDir::Files);

    QStringList livelFrames = list.filter(regExp);

    bool isReadOnly=false;

    int i;

    for(i=0; i

    {

      TFilePath frame = dir+TFilePath(livelFrames[i].toStdWString());

      if(frame.isEmpty() || !frame.isAbsolute()) continue;

      TFileStatus fs(frame);

      isReadOnly = !fs.isWritable();

    }

    return isReadOnly;

  }

  */

	else

		return false;

}

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

void getIndexesRangefromFids(

	TXshSimpleLevel *level, const std::set<tframeid> &fids, int &fromIndex, int &toIndex)</tframeid>

{

	if (fids.empty()) {

		fromIndex = toIndex = -1;

		return;

	}

	toIndex = 0;

	fromIndex = level->getFrameCount() - 1;

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

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

		int index = level->guessIndex(*it);

		if (index > toIndex)

			toIndex = index;

		if (index < fromIndex)

			fromIndex = index;

	}

}

} // namespace

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

//    TXshSimpleLevel  impementation

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

bool TXshSimpleLevel::m_rasterizePli = false;

bool TXshSimpleLevel::m_fillFullColorRaster = false;

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

TXshSimpleLevel::TXshSimpleLevel(const std::wstring &name)

	: TXshLevel(m_classCode, name), m_properties(new LevelProperties), m_palette(0), m_idBase(toString(idBaseCode++)), m_editableRangeUserInfo(L""), m_isSubsequence(false), m_16BitChannelLevel(false), m_isReadOnly(false), m_temporaryHookMerged(false)

{

}

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

TXshSimpleLevel::~TXshSimpleLevel()

{

	clearFrames();

	if (m_palette)

		m_palette->release();

}

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

void TXshSimpleLevel::setEditableRange(unsigned int from, unsigned int to, const std::wstring &userName)

{

	assert(from <= to && to < (unsigned int)getFrameCount());

	unsigned int i;

	for (i = from; i <= to; i++)

		m_editableRange.insert(index2fid(i));

	QString hostName = TSystem::getHostName();

	m_editableRangeUserInfo = userName + L"_" + hostName.toStdWString();

	std::wstring fileName = getEditableFileName();

	TFilePath dstPath = getScene()->decodeFilePath(m_path);

	dstPath = dstPath.withName(fileName).withType(dstPath.getType());

	// Load temporary level file (for pli and tlv types only)

	if (getType() != OVL_XSHLEVEL && TSystem::doesExistFileOrLevel(dstPath)) {

		TLevelReaderP lr(dstPath);

		TLevelP level = lr->loadInfo();

		setPalette(level->getPalette());

		for (TLevel::Iterator it = level->begin(); it != level->end(); it++) {

			TImageP img = lr->getFrameReader(it->first)->load();

			setFrame(it->first, img);

		}

	}

	// Merge temporary hook file with current hookset

	const TFilePath &hookFile = getHookPath(dstPath);

	mergeTemporaryHookFile(from, to, hookFile);

}

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

void TXshSimpleLevel::mergeTemporaryHookFile(unsigned int from, unsigned int to, const TFilePath &hookFile)

{

	if (!TFileStatus(hookFile).doesExist())

		return;

	HookSet *tempHookSet = new HookSet;

	TIStream is(hookFile);

	std::string tagName;

	try {

		if (is.matchTag(tagName) && tagName == "hooks")

			tempHookSet->loadData(is);

	} catch (...) {

	}

	HookSet *hookSet = getHookSet();

	int tempHookCount = tempHookSet->getHookCount();

	if (tempHookCount == 0) {

		for (unsigned int f = from; f <= to; f++) {

			TFrameId fid = index2fid(f);

			hookSet->eraseFrame(fid);

		}

	} else {

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

			Hook *hook = tempHookSet->getHook(i);

			Hook *newHook = hookSet->touchHook(hook->getId());

			newHook->setTrackerObjectId(hook->getTrackerObjectId());

			newHook->setTrackerRegionHeight(hook->getTrackerRegionHeight());

			newHook->setTrackerRegionWidth(hook->getTrackerRegionWidth());

			for (unsigned int f = from; f <= to; f++) {

				TFrameId fid = index2fid(f);

				newHook->setAPos(fid, hook->getAPos(fid));

				newHook->setBPos(fid, hook->getBPos(fid));

			}

		}

	}

	m_temporaryHookMerged = true;

}

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

void TXshSimpleLevel::clearEditableRange()

{

	m_editableRange.clear();

	m_editableRangeUserInfo = L"";

}

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

std::wstring TXshSimpleLevel::getEditableFileName()

{

#ifdef MACOSX

	std::wstring fileName = L"." + m_path.getWideName();

#else

	std::wstring fileName = m_path.getWideName();

#endif

	fileName += L"_" + m_editableRangeUserInfo;

	int from, to;

	getIndexesRangefromFids(this, m_editableRange, from, to);

	if (from == -1 && to == -1)

		return L"";

	fileName += L"_" + toWideString(from + 1) + L"-" + toWideString(to + 1);

	return fileName;

}

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

std::set<tframeid> TXshSimpleLevel::getEditableRange()</tframeid>

{

	return m_editableRange;

}

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

void TXshSimpleLevel::setRenumberTable()

{

	m_renumberTable.clear();

	FramesSet::iterator ft, fEnd = m_frames.end();

	for (ft = m_frames.begin(); ft != fEnd; ++ft)

		m_renumberTable[*ft] = *ft;

}

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

void TXshSimpleLevel::setDirtyFlag(bool on)

{

	m_properties->setDirtyFlag(on);

}

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

bool TXshSimpleLevel::getDirtyFlag() const

{

	return m_properties->getDirtyFlag();

}

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

void TXshSimpleLevel::touchFrame(const TFrameId &fid)

{

	m_properties->setDirtyFlag(true);

	TContentHistory *ch = getContentHistory();

	if (!ch) {

		ch = new TContentHistory(true);

		setContentHistory(ch);

	}

	ch->frameModifiedNow(fid);

	if (getType() == PLI_XSHLEVEL) {

		std::string id = rasterized(getImageId(fid));

		ImageManager::instance()->invalidate(id);

	}

	if (getType() & FULLCOLOR_TYPE) {

		std::string id = filled(getImageId(fid));

		ImageManager::instance()->invalidate(id);

	}

}

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

void TXshSimpleLevel::onPaletteChanged()

{

	FramesSet::iterator ft, fEnd = m_frames.end();

	for (ft = m_frames.begin(); ft != fEnd; ++ft) {

		const TFrameId &fid = *ft;

		if (getType() == PLI_XSHLEVEL) {

			std::string id = rasterized(getImageId(fid));

			ImageManager::instance()->invalidate(id);

		}

		if (getType() & FULLCOLOR_TYPE) {

			std::string id = filled(getImageId(fid));

			ImageManager::instance()->invalidate(id);

		}

		texture_utils::invalidateTexture(this, fid);

	}

}

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

void TXshSimpleLevel::setScannedPath(const TFilePath &fp)

{

	m_scannedPath = fp;

}

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

void TXshSimpleLevel::setPath(const TFilePath &fp, bool keepFrames)

{

	m_path = fp;

	if (!keepFrames) {

		clearFrames();

		assert(getScene());

		try {

			load();

		} catch (...) {

		}

	}

	if (getType() != PLI_XSHLEVEL) {

		if (!m_frames.empty()) {

			std::string imageId = getImageId(getFirstFid());

			const TImageInfo *imageInfo = ImageManager::instance()->getInfo(imageId, ImageManager::none, 0);

			if (imageInfo) {

				TDimension imageRes(0, 0);

				TPointD imageDpi;

				imageRes.lx = imageInfo->m_lx;

				imageRes.ly = imageInfo->m_ly;

				imageDpi.x = imageInfo->m_dpix;

				imageDpi.y = imageInfo->m_dpiy;

				m_properties->setImageDpi(imageDpi);

				m_properties->setImageRes(imageRes);

				m_properties->setBpp(imageInfo->m_bitsPerSample * imageInfo->m_samplePerPixel);

			}

		}

	}

}

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

void TXshSimpleLevel::clonePropertiesFrom(const TXshSimpleLevel *oldSl)

{

	m_properties->setImageDpi(oldSl->m_properties->getImageDpi()); // Watch out - may change dpi policy!

	m_properties->setDpi(oldSl->m_properties->getDpi());

	m_properties->setDpiPolicy(oldSl->m_properties->getDpiPolicy());

	m_properties->setImageRes(oldSl->m_properties->getImageRes());

	m_properties->setBpp(oldSl->m_properties->getBpp());

	m_properties->setSubsampling(oldSl->m_properties->getSubsampling());

}

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

TPalette *TXshSimpleLevel::getPalette() const

{

	return m_palette;

}

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

void TXshSimpleLevel::setPalette(TPalette *palette)

{

	if (m_palette != palette) {

		if (m_palette)

			m_palette->release();

		m_palette = palette;

		if (m_palette) {

			m_palette->addRef();

			if (!(getType() & FULLCOLOR_TYPE))

				m_palette->setPaletteName(getName());

		}

	}

}

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

void TXshSimpleLevel::getFids(std::vector<tframeid> &fids) const</tframeid>

{

	fids.assign(m_frames.begin(), m_frames.end());

}

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

std::vector<tframeid> TXshSimpleLevel::getFids() const</tframeid>

{

	return std::vector<tframeid>(m_frames.begin(), m_frames.end());</tframeid>

}

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

bool TXshSimpleLevel::isFid(const TFrameId &fid) const

{

	return m_frames.count(fid);

}

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

const TFrameId &TXshSimpleLevel::getFrameId(int index) const

{

	return *(m_frames.begin() += index);

}

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

TFrameId TXshSimpleLevel::getFirstFid() const

{

	return !isEmpty() ? *m_frames.begin() : TFrameId(TFrameId::NO_FRAME);

}

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

TFrameId TXshSimpleLevel::getLastFid() const

{

	return !isEmpty() ? *m_frames.rbegin() : TFrameId(TFrameId::NO_FRAME);

}

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

int TXshSimpleLevel::guessStep() const

{

	int frameCount = m_frames.size();

	if (frameCount < 2)

		return 1; // un livello con zero o un frame ha per def. step=1

	FramesSet::const_iterator ft = m_frames.begin();

	TFrameId firstFid = *ft++,

			 secondFid = *ft++;

	if (firstFid.getLetter() != 0 || secondFid.getLetter() != 0)

		return 1;

	int step = secondFid.getNumber() - firstFid.getNumber();

	if (step == 1)

		return 1;

	// controllo subito se lo step vale per l'ultimo frame

	// (cerco di limitare il numero di volte in cui devo controllare tutta la lista)

	TFrameId lastFid = *m_frames.rbegin();

	if (lastFid.getLetter() != 0)

		return 1;

	if (lastFid.getNumber() != firstFid.getNumber() + step * (frameCount - 1))

		return 1;

	for (int i = 2; ft != m_frames.end(); ++ft, ++i) {

		const TFrameId &fid = *ft;

		if (fid.getLetter() != 0)

			return 1;

		if (fid.getNumber() != firstFid.getNumber() + step * i)

			return 1;

	}

	return step;

}

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

int TXshSimpleLevel::fid2index(const TFrameId &fid) const

{

	FramesSet::const_iterator ft = m_frames.find(fid);

	return (ft != m_frames.end()) ? std::distance(m_frames.begin(), ft) : // Note: flat_set has random access

			   -1;														  // iterators, so this is FAST

}

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

int TXshSimpleLevel::guessIndex(const TFrameId &fid) const

{

	if (m_frames.empty())

		return 0; // no frames, return 0 (by definition)

	FramesSet::const_iterator ft = m_frames.lower_bound(fid);

	if (ft == m_frames.end()) {

		const TFrameId &maxFid = *m_frames.rbegin();

		assert(fid > maxFid);

		// fid not in the table, but greater than the last one.

		// return a suitable index. (e.g. frames are 1,3,5,7; fid2index(11) should return index=5)

		int step = guessStep();

		int i = (fid.getNumber() - maxFid.getNumber()) / step;

		return m_frames.size() - 1 + i;

	} else

		return std::distance(m_frames.begin(), ft);

}

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

TFrameId TXshSimpleLevel::index2fid(int index) const

{

	if (index < 0)

		return TFrameId(-2);

	int frameCount = m_frames.size();

	if (frameCount == 0)

		return TFrameId(1); // o_o?

	if (index < frameCount) {

		FramesSet::const_iterator ft = m_frames.begin();

		std::advance(ft, index);

		return *ft;

	} else {

		int step = guessStep();

		TFrameId maxFid = *m_frames.rbegin();

		int d = step * (index - frameCount + 1);

		return TFrameId(maxFid.getNumber() + d);

	}

}

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

TImageP TXshSimpleLevel::getFrame(const TFrameId &fid, UCHAR imFlags, int subsampling) const

{

	assert(m_type != UNKNOWN_XSHLEVEL);

	// If the required frame is not in range, quit

	if (m_frames.count(fid) == 0)

		return TImageP();

	const std::string &imgId = getImageId(fid);

	ImageLoader::BuildExtData extData(this, fid, subsampling);

	TImageP img = ImageManager::instance()->getImage(

		imgId, imFlags, &extData);

	if (imFlags & ImageManager::toBeModified) {

		// The image will be modified. Perform any related invalidation.

		texture_utils::invalidateTexture(this, fid); // We must rebuild associated textures

	}

	return img;

}

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

TImageInfo *TXshSimpleLevel::getFrameInfo(const TFrameId &fid, bool toBeModified)

{

	assert(m_type != UNKNOWN_XSHLEVEL);

	// If the required frame is not in range, quit

	if (m_frames.count(fid) == 0)

		return 0;

	const std::string &imgId = getImageId(fid);

	TImageInfo *info = ImageManager::instance()->getInfo(

		imgId, toBeModified ? ImageManager::toBeModified : ImageManager::none, 0);

	return info;

}

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

TImageP TXshSimpleLevel::getFrameIcon(const TFrameId &fid) const

{

	assert(m_type != UNKNOWN_XSHLEVEL);

	if (m_frames.count(fid) == 0)

		return TImageP();

	// NOTE: Icons caching is DISABLED at this stage. It is now responsibility of

	// ToonzQt's IconGenerator class.

	ImageLoader::BuildExtData extData(this, fid);

	extData.m_subs = 1, extData.m_icon = true;

	const std::string &imgId = getImageId(fid);

	TImageP img = ImageManager::instance()->getImage(imgId, ImageManager::dontPutInCache, &extData);

	TToonzImageP timg = (TToonzImageP)img;

	if (timg && m_palette)

		timg->setPalette(m_palette);

	return img;

}

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

// load icon (and image) data of all frames into cache

void TXshSimpleLevel::loadAllIconsAndPutInCache(bool cacheImagesAsWell)

{

	if (m_type != TZP_XSHLEVEL)

		return;

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

	getFids(fids);

	std::vector<std::string> iconIds;</std::string>

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

		iconIds.push_back(getIconId(fids[i]));

	}

	ImageManager::instance()->loadAllTlvIconsAndPutInCache(this, fids, iconIds, cacheImagesAsWell);

}

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

TRasterImageP TXshSimpleLevel::getFrameToCleanup(const TFrameId &fid) const

{

	assert(m_type != UNKNOWN_XSHLEVEL);

	FramesSet::const_iterator ft = m_frames.find(fid);

	if (ft == m_frames.end())

		return TImageP();

	bool flag = (m_scannedPath != TFilePath());

	std::string imageId = getImageId(fid, flag ? Scanned : 0);

	ImageLoader::BuildExtData extData(this, fid, 1);

	TRasterImageP img = ImageManager::instance()->getImage(imageId, ImageManager::dontPutInCache, &extData);

	if (!img)

		return img;

	double x_dpi, y_dpi;

	img->getDpi(x_dpi, y_dpi);

	if (!x_dpi && !y_dpi) {

		TPointD dpi = m_properties->getDpi();

		img->setDpi(dpi.x, dpi.y);

	}

	return img;

}

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

TImageP TXshSimpleLevel::getFullsampledFrame(const TFrameId &fid, UCHAR imFlags) const

{

	assert(m_type != UNKNOWN_XSHLEVEL);

	FramesSet::const_iterator it = m_frames.find(fid);

	if (it == m_frames.end())

		return TRasterImageP();

	std::string imageId = getImageId(fid);

	ImageLoader::BuildExtData extData(this, fid, 1);

	TImageP img = ImageManager::instance()->getImage(imageId, imFlags, &extData);

	if (imFlags & ImageManager::toBeModified) {

		// The image will be modified. Perform any related invalidation.

		texture_utils::invalidateTexture(this, fid); // We must rebuild associated textures

	}

	return img;

}

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

std::string TXshSimpleLevel::getIconId(const TFrameId &fid, int frameStatus) const

{

	return "icon:" + getImageId(fid, frameStatus);

}

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

std::string TXshSimpleLevel::getIconId(const TFrameId &fid, const TDimension &size) const

{

	return getImageId(fid) + ":" + toString(size.lx) + "x" + toString(size.ly);

}

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

namespace

{

TAffine getAffine(const TDimension &srcSize, const TDimension &dstSize)

{

	double scx = 1 * dstSize.lx / (double)srcSize.lx;

	double scy = 1 * dstSize.ly / (double)srcSize.ly;

	double sc = tmin(scx, scy);

	double dx = (dstSize.lx - srcSize.lx * sc) * 0.5;

	double dy = (dstSize.ly - srcSize.ly * sc) * 0.5;

	return TScale(sc) * TTranslation(0.5 * TPointD(srcSize.lx, srcSize.ly) + TPointD(dx, dy));

}

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

/*!Costruisce l'icona di dimesione \b size dell'immagine \b img.*/

TImageP buildIcon(const TImageP &img, const TDimension &size)

{

	TRaster32P raster(size);

	if (TVectorImageP vi = img) {

		TOfflineGL *glContext = new TOfflineGL(size);

		TDimension cameraSize(768, 576);

		TPalette *vPalette = img->getPalette();

		assert(vPalette);

		const TVectorRenderData rd(

			getAffine(cameraSize, size),

			TRect(),

			vPalette,

			0, false);

		glContext->clear(TPixel32::White);

		glContext->draw(vi, rd);

		raster->copy(glContext->getRaster());

		delete glContext;

	} else if (TToonzImageP ti = img) {

		raster->fill(TPixel32(255, 255, 255, 255));

		TRasterCM32P rasCM32 = ti->getRaster();

		TRect bbox;

		bbox = ti->getSavebox();

		if (!bbox.isEmpty()) {

			rasCM32 = rasCM32->extractT(bbox);

			double sx = raster->getLx() / (double)rasCM32->getLx();

			double sy = raster->getLy() / (double)rasCM32->getLy();

			double sc = tmin(sx, sy);

			TAffine aff = TScale(sc).place(

				rasCM32->getCenterD(),

				raster->getCenterD());

			TRop::resample(

				raster,

				rasCM32,

				ti->getPalette(),

				aff);

			raster->lock();

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

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

				TPixel32 *endPix = pix + raster->getLx();

				while (pix < endPix) {

					*pix = overPix(TPixel32::White, *pix);

					pix++;

				}

			}

			raster->unlock();

		}

	} else {

		TRasterImageP ri = img;

		if (ri) {

			ri->makeIcon(raster);

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

		} else

			raster->fill(TPixel32(127, 50, 20));

	}

	return TRasterImageP(raster);

}

} // anonymous namespace

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

void TXshSimpleLevel::setFrame(const TFrameId &fid, const TImageP &img)

{

	assert(m_type != UNKNOWN_XSHLEVEL);

	if (img)

		img->setPalette(getPalette());

	m_frames.insert(fid);

	TFilePath path = m_path;

	int frameStatus = getFrameStatus(fid);

	static const int SCANNED_OR_CLEANUPPED = (Scanned | Cleanupped);

	if ((frameStatus & SCANNED_OR_CLEANUPPED) == Scanned)

		path = m_scannedPath;

	// Deal with the ImageManger: ensure the identifiers are bound, and the

	// associated image is either modified to img or (if !img) invalidated.

	const std::string &imageId = getImageId(fid);

	if (!ImageManager::instance()->isBound(imageId)) {

		const TFilePath &decodedPath = getScene()->decodeFilePath(path);

		ImageManager::instance()->bind(imageId, new ImageLoader(decodedPath, fid));

	}

	ImageManager::instance()->setImage(imageId, img); // Invalidates if !img

	if (frameStatus == Normal) {

		// Only a normal frame can have these. Justified since:

		//  a) PLIs have nothing to share with cleanup stuff

		//  b) The latter is used only in LineTest - which does not have Cleanup

		if (m_type == PLI_XSHLEVEL) {

			const std::string &imageId2 = rasterized(imageId);

			if (!ImageManager::instance()->isBound(imageId2))

				ImageManager::instance()->bind(imageId2, new ImageRasterizer);

			else

				ImageManager::instance()->invalidate(imageId2);

		}

		if (m_type == OVL_XSHLEVEL || m_type == TZI_XSHLEVEL) {

			const std::string &imageId2 = filled(imageId);

			if (!ImageManager::instance()->isBound(imageId2))

				ImageManager::instance()->bind(imageId2, new ImageFiller);

			else

				ImageManager::instance()->invalidate(imageId2);

		}

	}

}