781 lines
23 KiB
C++
781 lines
23 KiB
C++
|
|
|
|
#include "toonz/sceneresources.h"
|
|
#include "toonz/toonzscene.h"
|
|
#include "toonz/tproject.h"
|
|
#include "toonz/levelset.h"
|
|
#include "toonz/txshsimplelevel.h"
|
|
#include "toonz/txshpalettelevel.h"
|
|
#include "toonz/levelproperties.h"
|
|
#include "toonz/txshsoundlevel.h"
|
|
#include "toonz/namebuilder.h"
|
|
#include "toonz/childstack.h"
|
|
#include "toonz/txsheet.h"
|
|
#include "toonz/preferences.h"
|
|
#include "tpalette.h"
|
|
|
|
#include "tconvert.h"
|
|
#include "tlogger.h"
|
|
#include "tsystem.h"
|
|
|
|
namespace
|
|
{
|
|
//=============================================================================
|
|
|
|
// se path e' della forma +folder/<oldSavePath>/name.type
|
|
// allora sostituisce oldSavePath con newSavePath e ritorna true
|
|
|
|
bool changeSavePath(TFilePath &path, TFilePath oldSavePath, TFilePath newSavePath)
|
|
{
|
|
if (oldSavePath == newSavePath)
|
|
return false;
|
|
TFilePath fp = path.getParentDir();
|
|
std::wstring head;
|
|
TFilePath tail;
|
|
fp.split(head, tail);
|
|
if (head != L"" && tail == oldSavePath) {
|
|
path = path.withParentDir(TFilePath(head) + newSavePath);
|
|
return true;
|
|
} else
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
//From ../../../filename#type.psd to ../../../filename.psd
|
|
TFilePath restorePsdPath(const TFilePath &fp)
|
|
{
|
|
QString path = QString::fromStdWString(fp.getWideString());
|
|
if (fp.getType() != "psd" || !path.contains("#"))
|
|
return fp;
|
|
int from = path.indexOf("#");
|
|
int to = path.lastIndexOf(".");
|
|
path.remove(from, to - from);
|
|
return TFilePath(path.toStdWString());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool makePathUnique(ToonzScene *scene, TFilePath &path)
|
|
{
|
|
std::wstring name = path.getWideName();
|
|
int id = 2;
|
|
int i = name.length() - 1;
|
|
int num = 0, p = 1;
|
|
while (i >= 0 && L'0' <= name[i] && name[i] <= L'9') {
|
|
num += p * (name[i] - L'0');
|
|
p *= 10;
|
|
i--;
|
|
}
|
|
if (i >= 0 && name[i] == L'_') {
|
|
id = num + 1;
|
|
name = name.substr(0, i);
|
|
}
|
|
|
|
bool ret = false;
|
|
while (TSystem::doesExistFileOrLevel(scene->decodeFilePath(path))) {
|
|
ret = true;
|
|
path = path.withName(name + L"_" + toWideString(id));
|
|
id++;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool getCollectedPath(ToonzScene *scene, TFilePath &path)
|
|
{
|
|
if (!path.isAbsolute() || path.getWideString()[0] == L'+')
|
|
return false;
|
|
|
|
TFilePath collectedPath = scene->getImportedLevelPath(path);
|
|
if (path == collectedPath)
|
|
return false;
|
|
|
|
TFilePath actualCollectedPath = scene->decodeFilePath(collectedPath);
|
|
|
|
if (makePathUnique(scene, actualCollectedPath))
|
|
collectedPath = collectedPath.withName(actualCollectedPath.getName());
|
|
|
|
path = collectedPath;
|
|
return true;
|
|
}
|
|
|
|
} // namespace
|
|
|
|
//=============================================================================
|
|
//
|
|
// ResourceImportStrategy
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ResourceImportStrategy::ResourceImportStrategy(int strategy)
|
|
: m_childFolderEnabled(false), m_strategy(strategy)
|
|
{
|
|
setChildFolderEnabled(Preferences::instance()->isSubsceneFolderEnabled());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TFilePath ResourceImportStrategy::process(ToonzScene *scene, ToonzScene *srcScene, TFilePath srcPath)
|
|
{
|
|
TFilePath srcActualPath = srcScene->decodeFilePath(srcPath);
|
|
if (!scene->isExternPath(srcActualPath) || m_strategy == DONT_IMPORT)
|
|
return srcPath;
|
|
|
|
TFilePath dstPath;
|
|
if (srcPath.getWideString().find(L'+') == 0)
|
|
dstPath = srcPath;
|
|
else
|
|
dstPath = scene->getImportedLevelPath(srcPath);
|
|
TFilePath actualDstPath = scene->decodeFilePath(dstPath);
|
|
assert(actualDstPath != TFilePath());
|
|
|
|
if (m_strategy == IMPORT_AND_OVERWRITE) {
|
|
//bool overwritten = false;
|
|
if (TSystem::doesExistFileOrLevel(actualDstPath)) {
|
|
TSystem::removeFileOrLevel(actualDstPath);
|
|
// overwritten = true;
|
|
}
|
|
if (TSystem::doesExistFileOrLevel(srcPath))
|
|
TXshSimpleLevel::copyFiles(actualDstPath, srcPath);
|
|
|
|
return dstPath;
|
|
} else if (m_strategy == IMPORT_AND_RENAME) {
|
|
std::wstring levelName = srcPath.getWideName();
|
|
TLevelSet *parentLevelSet = scene->getLevelSet();
|
|
NameModifier nm(levelName);
|
|
std::wstring newName;
|
|
for (;;) {
|
|
newName = nm.getNext();
|
|
if (!parentLevelSet->hasLevel(newName))
|
|
break;
|
|
}
|
|
|
|
dstPath = dstPath.withName(newName);
|
|
actualDstPath = scene->decodeFilePath(dstPath);
|
|
|
|
if (TSystem::doesExistFileOrLevel(actualDstPath))
|
|
TSystem::removeFileOrLevel(actualDstPath);
|
|
|
|
if (TSystem::doesExistFileOrLevel(srcActualPath)) {
|
|
TXshSimpleLevel::copyFiles(actualDstPath, srcActualPath);
|
|
}
|
|
return dstPath;
|
|
}
|
|
return srcPath;
|
|
}
|
|
|
|
//=============================================================================
|
|
//
|
|
// SceneResource
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
SceneResource::SceneResource(ToonzScene *scene)
|
|
: m_scene(scene), m_untitledScene(scene->isUntitled()), m_oldSavePath(scene->getSavePath())
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
SceneResource::~SceneResource()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SceneResource::updatePath(TFilePath &fp)
|
|
{
|
|
if (m_untitledScene)
|
|
changeSavePath(fp, m_oldSavePath, m_scene->getSavePath());
|
|
}
|
|
|
|
//=============================================================================
|
|
//
|
|
// SceneLevel
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
SceneLevel::SceneLevel(ToonzScene *scene, TXshSimpleLevel *sl)
|
|
: SceneResource(scene), m_sl(sl), m_oldPath(sl->getPath()), m_oldActualPath(scene->decodeFilePath(sl->getPath())), m_oldScannedPath(sl->getScannedPath()), m_oldRefImgPath(), m_oldActualRefImgPath()
|
|
{
|
|
if (m_oldScannedPath != TFilePath())
|
|
m_oldActualScannedPath = m_scene->decodeFilePath(m_oldScannedPath);
|
|
if ((sl->getPath().getType() == "tlv" || sl->getPath().getType() == "pli") && sl->getPalette()) {
|
|
m_oldRefImgPath = sl->getPalette()->getRefImgPath();
|
|
m_oldActualRefImgPath = m_scene->decodeFilePath(m_oldRefImgPath);
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SceneLevel::save()
|
|
{
|
|
TFilePath fp = m_oldPath;
|
|
SceneResource::updatePath(fp);
|
|
TFilePath actualFp = m_scene->decodeFilePath(fp);
|
|
actualFp = restorePsdPath(actualFp);
|
|
TFilePath oldActualPath = restorePsdPath(m_oldActualPath);
|
|
assert(actualFp.getWideString() == L"" || actualFp.getWideString()[0] != L'+');
|
|
if (actualFp != oldActualPath || !TSystem::doesExistFileOrLevel(oldActualPath) || m_sl->getProperties()->getDirtyFlag() || (m_sl->getPalette() && m_sl->getPalette()->getDirtyFlag())) {
|
|
try {
|
|
TSystem::touchParentDir(actualFp);
|
|
if (actualFp != oldActualPath &&
|
|
TSystem::doesExistFileOrLevel(oldActualPath) &&
|
|
m_sl->getProperties()->getDirtyFlag() == false &&
|
|
(!m_sl->getPalette() || (m_sl->getPalette() && m_sl->getPalette()->getDirtyFlag() == false))) {
|
|
try {
|
|
TXshSimpleLevel::copyFiles(actualFp, oldActualPath);
|
|
} catch (...) {
|
|
}
|
|
//Must NOT KEEP FRAMES, it generate a level frames bind necessary to imageBuilder path refresh.
|
|
m_sl->setPath(fp, false);
|
|
} else {
|
|
m_sl->save(actualFp, oldActualPath);
|
|
|
|
if ((actualFp.getType() == "tlv" || actualFp.getType() == "pli") &&
|
|
actualFp != oldActualPath &&
|
|
m_oldRefImgPath != TFilePath()) {
|
|
//Devo preoccuparmi dell'eventuale livello colormodel
|
|
TFilePath actualRefImagPath = m_scene->decodeFilePath(m_oldRefImgPath);
|
|
TFilePath actualRefImagPathTpl = actualRefImagPath.withType("tpl");
|
|
TFilePath oldRefImagPathTpl = m_oldActualRefImgPath.withType("tpl");
|
|
TSystem::copyFile(actualRefImagPath, m_oldActualRefImgPath);
|
|
if (actualRefImagPath.getType() == "tlv")
|
|
TSystem::copyFile(actualRefImagPathTpl, oldRefImagPathTpl);
|
|
}
|
|
|
|
if (actualFp.getType() == "tif" || actualFp.getType() == "tiff" || actualFp.getType() == "tga" || actualFp.getType() == "tzi") {
|
|
TFilePath clnin = oldActualPath.withNoFrame().withType("cln");
|
|
if (TSystem::doesExistFileOrLevel(clnin))
|
|
TSystem::copyFile(actualFp.withNoFrame().withType("cln"), clnin);
|
|
}
|
|
}
|
|
//Se il livello e' tlv verifico se esiste il corrispondente unpainted ed in caso affermativo lo copio.
|
|
//Questo controllo viene fatto qui e non nella copia o nel salvataggio del livello perche' in generale
|
|
//non si vuole che il livello unpainted venga copiato con il livello.
|
|
if (actualFp.getType() == "tlv") {
|
|
TFilePath oldUnpaintedLevelPath = oldActualPath.getParentDir() + "nopaint\\" + TFilePath(oldActualPath.getName() + "_np." + oldActualPath.getType());
|
|
TFilePath unpaintedLevelPath = actualFp.getParentDir() + "nopaint\\" + TFilePath(actualFp.getName() + "_np." + actualFp.getType());
|
|
if (TSystem::doesExistFileOrLevel(oldUnpaintedLevelPath) && !TSystem::doesExistFileOrLevel(unpaintedLevelPath) && TSystem::touchParentDir(unpaintedLevelPath))
|
|
TSystem::copyFile(unpaintedLevelPath, oldUnpaintedLevelPath);
|
|
TFilePath oldUnpaintedPalettePath = oldUnpaintedLevelPath.withType("tpl");
|
|
TFilePath unpaintedPalettePath = unpaintedLevelPath.withType("tpl");
|
|
if (TSystem::doesExistFileOrLevel(oldUnpaintedPalettePath) && !TSystem::doesExistFileOrLevel(unpaintedPalettePath) && TSystem::touchParentDir(unpaintedPalettePath))
|
|
TSystem::copyFile(unpaintedPalettePath, oldUnpaintedPalettePath);
|
|
}
|
|
} catch (...) {
|
|
}
|
|
}
|
|
fp = m_oldScannedPath;
|
|
if (fp != TFilePath()) {
|
|
SceneResource::updatePath(fp);
|
|
actualFp = m_scene->decodeFilePath(fp);
|
|
if (actualFp != m_oldActualScannedPath &&
|
|
TSystem::doesExistFileOrLevel(m_oldActualScannedPath)) {
|
|
try {
|
|
TSystem::touchParentDir(actualFp);
|
|
TSystem::copyFileOrLevel_throw(actualFp, m_oldActualScannedPath);
|
|
m_sl->clearFrames();
|
|
m_sl->load();
|
|
} catch (...) {
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SceneLevel::updatePath()
|
|
{
|
|
if (!m_untitledScene)
|
|
return;
|
|
TFilePath fp = m_oldPath;
|
|
SceneResource::updatePath(fp);
|
|
m_sl->setPath(fp, true);
|
|
fp = m_oldScannedPath;
|
|
SceneResource::updatePath(fp);
|
|
m_sl->setScannedPath(fp);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SceneLevel::rollbackPath()
|
|
{
|
|
if (!m_untitledScene)
|
|
return;
|
|
m_sl->setPath(m_oldPath, true);
|
|
m_sl->setScannedPath(m_oldScannedPath);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool SceneLevel::isDirty()
|
|
{
|
|
if (m_sl->getProperties()->getDirtyFlag() ||
|
|
(m_sl->getPalette() && m_sl->getPalette()->getDirtyFlag()))
|
|
return true;
|
|
else
|
|
return false;
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString SceneLevel::getResourceName()
|
|
{
|
|
QString string;
|
|
bool levelIsDirty = false;
|
|
if (m_sl->getProperties()->getDirtyFlag()) {
|
|
string += QString::fromStdString(m_sl->getPath().getLevelName());
|
|
levelIsDirty = true;
|
|
}
|
|
if (m_sl->getPalette() && m_sl->getPalette()->getDirtyFlag()) {
|
|
if (levelIsDirty)
|
|
string += " and ";
|
|
if (m_sl->getPath().getType() == "pli")
|
|
string += QString::fromStdWString(m_sl->getPalette()->getPaletteName()) + ".pli (palette)";
|
|
else
|
|
string += QString::fromStdWString(m_sl->getPalette()->getPaletteName()) + ".tpl";
|
|
}
|
|
|
|
return string;
|
|
}
|
|
|
|
//=============================================================================
|
|
//
|
|
// ScenePalette
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ScenePalette::ScenePalette(ToonzScene *scene, TXshPaletteLevel *pl)
|
|
: SceneResource(scene), m_pl(pl), m_oldPath(pl->getPath()), m_oldActualPath(scene->decodeFilePath(pl->getPath()))
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ScenePalette::save()
|
|
{
|
|
assert(m_oldPath != TFilePath());
|
|
TFilePath fp = m_oldPath;
|
|
SceneResource::updatePath(fp);
|
|
TFilePath actualFp = m_scene->decodeFilePath(fp);
|
|
try {
|
|
TSystem::touchParentDir(actualFp);
|
|
if (actualFp != m_oldActualPath && TSystem::doesExistFileOrLevel(m_oldActualPath)) {
|
|
TSystem::copyFile(actualFp, m_oldActualPath);
|
|
}
|
|
m_pl->save(); // actualFp non so perche' era cosi'
|
|
} catch (...) {
|
|
TLogger::error() << "Can't save " << actualFp;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ScenePalette::updatePath()
|
|
{
|
|
TFilePath fp = m_oldPath;
|
|
SceneResource::updatePath(fp);
|
|
if (fp != m_oldPath)
|
|
m_pl->setPath(fp);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ScenePalette::rollbackPath()
|
|
{
|
|
m_pl->setPath(m_oldPath);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool ScenePalette::isDirty()
|
|
{
|
|
return m_pl->getPalette()->getDirtyFlag();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
QString ScenePalette::getResourceName()
|
|
{
|
|
return QString::fromStdString(m_pl->getPath().getLevelName());
|
|
}
|
|
|
|
//=============================================================================
|
|
//
|
|
// SceneSound
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
SceneSound::SceneSound(ToonzScene *scene, TXshSoundLevel *sl)
|
|
: SceneResource(scene), m_sl(sl), m_oldPath(sl->getPath()), m_oldActualPath(scene->decodeFilePath(sl->getPath()))
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SceneSound::save()
|
|
{
|
|
assert(m_oldPath != TFilePath());
|
|
TFilePath fp = m_oldPath;
|
|
SceneResource::updatePath(fp);
|
|
TFilePath actualFp = m_scene->decodeFilePath(fp);
|
|
try {
|
|
TSystem::touchParentDir(actualFp);
|
|
if (!TSystem::doesExistFileOrLevel(m_oldActualPath)) {
|
|
m_sl->save(actualFp);
|
|
} else if (actualFp != m_oldActualPath) {
|
|
TSystem::copyFile(actualFp, m_oldActualPath);
|
|
}
|
|
} catch (...) {
|
|
TLogger::error() << "Can't save " << actualFp;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SceneSound::updatePath()
|
|
{
|
|
TFilePath fp = m_oldPath;
|
|
SceneResource::updatePath(fp);
|
|
if (fp != m_oldPath)
|
|
m_sl->setPath(fp);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SceneSound::rollbackPath()
|
|
{
|
|
m_sl->setPath(m_oldPath);
|
|
}
|
|
|
|
//=============================================================================
|
|
//
|
|
// SceneResources
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
SceneResources::SceneResources(ToonzScene *scene, TXsheet *subXsheet)
|
|
: m_scene(scene), m_commitDone(false), m_wasUntitled(scene->isUntitled()), m_subXsheet(subXsheet)
|
|
{
|
|
getResources();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
SceneResources::~SceneResources()
|
|
{
|
|
if (!m_commitDone)
|
|
rollbackPaths();
|
|
clearPointerContainer(m_resources);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SceneResources::getResources()
|
|
{
|
|
ToonzScene *scene = m_scene;
|
|
std::vector<TXshLevel *> levels;
|
|
scene->getLevelSet()->listLevels(levels);
|
|
std::vector<TXshLevel *>::iterator it;
|
|
|
|
for (it = levels.begin(); it != levels.end(); ++it) {
|
|
TXshSimpleLevel *sl = (*it)->getSimpleLevel();
|
|
if (sl)
|
|
m_resources.push_back(new SceneLevel(scene, sl));
|
|
TXshPaletteLevel *pl = (*it)->getPaletteLevel();
|
|
if (pl)
|
|
m_resources.push_back(new ScenePalette(scene, pl));
|
|
TXshSoundLevel *sdl = (*it)->getSoundLevel();
|
|
if (sdl)
|
|
m_resources.push_back(new SceneSound(scene, sdl));
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SceneResources::save(const TFilePath newScenePath)
|
|
{
|
|
TFilePath oldScenePath = m_scene->getScenePath();
|
|
m_scene->setScenePath(newScenePath);
|
|
for (int i = 0; i < (int)m_resources.size(); i++)
|
|
m_resources[i]->save();
|
|
m_scene->setScenePath(oldScenePath);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SceneResources::updatePaths()
|
|
{
|
|
for (int i = 0; i < (int)m_resources.size(); i++)
|
|
m_resources[i]->updatePath();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SceneResources::rollbackPaths()
|
|
{
|
|
for (int i = 0; i < (int)m_resources.size(); i++)
|
|
m_resources[i]->rollbackPath();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void SceneResources::accept(ResourceProcessor *processor, bool autoCommit)
|
|
{
|
|
for (int i = 0; i < (int)m_resources.size() && !processor->aborted(); i++)
|
|
m_resources[i]->accept(processor);
|
|
if (autoCommit)
|
|
commit();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//return the name list of dirty resources
|
|
void SceneResources::getDirtyResources(std::vector<QString> &dirtyResources)
|
|
{
|
|
for (int i = 0; i < (int)m_resources.size(); i++)
|
|
if (m_resources[i]->isDirty()) {
|
|
dirtyResources.push_back(m_resources[i]->getResourceName());
|
|
}
|
|
}
|
|
|
|
//=============================================================================
|
|
//
|
|
// ResourceImporter
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ResourceImporter::ResourceImporter(
|
|
ToonzScene *scene,
|
|
TProject *dstProject,
|
|
ResourceImportStrategy &importStrategy)
|
|
: m_scene(scene), m_dstProject(dstProject), m_dstScene(new ToonzScene()), m_importStrategy(importStrategy)
|
|
{
|
|
m_dstScene->setProject(dstProject);
|
|
TFilePath newFp =
|
|
dstProject->getScenesPath() + (scene->getScenePath() - scene->getProject()->getScenesPath());
|
|
makeUnique(newFp);
|
|
m_dstScene->setScenePath(newFp);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ResourceImporter::~ResourceImporter()
|
|
{
|
|
delete m_dstScene;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool ResourceImporter::makeUnique(TFilePath &path)
|
|
{
|
|
return makePathUnique(m_dstScene, path);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TFilePath ResourceImporter::getImportedScenePath() const
|
|
{
|
|
return m_dstScene->getScenePath();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TFilePath ResourceImporter::codePath(const TFilePath &oldPath, const TFilePath &newActualPath)
|
|
{
|
|
return oldPath.withName(newActualPath.getName());
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
std::string ResourceImporter::extractPsdSuffix(TFilePath &path)
|
|
{
|
|
if (path.getType() != "psd")
|
|
return "";
|
|
std::string name = path.getName();
|
|
int i = name.find("#");
|
|
if (i == std::string::npos)
|
|
return "";
|
|
std::string suffix = name.substr(i);
|
|
path = path.withName(name.substr(0, i));
|
|
return suffix;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
TFilePath ResourceImporter::buildPsd(const TFilePath &basePath, const std::string &suffix)
|
|
{
|
|
return basePath.withName(basePath.getName() + suffix);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ResourceImporter::process(TXshSimpleLevel *sl)
|
|
{
|
|
if (sl->getPath().isAbsolute())
|
|
return;
|
|
TFilePath newPath;
|
|
|
|
TFilePath slPath = sl->getPath();
|
|
std::string suffix = extractPsdSuffix(slPath);
|
|
|
|
TFilePath imgRefPath;
|
|
if (sl->getPalette())
|
|
imgRefPath = sl->getPalette()->getRefImgPath();
|
|
newPath = m_importStrategy.process(m_dstScene, m_scene, slPath);
|
|
if (imgRefPath != TFilePath() && !m_dstScene->isExternPath(m_dstScene->decodeFilePath(imgRefPath)))
|
|
m_importStrategy.process(m_dstScene, m_scene, imgRefPath);
|
|
|
|
if (suffix != "")
|
|
newPath = buildPsd(newPath, suffix);
|
|
|
|
sl->setPath(newPath);
|
|
if (sl->getScannedPath() != TFilePath()) {
|
|
newPath = m_importStrategy.process(m_dstScene, m_scene, sl->getScannedPath());
|
|
sl->setScannedPath(newPath);
|
|
}
|
|
sl->setDirtyFlag(false);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ResourceImporter::process(TXshPaletteLevel *pl)
|
|
{
|
|
if (pl->getPath().isAbsolute())
|
|
return;
|
|
TFilePath newPath;
|
|
newPath = m_importStrategy.process(m_dstScene, m_scene, pl->getPath());
|
|
pl->setPath(newPath);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ResourceImporter::process(TXshSoundLevel *sl)
|
|
{
|
|
if (sl->getPath().isAbsolute())
|
|
return;
|
|
TFilePath newPath;
|
|
newPath = m_importStrategy.process(m_dstScene, m_scene, sl->getPath());
|
|
sl->setPath(newPath);
|
|
}
|
|
|
|
//=============================================================================
|
|
//
|
|
// ResourceCollector
|
|
//
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ResourceCollector::ResourceCollector(ToonzScene *scene)
|
|
: m_scene(scene), m_count(0)
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
ResourceCollector::~ResourceCollector()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
bool ResourceCollector::makeUnique(TFilePath &path)
|
|
{
|
|
return makePathUnique(m_scene, path);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ResourceCollector::process(TXshSimpleLevel *sl)
|
|
{
|
|
TFilePath path = sl->getPath();
|
|
std::string suffix = ResourceImporter::extractPsdSuffix(path);
|
|
std::map<TFilePath, TFilePath>::iterator it = m_collectedFiles.find(path);
|
|
if (it != m_collectedFiles.end()) {
|
|
TFilePath destPath = it->second;
|
|
if (suffix != "")
|
|
destPath = ResourceImporter::buildPsd(destPath, suffix);
|
|
sl->setPath(destPath);
|
|
} else {
|
|
TFilePath collectedPath = path;
|
|
if (getCollectedPath(m_scene, collectedPath)) {
|
|
TFilePath actualCollectedPath = m_scene->decodeFilePath(collectedPath);
|
|
if (actualCollectedPath != path && TSystem::doesExistFileOrLevel(path) &&
|
|
!TSystem::doesExistFileOrLevel(actualCollectedPath)) {
|
|
try {
|
|
TSystem::touchParentDir(actualCollectedPath);
|
|
TXshSimpleLevel::copyFiles(actualCollectedPath, path);
|
|
} catch (...) {
|
|
}
|
|
}
|
|
++m_count;
|
|
TFilePath destPath = collectedPath;
|
|
if (suffix != "")
|
|
destPath = ResourceImporter::buildPsd(destPath, suffix);
|
|
sl->setPath(destPath);
|
|
m_collectedFiles[path] = collectedPath;
|
|
}
|
|
}
|
|
|
|
if (sl->getScannedPath() != TFilePath()) {
|
|
path = sl->getScannedPath();
|
|
TFilePath collectedPath = path;
|
|
if (getCollectedPath(m_scene, collectedPath)) {
|
|
TFilePath actualCollectedPath = m_scene->decodeFilePath(collectedPath);
|
|
if (actualCollectedPath != path && TSystem::doesExistFileOrLevel(path)) {
|
|
try {
|
|
TSystem::touchParentDir(actualCollectedPath);
|
|
TXshSimpleLevel::copyFiles(actualCollectedPath, path);
|
|
} catch (...) {
|
|
}
|
|
}
|
|
sl->setScannedPath(collectedPath);
|
|
m_count++;
|
|
}
|
|
}
|
|
sl->setDirtyFlag(false);
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ResourceCollector::process(TXshSoundLevel *sl)
|
|
{
|
|
TFilePath path = sl->getPath();
|
|
TFilePath collectedPath = path;
|
|
if (!getCollectedPath(m_scene, collectedPath))
|
|
return;
|
|
|
|
TFilePath actualCollectedPath = m_scene->decodeFilePath(collectedPath);
|
|
if (actualCollectedPath != path && TSystem::doesExistFileOrLevel(path)) {
|
|
try {
|
|
TSystem::touchParentDir(actualCollectedPath);
|
|
TXshSimpleLevel::copyFiles(actualCollectedPath, path);
|
|
|
|
} catch (...) {
|
|
}
|
|
}
|
|
sl->setPath(collectedPath);
|
|
m_count++;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
void ResourceCollector::process(TXshPaletteLevel *pl)
|
|
{
|
|
TFilePath path = pl->getPath();
|
|
TFilePath collectedPath = path;
|
|
if (!getCollectedPath(m_scene, collectedPath))
|
|
return;
|
|
|
|
TFilePath actualCollectedPath = m_scene->decodeFilePath(collectedPath);
|
|
if (actualCollectedPath != path && TSystem::doesExistFileOrLevel(path)) {
|
|
try {
|
|
TSystem::touchParentDir(actualCollectedPath);
|
|
TXshSimpleLevel::copyFiles(actualCollectedPath, path);
|
|
|
|
} catch (...) {
|
|
}
|
|
}
|
|
pl->setPath(collectedPath);
|
|
m_count++;
|
|
}
|