// 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();

  void run() override = 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 final : 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() override;

};

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

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 final : 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() override;

};

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

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) {

    glContext->doneCurrent();

    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 final : 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() override;

};

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

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 final : 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() override;

  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 final : 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() override;

};

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

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);

}

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

void MeshImageIconRenderer::run() {

  try {

    TRaster32P ras(generateRaster(getIconSize()));

    if (ras) setIcon(ras);

  } catch (...) {

  }

}

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

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

//    XsheetIconRenderer class

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

class XsheetIconRenderer final : public IconRenderer {

  TXsheet *m_xsheet;

  int m_row;

public:

  XsheetIconRenderer(const std::string &id, const TDimension &iconSize,

                     TXsheet *xsheet, int row = 0)

      : IconRenderer(id, iconSize), m_xsheet(xsheet), m_row(row) {

    if (m_xsheet) {

      assert(m_xsheet->getRefCount() > 0);

      m_xsheet->addRef();

    }

  }

  ~XsheetIconRenderer() {

    if (m_xsheet) m_xsheet->release();

  }

  static std::string getId(TXshChildLevel *level, int row) {

    return "sub:" + ::to_string(level->getName()) + std::to_string(row);

  }

  TRaster32P generateRaster(const TDimension &iconSize) const;

  void run() override;

};

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

TRaster32P XsheetIconRenderer::generateRaster(

    const TDimension &iconSize) const {

  ToonzScene *scene = m_xsheet->getScene();

  TRaster32P ras(iconSize);

  TPixel32 bgColor = scene->getProperties()->getBgColor();

  bgColor.m        = 255;

  ras->fill(bgColor);

  TImageCache::instance()->setEnabled(false);