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

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

// Utility functions

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

namespace {

const VersionNumber l_currentVersion(71, 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);

  }

}

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

/*-- TODO: オプション化して復活させるか、検討のこと --*/

/*

void saveBackup(const TFilePath &fp)

{

  if(!TFileStatus(fp).doesExist()) return;

        wstring sceneName = fp.getWideName();

  TFilePath bckDir = fp.getParentDir() + "backups" + sceneName;

  if(!TFileStatus(bckDir).doesExist())

  {

    try {TSystem::mkDir(bckDir);}

    catch(...) {return;}

  }

  std::map<int, tfilepath=""> oldBackups;</int,>

  TFilePathSet lst = TSystem::readDirectory(bckDir);

  for(TFilePathSet::iterator it = lst.begin(); it != lst.end(); ++it)

  {

    TFilePath fp2 = *it;

    if(fp2.getType() != "tnz" && fp2.getType() != "tab") continue;

    wstring name = fp2.getWideName();

    if(name.find_first_of(L"0123456789") == wstring::npos) continue;

                int i = name.find(sceneName);

                if(i != wstring::npos)

                        name = name.substr(sceneName.size()+1);

    if(name == L"" || name.find_first_not_of(L"0123456789") != wstring::npos)

      continue;

    int index = toInt(name);

    assert(0

    assert(oldBackups.count(index)==0);

    oldBackups[index] = fp2;

  }

  int m = 3;

  if((int)oldBackups.size()>m)

  {

    std::map<int, tfilepath="">::iterator it = oldBackups.begin();</int,>

    for(int i=0;i+m<(int)oldBackups.size();i++)

    {

      assert(it != oldBackups.end());

      TFilePath toKill = it->second;

      try {TSystem::deleteFile(toKill); } catch(...) {}

      ++it;

    }

  }

  TFilePath bckFp;

  if(oldBackups.empty())

  {

    if(fp.getType() == "tnz")

      bckFp = bckDir + TFilePath(sceneName + L"_1.tnz");

    else if(fp.getType() == "tab")

      bckFp = bckDir + TFilePath(sceneName + L"_1.tab");

  }

  else

  {

    int id = oldBackups.rbegin()->first + 1;

    if(fp.getType() == "tnz")

      bckFp = bckDir + TFilePath(sceneName + L"_" + ::to_wstring(id) + L".tnz");

    else if(fp.getType() == "tab")

      bckFp = bckDir + TFilePath(sceneName + L"_" + ::to_wstring(id) + L".tab");

  }

  TSystem::renameFile(bckFp, fp);

}

*/

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

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

  loadNoResources(path);              // This loads a version number ..

  loadResources(withProgressDialog);  // .. this uses the version number ..

  setVersionNumber(

      VersionNumber());  // .. but scene instances in memory do not retain

}  // a version number beyond resource loading

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

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

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

  // if(TFileStatus(scenePath).doesExist()) saveBackup(scenePath);

  TSystem::touchFile(scenePath);

  makeSceneIcon(this);

  // TOStream os(scenePath, compressionEnabled);

  TOStream os(scenePath, false);

  if (!os.checkStatus()) throw TException("Could not open 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 save");

  if (subxsh) {

    setScenePath(oldScenePath);

    if (wasUntitled) setUntitled();

  } else {

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

  }

}

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

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;

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

  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;

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

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

  }

  ogl.doneCurrent();

  currentOfflineGL = 0;

}

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

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

    for (;;) {

      levelName = nameBuilder->getNext();

      /*-- levelが既にロード済みなら、次の名前を取得 --*/

      if (m_levelSet->getLevel(levelName) != 0) continue;

      /*-- LevelSetの中に同じファイルパスのLevelがあるかをチェック --*/

      if (type != CHILD_XSHLEVEL && type != PLT_XSHLEVEL) {

        if (fp.isEmpty()) fp = getDefaultLevelPath(type, levelName);

        TFilePath actualFp   = decodeFilePath(fp);

        if (TSystem::doesExistFileOrLevel(

                actualFp))  // if(TFileStatus(actualFp).doesExist()) continue;

        {

          fp = TFilePath();

          continue;

        }

        int l, lCount = levelSet->getLevelCount();

        for (l = 0; l != lCount; ++l) {

          TXshLevel *xl = levelSet->getLevel(l);

          if (!xl) continue;

          TXshSimpleLevel *sl = xl->getSimpleLevel();

          if (!sl) continue;

          TFilePath lfp = decodeFilePath(sl->getPath());

          if (actualFp == lfp) break;

        }

        if (l < lCount) {

          /*-- fpが既存のLevelと重複したため、再設定する --*/

          fp = TFilePath();

          continue;

        }

      }

      break;

    }

  }

  TXshLevel *xl = 0;

  if (type == CHILD_XSHLEVEL) {

    TXshChildLevel *cl = new TXshChildLevel(levelName);

    cl->setScene(this);

    cl->getXsheet()->setScene(this);

    xl = cl;

    // Include the project's default cameras

    const TSceneProperties &props =

        TProjectManager::instance()->getCurrentProject()->getSceneProperties();