#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"_" + toWideString(id) + L".tnz");

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

      bckFp = bckDir + TFilePath(sceneName + L"_" + toWideString(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

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

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

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 = toInt(v.substr(0, k));

				versionNumber.second = toInt(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 + toString(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), const_cast<txsheet *="">(xsh), row);</txsheet></toonzscene>

		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), const_cast<txsheet *="">(xsh), row);</txsheet></toonzscene>

		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::auto_ptr<namebuilder> nameBuilder(NameBuilder::getBuilder(levelName));</namebuilder>

		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;