#include "toonz/toonzscene.h"

// TnzLib includes

#include "toonz/txsheet.h"

#include "toonz/txshcell.h"

#include "toonz/txshsimplelevel.h"

#include "toonz/txshchildlevel.h"

#include "toonz/txshleveltypes.h"

#include "toonz/txshlevelcolumn.h"

#include "toonz/txshsoundcolumn.h"

#include "toonz/txshsoundlevel.h"

#include "toonz/sceneproperties.h"

#include "toonz/stage.h"

#include "toonz/stagevisitor.h"

#include "toonz/levelset.h"

#include "toonz/tstageobjecttree.h"

#include "toonz/observer.h"

#include "toonz/namebuilder.h"

#include "toonz/tproject.h"

#include "toonz/toonzimageutils.h"

#include "toonz/childstack.h"

#include "toonz/levelproperties.h"

#include "toonz/tcamera.h"

#include "toonz/sceneresources.h"

#include "toonz/preferences.h"

#include "toonz/fullcolorpalette.h"

#include "toonz/txshpalettecolumn.h"

#include "toonz/txshpalettelevel.h"

#include "toonz/toonzfolders.h"

// TnzCore includes

#include "timagecache.h"

#include "tstream.h"

#include "tstreamexception.h"

#include "tofflinegl.h"

#include "tenv.h"

#include "tsystem.h"

#include "tfiletype.h"

#include "tlevel_io.h"

#include "ttoonzimage.h"

#include "tlogger.h"

#include "tvectorimage.h"

#include "tcontenthistory.h"

#include "toutputproperties.h"

#include "trop.h"

TOfflineGL *currentOfflineGL = 0;

#include <qprogressdialog></qprogressdialog>

#ifdef MACOSX

#include <qsurfaceformat></qsurfaceformat>

#include <qoffscreensurface></qoffscreensurface>

#include <qopenglcontext></qopenglcontext>

#include <qopenglframebufferobject></qopenglframebufferobject>

#endif

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

// Utility functions

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

namespace {

// tentatively update the scene file version from 71.0 to 71.1 in order to

// manage PNG level settings

const VersionNumber l_currentVersion(71, 1);

// TODO: Revise VersionNumber with OT version (converting 71.0 -> 14.0 , 71.1

// -> 15.0)

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

std::string getFolderName(int levelType) {

  switch (levelType) {

  case TZI_XSHLEVEL:

    return TProject::Inputs;

  case PLI_XSHLEVEL:

    return TProject::Drawings;

  case TZP_XSHLEVEL:

    return TProject::Drawings;

  case OVL_XSHLEVEL:

    return TProject::Extras;

  default:

    return TProject::Extras;

  }

}

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

/*

TFilePath adjustTypeAndFrame(int levelType, TFilePath fp)

{

  switch(levelType)

  {

    case TZI_XSHLEVEL:

      if(fp.getType()=="") fp=fp.withType("tif");

      return fp.withFrame(TFrameId::EMPTY_FRAME);

    case PLI_XSHLEVEL:

      return fp.withFrame(TFrameId::NO_FRAME)

               .withType("pli");

    case TZP_XSHLEVEL:

      return fp.withFrame(TFrameId::NO_FRAME)

               .withType("tlv");

    case OVL_XSHLEVEL:

    default:

      if(fp.getType()=="") fp=fp.withType("png");

      return fp;

  }

}

*/

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

TFilePath getUntitledScenesDir() {

  return ToonzFolder::getCacheRootFolder() + "temp";

}

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

// se path = head + tail ritorna true e assegna head

bool checkTail(TFilePath path, TFilePath tail, TFilePath &head) {

  for (;;) {

    if (tail == TFilePath()) {

      head = path;

      return true;

    }

    if (path == TFilePath()) return false;

    if (path.withoutParentDir() != tail.withoutParentDir()) return false;

    path = path.getParentDir();

    tail = tail.getParentDir();

  }

}

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

void makeSceneIcon(ToonzScene *scene) {

  TDimension cameraSize = scene->getCurrentCamera()->getRes();

  int maxSize               = 128;

  TDimension iconCameraSize = cameraSize;

  if (cameraSize.lx > cameraSize.ly) {

    iconCameraSize.ly = maxSize * cameraSize.ly / cameraSize.lx;

    iconCameraSize.lx = maxSize;

  } else {

    iconCameraSize.lx = maxSize * cameraSize.lx / cameraSize.ly;

    iconCameraSize.ly = maxSize;

  }

  TRaster32P ras(iconCameraSize);

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

  ras->fill(bgColor);

  scene->renderFrame(ras, 0);

  TFilePath iconPath = scene->getIconPath();

  if (TSystem::touchParentDir(iconPath)) TImageWriter::save(iconPath, ras);

}

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

void deleteUntitledScene(const TFilePath &fp) {

  if (TFileStatus(fp).isDirectory()) {

    TFilePath tempDir = getUntitledScenesDir();

    if (TFileStatus(tempDir).isDirectory() &&

        tempDir.isAncestorOf(fp))  // per sicurezza

    {

      try {

        TSystem::rmDirTree(fp);

      } catch (...) {

        assert(0);

      }

    } else

      assert(0);

  }

}

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

static void saveBackup(TFilePath path) {

  int totalBackups = Preferences::instance()->getBackupKeepCount();

  totalBackups -= 1;

  TFilePath backup = path.withType(path.getType() + ".bak");

  TFilePath prevBackup =

      path.withType(path.getType() + ".bak" + std::to_string(totalBackups));

  while (--totalBackups >= 0) {

    std::string bakExt =

        ".bak" + (totalBackups > 0 ? std::to_string(totalBackups) : "");

    backup = path.withType(path.getType() + bakExt);

    if (TSystem::doesExistFileOrLevel(backup)) {

      try {

        TSystem::copyFileOrLevel_throw(prevBackup, backup);

      } catch (...) {

      }

    }

    prevBackup = backup;

  }

  try {

    if (TSystem::doesExistFileOrLevel(backup))

      TSystem::removeFileOrLevel_throw(backup);

    TSystem::copyFileOrLevel_throw(backup, path);

  } catch (...) {

  }

}

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

// serve per correggere un problema verificatosi da Bianco (con la beta3)

// vengono create coppie di livelli con lo stesso nome e in genere path diverso

void fixBiancoProblem(ToonzScene *scene, TXsheet *xsh) {

  TLevelSet *levelSet = scene->getLevelSet();

  std::set<txsheet *=""> visited, tovisit;</txsheet>

  tovisit.insert(xsh);

  while (!tovisit.empty()) {

    xsh = *tovisit.begin();

    xsh->setScene(scene);  // sound problem

    visited.insert(xsh);

    tovisit.erase(xsh);

    int c0 = 0, c1 = xsh->getColumnCount() - 1;

    for (int c = c0; c <= c1; c++) {

      if (xsh->isColumnEmpty(c)) continue;

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

      if (!column || !column->getLevelColumn()) continue;

      TXshLevelColumn *lcolumn = column->getLevelColumn();

      int r0 = 0, r1 = -1;

      lcolumn->getRange(r0, r1);

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

        TXshCell cell = lcolumn->getCell(r);

        if (cell.isEmpty()) continue;

        TXshLevel *xl = cell.m_level.getPointer();

        scene->getLevelSet()->insertLevel(xl);  // per sicurezza

        xl->setScene(scene);

        if (TXshChildLevel *childLevel = xl->getChildLevel()) {

          TXsheet *childXsh = childLevel->getXsheet();

          if (visited.count(childXsh) > 0) continue;

          tovisit.insert(childXsh);

        } else {

          TXshLevel *xl2 = levelSet->getLevel(xl->getName());

          if (xl2) {

            if (xl2 != xl) {

              cell.m_level = xl2;

              lcolumn->setCell(r, cell);

            }

          } else {

            xl->setScene(scene);

            levelSet->insertLevel(xl);

          }

        }

      }

    }

  }

}

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

}  // namespace

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

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

static void deleteAllUntitledScenes() {

  TFilePath tempDir = getUntitledScenesDir();

  try {

    if (TFileStatus(tempDir).isDirectory()) {

      TFilePathSet fps;

      TSystem::readDirectory(fps, tempDir);

      TFilePathSet::iterator fpsIt;

      for (fpsIt = fps.begin(); fpsIt != fps.end(); ++fpsIt) {

        TFilePath fp = *fpsIt;

        if (TFileStatus(fp).isDirectory() &&

            fp.getName().find("untitled") != -1)

          TSystem::rmDirTree(fp);

      }

    }

  } catch (...) {

  }

}

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

// ToonzScene

ToonzScene::ToonzScene()

    : m_contentHistory(0), m_isUntitled(true), m_isLoading(false) {

  m_childStack = new ChildStack(this);

  m_properties = new TSceneProperties();

  m_levelSet   = new TLevelSet();

  m_project    = new TProject();

  m_project->addRef();

}

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

ToonzScene::~ToonzScene() {

  delete m_properties;

  delete m_levelSet;

  delete m_childStack;

  delete m_contentHistory;

  assert(m_project);

  if (m_project) m_project->release();

}

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

void ToonzScene::setSceneName(std::wstring name) {

  m_scenePath = m_scenePath.withName(name);

}

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

void ToonzScene::clear() {

  if (isUntitled()) deleteUntitledScene(getScenePath().getParentDir());

  m_childStack->clear();

  m_scenePath                  = TFilePath();

  TSceneProperties *properties = m_properties;

  m_properties                 = new TSceneProperties();

  delete properties;

  m_levelSet->clear();

}

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

void ToonzScene::setProject(TProject *project) {

  assert(project);

  if (project != m_project) {

    if (project) project->addRef();

    if (m_project) m_project->release();

    m_project = project;

  }

}

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

TProject *ToonzScene::getProject() const { return m_project; }

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

void ToonzScene::setScenePath(const TFilePath &fp) {

  m_scenePath  = fp;

  m_isUntitled = false;

}

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

bool ToonzScene::isUntitled() const {

  return m_scenePath == TFilePath() || m_isUntitled;

}

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

void ToonzScene::load(const TFilePath &path, bool withProgressDialog) {

  setIsLoading(true);

  try {

    loadNoResources(path);

    loadResources(withProgressDialog);

  } catch (...) {

    setIsLoading(false);

    throw;

  }

  setIsLoading(false);

}

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

// Funzioncina veloce per trovare il numero di frame di una scena senza caricare

// nulla. (implementato per Toonz 6.0 beta 1)

int ToonzScene::loadFrameCount(const TFilePath &fp) {

  TIStream is(fp);

  if (!is) throw TException(fp.getWideString() + L": Can't open file");

  try {

    // Leggo il primo tag (<tnz tab="">) ed estraggo il framecount (se c'e')</tnz>

    std::string tagName = "";

    if (!is.matchTag(tagName)) throw TException("Bad file format");

    if (tagName == "tab" || tagName == "tnz") {

      int frameCount;

      if (is.getTagParam("framecount", frameCount))

        return frameCount;

      else

        return 0;

    } else

      throw TException("Bad file format");

  } catch (TException &e) {

    throw TIStreamException(is, e);

  } catch (...) {

    throw TIStreamException(is);

  }

  return 0;

}

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

void ToonzScene::loadNoResources(const TFilePath &fp) {

  clear();

  TProjectManager *pm    = TProjectManager::instance();

  TProjectP sceneProject = pm->loadSceneProject(fp);

  if (!sceneProject) return;

  setProject(sceneProject.getPointer());

  loadTnzFile(fp);

  getXsheet()->updateFrameCount();

}

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

/*--

 * プログレスダイアログをGUIからの実行時でのみ表示させる。tcomposerから実行の場合は表示させない

 * --*/

void ToonzScene::loadResources(bool withProgressDialog) {

  /*--- m_levelSet->getLevelCount()が10個以上のとき表示させる　---*/

  QProgressDialog *progressDialog = 0;

  if (withProgressDialog && m_levelSet->getLevelCount() >= 10) {

    progressDialog = new QProgressDialog("Loading Scene Resources", "", 0,

                                         m_levelSet->getLevelCount());

    progressDialog->setModal(true);

    progressDialog->setAutoReset(

        true); /*--maximumに到達したら自動でresetを呼ぶ--*/

    progressDialog->setAutoClose(true); /*--resetが呼ばれたら自動で閉じる--*/

    progressDialog->setAttribute(Qt::WA_DeleteOnClose,

                                 true); /*--閉じたら自動でDeleteされる--*/

    progressDialog->setCancelButton(0);

    progressDialog->setValue(0);

    progressDialog->show();

  }

  int i;

  for (i = 0; i < m_levelSet->getLevelCount(); i++) {

    if (progressDialog) progressDialog->setValue(i + 1);

    TXshLevel *level = m_levelSet->getLevel(i);

    try {

      level->load();

    } catch (...) {

    }

  }

  getXsheet()->updateFrameCount();

}

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

void ToonzScene::loadTnzFile(const TFilePath &fp) {

  bool reading22 = false;

  TIStream is(fp);

  if (!is) throw TException(fp.getWideString() + L": Can't open file");

  try {

    std::string tagName = "";

    if (!is.matchTag(tagName)) throw TException("Bad file format");

    if (tagName == "tab" || tagName == "tnz") {

      std::string rootTagName = tagName;

      std::string v           = is.getTagAttribute("version");

      VersionNumber versionNumber(0, 0);

      int k = v.find(".");

      if (k != (int)std::string::npos && 0 < k && k < (int)v.length()) {

        versionNumber.first  = std::stoi(v.substr(0, k));

        versionNumber.second = std::stoi(v.substr(k + 1));

      }

      if (versionNumber == VersionNumber(0, 0))

        throw TException("Bad version number :" + v);

      setVersionNumber(versionNumber);

      is.setVersion(versionNumber);

      while (is.matchTag(tagName)) {

        if (tagName == "generator") {

          std::string program = is.getString();

          // TODO: This obsolete condition should be removed before releasing OT

          // v2.2 !

          reading22 = program.find("2.2") != std::string::npos;

        } else if (tagName == "properties")

          m_properties->loadData(is, false);

        else if (tagName == "palette")  // per compatibilita' beta1

        {

          TPalette *palette = new TPalette;

          is >> *palette;

          delete palette;

        } else if (tagName == "levelSet")

          m_levelSet->loadData(is);

        else if (tagName == "levels") {

          // obsoleto

          if (!reading22) assert(0);

          while (!is.eos()) {

            TPersist *p = 0;

            is >> p;

            TXshLevel *xshLevel = dynamic_cast<txshlevel *="">(p);</txshlevel>

            if (xshLevel) {

              xshLevel->setScene(this);

              TXshSimpleLevel *sl = xshLevel->getSimpleLevel();

              if (reading22 && sl && sl->getPath() == TFilePath()) {

                sl->setType(PLI_XSHLEVEL);

                sl->setPath(TFilePath("+drawings/") +

                            (sl->getName() + L".pli"));

              }

              m_levelSet->insertLevel(xshLevel);

            }

          }

        } else if (tagName == "xsheet")

          is >> *getXsheet();

        else if (tagName == "history") {

          std::string historyData, s;

          while (!is.eos()) {

            is >> s;

            historyData += s;

          }

          TContentHistory *history = getContentHistory(true);

          history->deserialize(QString::fromStdString(historyData));

        } else

          throw TException(tagName + " : unexpected tag");

        if (!is.matchEndTag()) throw TException(tagName + " : missing end tag");

      }

      if (!is.matchEndTag())

        throw TException(rootTagName + " : missing end tag");

    } else

      throw TException("Bad file format");

    setScenePath(fp);

    for (int i = 0; i < m_levelSet->getLevelCount(); i++)

      m_levelSet->getLevel(i)->setScene(this);

  } catch (TException &e) {

    throw TIStreamException(is, e);

  } catch (...) {

    throw TIStreamException(is);

  }

  m_properties->cloneCamerasTo(getXsheet()->getStageObjectTree());

  fixBiancoProblem(this, getXsheet());

}

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

// saveUntitled() viene chiamata subito dopo newScene

// serve principalmente come lock per evitare che vengano create due scene

// con lo stesso nome.

void ToonzScene::setUntitled() {

  m_isUntitled               = true;

  const std::string baseName = "untitled";

  TFilePath tempDir          = getUntitledScenesDir();

  if (TFileStatus(tempDir).doesExist() == false) {

    try {

      TSystem::mkDir(tempDir);

    } catch (...) {

    }

  }

  std::string name = baseName;

  if (TFileStatus(tempDir + name).doesExist()) {

    int count = 2;

    do {

      name = baseName + std::to_string(count++);

    } while (TFileStatus(tempDir + name).doesExist());

  }

  TFilePath fp = tempDir + name + (name + ".tnz");

  try {

    TSystem::touchParentDir(fp);

  } catch (...) {

    assert(0);

  }

  m_scenePath = fp;

}

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

// When saving as sub-xsheet, the sub becomes top. So, its cameras must be

// associated to the scene properties.

class CameraRedirection {

  ToonzScene *m_scene;

  TXsheet *m_xsh;

public:

  CameraRedirection(ToonzScene *scene, TXsheet *xsh)

      : m_scene(scene), m_xsh(xsh) {

    if (!xsh) xsh = m_scene->getTopXsheet();

    m_scene->getProperties()->cloneCamerasFrom(xsh->getStageObjectTree());

  }

  ~CameraRedirection() {

    if (m_xsh)

      m_scene->getProperties()->cloneCamerasFrom(

          m_scene->getTopXsheet()->getStageObjectTree());

  }

};

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

void ToonzScene::save(const TFilePath &fp, TXsheet *subxsh) {

  TFilePath oldScenePath = getScenePath();

  TFilePath newScenePath = fp;

  CameraRedirection redir(this, subxsh);

  bool wasUntitled = isUntitled();

  setScenePath(fp);

  TFileStatus fs(newScenePath);

  if (fs.doesExist() && !fs.isWritable())

    throw TSystemException(newScenePath,

                           "The scene cannot be saved: it is a read only "

                           "scene.\n All resources have been saved.");

  TFilePath scenePath = decodeFilePath(fp);

  TFilePath scenePathTemp(scenePath.getWideString() +

                          QString(".tmp").toStdWString());

  if (Preferences::instance()->isBackupEnabled() &&

      oldScenePath == newScenePath && TFileStatus(scenePath).doesExist())

    saveBackup(scenePath);

  if (TFileStatus(scenePathTemp).doesExist())

    TSystem::removeFileOrLevel(scenePathTemp);

  //  TSystem::touchFile(scenePath);

  TSystem::touchFile(scenePathTemp);

  makeSceneIcon(this);

  // TOStream os(scenePath, compressionEnabled);

  //  TOStream os(scenePath, false);

  {

    TOStream os(scenePathTemp, false);

    if (!os.checkStatus())

      throw TException("Could not open temporary save file");

    TXsheet *xsh = subxsh;

    if (xsh == 0) xsh = m_childStack->getTopXsheet();

    std::map<std::string, std::string=""> attr;</std::string,>

    attr["version"] =

        (QString::number(l_currentVersion.first) +

         "."  // From now on, version numbers in saved files will have

         + QString::number(

               l_currentVersion.second))  // the signature "MAJOR.MINOR", where:

            .toStdString();               //

    attr["framecount"] =

        QString::number(  //    MAJOR = Toonz version number * 10 (eg 7.0 => 70)

            xsh->getFrameCount())

            .toStdString();  //    MINOR = Reset to 0 after each major

                             //    increment,

                             //    and

    //            advancing on its own when fixing bugs.

    os.openChild("tnz", attr);

    os.child("generator") << TEnv::getApplicationFullName();

    os.openChild("properties");

    m_properties->saveData(os);

    os.closeChild();

    if (subxsh) {

      std::set<txshlevel *=""> saveSet;</txshlevel>

      subxsh->getUsedLevels(saveSet);

      m_levelSet->setSaveSet(saveSet);

    }

    os.openChild("levelSet");

    m_levelSet->saveData(os);

    os.closeChild();

    std::set<txshlevel *=""> emptySaveSet;</txshlevel>

    m_levelSet->setSaveSet(emptySaveSet);

    os.openChild("xsheet");

    os << *xsh;

    os.closeChild();

    if (getContentHistory()) {

      os.openChild("history");

      QString data = getContentHistory()->serialize();

      int i        = 0, j;

      // non scrivo tutta la std::string di seguito per evitare problemi se

      // diventa

      // troppo lunga. Cerco di spezzarla in modo che sia "bella da leggere" nel

      // tnz

      while ((j = data.indexOf("||", i)) >= i) {

        os << data.mid(i, j - i + 1).toStdWString();

        os.cr();

        i = j + 1;

      }

      os << data.mid(i).toStdWString();

      os.closeChild();

    }

    os.closeChild();

    bool status = os.checkStatus();

    if (!status) throw TException("Could not complete the temporary save");

  }

  if (TFileStatus(scenePathTemp).doesExist())

    TSystem::renameFile(scenePath, scenePathTemp, true);

  if (subxsh) {

    setScenePath(oldScenePath);

    if (wasUntitled) setUntitled();

  } else {

    if (wasUntitled) deleteUntitledScene(oldScenePath.getParentDir());

  }

  // update the last saved version

  setVersionNumber(l_currentVersion);

}

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

int ToonzScene::getFrameCount() const {

  TXsheet *xsh = getXsheet();

  return xsh ? xsh->getFrameCount() : 0;

}

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

void ToonzScene::renderFrame(const TRaster32P &ras, int row, const TXsheet *xsh,

                             bool checkFlags) const {

  if (xsh == 0) xsh = getXsheet();

  TCamera *camera        = xsh->getStageObjectTree()->getCurrentCamera();

  TDimension cameraRes   = camera->getRes();

  TDimensionD cameraSize = camera->getSize();

  // voglio che la camera sia completamente contenuta dentro raster

  double sx = (double)ras->getLx() / (double)cameraSize.lx;

  double sy = (double)ras->getLy() / (double)cameraSize.ly;

  double sc = (sx < sy) ? sx : sy;

  const TAffine &cameraAff =

      xsh->getPlacement(xsh->getStageObjectTree()->getCurrentCameraId(), row);

  const TAffine &viewAff = TScale(sc / Stage::inch) * cameraAff.inv();

  TRect clipRect(ras->getBounds());

  TOfflineGL ogl(ras->getSize());

  currentOfflineGL = &ogl;

  ogl.makeCurrent();

  {

    glTranslated(0.5 * ras->getLx(), 0.5 * ras->getLy(), 0.0);

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    glClear(GL_COLOR_BUFFER_BIT);

    ImagePainter::VisualSettings vs;

    vs.m_plasticVisualSettings.m_drawMeshesWireframe = false;

    vs.m_forSceneIcon                                = true;

    Stage::RasterPainter painter(ras->getSize(), viewAff, clipRect, vs,

                                 checkFlags);

    Stage::visit(painter, const_cast<toonzscene *="">(this),</toonzscene>

                 const_cast<txsheet *="">(xsh), row);</txsheet>

    painter.flushRasterImages();

    glFlush();

    TRop::over(ras, ogl.getRaster());

  }

  ogl.doneCurrent();

  currentOfflineGL = 0;

}

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

//! Performs a camera-stand render of the specified xsheet in the specified

//! placedRect,

//! with known world/placed reference change - and returns the result in a

//! 32-bit raster.

void ToonzScene::renderFrame(const TRaster32P &ras, int row, const TXsheet *xsh,

                             const TRectD &placedRect,

                             const TAffine &worldToPlacedAff) const {

  // Build reference change affines

  const TAffine &placedToOglRefAff =

      TScale(ras->getLx() / placedRect.getLx(),

             ras->getLy() / placedRect.getLy()) *

      TTranslation(-0.5 * (placedRect.x0 + placedRect.x1),

                   -0.5 * (placedRect.y0 + placedRect.y1));

  const TAffine &cameraAff =

      xsh->getPlacement(xsh->getStageObjectTree()->getCurrentCameraId(), row);

  const TAffine &worldToOglRefAff =

      placedToOglRefAff * worldToPlacedAff * cameraAff.inv();

  TRect clipRect(ras->getBounds());

// fix for plastic tool applied to subxsheet

#ifdef MACOSX

  QSurfaceFormat format;

  format.setProfile(QSurfaceFormat::CompatibilityProfile);

  std::unique_ptr<qoffscreensurface> surface(new QOffscreenSurface());</qoffscreensurface>

  surface->setFormat(format);

  surface->create();

  glPushAttrib(GL_ALL_ATTRIB_BITS);

  glMatrixMode(GL_MODELVIEW), glPushMatrix();

  glMatrixMode(GL_PROJECTION), glPushMatrix();

#else

  TOfflineGL ogl(ras->getSize());

  currentOfflineGL = &ogl;

  ogl.makeCurrent();

#endif

  {

#ifdef MACOSX

    std::unique_ptr<qopenglframebufferobject> fb(</qopenglframebufferobject>

        new QOpenGLFramebufferObject(ras->getLx(), ras->getLy()));

    fb->bind();

    assert(glGetError() == GL_NO_ERROR);

    glViewport(0, 0, ras->getLx(), ras->getLy());

    glMatrixMode(GL_PROJECTION);

    glLoadIdentity();

    gluOrtho2D(0, ras->getLx(), 0, ras->getLy());

    glMatrixMode(GL_MODELVIEW);

    glLoadIdentity();

#endif

    glTranslated(0.5 * ras->getLx(), 0.5 * ras->getLy(), 0.0);

    glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

    glClear(GL_COLOR_BUFFER_BIT);

    ImagePainter::VisualSettings vs;

    vs.m_plasticVisualSettings.m_drawMeshesWireframe = false;

    Stage::RasterPainter painter(ras->getSize(), worldToOglRefAff, clipRect, vs,

                                 false);

    Stage::visit(painter, const_cast<toonzscene *="">(this),</toonzscene>

                 const_cast<txsheet *="">(xsh), row);</txsheet>

    painter.flushRasterImages();

    glFlush();

#ifdef MACOSX

    QImage img =

        fb->toImage().scaled(QSize(ras->getLx(), ras->getLy()),

                             Qt::IgnoreAspectRatio, Qt::SmoothTransformation);

    int wrap      = ras->getLx() * sizeof(TPixel32);

    uchar *srcPix = img.bits();

    uchar *dstPix = ras->getRawData() + wrap * (ras->getLy() - 1);

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

      memcpy(dstPix, srcPix, wrap);

      dstPix -= wrap;

      srcPix += wrap;

    }

    fb->release();

    assert(glGetError() == GL_NO_ERROR);

#else

    TRop::over(ras, ogl.getRaster());

#endif

  }

#ifdef MACOSX

  glMatrixMode(GL_MODELVIEW), glPopMatrix();

  glMatrixMode(GL_PROJECTION), glPopMatrix();

  glPopAttrib();

#else

  ogl.doneCurrent();

  currentOfflineGL = 0;

#endif

}

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

TXshLevel *ToonzScene::createNewLevel(int type, std::wstring levelName,

                                      const TDimension &dim, double dpi,

                                      TFilePath fp) {

  TLevelSet *levelSet = getLevelSet();

  if (type == TZI_XSHLEVEL)  // TZI type corresponds to the 'Scan Level'

    type = OVL_XSHLEVEL;     // default option. See Toonz Preferences class.

  if (type == CHILD_XSHLEVEL && levelName == L"") levelName = L"sub";

  // Select a different unique level name in case it already exists (either in

  // scene or on disk)

  {

    const std::unique_ptr<namebuilder> nameBuilder(</namebuilder>

        NameBuilder::getBuilder(levelName));