OMKInteractorExtension.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 "OMKInteractorExtension.h"
#include "OMKExtensibleSimulatedObject.h"
#include "OMKParametersAccessor.inl"
#include "OMKValuedEventListenerCallBack.h"
#include "OMKEventListenerCallBack.h"
#include "OMKMultipleConfigurationParameter.h"
#include "OMKIAttribute.h"
#include "OMKSessionPrm.h"
#include <vector>
#include <string>
#include <iostream>

using namespace OMK ;
using namespace OMK::Iii ;
using namespace OMK::Type ;

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

// Default constructor
InteractorExtension::InteractorExtension( ExtensibleSimulatedObject* owner, const Name& id, bool registerExtension )
: ExtensionT< ExtensibleSimulatedObject >( owner, id, registerExtension ),
  _access( "", 1 ),
  _accessibleConnectorsListener( 0 ),
  _currentValuesSentAndControlTakenListener( 0 ),
  _controlReleasedListener( 0 ),
  _controlEndedListener( 0 ),
  _controlTakenByListener( 0 ),
  _controlReleasedByListener( 0 ),
  _currentValuesSentListener( 0 )
{
  // To be sure that there is an output all the interactor output are scanned
  const ConfigurationParameterDescriptor * node = _owner->getObjectDescriptor().getExtensionsParameters() ;
  const ConfigurationParameterDescriptor * extNode = node ? node->getSubDescriptorByName( _id.getCString() ) : 0 ;
  const ConfigurationParameterDescriptor * outputNode = extNode ? extNode->getSubDescriptorByName( "Outputs" ) : 0 ;
  if( outputNode )
  {
    int nbItems = outputNode->getNumberOfSubItems() ;
    OMTRACEID( OMK_DEBUG_III, "The interactor " <<  OMK::debugMsg( this, _owner ) << " has " << nbItems << " outputs" ) ;
    for( int i = 0 ; i < nbItems ; ++i )
    { 
      // Retrieves parameters sets for each interactor output
      Name id( static_cast<const MultipleConfigurationParameter *>( outputNode )->getNameOfSubDescriptor( i ) ) ;
      IAttribute* attribute = _owner->getAttribute( id ) ;
      if( attribute )
      {
        // To be sure that there is an output
        attribute->createOutput() ;
        OMTRACEID( OMK_DEBUG_III, ( attribute->getOutput() ? ":-)" : ":-(" ) << " Create the output for \"" << id << "\" !" ) ; 
      }
      else
      {
        OMTRACEID( OMK_DEBUG_III, ":-( Error the interactor " <<  OMK::debugMsg( this, _owner ) << std::endl
                 << ">>> Unable to create the output for \"" << id << "\" because this attribute doesn't exist !" ) ; 
      }
    }
  }
  else
  {
    OMTRACEID( OMK_DEBUG_III, ":-( Error the interactor " <<  OMK::debugMsg( this, _owner ) << std::endl
              << ">>> Unable to find the output node !" ) ; 
  }
}

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

// Destructor
InteractorExtension::~InteractorExtension()
{
  //Removes event listener
  delete _accessibleConnectorsListener ;
  delete _currentValuesSentAndControlTakenListener ;
  delete _controlReleasedListener ;
  delete _controlEndedListener ;
  delete _controlTakenByListener ;
  delete _controlReleasedByListener ;
  delete _currentValuesSentListener ;
  
  // Destroy each session
  closeAllSessions() ;

  // Destroy each connector, which will disconnect its associated input
  for ( InteractorOutputsMap::const_iterator i = _interactorOutputs.begin() ; i !=  _interactorOutputs.end() ; ++i )
  {
    delete i->second ;
  }
  // Finally clears the map 
  _interactorOutputs.clear() ;
}
//-----------------------------------------------------------------

bool InteractorExtension::loadExtensionParameters( const ConfigurationParameterDescriptor * node ) 
{
  bool ok = true ;

  ParametersAccessor::get( node, "Level", _access._level ) ; 
  ok = ParametersAccessor::get( node, "Group", _access._groupName ) && ok ; 
  OMTRACEID( OMK_DEBUG_III, "The interactor" <<  OMK::debugMsg( this, _owner ) 
                         << " is in the group \"" << _access._groupName 
                         << "\" and has the level " << _access._level ) ;

  startInteractor() ;

  const ConfigurationParameterDescriptor * outputNode = node->getSubDescriptorByName( "Outputs" ) ;
  if( outputNode )
  {
    int nbItems = outputNode->getNumberOfSubItems() ;
    OMTRACEID( OMK_DEBUG_III, "The interactor " <<  OMK::debugMsg( this, _owner ) << " has " << nbItems << " outputs" ) ;
    for( int i = 0 ; i < nbItems && ok ; ++i )
    { 
      // Retrieves parameters sets for each interactor output
      Name id( static_cast<const MultipleConfigurationParameter *>( outputNode )->getNameOfSubDescriptor( i ) ) ;
      const ConfigurationParameterDescriptor * outputParameters = outputNode->getSubDescriptorByPosition( i ) ;
      ok = InteractorOutput::create( id, this, outputParameters ) && ok ;
    }
  }

  return ok  ;
}
//-----------------------------------------------------------------

void InteractorExtension::startInteractor() 
{
  if( !_accessibleConnectorsListener )
  { 
    // The event listener is not already created => adds it
    _accessibleConnectorsListener = new Type::AccessibleParametersListEventListener
      ( *_owner, this, 
        &InteractorExtension::processAccessibleParameters, 
        EventId::ACCESSIBLE_PARAMETERS ) ;
    _currentValuesSentAndControlTakenListener = new ControlTakenEventListener
      ( *_owner, this, 
         &InteractorExtension::processCurrentValuesSentAndControlTaken, 
        EventId::CURRENT_VALUES_SENT_AND_CONTROL_TAKEN ) ;
    _controlReleasedListener = new ControlEndedEventListener
      (  *_owner, this, 
         &InteractorExtension::processControlReleased,
         EventId::CONTROL_RELEASED ) ;
    _controlEndedListener = new ControlEndedEventListener
      ( *_owner, this, 
        &InteractorExtension::processControlEnded, 
        EventId::CONTROL_ENDED ) ;
    _controlTakenByListener = new ControlUpdatedEventListener
      ( *_owner, this, 
        &InteractorExtension::processControlTakenBy, 
        EventId::CONTROL_TAKEN_BY ) ;
    _controlReleasedByListener = new ControlUpdatedEventListener
      ( *_owner, this, 
        &InteractorExtension::processControlReleasedBy, 
        EventId::CONTROL_RELEASED_BY ) ;
    _currentValuesSentListener = new EventListenerCallBack< InteractorExtension >
      ( *_owner, this, 
        &InteractorExtension::processCurrentValuesSent, 
        EventId::CURRENT_VALUES_SENT ) ;
  }
}
//-----------------------------------------------------------------

void InteractorExtension::startSessionWith( const Name& interactiveObject )
{ 
  if( !getSessionWith( interactiveObject ) )
  {
    OMTRACEID( OMK_DEBUG_III, "The interactor " <<  OMK::debugMsg( this, _owner ) << " starts session with \"" <<  interactiveObject << "\"") ;
    // Add a new session
    SessionPrm* session = createSession( interactiveObject ) ;
    if( session )
    {
      _sessionsPrm.insert( std::pair< const Name, SessionPrm* >( session->getInteractiveObject(), session ) ) ;
      // Asks for parameters => init will be call if the interactive object answers with the list of its parameters
      (*session).c( getAccessibleParameters ) ;
    }
  }
  else
  {
    OMTRACEID( OMK_DEBUG_III, "The interactor " <<  OMK::debugMsg( this, _owner )
               << " doesn't need to start a session with interactive object \"" <<  interactiveObject << "\", session already exists" ) ;
  }
}

//-----------------------------------------------------------------
SessionPrm* InteractorExtension::createSession( const Name& interactiveObject ) 
{
  // return the standard session (can be nul if interactiveObject is not a simulated object)
  return SessionPrm::create( this, interactiveObject ) ;
}

//-----------------------------------------------------------------
void InteractorExtension::closeSessionWith( const Name& interactiveObject )
{ 
  SessionPrm* session = getSessionWith( interactiveObject ) ;
  if( session )
  {
    OMTRACEID( OMK_DEBUG_III, "The interactor " <<  OMK::debugMsg( this, _owner ) << " stops session with " <<  interactiveObject ) ;
    // Releases the interactive object, erases session from map, and destroys it
    (*session).c( controlRelease ) ;
    _sessionsPrm.erase( interactiveObject ) ;
    delete session ;
  }
}

//-----------------------------------------------------------------
void InteractorExtension::closeAllSessions() 
{
  for ( SessionsMap::const_iterator i = _sessionsPrm.begin() ; i != _sessionsPrm.end() ; i = _sessionsPrm.begin() )
  {
    closeSessionWith( i->first ) ;
  }
}

//-----------------------------------------------------------------
SessionPrm* InteractorExtension::getSessionWith( const Name& interactiveObject ) 
{
  SessionsMap::const_iterator session = _sessionsPrm.find( interactiveObject ) ;
  return ( session != _sessionsPrm.end() ) ? session->second : 0 ;
}

//-----------------------------------------------------------------
bool InteractorExtension::processAccessibleParameters( Type::AccessibleParametersListEvent *event ) 
{
  OMASSERTM( event->eventId == EventId::ACCESSIBLE_PARAMETERS, "The event must be \"" << EventId::ACCESSIBLE_PARAMETERS << "\" but is \"" << event->eventId << "\"" ) ;
  SessionPrm* session = getSessionWith( event->sender ) ;
  OMTRACEID( OMK_DEBUG_III, "The interactor " <<  OMK::debugMsg( this, _owner ) << " received the connectors list from \"" << event->sender << "\"" << ( session ? "" : " but it is not interacting with it !" ) ) ;
  if( session )
  {
    session->init( _interactorOutputs, event->value ) ;
  }
  return session != 0 ;
}

//-----------------------------------------------------------------
bool InteractorExtension::processCurrentValuesSentAndControlTaken( ControlTakenEvent *event ) 
{
  OMASSERTM( event->eventId == EventId::CURRENT_VALUES_SENT_AND_CONTROL_TAKEN, "The event must be \"" << EventId::CONTROL_TAKE_OVER_AND_GET_CURRENT_VALUES << "\" but is \"" << event->eventId << "\"" ) ;
  const ControlTakenPrm& value = event->value ;
  SessionPrm* session = getSessionWith( event->sender ) ;
  if( session )
  {
    for( ControlTakenPrm::const_iterator id = value.begin() ; id !=  value.end() ; ++id )
    {
      session->addControlledConnector( *id ) ;
    }
  }
  else
  {
    OMTRACEID( OMK_DEBUG_III, "The interactor " <<  OMK::debugMsg( this, _owner ) << " has no available session with \"" <<  event->sender << "\"" ) ;
  }

  return session != 0 ;
}

//-----------------------------------------------------------------
bool InteractorExtension::processControlReleased( ControlReleasedEvent *event )
{
  OMASSERTM( event->eventId == EventId::CONTROL_RELEASED, "The event must be \"" << EventId::CONTROL_RELEASED << "\" and is \"" << event->eventId << "\"" ) ;
  OMTRACEID( OMK_DEBUG_III, "The interactor " <<  OMK::debugMsg( this, _owner ) << " has released its control on \"" << event->value << "\"" ) ;
  return false ;
}
//-----------------------------------------------------------------
bool InteractorExtension::processControlEnded( ControlEndedEvent *event ) 
{
  OMASSERTM( event->eventId == EventId::CONTROL_ENDED, "The event must be \"" << EventId::CONTROL_ENDED << "\" and is \"" << event->eventId << "\"" ) ;
  const Name& value = event->value ;
  SessionPrm* session = getSessionWith( event->sender ) ;
  if( session )
  {
    session->removeControlledConnector( value ) ;
  }
  else
  {
    OMTRACEID( OMK_DEBUG_III, "The interactor " <<  OMK::debugMsg( this, _owner ) << " has no available session with \"" <<  event->sender << "\"" ) ;
  }
  return session != 0 ;
}

//-----------------------------------------------------------------
bool InteractorExtension::processCurrentValuesSent( Event* event ) 
{
  OMASSERTM( event->eventId == EventId::CURRENT_VALUES_SENT, "The event must be \"" << EventId::CURRENT_VALUES_SENT << "\" but is \"" << event->eventId << "\"" ) ;
  return true ; 
}
//-----------------------------------------------------------------
bool InteractorExtension::processControlTakenBy( ControlUpdatedEvent* event ) 
{
  OMASSERTM( event->eventId == EventId::CONTROL_TAKEN_BY, "The event must be \"" << EventId::CONTROL_TAKEN_BY << "\" but is \"" << event->eventId << "\"" ) ;
  return true ; 
}
//-----------------------------------------------------------------
bool InteractorExtension::processControlReleasedBy( ControlUpdatedEvent* event ) 
{
  OMASSERTM( event->eventId == EventId::CONTROL_RELEASED_BY, "The event must be \"" << EventId::CONTROL_RELEASED_BY << "\" but is \"" << event->eventId << "\"" ) ;
  return true ; 
}
//-----------------------------------------------------------------
void InteractorExtension::addInteractorOutput( InteractorOutput* interactorOutput ) 
{
  _interactorOutputs.insert( std::pair< InteractorOutputsIndex, InteractorOutput* >( InteractorOutputsIndex( interactorOutput->category(), interactorOutput->type() ), interactorOutput ) ) ;
}
//-----------------------------------------------------------------

---