#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 <qtcore></qtcore>

#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,</tframeid>

                             int &toIndex) {

  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(std::to_string(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"_" + std::to_wstring(from + 1) + L"-" + std::to_wstring(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) + ":" + std::to_string(size.lx) + "x" +

         std::to_string(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  = std::min(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);

    TDimension cameraSize(1920, 1080);

    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 = std::min(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);

    }

  }

}

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

void TXshSimpleLevel::eraseFrame(const TFrameId &fid) {

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

  if (ft == m_frames.end()) return;

  // Erase the corresponding entry in the renumber table

  std::map<tframeid, tframeid="">::iterator rt, rEnd(m_renumberTable.end());</tframeid,>

  for (rt = m_renumberTable.begin(); rt != rEnd; ++rt) {

    if (rt->second == fid) {

      m_renumberTable.erase(rt->first);

      break;

    }

  }

  m_frames.erase(ft);

  getHookSet()->eraseFrame(fid);

  ImageManager *im = ImageManager::instance();

  {

    im->unbind(getImageId(fid, Normal));

    im->unbind(getImageId(fid, Scanned));

    im->unbind(getImageId(fid, CleanupPreview));

    if (m_type == PLI_XSHLEVEL) im->unbind(rasterized(getImageId(fid)));

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

      im->unbind(filled(getImageId(fid)));

    texture_utils::invalidateTexture(this, fid);

  }

}

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

void TXshSimpleLevel::clearFrames() {

  ImageManager *im = ImageManager::instance();

  // Unbind frames

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

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

    im->unbind(getImageId(*ft, Scanned));

    im->unbind(getImageId(*ft, Cleanupped));

    im->unbind(getImageId(*ft, CleanupPreview));

    if (m_type == PLI_XSHLEVEL) im->unbind(rasterized(getImageId(*ft)));

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

      im->unbind(filled(getImageId(*ft)));

    texture_utils::invalidateTexture(this, *ft);

  }

  // Clear level

  m_frames.clear();

  m_editableRange.clear();