void SplinePlugGadget::splineRemoved( SetPtr splineStandardSet, IECore::RunTimeTypedPtr splinePlug )
{
m_uis.erase( static_cast<Plug *>( splinePlug.get() ) );
// remove the points from the selection
SplineffPlugPtr p = IECore::runTimeCast<SplineffPlug>( splinePlug );
if( p )
{
unsigned numPoints = p->numPoints();
for( unsigned i = 0; i<numPoints; i++ )
{
m_selection->remove( p->pointPlug( i ) );
}
}
}
int ParameterisedHolder<BaseType>::knob_changed( DD::Image::Knob *knob )
{
if( knob==m_classSpecifierKnob || knob==m_classReloadKnob )
{
// reload the class, or load a new class
updateParameterised( knob==m_classReloadKnob );
// regenerate the knobs used to represent the parameters
replaceKnobs();
// update the version menu
updateVersionChooser();
return 1;
}
else if( knob==m_getParameterisedKnob )
{
// this is triggered by the FnParameterisedHolder.getParameterised implementation.
// currently there's no way to get an Op * and call a method on it from
// python, so we use the knob_changed() mechanism to simulate a function call by
// shoving the result into g_getParameterisedResult for subsequent retrieval.
g_getParameterisedResult = loadClass( false );
if( g_getParameterisedResult )
{
ParameterisedInterface *parameterisedInterface = dynamic_cast<ParameterisedInterface *>( g_getParameterisedResult.get() );
// apply current state
ConstCompoundObjectPtr classSpecifier = runTimeCast<const CompoundObject>( m_classSpecifierKnob->getValue() );
ConstObjectPtr handlerState = classSpecifier->member<Object>( "handlerState" );
if( handlerState )
{
m_parameterHandler->setState( parameterisedInterface->parameters(), handlerState );
}
// get values directly from knobs as they haven't been stored at this point
m_parameterHandler->setParameterValue( parameterisedInterface->parameters(), ParameterHandler::Knob );
}
return 1;
}
else if( knob==m_modifiedParametersKnob )
{
// this is triggered by the FnParameterisedHolder.classModificationContext() implementation.
// as above, we use this method in lieu of being able to call a method on this class.
// get the new handler state and store it so we have it for save/load copy/paste etc
////////////////////////////////////////////////////////////////////////////////////
ParameterisedInterface *inputParameterisedInterface = dynamic_cast<ParameterisedInterface *>( g_modifiedParametersInput.get() );
ObjectPtr handlerState = m_parameterHandler->getState( inputParameterisedInterface->parameters() );
CompoundObjectPtr classSpecifier = runTimeCast<CompoundObject>( m_classSpecifierKnob->getValue()->copy() );
if( handlerState )
{
classSpecifier->members()["handlerState"] = handlerState;
}
else
{
classSpecifier->members().erase( "handlerState" );
}
// it seems that setting the value from inside knob_changed() doesn't emit a new knob_changed(), which
// is fortunately what we want.
m_classSpecifierKnob->setValue( classSpecifier );
// apply the new state to the current parameterised object
////////////////////////////////////////////////////////////////////////////////////
ParameterisedInterface *parameterisedInterface = dynamic_cast<ParameterisedInterface *>( m_parameterised.get() );
if( handlerState )
{
m_parameterHandler->setState( parameterisedInterface->parameters(), handlerState );
}
parameterisedInterface->parameters()->setValue( inputParameterisedInterface->parameters()->getValue() );
// update the knobs using our newly updated parameterised object
////////////////////////////////////////////////////////////////////////////////////
replaceKnobs();
setKnobValues();
// forget the input
g_modifiedParametersInput = 0;
return 1;
}
return BaseType::knob_changed( knob );
}
void ParameterisedHolder<BaseType>::setParameterised( IECore::RunTimeTypedPtr parameterised, bool keepExistingValues )
{
BlockedConnection connectionBlocker( m_plugSetConnection );
IECore::ParameterisedInterface *interface = dynamic_cast<IECore::ParameterisedInterface *>( parameterised.get() );
if( !interface )
{
throw IECore::Exception( "Not a ParameterisedInterface derived type." );
}
m_parameterised = parameterised;
m_parameterHandler = new CompoundParameterHandler( interface->parameters() );
if( keepExistingValues )
{
m_parameterHandler->restore( this );
}
m_parameterHandler->setupPlug( this );
if( !keepExistingValues )
{
m_parameterHandler->setPlugValue();
}
}