OMKIConnectors.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 "OMKIConnectors.h"
#include "OMKIAttribute.h"
#include "OMKExtensibleSimulatedObject.h"
#include "OMKParametersAccessor.inl"
#include "OMKInteractiveExtension.h"
#include "OMKIAccessRule.h"

namespace OMK  
{
  namespace Iii
  {
//-----------------------------------------------------------------
IConnector::IConnector( const Name& id, const Name& category, const Name& type, 
                       OMK::Type::AccessLevel accessLevel, bool freezable, 
                        ExtensibleSimulatedObject *owner ) 
: _id( id ), 
  _category( category ), 
  _type( type ),
  _accessRule( 0 ),
  _owner( owner )
{
  _accessRule = AccessRuleFactory::getInstance().create( "GrpLevel" )( 0 ) ;
}
//-----------------------------------------------------------------
IConnector::IConnector( const Name& id,  
                        const Name& attributeId,  
                        const Name& type,
                        InteractiveExtension *extension,
                        const ConfigurationParameterDescriptor* node ) 
: _id( id ), 
  _attributeId( attributeId ), 
  _category(), 
  _type( type ),
  _accessRule( 0 ),
  _owner( extension->getOwner() ),
  _interactiveExtension( extension )
{
  ParametersAccessor::get( node, "Category", _category ) ;

  // Access rule
  const ConfigurationParameterDescriptor* accessRuleNode = 0 ;
  std::string accessRuleGrp ;
  Name accessRuleType( "GrpLevel" ) ;
  if( ParametersAccessor::get( node, "AccessRule", accessRuleNode ) )
  {
    if( !dynamic_cast< const MultipleConfigurationParameter* >( accessRuleNode ) )
    { // It is a name => Try to find the corresponding access rule definition
      // in the "AccessRules" node of the controller
      ParametersAccessor::get( node, "AccessRule", accessRuleGrp ) ;
      const ConfigurationParameterDescriptor* defaultAccessRulesNode = 0 ;
      ParametersAccessor::get( _owner->getController().getConfigurationParameters(), 
                               "AccessRules", defaultAccessRulesNode ) ;
      ParametersAccessor::get( defaultAccessRulesNode, accessRuleGrp, accessRuleNode ) ;
    }
    // else No name => Try to find a node which defines a local definition of the access rule
  }
  ParametersAccessor::get( accessRuleNode, "Class", accessRuleType ) ;
  _accessRule = AccessRuleFactory::getInstance().create( accessRuleType )( accessRuleNode ) ;

  bool postCompute = _owner->getAttribute( _attributeId )->getOutput() != 0 ;
  ParametersAccessor::get( node, "PostCompute", postCompute ) ;
  // If there is a output we must use post processing
  _interactiveExtension->addConnector( this, postCompute ) ;
}
//-----------------------------------------------------------------
void IConnector::SendControlTakenBy( const Name& newInteractor )
{
  for( std::list< Name >::const_iterator interactor = _toolsInUse.begin() ;
       interactor != _toolsInUse.end() ;
       ++interactor )
  {
    _owner->sendValuedEvent( 
        *interactor, 
        EventId::CONTROL_TAKEN_BY, 
        Type::ControlUpdatedType( Type::ControlUpdatedPrm( _id, newInteractor ) ) ) ;
  }
}
//-----------------------------------------------------------------
void IConnector::SendControlReleased( const Name& interactor )
{
  _owner->sendValuedEvent( interactor, EventId::CONTROL_RELEASED, _id ) ;
}
//-----------------------------------------------------------------
void IConnector::SendControlReleasedBy( const Name& oldInteractor )
{
  for( std::list< Name >::const_iterator interactor = _toolsInUse.begin() ;
       interactor != _toolsInUse.end() ;
       ++interactor )
  {
    if( *interactor != oldInteractor )
    {
      _owner->sendValuedEvent( 
        *interactor, 
        EventId::CONTROL_RELEASED_BY, 
        Type::ControlUpdatedType( Type::ControlUpdatedPrm( _id, oldInteractor ) ) ) ;
    }
  }
}
//-----------------------------------------------------------------
void IConnector::SendControlEnded( const Name& interactor )
{
  _owner->sendValuedEvent( interactor, EventId::CONTROL_ENDED, _id ) ;
}
//-----------------------------------------------------------------
  }// namespace Iii
}// namespace OMK

---