OMKInputExtension.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 "OMKInputExtension.h"
#include "OMKExtension.inl"
#include "OMKInputListener.h"
#include "OMKAddInputListenerPrm.h"
#include "OMKAddInputKeyPrm.h"
#include "OMKMultipleConfigurationParameter.h"
#include "OMKParametersAccessor.inl"
#include "OMKEscListener.h"
#include "OMKKeyListener.h"
#include "OMKParametersAccessor.h"

using namespace OMK ;
using namespace OMK::Vis ;
using namespace OMK::Inp ;
EventIdentifier InputExtension::ADD_INPUT( "add input listener" ) ;
EventIdentifier InputExtension::REMOVE_INPUT( "remove input listener" ) ;
EventIdentifier InputExtension::ADD_KEY( "add key listener" ) ;
//-------------------------------------------------------------------------
REGISTER_EXTENSION_FACTORY( InputExtension, "InputExtension" ) ;

//-------------------------------------------------------------------------
// constructor
//-------------------------------------------------------------------------
InputExtension::InputExtension( ExtensibleSimulatedObject* owner, const Name& id, bool registerExtension )
: ExtensionT< OMK::Vis::OgreVis >( owner, id, registerExtension ),
  _inputSystem( 0 ),
  _keyboard( 0 ),
  _mouse( 0 ),
  _inputCreatorListener( 0 ),
  _currentWidth (800),
  _currentHeight(600),
  _window (0)
{
}
//-------------------------------------------------------------------------
bool InputExtension::loadExtensionParameters( const ConfigurationParameterDescriptor * node ) 
{
  // Init input devices
  createOISInputSystem(node) ;
  initOIS() ;

  //Insertion in OpenMASK event processing
  _inputCreatorListener = new InputCreatorListener( _owner, this ) ;
  _owner->addEventListener( *_inputCreatorListener ) ;

  // creation of the input listeners defined
  // Retrieve the extension fields to create the extensions which defined a "Class"
  if( node )
  {
    int nbItems = node->getNumberOfSubItems() ;
    for( int i = 0 ; i < nbItems ; ++i )
    { 
      // Retrieves parameters sets for each extension
      std::string id( static_cast<const MultipleConfigurationParameter *>( node )->getNameOfSubDescriptor( i ) ) ;
      if( "ExitOnEsc" == id )
      {
        // For exit on escape
        bool exitOnEsc = false ;
        ParametersAccessor::get( node, "ExitOnEsc", exitOnEsc ) ;
        if( exitOnEsc )
        {
          Name id( "exitOnEsc" ) ;
          addListener( Name( id ), new EscListener( _owner, id ) ) ;
        }
      }
      if( "Keys" == id )
      {
        const ConfigurationParameterDescriptor * keyParam = node->getSubDescriptorByPosition( i ) ;
        int nbKeys = keyParam->getNumberOfSubItems() ;
        for( int k = 0 ; k < nbKeys ; ++k )
        { 
          std::string key( static_cast<const MultipleConfigurationParameter *>( keyParam )->getNameOfSubDescriptor( k ) ) ;
          addListener( Name( "Key_" + key ), new OMK::Inp::KeyListener( _owner, key, keyParam ) ) ;
        }
      }
      else
      {
        const ConfigurationParameterDescriptor * inputParam = node->getSubDescriptorByPosition( i ) ;
        // Try to retrieve the class id to create the extension
        Name classId ;
        if( ParametersAccessor::get( inputParam, "Class", classId ) )
        { // ClassId is ok => Create the extension
          addListener( Name( id ), classId, inputParam ) ;
        }
      }
    }
  }

  return true ;
}

//-------------------------------------------------------------------------
// overwrite this method if you use something else than Ogre
// and change the Type use for the father ExtensionT<> 
void InputExtension::createOISInputSystem(const ConfigurationParameterDescriptor* node)
{
  OMASSERTM( _owner, "Must have a valid visualisation object !" ) ;
  OMASSERTM( _owner->touchRoot().getAutoCreatedWindow(), "Must have a valid visualisation window !" ) ;
  OMASSERTM( !_inputSystem && !_keyboard && !_mouse && _joysticks.empty(), "Must uninitialized !" ) ;
  OIS::ParamList paramList ;
  // Setup basic variables
  // Get window handle
  size_t theWindow = 0;
  _owner->touchRoot().getAutoCreatedWindow()->getCustomAttribute( "WINDOW", &theWindow );
#if defined WIN32
  // Uncomment these two lines to allow users to switch keyboards via the language bar
  paramList.insert(std::make_pair( std::string( "w32_keyboard" ), std::string( "DISCL_FOREGROUND" ) ) );
  paramList.insert(std::make_pair( std::string( "w32_keyboard" ), std::string( "DISCL_NONEXCLUSIVE" ) ) );

#elif defined OIS_LINUX_PLATFORM
  paramList.insert( std::make_pair( std::string( "XAutoRepeatOn" ), std::string( "true") ) );    
  paramList.insert( std::make_pair( std::string( "x11_mouse_hide" ), std::string( "false" ) ) ); 
  paramList.insert( std::make_pair( std::string( "x11_mouse_grab" ), std::string( "false" ) ) ); 

  std::string grabKeyboard ="false";
  ParametersAccessor::get ( node, "x11_keyboard_grab", grabKeyboard);
  OMASSERTM( (grabKeyboard == "false") || (grabKeyboard == "true"),
      " parameter x11_keyboard_grab must be true or false"); 
  paramList.insert( std::make_pair( std::string( "x11_keyboard_grab" ),grabKeyboard ) );         
#endif
  // Fill parameter list
  std::ostringstream theWindowStr;
  theWindowStr << theWindow ;
  paramList.insert( std::make_pair( std::string( "WINDOW" ), theWindowStr.str() ) );

  // Create inputsystem
  _inputSystem = OIS::InputManager::createInputSystem( paramList );
}
//-------------------------------------------------------------------------
void InputExtension::initOIS() 
{
  OMASSERT( _inputSystem && "Must initialized !" ) ;
  // If possible create a buffered keyboard
 if( 0 < _inputSystem->numKeyboards() )
// Future OIS Version
//  if( 0 < _inputSystem->getNumberOfDevices(OIS::OISKeyboard) )
  {
    _keyboard = static_cast<OIS::Keyboard*>( _inputSystem->createInputObject( OIS::OISKeyboard, true ) );
    _keyboard->setEventCallback( this );
  }
  else
  {
    OMTRACEID(OMK_DEBUG_INP_EXT, ">>>No keyboard to listen !" << std::endl ) ;
  }

  // If possible create a buffered mouse
  if( 0 < _inputSystem->numMice() )
// Future OIS Version
//  if( 0 < _inputSystem->getNumberOfDevices(OIS::OISMouse) )
  {
    _mouse = static_cast< OIS::Mouse* >( _inputSystem->createInputObject( OIS::OISMouse, true ) );
    _mouse->setEventCallback( this );

    // Get window size
    unsigned int width, height, depth;
    int left, top;
    _window = _owner->touchRoot().getAutoCreatedWindow();
    OMASSERT ( _window && "No RenderWindow" );
    _window->getMetrics( width, height, depth, left, top );

    // Set mouse region 
    setWindowExtents( width, height );
  }
  else
  {
    OMTRACEID(OMK_DEBUG_INP_EXT, ">>>No mouse to listen !" << std::endl ) ;
  }

  // If possible create all joysticks in buffered mode
  if( 0 < _inputSystem->numJoySticks() ) 
 // Future OIS Version
 //    if( 0 < _inputSystem->getNumberOfDevices(OIS::OISJoyStick) ) 
  {
  _joysticks.resize( _inputSystem->numJoySticks() );
 // Future OIS Version
//  _joysticks.resize( _inputSystem->getNumberOfDevices(OIS::OISJoyStick) );
    for( std::vector< OIS::JoyStick* >::iterator i = _joysticks.begin() ;
         i != _joysticks.end() ; 
         ++i ) 
    {
      (*i) = static_cast< OIS::JoyStick* >( _inputSystem->createInputObject( OIS::OISJoyStick, true ) );
      (*i)->setEventCallback( this );
    }
  }
  else
  {
    OMTRACEID(OMK_DEBUG_INP_EXT, ">>>No joystick to listen !" << std::endl ) ;
  }
}

//-------------------------------------------------------------------------
InputExtension::~InputExtension()
{
  if( _inputSystem ) 
  {
    if( _keyboard ) 
    {
      _inputSystem->destroyInputObject( _keyboard );
      _keyboard = 0;
    }

    if( _mouse ) 
    {
      _inputSystem->destroyInputObject( _mouse );
      _mouse = 0;
    }

    if( 0 < _joysticks.size() ) 
    {
      for( std::vector< OIS::JoyStick* >::iterator i = _joysticks.begin() ; 
          i != _joysticks.end(); 
          ++i ) 
      {
        _inputSystem->destroyInputObject( *i );
      }

      _joysticks.clear();
    }

    OIS::InputManager::destroyInputSystem( _inputSystem ) ;
    _inputSystem = 0 ;

    // Delete all the registered listener
    for( std::map< Name, InputListener* >::iterator i = _inputListeners.begin() ;
         i != _inputListeners.end() ;
         i++  ) 
    {
        delete i->second ;
    }
    // Clear Listeners
    _keyListeners.clear();
    _mouseListeners.clear();
    _joystickListeners.clear();
  }

  // Remove the event listener
  delete _inputCreatorListener ;
}


//-------------------------------------------------------------------------
void InputExtension::preComputeParameters() 
{
  // Need to capture devices every compute
  capture() ;
  //Update Mouse
  if ( _mouse  && 
      (  ( _window->getWidth() != _currentWidth ) 
      || (_window->getHeight() != _currentHeight ) ) )
    setWindowExtents ( _window->getWidth(), _window->getHeight());
}

//-------------------------------------------------------------------------
void InputExtension::capture() 
{
  // Capture/update each device
  if( _keyboard ) 
  {
    _keyboard->capture() ;
  }
  if( _mouse ) 
  {
    _mouse->capture() ;
  }
  for( std::vector< OIS::JoyStick* >::iterator i = _joysticks.begin() ;
       i != _joysticks.end() ; 
       ++i ) 
  {
    (*i)->capture() ;
  }
}

//-----------------------------------------------------------------------------
void InputExtension::setWindowExtents( int width, int height ) 
{
  const OIS::MouseState &mouseState = _mouse->getMouseState();
  mouseState.width  = width;
  mouseState.height = height;
  _currentWidth = width;
  _currentHeight = height;
}



//-------------------------------------------------------------------------
bool InputExtension::keyPressed( const OIS::KeyEvent &e ) 
{
  for( std::map< Name, OIS::KeyListener* >::iterator i = _keyListeners.begin(); 
       i != _keyListeners.end() ; 
       ++i ) 
  {
    i->second->keyPressed( e );
  }

  return true;
}

//-------------------------------------------------------------------------
bool InputExtension::keyReleased( const OIS::KeyEvent &e ) 
{
  for( std::map< Name, OIS::KeyListener* >::iterator i = _keyListeners.begin(); 
       i != _keyListeners.end() ; 
       ++i ) 
  {
    i->second->keyReleased( e );
  }

  return true;
}

//-------------------------------------------------------------------------
bool InputExtension::mouseMoved( const OIS::MouseEvent &e ) 
{
  for( std::map< Name, OIS::MouseListener* >::iterator i = _mouseListeners.begin(); 
       i != _mouseListeners.end() ; 
       ++i ) 
  {
    i->second->mouseMoved( e );
  }

  return true;
}

//-------------------------------------------------------------------------
bool InputExtension::mousePressed( const OIS::MouseEvent &e, OIS::MouseButtonID id ) 
{
  for( std::map< Name, OIS::MouseListener* >::iterator i = _mouseListeners.begin(); 
       i != _mouseListeners.end() ; 
       ++i ) 
  {
    i->second->mousePressed( e, id );
  }

  return true;
}

//-------------------------------------------------------------------------
bool InputExtension::mouseReleased( const OIS::MouseEvent &e, OIS::MouseButtonID id ) 
{
  for( std::map< Name, OIS::MouseListener* >::iterator i = _mouseListeners.begin(); 
       i != _mouseListeners.end() ; 
       ++i ) 
  {
    i->second->mouseReleased( e, id );
  }

  return true;
}

//-------------------------------------------------------------------------
bool InputExtension::povMoved( const OIS::JoyStickEvent &e, int pov ) 
{
  for( std::map< Name, OIS::JoyStickListener* >::iterator i = _joystickListeners.begin(); 
       i != _joystickListeners.end() ; 
       ++i ) 
  {
    i->second->povMoved( e, pov );
  }

  return true;
}

//-------------------------------------------------------------------------
bool InputExtension::axisMoved( const OIS::JoyStickEvent &e, int axis ) 
{
  for( std::map< Name, OIS::JoyStickListener* >::iterator i = _joystickListeners.begin(); 
       i != _joystickListeners.end() ; 
       ++i ) 
  {
    i->second->axisMoved( e, axis );
  }

  return true;
}

//-------------------------------------------------------------------------
bool InputExtension::sliderMoved( const OIS::JoyStickEvent &e, int sliderID ) 
{
  for( std::map< Name, OIS::JoyStickListener* >::iterator i = _joystickListeners.begin(); 
       i != _joystickListeners.end() ; 
       ++i ) 
  {
    i->second->sliderMoved( e, sliderID );
  }

  return true;
}

//-------------------------------------------------------------------------
bool InputExtension::buttonPressed( const OIS::JoyStickEvent &e, int button ) 
{
  for( std::map< Name, OIS::JoyStickListener* >::iterator i = _joystickListeners.begin(); 
       i != _joystickListeners.end() ; 
       ++i ) 
  {
    i->second->buttonPressed( e, button );
  }

  return true;
}

//-------------------------------------------------------------------------
bool InputExtension::buttonReleased( const OIS::JoyStickEvent &e, int button ) 
{
  for( std::map< Name, OIS::JoyStickListener* >::iterator i = _joystickListeners.begin(); 
       i != _joystickListeners.end() ; 
       ++i ) 
  {
    i->second->buttonReleased( e, button );
  }

  return true;
}

//-------------------------------------------------------------------------
bool InputExtension::addKeyListener( const AddInputKeyPrm& prm ) 
{
  return addKeyListener( prm.getKey(), prm.getListeningObjectId() ) ;
}
//-------------------------------------------------------------------------
bool InputExtension::addKeyListener( const std::string& key,
                                     const Name& listeningObject ) 
{
  // return value
  bool ok = false ;
  
  Name listenerId( "Key_" + key ) ;
  std::map< Name, InputListener* >::iterator i = _inputListeners.find( listenerId );
  OMK::Inp::KeyListener* keyListener = 0 ;
  if( i == _inputListeners.end() ) 
  {
    // not yet implemented
    keyListener = new OMK::Inp::KeyListener( _owner, key, 0 ) ;
    addListener( listenerId, keyListener ) ;
  }
  else
  {
    // Already created
    keyListener = dynamic_cast< OMK::Inp::KeyListener* >( i->second ) ;
  }
  // Appends the object to the listener
  keyListener->addListeningObject( listeningObject ) ;

  return ok ;
}
//-------------------------------------------------------------------------
bool InputExtension::addListener( const AddInputListenerPrm& prm ) 
{
  return addListener( prm.getListenerId(),
                      prm.getClassId(),
                      prm.getConfigParam() );
}
//-------------------------------------------------------------------------
bool InputExtension::addListener( const Name& id, 
                                  const Name& classId, 
                                  const ConfigurationParameterDescriptor* configParam ) 
{
  // Creates the listener
  return addListener( id, InputListenerFactory::getInstance().create( classId )( _owner, id, configParam ) ) ;
}
//-------------------------------------------------------------------------
bool InputExtension::addListener( const Name& id, InputListener *listener ) 
{
  std::ostringstream errorMsg ;
  // return value
  bool ok = false ; // Will be ok, if at least one listener (keyboard, mouse or joystick) can be registered
  // Add the new input listener to the visualisation
  if( listener )
  { 
    std::map< Name, InputListener* >::iterator i = _inputListeners.find( id );
    if( i == _inputListeners.end() ) 
    { 
      // It is a really new item, adds it in the main list
      _inputListeners[ id ] = listener ;
      
      //Is it a keyboard listener ?
      if( _keyboard ) 
      { 
        OIS::KeyListener* keyListener = dynamic_cast< OIS::KeyListener* >( listener ) ;
        if( keyListener )
        {
          _keyListeners[ id ] = keyListener ;
          ok = true ;
        }
      }
      else
      {
        errorMsg << "Unable to register the keyboard listener \"" << id << "\" because there is no keyboard" << std::endl ;
      }

      //Is it a mouse listener ?
      if( _mouse ) 
      { 
        OIS::MouseListener* mouseListener = dynamic_cast< OIS::MouseListener* >( listener ) ;
        if( mouseListener )
        {
          _mouseListeners[ id ] = mouseListener ;
          ok = true ;
        }
      }
      else
      {
        errorMsg << "Unable to register the mouse listener \"" << id << "\" because there is no mouse" << std::endl;
      }

      //Is it a joystick listener ?
      if( 0 < _joysticks.size() ) 
      {
        OIS::JoyStickListener* joystickListener = dynamic_cast< OIS::JoyStickListener* >( listener ) ;
        if( joystickListener )
        {
          _joystickListeners[ id ] = joystickListener ;
          ok = true ;
        }
      }
      else
      {
        errorMsg << "Unable to register the joystick listener listener \"" << id << "\" because there is no joystickListener" << std::endl;
      }
    }
    else 
    {
      // Duplicate Item
      errorMsg << "The listener \"" << id<< "\" is a duplicate one" << std::endl ;
    }
  }
  else
  {
    errorMsg << "Unable to create the input listener \"" << id << "\"" << std::endl ;
  }
  // Unable to process event => error message
  if( !ok )
  {
    OMTRACEID(OMK_DEBUG_INP_EXT, "Error for " << OMK::debugMsg( _owner ) << std::endl
                        << ">>> " << errorMsg.str() ) ; 
    delete listener ;
  }
  return ok ;
}
 
//-------------------------------------------------------------------------
bool InputExtension::removeListener( const Name& id ) 
{
  bool ok = false ;
  std::map< Name, InputListener* >::iterator i = _inputListeners.find( id );
  if( i != _inputListeners.end() ) 
  { 
    _inputListeners.erase( i ) ;
    // remove form keyboard listener list
    std::map< Name, OIS::KeyListener* >::iterator ik = _keyListeners.find( id );
    if( ik != _keyListeners.end() ) _keyListeners.erase( ik ) ;
    // remove form mouse listener list
    std::map< Name, OIS::MouseListener* >::iterator im = _mouseListeners.find( id );
    if( im != _mouseListeners.end() ) _mouseListeners.erase( im ) ;
    // remove form joystick listener list
    std::map< Name, OIS::JoyStickListener* >::iterator ij = _joystickListeners.find( id );
    if( ij != _joystickListeners.end() ) _joystickListeners.erase( ij ) ;

    // delete the listener
    delete i->second ;
  }
  else
  {
          OMTRACEID(OMK_DEBUG_INP_EXT, "Error for " << OMK::debugMsg( _owner ) << std::endl
                        << ">>> Unable to remove \"" << id << "\", this listener is not registered." << std::endl ) ; 
  }
  return ok ;
}

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

//-------------------------------------------------------------------------
// InputCreatorListener
//-------------------------------------------------------------------------
InputCreatorListener::InputCreatorListener( OMK::Vis::OgreVis* owner, InputExtension* inputExtension ) 
: EventListener( *owner ),
  _inputExtension( inputExtension )
{
}
//-------------------------------------------------------------------------
InputCreatorListener::~InputCreatorListener()
{
}
//-------------------------------------------------------------------------
void InputCreatorListener::registerEvents()
{
  _owner.registerEventListenerForEvent( *this, InputExtension::ADD_INPUT ) ;
  _owner.registerEventListenerForEvent( *this, InputExtension::REMOVE_INPUT ) ;
  _owner.registerEventListenerForEvent( *this, InputExtension::ADD_KEY ) ;
}
//-------------------------------------------------------------------------
bool InputCreatorListener::processEvent( Event * e ) 
{
  OMTRACEID(OMK_DEBUG_INP_EXT, ">>>eventId  \"" << e->eventId.getString()<< "\"" << std::endl ) ;
  // Return value
  bool ok = false ;

  if( e->eventId == InputExtension::ADD_INPUT )
  { // Add a new partner
          ok = _inputExtension->addListener( dynamic_cast< ValuedEvent< AddInputListenerPrm > * >( e )->value ) ;
  }
  else if( e->eventId == InputExtension::REMOVE_INPUT )
  { // Add a new partner
          ok = _inputExtension->removeListener( dynamic_cast< ValuedEvent< Name > * >( e )->value ) ;
  }
  else if( e->eventId == InputExtension::ADD_KEY )
  { // Add a new partner
          ok = _inputExtension->addKeyListener( dynamic_cast< ValuedEvent< AddInputKeyPrm > * >( e )->value ) ;
  }

  return ok ;
}

---