OMKSessionPrm.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 "OMKSessionPrm.h"
#include "OMKAccessLevelList.inl"
#include "OMKInteractorExtension.h"
#include "OMKInteractorOutput.h"
#include "OMKExtensibleSimulatedObject.h"
#include "OMKIAttribute.h"
#include "OMKIAttribute.h"

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

//-----------------------------------------------------------------
SessionPrm* SessionPrm::create( InteractorExtension* owner, const Name& interactiveObject )
{
  OMASSERTM( owner, "Cannot be null" ) ;
  return owner->getOwner()->getController().getPointerToSimulatedObjectNamed( interactiveObject ) ?
      new SessionPrm( owner, interactiveObject ) :
      0 ; // Not ok because it is not a simulated object
}

//-----------------------------------------------------------------
SessionPrm::SessionPrm( InteractorExtension* owner, const Name& interactiveObject ) 
: _interactiveObject( interactiveObject ),
  _owner( owner )
{
  OMASSERTM( _owner, "The listener must be valid" ); 
}

//-----------------------------------------------------------------
SessionPrm::~SessionPrm() 
{
}

//-----------------------------------------------------------------
// connectors.getId : the connector id
// connectors.getSecondId : the category
void SessionPrm::init( const InteractorOutputsMap& interactorOutputsMap, const AccessibleParametersListPrm& connectors ) 
{
  for ( AccessibleParametersListPrm::const_iterator connector = connectors.begin() ; 
        connector != connectors.end() ; 
        ++connector )
  { // Try to connect each id sent by the interactor 
    OMTRACEID( OMK_DEBUG_III, ":-| The interactive object \"" << _interactiveObject << "\" can be controlled with connector \"" << connector->_id << "\" of category \"" << connector->_category << "\" the parameter is " << (connector->_accessible ? "accessible" : "unaccessible") ) ;
    // Is the id in the connector list
    InteractorOutputsMap::const_iterator interactorOutput = interactorOutputsMap.find( InteractorOutputsIndex( connector->_category, connector->_type ) ) ;
    if( interactorOutput != interactorOutputsMap.end() )
    { // Stores a new link
      OMTRACEID( OMK_DEBUG_III, ":-| The session with interactive object \"" << _interactiveObject << "\" can have control from the interactor output \"" << interactorOutput->second->id() << "\"" ) ;
      _links.insert( std::pair< Name, SessionPrm::Link >( interactorOutput->second->id(), Link( connector->_id, interactorOutput->second ) ) ) ;
    }
  }
}

//-----------------------------------------------------------------
void SessionPrm::addControlledConnector( const ControlTakenOfParameterPrm& prm ) 
{
  bool ok = false ;
  for ( std::map< Name, SessionPrm::Link >::iterator link = _links.begin() ; link != _links.end() ; ++link )
  { // Try to find the connector
    if( link->second._connector == prm.first )
    {
      link->second._state = EIsUnderControl ;
      ok = true ;
      break ;
    }
  }
  if( !ok )
  {
    OMTRACEID( OMK_DEBUG_III, ":-( The connector with id \"" << prm.first << "\" is not available, cannot add it !" ) ;
  }
}

//-----------------------------------------------------------------
void SessionPrm::removeControlledConnector( const Name& id )
{
  bool ok = false ;
  for ( std::map< Name, SessionPrm::Link >::iterator link = _links.begin() ; link != _links.end() ; ++link )
  { // Try to find the connector
    if( link->second._connector == id )
    {
      link->second._state = EIsNotControlled ;
      ok = true ;
      break ;
    }
  }
  if( !ok )
  {
    OMTRACEID( OMK_DEBUG_III, ":-( The connector with id \"" << id << "\" is not under control, cannot remove it !" ) ;
  }
}

//-----------------------------------------------------------------
std::list< Name > SessionPrm::getActiveOutputs() const 
{
  std::list< Name > activeOutputs ;
  for ( std::map< Name, Link >::const_iterator link = _links.begin() ; link !=  _links.end() ; ++link )
  {
    if( link->second._state == EIsUnderControl ) activeOutputs.push_back( link->first ) ;
  }
  return activeOutputs ;
}

//-----------------------------------------------------------------
bool SessionPrm::isActiveOutput( const Name& id ) const 
{
  std::map< Name, Link >::const_iterator link = _links.find( id ) ;
  return link != _links.end() && link->second._state == EIsUnderControl ;
}

//-----------------------------------------------------------------
SessionPrm::OutputStates SessionPrm::outputState( const Name& id ) const 
{
  std::map< Name, Link >::const_iterator link = _links.find( id ) ;
  return link != _links.end() ? link->second._state : EUnknow ;
}

//-----------------------------------------------------------------
Name SessionPrm::getOutputId( const Name& connectorId ) const 
{
  Name id ;
  for ( std::map< Name, SessionPrm::Link >::const_iterator link = _links.begin() ; link != _links.end() ; ++link )
  { // Try to find the id in the link part
    if( link->second._connector == connectorId )
    {
      id = link->first ;
      break ;
    }
  }
  return id ;
}

//-----------------------------------------------------------------
void SessionPrm::selfGetAccessibleParameters() 
{ 
  _owner->getInteractor()->sendValuedEvent( _interactiveObject, EventId::GET_ACCESSIBLE_PARAMETERS, OMK::Type::GetAccessibleParametersType( OMK::Type::GetAccessibleParametersPrm( _owner->getGroup(), _owner->getAccessLevel() ) ) ) ;
  _ids.clear() ;
}
//-----------------------------------------------------------------
/*void SessionPrm::selfGetCurrentValues() 
{ 
  AccessCurrentValuePrm connectorsToGet( _owner->getAccessLevel() ) ;   
  if( _ids.empty() )
  {
    for ( std::map< Name, SessionPrm::Link >::const_iterator link = _links.begin() ; link != _links.end() ; ++link )
    { // Try to connect each id sent by the interactor 
      // Is the id in the connector list
      connectorsToGet.addItem( TwoIdsPrm( link->second._connector, link->first ) ) ;
    }
  }
  else
  {
    for ( std::vector< Name >::const_iterator id = _ids.begin() ; id !=  _ids.end() ; ++id )
    {
      std::map< Name, SessionPrm::Link >::const_iterator link = _links.find( *id ) ;
      if( link != _links.end() )
      {
        connectorsToGet.addItem( TwoIdsPrm( link->second._connector, link->first ) ) ;
      }
      else
      {
        OMTRACEID( OMK_DEBUG_III, ":-( The id \"" << (*id) << "\" is not available" ) ;
      }
    }
  }
  if( !connectorsToGet.getItems().empty() )
  {
    _owner->getInteractor()->sendValuedEvent( _interactiveObject, EventId::GET_CURRENT_VALUE, AccessCurrentValueType( connectorsToGet ) ) ;
  }
  
  _ids.clear() ;
}*/
//-----------------------------------------------------------------
void SessionPrm::selfControlTakeOverAndGetCurrentValues() 
{ 
  TakeOverAndGetCurrentValuesPrm connectorsToControl( _owner->getGroup(), _owner->getAccessLevel() ) ;   
  if( _ids.empty() )
  {
    for ( std::map< Name, SessionPrm::Link >::iterator link = _links.begin() ; link != _links.end() ; ++link )
    { // Try to connect each id sent by the interactor 
      // Is the id in the connector list
      connectorsToControl.addItem( ControlTakeOverPrm( link->second._connector,
                                                       link->first
                                                       // FIXME: owner access level is not the apropriate value!
                                                      ) ) ;
      // Set the flag to waiting
      link->second._state = EWaitingForAnswer ;
    }
  }
  else
  {
    for ( std::vector< Name >::const_iterator id = _ids.begin() ; id !=  _ids.end() ; ++id )
    {
      std::map< Name, SessionPrm::Link >::iterator link = _links.find( *id ) ;
      if( link != _links.end() )
      {
        connectorsToControl.addItem( ControlTakeOverPrm( link->second._connector,
                                                         link->first
                                                         // FIXME: owner access level is not the apropriate value!
                                                          ) ) ;
        // Set the flag to waiting
        link->second._state = EWaitingForAnswer ;
      }
      else
      {
        OMTRACEID( OMK_DEBUG_III, ":-( No link with interactor output \"" << (*id) << "\" available" ) ;
      }
    }
  }
  if( !connectorsToControl._items.empty() )
  {
    _owner->getInteractor()->sendValuedEvent( _interactiveObject, EventId::CONTROL_TAKE_OVER_AND_GET_CURRENT_VALUES, TakeOverAndGetCurrentValuesType( connectorsToControl ) ) ;
  }
  _ids.clear() ;
}
//-----------------------------------------------------------------
void SessionPrm::selfControlRelease()
{ 
  ControlReleasePrm connectorsList ;
  for ( std::vector< Name >::const_iterator id = _ids.begin() ; id !=  _ids.end() ; ++id )
  {
    std::map< Name, SessionPrm::Link >::iterator link = _links.find( *id ) ;
    if( link != _links.end() )
    {
      connectorsList.push_back( link->second._connector ) ;
      link->second._state = EIsNotControlled ;
    }
    else
    {
      OMTRACEID( OMK_DEBUG_III, ":-( No link with interactor output \"" << (*id) << "\" available" ) ;
    }
  }
  if( !connectorsList.empty() )
  { // The list is filled => send it
    _owner->getInteractor()->sendValuedEvent( _interactiveObject, EventId::CONTROL_RELEASE, ControlReleaseType( connectorsList ) ) ;
  }
  else if( _ids.empty() )
  { // all is selected or none is selected => release all <=> no parameter to send
    for ( std::map< Name, SessionPrm::Link >::iterator link = _links.begin() ; link != _links.end() ; ++link )
    { 
      // Set the flag to not controlled
      link->second._state = EIsNotControlled ;
    }
    _owner->getInteractor()->sendEvent( _interactiveObject, EventId::CONTROL_RELEASE ) ;
  }
  // else a list of unusable ids => error, no event to send
  _ids.clear() ;
}
//-----------------------------------------------------------------
void SessionPrm::selfControlFreeze() 
{ 
  OMERROR( "Control freeze not implemented for interactive object \"" << _interactiveObject << "\"" << std::endl ) ;
  _ids.clear() ;
}
//-----------------------------------------------------------------
void SessionPrm::selfControlUnfreeze()
{ 
  OMERROR( "control unfreeze not implemented  for interactive object \"" << _interactiveObject << "\"" << std::endl ) ;
  _ids.clear() ;
}

---