void GraphComponent::removeChildInternal( GraphComponentPtr child, bool emitParentChanged ) { if( emitParentChanged ) { child->parentChanging( 0 ); } ChildContainer::iterator it = std::find( m_children.begin(), m_children.end(), child ); if( it == m_children.end() || child->m_parent != this ) { // the public removeChild() method protects against this case, but it's still possible to // arrive here if an Action (which has a direct binding to removeChildInternal) is being replayed // from the undo queue, and just prior to that something called the public removeChild() method. // this can occur if a slot calls removeChild() from a signal triggered during the replay of the // undo queue. the onus is on such slots to not reperform their work when ScriptNode::currentActionStage() // is Action::Redo - instead they should rely on the fact that their actions will have been // recorded and replayed automatically. throw Exception( boost::str( boost::format( "GraphComponent::removeChildInternal : \"%s\" is not a child of \"%s\"." ) % child->fullName() % fullName() ) ); } m_children.erase( it ); child->m_parent = 0; childRemovedSignal()( this, child.get() ); if( emitParentChanged ) { child->parentChangedSignal()( child.get(), this ); } }
void GraphComponent::addChildInternal( GraphComponentPtr child ) { child->parentChanging( this ); GraphComponent *previousParent = child->m_parent; if( previousParent ) { // remove the child from the previous parent, but don't emit parentChangedSignal. // this prevents a parent changed signal with new parent 0 followed by a parent // changed signal with the new parent. previousParent->removeChildInternal( child, false ); } m_children.push_back( child ); child->m_parent = this; child->setName( child->m_name.value() ); // to force uniqueness childAddedSignal()( this, child.get() ); child->parentChangedSignal()( child.get(), previousParent ); }
void GraphComponent::addChildInternal( GraphComponentPtr child, size_t index ) { child->parentChanging( this ); GraphComponent *previousParent = child->m_parent; if( previousParent ) { // remove the child from the previous parent, but don't emit parentChangedSignal. // this prevents a parent changed signal with new parent null followed by a parent // changed signal with the new parent. previousParent->removeChildInternal( child, false ); } m_children.insert( m_children.begin() + min( index, m_children.size() ), child ); child->m_parent = this; child->setName( child->m_name.value() ); // to force uniqueness Signals::emitLazily( m_signals.get(), &Signals::childAddedSignal, this, child.get() ); child->parentChanged( previousParent ); Signals::emitLazily( child->m_signals.get(), &Signals::parentChangedSignal, child.get(), previousParent ); }
SimpleAction( const GraphComponentPtr subject, const Function &doFn, const Function &undoFn ) : m_subject( subject.get() ), m_doFn( doFn ), m_undoFn( undoFn ) { // In the documentation for Action::enact(), we promise that we'll keep // the subject alive for as long as the Functions are in use. If the subject // is a ScriptNode, that is taken care of for us, as the ScriptNode has ownership // of the SimpleAction. If the subject is not a ScriptNode, we must increment // the reference count and decrement it again in our destructor. if( !m_subject->isInstanceOf( Gaffer::ScriptNode::staticTypeId() ) ) { m_subject->addRef(); } }
void GraphComponent::addChild( GraphComponentPtr child ) { if( child->m_parent==this ) { return; } throwIfChildRejected( child.get() ); if( refCount() ) { // someone is pointing to us, so we may have a ScriptNode ancestor and we should do things // in an undoable way. figure out what our undo function should be - it varies based on what // the previous parent was. Action::Function undoFn; if( child->m_parent ) { if( child->m_parent->isInstanceOf( (IECore::TypeId)ScriptNodeTypeId ) ) { // use raw pointer to avoid circular reference between script and undo queue undoFn = boost::bind( &GraphComponent::addChildInternal, child->m_parent, child ); } else { // use smart pointer to ensure parent remains alive, even if something unscrupulous // messes it with non-undoable actions that aren't stored in the undo queue. undoFn = boost::bind( &GraphComponent::addChildInternal, GraphComponentPtr( child->m_parent ), child ); } } else { // no previous parent. undoFn = boost::bind( &GraphComponent::removeChildInternal, this, child, true ); } Action::enact( this, // ok to use raw pointer for this - lifetime of subject guaranteed. boost::bind( &GraphComponent::addChildInternal, this, child ), undoFn ); } else { // we have no references to us - chances are we're in construction still. adding ourselves to an // undo queue is impossible, and creating temporary smart pointers to ourselves (as above) will // cause our destruction before construction completes. just do the work directly. addChildInternal( child ); } }
void GraphComponent::setChild( const IECore::InternedString &name, GraphComponentPtr child ) { GraphComponentPtr existingChild = getChild<GraphComponent>( name ); if( existingChild && existingChild == child ) { return; } throwIfChildRejected( child.get() ); if( existingChild ) { removeChild( existingChild ); } child->setName( name ); addChild( child ); }