OMKAttributeAnimator.h

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                                 */
/************************************************************************/
                
#if !defined OMK_ATTRIBUTEANIMATOR_H
#define OMK_ATTRIBUTEANIMATOR_H

#include "OMKAttribute.h"
#include "OMKAddAnimatorPrm.h"
#include "OMKVisBase.h" 
namespace OMK  
{

//-----------------------------------------------------------------
template< typename PrmType, typename ModelType, typename AccessorType >
class IAttributeAnimatorT : public IAttributeT< PrmType, ModelType, AccessorType >
{ 
public:
  using IAttributeT< PrmType, ModelType, AccessorType >::getId;
  using IAttributeT< PrmType, ModelType, AccessorType >::get;
  using IAttributeT< PrmType, ModelType, AccessorType >::isUpdated;
  using IAttributeT< PrmType, ModelType, AccessorType >::sendValueTo;
  using IAttributeT< PrmType, ModelType, AccessorType >::sendValueOf;
  using IAttributeT< PrmType, ModelType, AccessorType >::fireValueTo;
  using IAttributeT< PrmType, ModelType, AccessorType >::fireValueOf;
  using IAttributeT< PrmType, ModelType, AccessorType >::_output;
  using IAttributeT< PrmType, ModelType, AccessorType >::_owner;

protected:
  IAttributeAnimatorT( const Name& id, const AccessorType& init ) ;
public:
  virtual ~IAttributeAnimatorT() ;


protected:
  virtual bool loadParameters( const ConfigurationParameterDescriptor* node, const std::string* aliasName ) ;
public:
  bool initAnimator( const ConfigurationParameterDescriptor* node = 0 ) { return initAnimator( node, 0 ) ; }
  bool initAnimator( const ConfigurationParameterDescriptor* node, const std::string& aliasName ) { return initAnimator( node, &aliasName ) ; }
protected:
  virtual bool initAnimator( const ConfigurationParameterDescriptor* node, const std::string* aliasName ) ;


public:
  virtual void setValueToOutput() ;
protected:
  Name _localVisu ;
  EventIdentifier _eventId ;
  Name _eventBaseId ;
  enum
  {
    TYPE_UNINITIALISED = 0,
    TYPE_OUTPUT,
    TYPE_EVENT_LOCAL_VISU,
    TYPE_SIGNAL_ALL_VISU
  } _type ;
} ;

//-----------------------------------------------------------------
template< typename PrmType >
class AttributeAnimatorT : public IAttributeAnimatorT< PrmType, OMK::Type::SimpleTypeT< PrmType >, AccessorT< PrmType > >
{ 

public:
  AttributeAnimatorT( const Name& id, const PrmType& value ) 
    : IAttributeAnimatorT< PrmType, OMK::Type::SimpleTypeT< PrmType >, AccessorT< PrmType > >( id, AccessorT< PrmType >( value ) ) {}
  virtual ~AttributeAnimatorT() {}









  PrmType& getRef() { return this->_accessor.operator PrmType&() ; }
} ;

//-----------------------------------------------------------------
template< typename PrmType >
class AttributeAnimatorTypeT : public IAttributeAnimatorT< PrmType, PrmType, AccessorT< PrmType > >
{ 

public:
  AttributeAnimatorTypeT( const Name& id, const PrmType& value ) 
    : IAttributeAnimatorT< PrmType, PrmType, AccessorT< PrmType > >( id, AccessorT< PrmType >( value ) ) {}
  virtual ~AttributeAnimatorTypeT() {}

  PrmType& getRef() { return this->_accessor.operator PrmType&() ; }
} ;


//-----------------------------------------------------------------
template< typename PrmType, typename  PrmAccType >
class AttributeAnimatorAccT : public IAttributeAnimatorT< PrmType, OMK::Type::SimpleTypeT< PrmType >, AccessorAccT< PrmType,  PrmAccType > >
{ 

public:
  AttributeAnimatorAccT( const Name& id, IAccessorT<  PrmAccType >* accessor ) 
    : IAttributeAnimatorT< PrmType, OMK::Type::SimpleTypeT< PrmType >, AccessorAccT< PrmType,  PrmAccType > >( id, AccessorAccT< PrmType,  PrmAccType >( accessor ) ) {}
  virtual ~AttributeAnimatorAccT() {}







  void setAccessor( IAccessorT< PrmAccType >* accessor )
  {
    this->_accessor.setAccessor( accessor ) ;
  }
} ;

//-----------------------------------------------------------------
template< typename PrmType, typename  PrmAccType >
class AttributeAnimatorAccTypeT : public IAttributeAnimatorT< PrmType, PrmType, AccessorAccT< PrmType,  PrmAccType > >
{ 

public:
  AttributeAnimatorAccTypeT( const Name& id, IAccessorT<  PrmAccType >* accessor ) 
    : IAttributeAnimatorT< PrmType, PrmType, AccessorAccT< PrmType,  PrmAccType > >( id, AccessorAccT< PrmType,  PrmAccType >( accessor ) ) {}
  virtual ~AttributeAnimatorAccTypeT() {}







  void setAccessor( IAccessorT< PrmAccType >* accessor )
  {
    this->_accessor.setAccessor( accessor ) ;
  }
} ;



//-----------------------------------------------------------------
template< typename PrmType, typename ObjectType >
class AttributeAnimatorFctT : public IAttributeAnimatorT< PrmType, OMK::Type::SimpleTypeT< PrmType >, AccessorFctT< PrmType, ObjectType > >
{ 

public:
  AttributeAnimatorFctT( const Name& id, ObjectType *object, 
                 typename AccessorFctT< PrmType, ObjectType >::SetMethod setMethod, 
                 typename AccessorFctT< PrmType, ObjectType >::GetMethod getMethod ) 
    : IAttributeAnimatorT< PrmType, OMK::Type::SimpleTypeT< PrmType >, AccessorFctT< PrmType, ObjectType > >
    ( id, AccessorAccT< PrmType, ObjectType >( object, setMethod, getMethod ) ) {}
  virtual ~AttributeAnimatorFctT() {}
} ;

//-----------------------------------------------------------------
template< typename PrmType, typename ObjectType >
class AttributeAnimatorFctTypeT : public IAttributeAnimatorT< PrmType, PrmType, AccessorFctT< PrmType, ObjectType > >
{ 

public:
  AttributeAnimatorFctTypeT( const Name& id, ObjectType *object, 
                     typename AccessorFctT< PrmType, ObjectType >::SetMethod setMethod, 
                     typename AccessorFctT< PrmType, ObjectType >::GetMethod getMethod ) 
    : IAttributeAnimatorT< PrmType, PrmType, AccessorFctT< PrmType, ObjectType > >
    ( id, AccessorAccT< PrmType, ObjectType >( object, setMethod, getMethod ) ) {}
  virtual ~AttributeAnimatorFctTypeT() {}
} ;


//=================================================================

template< typename Type, typename ModelType, typename AccessorType >
IAttributeAnimatorT< Type, ModelType, AccessorType >::IAttributeAnimatorT( const Name& id, const AccessorType& init ) 
: IAttributeT< Type, ModelType, AccessorType >( id, init ),
  _localVisu(),
  _type( TYPE_UNINITIALISED )
{
}
//-----------------------------------------------------------------

template< typename Type, typename ModelType, typename AccessorType >
IAttributeAnimatorT< Type, ModelType, AccessorType >::~IAttributeAnimatorT() 
{
}
//-----------------------------------------------------------------

template< typename PrmType, typename ModelType, typename AccessorType >
bool IAttributeAnimatorT< PrmType, ModelType, AccessorType >
::loadParameters( const ConfigurationParameterDescriptor * node, const std::string* aliasName ) 
{
  std::string strId( aliasName ? *aliasName : getId().getCString() ) ;
  bool ok = true ;
  const ConfigurationParameterDescriptor * animatorNode = 0 ;
  ok = ok && ParametersAccessor::get( node, strId + "Animator", animatorNode ) ;
  ok = ok && animatorNode != 0 ;

  // Set the type of connection with the animator 
  // Look for visualisation name (the same as AddAnimatorPrm::loadParameters)
  bool localVisu = ParametersAccessor::get( animatorNode, "VisuName", _localVisu ) ; 
  // If there is an output => force to output
  _type = _output ? TYPE_OUTPUT : ( localVisu ? TYPE_EVENT_LOCAL_VISU : TYPE_SIGNAL_ALL_VISU ) ;

  _eventBaseId = _owner->getName().getString() + "_" + getId().getString() + "_animator" ;
  _eventId = OMK::EventId::getCurrentValueEventId( _eventBaseId.getString() ) ;
  // Load the parameters to create the connection for the animator
  ConfigurationParameterDescriptor * modifiedAnimatorNode = const_cast< ConfigurationParameterDescriptor* >( animatorNode ) ;
  switch( _type )
  {
  case TYPE_OUTPUT:
    ParametersAccessor::set( modifiedAnimatorNode, "ConnectTo", std::pair< Name, Name >( _owner->getName(), _output->getName() )) ;
    break ;
  case TYPE_EVENT_LOCAL_VISU :
    ParametersAccessor::set( modifiedAnimatorNode, "ListenedEvent", _eventId ) ; 
    break ;
  case TYPE_SIGNAL_ALL_VISU :
    ParametersAccessor::set( modifiedAnimatorNode, "ListenedEvent", _eventId ) ; 
    ParametersAccessor::set( modifiedAnimatorNode, "Emitter", _owner->getName() ) ; 
    break ;
  default:
    OMASSERTM( false, "Cannot create the animator" ) ;
  }
  return  ok && IAttributeT< PrmType, ModelType, AccessorType >::loadParameters( node, aliasName ) ;
}
//-----------------------------------------------------------------
template< typename PrmType, typename ModelType, typename AccessorType >
bool IAttributeAnimatorT< PrmType, ModelType, AccessorType >
::initAnimator( const ConfigurationParameterDescriptor * node, const std::string* aliasName ) 
{
  node = node ? node : _owner->getConfigurationParameters() ;
  std::string strId( aliasName ? *aliasName : getId().getCString() ) ;
  bool ok = true ;
  const ConfigurationParameterDescriptor * animatorNode = 0 ;
  ok = ok && ParametersAccessor::get( node, strId + "Animator", animatorNode ) ;
 // OMMESSAGE(  "Config " << *animatorNode);
  ok = ok && animatorNode != 0 ;


  OMK::Type::AddAnimatorPrm animatorPrm ;
  animatorPrm.loadParameters( animatorNode ) ;
  animatorPrm.setConfigParam( animatorNode->clone() );
  // if name is not defined, defines one
  if( animatorPrm.getObjectName() == Name() ) animatorPrm.setObjectName( _eventBaseId.getString() ) ;

  if( ok )
  {
    //Don't send a signal if it's a local object ie on only one visu
   if( Name() != _localVisu )
    {
      _owner->sendValuedEvent( _localVisu,
         OMK::Vis::VisBase::ADD_ANIMATOR_EVENT_ID, animatorPrm ) ;
    }
    else
    {
      _owner->fireValuedSignal( OMK::Vis::VisBase::ADD_ANIMATOR_EVENT_ID, animatorPrm ) ;
    }
  }
  else
  {
    OMASSERTM(false, "Unable to create the animator, have you forget some parameters?" << *animatorNode ) ;
  }
  return ok;

}

template< typename Type, typename ModelType, typename AccessorType >
void IAttributeAnimatorT< Type, ModelType, AccessorType >::setValueToOutput()
{
  if ( isUpdated() )
  OMTRACEID("Attribute","Attr Updated " << EventId::getCurrentValueEventId( this->_id.getCString()) << " current :"<< _eventBaseId);

  switch( _type )
  {
  case TYPE_OUTPUT:
    _output->set( ModelType( get() ) ) ;
    break ;
  case TYPE_EVENT_LOCAL_VISU :
    if( isUpdated() ) sendValueTo( _localVisu, _eventBaseId, false ) ;
    break ;
  case TYPE_SIGNAL_ALL_VISU :
    if( isUpdated() ) fireValueTo( _eventBaseId, false ) ;
    break ;
  case TYPE_UNINITIALISED :
    OMERROR( "The attribute is not initialised, call loadParameters()" ) ;
    if ( _output )
    _output->set( ModelType( get() ) ) ;
    break;
  default:
    OMASSERTM( false, "Cannot update the animator" ) ;
  }
}
//-----------------------------------------------------------------

} //namespace OMK  

#endif 

---