Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Changeset 1204


Ignore:
Timestamp:
Apr 30, 2008, 9:58:13 AM (16 years ago)
Author:
rgrieder
Message:
  • added some const qualifiers
  • renamed a few very ugly variables for the 7th time
  • added new functions (isHandlerActive, isDeviceInitialised)
Location:
code/branches/input
Files:
7 edited

Legend:

Unmodified
Added
Removed
  • code/branches/input/src/core/CorePrereqs.h

    r1062 r1204  
    114114  class Identifier;
    115115  class IdentifierDistributor;
    116   class InputBuffer;
    117   class InputBufferListener;
    118   class InputHandlerGame;
    119   class InputHandlerGUI;
    120   class InputManager;
    121116  template <class T>
    122117  class Iterator;
     
    146141  class XMLPortObjectContainer;
    147142  class XMLPortParamContainer;
     143
     144  // input
     145  class InputBuffer;
     146  class InputBufferListener;
     147  class InputManager;
     148  class KeyBinder;
     149  class GUIInputHandler;
     150  class KeyHandler;
     151  class MouseHandler;
     152  class JoyStickHandler;
     153
    148154}
    149155
  • code/branches/input/src/core/InputManager.cc

    r1203 r1204  
    3030  @file
    3131  @brief Implementation of the InputManager that captures all the input from OIS
    32          and redirects it to listeners if necessary.
     32         and redirects it to handlers if necessary.
    3333 */
    3434
     
    3737#include "Debug.h"
    3838#include "InputBuffer.h"
    39 #include "ConsoleCommand.h"
    40 #include "util/Convert.h"
     39#include "InputHandler.h"
    4140
    4241namespace orxonox
     
    8382    @param windowHeight The height of the render window
    8483  */
    85   bool InputManager::_initialise(size_t windowHnd, int windowWidth, int windowHeight,
    86         bool createKeyboard, bool createMouse, bool createJoySticks)
     84  bool InputManager::_initialise(const size_t windowHnd, const int windowWidth, const int windowHeight,
     85        const bool createKeyboard, const bool createMouse, const bool createJoySticks)
    8786  {
    8887    if (state_ == IS_UNINIT)
     
    135134
    136135    // InputManager holds the input buffer --> create one and add it.
    137     addKeyListener(new InputBuffer(), "buffer");
     136    addKeyHandler(new InputBuffer(), "buffer");
    138137
    139138    KeyBinder* binder = new KeyBinder();
    140139    binder->loadBindings();
    141     addKeyListener(binder, "keybinder");
    142     addMouseListener(binder, "keybinder");
     140    addKeyHandler(binder, "keybinder");
     141    addMouseHandler(binder, "keybinder");
    143142
    144143    // Read all the key bindings and assign them
     
    273272    if (state_ != IS_UNINIT)
    274273    {
    275       if (listenersKey_.find("buffer") != listenersKey_.end())
    276         delete listenersKey_["buffer"];
    277 
    278       if (listenersKey_.find("keybinder") != listenersKey_.end())
    279         delete listenersKey_["keybinder"];
    280 
    281       listenersKeyActive_.clear();
    282       listenersMouseActive_.clear();
    283       listenersJoySticksActive_.clear();
    284       listenersKey_.clear();
    285       listenersMouse_.clear();
    286       listenersJoySticks_.clear();
     274      if (keyHandlers_.find("buffer") != keyHandlers_.end())
     275        delete keyHandlers_["buffer"];
     276
     277      if (keyHandlers_.find("keybinder") != keyHandlers_.end())
     278        delete keyHandlers_["keybinder"];
     279
     280      activeKeyHandlers_.clear();
     281      activeMouseHandlers_.clear();
     282      activeJoyStickHandlers_.clear();
     283      keyHandlers_.clear();
     284      mouseHandlers_.clear();
     285      joyStickHandlers_.clear();
    287286
    288287      keysDown_.clear();
    289288      mouseButtonsDown_.clear();
    290       joySticksButtonsDown_.clear();
     289      joyStickButtonsDown_.clear();
    291290
    292291      _destroyKeyboard();
     
    368367      if (stateRequest_ != IS_CUSTOM)
    369368      {
    370         listenersKeyActive_.clear();
    371         listenersMouseActive_.clear();
    372         listenersJoySticksActive_.clear();
     369        activeKeyHandlers_.clear();
     370        activeMouseHandlers_.clear();
     371        activeJoyStickHandlers_.clear();
    373372
    374373        switch (stateRequest_)
     
    376375        case IS_NORMAL:
    377376          // normal play mode
    378           if (listenersKey_.find("keybinder") != listenersKey_.end())
    379             listenersKeyActive_.push_back(listenersKey_["keybinder"]);
    380           if (listenersMouse_.find("keybinder") != listenersMouse_.end())
    381             listenersMouseActive_.push_back(listenersMouse_["keybinder"]);
    382           if (listenersJoySticks_.find("keybinder") != listenersJoySticks_.end())
     377          if (keyHandlers_.find("keybinder") != keyHandlers_.end())
     378            activeKeyHandlers_.push_back(keyHandlers_["keybinder"]);
     379          if (mouseHandlers_.find("keybinder") != mouseHandlers_.end())
     380            activeMouseHandlers_.push_back(mouseHandlers_["keybinder"]);
     381          if (joyStickHandlers_.find("keybinder") != joyStickHandlers_.end())
    383382          {
    384383            for (std::map<int, OIS::JoyStick*>::const_iterator it = joySticks_.begin();
    385384                  it != joySticks_.end(); it++)
    386               listenersJoySticksActive_[(*it).first].push_back(listenersJoySticks_["keybinder"]);
     385              activeJoyStickHandlers_[(*it).first].push_back(joyStickHandlers_["keybinder"]);
    387386          }
    388387          break;
     
    393392
    394393        case IS_CONSOLE:
    395           if (listenersMouse_.find("keybinder") != listenersMouse_.end())
    396             listenersMouseActive_.push_back(listenersMouse_["keybinder"]);
    397           if (listenersJoySticks_.find("keybinder") != listenersJoySticks_.end())
     394          if (mouseHandlers_.find("keybinder") != mouseHandlers_.end())
     395            activeMouseHandlers_.push_back(mouseHandlers_["keybinder"]);
     396          if (joyStickHandlers_.find("keybinder") != joyStickHandlers_.end())
    398397          {
    399398            for (std::map<int, OIS::JoyStick*>::const_iterator it = joySticks_.begin();
    400399                  it != joySticks_.end(); it++)
    401               listenersJoySticksActive_[(*it).first].push_back(listenersJoySticks_["keybinder"]);
     400              activeJoyStickHandlers_[(*it).first].push_back(joyStickHandlers_["keybinder"]);
    402401          }
    403402
    404           if (listenersKey_.find("buffer") != listenersKey_.end())
    405             listenersKeyActive_.push_back(listenersKey_["buffer"]);
     403          if (keyHandlers_.find("buffer") != keyHandlers_.end())
     404            activeKeyHandlers_.push_back(keyHandlers_["buffer"]);
    406405          else
    407406          {
    408407            // someone fiddled with the InputBuffer
    409408            CCOUT(2) << "Error: Cannot redirect input to console, InputBuffer instance missing." << std::endl;
    410             if (listenersKey_.find("keybinder") != listenersKey_.end())
    411               listenersKeyActive_.push_back(listenersKey_["keybinder"]);
     409            if (keyHandlers_.find("keybinder") != keyHandlers_.end())
     410              activeKeyHandlers_.push_back(keyHandlers_["keybinder"]);
    412411            else
    413412              // this is bad
     
    430429
    431430
    432     // call all the listeners for the held key events
     431    // call all the handlers for the held key events
    433432    for (std::list<OIS::KeyCode>::const_iterator itKey = keysDown_.begin();
    434433          itKey != keysDown_.end(); itKey++)
    435434    {
    436435      OIS::KeyEvent keyArg(keyboard_, *itKey, 0);
    437       for (std::list<KeyHandler*>::const_iterator itKeyHandler = listenersKeyActive_.begin();
    438             itKeyHandler != listenersKeyActive_.end(); itKeyHandler++)
     436      for (std::list<KeyHandler*>::const_iterator itKeyHandler = activeKeyHandlers_.begin();
     437            itKeyHandler != activeKeyHandlers_.end(); itKeyHandler++)
    439438      {
    440439        (*itKeyHandler)->keyHeld(keyArg);
     
    442441    }
    443442
    444     // call all the listeners for the held mouse button events
     443    // call all the handlers for the held mouse button events
    445444    for (std::list<OIS::MouseButtonID>::const_iterator itMouseButton = mouseButtonsDown_.begin();
    446445          itMouseButton != mouseButtonsDown_.end(); itMouseButton++)
    447446    {
    448447      OIS::MouseEvent mouseButtonArg(mouse_, mouse_->getMouseState());
    449       for (std::list<MouseHandler*>::const_iterator itMouseHandler = listenersMouseActive_.begin();
    450             itMouseHandler != listenersMouseActive_.end(); itMouseHandler++)
     448      for (std::list<MouseHandler*>::const_iterator itMouseHandler = activeMouseHandlers_.begin();
     449            itMouseHandler != activeMouseHandlers_.end(); itMouseHandler++)
    451450      {
    452451        (*itMouseHandler)->mouseHeld(mouseButtonArg, *itMouseButton);
     
    454453    }
    455454
    456     // call all the listeners for the held joy stick button events
    457     for (std::map<int, std::list <int> >::const_iterator itJoyStick = joySticksButtonsDown_.begin();
    458           itJoyStick != joySticksButtonsDown_.end(); itJoyStick++)
     455    // call all the handlers for the held joy stick button events
     456    for (std::map<int, std::list <int> >::const_iterator itJoyStick = joyStickButtonsDown_.begin();
     457          itJoyStick != joyStickButtonsDown_.end(); itJoyStick++)
    459458    {
    460459      int id = (*itJoyStick).first;
     
    463462      {
    464463        OIS::JoyStickEvent joyStickButtonArg(joySticks_[id], joySticks_[id]->getJoyStickState());
    465         for (std::list<JoyStickHandler*>::const_iterator itJoyStickHandler = listenersJoySticksActive_[id].begin();
    466               itJoyStickHandler != listenersJoySticksActive_[id].end(); itJoyStickHandler++)
     464        for (std::list<JoyStickHandler*>::const_iterator itJoyStickHandler = activeJoyStickHandlers_[id].begin();
     465              itJoyStickHandler != activeJoyStickHandlers_[id].end(); itJoyStickHandler++)
    467466        {
    468467          (*itJoyStickHandler)->buttonHeld(joyStickButtonArg, *itJoyStickButton);
     
    490489    keysDown_.push_back(e.key);
    491490
    492     for (std::list<KeyHandler*>::const_iterator it = listenersKeyActive_.begin(); it != listenersKeyActive_.end(); it++)
     491    for (std::list<KeyHandler*>::const_iterator it = activeKeyHandlers_.begin(); it != activeKeyHandlers_.end(); it++)
    493492      (*it)->keyPressed(e);
    494493
     
    512511    }
    513512
    514     for (std::list<KeyHandler*>::const_iterator it = listenersKeyActive_.begin(); it != listenersKeyActive_.end(); it++)
     513    for (std::list<KeyHandler*>::const_iterator it = activeKeyHandlers_.begin(); it != activeKeyHandlers_.end(); it++)
    515514      (*it)->keyReleased(e);
    516515
     
    524523  bool InputManager::mouseMoved(const OIS::MouseEvent &e)
    525524  {
    526     for (std::list<MouseHandler*>::const_iterator it = listenersMouseActive_.begin(); it != listenersMouseActive_.end(); it++)
     525    for (std::list<MouseHandler*>::const_iterator it = activeMouseHandlers_.begin(); it != activeMouseHandlers_.end(); it++)
    527526      (*it)->mouseMoved(e);
    528527
     
    548547    mouseButtonsDown_.push_back(id);
    549548
    550     for (std::list<MouseHandler*>::const_iterator it = listenersMouseActive_.begin(); it != listenersMouseActive_.end(); it++)
     549    for (std::list<MouseHandler*>::const_iterator it = activeMouseHandlers_.begin(); it != activeMouseHandlers_.end(); it++)
    551550      (*it)->mousePressed(e, id);
    552551
     
    571570    }
    572571
    573     for (std::list<MouseHandler*>::const_iterator it = listenersMouseActive_.begin(); it != listenersMouseActive_.end(); it++)
     572    for (std::list<MouseHandler*>::const_iterator it = activeMouseHandlers_.begin(); it != activeMouseHandlers_.end(); it++)
    574573      (*it)->mouseReleased(e, id);
    575574
     
    582581
    583582    // check whether the button is already in the list (can happen when focus was lost)
    584     std::list<int>& buttonsDownList = joySticksButtonsDown_[devID];
     583    std::list<int>& buttonsDownList = joyStickButtonsDown_[devID];
    585584    for (std::list<int>::iterator it = buttonsDownList.begin(); it != buttonsDownList.end(); it++)
    586585    {
     
    591590      }
    592591    }
    593     joySticksButtonsDown_[devID].push_back(button);
    594 
    595     std::list<JoyStickHandler*>::iterator end = listenersJoySticksActive_[devID].end();
    596     for (std::list<JoyStickHandler*>::const_iterator it = listenersJoySticksActive_[devID].begin(); it != end; it++)
     592    joyStickButtonsDown_[devID].push_back(button);
     593
     594    std::list<JoyStickHandler*>::iterator end = activeJoyStickHandlers_[devID].end();
     595    for (std::list<JoyStickHandler*>::const_iterator it = activeJoyStickHandlers_[devID].begin(); it != end; it++)
    597596      (*it)->buttonPressed(arg, button);
    598597
     
    604603    int devID = arg.device->getID();
    605604
    606     // remove the button from the joySticksButtonsDown_ list
    607     std::list<int>& buttonsDownList = joySticksButtonsDown_[devID];
     605    // remove the button from the joyStickButtonsDown_ list
     606    std::list<int>& buttonsDownList = joyStickButtonsDown_[devID];
    608607    for (std::list<int>::iterator it = buttonsDownList.begin(); it != buttonsDownList.end(); it++)
    609608    {
     
    615614    }
    616615
    617     std::list<JoyStickHandler*>::const_iterator end = listenersJoySticksActive_[devID].end();
    618     for (std::list<JoyStickHandler*>::const_iterator it = listenersJoySticksActive_[devID].begin(); it != end; it++)
     616    std::list<JoyStickHandler*>::const_iterator end = activeJoyStickHandlers_[devID].end();
     617    for (std::list<JoyStickHandler*>::const_iterator it = activeJoyStickHandlers_[devID].begin(); it != end; it++)
    619618      (*it)->buttonReleased(arg, button);
    620619
     
    625624  {
    626625    int devID = arg.device->getID();
    627     std::list<JoyStickHandler*>::const_iterator end = listenersJoySticksActive_[devID].end();
    628     for (std::list<JoyStickHandler*>::const_iterator it = listenersJoySticksActive_[devID].begin(); it != end; it++)
     626    std::list<JoyStickHandler*>::const_iterator end = activeJoyStickHandlers_[devID].end();
     627    for (std::list<JoyStickHandler*>::const_iterator it = activeJoyStickHandlers_[devID].begin(); it != end; it++)
    629628      (*it)->axisMoved(arg, axis);
    630629
     
    635634  {
    636635    int devID = arg.device->getID();
    637     std::list<JoyStickHandler*>::const_iterator end = listenersJoySticksActive_[devID].end();
    638     for (std::list<JoyStickHandler*>::const_iterator it = listenersJoySticksActive_[devID].begin(); it != end; it++)
     636    std::list<JoyStickHandler*>::const_iterator end = activeJoyStickHandlers_[devID].end();
     637    for (std::list<JoyStickHandler*>::const_iterator it = activeJoyStickHandlers_[devID].begin(); it != end; it++)
    639638      (*it)->sliderMoved(arg, id);
    640639
     
    645644  {
    646645    int devID = arg.device->getID();
    647     std::list<JoyStickHandler*>::const_iterator end = listenersJoySticksActive_[devID].end();
    648     for (std::list<JoyStickHandler*>::const_iterator it = listenersJoySticksActive_[devID].begin(); it != end; it++)
     646    std::list<JoyStickHandler*>::const_iterator end = activeJoyStickHandlers_[devID].end();
     647    for (std::list<JoyStickHandler*>::const_iterator it = activeJoyStickHandlers_[devID].begin(); it != end; it++)
    649648      (*it)->povMoved(arg, id);
    650649
     
    658657  // ################################
    659658
    660   bool InputManager::initialise(size_t windowHnd, int windowWidth, int windowHeight,
    661     bool createKeyboard, bool createMouse, bool createJoySticks)
     659  bool InputManager::initialise(const size_t windowHnd, const int windowWidth, const int windowHeight,
     660    const bool createKeyboard, const bool createMouse, const bool createJoySticks)
    662661  {
    663662    return _getSingleton()._initialise(windowHnd, windowWidth, windowHeight,
     
    678677  {
    679678    return _getSingleton()._initialiseJoySticks();
     679  }
     680
     681  bool InputManager::isKeyboardInitialised()
     682  {
     683    return (_getSingleton().keyboard_ != 0);
     684  }
     685
     686  bool InputManager::isMouseInitialised()
     687  {
     688    return (_getSingleton().mouse_ != 0);
     689  }
     690
     691  bool InputManager::areJoySticksInitialised()
     692  {
     693    return (_getSingleton().joySticks_.size() > 0);
    680694  }
    681695
     
    708722    @param height the new height of the render window
    709723  */
    710   void InputManager::setWindowExtents(int width, int height)
     724  void InputManager::setWindowExtents(const int width, const int height)
    711725  {
    712726    if (_getSingleton().mouse_)
     
    742756
    743757  /**
    744     @brief Adds a new key listener.
    745     @param listener Pointer to the listener object.
    746     @param name Unique name of the listener.
     758    @brief Adds a new key handler.
     759    @param handler Pointer to the handler object.
     760    @param name Unique name of the handler.
    747761    @return True if added, false if name already existed.
    748762  */
    749   bool InputManager::addKeyListener(KeyHandler* listener, const std::string& name)
    750   {
    751     if (_getSingleton().listenersKey_.find(name) == _getSingleton().listenersKey_.end())
    752     {
    753       _getSingleton().listenersKey_[name] = listener;
     763  bool InputManager::addKeyHandler(KeyHandler* handler, const std::string& name)
     764  {
     765    if (_getSingleton().keyHandlers_.find(name) == _getSingleton().keyHandlers_.end())
     766    {
     767      _getSingleton().keyHandlers_[name] = handler;
    754768      return true;
    755769    }
     
    759773
    760774  /**
    761     @brief Removes a Key Listener from the list.
    762     @param name Unique name of the listener.
     775    @brief Removes a Key handler from the list.
     776    @param name Unique name of the handler.
    763777    @return True if removal was successful, false if name was not found.
    764778  */
    765   bool InputManager::removeKeyListener(const std::string &name)
    766   {
    767     disableKeyListener(name);
    768     std::map<std::string, KeyHandler*>::iterator it = _getSingleton().listenersKey_.find(name);
    769     if (it != _getSingleton().listenersKey_.end())
    770     {
    771       _getSingleton().listenersKey_.erase(it);
     779  bool InputManager::removeKeyHandler(const std::string &name)
     780  {
     781    disableKeyHandler(name);
     782    std::map<std::string, KeyHandler*>::iterator it = _getSingleton().keyHandlers_.find(name);
     783    if (it != _getSingleton().keyHandlers_.end())
     784    {
     785      _getSingleton().keyHandlers_.erase(it);
    772786      return true;
    773787    }
     
    777791
    778792  /**
    779     @brief Returns the pointer to a listener.
    780     @param name Unique name of the listener.
     793    @brief Returns the pointer to a handler.
     794    @param name Unique name of the handler.
    781795    @return Pointer to the instance, 0 if name was not found.
    782796  */
    783   KeyHandler* InputManager::getKeyListener(const std::string& name)
    784   {
    785     std::map<std::string, KeyHandler*>::iterator it = _getSingleton().listenersKey_.find(name);
    786     if (it != _getSingleton().listenersKey_.end())
     797  KeyHandler* InputManager::getKeyHandler(const std::string& name)
     798  {
     799    std::map<std::string, KeyHandler*>::iterator it = _getSingleton().keyHandlers_.find(name);
     800    if (it != _getSingleton().keyHandlers_.end())
    787801    {
    788802      return (*it).second;
     
    793807
    794808  /**
    795     @brief Enables a specific key listener that has already been added.
    796     @param name Unique name of the listener.
     809    @brief Enables a specific key handler that has already been added.
     810    @param name Unique name of the handler.
    797811    @return False if name was not found, true otherwise.
    798812  */
    799   bool InputManager::enableKeyListener(const std::string& name)
    800   {
    801     // get pointer from the map with all stored listeners
    802     std::map<std::string, KeyHandler*>::const_iterator mapIt = _getSingleton().listenersKey_.find(name);
    803     if (mapIt == _getSingleton().listenersKey_.end())
    804       return false;
    805     // see whether the listener is already in the list
    806     for (std::list<KeyHandler*>::iterator it = _getSingleton().listenersKeyActive_.begin();
    807           it != _getSingleton().listenersKeyActive_.end(); it++)
     813  bool InputManager::enableKeyHandler(const std::string& name)
     814  {
     815    // get pointer from the map with all stored handlers
     816    std::map<std::string, KeyHandler*>::const_iterator mapIt = _getSingleton().keyHandlers_.find(name);
     817    if (mapIt == _getSingleton().keyHandlers_.end())
     818      return false;
     819    // see whether the handler is already in the list
     820    for (std::list<KeyHandler*>::iterator it = _getSingleton().activeKeyHandlers_.begin();
     821          it != _getSingleton().activeKeyHandlers_.end(); it++)
    808822    {
    809823      if ((*it) == (*mapIt).second)
    810824        return true;
    811825    }
    812     _getSingleton().listenersKeyActive_.push_back((*mapIt).second);
    813     return true;
    814   }
    815 
    816   /**
    817     @brief Disables a specific key listener.
    818     @param name Unique name of the listener.
     826    _getSingleton().activeKeyHandlers_.push_back((*mapIt).second);
     827    return true;
     828  }
     829
     830  /**
     831    @brief Disables a specific key handler.
     832    @param name Unique name of the handler.
    819833    @return False if name was not found, true otherwise.
    820834  */
    821   bool InputManager::disableKeyListener(const std::string &name)
    822   {
    823     // get pointer from the map with all stored listeners
    824     std::map<std::string, KeyHandler*>::const_iterator mapIt = _getSingleton().listenersKey_.find(name);
    825     if (mapIt == _getSingleton().listenersKey_.end())
    826       return false;
    827     // look for the listener in the list
    828     for (std::list<KeyHandler*>::iterator it = _getSingleton().listenersKeyActive_.begin();
    829           it != _getSingleton().listenersKeyActive_.end(); it++)
     835  bool InputManager::disableKeyHandler(const std::string &name)
     836  {
     837    // get pointer from the map with all stored handlers
     838    std::map<std::string, KeyHandler*>::const_iterator mapIt = _getSingleton().keyHandlers_.find(name);
     839    if (mapIt == _getSingleton().keyHandlers_.end())
     840      return false;
     841    // look for the handler in the list
     842    for (std::list<KeyHandler*>::iterator it = _getSingleton().activeKeyHandlers_.begin();
     843          it != _getSingleton().activeKeyHandlers_.end(); it++)
    830844    {
    831845      if ((*it) == (*mapIt).second)
    832846      {
    833         _getSingleton().listenersKeyActive_.erase(it);
     847        _getSingleton().activeKeyHandlers_.erase(it);
    834848        return true;
    835849      }
     
    838852  }
    839853
     854  /**
     855    @brief Checks whether a key handler is active
     856    @param name Unique name of the handler.
     857    @return False if key handler is not active or doesn't exist, true otherwise.
     858  */
     859  bool InputManager::isKeyHandlerActive(const std::string& name)
     860  {
     861    // get pointer from the map with all stored handlers
     862    std::map<std::string, KeyHandler*>::const_iterator mapIt = _getSingleton().keyHandlers_.find(name);
     863    if (mapIt == _getSingleton().keyHandlers_.end())
     864      return false;
     865    // see whether the handler is already in the list
     866    for (std::list<KeyHandler*>::iterator it = _getSingleton().activeKeyHandlers_.begin();
     867          it != _getSingleton().activeKeyHandlers_.end(); it++)
     868    {
     869      if ((*it) == (*mapIt).second)
     870        return true;
     871    }
     872    return false;
     873  }
     874
    840875
    841876  // ###### MouseHandler ######
    842877  /**
    843     @brief Adds a new mouse listener.
    844     @param listener Pointer to the listener object.
    845     @param name Unique name of the listener.
     878    @brief Adds a new mouse handler.
     879    @param handler Pointer to the handler object.
     880    @param name Unique name of the handler.
    846881    @return True if added, false if name already existed.
    847882  */
    848   bool InputManager::addMouseListener(MouseHandler* listener, const std::string& name)
    849   {
    850     if (_getSingleton().listenersMouse_.find(name) == _getSingleton().listenersMouse_.end())
    851     {
    852       _getSingleton().listenersMouse_[name] = listener;
     883  bool InputManager::addMouseHandler(MouseHandler* handler, const std::string& name)
     884  {
     885    if (_getSingleton().mouseHandlers_.find(name) == _getSingleton().mouseHandlers_.end())
     886    {
     887      _getSingleton().mouseHandlers_[name] = handler;
    853888      return true;
    854889    }
     
    858893
    859894  /**
    860     @brief Removes a Mouse Listener from the list.
    861     @param name Unique name of the listener.
     895    @brief Removes a Mouse handler from the list.
     896    @param name Unique name of the handler.
    862897    @return True if removal was successful, false if name was not found.
    863898  */
    864   bool InputManager::removeMouseListener(const std::string &name)
    865   {
    866     disableMouseListener(name);
    867     std::map<std::string, MouseHandler*>::iterator it = _getSingleton().listenersMouse_.find(name);
    868     if (it != _getSingleton().listenersMouse_.end())
    869     {
    870       _getSingleton().listenersMouse_.erase(it);
     899  bool InputManager::removeMouseHandler(const std::string &name)
     900  {
     901    disableMouseHandler(name);
     902    std::map<std::string, MouseHandler*>::iterator it = _getSingleton().mouseHandlers_.find(name);
     903    if (it != _getSingleton().mouseHandlers_.end())
     904    {
     905      _getSingleton().mouseHandlers_.erase(it);
    871906      return true;
    872907    }
     
    876911
    877912  /**
    878     @brief Returns the pointer to a listener.
    879     @param name Unique name of the listener.
     913    @brief Returns the pointer to a handler.
     914    @param name Unique name of the handler.
    880915    @return Pointer to the instance, 0 if name was not found.
    881916  */
    882   MouseHandler* InputManager::getMouseListener(const std::string& name)
    883   {
    884     std::map<std::string, MouseHandler*>::iterator it = _getSingleton().listenersMouse_.find(name);
    885     if (it != _getSingleton().listenersMouse_.end())
     917  MouseHandler* InputManager::getMouseHandler(const std::string& name)
     918  {
     919    std::map<std::string, MouseHandler*>::iterator it = _getSingleton().mouseHandlers_.find(name);
     920    if (it != _getSingleton().mouseHandlers_.end())
    886921    {
    887922      return (*it).second;
     
    892927
    893928  /**
    894     @brief Enables a specific mouse listener that has already been added.
    895     @param name Unique name of the listener.
     929    @brief Enables a specific mouse handler that has already been added.
     930    @param name Unique name of the handler.
    896931    @return False if name was not found, true otherwise.
    897932  */
    898   bool InputManager::enableMouseListener(const std::string& name)
    899   {
    900     // get pointer from the map with all stored listeners
    901     std::map<std::string, MouseHandler*>::const_iterator mapIt = _getSingleton().listenersMouse_.find(name);
    902     if (mapIt == _getSingleton().listenersMouse_.end())
    903       return false;
    904     // see whether the listener is already in the list
    905     for (std::list<MouseHandler*>::iterator it = _getSingleton().listenersMouseActive_.begin();
    906           it != _getSingleton().listenersMouseActive_.end(); it++)
     933  bool InputManager::enableMouseHandler(const std::string& name)
     934  {
     935    // get pointer from the map with all stored handlers
     936    std::map<std::string, MouseHandler*>::const_iterator mapIt = _getSingleton().mouseHandlers_.find(name);
     937    if (mapIt == _getSingleton().mouseHandlers_.end())
     938      return false;
     939    // see whether the handler is already in the list
     940    for (std::list<MouseHandler*>::iterator it = _getSingleton().activeMouseHandlers_.begin();
     941          it != _getSingleton().activeMouseHandlers_.end(); it++)
    907942    {
    908943      if ((*it) == (*mapIt).second)
    909944        return true;
    910945    }
    911     _getSingleton().listenersMouseActive_.push_back((*mapIt).second);
    912     return true;
    913   }
    914 
    915   /**
    916     @brief Disables a specific mouse listener.
    917     @param name Unique name of the listener.
     946    _getSingleton().activeMouseHandlers_.push_back((*mapIt).second);
     947    return true;
     948  }
     949
     950  /**
     951    @brief Disables a specific mouse handler.
     952    @param name Unique name of the handler.
    918953    @return False if name was not found, true otherwise.
    919954  */
    920   bool InputManager::disableMouseListener(const std::string &name)
    921   {
    922     // get pointer from the map with all stored listeners
    923     std::map<std::string, MouseHandler*>::const_iterator mapIt = _getSingleton().listenersMouse_.find(name);
    924     if (mapIt == _getSingleton().listenersMouse_.end())
    925       return false;
    926     // look for the listener in the list
    927     for (std::list<MouseHandler*>::iterator it = _getSingleton().listenersMouseActive_.begin();
    928           it != _getSingleton().listenersMouseActive_.end(); it++)
     955  bool InputManager::disableMouseHandler(const std::string &name)
     956  {
     957    // get pointer from the map with all stored handlers
     958    std::map<std::string, MouseHandler*>::const_iterator mapIt = _getSingleton().mouseHandlers_.find(name);
     959    if (mapIt == _getSingleton().mouseHandlers_.end())
     960      return false;
     961    // look for the handler in the list
     962    for (std::list<MouseHandler*>::iterator it = _getSingleton().activeMouseHandlers_.begin();
     963          it != _getSingleton().activeMouseHandlers_.end(); it++)
    929964    {
    930965      if ((*it) == (*mapIt).second)
    931966      {
    932         _getSingleton().listenersMouseActive_.erase(it);
     967        _getSingleton().activeMouseHandlers_.erase(it);
    933968        return true;
    934969      }
     
    937972  }
    938973
     974  /**
     975    @brief Checks whether a mouse handler is active
     976    @param name Unique name of the handler.
     977    @return False if key handler is not active or doesn't exist, true otherwise.
     978  */
     979  bool InputManager::isMouseHandlerActive(const std::string& name)
     980  {
     981    // get pointer from the map with all stored handlers
     982    std::map<std::string, MouseHandler*>::const_iterator mapIt = _getSingleton().mouseHandlers_.find(name);
     983    if (mapIt == _getSingleton().mouseHandlers_.end())
     984      return false;
     985    // see whether the handler is already in the list
     986    for (std::list<MouseHandler*>::iterator it = _getSingleton().activeMouseHandlers_.begin();
     987          it != _getSingleton().activeMouseHandlers_.end(); it++)
     988    {
     989      if ((*it) == (*mapIt).second)
     990        return true;
     991    }
     992    return false;
     993  }
     994
    939995
    940996  // ###### JoyStickHandler ######
    941997
    942998  /**
    943     @brief Adds a new joy stick listener.
    944     @param listener Pointer to the listener object.
    945     @param name Unique name of the listener.
     999    @brief Adds a new joy stick handler.
     1000    @param handler Pointer to the handler object.
     1001    @param name Unique name of the handler.
    9461002    @return True if added, false if name already existed.
    9471003  */
    948   bool InputManager::addJoyStickListener(JoyStickHandler* listener, const std::string& name)
    949   {
    950     if (_getSingleton().listenersJoySticks_.find(name) == _getSingleton().listenersJoySticks_.end())
    951     {
    952       _getSingleton().listenersJoySticks_[name] = listener;
     1004  bool InputManager::addJoyStickHandler(JoyStickHandler* handler, const std::string& name)
     1005  {
     1006    if (_getSingleton().joyStickHandlers_.find(name) == _getSingleton().joyStickHandlers_.end())
     1007    {
     1008      _getSingleton().joyStickHandlers_[name] = handler;
    9531009      return true;
    9541010    }
     
    9581014
    9591015  /**
    960     @brief Removes a JoyStick Listener from the list.
    961     @param name Unique name of the listener.
     1016    @brief Removes a JoyStick handler from the list.
     1017    @param name Unique name of the handler.
    9621018    @return True if removal was successful, false if name was not found.
    9631019  */
    964   bool InputManager::removeJoyStickListener(const std::string &name)
     1020  bool InputManager::removeJoyStickHandler(const std::string &name)
    9651021  {
    9661022    for (std::map<int, OIS::JoyStick*>::iterator itstick = _getSingleton().joySticks_.begin(); itstick != _getSingleton().joySticks_.end(); itstick++)
    967       disableJoyStickListener(name, (*itstick).first);
    968 
    969     std::map<std::string, JoyStickHandler*>::iterator it = _getSingleton().listenersJoySticks_.find(name);
    970     if (it != _getSingleton().listenersJoySticks_.end())
    971     {
    972       _getSingleton().listenersJoySticks_.erase(it);
     1023      disableJoyStickHandler(name, (*itstick).first);
     1024
     1025    std::map<std::string, JoyStickHandler*>::iterator it = _getSingleton().joyStickHandlers_.find(name);
     1026    if (it != _getSingleton().joyStickHandlers_.end())
     1027    {
     1028      _getSingleton().joyStickHandlers_.erase(it);
    9731029      return true;
    9741030    }
     
    9781034
    9791035  /**
    980     @brief Returns the pointer to a listener.
    981     @param name Unique name of the listener.
     1036    @brief Returns the pointer to a handler.
     1037    @param name Unique name of the handler.
    9821038    @return Pointer to the instance, 0 if name was not found.
    9831039  */
    984   JoyStickHandler* InputManager::getJoyStickListener(const std::string& name)
    985   {
    986     std::map<std::string, JoyStickHandler*>::iterator it = _getSingleton().listenersJoySticks_.find(name);
    987     if (it != _getSingleton().listenersJoySticks_.end())
     1040  JoyStickHandler* InputManager::getJoyStickHandler(const std::string& name)
     1041  {
     1042    std::map<std::string, JoyStickHandler*>::iterator it = _getSingleton().joyStickHandlers_.find(name);
     1043    if (it != _getSingleton().joyStickHandlers_.end())
    9881044    {
    9891045      return (*it).second;
     
    9941050
    9951051  /**
    996     @brief Enables a specific joy stick listener that has already been added.
    997     @param name Unique name of the listener.
     1052    @brief Enables a specific joy stick handler that has already been added.
     1053    @param name Unique name of the handler.
    9981054    @return False if name or id was not found, true otherwise.
    9991055  */
    1000   bool InputManager::enableJoyStickListener(const std::string& name, const int id)
    1001   {
    1002     // get pointer from the map with all stored listeners
    1003     std::map<std::string, JoyStickHandler*>::const_iterator listenerIt = _getSingleton().listenersJoySticks_.find(name);
    1004     if (listenerIt == _getSingleton().listenersJoySticks_.end())
     1056  bool InputManager::enableJoyStickHandler(const std::string& name, const int id)
     1057  {
     1058    // get pointer from the map with all stored handlers
     1059    std::map<std::string, JoyStickHandler*>::const_iterator handlerIt = _getSingleton().joyStickHandlers_.find(name);
     1060    if (handlerIt == _getSingleton().joyStickHandlers_.end())
    10051061      return false;
    10061062
     
    10101066      return false;
    10111067
    1012     // see whether the listener is already in the list
    1013     for (std::list<JoyStickHandler*>::iterator it = _getSingleton().listenersJoySticksActive_[id].begin();
    1014           it != _getSingleton().listenersJoySticksActive_[id].end(); it++)
    1015     {
    1016       if ((*it) == (*listenerIt).second)
     1068    // see whether the handler is already in the list
     1069    for (std::list<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[id].begin();
     1070          it != _getSingleton().activeJoyStickHandlers_[id].end(); it++)
     1071    {
     1072      if ((*it) == (*handlerIt).second)
    10171073        return true;
    10181074    }
    1019     _getSingleton().listenersJoySticksActive_[id].push_back((*listenerIt).second);
    1020     return true;
    1021   }
    1022 
    1023   /**
    1024     @brief Disables a specific joy stick listener.
    1025     @param name Unique name of the listener.
     1075    _getSingleton().activeJoyStickHandlers_[id].push_back((*handlerIt).second);
     1076    return true;
     1077  }
     1078
     1079  /**
     1080    @brief Disables a specific joy stick handler.
     1081    @param name Unique name of the handler.
    10261082    @return False if name or id was not found, true otherwise.
    10271083  */
    1028   bool InputManager::disableJoyStickListener(const std::string &name, int id)
    1029   {
    1030     // get pointer from the map with all stored listeners
    1031     std::map<std::string, JoyStickHandler*>::const_iterator listenerIt = _getSingleton().listenersJoySticks_.find(name);
    1032     if (listenerIt == _getSingleton().listenersJoySticks_.end())
     1084  bool InputManager::disableJoyStickHandler(const std::string &name, int id)
     1085  {
     1086    // get pointer from the map with all stored handlers
     1087    std::map<std::string, JoyStickHandler*>::const_iterator handlerIt = _getSingleton().joyStickHandlers_.find(name);
     1088    if (handlerIt == _getSingleton().joyStickHandlers_.end())
    10331089      return false;
    10341090
     
    10381094      return false;
    10391095
    1040     // look for the listener in the list
    1041     for (std::list<JoyStickHandler*>::iterator it = _getSingleton().listenersJoySticksActive_[id].begin();
    1042           it != _getSingleton().listenersJoySticksActive_[id].end(); it++)
    1043     {
    1044       if ((*it) == (*listenerIt).second)
    1045       {
    1046         _getSingleton().listenersJoySticksActive_[id].erase(it);
     1096    // look for the handler in the list
     1097    for (std::list<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[id].begin();
     1098          it != _getSingleton().activeJoyStickHandlers_[id].end(); it++)
     1099    {
     1100      if ((*it) == (*handlerIt).second)
     1101      {
     1102        _getSingleton().activeJoyStickHandlers_[id].erase(it);
    10471103        return true;
    10481104      }
     
    10511107  }
    10521108
     1109  /**
     1110    @brief Checks whether a joy stick handler is active
     1111    @param name Unique name of the handler.
     1112    @return False if key handler is not active or doesn't exist, true otherwise.
     1113  */
     1114  bool InputManager::isJoyStickHandlerActive(const std::string& name, const int id)
     1115  {
     1116    // get pointer from the map with all stored handlers
     1117    std::map<std::string, JoyStickHandler*>::const_iterator handlerIt = _getSingleton().joyStickHandlers_.find(name);
     1118    if (handlerIt == _getSingleton().joyStickHandlers_.end())
     1119      return false;
     1120
     1121    // check for existance of the ID
     1122    std::map<int, OIS::JoyStick*>::const_iterator joyStickIt = _getSingleton().joySticks_.find(id);
     1123    if (joyStickIt == _getSingleton().joySticks_.end())
     1124      return false;
     1125
     1126    // see whether the handler is already in the list
     1127    for (std::list<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[id].begin();
     1128          it != _getSingleton().activeJoyStickHandlers_[id].end(); it++)
     1129    {
     1130      if ((*it) == (*handlerIt).second)
     1131        return true;
     1132    }
     1133    return false;
     1134  }
     1135
    10531136}
  • code/branches/input/src/core/InputManager.h

    r1203 r1204  
    4343#include "ois/OIS.h"
    4444#include "Tickable.h"
    45 //#include "InputEvent.h"
    46 #include "InputHandler.h"
    4745
    4846namespace orxonox
     
    5452  /**
    5553    @brief Captures and distributes mouse and keyboard input.
    56     It resolves the key bindings to InputEvents which can be heard by
    57     implementing the InputEventListener interface.
    5854  */
    5955  class _CoreExport InputManager
    6056        : public Tickable,
    61           public OIS::MouseListener, public OIS::KeyListener, public OIS::JoyStickListener
     57          public OIS::KeyListener, public OIS::MouseListener, public OIS::JoyStickListener
    6258  {
    6359  public: // enumerations
     
    7672
    7773  public: // static functions
    78     static bool initialise(size_t windowHnd, int windowWidth, int windowHeight,
    79           bool createKeyboard = true, bool createMouse = true, bool createJoySticks = false);
     74    static bool initialise(const size_t windowHnd, const int windowWidth, const int windowHeight,
     75          const bool createKeyboard = true, const bool createMouse = true, const bool createJoySticks = false);
    8076    static bool initialiseKeyboard();
    8177    static bool initialiseMouse();
    8278    static bool initialiseJoySticks();
     79    static bool isKeyboardInitialised();
     80    static bool isMouseInitialised();
     81    static bool areJoySticksInitialised();
    8382
    8483    static void destroy();
     
    8786    static void destroyJoySticks();
    8887
    89     static void setWindowExtents(int width, int height);
     88    static void setWindowExtents(const int width, const int height);
    9089
    9190    static void setInputState(const InputState state);
    9291    static InputState getInputState();
    93     static void setKeyBindingState           (bool bActive);
    94     static void setMouseButtonBindingState   (bool bActive);
    95     static void setJoyStickButtonBindingState(bool bActive);
    9692
    97     static bool addKeyListener(KeyHandler* listener, const std::string& name);
    98     static bool removeKeyListener  (const std::string& name);
    99     static bool enableKeyListener  (const std::string& name);
    100     static bool disableKeyListener (const std::string& name);
    101     static bool isKeyListenerActive(const std::string& name);
    102     static KeyHandler* getKeyListener(const std::string& name);
     93    static bool addKeyHandler                 (KeyHandler* handler, const std::string& name);
     94    static bool removeKeyHandler              (const std::string& name);
     95    static KeyHandler* getKeyHandler          (const std::string& name);
     96    static bool enableKeyHandler              (const std::string& name);
     97    static bool disableKeyHandler             (const std::string& name);
     98    static bool isKeyHandlerActive            (const std::string& name);
    10399
    104     static bool addMouseListener(MouseHandler* listener, const std::string& name);
    105     static bool removeMouseListener  (const std::string& name);
    106     static bool enableMouseListener  (const std::string& name);
    107     static bool disableMouseListener (const std::string& name);
    108     static bool isMouseListenerActive(const std::string& name);
    109     static MouseHandler* getMouseListener(const std::string& name);
     100    static bool addMouseHandler               (MouseHandler* handler, const std::string& name);
     101    static bool removeMouseHandler            (const std::string& name);
     102    static MouseHandler* getMouseHandler      (const std::string& name);
     103    static bool enableMouseHandler            (const std::string& name);
     104    static bool disableMouseHandler           (const std::string& name);
     105    static bool isMouseHandlerActive          (const std::string& name);
    110106
    111     static bool addJoyStickListener(JoyStickHandler* listener, const std::string& name);
    112     static bool removeJoyStickListener  (const std::string& name);
    113     static bool enableJoyStickListener  (const std::string& name, const int id);
    114     static bool disableJoyStickListener (const std::string& name, const int id);
    115     static bool isJoyStickListenerActive(const std::string& name);
    116     static JoyStickHandler* getJoyStickListener(const std::string& name);
     107    static bool addJoyStickHandler            (JoyStickHandler* handler, const std::string& name);
     108    static bool removeJoyStickHandler         (const std::string& name);
     109    static JoyStickHandler* getJoyStickHandler(const std::string& name);
     110    static bool enableJoyStickHandler        (const std::string& name, const int id);
     111    static bool disableJoyStickHandler        (const std::string& name, const int id);
     112    static bool isJoyStickHandlerActive       (const std::string& name, const int id);
    117113
    118114    // Temporary solutions. Will be removed soon!
     
    127123
    128124    // Intenal methods
    129     bool _initialise(size_t, int, int, bool, bool, bool);
     125    bool _initialise(const size_t, const int, const int, const bool, const bool, const bool);
    130126    bool _initialiseKeyboard();
    131127    bool _initialiseMouse();
     
    157153
    158154  private: // variables
    159     OIS::InputManager* inputSystem_;            //!< OIS input manager
    160     OIS::Keyboard*     keyboard_;               //!< OIS mouse
    161     OIS::Mouse*        mouse_;                  //!< OIS keyboard
    162     std::map<int, OIS::JoyStick*> joySticks_;   //!< OIS joy sticks
     155    OIS::InputManager*                          inputSystem_; //!< OIS input manager
     156    OIS::Keyboard*                              keyboard_;    //!< OIS mouse
     157    OIS::Mouse*                                 mouse_;       //!< OIS keyboard
     158    std::map<int, OIS::JoyStick*>               joySticks_;   //!< OIS joy sticks
    163159
    164160    InputState state_;
    165161    InputState stateRequest_;
    166162
    167     std::map<std::string, KeyHandler*>      listenersKey_;
    168     std::map<std::string, MouseHandler*>    listenersMouse_;
    169     std::map<std::string, JoyStickHandler*> listenersJoySticks_;
     163    std::map<std::string, KeyHandler*>          keyHandlers_;
     164    std::map<std::string, MouseHandler*>        mouseHandlers_;
     165    std::map<std::string, JoyStickHandler*>     joyStickHandlers_;
    170166
    171     std::list<KeyHandler*>      listenersKeyActive_;
    172     std::list<MouseHandler*>    listenersMouseActive_;
    173     std::map< int, std::list<JoyStickHandler*> > listenersJoySticksActive_;
     167    std::list<KeyHandler*>                      activeKeyHandlers_;
     168    std::list<MouseHandler*>                    activeMouseHandlers_;
     169    std::map<int, std::list<JoyStickHandler*> > activeJoyStickHandlers_;
    174170
    175     std::list<OIS::KeyCode>         keysDown_;
    176     std::list<OIS::MouseButtonID>   mouseButtonsDown_;
    177     std::map< int, std::list<int> > joySticksButtonsDown_;
     171    std::list<OIS::KeyCode>                     keysDown_;
     172    std::list<OIS::MouseButtonID>               mouseButtonsDown_;
     173    std::map< int, std::list<int> >             joyStickButtonsDown_;
    178174
    179175  };
  • code/branches/input/src/orxonox/Orxonox.cc

    r1182 r1204  
    414414  void Orxonox::startRenderLoop()
    415415  {
    416     InputBuffer* ib = dynamic_cast<InputBuffer*>(InputManager::getKeyListener("buffer"));
     416    InputBuffer* ib = dynamic_cast<InputBuffer*>(InputManager::getKeyHandler("buffer"));
    417417    console_ = new Testconsole(ib);
    418418    ib->registerListener(console_, &Testconsole::listen, true);
  • code/branches/input/src/orxonox/Orxonox.h

    r1182 r1204  
    4444
    4545#include "GraphicsEngine.h"
    46 #include "core/InputEventListener.h"
    47 
    4846
    4947namespace orxonox {
  • code/branches/input/visual_studio/vc8/core.vcproj

    r1203 r1204  
    149149                        >
    150150                        <File
    151                                 RelativePath="..\..\src\core\asdf.cc"
    152                                 >
    153                                 <FileConfiguration
    154                                         Name="Debug|Win32"
    155                                         ExcludedFromBuild="true"
    156                                         >
    157                                         <Tool
    158                                                 Name="VCCLCompilerTool"
    159                                         />
    160                                 </FileConfiguration>
    161                                 <FileConfiguration
    162                                         Name="Release|Win32"
    163                                         ExcludedFromBuild="true"
    164                                         >
    165                                         <Tool
    166                                                 Name="VCCLCompilerTool"
    167                                         />
    168                                 </FileConfiguration>
    169                         </File>
    170                         <File
    171151                                RelativePath="..\..\src\core\BaseObject.cc"
    172152                                >
     
    217197                        </File>
    218198                        <File
    219                                 RelativePath="..\..\src\core\InputEventListener.cc"
    220                                 >
    221                                 <FileConfiguration
    222                                         Name="Debug|Win32"
    223                                         ExcludedFromBuild="true"
    224                                         >
    225                                         <Tool
    226                                                 Name="VCCLCompilerTool"
    227                                         />
    228                                 </FileConfiguration>
    229                                 <FileConfiguration
    230                                         Name="Release|Win32"
    231                                         ExcludedFromBuild="true"
    232                                         >
    233                                         <Tool
    234                                                 Name="VCCLCompilerTool"
    235                                         />
    236                                 </FileConfiguration>
    237                         </File>
    238                         <File
    239199                                RelativePath="..\..\src\core\InputHandler.cc"
    240200                                >
    241                                 <FileConfiguration
    242                                         Name="Debug|Win32"
    243                                         >
    244                                         <Tool
    245                                                 Name="VCCLCompilerTool"
    246                                         />
    247                                 </FileConfiguration>
    248                                 <FileConfiguration
    249                                         Name="Release|Win32"
    250                                         >
    251                                         <Tool
    252                                                 Name="VCCLCompilerTool"
    253                                         />
    254                                 </FileConfiguration>
    255201                        </File>
    256202                        <File
     
    317263                        >
    318264                        <File
    319                                 RelativePath="..\..\src\core\asdf.h"
    320                                 >
    321                         </File>
    322                         <File
    323265                                RelativePath="..\..\src\core\BaseObject.h"
    324266                                >
     
    398340                        <File
    399341                                RelativePath="..\..\src\core\InputBuffer.h"
    400                                 >
    401                         </File>
    402                         <File
    403                                 RelativePath="..\..\src\core\InputEvent.h"
    404                                 >
    405                         </File>
    406                         <File
    407                                 RelativePath="..\..\src\core\InputEventListener.h"
    408342                                >
    409343                        </File>
  • code/branches/input/visual_studio/vc8/orxonox.vcproj

    r1203 r1204  
    434434                                >
    435435                        </File>
    436                         <File
    437                                 RelativePath="..\..\src\orxonox\Steerable.h"
    438                                 >
    439                         </File>
    440436                        <Filter
    441437                                Name="hud"
Note: See TracChangeset for help on using the changeset viewer.