bool PanelCreator::SaveToXML( GuiObjectCPtr _spObject, CFoundation::XMLDocumentPtr _spDoc, CFoundation::XMLElementPtr _spXMLElement ) const
{
GuiObjectCreator::SaveToXML( _spObject, _spDoc, _spXMLElement );
PanelCPtr spPanel = static_pointer_cast< const Panel >( _spObject );
// save children
ChildIterator clIterator = spPanel->GetChildIterator();
GuiObjectPtr pChild = clIterator.GetFirst();
while( !clIterator.IsDone() )
{
// Create new XML node
CFoundation::XMLElementPtr spChildXMLElement = _spDoc->CreateElement( pChild->GetTypeId() );
// Add as child
_spXMLElement->InsertChildLast( spChildXMLElement );
// Save child
GuiMain::GetInstance().SaveToXML( pChild, _spDoc, spChildXMLElement );
pChild = clIterator.GetNext();
}
return true;
}
OverlayElement* OverlayContainer::findElementAt(Real x, Real y) // relative to parent
{
OverlayElement* ret = NULL;
int currZ = -1;
if (mVisible)
{
ret = OverlayElement::findElementAt(x,y); //default to the current container if no others are found
if (ret && mChildrenProcessEvents)
{
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
OverlayElement* currentOverlayElement = it.getNext();
if (currentOverlayElement->isVisible() && currentOverlayElement->isEnabled())
{
int z = currentOverlayElement->getZOrder();
if (z > currZ)
{
OverlayElement* elementFound = currentOverlayElement->findElementAt(x ,y );
if (elementFound)
{
currZ = z;
ret = elementFound;
}
}
}
}
}
}
return ret;
}
/// Get parent node (or NULL if no hierarchy or for root node)
sofa::core::objectmodel::BaseNode::Children Node::getChildren() const
{
Children list_children;
list_children.reserve(child.size());
for (ChildIterator it = child.begin(), itend = child.end(); it != itend; ++it)
list_children.push_back(it->get());
return list_children;
}
void SymbolNode::removeChild(const SymbolInfo &inf)
{
ChildIterator pChild = m_childList.find(inf);
if (pChild != m_childList.end())
{
pChild.value()->m_parent = WeakPtr();
m_childList.remove(inf);
}
}
//---------------------------------------------------------------------
void OverlayContainer::_positionsOutOfDate(void)
{
OverlayElement::_positionsOutOfDate();
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
it.getNext()->_positionsOutOfDate();
}
}
//---------------------------------------------------------------------
void OverlayContainer::_notifyWorldTransforms(const Matrix4& xform)
{
OverlayElement::_notifyWorldTransforms(xform);
// Update children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
it.getNext()->_notifyWorldTransforms(xform);
}
}
/// Find a child node given its name
Node* Node::getChild(const std::string& name) const
{
// cerr<<"Node::getChild, in "<< getName() << ", looking for " << name << endl;
for (ChildIterator it = child.begin(), itend = child.end(); it != itend; ++it)
{
// cerr<<"Node::getChild, see " << (*it)->getName() << endl;
if ((*it)->getName() == name)
return it->get();
}
return NULL;
}
//---------------------------------------------------------------------
void OverlayContainer::_notifyViewport()
{
OverlayElement::_notifyViewport();
// Update children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
it.getNext()->_notifyViewport();
}
}
void recursivelyMarkIf(Node* start, const NodeConditional& nc) {
if (nc(&*start)) {
start->mark |= MARK_KEEP | MARK_KEEP_KIDS;
for (ChildIterator ci = childBegin(start); !ci.done(); ++ci) {
recursivelyMarkIf(&*ci, nc);
}
} else {
start->mark |= MARK_KEEP;
}
}
//---------------------------------------------------------------------
void OverlayContainer::_update(void)
{
// call superclass
OverlayElement::_update();
// Update children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
it.getNext()->_update();
}
}
//---------------------------------------------------------------------
void OverlayContainer::_notifyZOrder(ushort newZOrder)
{
OverlayElement::_notifyZOrder(newZOrder);
// Update children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
// Give children ZOrder 1 higher than this
it.getNext()->_notifyZOrder(newZOrder + 1);
}
}
//---------------------------------------------------------------------
void OverlayContainer::_notifyParent(OverlayContainer* parent, Overlay* overlay)
{
OverlayElement::_notifyParent(parent, overlay);
// Update children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
// Notify the children of the overlay
it.getNext()->_notifyParent(this, overlay);
}
}
int ProtoNode::childrenCount() const
{
if (!node_) return 0;
int row_count = 0;
ChildIterator kids = children();
while ( kids.element().isValid() )
{
row_count++;
kids.next();
}
return row_count;
}
//---------------------------------------------------------------------
ushort OverlayContainer::_notifyZOrder(ushort newZOrder)
{
OverlayElement::_notifyZOrder(newZOrder);
// One for us
newZOrder++;
// Update children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
// Children "consume" Z-order values, so keep track of them
newZOrder = it.getNext()->_notifyZOrder(newZOrder);
}
return newZOrder;
}
//---------------------------------------------------------------------
void OverlayContainer::_updateRenderQueue(RenderQueue* queue)
{
if (mVisible)
{
OverlayElement::_updateRenderQueue(queue);
// Also add children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
// Give children Z-order 1 higher than this
it.getNext()->_updateRenderQueue(queue);
}
}
}
/** Overridden from OverlayContainer */
void cCompassOverlay::_updateRenderQueue(RenderQueue* queue) {
if (mVisible)
{
if (!mTransparent && !mpMaterial.isNull())
{
OverlayElement::_updateRenderQueue(queue);
}
// Also add children
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
// Give children ZOrder 1 higher than this
it.getNext()->_updateRenderQueue(queue);
}
}
}
OverlayElement* OverlayContainer::clone(const String& instanceName)
{
OverlayContainer *newContainer;
newContainer = static_cast<OverlayContainer*>(OverlayElement::clone(instanceName));
ChildIterator it = getChildIterator();
while (it.hasMoreElements())
{
OverlayElement* oldChildElement = it.getNext();
if (oldChildElement->isCloneable())
{
OverlayElement* newChildElement = oldChildElement->clone(instanceName);
newContainer->_addChild(newChildElement);
}
}
return newContainer;
}
/*!
Destroys children of nodes that are not marked,
defragments the node array
always keeps the root
Note: invalidates all pointers to nodes of the tree, and all
iterators.
*/
void eraseChildrenOfUnmarkedNodes() {
unsigned int write = 0;
nodes[root_index].mark = MARK_KEEP;
assert(root_index < allocation_index);
for (unsigned int read = root_index; read != allocation_index; read++) {
Node *node = &nodes[read];
char mark = node->mark;
if (mark) {
// TODO: could handle read == write as a special case
Node *write_node = &nodes[write];
*write_node = *node; // copy
write_node->mark = 0; // clear mark
if (mark & MARK_KEEP_KIDS) {
// adjust children's parent pointers
for (ChildIterator it = childBegin(write_node); !it.done(); ++it) {
it->parent = write;
}
} else {
write_node->num_children = 0;
}
// adjust parent's first_child "pointer" if this is its first child
if (read != root_index) {
Node* parent_node = getParent(node);
if (write < parent_node->first_child) {
parent_node->first_child = write;
}
}
write++;
}
}
root_index = 0;
nodes[root_index].parent = 0;
allocation_index = write;
}
void Box::exportForReference( const std::string &fileName ) const
{
const ScriptNode *script = scriptNode();
if( !script )
{
throw IECore::Exception( "Box::exportForReference called without ScriptNode" );
}
// we only want to save out our child nodes and plugs that are visible in the UI, so we build a filter
// to specify just the things to export.
boost::regex invisiblePlug( "^__.*$" );
StandardSetPtr toExport = new StandardSet;
for( ChildIterator it = children().begin(), eIt = children().end(); it != eIt; ++it )
{
if( (*it)->isInstanceOf( Node::staticTypeId() ) )
{
toExport->add( *it );
}
else if( const Plug *plug = IECore::runTimeCast<Plug>( it->get() ) )
{
if( !boost::regex_match( plug->getName().c_str(), invisiblePlug ) )
{
toExport->add( *it );
}
}
}
ContextPtr context = new Context;
context->set( "valuePlugSerialiser:resetParentPlugDefaults", true );
context->set( "serialiser:includeParentMetadata", true );
context->set( "serialiser:includeVersionMetadata", true );
Context::Scope scopedContext( context.get() );
script->serialiseToFile( fileName, this, toExport.get() );
}
