OMKVisObjectExtension.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 "OMKVisObjectExtension.h"
#include "OMKTracer.h"
#include "OMKParametersAccessor.inl"
#include "OMKMultipleConfigurationParameter.h"
#include "OMKVisBase.h"
#include "OMKAddVisualObjectPrm.h"
#include "OMKAddAnimatorPrm.h"
//-------------------------------------------------------------------------
using namespace OMK ;
using namespace OMK::Vis ;
using namespace OMK::Type ;
//-------------------------------------------------------------------------
REGISTER_EXTENSION_FACTORY( VisObjectExtension, "VisObject" ) ;
//-------------------------------------------------------------------------
VisObjectExtension::VisObjectExtension( ExtensibleSimulatedObject* owner, const Name& id, bool registerExtension )
  : OMK::ExtensionT< ExtensibleSimulatedObject >( owner, id, registerExtension )
{
}
//-------------------------------------------------------------------------
VisObjectExtension::~VisObjectExtension()
{
}
//-------------------------------------------------------------------------
bool VisObjectExtension::loadObjectParameters( const ConfigurationParameterDescriptor * node )
{
  // Retrieve the visual objects
  bool ok = true ;
  Name visuName ;
  const VisBase* visu = dynamic_cast< const VisBase* >( _owner ) ;
  if( visu )
  { // The extension owner is the visuable object itself => retrieve its name
    visuName = visu->getName() ;
  }
  else
  { // The extension owner is not the visuable object =>  try to find the name in the object parameters
    ParametersAccessor::get( node, "VisuName", visuName ) ;
  }
  const ConfigurationParameterDescriptor * objectNode = node ? node->getSubDescriptorByName( "VisualObject" ) : 0 ;

  if( objectNode )
  {
    int nbItems = objectNode->getNumberOfSubItems() ;
    for( int i = 0 ; i < nbItems ; ++i )
    { 
      // Retrieve parameters sets for each visual object
      std::string id = static_cast<const MultipleConfigurationParameter *>( objectNode )->getNameOfSubDescriptor( i ) ;
      const ConfigurationParameterDescriptor * param = objectNode->getSubDescriptorByPosition( i ) ;
      AddVisualObjectPrm prm ;
      ok = prm.loadParameters( param, "", _owner ) && ok ;
      if( ok )
      {
        // Fill the name of the object, it is the name of the node
        prm.setObjectName( id ) ;
        // Try to find the name of the visualisation
        visuName = prm.getVisuName() != Name() ? prm.getVisuName() : visuName ;

        OMTRACEID( OMK_DEBUG_VIS_EXEC, "Sender \"" << _owner->getName().getString() << "\" (class "
                   << _owner->getObjectDescriptor().getClass().getString() << ")" << std::endl
                   << ">>> visualisation \"" << visuName << "\"" << std::endl
                   << ">>> object name \"" << id << "\"" << std::endl
                   << ">>> event \"" << prm << "\"" ) ; 
        // sends the appropriate event to create the visual objects
        if( visuName != Name() )
        { // A name was in arg or was found in parameters node
          // Send directly to the visualisation
          _owner->sendValuedEvent( visuName, VisBase::ADD_VISUAL_OBJECT_EVENT_ID, prm ) ;
        }
        else
        { // No name was found
          // Fire signal to any visualisation which listens 
          // => each will creates its own visual object
          _owner->fireValuedSignal( VisBase::ADD_VISUAL_OBJECT_EVENT_ID, prm ) ;
        }
      }
      else
      { // Not ok, display the following message and exit
        OMTRACE( "Error for object \"" << _owner->getName().getString() << "\" (class "
                 << _owner->getObjectDescriptor().getClass().getString() << ")" << std::endl
                 << ">>> :-( Unable to load the visual object named \"" << id << "\"." ) ; 
      }
    }
  }

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

  if( animatorNode )
  {
    int nbItems = animatorNode->getNumberOfSubItems() ;
    for( int i = 0 ; i < nbItems ; ++i )
    { 
      // Retrieve parameters sets for each animator
      std::string id = static_cast<const MultipleConfigurationParameter *>( animatorNode )->getNameOfSubDescriptor( i ) ;
      const ConfigurationParameterDescriptor * param = animatorNode->getSubDescriptorByPosition( i ) ;
      if( !loadAnimatorParameters( id, param, _owner, visuName, 0 ) && ok  )
      { // Not ok, display the following message and exit
        OMTRACE( "Error for object \"" << _owner->getName().getString() << "\" (class "
                 << _owner->getObjectDescriptor().getClass().getString() << ")" << std::endl
                 << ">>> :-( Unable to load the animator named \"" << id << "\"." << std::endl ) ; 
        ok = false ;
      }
    }
  }
  else
  {
    OMTRACE( "Warning for sender \"" << _owner->getName().getString() << "\" (class "
             << _owner->getObjectDescriptor().getClass().getString() << ")" << std::endl
             << ">>> :-| No Animator to create !" << std::endl ) ; 
  }
  return ok ;
}
//-------------------------------------------------------------------------

bool VisObjectExtension::loadAnimatorParameters( const Name& id, 
                                                 const ConfigurationParameterDescriptor* node, 
                                                 SimulatedObject* sender, 
                                                 const Name& visuNameTmp,
                                                 const Name* visualObjectName ) 
{
  OMASSERTM( sender, "Must be a valid pointer on a simulated object" ) ;
  // read parameters, if unable return false
  AddAnimatorPrm prm ;
  if( !prm.loadParameters( node, "", sender ) ) return false ;

  prm.setObjectName( id ) ;
  if( visualObjectName ) 
  {
    OMASSERTM( ( prm.getVisualObjectName() == *visualObjectName || prm.getVisualObjectName() == Name() ),
               "The visual object owner name must be egal or null" ) ;
    prm.setVisualObjectName( *visualObjectName ) ;
  }
  OMASSERTM( prm.getVisualObjectName() != Name(),
             "The visual object owner name cannot be null" ) ;

  // Try to find the name of the visualisation
  // Try to find the name of the visualisation
  Name visuName( prm.getVisuName() != Name() ? prm.getVisuName() : visuNameTmp ) ;

  OMTRACEID( OMK_DEBUG_VIS_EXEC, "Sender \"" << sender->getName().getString() << "\" (class "
             << sender->getObjectDescriptor().getClass().getString() << ")" << std::endl
             << ">>> visualisation \"" << visuName << "\"" << std::endl
             << ">>> object name \"" << id << "\"" << std::endl
             << ">>> event \"" << prm << "\"" << std::endl ) ; 

  // sends the appropriate event to create the visual objects
  if( visuName != Name() )
  { // A name was in arg or was found in parameters node
    // Send directly to the visualisation
    sender->sendValuedEvent( visuName , VisBase::ADD_ANIMATOR_EVENT_ID, prm ) ;
    OMTRACEID( OMK_DEBUG_VIS_EXEC, "VisBase::loadAnimatorParameters" << std::endl 
               << ">>> :-) Send the event to create the animator to \"" << visuName << "\" ok" << std::endl ) ;
  }
  else
  { // No name was found
    // Fire signal to any visualisation which listens 
    // => each will creates its own visual object
    sender->fireValuedSignal( VisBase::ADD_ANIMATOR_EVENT_ID, prm ) ;
    OMTRACEID( OMK_DEBUG_VIS_EXEC, "VisBase::loadAnimatorParameters" << std::endl 
               << ">>> :-) Fire the signal to create the animator ok" << std::endl ) ;
  }

  return true ;
}

//-------------------------------------------------------------------------

---