void serialize(ArchivePtr& par)
{
par->update(m_b);
par->update(m_d);
par->update(m_i);
par->update(m_str);
}
void TestParser(const String& dir, const String& suff, const String& pattern) {
suffix = suff;
ArchivePtr arch = FileSystem::Instance().OpenArchive("EngineData");
if (arch) {
arch->Scan(this, dir + "/" + pattern);
}
}
void ResourceLoader::loadFromModel( Path path2model, const Directory dir )
{
VariantMap archives = config::load( path2model );
for( auto& entry : archives )
{
Path absArchivePath( entry.second.toString() );
if( !absArchivePath.exist() )
{
Path rpath = entry.second.toString();
absArchivePath = dir/rpath;
}
Logger::warning( "ResourceLoader: try mount archive " + absArchivePath.toString() );
Directory absDir = absArchivePath.directory();
absArchivePath = absDir.find( absArchivePath.baseName(), Path::ignoreCase );
ArchivePtr archive = FileSystem::instance().mountArchive( absArchivePath );
if( archive.isValid() )
{
emit _d->onStartLoadingSignal( entry.first );
NFile archiveInfo = archive->createAndOpenFile( archiveDescFile );
loadAtlases( archiveInfo, true );
//FileSystem::instance().unmountArchive( archive );
}
else
{
Logger::warning( "ResourceLoader: cannot load archive " + absArchivePath.toString() );
}
}
}
void ResourceLoader::loadFiles(Path path)
{
ArchivePtr archive = FileSystem::instance().mountArchive( path );
if( archive.isValid() )
{
loadFiles( archive );
FileSystem::instance().unmountArchive( archive );
}
}
void ViewArea::storeAllViewAreaLayouts(ArchivePtr archive)
{
ListingPtr layouts = new Listing();
for(size_t i=0; i < viewAreas.size(); ++i){
ArchivePtr layout = new Archive();
layout->inheritSharedInfoFrom(*archive);
viewAreas[i]->storeLayout(layout);
layouts->append(layout);
}
if(!layouts->empty()){
archive->insert("viewAreas", layouts);
}
}
bool ItemTreeArchiver::restore(ArchivePtr archive, ItemPtr parentItem)
{
bool result = false;
archive->setCurrentParentItem(0);
try {
result = restoreItemIter(archive.get(), parentItem);
} catch (const YamlNode::Exception& ex) {
messageView->put(ex.message());
}
archive->setCurrentParentItem(0);
return result;
}
void initialize(ClimateType climate)
{
VariantMap climateArchives = config::load( SETTINGS_RC_PATH( climateModel ) );
std::string optName;
if( climate == central ) {
optName = CAESARIA_STR_A(central);
}
else if( climate == northen ) {
optName = "north";
}
else if( climate == desert ) {
optName = "south";
}
StringArray archives = climateArchives.get( optName ).toStringArray();
for( auto& str : archives )
{
Path archivePath = str;
Directory dir = archivePath.directory();
archivePath = dir.find( archivePath.baseName(), Path::ignoreCase );
ArchivePtr archive = FileSystem::instance().mountArchive( archivePath );
if( archive.isNull() )
{
Logger::warning( "ClimateManager: can't load file " + archivePath.toString() );
continue;
}
ResourceLoader rc;
NFile atlasInfo = archive->createAndOpenFile( "info" );
if( atlasInfo.isOpen() )
{
rc.loadAtlases( atlasInfo, false );
}
else
{
rc.loadFiles( archive );
}
}
}
bool SensorVisualizerItem::store(Archive& archive)
{
ListingPtr subItems = new Listing();
for(size_t i=0; i < impl->subItems.size(); i++){
Item* item = impl->subItems[i];
string pluginName, className;
ItemManager::getClassIdentifier(item, pluginName, className);
ArchivePtr subArchive = new Archive();
subArchive->write("class", className);
subArchive->write("name", item->name());
item->store(*subArchive);
subItems->append(subArchive);
}
archive.insert("subItems", subItems);
return true;
}
void ResourceLoader::loadFiles(ArchivePtr archive)
{
const vfs::Entries::Items& files = archive->entries()->items();
gfx::PictureBank& pb = gfx::PictureBank::instance();
std::string basename;
basename.reserve( 256 );
for( auto& entry : files )
{
NFile file = archive->createAndOpenFile( entry.name );
if( file.isOpen() )
{
gfx::Picture pic = PictureLoader::instance().load( file );
if( pic.isValid() )
{
basename = entry.name.baseName().toString();
pb.setPicture( basename, pic );
}
}
}
}
void ArchiveListWidget::deleteItem()
{
ArchiveListWidgetItem *archiveItem =
qobject_cast<ArchiveListWidgetItem *>(sender());
if(archiveItem)
{
ArchivePtr archive = archiveItem->archive();
QMessageBox::StandardButton confirm =
QMessageBox::question(this, tr("Confirm delete"),
tr("Are you sure you want to delete"
" archive %1 (this cannot be undone)?")
.arg(archive->name()));
if(confirm == QMessageBox::Yes)
{
QList<ArchivePtr> archiveList;
archiveList.append(archive);
emit deleteArchives(archiveList);
}
}
}
bool ViewManager::storeViewStates(ArchivePtr archive, const std::string& key)
{
// assign view ids first
int id = 0;
ModuleNameToClassNameToViewInfoMap::iterator p;
for(p = moduleNameToClassNameToViewInfoMap.begin(); p != moduleNameToClassNameToViewInfoMap.end(); ++p){
ClassNameToViewInfoMap& viewInfoMap = *p->second;
for(ClassNameToViewInfoMap::iterator q = viewInfoMap.begin(); q != viewInfoMap.end(); ++q){
ViewInfoPtr& viewInfo = q->second;
InstanceInfoList& instances = viewInfo->instances;
for(InstanceInfoList::iterator p = instances.begin(); p != instances.end(); ++p){
archive->registerViewId((*p)->view, id++);
}
}
}
ListingPtr viewList = new Listing();
for(p = moduleNameToClassNameToViewInfoMap.begin(); p != moduleNameToClassNameToViewInfoMap.end(); ++p){
const std::string& moduleName = p->first;
ClassNameToViewInfoMap& viewInfoMap = *p->second;
for(ClassNameToViewInfoMap::iterator q = viewInfoMap.begin(); q != viewInfoMap.end(); ++q){
ViewInfoPtr& viewInfo = q->second;
InstanceInfoList& instances = viewInfo->instances;
for(InstanceInfoList::iterator p = instances.begin(); p != instances.end(); ++p){
View* view = (*p)->view;
ArchivePtr viewArchive = storeView(*archive, moduleName, *viewInfo, view);
if(viewArchive){
viewList->append(viewArchive);
}
}
}
}
if(!viewList->empty()){
archive->insert(key, viewList);
return true;
}
return false;
}
int main(void)
{
// Get hold of the Manager class
ManagerPtr manager = getManager();
// Use the manager to look up a particular archive format
ArchiveTypePtr archiveType = manager->getArchiveTypeByCode("grp-duke3d");
// Open an archive file on disk
stream::file_sptr file(new stream::file());
file->open("duke3d.grp");
// We cheat here - we should check and load any supplementary files, but
// for the sake of keeping this example simple we know this format doesn't
// need any supps.
camoto::SuppData supps;
// Use the archive format handler to read in the file we opened as an archive
ArchivePtr arch = archiveType->open(file, supps);
// Get a list of all the files in the archive
const Archive::VC_ENTRYPTR& contents = arch->getFileList();
// Print the size of the list (the number of files in the archive)
std::cout << "Found " << contents.size() << " files.\n";
// Run through the list of files and show the filename
for (Archive::VC_ENTRYPTR::const_iterator i = contents.begin(); i != contents.end(); i++) {
const Archive::EntryPtr subfile = *i;
std::cout << subfile->strName << "\n";
}
std::cout << "Done." << std::endl;
// No cleanup required because all the Ptr variables are shared pointers,
// which get destroyed automatically when they go out of scope (and nobody
// else is using them!)
return 0;
}
void ArchiveListWidget::selectArchive(ArchivePtr archive)
{
if(!archive)
{
DEBUG << "Null ArchivePtr passed.";
return;
}
for(int i = 0; i < count(); ++i)
{
ArchiveListWidgetItem *archiveItem =
static_cast<ArchiveListWidgetItem *>(item(i));
if(archiveItem
&& (archiveItem->archive()->objectKey() == archive->objectKey()))
{
clearSelection();
setCurrentItem(archiveItem);
scrollToItem(currentItem(), QAbstractItemView::EnsureVisible);
break;
}
}
}
void ArchiveListWidget::addArchive(ArchivePtr archive)
{
if(!archive)
{
DEBUG << "Null ArchivePtr passed.";
return;
}
// Find insertion position based on sorted timestamps.
int pos = 0;
for(; pos < count(); ++pos)
{
ArchiveListWidgetItem *archiveItem =
static_cast<ArchiveListWidgetItem *>(item(pos));
if(archiveItem
&& (archive->timestamp() > archiveItem->archive()->timestamp()))
{
break;
}
}
insertArchive(archive, pos);
}
void ArchiveListWidget::insertArchive(ArchivePtr archive, int pos)
{
if(!archive)
{
DEBUG << "Null ArchivePtr passed.";
return;
}
ArchiveListWidgetItem *item = new ArchiveListWidgetItem(archive);
connect(item, &ArchiveListWidgetItem::requestDelete, this,
&ArchiveListWidget::deleteItem);
connect(item, &ArchiveListWidgetItem::requestInspect, this,
&ArchiveListWidget::inspectItem);
connect(item, &ArchiveListWidgetItem::requestRestore, this,
&ArchiveListWidget::restoreItem);
connect(item, &ArchiveListWidgetItem::requestGoToJob, this,
&ArchiveListWidget::goToJob);
connect(item, &ArchiveListWidgetItem::removeItem, this,
&ArchiveListWidget::removeItem);
insertItem(pos, item);
setItemWidget(item, item->widget());
item->setHidden(!archive->name().contains(_filter));
emit countChanged(count(), visibleItemsCount());
}
ArchivePtr ItemTreeArchiver::storeIter(ArchivePtr& parentArchive, Item* item)
{
string pluginName;
string className;
if(!ItemManager::getClassIdentifier(item, pluginName, className)) {
messageView->putln(format(_("\"%1%\" cannot be stored. Its type is not registered.")) % item->name());
return 0;
}
ArchivePtr archive = new Archive();
archive->inheritSharedInfoFrom(parentArchive);
messageView->putln(format(_("Storing %1% \"%2%\"")) % className % item->name());
messageView->flush();
ArchivePtr dataArchive = new Archive();
dataArchive->inheritSharedInfoFrom(parentArchive);
if(!item->store(*dataArchive)) {
messageView->putln(format(_("\"%1%\" cannot be stored.")) % item->name());
return 0;
}
archive->registerItemId(item, itemIdCounter);
archive->write("id", itemIdCounter);
itemIdCounter++;
archive->write("name", item->name(), YAML_DOUBLE_QUOTED);
archive->write("plugin", pluginName);
archive->write("class", className);
if(!dataArchive->empty()) {
archive->insert("data", dataArchive);
}
YamlSequencePtr children = new YamlSequence();
for(Item* childItem = item->childItem(); childItem; childItem = childItem->nextItem()) {
if(childItem->isSubItem()) {
continue;
}
ArchivePtr childArchive = storeIter(archive, childItem);
if(childArchive) {
children->append(childArchive);
}
}
if(!children->empty()) {
archive->insert("children", children);
}
return archive;
}
void ViewManager::restoreViews(ArchivePtr archive, const std::string& key, ViewManager::ViewStateInfo& out_viewStateInfo)
{
MessageView* mv = MessageView::instance();
typedef map<ViewInfo*, vector<View*> > ViewsMap;
ViewsMap remainingViewsMap;
Listing* viewList = archive->findListing(key);
if(viewList->isValid() && !viewList->empty()){
vector<ViewState>* viewsToRestoreState = new vector<ViewState>();
out_viewStateInfo.data = viewsToRestoreState;
int id;
string moduleName;
string className;
string instanceName;
for(int i=0; i < viewList->size(); ++i){
Archive* viewArchive = dynamic_cast<Archive*>(viewList->at(i)->toMapping());
if(viewArchive){
bool isHeaderValid =
viewArchive->read("id", id) &&
viewArchive->read("plugin", moduleName) &&
viewArchive->read("class", className);
if(isHeaderValid){
View* view = 0;
if(!viewArchive->read("name", instanceName)){
view = getOrCreateView(moduleName, className);
} else {
// get one of the view instances having the instance name, or create a new instance.
// Different instances are assigned even if there are instances with the same name in the archive
ViewInfo* info = findViewInfo(moduleName, className);
if(info){
vector<View*>* remainingViews;
ViewsMap::iterator p = remainingViewsMap.find(info);
if(p != remainingViewsMap.end()){
remainingViews = &p->second;
} else {
remainingViews = &remainingViewsMap[info];
InstanceInfoList& instances = info->instances;
remainingViews->reserve(instances.size());
InstanceInfoList::iterator q = instances.begin();
if(info->hasDefaultInstance() && q != instances.end()){
++q;
}
while(q != instances.end()){
remainingViews->push_back((*q++)->view);
}
}
for(vector<View*>::iterator q = remainingViews->begin(); q != remainingViews->end(); ++q){
if((*q)->name() == instanceName){
view = *q;
remainingViews->erase(q);
break;
}
}
if(!view){
if(!info->isSingleton() || info->instances.empty()){
view = info->createView(instanceName, true);
} else {
mv->putln(MessageView::ERROR,
boost::format(_("A singleton view \"%1%\" of the %2% type cannot be created because its singleton instance has already been created."))
% instanceName % info->className());
}
}
}
}
if(view){
archive->registerViewId(view, id);
ArchivePtr state = viewArchive->findSubArchive("state");
if(state->isValid()){
state->inheritSharedInfoFrom(*archive);
viewsToRestoreState->push_back(ViewState(view, state));
}
if(viewArchive->get("mounted", false)){
mainWindow->viewArea()->addView(view);
}
}
}
}
}
}
}
static bool ArchiveCompare (ArchivePtr a, ArchivePtr b) { return (a->timestamp() > b->timestamp()); }
void ViewArea::restoreAllViewAreaLayouts(ArchivePtr archive)
{
ViewAreaImpl* mainViewAreaImpl = MainWindow::instance()->viewArea()->impl;
if(archive){
Listing& layouts = *archive->findListing("viewAreas");
if(!layouts.isValid()){
// for the compatibility with the older (1.4 or earlier) versions
Archive* layoutOfViews = archive->findSubArchive("layoutOfViews");
if(layoutOfViews->isValid()){
layoutOfViews->inheritSharedInfoFrom(*archive);
mainViewAreaImpl->restoreLayout(layoutOfViews);
}
} else {
QDesktopWidget* desktop = QApplication::desktop();
const int numScreens = desktop->screenCount();
for(int i=0; i < layouts.size(); ++i){
Mapping& layout = *layouts[i].toMapping();
Archive* contents = dynamic_cast<Archive*>(layout.get("contents").toMapping());
if(contents){
contents->inheritSharedInfoFrom(*archive);
const string type = layout.get("type").toString();
if(type == "embedded"){
mainViewAreaImpl->restoreLayout(contents);
mainViewAreaImpl->self->setViewTabsVisible(layout.get("tabs", mainViewAreaImpl->viewTabsVisible));
} else if(type == "independent"){
ViewArea* viewWindow = new ViewArea();
viewWindow->impl->viewTabsVisible = layout.get("tabs", true);
viewWindow->impl->restoreLayout(contents);
if(viewWindow->impl->numViews == 0){
delete viewWindow;
} else {
const Listing& geo = *layout.findListing("geometry");
if(geo.isValid() && geo.size() == 4){
// -1 means the primary screen
int screen = -1;
if(layout.read("screen", screen)){
if(screen >= numScreens){
screen = -1;
}
}
const QRect s = desktop->screenGeometry(screen);
const QRect r(geo[0].toInt(), geo[1].toInt(), geo[2].toInt(), geo[3].toInt());
viewWindow->setGeometry(r.translated(s.x(), s.y()));
}
if(layout.get("fullScreen", false)){
layout.read("maximized", viewWindow->impl->isMaximizedBeforeFullScreen);
viewWindow->showFullScreen();
} else {
if(layout.get("maximized"), false){
viewWindow->showMaximized();
} else {
viewWindow->show();
}
}
}
}
}
}
}
}
if(isBeforeDoingInitialLayout){
mainViewAreaImpl->resetLayout();
}
}
void ViewArea::restoreLayout(ArchivePtr archive)
{
impl->restoreLayout(archive.get());
}
static bool cmp_timestamp(const ArchivePtr &a, const ArchivePtr &b)
{
return (a->timestamp() > b->timestamp());
}
