OMKVisBase.cpp

Go to the documentation of this file.

/************************************************************************/
/* This file is part of openMask(c) INRIA, CNRS, Universite de Rennes 1 */
/* 1993-2002, thereinafter the Software                                 */
/*                                                                      */
/* The Software has been developped within the Siames Project.          */
/* INRIA, the University of Rennes 1 and CNRS jointly hold intellectual */
/* property rights                                                      */
/*                                                                      */
/* The Software has been registered with the Agence pour la Protection  */
/* des Programmes (APP) under registration number                       */
/* IDDN.FR.001.510008.00.S.P.2001.000.41200                             */
/*                                                                      */
/* This file may be distributed under the terms of the Q Public License */
/* version 1.0 as defined by Trolltech AS of Norway and appearing in    */
/* the file LICENSE.QPL included in the packaging of this file.         */
/*                                                                      */
/* Licensees holding valid specific licenses issued by INRIA, CNRS or   */
/* Universite Rennes 1 for the software may use this file in            */
/* acordance with that specific license                                 */
/************************************************************************/
#include "OMKVisBase.h"
#include "OMKAnimatorEventPlug.h"
#include "OMKVisualObject.h"
#include "OMKAnimator.h"
#include "OMKAddAnimatorPrm.h"
#include "OMKAddVisualObjectPrm.h"
#include "OMKValuedEvent.h"
#include "OMKMultipleConfigurationParameter.h"
#include "OMKVisObjectExtension.h"
#include "OMKVisServiceExtension.h" 

using namespace OMK ;
using namespace OMK::Vis ;
using namespace OMK::Type ;

EventIdentifier VisBase::ADD_VISUAL_OBJECT_EVENT_ID   ( "AddVisualObjectEvent"    ) ;
EventIdentifier VisBase::DELETE_VISUAL_OBJECT_EVENT_ID( "DeleteVisualObjectEvent" ) ;
EventIdentifier VisBase::ADD_ANIMATOR_EVENT_ID        ( "AddAnimatorEvent"        ) ;
EventIdentifier VisBase::DELETE_ANIMATOR_EVENT_ID     ( "DeleteAnimatorEvent"     ) ;

//-------------------------------------------------------------------------
// constructor
//-------------------------------------------------------------------------
VisBase::VisBase( Controller& ctrl, const ObjectDescriptor& objectDescriptor )
: ExtensibleSimulatedObject( ctrl, objectDescriptor )
{
  new VisObjectExtension( this, "visualOjectLoader" ) ;
  new VisServiceExtension(this, "VisServiceExtension" ) ;
}

//-------------------------------------------------------------------------
// destructor
//-------------------------------------------------------------------------
VisBase::~VisBase()
{
}

//-------------------------------------------------------------------------
// finish
//-------------------------------------------------------------------------
void 
VisBase::finish()
{
  cancelRegistrationForSignal ( ADD_VISUAL_OBJECT_EVENT_ID );
  cancelRegistrationForSignal ( ADD_ANIMATOR_EVENT_ID );

  OMTRACEID( OMK_DEBUG_VIS_EXEC, " Destruction " <<  getName().getCString() );  
  for ( VisualObjectMap::iterator i = _visualObjects.begin() ;
      i != _visualObjects.end() ;
      i++ )
  {
    delete i->second ;
  }
  ExtensibleSimulatedObject::finish();
}
//-------------------------------------------------------------------------
// init
//-------------------------------------------------------------------------
void VisBase::init( )
{
  ExtensibleSimulatedObject::init ();
  new AddVisualObjectEventListener( *this, &VisBase::processAddVisualObjectEvent, ADD_VISUAL_OBJECT_EVENT_ID ) ;
  new DeleteVisualObjectEventListener( *this, &VisBase::processDeleteVisualObjectEvent, DELETE_VISUAL_OBJECT_EVENT_ID ) ;
  new AddAnimatorEventListener( *this, &VisBase::processAddAnimatorEvent, ADD_ANIMATOR_EVENT_ID ) ;
  new DeleteAnimatorEventListener( *this, &VisBase::processDeleteAnimatorEvent, DELETE_ANIMATOR_EVENT_ID ) ;
  registerForSignal ( ADD_VISUAL_OBJECT_EVENT_ID );
  registerForSignal ( DELETE_VISUAL_OBJECT_EVENT_ID );
  registerForSignal ( ADD_ANIMATOR_EVENT_ID );
  registerForSignal ( DELETE_ANIMATOR_EVENT_ID );
}
//-------------------------------------------------------------------------
// processEvent
//-------------------------------------------------------------------------
bool VisBase::processEvent( Event *e ) 
{
  OMTRACEID( OMK_DEBUG_VIS_EXEC, ">>> eventId to process \"" << e->eventId.getString()<< "\"" << std::endl ) ;
  // Return value
  bool ok = false ;

  // Scan all the registered events to find the good ones
  EventPlugMap::iterator eventPlugs =_eventIdAndPlug.find( e->eventId ) ;
  if( eventPlugs != _eventIdAndPlug.end() )
  {
    for( EventPlugList::iterator i = eventPlugs->second.begin() ;
      i != eventPlugs->second.end() ;
      ++i )
    {
      ok = true ;
      (*i)->setEvent( e ) ;
    }
  }
  OMTRACEID( OMK_DEBUG_VIS_EXEC, ">>> :-| End " << ( ok ? "ok" : "not ok => default processing" ) << std::endl ) ;
  return ok || SimulatedObject::processEvent( e ) ;
}

//-------------------------------------------------------------------------
// processAddVisualObjectEvent
//-------------------------------------------------------------------------
bool VisBase::processAddVisualObjectEvent( AddVisualObjectEvent *event ) 
{
  OMASSERTM( event->eventId == ADD_VISUAL_OBJECT_EVENT_ID, "Not the good event" ) ;
  std::string errorMsg ;
  // Get the visual object
  VisualObject* visualObject = 0 ;
  // return value
  bool ok = false ;
  OMTRACEID( OMK_DEBUG_VIS_EXEC, " Event value: " <<  event->value );  
  visualObject =  getVisualObject( event->value.getObjectName() );
  if ( visualObject )
  {
  OMMESSAGE (" VisualObject already exists : " 
      << visualObject->getId() << " send by " << event->sender 
      << " Event " << *event);
  }
  else
    visualObject = VisualObjectFactory::getInstance().create( event->value.getClassId() )
    ( *this, event->value.getObjectName(), event->value.getConfigParam()  ) ;
  
  if( visualObject )
  { // Add the new visual object to the visualisation
    addNewVisualObject( visualObject ) ;
    OMTRACEID( OMK_DEBUG_VIS_EXEC, ">>> New size " << _visualObjects.size() << std::endl ) ; 
    ok = true ;

    // Read the parameters for animators
    const ConfigurationParameterDescriptor * animatorNode = event->value.getConfigParam() ? event->value.getConfigParam()->getSubDescriptorByName( "Animator" ) : 0 ;

    AnimatorsToCreateMap::iterator entry = _animatorsToCreate.find( event->value.getObjectName() ) ;
    if( entry != _animatorsToCreate.end() )
    {
      for( std::vector< AddAnimatorPrm >::iterator prm = entry->second.begin() ;
           prm != entry->second.end() ;
           ++prm )
      {
        // sends the appropriate event to create the visual objects
        if( prm->getVisualObjectName() != Name() )
        { // A name was in arg or was found in parameters node
          // Send directly to the visualisation
          sendValuedEvent( prm->getVisualObjectName(), VisBase::ADD_ANIMATOR_EVENT_ID, *prm ) ;
          OMTRACEID( OMK_DEBUG_VIS_EXEC, ">>> :-) Send again the event to create the animator to \"" << prm->getVisualObjectName() << "\"" ) ;
        }
        else
        { // No name was found
          // Fire signal to any visualisation which listens 
          // => each will creates its own visual object
          fireValuedSignal( VisBase::ADD_ANIMATOR_EVENT_ID, *prm ) ;
          OMTRACEID( OMK_DEBUG_VIS_EXEC, ">>> :-) Fire again the signal to create the animator" ) ;
        }
      }
    }

    if( animatorNode )
    {
      int nbItems = animatorNode->getNumberOfSubItems() ;
      for( int i = 0 ; i < nbItems ; ++i )
      { 
        // Retrieve parameters sets for each animator
        std::string name = dynamic_cast<const MultipleConfigurationParameter *>( animatorNode )->getNameOfSubDescriptor( i ) ;
        const ConfigurationParameterDescriptor * param = animatorNode->getSubDescriptorByPosition( i ) ;
        OMTRACEID( OMK_DEBUG_VIS_EXEC, ">>> item #" << i << "/" << nbItems << std::endl 
          << ">>> " << name << std::endl ) ;
        ok = VisObjectExtension::loadAnimatorParameters( name, param, this, getName(), &event->value.getObjectName() ) && ok ;
        OMTRACEID( OMK_DEBUG_VIS_EXEC, ">>> :-) " << name << " loaded" ) ;
      }
    }
    else
    {
      OMTRACEID( OMK_DEBUG_VIS_EXEC, "Warning for visualisation \"" << getName().getString() << "\" (class "
        << getObjectDescriptor().getClass().getString() << ")" << std::endl
        << ">>> :-| No Animator to create !" ) ; 
    }
  }
  else if( errorMsg == "" )
  {
    errorMsg = "Unable to create the visual object" ;
  }
  // Unable to process event => error message
  if( !ok )
  {
    OMTRACE(    "Error for object \"" << getName().getString() << "\" (class " 
      << getObjectDescriptor().getClass().getString() << ")" << std::endl
      << ">>> :-( " << errorMsg << "." << std::endl ) ; 
  }
  // allow ProcessEvent by other listener 
 return false ;
}
//-------------------------------------------------------------------------
// processDeleteVisualObjectEvent
//-------------------------------------------------------------------------
bool VisBase::processDeleteVisualObjectEvent( DeleteVisualObjectEvent *event ) 
{
  OMASSERTM( event->eventId == DELETE_VISUAL_OBJECT_EVENT_ID, "Not the good event" ) ;
  deleteVisualObject( event->value ) ;
  // allow ProcessEvent by other listener 
  return false ;
}

//-------------------------------------------------------------------------
// processAddAnimatorEvent
//-------------------------------------------------------------------------
bool VisBase::processAddAnimatorEvent( AddAnimatorEvent *event ) 
{
  OMASSERTM( event->eventId == ADD_ANIMATOR_EVENT_ID, "Not the good event" ) ;
  std::string errorMsg ;
  // Get the visual object
  Name visualObjectName( event->value.getVisualObjectName() ) ; 
  VisualObject* visualObject = getVisualObject( visualObjectName ) ;
  Animator* animator = 0 ;
  // return value
  bool ok = false ;
  if( !visualObject )
  {
    AnimatorsToCreateMap::iterator entry = _animatorsToCreate.find( visualObjectName ) ;
    if( entry == _animatorsToCreate.end() )
    {
      _animatorsToCreate[ visualObjectName ] = std::vector< AddAnimatorPrm >() ;
      entry = _animatorsToCreate.find( visualObjectName ) ;
    }
    entry->second.push_back( event->value ) ;
    errorMsg += "Cannot find the visual object named \"" + event->value.getVisualObjectName().getString() + "\" for the moment, stores the event for later" ; 
  }
  else
  { // Parameters are ok => Create the animator
    animator = AnimatorFactory::getInstance().create( event->value.getClassId() )
      ( *visualObject, event->value.getObjectName(), *event->value.getConfigParam()->clone() ) ;
  }

  if( animator )
  { // Add the new animator to the visual object
    visualObject->addAnimator( animator ) ;
    ok = true ;
  }
  else
  {
    errorMsg += " so unable to create the animator now" ;
    OMTRACEID( OMK_DEBUG_VIS_EXEC, "Warning for " << debugMsg( this ) << std::endl
        << ">>> :-| " << errorMsg << "." << std::endl 
        << " Event : " << * event ) ; 
  }
  // Unable to process event => error message
  // allow ProcessEvent by other listener 
  return false ;
}

//-------------------------------------------------------------------------
// processDeleteAniamtorEvent
//-------------------------------------------------------------------------
bool VisBase::processDeleteAnimatorEvent( DeleteAnimatorEvent *event )
{
  OMASSERTM( event->eventId == DELETE_ANIMATOR_EVENT_ID, "Not the good event" ) ;
  const DeleteAnimatorPrm& prm = event->value.getValue() ;
  VisualObjectMap::iterator i = _visualObjects.find( prm.first ) ;
  if( i != _visualObjects.end() )
  {
    i->second->deleteAnimator( prm.second ) ;
  }
  // allow ProcessEvent by other listener 
  return false;
}

//-------------------------------------------------------------------------
// registerEventPlug
//-------------------------------------------------------------------------
void 
VisBase::registerEventPlug( const EventIdentifier& eventId, 
                            const std::string& emitter, 
                            OMK::Vis::IAnimatorEventPlug* plug ) 
{
  // Find the list
  EventPlugMap::iterator eventPlugs =_eventIdAndPlug.find( eventId ) ;
  if( eventPlugs == _eventIdAndPlug.end() )
  {
    _eventIdAndPlug[ eventId ] = EventPlugList() ;
  }
  eventPlugs =_eventIdAndPlug.find( eventId ) ;
  OMASSERT( eventPlugs != _eventIdAndPlug.end() ) ;
  // Register the plug associated to the event in the list
  eventPlugs->second.push_back( plug ) ;
  // Register the visualisation as a listener
  SimulatedObject* emitterPtr = _controller.getPointerToSimulatedObjectNamed ( emitter );
  if( emitterPtr ) 
  { // The emitter exists => register for the signal form this emitter
    registerForSignalBy( eventId, emitterPtr, eventId ) ;
  }
  else
  { // The emitter doesn't exist => register for the signal from any objectDescriptor
    registerForSignal( eventId ) ;
  }
}

//-------------------------------------------------------------------------
// removeEventPlug
//-------------------------------------------------------------------------
void VisBase::removeEventPlug( const EventIdentifier& eventId, OMK::Vis::IAnimatorEventPlug *plug )
{
  // Find the list
  EventPlugMap::iterator eventPlugs =_eventIdAndPlug.find( eventId ) ;
  if( eventPlugs != _eventIdAndPlug.end() )
  {
    _eventIdAndPlug[ eventId ].remove( plug ) ;
  }
  else
  {
    OMERROR( ">>> :-( The event id \"" << eventId << "\" is not present => cannot delete the plug " << plug ) ;
  }
}

//-------------------------------------------------------------------------
// addNewVisualObject
//-------------------------------------------------------------------------
void 
VisBase::addNewVisualObject( OMK::Vis::VisualObject* visualObject )
{
  OMASSERTM( visualObject, "Must be a valid pointer" ) ;
  // Add the partner in the list
  _visualObjects[ visualObject->getId() ] = visualObject ;
}

//-------------------------------------------------------------------------
// deleteVisualObject
//-------------------------------------------------------------------------
void VisBase::deleteVisualObject( const Name& id )
{
  VisualObjectMap::iterator i = _visualObjects.find( id ) ;
  OMASSERTM( i != _visualObjects.end(), "The visual object named \"" << id << "\" is not present !" ) ;
  // delete the visual object
  delete i->second ;
  _visualObjects.erase( i ) ;
  OMTRACEID( OMK_DEBUG_VIS_EXEC, ">>> :-) The visual object named \"" << id << "\" is deleted" ) ;
}

//-------------------------------------------------------------------------
// getVisualObject
//-------------------------------------------------------------------------
VisualObject* 
VisBase::getVisualObject( const Name& id ) const 
{
  VisualObjectMap::const_iterator i = _visualObjects.find( id ) ;
  return i != _visualObjects.end() ? i->second : 0 ;
}

//-------------------------------------------------------------------------
// compute
//-------------------------------------------------------------------------
void 
VisBase::computeParameters() 
{
  for ( VisualObjectMap::iterator i = _visualObjects.begin() ;
    i != _visualObjects.end() ;
    ++i )
  {
    i->second->update() ;
  }
}

---