// -----------------------------------------------------------------------------
// Creates a new archive of the specified format and adds it to the list of open
// archives. Returns the created archive, or nullptr if an invalid archive type
// was given
// -----------------------------------------------------------------------------
Archive* ArchiveManager::newArchive(const string& format)
{
// Create a new archive depending on the type specified
Archive* new_archive;
if (format == "wad")
new_archive = new WadArchive();
else if (format == "zip")
new_archive = new ZipArchive();
else
{
Global::error = S_FMT("Can not create archive of format: %s", CHR(format));
Log::error(Global::error);
return nullptr;
}
// If the archive was created, set its filename and add it to the list
if (new_archive)
{
new_archive->setFilename(S_FMT("UNSAVED (%s)", new_archive->formatDesc().name));
addArchive(new_archive);
}
// Return the created archive, if any
return new_archive;
}
/* ArchiveManager::newArchive
* Creates a new archive of the specified format and adds it to the
* list of open archives. Returns the created archive, or NULL if an
* invalid archive type was given
*******************************************************************/
Archive* ArchiveManager::newArchive(uint8_t type)
{
// Init variables
Archive* new_archive = NULL;
string format_str = "";
// Create a new archive depending on the type specified
switch (type)
{
case ARCHIVE_WAD:
new_archive = new WadArchive();
format_str = "wad";
break;
case ARCHIVE_ZIP:
new_archive = new ZipArchive();
format_str = "zip";
break;
default:
wxLogMessage("This shouldn't happen.");
return NULL;
}
// If the archive was created, set its filename and add it to the list
if (new_archive)
{
new_archive->setFilename(S_FMT("UNSAVED (%s)", format_str));
addArchive(new_archive);
}
// Return the created archive, if any
return new_archive;
}
// -----------------------------------------------------------------------------
// Opens [dir] as a DirArchive and adds it to the list.
// Returns a pointer to the archive or nullptr if an error occurred.
// -----------------------------------------------------------------------------
Archive* ArchiveManager::openDirArchive(const string& dir, bool manage, bool silent)
{
auto new_archive = getArchive(dir);
LOG_MESSAGE(1, "Opening directory %s as archive", dir);
// If the archive is already open, just return it
if (new_archive)
{
// Announce open
if (!silent)
{
MemChunk mc;
uint32_t index = archiveIndex(new_archive);
mc.write(&index, 4);
announce("archive_opened", mc);
}
return new_archive;
}
new_archive = new DirArchive();
// If it opened successfully, add it to the list if needed & return it,
// Otherwise, delete it and return nullptr
if (new_archive->open(dir))
{
if (manage)
{
// Add the archive
addArchive(new_archive);
// Announce open
if (!silent)
{
MemChunk mc;
uint32_t index = archiveIndex(new_archive);
mc.write(&index, 4);
announce("archive_opened", mc);
}
// Add to recent files
addRecentFile(dir);
}
// Return the opened archive
return new_archive;
}
else
{
LOG_MESSAGE(1, "Error: " + Global::error);
delete new_archive;
return nullptr;
}
}
Common::String Disk_ns::selectArchive(const Common::String& name) {
Common::String oldName = _resArchiveName;
if (_sset.hasArchive(name)) {
return oldName;
}
if (!_resArchiveName.empty()) {
_sset.remove(_resArchiveName);
}
_resArchiveName = name;
addArchive(name, NORMAL_ARCHIVE_PRIORITY);
return oldName;
}
void Disk_ns::setLanguage(uint16 language) {
debugC(1, kDebugDisk, "setLanguage(%i)", language);
assert(language < 4);
if (!_language.empty()) {
_sset.remove(_language);
}
static const char *languages[] = { "it", "fr", "en", "ge" };
_language = languages[language];
if (_sset.hasArchive(_language)) {
return;
}
addArchive(_language, LOWEST_ARCHIVE_PRIORITY);
}
Alembic::Abc::IArchive * getArchiveFromID(XSI::CString path)
{
std::map<std::string,Alembic::Abc::IArchive *>::iterator it;
it = gArchives.find(path.GetAsciiString());
if(it == gArchives.end())
{
// check if the file exists
FILE * file = fopen(path.GetAsciiString(),"rb");
if(file != NULL)
{
fclose(file);
addArchive(new Alembic::Abc::IArchive( Alembic::AbcCoreHDF5::ReadArchive(), path.GetAsciiString()));
return getArchiveFromID(path);
}
return NULL;
}
return it->second;
}
Alembic::Abc::IArchive* getArchiveFromID(std::string const& path)
{
ESS_PROFILE_SCOPE("getArchiveFromID-1");
std::map<std::string, AlembicArchiveInfo>::iterator it;
std::string resolvedPath = resolvePath(path);
it = gArchives.find(resolvedPath);
if (it == gArchives.end()) {
// check if the file exists
if (!boost::filesystem::exists(resolvedPath.c_str())) {
ESS_LOG_ERROR("Can't find Alembic file. Path: "
<< path << " Resolved path: " << resolvedPath);
return NULL;
}
FILE* file = fopen(resolvedPath.c_str(), "rb");
if (file == NULL) {
return NULL;
}
else {
fclose(file);
AbcF::IFactory iFactory;
AbcF::IFactory::CoreType oType;
addArchive(new Abc::IArchive(iFactory.getArchive(resolvedPath, oType)));
// addArchive(new Abc::IArchive( Alembic::AbcCoreHDF5::ReadArchive(),
// resolvedPath));
Abc::IArchive* pArchive = gArchives.find(resolvedPath)->second.archive;
EC_LOG_INFO("Opening Abc Archive: " << pArchive->getName());
return pArchive;
}
}
return it->second.archive;
}
void DosDisk_ns::init() {
// setup permament archives
addArchive("disk1", LOW_ARCHIVE_PRIORITY);
}
// -----------------------------------------------------------------------------
// Same as the above function, except it opens from an ArchiveEntry
// -----------------------------------------------------------------------------
Archive* ArchiveManager::openArchive(ArchiveEntry* entry, bool manage, bool silent)
{
// Check entry was given
if (!entry)
return nullptr;
// Check if the entry is already opened
for (auto& open_archive : open_archives_)
{
if (open_archive.archive->parentEntry() == entry)
{
// Announce open
if (!silent)
{
MemChunk mc;
uint32_t index = archiveIndex(open_archive.archive);
mc.write(&index, 4);
announce("archive_opened", mc);
}
return open_archive.archive;
}
}
// Check entry type
Archive* new_archive;
if (WadArchive::isWadArchive(entry->data()))
new_archive = new WadArchive();
else if (ZipArchive::isZipArchive(entry->data()))
new_archive = new ZipArchive();
else if (ResArchive::isResArchive(entry->data()))
new_archive = new ResArchive();
else if (LibArchive::isLibArchive(entry->data()))
new_archive = new LibArchive();
else if (DatArchive::isDatArchive(entry->data()))
new_archive = new DatArchive();
else if (PakArchive::isPakArchive(entry->data()))
new_archive = new PakArchive();
else if (BSPArchive::isBSPArchive(entry->data()))
new_archive = new BSPArchive();
else if (GrpArchive::isGrpArchive(entry->data()))
new_archive = new GrpArchive();
else if (RffArchive::isRffArchive(entry->data()))
new_archive = new RffArchive();
else if (GobArchive::isGobArchive(entry->data()))
new_archive = new GobArchive();
else if (LfdArchive::isLfdArchive(entry->data()))
new_archive = new LfdArchive();
else if (HogArchive::isHogArchive(entry->data()))
new_archive = new HogArchive();
else if (ADatArchive::isADatArchive(entry->data()))
new_archive = new ADatArchive();
else if (Wad2Archive::isWad2Archive(entry->data()))
new_archive = new Wad2Archive();
else if (WadJArchive::isWadJArchive(entry->data()))
new_archive = new WadJArchive();
else if (WolfArchive::isWolfArchive(entry->data()))
new_archive = new WolfArchive();
else if (GZipArchive::isGZipArchive(entry->data()))
new_archive = new GZipArchive();
else if (BZip2Archive::isBZip2Archive(entry->data()))
new_archive = new BZip2Archive();
else if (TarArchive::isTarArchive(entry->data()))
new_archive = new TarArchive();
else if (DiskArchive::isDiskArchive(entry->data()))
new_archive = new DiskArchive();
else if (entry->name().Lower().EndsWith(".pod") && PodArchive::isPodArchive(entry->data()))
new_archive = new PodArchive();
else if (ChasmBinArchive::isChasmBinArchive(entry->data()))
new_archive = new ChasmBinArchive();
else if (SiNArchive::isSiNArchive(entry->data()))
new_archive = new SiNArchive();
else
{
// Unsupported format
Global::error = "Unsupported or invalid Archive format";
return nullptr;
}
// If it opened successfully, add it to the list & return it,
// Otherwise, delete it and return nullptr
if (new_archive->open(entry))
{
if (manage)
{
// Add to parent's child list if parent is open in the manager (it should be)
int index_parent = -1;
if (entry->parent())
index_parent = archiveIndex(entry->parent());
if (index_parent >= 0)
open_archives_[index_parent].open_children.push_back(new_archive);
// Add the new archive
addArchive(new_archive);
// Announce open
if (!silent)
{
MemChunk mc;
uint32_t index = archiveIndex(new_archive);
mc.write(&index, 4);
announce("archive_opened", mc);
}
}
return new_archive;
}
else
{
LOG_MESSAGE(1, "Error: " + Global::error);
delete new_archive;
return nullptr;
}
}
// -----------------------------------------------------------------------------
// Opens and adds a archive to the list, returns a pointer to the newly opened
// and added archive, or nullptr if an error occurred
// -----------------------------------------------------------------------------
Archive* ArchiveManager::openArchive(const string& filename, bool manage, bool silent)
{
// Check for directory
if (!wxFile::Exists(filename) && wxDirExists(filename))
return openDirArchive(filename, manage, silent);
auto new_archive = getArchive(filename);
LOG_MESSAGE(1, "Opening archive %s", filename);
// If the archive is already open, just return it
if (new_archive)
{
// Announce open
if (!silent)
{
MemChunk mc;
uint32_t index = archiveIndex(new_archive);
mc.write(&index, 4);
announce("archive_opened", mc);
}
return new_archive;
}
// Determine file format
if (WadArchive::isWadArchive(filename))
new_archive = new WadArchive();
else if (ZipArchive::isZipArchive(filename))
new_archive = new ZipArchive();
else if (ResArchive::isResArchive(filename))
new_archive = new ResArchive();
else if (DatArchive::isDatArchive(filename))
new_archive = new DatArchive();
else if (LibArchive::isLibArchive(filename))
new_archive = new LibArchive();
else if (PakArchive::isPakArchive(filename))
new_archive = new PakArchive();
else if (BSPArchive::isBSPArchive(filename))
new_archive = new BSPArchive();
else if (GrpArchive::isGrpArchive(filename))
new_archive = new GrpArchive();
else if (RffArchive::isRffArchive(filename))
new_archive = new RffArchive();
else if (GobArchive::isGobArchive(filename))
new_archive = new GobArchive();
else if (LfdArchive::isLfdArchive(filename))
new_archive = new LfdArchive();
else if (HogArchive::isHogArchive(filename))
new_archive = new HogArchive();
else if (ADatArchive::isADatArchive(filename))
new_archive = new ADatArchive();
else if (Wad2Archive::isWad2Archive(filename))
new_archive = new Wad2Archive();
else if (WadJArchive::isWadJArchive(filename))
new_archive = new WadJArchive();
else if (WolfArchive::isWolfArchive(filename))
new_archive = new WolfArchive();
else if (GZipArchive::isGZipArchive(filename))
new_archive = new GZipArchive();
else if (BZip2Archive::isBZip2Archive(filename))
new_archive = new BZip2Archive();
else if (TarArchive::isTarArchive(filename))
new_archive = new TarArchive();
else if (DiskArchive::isDiskArchive(filename))
new_archive = new DiskArchive();
else if (PodArchive::isPodArchive(filename))
new_archive = new PodArchive();
else if (ChasmBinArchive::isChasmBinArchive(filename))
new_archive = new ChasmBinArchive();
else if (SiNArchive::isSiNArchive(filename))
new_archive = new SiNArchive();
else
{
// Unsupported format
Global::error = "Unsupported or invalid Archive format";
return nullptr;
}
// If it opened successfully, add it to the list if needed & return it,
// Otherwise, delete it and return nullptr
if (new_archive->open(filename))
{
if (manage)
{
// Add the archive
addArchive(new_archive);
// Announce open
if (!silent)
{
MemChunk mc;
uint32_t index = archiveIndex(new_archive);
mc.write(&index, 4);
announce("archive_opened", mc);
}
// Add to recent files
addRecentFile(filename);
}
// Return the opened archive
return new_archive;
}
else
{
LOG_MESSAGE(1, "Error: " + Global::error);
delete new_archive;
return nullptr;
}
}
/* ArchiveManager::openArchive
* Same as the above function, except it opens from an ArchiveEntry
*******************************************************************/
Archive* ArchiveManager::openArchive(ArchiveEntry* entry, bool manage, bool silent)
{
Archive* new_archive = NULL;
// Check entry was given
if (!entry)
return NULL;
// Check if the entry is already opened
for (size_t a = 0; a < open_archives.size(); a++)
{
if (open_archives[a].archive->getParent() == entry)
{
// Announce open
if (!silent)
{
MemChunk mc;
uint32_t index = archiveIndex(open_archives[a].archive);
mc.write(&index, 4);
announce("archive_opened", mc);
}
return open_archives[a].archive;
}
}
// Check entry type
if (WadArchive::isWadArchive(entry->getMCData()))
new_archive = new WadArchive();
else if (ZipArchive::isZipArchive(entry->getMCData()))
new_archive = new ZipArchive();
else if (ResArchive::isResArchive(entry->getMCData()))
new_archive = new ResArchive();
else if (LibArchive::isLibArchive(entry->getMCData()))
new_archive = new LibArchive();
else if (DatArchive::isDatArchive(entry->getMCData()))
new_archive = new DatArchive();
else if (PakArchive::isPakArchive(entry->getMCData()))
new_archive = new PakArchive();
else if (BSPArchive::isBSPArchive(entry->getMCData()))
new_archive = new BSPArchive();
else if (GrpArchive::isGrpArchive(entry->getMCData()))
new_archive = new GrpArchive();
else if (RffArchive::isRffArchive(entry->getMCData()))
new_archive = new RffArchive();
else if (GobArchive::isGobArchive(entry->getMCData()))
new_archive = new GobArchive();
else if (LfdArchive::isLfdArchive(entry->getMCData()))
new_archive = new LfdArchive();
else if (HogArchive::isHogArchive(entry->getMCData()))
new_archive = new HogArchive();
else if (ADatArchive::isADatArchive(entry->getMCData()))
new_archive = new ADatArchive();
else if (Wad2Archive::isWad2Archive(entry->getMCData()))
new_archive = new Wad2Archive();
else if (WadJArchive::isWadJArchive(entry->getMCData()))
new_archive = new WadJArchive();
else if (WolfArchive::isWolfArchive(entry->getMCData()))
new_archive = new WolfArchive();
else if (GZipArchive::isGZipArchive(entry->getMCData()))
new_archive = new GZipArchive();
else if (BZip2Archive::isBZip2Archive(entry->getMCData()))
new_archive = new BZip2Archive();
else if (TarArchive::isTarArchive(entry->getMCData()))
new_archive = new TarArchive();
else if (DiskArchive::isDiskArchive(entry->getMCData()))
new_archive = new DiskArchive();
else
{
// Unsupported format
Global::error = "Unsupported or invalid Archive format";
return NULL;
}
// If it opened successfully, add it to the list & return it,
// Otherwise, delete it and return NULL
if (new_archive->open(entry))
{
if (manage)
{
// Add to parent's child list if parent is open in the manager (it should be)
int index_parent = -1;
if (entry->getParent())
index_parent = archiveIndex(entry->getParent());
if (index_parent >= 0)
open_archives[index_parent].open_children.push_back(new_archive);
// Add the new archive
addArchive(new_archive);
// Announce open
if (!silent)
{
MemChunk mc;
uint32_t index = archiveIndex(new_archive);
mc.write(&index, 4);
announce("archive_opened", mc);
}
}
return new_archive;
}
else
{
wxLogMessage("Error: " + Global::error);
delete new_archive;
return NULL;
}
}
