bool EditableSceneBodyImpl::storeProperties(Archive& archive)
{
ListingPtr states = new Listing();
ItemList<BodyItem> bodyItems;
bodyItems.extractChildItems(RootItem::instance());
for(size_t i=0; i < bodyItems.size(); ++i){
BodyItem* bodyItem = bodyItems[i];
EditableSceneBody* sceneBody = bodyItem->existingSceneBody();
if(sceneBody){
ValueNodePtr id = archive.getItemId(bodyItem);
if(id){
EditableSceneBodyImpl* impl = sceneBody->impl;
MappingPtr state = new Mapping();
state->insert("bodyItem", id);
state->write("showCenterOfMass", impl->isCmVisible);
state->write("showZmp", impl->isZmpVisible);
states->append(state);
}
}
}
if(!states->empty()){
archive.insert("editableSceneBodies", states);
return true;
}
return false;
}
ValueNodePtr Archive::getItemId(Item* item) const
{
if(shared){
int i = 0;
Item* mainItem = item;
while(mainItem->isSubItem()){
++i;
mainItem = mainItem->parentItem();
}
ItemToIdMap::const_iterator p = shared->itemToIdMap.find(mainItem);
if(p != shared->itemToIdMap.end()){
const int id = p->second;
if(i == 0){
return new ScalarNode(id);
} else {
ListingPtr idPath = new Listing(i + 1);
idPath->setFlowStyle(true);
while(item->isSubItem()){
idPath->write(i--, item->name(), DOUBLE_QUOTED);
item = item->parentItem();
}
idPath->write(0, id);
return idPath;
}
}
}
return 0;
}
void ItemTreeViewImpl::storeExpandedItems(Archive& archive)
{
ListingPtr expanded = new Listing();
expanded->setFlowStyle(true);
storeExpandedItemsSub(invisibleRootItem(), archive, expanded);
if(!expanded->empty()){
archive.insert("expanded", expanded);
}
}
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);
}
}
void ItemTreeViewImpl::storeItemIds(Archive& archive, const char* key, const ItemList<>& items)
{
ListingPtr idseq = new Listing();
idseq->setFlowStyle(true);
for(size_t i=0; i < items.size(); ++i){
ValueNodePtr id = archive.getItemId(items[i]);
if(id){
idseq->append(id);
}
}
if(!idseq->empty()){
archive.insert(key, idseq);
}
}
MappingPtr ViewAreaImpl::storeSplitterState(QSplitter* splitter, Archive* archive)
{
MappingPtr state = new Mapping;
ListingPtr children = new Listing;
for(int i=0; i < splitter->count(); ++i){
QSplitter* childSplitter = dynamic_cast<QSplitter*>(splitter->widget(i));
if(childSplitter){
MappingPtr childState = storeSplitterState(childSplitter, archive);
if(childState){
children->append(childState);
}
} else {
ViewPane* pane = dynamic_cast<ViewPane*>(splitter->widget(i));
if(pane && pane->count() > 0){
MappingPtr childState = storePaneState(pane, archive);
if(childState){
children->append(childState);
}
}
}
}
const int numChildren = children->size();
if(numChildren == 0){
state.reset();
} else if(numChildren == 1){
state = children->at(0)->toMapping();
} else if(numChildren == 2){
state->write("type", "splitter");
state->write("orientation", (splitter->orientation() == Qt::Vertical) ? "vertical" : "horizontal");
Listing* sizeSeq = state->createFlowStyleListing("sizes");
QList<int> sizes = splitter->sizes();
for(int i=0; i < sizes.size(); ++i){
sizeSeq->append(sizes[i]);
}
state->insert("children", children);
}
return state;
}
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;
}
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;
}
bool SensorVisualizerItem::restore(const Archive& archive)
{
impl->restoredSubItems.clear();
ListingPtr subItems = archive.findListing("subItems");
if(subItems->isValid()){
for(int i=0; i < subItems->size(); i++){
Archive* subArchive = dynamic_cast<Archive*>(subItems->at(i)->toMapping());
string className, itemName;
subArchive->read("class", className);
subArchive->read("name", itemName);
ItemPtr item;
item = ItemManager::create("Body", className);
item->setName(itemName);
item->restore(*subArchive);
impl->restoredSubItems.push_back(item);
}
}
return true;
}
void ItemTreeViewImpl::storeExpandedItemsSub(QTreeWidgetItem* parentTwItem, Archive& archive, ListingPtr& expanded)
{
int n = parentTwItem->childCount();
for(int i=0; i < n; ++i){
ItvItem* itvItem = dynamic_cast<ItvItem*>(parentTwItem->child(i));
if(itvItem){
if(itvItem->isExpanded()){
ValueNodePtr id = archive.getItemId(itvItem->item);
if(id){
expanded->append(id);
}
}
if(itvItem->childCount() > 0){
storeExpandedItemsSub(itvItem, archive, expanded);
}
}
}
}
