Changeset 3327

code/trunk

Property svn:mergeinfo changed
/code/branches/core4 merged: 3269,3271-3275,3278,3285,3290-3294,3310

code/trunk/src/core/CMakeLists.txt

r3304	r3327
31	31	ObjectListBase.cc
32	32	OrxonoxClass.cc
	33	WindowEventListener.cc
33	34
34	35	# command

code/trunk/src/core/CorePrereqs.h

-                      r3318
+                      r3327
     class TclThreadManager;
     class Template;
     class Tickable;
+    class WindowEventListener;
     class XMLFile;
     class XMLNameListener;
 …
     class Button;
     class CalibratorCallback;
-    class ExtendedInputState;
     class HalfAxis;
     class InputBuffer;
+    class InputDevice;
+    template <class Traits>
+    class InputDeviceTemplated;
+    class InputHandler;
     class InputManager;
     class InputState;
+    class JoyStickHandler;
+    class MouseHandler;
+    class JoyStick;
+    class Mouse;
+    class Keyboard;
     class KeyBinder;
     class KeyDetector;
-    class KeyHandler;
     class ParamCommand;
     class SimpleCommand;
+    class SimpleInputState;
     // multithreading

code/trunk/src/core/OrxonoxClass.h

-                      r3325
+                      r3327
 #include "CorePrereqs.h"
 #include <set>
+#include <vector>
 namespace orxonox

code/trunk/src/core/input/Button.cc

r3280	r3327
60	60	nCommands_[2]=0;
61	61	this->configContainer_ = 0;
62		~~clear();~~
63	62	}
64	63
…	…
83	82	commands_[j] = 0;
84	83	nCommands_[j] = 0;
85		}
86		~~else~~
87		{
88		~~commands_[j] = 0;~~
89	84	}
90	85	}

code/trunk/src/core/input/Button.h

r3280	r3327
36	36	#define _Button_H__
37	37
38		#include "~~core/Core~~Prereqs.h"
	38	#include "InputPrereqs.h"
39	39
40	40	#include <string>

code/trunk/src/core/input/CMakeLists.txt

-                      r3196
+                      r3327
 ADD_SOURCE_FILES(CORE_SRC_FILES
   Button.cc
-  ExtendedInputState.cc
   HalfAxis.cc
   InputBuffer.cc
   InputCommands.cc
   InputManager.cc
+  JoyStickDeviceNumberListener.cc
+  InputState.cc
+  JoyStick.cc
+  JoyStickQuantityListener.cc
   KeyBinder.cc
+  Keyboard.cc
   KeyDetector.cc
   SimpleInputState.cc
+  Mouse.cc
+)

code/trunk/src/core/input/HalfAxis.cc

r1887	r3327
49	49	nParamCommands_ = 0;
50	50	}
51		~~else~~
52		{
53		~~nParamCommands_ = 0; nParamCommands_ = 0;~~
54		}
55	51	}
56	52

code/trunk/src/core/input/HalfAxis.h

r3196	r3327
36	36	#define _HalfAxis_H__
37	37
38		#include "~~core/Core~~Prereqs.h"
	38	#include "InputPrereqs.h"
39	39
40	40	#include "Button.h"

code/trunk/src/core/input/InputBuffer.cc

-                      r3301
+                      r3327
     void InputBuffer::processKey(const KeyEvent &evt)
+    {
         if (evt.isModifierDown(KeyboardModifier::Alt) && evt.key == KeyCode::Tab)
+    void InputBuffer::processKey(const KeyEvent& evt)
+    {
+        if (evt.isModifierDown(KeyboardModifier::Alt) && evt.getKeyCode() == KeyCode::Tab)
             return;
         for (std::list<BaseInputBufferListenerTuple*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
+        {
             if ((*it)->trueKeyFalseChar_ && ((*it)->key_ == evt.key))
+            if ((*it)->trueKeyFalseChar_ && ((*it)->key_ == evt.getKeyCode()))
                 (*it)->callFunction();
+        }
 …
         if (evt.isModifierDown(KeyboardModifier::Ctrl))
+        {
             if (evt.key == KeyCode::V)
+            if (evt.getKeyCode() == KeyCode::V)
                 this->insert(fromClipboard());
             else if (evt.key == KeyCode::C)
+            else if (evt.getKeyCode() == KeyCode::C)
                 toClipboard(this->buffer_);
             else if (evt.key == KeyCode::X)
+            else if (evt.getKeyCode() == KeyCode::X)
+            {
                 toClipboard(this->buffer_);
 …
         else if (evt.isModifierDown(KeyboardModifier::Shift))
+        {
             if (evt.key == KeyCode::Insert)
+            if (evt.getKeyCode() == KeyCode::Insert)
                 this->insert(fromClipboard());
             else if (evt.key == KeyCode::Delete)
+            else if (evt.getKeyCode() == KeyCode::Delete)
+            {
                 toClipboard(this->buffer_);
 …
+        }
         this->insert(static_cast<char>(evt.text));
+        this->insert(static_cast<char>(evt.getText()));
+    }
 …
         @param dt Delta time
     */
     void InputBuffer::updateInput(float dt)
+    void InputBuffer::keyboardUpdated(float dt)
+    {
         timeSinceKeyPressed_ += dt;
 …
+    }
     void InputBuffer::keyPressed(const KeyEvent &evt)
+    {
         lastKey_ = evt.key;
+    void InputBuffer::buttonPressed(const KeyEvent& evt)
+    {
+        lastKey_ = evt.getKeyCode();
         timeSinceKeyPressed_ = 0.0;
         timeSinceKeyRepeated_ = keyRepeatDeleay_;
 …
+    }
     void InputBuffer::keyHeld(const KeyEvent& evt)
+    {
         if (evt.key == lastKey_)
+    void InputBuffer::buttonHeld(const KeyEvent& evt)
+    {
+        if (evt.getKeyCode() == lastKey_)
+        {
             while (keysToRepeat_)

code/trunk/src/core/input/InputBuffer.h

-                      r3196
+                      r3327
 #define _InputBuffer_H__
 #include "core/CorePrereqs.h"
+#include "InputPrereqs.h"
 #include <list>
 #include <string>
 #include "core/OrxonoxClass.h"
 #include "InputInterfaces.h"
+#include "InputHandler.h"
 namespace orxonox
 …
     };
     class _CoreExport InputBuffer : public KeyHandler, public OrxonoxClass
+    class _CoreExport InputBuffer : public InputHandler, public OrxonoxClass
+    {
         public:
 …
             bool charIsAllowed(const char& input);
+            void keyPressed (const KeyEvent& evt);
+            void keyReleased(const KeyEvent& evt) { }
+            void keyHeld    (const KeyEvent& evt);
+            void processKey (const KeyEvent &e);
+            void buttonPressed(const KeyEvent& evt);
+            void buttonHeld   (const KeyEvent& evt);
+            void processKey   (const KeyEvent& evt);
+            void updateInput(float dt);
+            void updateKey(float dt) { }
+            void keyboardUpdated(float dt);
             std::string buffer_;

code/trunk/src/core/input/InputCommands.h

r2087	r3327
36	36	#define _InputCommands_H__
37	37
38		#include "~~core/Core~~Prereqs.h"
	38	#include "InputPrereqs.h"
39	39	#include "core/CommandEvaluation.h"
40	40

code/trunk/src/core/input/InputDevice.h

-                      r3276
+                      r3327
 /**
 @file
+@brief
+@brief
+    Implementation of InputDevice and InputDeviceTemplated
 */
 …
 #include <vector>
-#include <boost/foreach.hpp>
 #include <ois/OISInputManager.h>
 #include "util/Debug.h"
 #include "core/Clock.h"
-// TODO: Try to remove this
-#include "InputManager.h"
 #include "InputState.h"
 …
     /**
     @brief
+        Abstract base class for all input devices (mouse, keyboard and joy sticks).
+        It provides common virtual functions to be used by the InputManager.
     */
     class InputDevice
+    {
-        friend class InputManager;
     public:
+        InputDevice(unsigned int id) : bCalibrating_(false), id_(id) { }
+        //! Only resets the members
+        InputDevice(unsigned int id) : bCalibrating_(false), deviceID_(id) { }
         virtual ~InputDevice() { }
+        virtual std::string getClassName() = 0;
+        //! Returns the device class (derived) name as string
+        virtual std::string getClassName() const = 0;
+        //! Updates the device which should in turn distribute events
         virtual void update(const Clock& time) = 0;
+        //! Clear all button related buffers
         virtual void clearBuffers() = 0;
+        //! Start calibrating (only useful for joy sticks)
         void startCalibration()
+        {
 …
+        }
+        //! Stop calibrating and evaluate the data (only useful for joy sticks)
         void stopCalibration()
+        {
 …
+        }
+        unsigned int getDeviceID() { return this->id_; }
+        //! Returns a reference to the internal input state vector. Use with care!
+        std::vector<InputState*>& getStateListRef() { return this->inputStates_; }
+        //! Returns the ID of the device (the same as in InputDeviceEnumerator for mouse and keyboard)
+        unsigned int getDeviceID() const { return this->deviceID_; }
+        //! Tells whether the device is in calibration mode
+        bool isCalibrating() const { return bCalibrating_; }
     protected:
+        //! To be ovrridden by the subclass
         virtual void calibrationStarted() { }
+        //! To be ovrridden by the subclass
         virtual void calibrationStopped() { }
+        bool isCalibrating() { return bCalibrating_; }
+        // InputState handling
+        //! List of all input states that receive events from this device
         std::vector<InputState*> inputStates_;
     private:
+        InputDevice(const InputDevice& rhs);
+        std::vector<InputState*>& getStateListRef()
+        {
+            return this->inputStates_;
+        }
+        bool bCalibrating_;
+        const unsigned int id_;
+        InputDevice(const InputDevice& rhs); //!< Don't use!
+        bool bCalibrating_;                  //!< Whether the device is in calibration mode
+        const unsigned int deviceID_;        //!< ID of the device (the same as in InputDeviceEnumerator for mouse and keyboard)
     };
     /**
     @brief
+        Heavily templated base class for all three input devices.
+        The purpose of this class is not to provide an interface but rather
+        to reduce code redundancy. This concerns device creation and destruction
+        as well as common code for button events (press, release, hold).
+        In order to derive from this class you have to supply it with a struct
+        as template parameter that contains the necessary type traits.
     */
     template <class Traits>
 …
     public:
+        InputDeviceTemplated(unsigned int id)
+        //! Creates the OIS device
+        InputDeviceTemplated(unsigned int id, OIS::InputManager* oisInputManager)
             : InputDevice(id)
+        {
+            OIS::InputManager* system = InputManager::getInstance().getInputSystem();
+            oisDevice_ = static_cast<OISDeviceClass*>(system->createInputObject(OISDeviceValue, true));
+            , oisInputManager_(oisInputManager)
+        {
+            oisDevice_ = static_cast<OISDeviceClass*>(oisInputManager_->createInputObject(OISDeviceValue, true));
+            // Note: after the static_cast here, the casted this pointer becomes
+            //       invalid right until the subclass has been constructed!
             oisDevice_->setEventCallback(static_cast<DeviceClass*>(this));
             COUT(4) << "Instantiated a " << this->getClassName() << std::endl;
+        }
+        //! Destroys the OIS device
         virtual ~InputDeviceTemplated()
+        {
             try
+            {
                 InputManager::getInstance().getInputSystem()->destroyInputObject(oisDevice_);
+                oisInputManager_->destroyInputObject(oisDevice_);
+            }
             catch (...)
 …
+        }
+        OISDeviceClass* getOISDevice()
+        {
+            return this->oisDevice_;
+        }
+        std::string getClassName()
+        {
+            return InputDeviceNames::values[OISDeviceValue];
+        }
+        //! Captures OIS events (which then get distributed to the derived class) and creates the button held events
         void update(const Clock& time)
+        {
             oisDevice_->capture();
+            if (!this->isCalibrating())
+            {
+                // Call all the states with the held button event
+                for (unsigned int iB = 0; iB < pressedButtons_.size(); ++iB)
+                    for (unsigned int iS = 0; iS < inputStates_.size(); ++iS)
+                        inputStates_[iS]->buttonEvent<ButtonEvent::THold, Traits>(
+                            this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(pressedButtons_[iB]));
+                // Call states with device update events
+                for (unsigned int i = 0; i < inputStates_.size(); ++i)
+                    inputStates_[i]->update(time.getDeltaTime(), this->getDeviceID());
+            }
+            // Call all the states with the held button event
+            for (unsigned int iB = 0; iB < pressedButtons_.size(); ++iB)
+                for (unsigned int iS = 0; iS < inputStates_.size(); ++iS)
+                    inputStates_[iS]->buttonEvent<ButtonEvent::THold, Traits>(
+                        this->getDeviceID(), static_cast<DeviceClass*>(this)->getButtonEventArg(pressedButtons_[iB]));
+            // Call states with device update events
+            for (unsigned int i = 0; i < inputStates_.size(); ++i)
+                inputStates_[i]->update(time.getDeltaTime(), this->getDeviceID());
             static_cast<DeviceClass*>(this)->updateImpl(time);
+        }
+        //! Clears the list of pressed buttons and calls the derived class's method
         void clearBuffers()
+        {
 …
+        }
+        // Returns a pointer to the OIS device
+        OISDeviceClass* getOISDevice()   { return this->oisDevice_; }
+        // Returns the name of the derived class as string
+        std::string getClassName() const { return DeviceClass::getClassNameImpl(); }
     protected:
+        void buttonPressed(ButtonTypeParam button)
+        //! Common code for all button pressed events (updates pressed buttons list and calls the input states)
+        FORCEINLINE void buttonPressed(ButtonTypeParam button)
+        {
             // check whether the button already is in the list (can happen when focus was lost)
 …
+        }
+        void buttonReleased(ButtonTypeParam button)
+        //! Common code for all button released events (updates pressed buttons list and calls the input states)
+        FORCEINLINE void buttonReleased(ButtonTypeParam button)
+        {
             // remove the button from the pressedButtons_ list
 …
+        }
+        //! Managed pointer to the OIS device
         OISDeviceClass* oisDevice_;
     private:
+        void clearBuffersImpl() { } //!< Fallback dummy function for static polymorphism
+        void updateImpl(const Clock& time) { } //!< Fallback dummy function for static polymorphism
+        //!< Fallback dummy function for static polymorphism
+        void clearBuffersImpl() { }
+        //!< Fallback dummy function for static polymorphism
+        void updateImpl(const Clock& time) { }
         //!< Fallback dummy function for static polymorphism
         ButtonType& getButtonEventArg(ButtonType& button) { return button; }
+        std::vector<ButtonType> pressedButtons_;
+        std::vector<ButtonType> pressedButtons_; //!< List of all buttons that are currently pressed down
+        OIS::InputManager* oisInputManager_;     //!< Pointer to the OIS InputManager that can create and destroy devices
     };
+}

code/trunk/src/core/input/InputHandler.h

-                      r3276
+                      r3327
  */
-/**
-@file
-@brief
-    Declarations of various interface classes for the input management.
-*/
 #ifndef _InputHandler_H__
 #define _InputHandler_H__
 …
 namespace orxonox
+{
+    namespace ButtonEvent
+    {
+        //! Helper enum to deploy events with the help of templates
+        enum Value
+        {
+            Press,
+            Release,
+            Hold
+        };
+        //! Enables function overloading with integer values
+        template <ButtonEvent::Value Event>
+        struct EnumToType { };
+        typedef EnumToType<Press>   TPress;
+        typedef EnumToType<Release> TRelease;
+        typedef EnumToType<Hold>    THold;
+    }
+    namespace KeyboardModifier
+    {
+        //! Keyboard modifiers (shift, ctrl and alt)
+        enum Enum
+        {
+            Shift = 0x0000001,
+            Ctrl  = 0x0000010,
+            Alt   = 0x0000100
+        };
+    }
+    //! Event argument for key events
+    class _CoreExport KeyEvent
+    {
+    public:
+        KeyEvent(const OIS::KeyEvent& evt)
+            : key_(static_cast<KeyCode::ByEnum>(evt.key))
+            , text_(evt.text)
+            , modifiers_(0)
+        { }
+        bool operator==(const KeyEvent& rhs) const
+            { return rhs.key_ == key_; }
+        bool operator!=(const KeyEvent& rhs) const
+            { return rhs.key_ != key_; }
+        void setModifiers(int modifiers)
+            { modifiers_ = modifiers; }
+        bool isModifierDown(KeyboardModifier::Enum modifier) const
+            { return static_cast<KeyboardModifier::Enum>(modifier & modifiers_); }
+        KeyCode::ByEnum getKeyCode() const
+            { return key_; }
+        unsigned int getText() const { return text_; }
+    private:
+        KeyCode::ByEnum key_;
+        unsigned int text_;
+        int modifiers_;
+    };
     /**
     @brief
+        Base class for all input handlers like KeyBinder, InputBuffer, etc.
+        Derive from this class if you wish to receive input events.
+        But keep in mind that this is pointless wihtout first having an InputState.
+    @note
+        The definitions for the button events with the weird arguments are simply
+        to avoid redunant code in the input devices.
     */
     class _CoreExport InputHandler
 …
         virtual void allDevicesUpdated(float dt) { }
+        //! Use this input handler if you want to occupy a device in an input state.
         static InputHandler EMPTY;
     };

code/trunk/src/core/input/InputManager.cc

-                      r3301
+                      r3327
 @file
 @brief
+    Implementation of the InputManager that captures all the input from OIS
+    and redirects it to handlers.
+ */
+    Implementation of the InputManager and a static variable from the InputHandler.
+*/
 #include "InputManager.h"
+#include <cassert>
 #include <climits>
-#include <cassert>
 #include <ois/OISException.h>
 #include <ois/OISInputManager.h>
+#include "util/Convert.h"
+#include <boost/foreach.hpp>
 #include "util/Exception.h"
 #include "util/ScopeGuard.h"
 …
 #include "core/ConsoleCommand.h"
 #include "core/CommandLine.h"
+#include "core/Functor.h"
 #include "InputBuffer.h"
 #include "KeyDetector.h"
+#include "InputState.h"
+#include "SimpleInputState.h"
+#include "ExtendedInputState.h"
+#include "JoyStickDeviceNumberListener.h"
+// HACK (include this as last, X11 seems to define some macros...)
+#ifdef ORXONOX_PLATFORM_LINUX
+#  include <ois/linux/LinuxMouse.h>
+#endif
+#include "JoyStick.h"
+#include "JoyStickQuantityListener.h"
+#include "Mouse.h"
+#include "Keyboard.h"
 namespace orxonox
+{
-    SetConsoleCommand(InputManager, calibrate, true);
-    SetConsoleCommand(InputManager, reload, false);
-#ifdef ORXONOX_PLATFORM_LINUX
-    SetConsoleCommand(InputManager, grabMouse, true);
-    SetConsoleCommand(InputManager, ungrabMouse, true);
-#endif
     SetCommandLineSwitch(keyboard_no_grab).information("Whether not to exclusively grab the keyboard");
+    EmptyHandler InputManager::EMPTY_HANDLER;
+    // Abuse of this source file for the InputHandler
+    InputHandler InputHandler::EMPTY;
     InputManager* InputManager::singletonRef_s = 0;
+    using namespace InputDevice;
+    /**
+    @brief
+        Defines the |= operator for easier use.
+    */
+    inline InputManager::InputManagerState operator|=(InputManager::InputManagerState& lval,
+                                                      InputManager::InputManagerState rval)
+    {
+        return (lval = (InputManager::InputManagerState)(lval | rval));
+    }
+    /**
+    @brief
+        Defines the &= operator for easier use.
+    */
+    inline InputManager::InputManagerState operator&=(InputManager::InputManagerState& lval, int rval)
+    {
+        return (lval = (InputManager::InputManagerState)(lval & rval));
+    //! Defines the |= operator for easier use.
+    inline InputManager::State operator|=(InputManager::State& lval, InputManager::State rval)
+    {
+        return (lval = (InputManager::State)(lval | rval));
+    }
+    //! Defines the &= operator for easier use.
+    inline InputManager::State operator&=(InputManager::State& lval, int rval)
+    {
+        return (lval = (InputManager::State)(lval & rval));
+    }
 …
     // ##########                                        ##########
     // ############################################################
+    /**
+    @brief
+        Constructor only sets member fields to initial zero values
+        and registers the class in the class hierarchy.
+    */
+    InputManager::InputManager()
+        : inputSystem_(0)
+        , keyboard_(0)
+        , mouse_(0)
+        , joySticksSize_(0)
+        , devicesNum_(0)
+    InputManager::InputManager(size_t windowHnd)
+        : internalState_(Bad)
+        , oisInputManager_(0)
+        , devices_(2)
         , windowHnd_(0)
+        , internalState_(Uninitialised)
+        , stateEmpty_(0)
+        , emptyState_(0)
         , keyDetector_(0)
+        , calibratorCallbackBuffer_(0)
+        , keyboardModifiers_(0)
+        , calibratorCallbackHandler_(0)
+    {
         RegisterRootObject(InputManager);
 …
         singletonRef_s = this;
+        setConfigValues();
+    }
+    /**
+    @brief
+        Sets the configurable values.
+    */
+        CCOUT(4) << "Constructing..." << std::endl;
+        this->setConfigValues();
+        this->loadDevices(windowHnd);
+        // Lowest priority empty InputState
+        emptyState_ = createInputState("empty", false, false, InputStatePriority::Empty);
+        emptyState_->setHandler(&InputHandler::EMPTY);
+        activeStates_[emptyState_->getPriority()] = emptyState_;
+        // KeyDetector to evaluate a pressed key's name
+        InputState* detector = createInputState("detector", false, false, InputStatePriority::Detector);
+        // Create a callback to avoid buttonHeld events after the key has been detected
+        FunctorMember<InputManager>* bufferFunctor = createFunctor(&InputManager::clearBuffers);
+        bufferFunctor->setObject(this);
+        detector->setLeaveFunctor(bufferFunctor);
+        keyDetector_ = new KeyDetector();
+        detector->setHandler(keyDetector_);
+        // Joy stick calibration helper callback
+        InputState* calibrator = createInputState("calibrator", false, false, InputStatePriority::Calibrator);
+        calibrator->setHandler(&InputHandler::EMPTY);
+        calibratorCallbackHandler_ = new InputBuffer();
+        calibratorCallbackHandler_->registerListener(this, &InputManager::stopCalibration, '\r', true);
+        calibrator->setKeyHandler(calibratorCallbackHandler_);
+        this->updateActiveStates();
+        {
+            // calibrate console command
+            FunctorMember<InputManager>* functor = createFunctor(&InputManager::calibrate);
+            functor->setObject(this);
+            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "calibrate"), true);
+        }
+        {
+            // reload console command
+            FunctorMember<InputManager>* functor = createFunctor(&InputManager::reload);
+            functor->setObject(this);
+            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "reload"), false);
+        }
+        internalState_ = Nothing;
+        CCOUT(4) << "Construction complete." << std::endl;
+    }
     void InputManager::setConfigValues()
+    {
-        SetConfigValue(calibrationFilename_, "joystick_calibration.ini")
-            .description("Ini filename for the the joy stick calibration data.")
-            .callback(this, &InputManager::_calibrationFileCallback);
+    }
-    /**
-    @brief
-        Callback for the joy stick calibration config file. @see setConfigValues.
-    */
-    void InputManager::_calibrationFileCallback()
+    {
-        ConfigFileManager::getInstance().setFilename(ConfigFileType::JoyStickCalibration, calibrationFilename_);
+    }
 …
     @brief
         Creates the OIS::InputMananger, the keyboard, the mouse and
         the joysticks and assigns the key bindings.
+        the joys ticks. If either of the first two fail, this method throws an exception.
     @param windowHnd
         The window handle of the render window
 …
     @param windowHeight
         The height of the render window
-    @param joyStickSupport
-        Whether or not to load the joy sticks as well
     */
+    void InputManager::initialise(size_t windowHnd, int windowWidth, int windowHeight, bool joyStickSupport)
+    {
+        CCOUT(3) << "Initialising Input System..." << std::endl;
+        if (!(internalState_ & OISReady))
+        {
+            CCOUT(4) << "Initialising OIS components..." << std::endl;
+            // store handle internally so we can reload OIS
+            windowHnd_ = windowHnd;
+            OIS::ParamList paramList;
+            std::ostringstream windowHndStr;
+            // Fill parameter list
+            windowHndStr << static_cast<unsigned int>(windowHnd);
+            paramList.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
+    void InputManager::loadDevices(size_t windowHnd)
+    {
+        CCOUT(3) << "Loading input devices..." << std::endl;
+        // When loading the devices they should not already be loaded
+        assert(internalState_ & Bad);
+        assert(devices_[InputDeviceEnumerator::Mouse] == 0);
+        assert(devices_[InputDeviceEnumerator::Keyboard] == 0);
+        assert(devices_.size() == InputDeviceEnumerator::FirstJoyStick);
+        // store handle internally so we can reload OIS
+        windowHnd_ = windowHnd;
+        OIS::ParamList paramList;
+        std::ostringstream windowHndStr;
+        // Fill parameter list
+        windowHndStr << static_cast<unsigned int>(windowHnd);
+        paramList.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
 #if defined(ORXONOX_PLATFORM_WINDOWS)
             //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_NONEXCLUSIVE")));
             //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND")));
             //paramList.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));
             //paramList.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));
+        //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_NONEXCLUSIVE")));
+        //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND")));
+        //paramList.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_NONEXCLUSIVE")));
+        //paramList.insert(std::make_pair(std::string("w32_keyboard"), std::string("DISCL_FOREGROUND")));
 #elif defined(ORXONOX_PLATFORM_LINUX)
+            paramList.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
+            paramList.insert(std::make_pair(std::string("x11_mouse_grab"), "true"));
+            paramList.insert(std::make_pair(std::string("x11_mouse_hide"), "true"));
+            bool kbNoGrab;
+            CommandLine::getValue("keyboard_no_grab", &kbNoGrab);
+            if (kbNoGrab)
+                paramList.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("false")));
+        paramList.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
+        paramList.insert(std::make_pair(std::string("x11_mouse_grab"), "true"));
+        paramList.insert(std::make_pair(std::string("x11_mouse_hide"), "true"));
+        bool kbNoGrab;
+        CommandLine::getValue("keyboard_no_grab", &kbNoGrab);
+        if (kbNoGrab)
+            paramList.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("false")));
+        else
+            paramList.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("true")));
+#endif
+        try
+        {
+            oisInputManager_ = OIS::InputManager::createInputSystem(paramList);
+            // Exception-safety
+            Loki::ScopeGuard guard = Loki::MakeGuard(OIS::InputManager::destroyInputSystem, oisInputManager_);
+            CCOUT(ORX_DEBUG) << "Created OIS input manager." << std::endl;
+            if (oisInputManager_->getNumberOfDevices(OIS::OISKeyboard) > 0)
+                devices_[InputDeviceEnumerator::Keyboard] = new Keyboard(InputDeviceEnumerator::Keyboard, oisInputManager_);
             else
+                paramList.insert(std::make_pair(std::string("x11_keyboard_grab"), std::string("true")));
+#endif
+                ThrowException(InitialisationFailed, "InputManager: No keyboard found, cannot proceed!");
+            // Successful initialisation
+            guard.Dismiss();
+        }
+        catch (std::exception& ex)
+        {
+            oisInputManager_ = NULL;
+            internalState_ |= Bad;
+            ThrowException(InitialisationFailed, "Could not initialise the input system: " << ex.what());
+        }
+        // TODO: Remove the two parameters
+        this->loadMouse();
+        this->loadJoySticks();
+        // Reorder states in case some joy sticks were added/removed
+        this->updateActiveStates();
+        CCOUT(3) << "Input devices loaded." << std::endl;
+    }
+    //! Creates a new orxonox::Mouse
+    void InputManager::loadMouse()
+    {
+        if (oisInputManager_->getNumberOfDevices(OIS::OISMouse) > 0)
+        {
             try
+            {
+                inputSystem_ = OIS::InputManager::createInputSystem(paramList);
+                // Exception-safety
+                Loki::ScopeGuard guard = Loki::MakeGuard(OIS::InputManager::destroyInputSystem, inputSystem_);
+                CCOUT(ORX_DEBUG) << "Created OIS input system" << std::endl;
+                _initialiseKeyboard();
+                // Nothing below should throw anymore, dismiss the guard
+                guard.Dismiss();
+            }
+            catch (OIS::Exception& ex)
+            {
+                ThrowException(InitialisationFailed, "Could not initialise the input system: " << ex.what());
+            }
+            _initialiseMouse();
+            if (joyStickSupport)
+                _initialiseJoySticks();
+            // Do this anyway to also inform when a joystick was detached.
+            _configureJoySticks();
+            // Set mouse/joystick region
+            if (mouse_)
+                setWindowExtents(windowWidth, windowHeight);
+            // clear all buffers
+            _clearBuffers();
+            internalState_ |= OISReady;
+            CCOUT(ORX_DEBUG) << "Initialising OIS components done." << std::endl;
+                devices_[InputDeviceEnumerator::Mouse] = new Mouse(InputDeviceEnumerator::Mouse, oisInputManager_);
+            }
+            catch (const OIS::Exception& ex)
+            {
+                CCOUT(2) << "Warning: Failed to create Mouse:" << ex.eText << std::endl
+                         << "Proceeding without mouse support." << std::endl;
+            }
+        }
         else
+        {
+            CCOUT(2) << "Warning: OIS compoments already initialised, skipping" << std::endl;
+        }
+        if (!(internalState_ & InternalsReady))
+        {
+            CCOUT(4) << "Initialising InputStates components..." << std::endl;
+            // Lowest priority empty InputState
+            stateEmpty_ = createInputState<SimpleInputState>("empty", false, false, InputStatePriority::Empty);
+            stateEmpty_->setHandler(&EMPTY_HANDLER);
+            activeStates_[stateEmpty_->getPriority()] = stateEmpty_;
+            // KeyDetector to evaluate a pressed key's name
+            SimpleInputState* detector = createInputState<SimpleInputState>("detector", false, false, InputStatePriority::Detector);
+            keyDetector_ = new KeyDetector();
+            detector->setHandler(keyDetector_);
+            // Joy stick calibration helper callback
+            SimpleInputState* calibrator = createInputState<SimpleInputState>("calibrator", false, false, InputStatePriority::Calibrator);
+            calibrator->setHandler(&EMPTY_HANDLER);
+            calibratorCallbackBuffer_ = new InputBuffer();
+            calibratorCallbackBuffer_->registerListener(this, &InputManager::_completeCalibration, '\r', true);
+            calibrator->setKeyHandler(calibratorCallbackBuffer_);
+            internalState_ |= InternalsReady;
+            CCOUT(4) << "Initialising InputStates complete." << std::endl;
+        }
+        _updateActiveStates();
+        CCOUT(3) << "Initialising complete." << std::endl;
+            CCOUT(ORX_WARNING) << "Warning: No mouse found! Proceeding without mouse support." << std::endl;
+    }
+    //! Creates as many joy sticks as are available.
+    void InputManager::loadJoySticks()
+    {
+        for (int i = 0; i < oisInputManager_->getNumberOfDevices(OIS::OISJoyStick); i++)
+        {
+            try
+            {
+                devices_.push_back(new JoyStick(InputDeviceEnumerator::FirstJoyStick + i, oisInputManager_));
+            }
+            catch (std::exception ex)
+            {
+                CCOUT(2) << "Warning: Failed to create joy stick: " << ex.what() << std::endl;
+            }
+        }
+        // inform all JoyStick Device Number Listeners
+        std::vector<JoyStick*> joyStickList;
+        for (unsigned int i = InputDeviceEnumerator::FirstJoyStick; i < devices_.size(); ++i)
+            joyStickList.push_back(static_cast<JoyStick*>(devices_[i]));
+        JoyStickQuantityListener::changeJoyStickQuantity(joyStickList);
+    }
+    void InputManager::setKeyDetectorCallback(const std::string& command)
+    {
+        this->keyDetector_->setCallbackCommand(command);
+    }
+    // ############################################################
+    // #####                    Destruction                   #####
+    // ##########                                        ##########
+    // ############################################################
+    InputManager::~InputManager()
+    {
+        CCOUT(4) << "Destroying..." << std::endl;
+        // Destroy calibrator helper handler and state
+        delete keyDetector_;
+        this->destroyState("calibrator");
+        // Destroy KeyDetector and state
+        delete calibratorCallbackHandler_;
+        this->destroyState("detector");
+        // destroy the empty InputState
+        this->destroyStateInternal(this->emptyState_);
+        // destroy all user InputStates
+        while (statesByName_.size() > 0)
+            this->destroyStateInternal((*statesByName_.rbegin()).second);
+        if (!(internalState_ & Bad))
+            this->destroyDevices();
+        CCOUT(4) << "Destruction complete." << std::endl;
+        singletonRef_s = 0;
+    }
     /**
     @brief
         Creates a keyboard and sets the event handler.
     @return
         False if keyboard stays uninitialised, true otherwise.
+        Destoys all input devices (joy sticks, mouse, keyboard and OIS::InputManager)
+    @throw
+        Method does not throw
     */
+    void InputManager::_initialiseKeyboard()
+    {
+        if (keyboard_ != 0)
+        {
+            CCOUT(2) << "Warning: Keyboard already initialised, skipping." << std::endl;
+            return;
+        }
+        if (inputSystem_->getNumberOfDevices(OIS::OISKeyboard) > 0)
+        {
+            keyboard_ = (OIS::Keyboard*)inputSystem_->createInputObject(OIS::OISKeyboard, true);
+            // register our listener in OIS.
+            keyboard_->setEventCallback(this);
+            // note: OIS will not detect keys that have already been down when the keyboard was created.
+            CCOUT(ORX_DEBUG) << "Created OIS keyboard" << std::endl;
+        }
+        else
+        {
+            ThrowException(InitialisationFailed, "InputManager: No keyboard found, cannot proceed!");
+        }
+    }
+    /**
+    @brief
+        Creates a mouse and sets the event handler.
+    @return
+        False if mouse stays uninitialised, true otherwise.
+    */
+    void InputManager::_initialiseMouse()
+    {
+        if (mouse_ != 0)
+        {
+            CCOUT(2) << "Warning: Mouse already initialised, skipping." << std::endl;
+            return;
+        }
+    void InputManager::destroyDevices()
+    {
+        CCOUT(3) << "Destroying devices..." << std::endl;
+        BOOST_FOREACH(InputDevice*& device, devices_)
+        {
+            if (device == NULL)
+                continue;
+            std::string className = device->getClassName();
+            try
+            {
+                delete device;
+                device = 0;
+                CCOUT(4) << className << " destroyed." << std::endl;
+            }
+            catch (...)
+            {
+                CCOUT(1) << className << " destruction failed! Potential resource leak!" << std::endl;
+            }
+        }
+        devices_.resize(InputDeviceEnumerator::FirstJoyStick);
+        assert(oisInputManager_ != NULL);
         try
+        {
+            if (inputSystem_->getNumberOfDevices(OIS::OISMouse) > 0)
+            {
+                mouse_ = static_cast<OIS::Mouse*>(inputSystem_->createInputObject(OIS::OISMouse, true));
+                // register our listener in OIS.
+                mouse_->setEventCallback(this);
+                CCOUT(ORX_DEBUG) << "Created OIS mouse" << std::endl;
+            }
+            else
+            {
+                CCOUT(ORX_WARNING) << "Warning: No mouse found! Proceeding without mouse support." << std::endl;
+            }
+        }
+        catch (OIS::Exception ex)
+        {
+            CCOUT(ORX_WARNING) << "Warning: Failed to create an OIS mouse\n"
+                << "OIS error message: \"" << ex.eText << "\"\n Proceeding without mouse support." << std::endl;
+            mouse_ = 0;
+        }
+    }
+    /**
+    @brief
+        Creates all joy sticks and sets the event handler.
+    @return
+        False joy stick stay uninitialised, true otherwise.
+    */
+    void InputManager::_initialiseJoySticks()
+    {
+        if (joySticksSize_ > 0)
+        {
+            CCOUT(2) << "Warning: Joy sticks already initialised, skipping." << std::endl;
+            return;
+        }
+        if (inputSystem_->getNumberOfDevices(OIS::OISJoyStick) > 0)
+        {
+            for (int i = 0; i < inputSystem_->getNumberOfDevices(OIS::OISJoyStick); i++)
+            {
+                try
+                {
+                    OIS::JoyStick* stig = static_cast<OIS::JoyStick*>
+                        (inputSystem_->createInputObject(OIS::OISJoyStick, true));
+                    CCOUT(ORX_DEBUG) << "Created OIS joy stick with ID " << stig->getID() << std::endl;
+                    joySticks_.push_back(stig);
+                    // register our listener in OIS.
+                    stig->setEventCallback(this);
+                }
+                catch (OIS::Exception ex)
+                {
+                    CCOUT(ORX_WARNING) << "Warning: Failed to create OIS joy number" << i << "\n"
+                        << "OIS error message: \"" << ex.eText << "\"" << std::endl;
+                }
+            }
+        }
+    }
+    /**
+    @brief
+        Helper function that loads the config value vector of one coefficient
+    */
+    void loadCalibration(std::vector<int>& list, const std::string& sectionName, const std::string& valueName, size_t size, int defaultValue)
+    {
+        list.resize(size);
+        unsigned int configValueVectorSize = ConfigFileManager::getInstance().getVectorSize(ConfigFileType::JoyStickCalibration, sectionName, valueName);
+        if (configValueVectorSize > size)
+            configValueVectorSize = size;
+        for (unsigned int i = 0; i < configValueVectorSize; ++i)
+        {
+            list[i] = multi_cast<int>(ConfigFileManager::getInstance().getValue(
+                ConfigFileType::JoyStickCalibration, sectionName, valueName, i, multi_cast<std::string>(defaultValue), false));
+        }
+        // fill the rest with default values
+        for (unsigned int i = configValueVectorSize; i < size; ++i)
+        {
+            list[i] = defaultValue;
+        }
+    }
+    /**
+    @brief
+        Sets the size of all the different lists that are dependent on the number
+        of joy stick devices created and loads the joy stick calibration.
+    @remarks
+        No matter whether there are a mouse and/or keyboard, they will always
+        occupy 2 places in the device number dependent lists.
+    */
+    void InputManager::_configureJoySticks()
+    {
+        joySticksSize_ = joySticks_.size();
+        devicesNum_    = 2 + joySticksSize_;
+        joyStickIDs_         .resize(joySticksSize_);
+        joyStickButtonsDown_ .resize(joySticksSize_);
+        povStates_           .resize(joySticksSize_);
+        sliderStates_        .resize(joySticksSize_);
+        joyStickMinValues_   .resize(joySticksSize_);
+        joyStickMaxValues_   .resize(joySticksSize_);
+        joyStickMiddleValues_.resize(joySticksSize_);
+        joyStickCalibrations_.resize(joySticksSize_);
+        for (unsigned int iJoyStick = 0; iJoyStick < joySticksSize_; iJoyStick++)
+        {
+            // Generate some sort of execution unique id per joy stick
+            std::string id = "JoyStick_";
+            id += multi_cast<std::string>(joySticks_[iJoyStick]->getNumberOfComponents(OIS::OIS_Button))  + "_";
+            id += multi_cast<std::string>(joySticks_[iJoyStick]->getNumberOfComponents(OIS::OIS_Axis))    + "_";
+            id += multi_cast<std::string>(joySticks_[iJoyStick]->getNumberOfComponents(OIS::OIS_Slider))  + "_";
+            id += multi_cast<std::string>(joySticks_[iJoyStick]->getNumberOfComponents(OIS::OIS_POV))     + "_";
+            id += multi_cast<std::string>(joySticks_[iJoyStick]->getNumberOfComponents(OIS::OIS_Vector3)) + "_";
+            id += joySticks_[iJoyStick]->vendor();
+            for (unsigned int i = 0; i < iJoyStick; ++i)
+            {
+                if (id == joyStickIDs_[i])
+                {
+                    // Two joysticks are probably equal --> add the index as well
+                    id += "_" + multi_cast<std::string>(iJoyStick);
+                }
+            }
+            joyStickIDs_[iJoyStick] = id;
+            size_t axes = sliderAxes + (size_t)this->joySticks_[iJoyStick]->getNumberOfComponents(OIS::OIS_Axis);
+            loadCalibration(joyStickMinValues_[iJoyStick], id, "MinValue", axes, -32768);
+            loadCalibration(joyStickMaxValues_[iJoyStick], id, "MaxValue", axes,  32768);
+            loadCalibration(joyStickMiddleValues_[iJoyStick], id, "MiddleValue", axes,      0);
+        }
+        _evaluateCalibration();
+        // state management
+        activeStatesTriggered_.resize(devicesNum_);
+        // inform all states
+        for (std::map<std::string, InputState*>::const_iterator it = inputStatesByName_.begin();
+            it != inputStatesByName_.end(); ++it)
+        {
+            it->second->setNumOfJoySticks(joySticksSize_);
+        }
+        // inform all JoyStick Device Number Listeners
+        for (ObjectList<JoyStickDeviceNumberListener>::iterator it = ObjectList<JoyStickDeviceNumberListener>::begin(); it; ++it)
+            it->JoyStickDeviceNumberChanged(joySticksSize_);
+    }
+    void InputManager::_evaluateCalibration()
+    {
+        for (unsigned int iJoyStick = 0; iJoyStick < this->joySticksSize_; ++iJoyStick)
+        {
+            for (unsigned int i = 0; i < this->joyStickMinValues_[iJoyStick].size(); i++)
+            {
+                this->joyStickCalibrations_[iJoyStick].middleValue[i] = this->joyStickMiddleValues_[iJoyStick][i];
+                this->joyStickCalibrations_[iJoyStick].negativeCoeff[i] = - 1.0f / (this->joyStickMinValues_[iJoyStick][i] - this->joyStickMiddleValues_[iJoyStick][i]);
+                this->joyStickCalibrations_[iJoyStick].positiveCoeff[i] =   1.0f / (this->joyStickMaxValues_[iJoyStick][i] - this->joyStickMiddleValues_[iJoyStick][i]);
+            }
+        }
+    }
+    void InputManager::_startCalibration()
+    {
+        for (unsigned int iJoyStick = 0; iJoyStick < this->joySticksSize_; ++iJoyStick)
+        {
+            // Set initial values
+            for (unsigned int i = 0; i < this->joyStickMinValues_[iJoyStick].size(); ++i)
+                this->joyStickMinValues_[iJoyStick][i] = INT_MAX;
+            for (unsigned int i = 0; i < this->joyStickMaxValues_[iJoyStick].size(); ++i)
+                this->joyStickMaxValues_[iJoyStick][i] = INT_MIN;
+            for (unsigned int i = 0; i < this->joyStickMiddleValues_[iJoyStick].size(); ++i)
+                this->joyStickMiddleValues_[iJoyStick][i] = 0;
+        }
+        getInstance().internalState_ |= Calibrating;
+        getInstance().requestEnterState("calibrator");
+    }
+    void InputManager::_completeCalibration()
+    {
+        for (unsigned int iJoyStick = 0; iJoyStick < this->joySticksSize_; ++iJoyStick)
+        {
+            // Get the middle positions now
+            unsigned int iAxis = 0;
+            for (unsigned int i = 0; i < sliderAxes/2; ++i)
+            {
+                this->joyStickMiddleValues_[iJoyStick][iAxis++] = this->joySticks_[iJoyStick]->getJoyStickState().mSliders[i].abX;
+                this->joyStickMiddleValues_[iJoyStick][iAxis++] = this->joySticks_[iJoyStick]->getJoyStickState().mSliders[i].abY;
+            }
+            // Note: joyStickMiddleValues_[iJoyStick] was already correctly resized in _configureJoySticks()
+            assert(joySticks_[iJoyStick]->getJoyStickState().mAxes.size() == joyStickMiddleValues_[iJoyStick].size() - sliderAxes);
+            for (unsigned int i = 0; i < joyStickMiddleValues_[iJoyStick].size() - sliderAxes; ++i)
+            {
+                this->joyStickMiddleValues_[iJoyStick][iAxis++] = this->joySticks_[iJoyStick]->getJoyStickState().mAxes[i].abs;
+            }
+            for (unsigned int i = 0; i < joyStickMinValues_[iJoyStick].size(); ++i)
+            {
+                // Minimum values
+                if (joyStickMinValues_[iJoyStick][i] == INT_MAX)
+                    joyStickMinValues_[iJoyStick][i] = -32768;
+                ConfigFileManager::getInstance().setValue(ConfigFileType::JoyStickCalibration,
+                    this->joyStickIDs_[iJoyStick], "MinValue", i, multi_cast<std::string>(joyStickMinValues_[iJoyStick][i]), false);
+                // Maximum values
+                if (joyStickMaxValues_[iJoyStick][i] == INT_MIN)
+                    joyStickMaxValues_[iJoyStick][i] = 32767;
+                ConfigFileManager::getInstance().setValue(ConfigFileType::JoyStickCalibration,
+                    this->joyStickIDs_[iJoyStick], "MaxValue", i, multi_cast<std::string>(joyStickMaxValues_[iJoyStick][i]), false);
+                // Middle values
+                ConfigFileManager::getInstance().setValue(ConfigFileType::JoyStickCalibration,
+                    this->joyStickIDs_[iJoyStick], "MiddleValue", i, multi_cast<std::string>(joyStickMiddleValues_[iJoyStick][i]), false);
+            }
+        }
+        _evaluateCalibration();
+        // restore old input state
+        requestLeaveState("calibrator");
+        internalState_ &= ~Calibrating;
+    }
+    // ############################################################
+    // #####                    Destruction                   #####
+    // ##########                                        ##########
+    // ############################################################
+    /**
+    @brief
+        Destroys all the created input devices and states.
+    */
+    InputManager::~InputManager()
+    {
+        if (internalState_ != Uninitialised)
+        {
+            CCOUT(3) << "Destroying ..." << std::endl;
+            // kick all active states 'nicely'
+            for (std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin();
+                rit != activeStates_.rend(); ++rit)
+            {
+                (*rit).second->onLeave();
+            }
+            // Destroy calibrator helper handler and state
+            delete keyDetector_;
+            requestDestroyState("calibrator");
+            // Destroy KeyDetector and state
+            delete calibratorCallbackBuffer_;
+            requestDestroyState("detector");
+            // destroy the empty InputState
+            _destroyState(this->stateEmpty_);
+            // destroy all user InputStates
+            while (inputStatesByName_.size() > 0)
+                _destroyState((*inputStatesByName_.rbegin()).second);
+            // destroy the devices
+            _destroyKeyboard();
+            _destroyMouse();
+            _destroyJoySticks();
+            try
+            {
+                OIS::InputManager::destroyInputSystem(inputSystem_);
+            }
+            catch (...)
+            {
+                CCOUT(1) << "OIS::InputManager destruction failed! Potential resource leak!" << std::endl;
+            }
+        }
+        singletonRef_s = 0;
+    }
+    /**
+    @brief
+        Destroys the keyboard and sets it to 0.
+    */
+    void InputManager::_destroyKeyboard()
+    {
+        assert(inputSystem_);
+        try
+        {
+            if (keyboard_)
+                inputSystem_->destroyInputObject(keyboard_);
+            keyboard_ = 0;
+            CCOUT(4) << "Keyboard destroyed." << std::endl;
+            OIS::InputManager::destroyInputSystem(oisInputManager_);
+        }
         catch (...)
+        {
+            CCOUT(1) << "Keyboard destruction failed! Potential resource leak!" << std::endl;
+        }
+    }
+    /**
+    @brief
+        Destroys the mouse and sets it to 0.
+    */
+    void InputManager::_destroyMouse()
+    {
+        assert(inputSystem_);
+        try
+        {
+            if (mouse_)
+                inputSystem_->destroyInputObject(mouse_);
+            mouse_ = 0;
+            CCOUT(4) << "Mouse destroyed." << std::endl;
+        }
+        catch (...)
+        {
+            CCOUT(1) << "Mouse destruction failed! Potential resource leak!" << std::endl;
+        }
+    }
+    /**
+    @brief
+        Destroys all the joy sticks and resizes the lists to 0.
+    */
+    void InputManager::_destroyJoySticks()
+    {
+        if (joySticksSize_ > 0)
+        {
+            assert(inputSystem_);
+            for (unsigned int i = 0; i < joySticksSize_; i++)
+            {
+                try
+                {
+                    if (joySticks_[i] != 0)
+                        inputSystem_->destroyInputObject(joySticks_[i]);
+                }
+                catch (...)
+                {
+                    CCOUT(1) << "Joy stick destruction failed! Potential resource leak!" << std::endl;
+                }
+            }
+            joySticks_.clear();
+            // don't use _configureNumberOfJoySticks(), might mess with registered handler if
+            // downgrading from 2 to 1 joystick
+            //_configureNumberOfJoySticks();
+            joySticksSize_ = 0;
+        }
+        CCOUT(4) << "Joy sticks destroyed." << std::endl;
+    }
+    /**
+    @brief
+        Removes and destroys an InputState.
+    @return
+        True if state was removed immediately, false if postponed.
+    */
+    void InputManager::_destroyState(InputState* state)
+    {
+        assert(state && !(this->internalState_ & Ticking));
+        std::map<int, InputState*>::iterator it = this->activeStates_.find(state->getPriority());
+        if (it != this->activeStates_.end())
+        {
+            this->activeStates_.erase(it);
+            _updateActiveStates();
+        }
+        inputStatesByName_.erase(state->getName());
+        delete state;
+    }
+    void InputManager::_clearBuffers()
+    {
+        keysDown_.clear();
+        keyboardModifiers_ = 0;
+        mouseButtonsDown_.clear();
+        for (unsigned int i = 0; i < joySticksSize_; ++i)
+        {
+            joyStickButtonsDown_[i].clear();
+            for (int j = 0; j < 4; ++j)
+            {
+                sliderStates_[i].sliderStates[j].x = 0;
+                sliderStates_[i].sliderStates[j].y = 0;
+                povStates_[i][j] = 0;
+            }
+        }
+    }
+            CCOUT(1) << "OIS::InputManager destruction failed! Potential resource leak!" << std::endl;
+        }
+        oisInputManager_ = NULL;
+        internalState_ |= Bad;
+        CCOUT(3) << "Destroyed devices." << std::endl;
+    }
     // ############################################################
 …
     // ############################################################
+    /**
+    @brief
+        Public interface. Only reloads immediately if the call stack doesn't
+        include the update() method.
+    @param joyStickSupport
+        Whether or not to initialise joy sticks as well.
+    */
+    void InputManager::reloadInputSystem(bool joyStickSupport)
+    void InputManager::reload()
+    {
         if (internalState_ & Ticking)
+        {
             // We cannot destroy OIS right now, because reload was probably
             // caused by a user clicking on a GUI item. The backtrace would then
+            // caused by a user clicking on a GUI item. The stack trace would then
             // include an OIS method. So it would be a very bad thing to destroy it..
             internalState_ |= ReloadRequest;
+            // Misuse of internalState_: We can easily store the joyStickSupport bool.
+            // use Uninitialised as 0 value in order to make use of the overloaded |= operator
+            internalState_ |= joyStickSupport ? JoyStickSupport : Uninitialised;
+        }
+        else if (internalState_ & OISReady)
+        {
+            _reload(joyStickSupport);
+        }
+        }
+        else if (internalState_ & Calibrating)
+            CCOUT(2) << "Warning: Cannot reload input system. Joy sticks are currently being calibrated." << std::endl;
         else
+        {
+            CCOUT(2) << "Warning: Cannot reload OIS. May not yet be initialised or"
+                     << "joy sticks are currently calibrating." << std::endl;
+        }
+    }
+    /**
+    @brief
+        Internal reload method. Destroys the OIS devices and loads them again.
+    */
+    void InputManager::_reload(bool joyStickSupport)
+    {
+        try
+        {
+            CCOUT(3) << "Reloading ..." << std::endl;
+            // Save mouse clipping size
+            int mouseWidth  = mouse_->getMouseState().width;
+            int mouseHeight = mouse_->getMouseState().height;
+            internalState_ &= ~OISReady;
+            // destroy the devices
+            _destroyKeyboard();
+            _destroyMouse();
+            _destroyJoySticks();
+            OIS::InputManager::destroyInputSystem(inputSystem_);
+            inputSystem_ = 0;
+            // clear all buffers containing input information
+            _clearBuffers();
+            initialise(windowHnd_, mouseWidth, mouseHeight, joyStickSupport);
+            CCOUT(3) << "Reloading done." << std::endl;
+        }
+        catch (OIS::Exception& ex)
+        {
+            CCOUT(1) << "An exception has occured while reloading:\n" << ex.what() << std::endl;
+        }
+            reloadInternal();
+    }
+    //! Internal reload method. Destroys the OIS devices and loads them again.
+    void InputManager::reloadInternal()
+    {
+        CCOUT(3) << "Reloading ..." << std::endl;
+        this->destroyDevices();
+        this->loadDevices(windowHnd_);
+        internalState_ &= ~Bad;
+        internalState_ &= ~ReloadRequest;
+        CCOUT(3) << "Reloading complete." << std::endl;
+    }
 …
     // ############################################################
-    /**
-    @brief
-        Updates the states and the InputState situation.
-    @param time
-        Clock holding the current time.
-    */
     void InputManager::update(const Clock& time)
+    {
+        if (internalState_ == Uninitialised)
+            return;
+        if (internalState_ & Bad)
+            ThrowException(General, "InputManager was not correctly reloaded.");
         else if (internalState_ & ReloadRequest)
+        {
+            _reload(internalState_ & JoyStickSupport);
+            internalState_ &= ~ReloadRequest;
+            internalState_ &= ~JoyStickSupport;
+        }
+            reloadInternal();
         // check for states to leave
 …
                 it != stateLeaveRequests_.end(); ++it)
+            {
                 (*it)->onLeave();
+                (*it)->left();
                 // just to be sure that the state actually is registered
                 assert(inputStatesByName_.find((*it)->getName()) != inputStatesByName_.end());
+                assert(statesByName_.find((*it)->getName()) != statesByName_.end());
                 activeStates_.erase((*it)->getPriority());
                 if ((*it)->getPriority() < InputStatePriority::HighPriority)
                     (*it)->setPriority(0);
                 _updateActiveStates();
+                updateActiveStates();
+            }
             stateLeaveRequests_.clear();
 …
+            {
                 // just to be sure that the state actually is registered
                 assert(inputStatesByName_.find((*it)->getName()) != inputStatesByName_.end());
+                assert(statesByName_.find((*it)->getName()) != statesByName_.end());
                 if ((*it)->getPriority() == 0)
+                {
                     // Get smallest possible priority between 1 and maxStateStackSize_s
-#if defined( __MINGW32__ ) // Avoid the strange mingw-stl bug with const_reverse_iterator
                     for(std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin();
                         rit != activeStates_.rend(); ++rit)
-#else
-                    for(std::map<int, InputState*>::const_reverse_iterator rit = activeStates_.rbegin();
-                        rit != activeStates_.rend(); ++rit)
-#endif
+                    {
                         if (rit->first < InputStatePriority::HighPriority)
 …
+                }
                 activeStates_[(*it)->getPriority()] = (*it);
                 _updateActiveStates();
                 (*it)->onEnter();
+                updateActiveStates();
+                (*it)->entered();
+            }
             stateEnterRequests_.clear();
 …
                 it != stateDestroyRequests_.end(); ++it)
+            {
                 _destroyState((*it));
+                destroyStateInternal((*it));
+            }
             stateDestroyRequests_.clear();
+        }
         // check whether a state has changed its EMPTY_HANDLER situation
+        // check whether a state has changed its EMPTY situation
         bool bUpdateRequired = false;
         for (std::map<int, InputState*>::iterator it = activeStates_.begin(); it != activeStates_.end(); ++it)
+        {
             if (it->second->handlersChanged())
+            {
                 it->second->resetHandlersChanged();
+            if (it->second->hasExpired())
+            {
+                it->second->resetExpiration();
                 bUpdateRequired = true;
+            }
+        }
         if (bUpdateRequired)
             _updateActiveStates();
+            updateActiveStates();
         // mark that we now start capturing and distributing input
         internalState_ |= Ticking;
+        // Capture all the input. This calls the event handlers in InputManager.
+        if (keyboard_)
+            keyboard_->capture();
+        if (mouse_)
+            mouse_->capture();
+        for (unsigned  int i = 0; i < joySticksSize_; i++)
+            joySticks_[i]->capture();
+        if (!(internalState_ & Calibrating))
+        {
+            // call all the handlers for the held key events
+            for (unsigned int iKey = 0; iKey < keysDown_.size(); iKey++)
+            {
+                KeyEvent kEvt(keysDown_[iKey], keyboardModifiers_);
+                for (unsigned int iState = 0; iState < activeStatesTriggered_[Keyboard].size(); ++iState)
+                    activeStatesTriggered_[Keyboard][iState]->keyHeld(kEvt);
+            }
+            // call all the handlers for the held mouse button events
+            for (unsigned int iButton = 0; iButton < mouseButtonsDown_.size(); iButton++)
+            {
+                for (unsigned int iState = 0; iState < activeStatesTriggered_[Mouse].size(); ++iState)
+                    activeStatesTriggered_[Mouse][iState]->mouseButtonHeld(mouseButtonsDown_[iButton]);
+            }
+            // call all the handlers for the held joy stick button events
+            for (unsigned int iJoyStick  = 0; iJoyStick < joySticksSize_; iJoyStick++)
+                for (unsigned int iButton   = 0; iButton   < joyStickButtonsDown_[iJoyStick].size(); iButton++)
+                {
+                    for (unsigned int iState = 0; iState < activeStatesTriggered_[JoyStick0 + iJoyStick].size(); ++iState)
+                        activeStatesTriggered_[JoyStick0 + iJoyStick][iState]->joyStickButtonHeld(iJoyStick, joyStickButtonsDown_[iJoyStick][iButton]);
+                }
+            // update the handlers for each active handler
+            for (unsigned int i = 0; i < devicesNum_; ++i)
+            {
+                for (unsigned int iState = 0; iState < activeStatesTriggered_[i].size(); ++iState)
+                    activeStatesTriggered_[i][iState]->updateInput(time.getDeltaTime(), i);
+            }
+            // update the handler with a general tick afterwards
+            for (unsigned int i = 0; i < activeStatesTicked_.size(); ++i)
+                activeStatesTicked_[i]->updateInput(time.getDeltaTime());
+        }
+        // Capture all the input and handle it
+        BOOST_FOREACH(InputDevice* device, devices_)
+            if (device != NULL)
+                device->update(time);
+        // Update the states
+        for (unsigned int i = 0; i < activeStatesTicked_.size(); ++i)
+            activeStatesTicked_[i]->update(time.getDeltaTime());
         internalState_ &= ~Ticking;
 …
         Also, a list of all active states (no duplicates!) is compiled for the general update().
     */
+    void InputManager::_updateActiveStates()
+    {
+        for (unsigned int i = 0; i < devicesNum_; ++i)
+        {
+    void InputManager::updateActiveStates()
+    {
+        // temporary resize
+        for (unsigned int i = 0; i < devices_.size(); ++i)
+        {
+            if (devices_[i] == NULL)
+                continue;
+            std::vector<InputState*>& states = devices_[i]->getStateListRef();
             bool occupied = false;
+            activeStatesTriggered_[i].clear();
+#if defined( __MINGW32__ ) // Avoid the strange mingw-stl bug with const_reverse_iterator
+            states.clear();
             for (std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin(); rit != activeStates_.rend(); ++rit)
+            {
-#else
-            for (std::map<int, InputState*>::const_reverse_iterator rit = activeStates_.rbegin(); rit != activeStates_.rend(); ++rit)
+            {
-#endif
                 if (rit->second->isInputDeviceEnabled(i) && (!occupied || rit->second->bAlwaysGetsInput_))
+                {
                     activeStatesTriggered_[i].push_back(rit->second);
+                    states.push_back(rit->second);
                     if (!rit->second->bTransparent_)
                         occupied = true;
 …
         // Using a std::set to avoid duplicates
         std::set<InputState*> tempSet;
+        for (unsigned int i = 0; i < devicesNum_; ++i)
+            for (unsigned int iState = 0; iState < activeStatesTriggered_[i].size(); ++iState)
+                tempSet.insert(activeStatesTriggered_[i][iState]);
+        for (unsigned int i = 0; i < devices_.size(); ++i)
+            if (devices_[i] != NULL)
+                for (unsigned int iState = 0; iState < devices_[i]->getStateListRef().size(); ++iState)
+                    tempSet.insert(devices_[i]->getStateListRef()[iState]);
         // copy the content of the std::set back to the actual vector
 …
         for (std::set<InputState*>::const_iterator it = tempSet.begin();it != tempSet.end(); ++it)
             activeStatesTicked_.push_back(*it);
+        this->mouseButtonsDown_.clear();
+    }
+    /**
+    @brief
+        Clears all buffers that store what keys/buttons are being pressed at the moment.
+    */
+    }
     void InputManager::clearBuffers()
+    {
+        this->keysDown_.clear();
+        this->mouseButtonsDown_.clear();
+        for (unsigned int i = 0; i < this->joySticksSize_; ++i)
+            this->joyStickButtonsDown_[i].clear();
+    }
+    // ############################################################
+    // #####                    OIS events                    #####
+        BOOST_FOREACH(InputDevice* device, devices_)
+            if (device != NULL)
+                device->clearBuffers();
+    }
+    void InputManager::calibrate()
+    {
+        COUT(0) << "Move all joy stick axes fully in all directions." << std::endl
+                << "When done, put the axex in the middle position and press enter." << std::endl;
+        BOOST_FOREACH(InputDevice* device, devices_)
+            if (device != NULL)
+                device->startCalibration();
+        internalState_ |= Calibrating;
+        enterState("calibrator");
+    }
+    //! Tells all devices to stop the calibration and evaluate it. Buffers are being cleared as well!
+    void InputManager::stopCalibration()
+    {
+        BOOST_FOREACH(InputDevice* device, devices_)
+            if (device != NULL)
+                device->stopCalibration();
+        // restore old input state
+        leaveState("calibrator");
+        internalState_ &= ~Calibrating;
+        // Clear buffers to prevent button hold events
+        this->clearBuffers();
+        COUT(0) << "Calibration has been stored." << std::endl;
+    }
+    //! Gets called by WindowEventListener upon focus change --> clear buffers
+    void InputManager::windowFocusChanged()
+    {
+        this->clearBuffers();
+    }
+    // ############################################################
+    // #####                    Iput States                   #####
     // ##########                                        ##########
     // ############################################################
+    // ###### Key Events ######
+    /**
+    @brief
+        Event handler for the keyPressed Event.
+    @param e
+        Event information
+    */
+    bool InputManager::keyPressed(const OIS::KeyEvent &e)
+    {
+        // check whether the key already is in the list (can happen when focus was lost)
+        unsigned int iKey = 0;
+        while (iKey < keysDown_.size() && keysDown_[iKey].key != (KeyCode::ByEnum)e.key)
+            iKey++;
+        if (iKey == keysDown_.size())
+            keysDown_.push_back(Key(e));
+        else
+        {
+            // This happens when XAutoRepeat is set under linux. The KeyPressed event gets then sent
+            // continuously.
+            return true;
+        }
+        // update modifiers
+        if(e.key == OIS::KC_RMENU    || e.key == OIS::KC_LMENU)
+            keyboardModifiers_ |= KeyboardModifier::Alt;   // alt key
+        if(e.key == OIS::KC_RCONTROL || e.key == OIS::KC_LCONTROL)
+            keyboardModifiers_ |= KeyboardModifier::Ctrl;  // ctrl key
+        if(e.key == OIS::KC_RSHIFT   || e.key == OIS::KC_LSHIFT)
+            keyboardModifiers_ |= KeyboardModifier::Shift; // shift key
+        KeyEvent kEvt(e, keyboardModifiers_);
+        for (unsigned int iState = 0; iState < activeStatesTriggered_[Keyboard].size(); ++iState)
+            activeStatesTriggered_[Keyboard][iState]->keyPressed(kEvt);
+        return true;
+    }
+    /**
+    @brief
+        Event handler for the keyReleased Event.
+    @param e
+        Event information
+    */
+    bool InputManager::keyReleased(const OIS::KeyEvent &e)
+    {
+        // remove the key from the keysDown_ list
+        for (unsigned int iKey = 0; iKey < keysDown_.size(); iKey++)
+        {
+            if (keysDown_[iKey].key == (KeyCode::ByEnum)e.key)
+            {
+                keysDown_.erase(keysDown_.begin() + iKey);
+                break;
+            }
+        }
+        // update modifiers
+        if(e.key == OIS::KC_RMENU    || e.key == OIS::KC_LMENU)
+            keyboardModifiers_ &= ~KeyboardModifier::Alt;   // alt key
+        if(e.key == OIS::KC_RCONTROL || e.key == OIS::KC_LCONTROL)
+            keyboardModifiers_ &= ~KeyboardModifier::Ctrl;  // ctrl key
+        if(e.key == OIS::KC_RSHIFT   || e.key == OIS::KC_LSHIFT)
+            keyboardModifiers_ &= ~KeyboardModifier::Shift; // shift key
+        KeyEvent kEvt(e, keyboardModifiers_);
+        for (unsigned int iState = 0; iState < activeStatesTriggered_[Keyboard].size(); ++iState)
+            activeStatesTriggered_[Keyboard][iState]->keyReleased(kEvt);
+        return true;
+    }
+    // ###### Mouse Events ######
+    /**
+    @brief
+        Event handler for the mouseMoved Event.
+    @param e
+        Event information
+    */
+    bool InputManager::mouseMoved(const OIS::MouseEvent &e)
+    {
+        // check for actual moved event
+        if (e.state.X.rel != 0 || e.state.Y.rel != 0)
+        {
+            IntVector2 abs(e.state.X.abs, e.state.Y.abs);
+            IntVector2 rel(e.state.X.rel, e.state.Y.rel);
+            IntVector2 clippingSize(e.state.width, e.state.height);
+            for (unsigned int iState = 0; iState < activeStatesTriggered_[Mouse].size(); ++iState)
+                activeStatesTriggered_[Mouse][iState]->mouseMoved(abs, rel, clippingSize);
+        }
+        // check for mouse scrolled event
+        if (e.state.Z.rel != 0)
+        {
+            for (unsigned int iState = 0; iState < activeStatesTriggered_[Mouse].size(); ++iState)
+                activeStatesTriggered_[Mouse][iState]->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
+        }
+        return true;
+    }
+    /**
+    @brief
+        Event handler for the mousePressed Event.
+    @param e
+        Event information
+    @param id
+        The ID of the mouse button
+    */
+    bool InputManager::mousePressed(const OIS::MouseEvent &e, OIS::MouseButtonID id)
+    {
+        // check whether the button already is in the list (can happen when focus was lost)
+        unsigned int iButton = 0;
+        while (iButton < mouseButtonsDown_.size() && mouseButtonsDown_[iButton] != (MouseButtonCode::ByEnum)id)
+            iButton++;
+        if (iButton == mouseButtonsDown_.size())
+            mouseButtonsDown_.push_back((MouseButtonCode::ByEnum)id);
+        for (unsigned int iState = 0; iState < activeStatesTriggered_[Mouse].size(); ++iState)
+            activeStatesTriggered_[Mouse][iState]->mouseButtonPressed((MouseButtonCode::ByEnum)id);
+        return true;
+    }
+    /**
+    @brief
+        Event handler for the mouseReleased Event.
+    @param e
+        Event information
+    @param id
+        The ID of the mouse button
+    */
+    bool InputManager::mouseReleased(const OIS::MouseEvent &e, OIS::MouseButtonID id)
+    {
+        // remove the button from the keysDown_ list
+        for (unsigned int iButton = 0; iButton < mouseButtonsDown_.size(); iButton++)
+        {
+            if (mouseButtonsDown_[iButton] == (MouseButtonCode::ByEnum)id)
+            {
+                mouseButtonsDown_.erase(mouseButtonsDown_.begin() + iButton);
+                break;
+            }
+        }
+        for (unsigned int iState = 0; iState < activeStatesTriggered_[Mouse].size(); ++iState)
+            activeStatesTriggered_[Mouse][iState]->mouseButtonReleased((MouseButtonCode::ByEnum)id);
+        return true;
+    }
+    // ###### Joy Stick Events ######
+    /**
+    @brief
+        Returns the joy stick ID (orxonox) according to a OIS::JoyStickEvent
+    */
+    inline unsigned int InputManager::_getJoystick(const OIS::JoyStickEvent& arg)
+    {
+        // use the device to identify which one called the method
+        OIS::JoyStick* joyStick = (OIS::JoyStick*)arg.device;
+        unsigned int iJoyStick = 0;
+        while (joySticks_[iJoyStick] != joyStick)
+            iJoyStick++;
+        // assert: Unknown joystick fired an event.
+        assert(iJoyStick != joySticksSize_);
+        return iJoyStick;
+    }
+    bool InputManager::buttonPressed(const OIS::JoyStickEvent &arg, int button)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        // check whether the button already is in the list (can happen when focus was lost)
+        std::vector<JoyStickButtonCode::ByEnum>& buttonsDown = joyStickButtonsDown_[iJoyStick];
+        unsigned int iButton = 0;
+        while (iButton < buttonsDown.size() && buttonsDown[iButton] != button)
+            iButton++;
+        if (iButton == buttonsDown.size())
+            buttonsDown.push_back((JoyStickButtonCode::ByEnum)button);
+        for (unsigned int iState = 0; iState < activeStatesTriggered_[2 + iJoyStick].size(); ++iState)
+            activeStatesTriggered_[2 + iJoyStick][iState]->joyStickButtonPressed(iJoyStick, (JoyStickButtonCode::ByEnum)button);
+        return true;
+    }
+    bool InputManager::buttonReleased(const OIS::JoyStickEvent &arg, int button)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        // remove the button from the joyStickButtonsDown_ list
+        std::vector<JoyStickButtonCode::ByEnum>& buttonsDown = joyStickButtonsDown_[iJoyStick];
+        for (unsigned int iButton = 0; iButton < buttonsDown.size(); iButton++)
+        {
+            if (buttonsDown[iButton] == button)
+            {
+                buttonsDown.erase(buttonsDown.begin() + iButton);
+                break;
+            }
+        }
+        for (unsigned int iState = 0; iState < activeStatesTriggered_[2 + iJoyStick].size(); ++iState)
+            activeStatesTriggered_[2 + iJoyStick][iState]->joyStickButtonReleased(iJoyStick, (JoyStickButtonCode::ByEnum)button);
+        return true;
+    }
+    /**
+    @brief
+        Calls the states for a particular axis with our enumeration.
+        Used by OIS sliders and OIS axes.
+    */
+    void InputManager::_fireAxis(unsigned int iJoyStick, int axis, int value)
+    {
+        if (internalState_ & Calibrating)
+        {
+            if (value < joyStickMinValues_[iJoyStick][axis])
+                joyStickMinValues_[iJoyStick][axis] = value;
+            if (value > joyStickMaxValues_[iJoyStick][axis])
+                joyStickMaxValues_[iJoyStick][axis] = value;
+        }
+        else
+        {
+            float fValue = static_cast<float>(value - joyStickCalibrations_[iJoyStick].middleValue[axis]);
+            if (fValue > 0.0f)
+                fValue *= joyStickCalibrations_[iJoyStick].positiveCoeff[axis];
+            else
+                fValue *= joyStickCalibrations_[iJoyStick].negativeCoeff[axis];
+            for (unsigned int iState = 0; iState < activeStatesTriggered_[2 + iJoyStick].size(); ++iState)
+                activeStatesTriggered_[2 + iJoyStick][iState]->joyStickAxisMoved(iJoyStick, axis, fValue);
+        }
+    }
+    bool InputManager::axisMoved(const OIS::JoyStickEvent &arg, int axis)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        // keep in mind that the first 8 axes are reserved for the sliders
+        _fireAxis(iJoyStick, axis + sliderAxes, arg.state.mAxes[axis].abs);
+        return true;
+    }
+    bool InputManager::sliderMoved(const OIS::JoyStickEvent &arg, int id)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        if (sliderStates_[iJoyStick].sliderStates[id].x != arg.state.mSliders[id].abX)
+            _fireAxis(iJoyStick, id * 2, arg.state.mSliders[id].abX);
+        else if (sliderStates_[iJoyStick].sliderStates[id].y != arg.state.mSliders[id].abY)
+            _fireAxis(iJoyStick, id * 2 + 1, arg.state.mSliders[id].abY);
+        return true;
+    }
+    bool InputManager::povMoved(const OIS::JoyStickEvent &arg, int id)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        // translate the POV into 8 simple buttons
+        int lastState = povStates_[iJoyStick][id];
+        if (lastState & OIS::Pov::North)
+            buttonReleased(arg, 32 + id * 4 + 0);
+        if (lastState & OIS::Pov::South)
+            buttonReleased(arg, 32 + id * 4 + 1);
+        if (lastState & OIS::Pov::East)
+            buttonReleased(arg, 32 + id * 4 + 2);
+        if (lastState & OIS::Pov::West)
+            buttonReleased(arg, 32 + id * 4 + 3);
+        povStates_[iJoyStick].povStates[id] = arg.state.mPOV[id].direction;
+        int currentState = povStates_[iJoyStick][id];
+        if (currentState & OIS::Pov::North)
+            buttonPressed(arg, 32 + id * 4 + 0);
+        if (currentState & OIS::Pov::South)
+            buttonPressed(arg, 32 + id * 4 + 1);
+        if (currentState & OIS::Pov::East)
+            buttonPressed(arg, 32 + id * 4 + 2);
+        if (currentState & OIS::Pov::West)
+            buttonPressed(arg, 32 + id * 4 + 3);
+        return true;
+    }
+    // ############################################################
+    // #####         Other Public Interface Methods           #####
+    // ##########                                        ##########
+    // ############################################################
+    /**
+    @brief
+        Adjusts the mouse window metrics.
+        This method has to be called every time the size of the window changes.
+    @param width
+        The new width of the render window
+    @param^height
+        The new height of the render window
+    */
+    void InputManager::setWindowExtents(const int width, const int height)
+    {
+        if (mouse_)
+        {
+            // Set mouse region (if window resizes, we should alter this to reflect as well)
+            mouse_->getMouseState().width  = width;
+            mouse_->getMouseState().height = height;
+        }
+    }
+    /**
+    @brief
+        Sets the the name of the command used by the KeyDetector as callback.
+    @param command
+        Command name as string
+    */
+    void InputManager::setKeyDetectorCallback(const std::string& command)
+    {
+        this->keyDetector_->setCallbackCommand(command);
+    }
+    // ###### InputStates ######
+    /**
+    @brief
+        Adds a new key handler.
+    @param handler
+        Pointer to the handler object.
+    @param name
+        Unique name of the handler.
+    @param priority
+        Determines which InputState gets the input. Higher is better.
+        Use 0 to handle it implicitely by the order of activation.
+        Otherwise numbers larger than maxStateStackSize_s have to be used!
+    @return
+        True if added, false if name or priority already existed.
+    */
+    bool InputManager::_configureInputState(InputState* state, const std::string& name, bool bAlwaysGetsInput, bool bTransparent, int priority)
+    InputState* InputManager::createInputState(const std::string& name, bool bAlwaysGetsInput, bool bTransparent, InputStatePriority priority)
+    {
         if (name == "")
+            return false;
+        if (!state)
+            return false;
+        if (inputStatesByName_.find(name) == inputStatesByName_.end())
+            return 0;
+        if (statesByName_.find(name) == statesByName_.end())
+        {
             if (priority >= InputStatePriority::HighPriority || priority == InputStatePriority::Empty)
+            {
                 // Make sure we don't add two high priority states with the same priority
                 for (std::map<std::string, InputState*>::const_iterator it = this->inputStatesByName_.begin();
                     it != this->inputStatesByName_.end(); ++it)
+                for (std::map<std::string, InputState*>::const_iterator it = this->statesByName_.begin();
+                    it != this->statesByName_.end(); ++it)
+                {
                     if (it->second->getPriority() == priority)
+                    {
                         COUT(2) << "Warning: Could not add an InputState with the same priority '"
                             << priority << "' != 0." << std::endl;
                         return false;
+                            << static_cast<int>(priority) << "' != 0." << std::endl;
+                        return 0;
+                    }
+                }
+            }
+            inputStatesByName_[name] = state;
+            state->setNumOfJoySticks(numberOfJoySticks());
+            state->setName(name);
+            state->bAlwaysGetsInput_ = bAlwaysGetsInput;
+            state->bTransparent_ = bTransparent;
+            if (priority >= InputStatePriority::HighPriority || priority == InputStatePriority::Empty)
+                state->setPriority(priority);
+            return true;
+            InputState* state = new InputState(name, bAlwaysGetsInput, bTransparent, priority);
+            statesByName_[name] = state;
+            return state;
+        }
         else
+        {
             COUT(2) << "Warning: Could not add an InputState with the same name '" << name << "'." << std::endl;
+            return false;
+        }
+    }
+    /**
+    @brief
+        Removes and destroys an input state internally.
+    @param name
+        Name of the handler.
+    @return
+        True if removal was successful, false if name was not found.
+    @remarks
+        You can't remove the internal states "empty", "calibrator" and "detector".
+        The removal process is being postponed if InputManager::update() is currently running.
+    */
+    bool InputManager::requestDestroyState(const std::string& name)
+    {
+        if (name == "empty")
+        {
+            COUT(2) << "InputManager: Removing the empty state is not allowed!" << std::endl;
+            return false;
+        }
+        std::map<std::string, InputState*>::iterator it = inputStatesByName_.find(name);
+        if (it != inputStatesByName_.end())
+        {
+            if (activeStates_.find(it->second->getPriority()) != activeStates_.end())
+            {
+                // The state is still active. We have to postpone
+                stateLeaveRequests_.insert(it->second);
+                stateDestroyRequests_.insert(it->second);
+            }
+            else if (this->internalState_ & Ticking)
+            {
+                // cannot remove state while ticking
+                stateDestroyRequests_.insert(it->second);
+            }
+            else
+                _destroyState(it->second);
+            return true;
+        }
+        return false;
+    }
+    /**
+    @brief
+        Returns the pointer to the requested InputState.
+    @param name
+        Unique name of the state.
+    @return
+        Pointer to the instance, 0 if name was not found.
+    */
+            return 0;
+        }
+    }
     InputState* InputManager::getState(const std::string& name)
+    {
         std::map<std::string, InputState*>::iterator it = inputStatesByName_.find(name);
         if (it != inputStatesByName_.end())
+        std::map<std::string, InputState*>::iterator it = statesByName_.find(name);
+        if (it != statesByName_.end())
             return it->second;
         else
 …
+    }
+    /**
+    @brief
+        Returns the current input state (there might be others active too!)
+    @return
+        The current highest prioritised active input state.
+    */
+    InputState* InputManager::getCurrentState()
+    {
+        return (*activeStates_.rbegin()).second;
+    }
+    /**
+    @brief
+        Activates a specific input state.
+        It might not be really activated if the priority is too low!
+    @param name
+        Unique name of the state.
+    @return
+        False if name was not found, true otherwise.
+    */
+    bool InputManager::requestEnterState(const std::string& name)
+    bool InputManager::enterState(const std::string& name)
+    {
         // get pointer from the map with all stored handlers
         std::map<std::string, InputState*>::const_iterator it = inputStatesByName_.find(name);
         if (it != inputStatesByName_.end())
+        std::map<std::string, InputState*>::const_iterator it = statesByName_.find(name);
+        if (it != statesByName_.end())
+        {
             // exists
 …
+    }
+    /**
+    @brief
+        Deactivates a specific input state.
+    @param name
+        Unique name of the state.
+    @return
+        False if name was not found, true otherwise.
+    */
+    bool InputManager::requestLeaveState(const std::string& name)
+    bool InputManager::leaveState(const std::string& name)
+    {
         if (name == "empty")
 …
+        }
         // get pointer from the map with all stored handlers
         std::map<std::string, InputState*>::const_iterator it = inputStatesByName_.find(name);
         if (it != inputStatesByName_.end())
+        std::map<std::string, InputState*>::const_iterator it = statesByName_.find(name);
+        if (it != statesByName_.end())
+        {
             // exists
 …
+    }
+    // ############################################################
+    // #####                Console Commands                  #####
+    // ##########                                        ##########
+    // ############################################################
+    /**
+    @brief
+        Starts joy stick calibration.
+    */
+    void InputManager::calibrate()
+    {
+        COUT(0) << "Move all joy stick axes fully in all directions." << std::endl
+                << "When done, put the axex in the middle position and press enter." << std::endl;
+        getInstance()._startCalibration();
+    }
+    /**
+    @brief
+        Reloads the input system
+    */
+    void InputManager::reload(bool joyStickSupport)
+    {
+        getInstance().reloadInputSystem(joyStickSupport);
+    }
+    // ############################################################
+    // #####                   ugly hacks                     #####
+    // ##########                                        ##########
+    // ############################################################
+#ifdef ORXONOX_PLATFORM_LINUX
+    void InputManager::grabMouse()
+    {
+        OIS::LinuxMouse* linuxMouse = dynamic_cast<OIS::LinuxMouse*>(singletonRef_s->mouse_);
+        assert(linuxMouse);
+        linuxMouse->grab(true);
+    }
+    void InputManager::ungrabMouse()
+    {
+        OIS::LinuxMouse* linuxMouse = dynamic_cast<OIS::LinuxMouse*>(singletonRef_s->mouse_);
+        assert(linuxMouse);
+        linuxMouse->grab(false);
+    }
+#endif
+    bool InputManager::destroyState(const std::string& name)
+    {
+        if (name == "empty")
+        {
+            COUT(2) << "InputManager: Removing the empty state is not allowed!" << std::endl;
+            return false;
+        }
+        std::map<std::string, InputState*>::iterator it = statesByName_.find(name);
+        if (it != statesByName_.end())
+        {
+            if (activeStates_.find(it->second->getPriority()) != activeStates_.end())
+            {
+                // The state is still active. We have to postpone
+                stateLeaveRequests_.insert(it->second);
+                stateDestroyRequests_.insert(it->second);
+            }
+            else if (this->internalState_ & Ticking)
+            {
+                // cannot remove state while ticking
+                stateDestroyRequests_.insert(it->second);
+            }
+            else
+                destroyStateInternal(it->second);
+            return true;
+        }
+        return false;
+    }
+    //! Destroys an InputState internally.
+    void InputManager::destroyStateInternal(InputState* state)
+    {
+        assert(state && !(this->internalState_ & Ticking));
+        std::map<int, InputState*>::iterator it = this->activeStates_.find(state->getPriority());
+        if (it != this->activeStates_.end())
+        {
+            this->activeStates_.erase(it);
+            updateActiveStates();
+        }
+        statesByName_.erase(state->getName());
+        delete state;
+    }
+}

code/trunk/src/core/input/InputManager.h

-                      r3196
+                      r3327
  */
-/**
-@file
-@brief
-    Implementation of a little Input handler that distributes everything
-    coming from OIS.
-*/
 #ifndef _InputManager_H__
 #define _InputManager_H__
 #include "core/CorePrereqs.h"
+#include "InputPrereqs.h"
 #include <map>
 …
 #include <string>
 #include <vector>
+#include <ois/OISKeyboard.h>
+#include <ois/OISMouse.h>
+#include <ois/OISJoyStick.h>
+#include "util/Math.h"
+#include "util/OrxEnum.h"
+#include "core/OrxonoxClass.h"
+#include "InputInterfaces.h"
+#include "core/WindowEventListener.h"
+#include "InputState.h"
 namespace orxonox
 …
     /**
     @brief
+        Helper class to realise a vector<int[4]>
+        Manages the input devices (mouse, keyboard, joy sticks) and the input states.
+        Every input device has its own wrapper class which does the actualy input event
+        distribution. The InputManager only creates reloads (on request) those devices.
+        The other functionality concerns handling InputStates. They act as a layer
+        between InputHandlers (like the KeyBinder or the GUIManager) and InputDevices.
+        InputStates are memory managed by the IputManager. You cannot create or destroy
+        them on your own. Therefore all states get destroyed with the InputManager d'tor.
+    @note
+        - The actual lists containing all the InputStates for a specific device are stored
+          in the InputDevices themselves.
+        - The devices_ vector always has at least two elements: Keyboard (first) and mouse.
+          You best access them intenally with InputDeviceEnumerator::Keyboard/Mouse
+          The first joy stick is accessed with InputDeviceEnumerator::FirstJoyStick.
+        - Keyboard construction is mandatory , mouse and joy sticks are not.
+          If the OIS::InputManager or the Keyboard fail, an exception is thrown.
     */
     class POVStates
+    class _CoreExport InputManager : public WindowEventListener
+    {
     public:
+        int& operator[](unsigned int index) { return povStates[index]; }
+        int povStates[4];
+    };
+    /**
+    @brief
+        Helper class to realise a vector< {int[4], int[4]} >
+    */
+    class SliderStates
+    {
+    public:
+        IntVector2 sliderStates[4];
+    };
+    struct JoyStickCalibration
+    {
+        int middleValue[24];
+        float positiveCoeff[24];
+        float negativeCoeff[24];
+    };
+    struct InputStatePriority : OrxEnum<InputStatePriority>
+    {
+        OrxEnumConstructors(InputStatePriority);
+        static const int Empty        = -1;
+        static const int Dynamic      = 0;
+        static const int HighPriority = 1000;
+        static const int Console      = HighPriority + 0;
+        static const int Calibrator   = HighPriority + 1;
+        static const int Detector     = HighPriority + 2;
+    };
+    /**
+    @brief
+        Captures and distributes mouse and keyboard input.
+    */
+    class _CoreExport InputManager
+        : public OrxonoxClass,
+        public OIS::KeyListener, public OIS::MouseListener, public OIS::JoyStickListener
+    {
+        // --> setConfigValues is private
+        friend class ClassIdentifier<InputManager>;
+    public:
+        enum InputManagerState
+        //! Represents internal states of the InputManager.
+        enum State
+        {
+            Uninitialised    = 0x00,
+            OISReady         = 0x01,
+            InternalsReady   = 0x02,
+            Ticking          = 0x04,
+            Calibrating      = 0x08,
+            ReloadRequest    = 0x10,
+            JoyStickSupport  = 0x20 // used with ReloadRequest to store a bool
+            Nothing       = 0x00,
+            Bad           = 0x02,
+            Ticking       = 0x04,
+            Calibrating   = 0x08,
+            ReloadRequest = 0x10,
         };
+        InputManager ();
+        /**
+        @brief
+            Loads the devices and initialises the KeyDetector and the Calibrator.
+            If either the OIS input system and/or the keyboard could not be created,
+            the constructor fails with an std::exception.
+        */
+        InputManager(size_t windowHnd);
+        //! Destroys all devices AND all input states!
         ~InputManager();
+        void initialise(size_t windowHnd, int windowWidth, int windowHeight, bool joyStickSupport = true);
+        void reloadInputSystem(bool joyStickSupport = true);
+        void setConfigValues();
+        /**
+        @brief
+            Updates the devices (which distribute the input events) and the input states.
+            Any InpuStates changes (destroy, enter, leave) and happens here. If a reload request
+            was submitted while updating, the request wil be postponed until the next update call.
+        */
+        void update(const Clock& time);
+        //! Clears all input device buffers. This usually only includes the pressed button list.
         void clearBuffers();
+        unsigned int  numberOfKeyboards() { return keyboard_ ? 1 : 0; }
+        unsigned int  numberOfMice()      { return mouse_    ? 1 : 0; }
+        unsigned int  numberOfJoySticks() { return joySticksSize_; }
+        void setWindowExtents(const int width, const int height);
+        //! Starts joy stick calibration.
+        void calibrate();
+        /**
+        @brief
+            Reloads all the input devices. Use this method to initialise new joy sticks.
+        @note
+            Only reloads immediately if the call stack doesn't include the update() method.
+        */
+        void reload();
+        //-------------------------------
+        // Input States
+        //-------------------------------
+        /**
+        @brief
+            Creates a new InputState that gets managed by the InputManager.
+        @remarks
+            The InputManager will take care of the state completely. That also
+            means it gets deleted when the InputManager is destroyed!
+        @param name
+            Unique name of the InputState when referenced as string
+        @param priority
+            Priority matters when multiple states are active. You can specify any
+            number, but 1 - 99 is preferred (99 means high priority).
+        */
+        InputState* createInputState(const std::string& name, bool bAlwaysGetsInput = false, bool bTransparent = false, InputStatePriority priority = InputStatePriority::Dynamic);
+        /**
+        @brief
+            Returns a pointer to a InputState referenced by name.
+        @return
+            Returns NULL if state was not found.
+        */
+        InputState* getState(const std::string& name);
+        /**
+        @brief
+            Activates a specific input state.
+            It might not be actually activated if the priority is too low!
+        @return
+            False if name was not found, true otherwise.
+        */
+        bool enterState(const std::string& name);
+        /**
+        @brief
+            Deactivates a specific input state.
+        @return
+            False if name was not found, true otherwise.
+        */
+        bool leaveState(const std::string& name);
+        /**
+        @brief
+            Removes and destroys an input state.
+        @return
+            True if removal was successful, false if name was not found.
+        @remarks
+            - You can't remove the internal states "empty", "calibrator" and "detector".
+            - The removal process is being postponed if InputManager::update() is currently running.
+        */
+        bool destroyState(const std::string& name);
+        //-------------------------------
+        // Various getters and setters
+        //-------------------------------
+        //! Sets the the name of the command used by the KeyDetector as callback.
         void setKeyDetectorCallback(const std::string& command);
+        template <class T>
+        T* createInputState(const std::string& name, bool bAlwaysGetsInput = false, bool bTransparent = false, InputStatePriority priority = InputStatePriority::Dynamic);
+        InputState* getState       (const std::string& name);
+        InputState* getCurrentState();
+        bool requestDestroyState   (const std::string& name);
+        bool requestEnterState     (const std::string& name);
+        bool requestLeaveState     (const std::string& name);
+#ifdef ORXONOX_PLATFORM_LINUX
+        // HACK!
+        static void grabMouse();
+        static void ungrabMouse();
+#endif
+        void update(const Clock& time);
+        static InputManager& getInstance()    { assert(singletonRef_s); return *singletonRef_s; }
+        static InputManager* getInstancePtr() { return singletonRef_s; }
+        // console commands
+        static void calibrate();
+        static void reload(bool joyStickSupport = true);
+    public: // variables
+        static EmptyHandler                 EMPTY_HANDLER;
+        static const unsigned int           sliderAxes = 8;
+        //! Returns the number of joy stick that have been created since the c'tor or last call to reload().
+        unsigned int getJoyStickQuantity() const
+            { return devices_.size() - InputDeviceEnumerator::FirstJoyStick; }
+        //! Returns a pointer to the OIS InputManager. Only you if you know what you're doing!
+        OIS::InputManager* getOISInputManager()
+            { return this->oisInputManager_; }
+        //! Returns a reference to the singleton instance
+        static InputManager& getInstance() { assert(singletonRef_s); return *singletonRef_s; }
     private: // functions
         // don't mess with a Singleton
         InputManager (const InputManager&);
+        InputManager(const InputManager&);
         // Intenal methods
+        void _initialiseKeyboard();
+        void _initialiseMouse();
+        void _initialiseJoySticks();
+        void _configureJoySticks();
+        void _loadCalibration();
+        void _startCalibration();
+        void _completeCalibration();
+        void _evaluateCalibration();
+        void _destroyKeyboard();
+        void _destroyMouse();
+        void _destroyJoySticks();
+        void _destroyState(InputState* state);
+        void _clearBuffers();
+        void _reload(bool joyStickSupport);
+        void _fireAxis(unsigned int iJoyStick, int axis, int value);
+        unsigned int _getJoystick(const OIS::JoyStickEvent& arg);
+        void _updateActiveStates();
+        bool _configureInputState(InputState* state, const std::string& name, bool bAlwaysGetsInput, bool bTransparent, int priority);
+        // input events
+        bool mousePressed  (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
+        bool mouseReleased (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
+        bool mouseMoved    (const OIS::MouseEvent    &arg);
+        bool keyPressed    (const OIS::KeyEvent      &arg);
+        bool keyReleased   (const OIS::KeyEvent      &arg);
+        bool buttonPressed (const OIS::JoyStickEvent &arg, int button);
+        bool buttonReleased(const OIS::JoyStickEvent &arg, int button);
+        bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
+        bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
+        bool povMoved      (const OIS::JoyStickEvent &arg, int id);
+        // don't remove that! Or else add OIS as dependency library to orxonox.
+        bool vector3Moved  (const OIS::JoyStickEvent &arg, int id) { return true; }
+        void setConfigValues();
+        void _calibrationFileCallback();
+        void loadDevices(size_t windowHnd);
+        void loadMouse();
+        void loadJoySticks();
+        void destroyDevices();
+        void stopCalibration();
+        void reloadInternal();
+        void destroyStateInternal(InputState* state);
+        void updateActiveStates();
+        // From WindowEventListener
+        void windowFocusChanged();
     private: // variables
+        OIS::InputManager*                  inputSystem_;          //!< OIS input manager
+        OIS::Keyboard*                      keyboard_;             //!< OIS mouse
+        OIS::Mouse*                         mouse_;                //!< OIS keyboard
+        std::vector<OIS::JoyStick*>         joySticks_;            //!< OIS joy sticks
+        unsigned int                        joySticksSize_;
+        std::vector<std::string>            joyStickIDs_;          //!< Execution unique identification strings for the joy sticks
+        unsigned int                        devicesNum_;
+        size_t                              windowHnd_;            //!< Render window handle
+        InputManagerState                   internalState_;        //!< Current internal state
+        State                               internalState_;        //!< Current internal state
+        OIS::InputManager*                  oisInputManager_;      //!< OIS input manager
+        std::vector<InputDevice*>           devices_;              //!< List of all input devices (keyboard, mouse, joy sticks)
+        // TODO: Get this from the GraphicsManager during reload
+        size_t                              windowHnd_;            //!< Render window handle (used to reload the InputManager)
         // some internally handled states and handlers
         SimpleInputState*                   stateEmpty_;
+        InputState*                         emptyState_;           //!< Lowest priority states (makes handling easier)
         KeyDetector*                        keyDetector_;          //!< KeyDetector instance
+        InputBuffer*                        calibratorCallbackBuffer_;
+        std::map<std::string, InputState*>  inputStatesByName_;
+        std::set<InputState*>               stateEnterRequests_;   //!< Request to enter a new state
+        std::set<InputState*>               stateLeaveRequests_;   //!< Request to leave a running state
+        std::set<InputState*>               stateDestroyRequests_; //!< Request to destroy a state
+        std::map<int, InputState*>          activeStates_;
+        std::vector<std::vector<InputState*> > activeStatesTriggered_;
+        std::vector<InputState*>            activeStatesTicked_;
+        // joystick calibration
+        std::vector<std::vector<int> >      joyStickMinValues_;
+        std::vector<std::vector<int> >      joyStickMaxValues_;
+        std::vector<std::vector<int> >      joyStickMiddleValues_;
+        std::vector<ConfigValueContainer*>  calibrationConfigValueContainers_;
+        std::vector<JoyStickCalibration>    joyStickCalibrations_;
+        unsigned int                        keyboardModifiers_;    //!< Bit mask representing keyboard modifiers.
+        std::vector<POVStates>              povStates_;            //!< Keeps track of the joy stick POV states.
+        std::vector<SliderStates>           sliderStates_;         //!< Keeps track of the possibly two slider axes.
+        std::vector<Key>                    keysDown_;
+        std::vector<MouseButtonCode::ByEnum>      mouseButtonsDown_;
+        std::vector<std::vector<JoyStickButtonCode::ByEnum> >  joyStickButtonsDown_;
+        // ConfigValues
+        std::string                         calibrationFilename_;  //!< Joy stick calibration ini filename
+        static InputManager*                singletonRef_s;
+        //! InputBuffer that reacts to the Enter key when calibrating the joy sticks
+        InputBuffer*                        calibratorCallbackHandler_;
+        std::map<std::string, InputState*>  statesByName_;         //!< Contains all the created input states by name
+        std::map<int, InputState*>          activeStates_;         //!< Contains all active input states by priority (std::map is sorted!)
+        std::vector<InputState*>            activeStatesTicked_;   //!< Like activeStates_, but only contains the ones that currently receive events
+        std::set<InputState*>               stateEnterRequests_;   //!< Requests to enter a new state
+        std::set<InputState*>               stateLeaveRequests_;   //!< Requests to leave a running state
+        std::set<InputState*>               stateDestroyRequests_; //!< Requests to destroy a state
+        static InputManager*                singletonRef_s;        //!< Pointer reference to the singleton
     };
-    /**
-    @brief
-        Creates a new InputState by type, name and priority.
-        You will have to use this method because the
-        c'tors and d'tors are private.
-    @remarks
-        The InputManager will take care of the state completely. That also
-        means it gets deleted when the InputManager is destroyed!
-    @param name
-        Name of the InputState when referenced as string
-    @param priority
-        Priority matters when multiple states are active. You can specify any
-        number, but 1 - 99 is preferred (99 means high).
-    */
-    template <class T>
-    T* InputManager::createInputState(const std::string& name, bool bAlwaysGetsInput, bool bTransparent, InputStatePriority priority)
+    {
-        T* state = new T;
-        if (_configureInputState(state, name, bAlwaysGetsInput, bTransparent, priority))
-            return state;
-        else
+        {
-            delete state;
-            return 0;
+        }
+    }
+}

code/trunk/src/core/input/InputPrereqs.h

-                      r3276
+                      r3327
 @file
 @brief
+    Declarations of various interface classes for the input management.
+    Declarations of all key/button/axis code enumeration and string literals
+    and an input device enumeration.
 */
 …
         const unsigned int numberOfKeys = 0xEE; // 238
         // note: KeyCode comments were directly copied from OISKeyboard.h
+        //! Key codes as enumeration
         enum ByEnum
+        {
 …
         };
         // Names as string. Has no real linkage!
+        //! Key codes as strings
         const char* const ByString[] =
+        {
 …
         const unsigned int numberOfButtons = 8;
+        //! Mouse button codes as enumeration
         enum ByEnum
+        {
 …
         };
         // Names as string. Has no real linkage!
+        // Mouse button codes as strings
         const char* const ByString[] =
+        {
 …
         const unsigned int numberOfAxes = 2;
+        // Mouse axis codes as enumeration
         enum ByEnum
+        {
 …
         };
         // Names as string. Has no real linkage!
+        // Mouse axis codes as strings
         const char* const ByString[] =
+        {
 …
         const unsigned int numberOfButtons = 64;
+        // Joy stick button codes as enumeration
         enum ByEnum
+        {
 …
         };
         // Names as string. Has no real linkage!
+        // Joy stick button codes as strings
         const char* const ByString[] =
+        {
 …
         const unsigned int numberOfAxes = 24;
+        // Joy stick axis codes as enumeration
         enum ByEnum
+        {
 …
         };
         // Names as string. Has no real linkage!
+        // Joy stick axis codes as strings
         const char* const ByString[] =
+        {
 …
     namespace InputDeviceEnumerator
+    {
+        //! Used to access the devices in an array
         enum Value
+        {
 …
         };
+    }
-    namespace ButtonEvent
+    {
-        enum Value
+        {
-            Press,
-            Release,
-            Hold
-        };
-        template <ButtonEvent::Value Event>
-        struct EnumToType { };
-        typedef EnumToType<Press>   TPress;
-        typedef EnumToType<Release> TRelease;
-        typedef EnumToType<Hold>    THold;
+    }
-    namespace KeyboardModifier
+    {
-        enum Enum
+        {
-            Shift = 0x0000001,
-            Ctrl  = 0x0000010,
-            Alt   = 0x0000100
-        };
+    }
-    class _CoreExport KeyEvent
+    {
-    public:
-        KeyEvent(const OIS::KeyEvent& evt)
-            : key_(static_cast<KeyCode::ByEnum>(evt.key))
-            , text_(evt.text)
-            , modifiers_(0)
-        { }
-        bool operator==(const KeyEvent& rhs) const
-            { return rhs.key_ == key_; }
-        bool operator!=(const KeyEvent& rhs) const
-            { return rhs.key_ != key_; }
-        void setModifiers(int modifiers)
-            { modifiers_ = modifiers; }
-        bool isModifierDown(KeyboardModifier::Enum modifier) const
-            { return static_cast<KeyboardModifier::Enum>(modifier & modifiers_); }
-        KeyCode::ByEnum getKeyCode() const
-            { return key_; }
-        unsigned int getText() const { return text_; }
-    private:
-        KeyCode::ByEnum key_;
-        unsigned int text_;
-        int modifiers_;
-    };
-    //-----------------------------------------------------------------------
-    // Device type traits
-    //-----------------------------------------------------------------------
-    struct KeyboardTraits
+    {
-        typedef Keyboard DeviceClass;
-        typedef OIS::Keyboard OISDeviceClass;
-        typedef KeyEvent ButtonType;
-        typedef KeyEvent& ButtonTypeParam;
-        static const OIS::Type OISDeviceValue = OIS::OISKeyboard;
-    };
-    struct MouseTraits
+    {
-        typedef Mouse DeviceClass;
-        typedef OIS::Mouse OISDeviceClass;
-        typedef MouseButtonCode::ByEnum ButtonType;
-        typedef MouseButtonCode::ByEnum ButtonTypeParam;
-        static const OIS::Type OISDeviceValue = OIS::OISMouse;
-    };
-    struct JoyStickTraits
+    {
-        typedef JoyStick DeviceClass;
-        typedef OIS::JoyStick OISDeviceClass;
-        typedef JoyStickButtonCode::ByEnum ButtonType;
-        typedef JoyStickButtonCode::ByEnum ButtonTypeParam;
-        static const OIS::Type OISDeviceValue = OIS::OISJoyStick;
-    };
-    // Note: Entries correspond to OIS::Type enum
-    namespace InputDeviceNames
+    {
-        const char* const values[] = { "", "Keyboard", "Mouse", "JoyStick" };
+    }
+}

code/trunk/src/core/input/InputState.cc

-                      r3276
+                      r3327
 namespace orxonox
+{
+    InputState::InputState()
+        : priority_(0)
+        , bAlwaysGetsInput_(false)
+        , bTransparent_(false)
+    //! Sets priority of it's a high priority and resizes the handler list
+    InputState::InputState(const std::string& name, bool bAlwaysGetsInput, bool bTransparent, InputStatePriority priority)
+        : name_(name)
+        , bAlwaysGetsInput_(bAlwaysGetsInput)
+        , bTransparent_(bTransparent)
         , bExpired_(true)
         , handlers_(2)
 …
         , leaveFunctor_(0)
+    {
+        if (priority >= InputStatePriority::HighPriority || priority == InputStatePriority::Empty)
+            priority_ = priority;
+        else
+            priority_ = 0;
+        handlers_.resize(InputDeviceEnumerator::FirstJoyStick + this->getJoyStickList().size(), NULL);
+    }
 …
+    }
+    void InputState::JoyStickQuantityChanged(unsigned int n)
+    //! Called by JoyStickQuantityListener upon joy stick adding/removal
+    void InputState::JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList)
+    {
         unsigned int oldSize = handlers_.size();
         handlers_.resize(InputDeviceEnumerator::FirstJoyStick + n, NULL);
+        handlers_.resize(InputDeviceEnumerator::FirstJoyStick + joyStickList.size(), NULL);
         for (unsigned int i = oldSize; i < handlers_.size(); ++i)
 …
+    }
-    /**
-    @brief
-        Adds a joy stick handler.
-    @param handler
-        Pointer to the handler object.
-    @param joyStickID
-        ID of the joy stick
-    @return
-        True if added, false otherwise.
-    */
     bool InputState::setJoyStickHandler(InputHandler* handler, unsigned int joyStick)
+    {
 …
+    }
+    /**
+    @brief
+        Adds a joy stick handler.
+    @param handler
+        Pointer to the handler object.
+    @return
+        True if added, false if handler already existed.
+    */
+    bool InputState::setJoyStickHandler(InputHandler* handler)
+    void InputState::setJoyStickHandler(InputHandler* handler)
+    {
         joyStickHandlerAll_ = handler;
 …
             handlers_[i] = handler;
         bExpired_ = true;
-        return true;
+    }
+    /**
+    @brief
+        Adds a handler of any kind. dynamic_cast determines to which list it is added.
+    @param handler
+        Pointer to the handler object.
+    @return
+        True if added, false if handler already existed.
+    */
+    bool InputState::setHandler(InputHandler* handler)
+    void InputState::setHandler(InputHandler* handler)
+    {
         setKeyHandler(handler);
         setMouseHandler(handler);
         return setJoyStickHandler(handler);
+        setJoyStickHandler(handler);
+    }

code/trunk/src/core/input/InputState.h

-                      r3196
+                      r3327
  */
-/**
-@file
-@brief
-*/
 #ifndef _InputState_H__
 #define _InputState_H__
+#include "core/CorePrereqs.h"
+#include "InputPrereqs.h"
+#include <cassert>
 #include <string>
 #include <vector>
+#include "InputInterfaces.h"
+#include "util/OrxEnum.h"
+#include "InputHandler.h"
+#include "JoyStickQuantityListener.h"
 namespace orxonox
+{
+    class _CoreExport InputState
+    //! Enumeration wrapper for input state priorities
+    struct InputStatePriority : OrxEnum<InputStatePriority>
+    {
+        OrxEnumConstructors(InputStatePriority);
+        static const int Empty        = -1;
+        static const int Dynamic      = 0;
+        static const int HighPriority = 1000;
+        static const int Console      = HighPriority + 0;
+        static const int Calibrator   = HighPriority + 1;
+        static const int Detector     = HighPriority + 2;
+    };
+    /**
+    @brief
+        InputStates allow you to customise the input event targets at runtime.
+        The general idea is a stack: Every activated InputState will be pushed on
+        that stack and only the top one gets the input events. This is done for
+        every device (keyboard, mouse, all joy sticks) separately to allow
+        for intance keyboard input capturing for the console while you can still
+        steer a ship with the mouse.
+        There are two exceptions to this behaviour though:
+        - If an InputState is created with the 'Transparent' parameter on, the
+          state will not prevent input from getting to the state below it on the stack.
+          This can be useful for instance if you need to deploy input to multiple
+          handlers: Simply create two InputStates and make the high priority one transparent.
+        - If an InputState is created with the 'AlwaysGetsInput' parameter on, then
+          the state will always receive input as long as it is activated.
+        - Note: If you mark an InputState with both parameters on, then it will
+          not influence ony other InputState at all.
+        Priorities
+        **********
+        Every InputState has a priority when on the stack, but mostly this
+        priority is dynamic (InputStatePriority::Dynamic) which means that a state
+        pushed onto the stack will simply have a higher priority than the top one.
+        This behaviour really only applies to normal states that don't have
+        a high priority (InputStatePriority::HighPriority). These 'special' ones
+        are used for features like the KeyDetector or the console. Use with care!
+    */
+    class _CoreExport InputState : public JoyStickQuantityListener
+    {
         friend class InputManager;
+        //! Marks the index in the handler vector for the keyboard handler
+        static const InputDeviceEnumerator::Value keyboardIndex_s = InputDeviceEnumerator::Keyboard;
+        //! Marks the index in the handler vector for the mouse handler
+        static const InputDeviceEnumerator::Value mouseIndex_s = InputDeviceEnumerator::Mouse;
+        //! Marks the index in the handler vector for the first joy stick handler
+        static const InputDeviceEnumerator::Value firstJoyStickIndex_s = InputDeviceEnumerator::FirstJoyStick;
     public:
+        //! Sets the keyboard event handler (overwrites if there already was one!)
+        void setKeyHandler     (InputHandler* handler)
+            { handlers_[keyboardIndex_s] = handler; bExpired_ = true; }
+        //! Sets the mouse event handler (overwrites if there already was one!)
+        void setMouseHandler   (InputHandler* handler)
+            { handlers_[mouseIndex_s]    = handler; bExpired_ = true; }
+        /**
+        @brief
+            Sets the joy stick event handler for one specific joy stick (overwrites if there already was one!)
+        @return
+            Returns false if the specified device was not found
+        */
+        bool setJoyStickHandler(InputHandler* handler, unsigned int joyStick);
+        //! Sets the joy stick event handler for all joy sticks (overwrites if there already was one!)
+        void setJoyStickHandler(InputHandler* handler);
+        //! Sets an InputHandler to be used for all devices
+        void setHandler        (InputHandler* handler);
+        //! Returns the name of the state (which is unique!)
         const std::string& getName() const { return name_; }
+        //! Returns the priority of the state (which is unique if != 0)
         int getPriority()            const { return priority_; }
+        bool isInputDeviceEnabled(unsigned int device)
+        //! Tells whether there a handler installed for a specific device
+        bool isInputDeviceEnabled(unsigned int device);
+        //! Returns true if the handler situation has changed
+        bool hasExpired()      { return this->bExpired_; }
+        //! Call this if you have applied the changes resulting from changed handlers
+        void resetExpiration() { bExpired_ = false; }
+        //! Updates one specific device handler with #device#Updated
+        void update(float dt, unsigned int device);
+        //! Updates all handlers with allDevicesUpdated
+        void update(float dt);
+        //! Generic function that distributes all 9 button events
+        template <typename EventType, class Traits>
+        void buttonEvent(unsigned int device, const typename Traits::ButtonTypeParam button);
+        //! Event handler
+        void mouseMoved(IntVector2 abs, IntVector2 rel, IntVector2 clippingSize);
+        //! Event handler
+        void mouseScrolled(int abs, int rel);
+        //! Event handler
+        void joyStickAxisMoved(unsigned int device, unsigned int axis, float value);
+        // Functors
+        //! Called when the state is being activated (even if it doesn't get any events afterwards!)
+        void entered();
+        //! Called upon deactivation of the state
+        void left();
+        //! Sets a functor to be called upon activation of the state
+        void setEnterFunctor(Functor* functor) { this->enterFunctor_ = functor; }
+        //! Sets a functor to be called upon deactivation of the state
+        void setLeaveFunctor(Functor* functor) { this->leaveFunctor_ = functor; }
+    private:
+        InputState(const std::string& name, bool bAlwaysGetsInput, bool bTransparent, InputStatePriority priority);
+        ~InputState() { }
+        void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
+        //! Sets the priority (only to be used by the InputManager!)
+        void setPriority(int priority) { priority_ = priority; }
+        const std::string           name_;                  //!< Name of the state
+        const bool                  bAlwaysGetsInput_;      //!< See class declaration for explanation
+        const bool                  bTransparent_;          //!< See class declaration for explanation
+        int                         priority_;              //!< Current priority (might change)
+        bool                        bExpired_;              //!< See hasExpired()
+        std::vector<InputHandler*>  handlers_;              //!< Vector with all handlers where the index is the device ID
+        //! Handler to be used for all joy sticks (needs to be saved in case another joy stick gets attached)
+        InputHandler*               joyStickHandlerAll_;
+        Functor*                    enterFunctor_;          //!< Functor to be executed on enter
+        Functor*                    leaveFunctor_;          //!< Functor to be executed on leave
+    };
+    FORCEINLINE void InputState::update(float dt)
+    {
+        for (unsigned int i = 0; i < handlers_.size(); ++i)
+            if (handlers_[i] != NULL)
+                handlers_[i]->allDevicesUpdated(dt);
+    }
+    FORCEINLINE void InputState::update(float dt, unsigned int device)
+    {
+        switch (device)
+        {
+            if (device < bInputDeviceEnabled_.size())
+                return bInputDeviceEnabled_[device];
+            else
+                return false;
+        case InputDeviceEnumerator::Keyboard:
+            if (handlers_[keyboardIndex_s] != NULL)
+                handlers_[keyboardIndex_s]->keyboardUpdated(dt);
+            break;
+        case InputDeviceEnumerator::Mouse:
+            if (handlers_[mouseIndex_s] != NULL)
+                handlers_[mouseIndex_s]->mouseUpdated(dt);
+            break;
+        default: // joy sticks
+            if (handlers_[device] != NULL)
+                handlers_[device]->joyStickUpdated(device - firstJoyStickIndex_s, dt);
+            break;
+        }
+        bool handlersChanged() { return this->bHandlersChanged_; }
+        void resetHandlersChanged() { bHandlersChanged_ = false; }
+        virtual void onEnter() = 0;
+        virtual void onLeave() = 0;
+        virtual void registerOnEnter(Executor* executor)      { executorOnEnter_ = executor; }
+        virtual void unRegisterOnEnter()                      { executorOnEnter_ = 0; }
+        virtual void registerOnLeave(Executor* executor)      { executorOnLeave_ = executor; }
+        virtual void unRegisterOnLeave()                      { executorOnLeave_ = 0; }
+        virtual void updateInput(float dt, unsigned int device) = 0;
+        virtual void updateInput(float dt) = 0;
+        virtual void keyPressed (const KeyEvent& evt) = 0;
+        virtual void keyReleased(const KeyEvent& evt) = 0;
+        virtual void keyHeld    (const KeyEvent& evt) = 0;
+        virtual void mouseButtonPressed (MouseButtonCode::ByEnum id) = 0;
+        virtual void mouseButtonReleased(MouseButtonCode::ByEnum id) = 0;
+        virtual void mouseButtonHeld    (MouseButtonCode::ByEnum id) = 0;
+        virtual void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize) = 0;
+        virtual void mouseScrolled      (int abs, int rel) = 0;
+        virtual void joyStickButtonPressed (unsigned int joyStickID, JoyStickButtonCode::ByEnum id) = 0;
+        virtual void joyStickButtonReleased(unsigned int joyStickID, JoyStickButtonCode::ByEnum id) = 0;
+        virtual void joyStickButtonHeld    (unsigned int joyStickID, JoyStickButtonCode::ByEnum id) = 0;
+        virtual void joyStickAxisMoved     (unsigned int joyStickID, unsigned int axis, float value) = 0;
+    protected:
+        InputState()
+            : bHandlersChanged_(false)
+            , executorOnEnter_(0)
+            , executorOnLeave_(0)
+            , priority_(0)
+            , bAlwaysGetsInput_(false)
+            , bTransparent_(false)
+        { }
+        virtual ~InputState() { }
+        virtual void numberOfJoySticksChanged(unsigned int n) = 0;
+        void setInputDeviceEnabled(unsigned int device, bool bEnabled)
+        {
+            if (device < bInputDeviceEnabled_.size())
+                bInputDeviceEnabled_[device] = bEnabled;
+        }
+        bool bHandlersChanged_;
+        Executor*                                   executorOnEnter_;
+        Executor*                                   executorOnLeave_;
+    private:
+        void setNumOfJoySticks(unsigned int n)
+        {
+            bInputDeviceEnabled_.resize(n + 2);
+            numberOfJoySticksChanged(n);
+        }
+        void setName(const std::string& name)  { name_ = name; }
+        void setPriority(int priority)         { priority_ = priority; }
+        std::string                                 name_;
+        int                                         priority_;
+        std::vector<bool>                           bInputDeviceEnabled_;
+        bool                                        bAlwaysGetsInput_;
+        bool                                        bTransparent_;
+    };
+    }
+    template <typename EventType, class Traits>
+    FORCEINLINE void InputState::buttonEvent(unsigned int device, const typename Traits::ButtonTypeParam button)
+    {
+        assert(device < handlers_.size());
+        if (handlers_[device] != NULL)
+            handlers_[device]->buttonEvent(device, button, EventType());
+    }
+    FORCEINLINE void InputState::mouseMoved(IntVector2 abs, IntVector2 rel, IntVector2 clippingSize)
+    {
+        if (handlers_[mouseIndex_s] != NULL)
+            handlers_[mouseIndex_s]->mouseMoved(abs, rel, clippingSize);
+    }
+    FORCEINLINE void InputState::mouseScrolled(int abs, int rel)
+    {
+        if (handlers_[mouseIndex_s] != NULL)
+            handlers_[mouseIndex_s]->mouseScrolled(abs, rel);
+    }
+    FORCEINLINE void InputState::joyStickAxisMoved(unsigned int device, unsigned int axis, float value)
+    {
+        assert(device < handlers_.size());
+        if (handlers_[device] != NULL)
+            handlers_[device]->axisMoved(device - firstJoyStickIndex_s, axis, value);
+    }
+}

code/trunk/src/core/input/JoyStick.cc

-                      r3270
+                      r3327
  */
-/**
-@file
-@brief
-    Implementation of the JoyStick wrapper class.
-*/
 #include "JoyStick.h"
 #include <ois/OISJoyStick.h>
-#include <ois/OISInputManager.h>
 #include <boost/foreach.hpp>
 …
 #include "util/Convert.h"
 #include "InputState.h"
-#include "InputManager.h"
 namespace orxonox
+{
+    /**
+    @brief
+        Helper function that loads the config value vector of one coefficient
+    */
+    //! Helper function that loads the config value vector of one coefficient
     void loadCalibration(std::vector<int>& list, const std::string& sectionName, const std::string& valueName, size_t size, int defaultValue);
     JoyStick::JoyStick(const std::vector<InputState*>& states, unsigned int id)
+        : id_(id)
         , bCalibrating_(false)
         , inputStates_(states)
+    std::vector<std::string> JoyStick::deviceNames_s;
+    JoyStick::JoyStick(unsigned int id, OIS::InputManager* oisInputManager)
+        : super(id, oisInputManager)
+    {
         RegisterRootObject(JoyStick);
         this->setConfigValues();
+        OIS::InputManager* system = InputManager::getInstance().getInputSystem();
+        oisJoyStick_ = static_cast<OIS::JoyStick*>(system->createInputObject(OIS::OISJoyStick, true));
+        oisJoyStick_->setEventCallback(this);
+        idString_ = "JoyStick_";
+        std::string name = oisJoyStick_->vendor();
+        replaceCharacters(name, ' ', '_');
+        idString_ += name + "_";
+        idString_ += multi_cast<std::string>(oisJoyStick_->getNumberOfComponents(OIS::OIS_Button))  + "_";
+        idString_ += multi_cast<std::string>(oisJoyStick_->getNumberOfComponents(OIS::OIS_Axis))    + "_";
+        idString_ += multi_cast<std::string>(oisJoyStick_->getNumberOfComponents(OIS::OIS_Slider))  + "_";
+        idString_ += multi_cast<std::string>(oisJoyStick_->getNumberOfComponents(OIS::OIS_POV));
+        //idString_ += multi_cast<std::string>(oisJoyStick_->getNumberOfComponents(OIS::OIS_Vector3));
+        if (InputManager::getInstance().checkJoyStickID(idString_) == false)
+        {
+            // Make the ID unique for this execution time.
+            idString_ += "_" + multi_cast<std::string>(id_);
+        }
+        COUT(4) << "Created OIS joy stick with ID " << idString_ << std::endl;
+        // Initialise POV and Slider states
+        this->clearBuffersImpl();
+        // Generate unique name
+        if (oisDevice_->vendor().empty())
+            deviceName_ = "Unknown_";
+        else
+        {
+            std::string name = oisDevice_->vendor();
+            replaceCharacters(name, ' ', '_');
+            deviceName_ = name + "_";
+        }
+        deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_Button))  + "_";
+        deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_Axis))    + "_";
+        deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_Slider))  + "_";
+        deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_POV));
+        //deviceName_ += multi_cast<std::string>(oisDevice_->getNumberOfComponents(OIS::OIS_Vector3));
+        BOOST_FOREACH(std::string& idString, deviceNames_s)
+        {
+            if (deviceName_ == idString)
+            {
+                // Make the ID unique for this execution time.
+                deviceName_ += "_" + multi_cast<std::string>(this->getDeviceName());
+                break;
+            }
+        }
+        COUT(4) << "Created OIS joy stick with ID " << deviceName_ << std::endl;
         // Load calibration
         size_t axes = sliderAxes_s + static_cast<size_t>(oisJoyStick_->getNumberOfComponents(OIS::OIS_Axis));
         loadCalibration(configMinValues_,  idString_, "MinValue",  axes,  -32768);
         loadCalibration(configMaxValues_,  idString_, "MaxValue",  axes,   32768);
         loadCalibration(configZeroValues_, idString_, "ZeroValue", axes, 0);
+        size_t axes = sliderAxes_s + static_cast<size_t>(oisDevice_->getNumberOfComponents(OIS::OIS_Axis));
+        loadCalibration(configMinValues_,  deviceName_, "MinValue",  axes,  -32768);
+        loadCalibration(configMaxValues_,  deviceName_, "MaxValue",  axes,   32768);
+        loadCalibration(configZeroValues_, deviceName_, "ZeroValue", axes, 0);
         this->evaluateCalibration();
+    }
+    JoyStick::~JoyStick()
+    {
+        try
+        {
+            OIS::InputManager* system = InputManager::getInstance().getInputSystem();
+            system->destroyInputObject(oisJoyStick_);
+        }
+        catch (...)
+        {
+            COUT(1) << "Joy stick destruction failed! Potential resource leak!" << std::endl;
+        }
+    }
+    /**
+    @brief
+        Callback for the joy stick calibration config file. @see setConfigValues.
+    */
+    //! Callback for the joy stick calibration config file.
     void JoyStick::calibrationFileCallback()
+    {
 …
+    }
-    /**
-    @brief
-        Sets the configurable values.
-    */
     void JoyStick::setConfigValues()
+    {
 …
         // fill the rest with default values
         for (unsigned int i = configValueVectorSize; i < size; ++i)
+        {
             list[i] = defaultValue;
+        }
+    }
+    void JoyStick::startCalibration()
+    {
+        bCalibrating_ = true;
+    }
+    //! Called by InputDevice when calibration mode has started
+    void JoyStick::calibrationStarted()
+    {
         // Set initial values
         BOOST_FOREACH(int& minVal, configMinValues_)
 …
+    }
+    void JoyStick::stopCalibration()
+    //! Called by InputDevice when calibration mode has stopped
+    void JoyStick::calibrationStopped()
+    {
         // Get the middle positions now
 …
         for (unsigned int i = 0; i < sliderAxes_s/2; ++i)
+        {
             configZeroValues_[iAxis++] = oisJoyStick_->getJoyStickState().mSliders[i].abX;
             configZeroValues_[iAxis++] = oisJoyStick_->getJoyStickState().mSliders[i].abY;
+        }
         // Note: joyStickMiddleValues_[iJoyStick] was already correctly resised in loadCalibration()
         assert(oisJoyStick_->getJoyStickState().mAxes.size() == configZeroValues_.size() - sliderAxes_s);
+            configZeroValues_[iAxis++] = oisDevice_->getJoyStickState().mSliders[i].abX;
+            configZeroValues_[iAxis++] = oisDevice_->getJoyStickState().mSliders[i].abY;
+        }
+        // Note: joyStickZeroValues_[iJoyStick] was already correctly resised in loadCalibration()
+        assert(oisDevice_->getJoyStickState().mAxes.size() == configZeroValues_.size() - sliderAxes_s);
         for (unsigned int i = 0; i < configZeroValues_.size() - sliderAxes_s; ++i)
             configZeroValues_[iAxis++] = oisJoyStick_->getJoyStickState().mAxes[i].abs;
+            configZeroValues_[iAxis++] = oisDevice_->getJoyStickState().mAxes[i].abs;
         for (unsigned int i = 0; i < configMinValues_.size(); ++i)
 …
                 configMinValues_[i] = -32768;
             ConfigFileManager::getInstance().setValue(ConfigFileType::JoyStickCalibration,
                 idString_, "MinValue", i, multi_cast<std::string>(configMinValues_[i]), false);
+                deviceName_, "MinValue", i, multi_cast<std::string>(configMinValues_[i]), false);
             // Maximum values
 …
                 configMaxValues_[i] = 32767;
             ConfigFileManager::getInstance().setValue(ConfigFileType::JoyStickCalibration,
                 idString_, "MaxValue", i, multi_cast<std::string>(configMaxValues_[i]), false);
+                deviceName_, "MaxValue", i, multi_cast<std::string>(configMaxValues_[i]), false);
             // Middle values
             ConfigFileManager::getInstance().setValue(ConfigFileType::JoyStickCalibration,
                 idString_, "ZeroValue", i, multi_cast<std::string>(configZeroValues_[i]), false);
+                deviceName_, "ZeroValue", i, multi_cast<std::string>(configZeroValues_[i]), false);
+        }
         this->evaluateCalibration();
+        bCalibrating_ = false;
+    }
+    }
+    //! Evaluates the accumulated values during calibration
     void JoyStick::evaluateCalibration()
+    {
 …
+    }
     void JoyStick::clearBuffer()
+    {
         pressedButtons_.clear();
+    //! Resets the pov states
+    void JoyStick::clearBuffersImpl()
+    {
         for (int j = 0; j < 4; ++j)
+        {
             povStates_[j] = 0;
+            sliderStates_[j][0] = 0;
+            sliderStates_[j][1] = 0;
+        }
+    }
+    // ###### Events ######
+    void JoyStick::capture()
+    {
+        oisJoyStick_->capture();
+        // call all the handlers for the held joy stick button events
+        for (unsigned int iButton = 0; iButton < pressedButtons_.size(); iButton++)
+        {
+            BOOST_FOREACH(InputState* state, inputStates_)
+                state->joyStickButtonHeld(id_, pressedButtons_[iButton]);
+        }
+    }
+    bool JoyStick::buttonPressed(const OIS::JoyStickEvent &arg, int button)
+    {
+        // check whether the button already is in the list (can happen when focus was lost)
+        unsigned int iButton = 0;
+        while (iButton < pressedButtons_.size() && pressedButtons_[iButton] != button)
+            iButton++;
+        if (iButton == pressedButtons_.size())
+            pressedButtons_.push_back(static_cast<JoyStickButtonCode::ByEnum>(button));
+        BOOST_FOREACH(InputState* state, inputStates_)
+            state->joyStickButtonPressed(id_, static_cast<JoyStickButtonCode::ByEnum>(button));
+        return true;
+    }
+    bool JoyStick::buttonReleased(const OIS::JoyStickEvent &arg, int button)
+    {
+        // remove the button from the pressedButtons_ list
+        for (unsigned int iButton = 0; iButton < pressedButtons_.size(); iButton++)
+        {
+            if (static_cast<int>(pressedButtons_[iButton]) == button)
+            {
+                pressedButtons_.erase(pressedButtons_.begin() + iButton);
+                break;
+            }
+        }
+        BOOST_FOREACH(InputState* state, inputStates_)
+            state->joyStickButtonPressed(id_, static_cast<JoyStickButtonCode::ByEnum>(button));
+        return true;
+    }
+    /**
+    @brief
+        Calls the states for a particular axis with our enumeration.
+        Used by OIS sliders and OIS axes.
+    */
+    }
+    //! Generic method to forward axis events
     void JoyStick::fireAxis(int axis, int value)
+    {
         if (bCalibrating_)
+        if (this->isCalibrating())
+        {
             if (value < configMinValues_[axis])
 …
             BOOST_FOREACH(InputState* state, inputStates_)
+                state->joyStickAxisMoved(id_, axis, fValue);
+        }
+    }
+                state->joyStickAxisMoved(this->getDeviceID(), axis, fValue);
+        }
+    }
+    //! OIS joy stick axis event handler
     bool JoyStick::axisMoved(const OIS::JoyStickEvent &arg, int axis)
+    {
 …
+    }
+    //! A Slider always has an X and an Y direction!
     bool JoyStick::sliderMoved(const OIS::JoyStickEvent &arg, int id)
+    {
 …
+    }
+    //! A POV is the big button that can point in all directions (but only in one at once)
     bool JoyStick::povMoved(const OIS::JoyStickEvent &arg, int id)
+    {

code/trunk/src/core/input/JoyStick.h

-                      r3270
+                      r3327
  */
+/**
+@file
+@brief
+*/
+#ifndef _Core_JoyStick_H__
+#define _Core_JoyStick_H__
+#ifndef _JoyStick_H__
+#define _JoyStick_H__
+#include "core/CorePrereqs.h"
+#include "InputPrereqs.h"
 #include <string>
 #include <vector>
 #include "InputInterfaces.h"
+#include "InputDevice.h"
 namespace orxonox
+{
+    class _CoreExport JoyStick : public OrxonoxClass, public OIS::JoyStickListener
+    //! Template parameter collection for the base class
+    struct JoyStickTraits
+    {
+    private:
+        struct JoyStickCalibration
+        {
+        };
+        typedef JoyStick DeviceClass;
+        typedef OIS::JoyStick OISDeviceClass;
+        typedef JoyStickButtonCode::ByEnum ButtonType;
+        typedef JoyStickButtonCode::ByEnum ButtonTypeParam;
+        static const OIS::Type OISDeviceValue = OIS::OISJoyStick;
+    };
+    /**
+    @brief
+        Wraps around an OIS::JoyStick and forwards the input events to
+        a list of input states.
+        The class also supports joy stick calibration and stores the values
+        in an ini-file.
+    */
+    class _CoreExport JoyStick
+        : public OrxonoxClass
+        , public InputDeviceTemplated<JoyStickTraits>
+        , public OIS::JoyStickListener
+    {
+        friend class InputDeviceTemplated<JoyStickTraits>;
+        //! Super class alias
+        typedef InputDeviceTemplated<JoyStickTraits> super;
     public:
         JoyStick(const std::vector<InputState*>& states, unsigned int id);
         ~JoyStick();
+        //! Assigns a generated ID string and loads the calibration (if present)
+        JoyStick(unsigned int id, OIS::InputManager* oisInputManager);
+        ~JoyStick() { }
         void setConfigValues();
+        OIS::JoyStick* getOISJoyStick() { return this->oisJoyStick_; }
+        const std::string& getIDString() const { return this->idString_; }
+        void startCalibration();
+        void stopCalibration();
+        void capture();
+        void clearBuffer();
+        //! Returns the name generated from the number of knobs and the device name
+        const std::string& getDeviceName() const { return this->deviceName_; }
     private:
+        void calibrationStarted();
+        void calibrationStopped();
+        void evaluateCalibration();
+        void clearBuffersImpl();
         void calibrationFileCallback();
-        void evaluateCalibration();
         void fireAxis(int axis, int value);
+        bool buttonPressed (const OIS::JoyStickEvent &arg, int button);
+        bool buttonReleased(const OIS::JoyStickEvent &arg, int button);
+        //! OIS event handler
+        bool buttonPressed (const OIS::JoyStickEvent &arg, int button)
+        {
+            super::buttonPressed(static_cast<JoyStickButtonCode::ByEnum>(button));
+            return true;
+        }
+        //! OIS event handler
+        bool buttonReleased(const OIS::JoyStickEvent &arg, int button)
+        {
+            super::buttonReleased(static_cast<JoyStickButtonCode::ByEnum>(button));
+            return true;
+        }
         bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
         bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
         bool povMoved      (const OIS::JoyStickEvent &arg, int id);
         // don't remove that! Or else add OIS as dependency library to orxonox (it actually is..)
+        //! OIS event handler (don't remove that because of OIS version issues!)
         bool vector3Moved  (const OIS::JoyStickEvent &arg, int id) { return true; }
+        static const unsigned int sliderAxes_s = 8;
+        //! Returns the class name as string
+        static std::string getClassNameImpl() { return "JoyStick"; }
         OIS::JoyStick* oisJoyStick_;
         const unsigned int id_;
         std::string idString_;
+        std::string deviceName_;              //!< Name generated by the number of knobs and the device name
+        int povStates_[4];                    //!< Internal states for the POVs
+        int sliderStates_[4][2];              //!< Internal states for the Sliders (each slider has X and Y!)
         // calibration
+        bool bCalibrating_;
+        int zeroValues_[24];
+        float positiveCoeffs_[24];
+        float negativeCoeffs_[24];
+        int zeroValues_[24];                  //!< Axes values when the knob is in the middle
+        float positiveCoeffs_[24];            //!< Maps the negative part of an axis to a 0.0 to 1.0 floating range
+        float negativeCoeffs_[24];            //!< Maps the positive part of an axis to a 0.0 to 1.0 floating range
+        std::vector<int> configMinValues_;
+        std::vector<int> configMaxValues_;
+        std::vector<int> configZeroValues_;
+        int povStates_[4];
+        int sliderStates_[4][2];
+        std::vector<JoyStickButtonCode::ByEnum> pressedButtons_;
+        // InputState handling
+        const std::vector<InputState*>& inputStates_;
+        std::vector<int> configZeroValues_;   //!< Config file stored axis values when the knob is in the middle
+        std::vector<int> configMinValues_;    //!< Config file stored minimum axis values
+        std::vector<int> configMaxValues_;    //!< Config file stored maximum axis values
         // ConfigValues
+        std::string calibrationFilename_;  //!< Joy stick calibration ini filename
+        std::string calibrationFilename_;     //!< Joy stick calibration ini filename
+        //! Contains a list of all names to avoid duplicates
+        static std::vector<std::string> deviceNames_s;
+        //!< Maximum number of slider axes
+        static const unsigned int sliderAxes_s = 8;
     };
+}
 #endif /* _JoyStick_H__ */
+#endif /* _Core_JoyStick_H__ */

code/trunk/src/core/input/JoyStickQuantityListener.cc

-                      r3276
+                      r3327
  */
+/**
+@file
+@brief
+    Implementation of the JoyStickQuantityListener class.
+*/
+#include "JoyStickQuantityListener.h"
-#include "JoyStickQuantityListener.h"
 #include "core/CoreIncludes.h"
+#include "core/ObjectList.h"
 namespace orxonox
+{
+    std::vector<JoyStick*> JoyStickQuantityListener::joyStickList_s;
     JoyStickQuantityListener::JoyStickQuantityListener()
+    {
         RegisterObject(JoyStickQuantityListener);
+    }
+    //! Calls all registered objects and sets the static variable
+    /*static*/ void JoyStickQuantityListener::changeJoyStickQuantity(const std::vector<JoyStick*>& joyStickList)
+    {
+        joyStickList_s = joyStickList;
+        for (ObjectList<JoyStickQuantityListener>::iterator it = ObjectList<JoyStickQuantityListener>::begin(); it; ++it)
+            it->JoyStickQuantityChanged(joyStickList);
+    }
+}

code/trunk/src/core/input/JoyStickQuantityListener.h

-                      r3276
+                      r3327
 namespace orxonox
+{
+    //! Derive from this class to get informed when joy sticks get added/removed
     class _CoreExport JoyStickQuantityListener : virtual public OrxonoxClass
+    {
+    public:
+        friend class InputManager;
+    protected:
         JoyStickQuantityListener();
         virtual ~JoyStickQuantityListener() { }
+        virtual void JoyStickQuantityChanged(unsigned int value) = 0;
+        //! Returns a list with all JoySticks currently loaded
+        const std::vector<JoyStick*>& getJoyStickList() const { return joyStickList_s; }
+    private:
+        //! Called whenever joy sticks get added/removed
+        virtual void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList) = 0;
+        static void changeJoyStickQuantity(const std::vector<JoyStick*>& joyStickList);
+        //! Static variable that holds the latest distributed information
+        static std::vector<JoyStick*> joyStickList_s;
     };
+}

code/trunk/src/core/input/KeyBinder.cc

-                      r3301
+                      r3327
 #include "core/ConfigFileManager.h"
 #include "InputCommands.h"
 #include "InputManager.h"
+#include "JoyStick.h"
 namespace orxonox
 …
     */
     KeyBinder::KeyBinder()
+        : numberOfJoySticks_(0)
+        , deriveTime_(0.0f)
+        : deriveTime_(0.0f)
+    {
         mouseRelative_[0] = 0;
 …
         mousePosition_[0] = 0;
         mousePosition_[1] = 0;
+        joyStickButtons_.reserve(1000);
+        joyStickAxes_.reserve(1000);
         RegisterRootObject(KeyBinder);
 …
             else
                 nameSuffix = mouseWheelNames[i - MouseButtonCode::numberOfButtons];
             mouseButtons_[i].name_ = std::string("Mouse") + nameSuffix;
+            mouseButtons_[i].name_ = nameSuffix;
             mouseButtons_[i].paramCommandBuffer_ = &paramCommandBuffer_;
             mouseButtons_[i].groupName_ = "MouseButtons";
 …
         for (unsigned int i = 0; i < MouseAxisCode::numberOfAxes * 2; i++)
+        {
             mouseAxes_[i].name_ = std::string("Mouse") + MouseAxisCode::ByString[i / 2];
+            mouseAxes_[i].name_ = MouseAxisCode::ByString[i / 2];
             if (i & 1)
                 mouseAxes_[i].name_ += "Pos";
 …
         // initialise joy sticks separatly to allow for reloading
+        numberOfJoySticks_ = InputManager::getInstance().numberOfJoySticks();
+        initialiseJoyStickBindings();
+        // collect all Buttons and HalfAxes
+        compilePointerLists();
+        this->JoyStickQuantityChanged(this->getJoyStickList());
         // set them here to use allHalfAxes_
 …
+    }
     void KeyBinder::JoyStickDeviceNumberChanged(unsigned int value)
+    {
         unsigned int oldValue = numberOfJoySticks_;
         numberOfJoySticks_ = value;
+    void KeyBinder::JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList)
+    {
+        unsigned int oldValue = joySticks_.size();
+        joySticks_ = joyStickList;
         // initialise joy stick bindings
 …
         if (configFile_ != ConfigFileType::NoType)
+        {
             for (unsigned int iDev = oldValue; iDev < numberOfJoySticks_; ++iDev)
+            for (unsigned int iDev = oldValue; iDev < joySticks_.size(); ++iDev)
+            {
                 for (unsigned int i = 0; i < JoyStickButtonCode::numberOfButtons; ++i)
 …
     void KeyBinder::initialiseJoyStickBindings()
+    {
         this->joyStickAxes_.resize(numberOfJoySticks_);
         this->joyStickButtons_.resize(numberOfJoySticks_);
+        this->joyStickAxes_.resize(joySticks_.size());
+        this->joyStickButtons_.resize(joySticks_.size());
         // reinitialise all joy stick binings (doesn't overwrite the old ones)
         for (unsigned int iDev = 0; iDev < numberOfJoySticks_; iDev++)
+        {
             std::string deviceNumber = multi_cast<std::string>(iDev);
+        for (unsigned int iDev = 0; iDev < joySticks_.size(); iDev++)
+        {
+            std::string deviceName = joySticks_[iDev]->getDeviceName();
             // joy stick buttons
             for (unsigned int i = 0; i < JoyStickButtonCode::numberOfButtons; i++)
+            {
                 joyStickButtons_[iDev][i].name_ = std::string("JoyStick") + deviceNumber + JoyStickButtonCode::ByString[i];
+                joyStickButtons_[iDev][i].name_ = JoyStickButtonCode::ByString[i];
                 joyStickButtons_[iDev][i].paramCommandBuffer_ = &paramCommandBuffer_;
                 joyStickButtons_[iDev][i].groupName_ = std::string("JoyStick") + deviceNumber + "Buttons";
+                joyStickButtons_[iDev][i].groupName_ = "JoyStickButtons_" + deviceName;
+            }
             // joy stick axes
             for (unsigned int i = 0; i < JoyStickAxisCode::numberOfAxes * 2; i++)
+            {
                 joyStickAxes_[iDev][i].name_ = std::string("JoyStick") + deviceNumber + JoyStickAxisCode::ByString[i >> 1];
+                joyStickAxes_[iDev][i].name_ = JoyStickAxisCode::ByString[i / 2];
                 if (i & 1)
                     joyStickAxes_[iDev][i].name_ += "Pos";
 …
                     joyStickAxes_[iDev][i].name_ += "Neg";
                 joyStickAxes_[iDev][i].paramCommandBuffer_ = &paramCommandBuffer_;
                 joyStickAxes_[iDev][i].groupName_ = std::string("JoyStick") + deviceNumber + "Axes";
+                joyStickAxes_[iDev][i].groupName_ = "JoyStickAxes_" + deviceName;
+            }
+        }
 …
         for (unsigned int i = 0; i < KeyCode::numberOfKeys; i++)
             if (!keys_[i].name_.empty())
                 allButtons_[keys_[i].name_] = keys_ + i;
+                allButtons_[keys_[i].groupName_ + "." + keys_[i].name_] = keys_ + i;
         for (unsigned int i = 0; i < numberOfMouseButtons_; i++)
             allButtons_[mouseButtons_[i].name_] = mouseButtons_ + i;
+            allButtons_[mouseButtons_[i].groupName_ + "." + mouseButtons_[i].name_] = mouseButtons_ + i;
         for (unsigned int i = 0; i < MouseAxisCode::numberOfAxes * 2; i++)
+        {
             allButtons_[mouseAxes_[i].name_] = mouseAxes_ + i;
+            allButtons_[mouseAxes_[i].groupName_ + "." + mouseAxes_[i].name_] = mouseAxes_ + i;
             allHalfAxes_.push_back(mouseAxes_ + i);
+        }
         for (unsigned int iDev = 0; iDev < numberOfJoySticks_; iDev++)
+        for (unsigned int iDev = 0; iDev < joySticks_.size(); iDev++)
+        {
             for (unsigned int i = 0; i < JoyStickButtonCode::numberOfButtons; i++)
                 allButtons_[joyStickButtons_[iDev][i].name_] = &(joyStickButtons_[iDev][i]);
+                allButtons_[joyStickButtons_[iDev][i].groupName_ + "." + joyStickButtons_[iDev][i].name_] = &(joyStickButtons_[iDev][i]);
             for (unsigned int i = 0; i < JoyStickAxisCode::numberOfAxes * 2; i++)
+            {
                 allButtons_[joyStickAxes_[iDev][i].name_] = &(joyStickAxes_[iDev][i]);
+                allButtons_[joyStickAxes_[iDev][i].groupName_ + "." + joyStickAxes_[iDev][i].name_] = &(joyStickAxes_[iDev][i]);
                 allHalfAxes_.push_back(&(joyStickAxes_[iDev][i]));
+            }
 …
     void KeyBinder::resetJoyStickAxes()
+    {
         for (unsigned int iDev = 0; iDev < numberOfJoySticks_; ++iDev)
+        for (unsigned int iDev = 0; iDev < joySticks_.size(); ++iDev)
+        {
             for (unsigned int i = 0; i < JoyStickAxisCode::numberOfAxes * 2; i++)
 …
+    }
     void KeyBinder::updateMouse(float dt)
+    void KeyBinder::mouseUpdated(float dt)
+    {
         if (bDeriveMouseInput_)
 …
+    }
     void KeyBinder::updateJoyStick(float dt, unsigned int joyStick)
+    void KeyBinder::joyStickUpdated(unsigned int joyStick, float dt)
+    {
         for (unsigned int i = 0; i < JoyStickAxisCode::numberOfAxes * 2; i++)
 …
+    }
+    void KeyBinder::joyStickAxisMoved(unsigned int joyStickID, unsigned int axis, float value)
+    {
+        int i = axis * 2;
+    void KeyBinder::axisMoved(unsigned int device, unsigned int axisID, float value)
+    {
+        int i = axisID * 2;
+        JoyStickAxisVector& axis = joyStickAxes_[device];
         if (value < 0)
+        {
             joyStickAxes_[joyStickID][i].absVal_ = -value;
             joyStickAxes_[joyStickID][i].relVal_ = -value;
             joyStickAxes_[joyStickID][i].hasChanged_ = true;
             if (joyStickAxes_[joyStickID][i + 1].absVal_ > 0.0f)
+            {
                 joyStickAxes_[joyStickID][i + 1].absVal_ = -0.0f;
                 joyStickAxes_[joyStickID][i + 1].relVal_ = -0.0f;
                 joyStickAxes_[joyStickID][i + 1].hasChanged_ = true;
+            axis[i].absVal_ = -value;
+            axis[i].relVal_ = -value;
+            axis[i].hasChanged_ = true;
+            if (axis[i + 1].absVal_ > 0.0f)
+            {
+                axis[i + 1].absVal_ = -0.0f;
+                axis[i + 1].relVal_ = -0.0f;
+                axis[i + 1].hasChanged_ = true;
+            }
+        }
         else
+        {
             joyStickAxes_[joyStickID][i + 1].absVal_ = value;
             joyStickAxes_[joyStickID][i + 1].relVal_ = value;
             joyStickAxes_[joyStickID][i + 1].hasChanged_ = true;
             if (joyStickAxes_[joyStickID][i].absVal_ > 0.0f)
+            {
                 joyStickAxes_[joyStickID][i].absVal_ = -0.0f;
                 joyStickAxes_[joyStickID][i].relVal_ = -0.0f;
                 joyStickAxes_[joyStickID][i].hasChanged_ = true;
+            axis[i + 1].absVal_ = value;
+            axis[i + 1].relVal_ = value;
+            axis[i + 1].hasChanged_ = true;
+            if (axis[i].absVal_ > 0.0f)
+            {
+                axis[i].absVal_ = -0.0f;
+                axis[i].relVal_ = -0.0f;
+                axis[i].hasChanged_ = true;
+            }
+        }

code/trunk/src/core/input/KeyBinder.h

-                      r3196
+                      r3327
 #define _KeyBinder_H__
 #include "core/CorePrereqs.h"
+#include "InputPrereqs.h"
 #include <cassert>
 …
 #include <vector>
 #include "InputInterfaces.h"
+#include "InputHandler.h"
 #include "Button.h"
 #include "HalfAxis.h"
 #include "InputCommands.h"
 #include "JoyStickDeviceNumberListener.h"
+#include "JoyStickQuantityListener.h"
 namespace orxonox
 …
         Manages the key bindings.
     */
+    class _CoreExport KeyBinder : public KeyHandler, public MouseHandler, public JoyStickHandler,
+                                  public JoyStickDeviceNumberListener
+    class _CoreExport KeyBinder : public InputHandler, public JoyStickQuantityListener
+    {
     public:
 …
     protected: // functions
+        void updateInput(float dt);
+        void updateKey(float dt) { }
+        void updateMouse(float dt);
+        void updateJoyStick(float dt, unsigned int joyStick);
+        void allDevicesUpdated(float dt);
+        void mouseUpdated(float dt);
+        void joyStickUpdated(unsigned int joyStick, float dt);
         // internal
         void tickHalfAxis(HalfAxis& halfAxis);
         void buttonThresholdChanged();
         // from JoyStickDeviceNumberListener interface
         virtual void JoyStickDeviceNumberChanged(unsigned int value);
+        // from JoyStickQuantityListener interface
+        virtual void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
         void initialiseJoyStickBindings();
         void compilePointerLists();
         void keyPressed (const KeyEvent& evt);
         void keyReleased(const KeyEvent& evt);
         void keyHeld    (const KeyEvent& evt);
         void mouseButtonPressed (MouseButtonCode::ByEnum id);
         void mouseButtonReleased(MouseButtonCode::ByEnum id);
         void mouseButtonHeld    (MouseButtonCode::ByEnum id);
         void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize);
         void mouseScrolled      (int abs, int rel);
         void joyStickButtonPressed (unsigned int joyStickID, JoyStickButtonCode::ByEnum id);
         void joyStickButtonReleased(unsigned int joyStickID, JoyStickButtonCode::ByEnum id);
         void joyStickButtonHeld    (unsigned int joyStickID, JoyStickButtonCode::ByEnum id);
         void joyStickAxisMoved     (unsigned int joyStickID, unsigned int axis, float value);
+        void buttonPressed (const KeyEvent& evt);
+        void buttonReleased(const KeyEvent& evt);
+        void buttonHeld    (const KeyEvent& evt);
+        void buttonPressed (MouseButtonCode::ByEnum button);
+        void buttonReleased(MouseButtonCode::ByEnum button);
+        void buttonHeld    (MouseButtonCode::ByEnum button);
+        void mouseMoved    (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize);
+        void mouseScrolled (int abs, int rel);
+        void buttonPressed (unsigned int device, JoyStickButtonCode::ByEnum button);
+        void buttonReleased(unsigned int device, JoyStickButtonCode::ByEnum button);
+        void buttonHeld    (unsigned int device, JoyStickButtonCode::ByEnum button);
+        void axisMoved     (unsigned int device, unsigned int axis, float value);
     protected: // variables
         //! Currently active joy sticks
         unsigned int numberOfJoySticks_;
+        std::vector<JoyStick*>  joySticks_;
         //! Actual key bindings for keys on the keyboard
 …
     };
     inline void KeyBinder::keyPressed (const KeyEvent& evt)
     { assert(!keys_[evt.key].name_.empty()); keys_[evt.key].execute(KeybindMode::OnPress); }
     inline void KeyBinder::keyReleased(const KeyEvent& evt)
     { assert(!keys_[evt.key].name_.empty()); keys_[evt.key].execute(KeybindMode::OnRelease); }
     inline void KeyBinder::keyHeld    (const KeyEvent& evt)
     { assert(!keys_[evt.key].name_.empty()); keys_[evt.key].execute(KeybindMode::OnHold); }
     inline void KeyBinder::mouseButtonPressed (MouseButtonCode::ByEnum id)
     { mouseButtons_[id].execute(KeybindMode::OnPress); }
     inline void KeyBinder::mouseButtonReleased(MouseButtonCode::ByEnum id)
     { mouseButtons_[id].execute(KeybindMode::OnRelease); }
     inline void KeyBinder::mouseButtonHeld    (MouseButtonCode::ByEnum id)
     { mouseButtons_[id].execute(KeybindMode::OnHold); }
     inline void KeyBinder::joyStickButtonPressed (unsigned int joyStickID, JoyStickButtonCode::ByEnum id)
     { joyStickButtons_[joyStickID][id].execute(KeybindMode::OnPress); }
     inline void KeyBinder::joyStickButtonReleased(unsigned int joyStickID, JoyStickButtonCode::ByEnum id)
     { joyStickButtons_[joyStickID][id].execute(KeybindMode::OnRelease); }
     inline void KeyBinder::joyStickButtonHeld    (unsigned int joyStickID, JoyStickButtonCode::ByEnum id)
     { joyStickButtons_[joyStickID][id].execute(KeybindMode::OnHold); }
     inline void KeyBinder::updateInput(float dt)
+    inline void KeyBinder::buttonPressed (const KeyEvent& evt)
+    { assert(!keys_[evt.getKeyCode()].name_.empty()); keys_[evt.getKeyCode()].execute(KeybindMode::OnPress); }
+    inline void KeyBinder::buttonReleased(const KeyEvent& evt)
+    { assert(!keys_[evt.getKeyCode()].name_.empty()); keys_[evt.getKeyCode()].execute(KeybindMode::OnRelease); }
+    inline void KeyBinder::buttonHeld    (const KeyEvent& evt)
+    { assert(!keys_[evt.getKeyCode()].name_.empty()); keys_[evt.getKeyCode()].execute(KeybindMode::OnHold); }
+    inline void KeyBinder::buttonPressed (MouseButtonCode::ByEnum button)
+    { mouseButtons_[button].execute(KeybindMode::OnPress); }
+    inline void KeyBinder::buttonReleased(MouseButtonCode::ByEnum button)
+    { mouseButtons_[button].execute(KeybindMode::OnRelease); }
+    inline void KeyBinder::buttonHeld    (MouseButtonCode::ByEnum button)
+    { mouseButtons_[button].execute(KeybindMode::OnHold); }
+    inline void KeyBinder::buttonPressed (unsigned int device, JoyStickButtonCode::ByEnum button)
+    { joyStickButtons_[device][button].execute(KeybindMode::OnPress); }
+    inline void KeyBinder::buttonReleased(unsigned int device, JoyStickButtonCode::ByEnum button)
+    { joyStickButtons_[device][button].execute(KeybindMode::OnRelease); }
+    inline void KeyBinder::buttonHeld    (unsigned int device, JoyStickButtonCode::ByEnum button)
+    { joyStickButtons_[device][button].execute(KeybindMode::OnHold); }
+    inline void KeyBinder::allDevicesUpdated(float dt)
+    {
         // execute all buffered bindings (additional parameter)

code/trunk/src/core/input/KeyDetector.cc

r3196	r3327
26	26	*
27	27	*/
28
29		/**
30		~~@file~~
31		~~@brief~~
32		~~Implementation of the different input handlers.~~
33		*/
34	28
35	29	#include "KeyDetector.h"
…	…
68	62	for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
69	63	{
70		it->second->bindingString_ = callbackCommand_ + it->second->name_;
	64	it->second->bindingString_ = callbackCommand_ + it->second->groupName_ + "." + it->second->name_;
71	65	it->second->parse();
72	66	}
73	67	}
74	68
75		void KeyDetector::JoyStick~~DeviceNumberChanged(unsigned int value~~)
	69	void KeyDetector::JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList)
76	70	{
77		KeyBinder::JoyStick~~DeviceNumberChanged(value~~);
	71	KeyBinder::JoyStickQuantityChanged(joyStickList);
78	72	setCallbackCommand(callbackCommand_);
79	73	}

code/trunk/src/core/input/KeyDetector.h

-                      r3196
+                      r3327
  */
-/**
-@file
-@brief
-    Different definitions of input processing.
-*/
 #ifndef _KeyDetector_H__
 #define _KeyDetector_H__
 #include "core/CorePrereqs.h"
+#include "InputPrereqs.h"
 #include <string>
 …
         ~KeyDetector();
         void setCallbackCommand(const std::string& command);
         void JoyStickDeviceNumberChanged(unsigned int value);
+        void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
     private:

code/trunk/src/core/input/Keyboard.h

-                      r3276
+                      r3327
 #include "InputPrereqs.h"
+#include "InputHandler.h"
 #include "InputDevice.h"
 namespace orxonox
+{
+    //! Template parameter collection for the base class
+    struct KeyboardTraits
+    {
+        typedef Keyboard DeviceClass;
+        typedef OIS::Keyboard OISDeviceClass;
+        typedef KeyEvent ButtonType;
+        typedef KeyEvent& ButtonTypeParam;
+        static const OIS::Type OISDeviceValue = OIS::OISKeyboard;
+    };
     /**
     @brief
 …
     public:
+        Keyboard(unsigned int id) : super(id), modifiers_(0) { }
+        //! Only resets the keyboard modifiers. Initialising is done in the base class.
+        Keyboard(unsigned int id, OIS::InputManager* oisInputManager) : super(id, oisInputManager), modifiers_(0) { }
         ~Keyboard() { }
     private:
         // TODO: Do we need to reset the modifiers?
         void clearBuffersImpl() { }
+        //! Resets the keyboard modifiers
+        void clearBuffersImpl() { this->modifiers_ = 0; }
         //! Translates the KeyHandle to a KeyEvent
+        KeyEvent& getButtonEventArg(KeyEvent& button) { button.setModifiers(modifiers_); return button; }
+        KeyEvent& getButtonEventArg(KeyEvent& button)
+        {
+            button.setModifiers(modifiers_);
+            return button;
+        }
         bool keyPressed(const OIS::KeyEvent& arg);
         bool keyReleased(const OIS::KeyEvent& arg);
+        //! Returns the class name as string
+        static std::string getClassNameImpl() { return "Keyboard"; }
         //! Bit mask representing keyboard modifiers

code/trunk/src/core/input/Mouse.cc

-                      r3276
+                      r3327
 #include <ois/OISMouse.h>
+#include <boost/foreach.hpp>
+#include "core/ConsoleCommand.h"
+#include "core/CoreIncludes.h"
 #include "InputState.h"
-#include "core/ConsoleCommand.h"
-// HACK (include this as last, X11 seems to define some macros...)
 #ifdef ORXONOX_PLATFORM_LINUX
+#  include <ois/linux/LinuxMouse.h>
+// include this as last, X11 seems to define some macros...
+#include <ois/linux/LinuxMouse.h>
 #endif
 namespace orxonox
+{
     Mouse::Mouse(unsigned int id, unsigned int windowWidth, unsigned int windowHeight)
         : super(id)
+    Mouse::Mouse(unsigned int id, OIS::InputManager* oisInputManager)
+        : super(id, oisInputManager)
+    {
+        this->setMouseClipping(windowWidth, windowHeight);
+        // HACK:
+        instancePointer_s = this;
+    }
+        RegisterRootObject(Mouse);
+        this->windowResized(this->getWindowWidth(), this->getWindowHeight());
+    void Mouse::setMouseClipping(unsigned int width, unsigned int height)
+    {
         oisDevice_->getMouseState().width  = width;
         oisDevice_->getMouseState().height = height;
+    }
     unsigned int Mouse::getClippingWidth() const
+    {
         return oisDevice_->getMouseState().width;
+    }
     unsigned int Mouse::getClippingHeight() const
+    {
+        return oisDevice_->getMouseState().height;
+#ifdef ORXONOX_PLATFORM_LINUX
+        {
+            // Mouse grab console command
+            FunctorMember<Mouse>* functor = createFunctor(&Mouse::grab);
+            functor->setObject(this);
+            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "grab"), false);
+        }
+        {
+            // Mouse ungrab console command
+            FunctorMember<Mouse>* functor = createFunctor(&Mouse::ungrab);
+            functor->setObject(this);
+            this->getIdentifier()->addConsoleCommand(createConsoleCommand(functor, "ungrab"), false);
+        }
+#endif
+    }
 …
             IntVector2 rel(e.state.X.rel, e.state.Y.rel);
             IntVector2 clippingSize(e.state.width, e.state.height);
             BOOST_FOREACH(InputState* state, inputStates_)
                 state->mouseMoved(abs, rel, clippingSize);
+            for (unsigned int i = 0; i < inputStates_.size(); ++i)
+                inputStates_[i]->mouseMoved(abs, rel, clippingSize);
+        }
 …
         if (e.state.Z.rel != 0)
+        {
             BOOST_FOREACH(InputState* state, inputStates_)
                 state->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
+            for (unsigned int i = 0; i < inputStates_.size(); ++i)
+                inputStates_[i]->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
+        }
 …
+    }
+    // ############################################################
+    // #####                   ugly hacks                     #####
+    // ##########                                        ##########
+    // ############################################################
+    // HACK:
+    SetConsoleCommand(Mouse, setMouseClipping_s, false);
+#ifdef ORXONOX_PLATFORM_LINUX
+    SetConsoleCommand(Mouse, grabMouse, true);
+    SetConsoleCommand(Mouse, ungrabMouse, true);
+#endif
+    Mouse* Mouse::instancePointer_s = NULL;
+    void Mouse::windowResized(unsigned int newWidth, unsigned int newHeight)
+    {
+        oisDevice_->getMouseState().width  = newWidth;
+        oisDevice_->getMouseState().height = newHeight;
+    }
 #ifdef ORXONOX_PLATFORM_LINUX
     void Mouse::grabMouse()
+    void Mouse::grab()
+    {
         OIS::LinuxMouse* linuxMouse = dynamic_cast<OIS::LinuxMouse*>(instancePointer_s->oisDevice_);
+        OIS::LinuxMouse* linuxMouse = dynamic_cast<OIS::LinuxMouse*>(oisDevice_);
         assert(linuxMouse);
         linuxMouse->grab(true);
+    }
     void Mouse::ungrabMouse()
+    void Mouse::ungrab()
+    {
         OIS::LinuxMouse* linuxMouse = dynamic_cast<OIS::LinuxMouse*>(instancePointer_s->oisDevice_);
+        OIS::LinuxMouse* linuxMouse = dynamic_cast<OIS::LinuxMouse*>(oisDevice_);
         assert(linuxMouse);
         linuxMouse->grab(false);

code/trunk/src/core/input/Mouse.h

-                      r3276
+                      r3327
 #include "InputPrereqs.h"
 #include "InputDevice.h"
+#include "core/WindowEventListener.h"
 namespace orxonox
+{
+    //! Template parameter collection for the base class
+    struct MouseTraits
+    {
+        typedef Mouse DeviceClass;
+        typedef OIS::Mouse OISDeviceClass;
+        typedef MouseButtonCode::ByEnum ButtonType;
+        typedef MouseButtonCode::ByEnum ButtonTypeParam;
+        static const OIS::Type OISDeviceValue = OIS::OISMouse;
+    };
     /**
     @brief
 …
         : public InputDeviceTemplated<MouseTraits>
         , public OIS::MouseListener
+        , public WindowEventListener
+    {
         friend class InputDeviceTemplated<MouseTraits>;
 …
     public:
+        Mouse(unsigned int id, unsigned int windowWidth, unsigned int windowHeight);
+        //! Only sets the clipping size. Initialising is done in the base class.
+        Mouse(unsigned int id, OIS::InputManager* oisInputManager);
         ~Mouse() { }
-        /**
-        @brief
-            Adjusts the mouse window metrics.
-            This method has to be called every time the size of the window changes.
-        */
-        void setMouseClipping(unsigned int width, unsigned int height);
-        unsigned int getClippingWidth() const;
-        unsigned int getClippingHeight() const;
-        // HACK!
-        static void setMouseClipping_s(unsigned int width, unsigned int height)
-            { instancePointer_s->setMouseClipping(width, height); }
-        void setConfigValues() { }
 #ifdef ORXONOX_PLATFORM_LINUX
         // HACK!
         static void grabMouse();
         static void ungrabMouse();
+        // TODO: Make this a feature rather than a hack
+        void grab();
+        void ungrab();
 #endif
     private:
-        // TODO: Do we need to reset the mouse position?
-        void clearBuffersImpl() { }
         //! OIS event handler
         bool mousePressed(const OIS::MouseEvent &arg, OIS::MouseButtonID id)
 …
         bool mouseMoved(const OIS::MouseEvent &arg);
+        // HACK:
+        static Mouse* instancePointer_s;
+        void windowResized(unsigned int newWidth, unsigned int newHeight);
+        // Returns the class name as string
+        static std::string getClassNameImpl() { return "Mouse"; }
     };
+}

code/trunk/src/orxonox/GraphicsManager.cc

-                      r3323
+                      r3327
 #include "core/Game.h"
 #include "core/GameMode.h"
+#include "core/WindowEventListener.h"
 #include "tools/ParticleInterface.h"
-#include "interfaces/WindowEventListener.h"
 // HACK!
 …
     using boost::shared_ptr;
+    class _OrxonoxExport OgreWindowEventListener : public Ogre::WindowEventListener
+    {
+        void windowResized     (Ogre::RenderWindow* rw);
+        void windowFocusChange (Ogre::RenderWindow* rw);
+        void windowClosed      (Ogre::RenderWindow* rw);
+        //void windowMoved       (Ogre::RenderWindow* rw);
+    class OgreWindowEventListener : public Ogre::WindowEventListener
+    {
+    public:
+        void windowResized     (Ogre::RenderWindow* rw)
+            { orxonox::WindowEventListener::resizeWindow(rw->getWidth(), rw->getHeight()); }
+        void windowFocusChange (Ogre::RenderWindow* rw)
+            { orxonox::WindowEventListener::changeWindowFocus(); }
+        void windowClosed      (Ogre::RenderWindow* rw)
+            { orxonox::Game::getInstance().stop(); }
+        void windowMoved       (Ogre::RenderWindow* rw)
+            { orxonox::WindowEventListener::moveWindow(); }
     };
 …
         this->renderWindow_ = ogreRoot_->initialise(true, "Orxonox");
+        this->ogreWindowEventListener_->windowResized(renderWindow_);
         Ogre::WindowEventUtilities::addWindowEventListener(this->renderWindow_, ogreWindowEventListener_);
 …
         this->renderWindow_->writeContentsToTimestampedFile(Core::getLogPathString() + "screenShot_", ".jpg");
+    }
-    /****** OgreWindowEventListener ******/
-    void OgreWindowEventListener::windowResized(Ogre::RenderWindow* rw)
+    {
-        for (ObjectList<orxonox::WindowEventListener>::iterator it
-            = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
-            it->windowResized(rw->getWidth(), rw->getHeight());
+    }
-    void OgreWindowEventListener::windowFocusChange(Ogre::RenderWindow* rw)
+    {
-        for (ObjectList<orxonox::WindowEventListener>::iterator it
-            = ObjectList<orxonox::WindowEventListener>::begin(); it; ++it)
-            it->windowFocusChanged();
+    }
-    void OgreWindowEventListener::windowClosed(Ogre::RenderWindow* rw)
+    {
-        Game::getInstance().stop();
+    }
+}

code/trunk/src/orxonox/OrxonoxPrereqs.h

r3280	r3327
92	92	class Level;
93	93	class Scene;
	94	class Tickable;
94	95
95	96	class AddQuest;

code/trunk/src/orxonox/gamestates/GSGraphics.cc

-                      r3280
+                      r3327
 #include <OgreRenderWindow.h>
 #include "core/ConfigValueIncludes.h"
+#include "util/Convert.h"
 #include "core/Clock.h"
+#include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
 #include "core/Core.h"
-#include "core/CoreIncludes.h"
 #include "core/Game.h"
 #include "core/GameMode.h"
 #include "core/input/InputManager.h"
 #include "core/input/KeyBinder.h"
 #include "core/input/SimpleInputState.h"
+#include "core/input/InputState.h"
 #include "core/Loader.h"
 #include "core/XMLFile.h"
 …
         , debugOverlay_(0)
+    {
-        RegisterRootObject(GSGraphics);
+    }
     GSGraphics::~GSGraphics()
+    {
+    }
-    /**
-    @brief
-        this function does nothing
-        Indeed. Here goes nothing.
-    */
-    void GSGraphics::setConfigValues()
+    {
+    }
 …
         GameMode::setShowsGraphics(true);
-        setConfigValues();
         // Load OGRE including the render window
         this->graphicsManager_ = new GraphicsManager();
 …
         // Calls the InputManager which sets up the input devices.
+        inputManager_ = new InputManager();
+        inputManager_->initialise(windowHnd, renderWindow->getWidth(), renderWindow->getHeight(), true);
+        inputManager_ = new InputManager(windowHnd);
         // load master key bindings
         masterInputState_ = InputManager::getInstance().createInputState<SimpleInputState>("master", true);
+        masterInputState_ = InputManager::getInstance().createInputState("master", true);
         masterKeyBinder_ = new KeyBinder();
         masterKeyBinder_->loadBindings("masterKeybindings.ini");
 …
         // Load the InGameConsole
         console_ = new InGameConsole();
         console_->initialise(renderWindow->getWidth(), renderWindow->getHeight());
+        console_->initialise();
         // load the CEGUI interface
 …
         // enable master input
         InputManager::getInstance().requestEnterState("master");
+        InputManager::getInstance().enterState("master");
+    }
 …
         masterInputState_->setHandler(0);
         InputManager::getInstance().requestDestroyState("master");
+        InputManager::getInstance().destroyState("master");
         delete this->masterKeyBinder_;
 …
         this->graphicsManager_->update(time);
+    }
-    /**
-    @brief
-        Window has resized.
-    @param rw
-        The render window it occured in
-    @note
-        GraphicsManager has a render window stored itself. This is the same
-        as rw. But we have to be careful when using multiple render windows!
-    */
-    void GSGraphics::windowResized(unsigned int newWidth, unsigned int newHeight)
+    {
-        // OIS needs this under linux even if we only use relative input measurement.
-        if (this->inputManager_)
-            this->inputManager_->setWindowExtents(newWidth, newHeight);
+    }
-    /**
-    @brief
-        Window focus has changed.
-    @param rw
-        The render window it occured in
-    */
-    void GSGraphics::windowFocusChanged()
+    {
-        // instruct InputManager to clear the buffers (core library so we cannot use the interface)
-        if (this->inputManager_)
-            this->inputManager_->clearBuffers();
+    }
+}

code/trunk/src/orxonox/gamestates/GSGraphics.h

-                      r3280
+                      r3327
 #include "OrxonoxPrereqs.h"
 #include "core/GameState.h"
-#include "interfaces/WindowEventListener.h"
 namespace orxonox
 …
         This game state is only left out if we start a dedicated server where no graphics are present.
     */
     class _OrxonoxExport GSGraphics : public GameState, public WindowEventListener
+    class _OrxonoxExport GSGraphics : public GameState
+    {
     public:
         GSGraphics(const GameStateConstrParams& params);
         ~GSGraphics();
-        void setConfigValues();
         void activate();
 …
     private:
-        // Window events from WindowEventListener
-        void windowResized(unsigned int newWidth, unsigned int newHeight);
-        void windowFocusChanged();
         // managed singletons
         InputManager*         inputManager_;        //!< Reference to input management
 …
         KeyBinder*            masterKeyBinder_;     //!< Key binder for master key bindings
         SimpleInputState*     masterInputState_;    //!< Special input state for master input
+        InputState*           masterInputState_;    //!< Special input state for master input
         XMLFile*              debugOverlay_;
         ConsoleCommand*       ccToggleGUI_;         //!< Console command to toggle GUI

code/trunk/src/orxonox/gamestates/GSLevel.cc

-                      r3280
+                      r3327
 #include "core/input/InputManager.h"
 #include "core/input/SimpleInputState.h"
+#include "core/input/InputState.h"
 #include "core/input/KeyBinder.h"
 #include "core/Clock.h"
 …
         if (GameMode::showsGraphics())
+        {
             gameInputState_ = InputManager::getInstance().createInputState<SimpleInputState>("game");
+            gameInputState_ = InputManager::getInstance().createInputState("game");
             keyBinder_ = new KeyBinder();
             keyBinder_->loadBindings("keybindings.ini");
             gameInputState_->setHandler(keyBinder_);
             guiMouseOnlyInputState_ = InputManager::getInstance().createInputState<SimpleInputState>("guiMouseOnly");
+            guiMouseOnlyInputState_ = InputManager::getInstance().createInputState("guiMouseOnly");
             guiMouseOnlyInputState_->setMouseHandler(GUIManager::getInstancePtr());
             guiKeysOnlyInputState_ = InputManager::getInstance().createInputState<SimpleInputState>("guiKeysOnly");
+            guiKeysOnlyInputState_ = InputManager::getInstance().createInputState("guiKeysOnly");
             guiKeysOnlyInputState_->setKeyHandler(GUIManager::getInstancePtr());
 …
             // level is loaded: we can start capturing the input
             InputManager::getInstance().requestEnterState("game");
+            InputManager::getInstance().enterState("game");
+        }
+    }
 …
             GUIManager::getInstance().showGUI("inGameTest");
             GUIManager::getInstance().executeCode("showCursor()");
             InputManager::getInstance().requestEnterState("guiMouseOnly");
+            InputManager::getInstance().enterState("guiMouseOnly");
+        }
         else
 …
             GUIManager::getInstance().executeCode("hideGUI(\"inGameTest\")");
             GUIManager::getInstance().executeCode("hideCursor()");
             InputManager::getInstance().requestLeaveState("guiMouseOnly");
+            InputManager::getInstance().leaveState("guiMouseOnly");
+        }
+    }
 …
         if (GameMode::showsGraphics())
             InputManager::getInstance().requestLeaveState("game");
+            InputManager::getInstance().leaveState("game");
         if (GameMode::isMaster())
 …
             guiMouseOnlyInputState_->setHandler(0);
             guiKeysOnlyInputState_->setHandler(0);
             InputManager::getInstance().requestDestroyState("game");
+            InputManager::getInstance().destroyState("game");
             if (this->keyBinder_)
+            {
 …
+                {
                     COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
                     InputManager::getInstance().requestEnterState("detector");
+                    InputManager::getInstance().enterState("detector");
                     bindingString = command;
                     bTemporarySaved = bTemporary;
 …
                     COUT(0) << "Binding string \"" << bindingString << "\" on key '" << name << "'" << std::endl;
                     this->keyBinder_->setBinding(bindingString, name, bTemporarySaved);
                     InputManager::getInstance().requestLeaveState("detector");
+                    InputManager::getInstance().leaveState("detector");
                     bound = true;
+                }

code/trunk/src/orxonox/gamestates/GSLevel.h

-                      r3280
+                      r3327
         KeyBinder*            keyBinder_;               //!< tool that loads and manages the input bindings
         SimpleInputState*     gameInputState_;          //!< input state for normal ingame playing
         SimpleInputState*     guiMouseOnlyInputState_;  //!< input state if we only need the mouse to use the GUI
         SimpleInputState*     guiKeysOnlyInputState_;   //!< input state if we only need the keys to use the GUI
+        InputState*           gameInputState_;          //!< input state for normal ingame playing
+        InputState*           guiMouseOnlyInputState_;  //!< input state if we only need the mouse to use the GUI
+        InputState*           guiKeysOnlyInputState_;   //!< input state if we only need the keys to use the GUI
         Radar*                radar_;                   //!< represents the Radar (not the HUD part)
         CameraManager*        cameraManager_;           //!< camera manager for this level

code/trunk/src/orxonox/gamestates/GSMainMenu.cc

-                      r3280
+                      r3327
 #include "core/input/InputManager.h"
 #include "core/input/SimpleInputState.h"
+#include "core/input/InputState.h"
 #include "core/Game.h"
 #include "core/Clock.h"
 …
     void GSMainMenu::activate()
+    {
         inputState_ = InputManager::getInstance().createInputState<SimpleInputState>("mainMenu");
+        inputState_ = InputManager::getInstance().createInputState("mainMenu");
         inputState_->setHandler(GUIManager::getInstancePtr());
         inputState_->setJoyStickHandler(&InputManager::EMPTY_HANDLER);
+        inputState_->setJoyStickHandler(&InputHandler::EMPTY);
         // create an empty Scene
 …
+        }
         InputManager::getInstance().requestEnterState("mainMenu");
+        InputManager::getInstance().enterState("mainMenu");
         this->ambient_ = new SoundMainMenu();
 …
         delete this->ambient_;
         InputManager::getInstance().requestLeaveState("mainMenu");
         InputManager::getInstance().requestDestroyState("mainMenu");
+        InputManager::getInstance().leaveState("mainMenu");
+        InputManager::getInstance().destroyState("mainMenu");
         GUIManager::getInstance().setCamera(0);

code/trunk/src/orxonox/gamestates/GSMainMenu.h

r3280	r3327
53	53
54	54	private:
55		SimpleInputState* inputState_;
	55	InputState* inputState_;
56	56	Scene* scene_;
57	57	Ogre::Camera* camera_;

code/trunk/src/orxonox/gui/GUIManager.cc

r3287	r3327
69	69	void logEvent(const CEGUI::String& message, CEGUI::LoggingLevel level = CEGUI::Standard)
70	70	{
71		int orxonoxLevel;
	71	int orxonoxLevel = CEGUI::Standard;
72	72	switch (level)
73	73	{
…	…
366	366	void GUIManager::keyPressed(const KeyEvent& evt)
367	367	{
368		guiSystem_->injectKeyDown(evt.key); guiSystem_->injectChar(evt.text);
	368	guiSystem_->injectKeyDown(evt.getKeyCode());
	369	guiSystem_->injectChar(evt.getText());
369	370	}
370	371	void GUIManager::keyReleased(const KeyEvent& evt)
371	372	{
372		guiSystem_->injectKeyUp(evt.~~key~~);
	373	guiSystem_->injectKeyUp(evt.getKeyCode());
373	374	}
374	375
…	…
382	383	It is for CEGUI to process the event.
383	384	*/
384		void GUIManager::~~mouseB~~uttonPressed(MouseButtonCode::ByEnum id)
	385	void GUIManager::buttonPressed(MouseButtonCode::ByEnum id)
385	386	{
386	387	try
…	…
404	405	It is for CEGUI to process the event.
405	406	*/
406		void GUIManager::~~mouseB~~uttonReleased(MouseButtonCode::ByEnum id)
	407	void GUIManager::buttonReleased(MouseButtonCode::ByEnum id)
407	408	{
408	409	try

code/trunk/src/orxonox/gui/GUIManager.h

-                      r3280
+                      r3327
 #include "util/OgreForwardRefs.h"
 #include "core/input/InputInterfaces.h"
+#include "core/input/InputHandler.h"
 // tolua_begin
 …
     class _OrxonoxExport GUIManager
 // tolua_end
         : public KeyHandler, public MouseHandler
+        : public InputHandler
 // tolua_begin
+    {
 …
         void keyPressed (const KeyEvent& evt);
         void keyReleased(const KeyEvent& evt);
-        void keyHeld    (const KeyEvent& evt) { }
         // mouseHandler functions
+        void mouseButtonPressed (MouseButtonCode::ByEnum id);
+        void mouseButtonReleased(MouseButtonCode::ByEnum id);
+        void mouseButtonHeld    (MouseButtonCode::ByEnum id) { }
+        void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize);
+        void mouseScrolled      (int abs, int rel);
+        void updateInput(float dt)  { }
+        void updateKey  (float dt)  { }
+        void updateMouse(float dt)  { }
+        void buttonPressed (MouseButtonCode::ByEnum id);
+        void buttonReleased(MouseButtonCode::ByEnum id);
+        void mouseMoved    (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize);
+        void mouseScrolled (int abs, int rel);
         Ogre::RenderWindow*         renderWindow_;      //!< Ogre's render window to give CEGUI access to it

code/trunk/src/orxonox/interfaces/InterfaceCompilation.cc

-                      r3196
+                      r3327
 #include "Tickable.h"
 #include "TimeFactorListener.h"
-#include "WindowEventListener.h"
 #include "core/CoreIncludes.h"
 …
     //----------------------------
-    // WindowEventListener
-    //----------------------------
-    /**
-        @brief Constructor for the WindowEventListener.
-    */
-    WindowEventListener::WindowEventListener()
+    {
-        RegisterRootObject(WindowEventListener);
+    }
-    //----------------------------
     // Rewardable
     //----------------------------

code/trunk/src/orxonox/objects/pickup/PickupInventory.cc

-                      r3196
+                      r3327
             GUIManager::getInstance().executeCode("hideGUI(\"PickupInventory\")");
             GUIManager::getInstance().executeCode("hideCursor()");
             InputManager::getInstance().requestLeaveState("guiMouseOnly");
+            InputManager::getInstance().leaveState("guiMouseOnly");
+        }
         else
 …
             GUIManager::getInstance().showGUI("PickupInventory");
             GUIManager::getInstance().executeCode("showCursor()");
             InputManager::getInstance().requestEnterState("guiMouseOnly");
+            InputManager::getInstance().enterState("guiMouseOnly");
+        }
         PickupInventory::getSingleton()->setVisible(!PickupInventory::getSingleton()->isVisible());

code/trunk/src/orxonox/overlays/GUIOverlay.cc

r3301	r3327
70	70	str = out.str();
71	71	GUIManager::getInstance().executeCode("showCursor()");
72		InputManager::getInstance().~~requestE~~nterState("guiMouseOnly");
	72	InputManager::getInstance().enterState("guiMouseOnly");
73	73	GUIManager::getInstance().executeCode("showGUI(\"" + this->guiName_ + "\", " + str + ")");
74	74	}
…	…
77	77	GUIManager::getInstance().executeCode("hideGUI(\"" + this->guiName_ + "\")");
78	78	GUIManager::getInstance().executeCode("hideCursor()");
79		InputManager::getInstance().~~requestL~~eaveState("guiMouseOnly");
	79	InputManager::getInstance().leaveState("guiMouseOnly");
80	80	}
81	81	}

code/trunk/src/orxonox/overlays/OrxonoxOverlay.cc

-                      r3301
+                      r3327
 #include "core/XMLPort.h"
 #include "core/ConsoleCommand.h"
-#include "GraphicsManager.h"
 namespace orxonox
 …
         // Get aspect ratio from the render window. Later on, we get informed automatically
+        Ogre::RenderWindow* defaultWindow = GraphicsManager::getInstance().getRenderWindow();
+        this->windowAspectRatio_ = static_cast<float>(defaultWindow->getWidth()) / defaultWindow->getHeight();
+        this->windowAspectRatio_ = static_cast<float>(this->getWindowWidth()) / this->getWindowHeight();
         this->sizeCorrectionChanged();

code/trunk/src/orxonox/overlays/OrxonoxOverlay.h

r3196	r3327
42	42	#include "util/OgreForwardRefs.h"
43	43	#include "core/BaseObject.h"
44		#include "~~interfaces~~/WindowEventListener.h"
	44	#include "core/WindowEventListener.h"
45	45
46	46	namespace orxonox

code/trunk/src/orxonox/overlays/console/InGameConsole.cc

-                      r3301
+                      r3327
 #include "core/ConsoleCommand.h"
 #include "core/input/InputManager.h"
 #include "core/input/SimpleInputState.h"
+#include "core/input/InputState.h"
 #include "core/input/InputBuffer.h"
 …
         // destroy the input state previously created (InputBuffer gets destroyed by the Shell)
         InputManager::getInstance().requestDestroyState("console");
+        InputManager::getInstance().destroyState("console");
         Ogre::OverlayManager* ovMan = Ogre::OverlayManager::getSingletonPtr();
 …
             if (bHidesAllInput_)
+            {
                 inputState_->setMouseHandler(&InputManager::EMPTY_HANDLER);
                 inputState_->setJoyStickHandler(&InputManager::EMPTY_HANDLER);
+                inputState_->setMouseHandler(&InputHandler::EMPTY);
+                inputState_->setJoyStickHandler(&InputHandler::EMPTY);
+            }
             else
 …
         @brief Initializes the InGameConsole.
     */
     void InGameConsole::initialise(int windowWidth, int windowHeight)
+    void InGameConsole::initialise()
+    {
         // create the corresponding input state
         inputState_ = InputManager::getInstance().createInputState<SimpleInputState>("console", false, false, InputStatePriority::Console);
+        inputState_ = InputManager::getInstance().createInputState("console", false, false, InputStatePriority::Console);
         inputState_->setKeyHandler(Shell::getInstance().getInputBuffer());
         bHidesAllInputChanged();
 …
         this->consoleOverlayContainer_->addChild(this->consoleOverlayNoise_);
         this->windowResized(windowWidth, windowHeight);
+        this->windowResized(this->getWindowWidth(), this->getWindowWidth());
         // move overlay "above" the top edge of the screen
 …
+        {
             this->bActive_ = true;
             InputManager::getInstance().requestEnterState("console");
+            InputManager::getInstance().enterState("console");
             Shell::getInstance().registerListener(this);
 …
+        {
             this->bActive_ = false;
             InputManager::getInstance().requestLeaveState("console");
+            InputManager::getInstance().leaveState("console");
             Shell::getInstance().unregisterListener(this);

code/trunk/src/orxonox/overlays/console/InGameConsole.h

-                      r3196
+                      r3327
 #include "util/OgreForwardRefs.h"
 #include "core/Shell.h"
 #include "interfaces/WindowEventListener.h"
+#include "core/WindowEventListener.h"
 namespace orxonox
 …
         ~InGameConsole();
         void initialise(int windowWidth, int windowHeight);
+        void initialise();
         void destroy();
         void setConfigValues();
 …
         // input related
         SimpleInputState* inputState_;
+        InputState* inputState_;
         // config values

code/trunk/src/util/StringUtils.cc

-                      r3301
+                      r3327
         return std::string::npos;
+    }
+    /**
+        @brief Replaces individual charaters
+        @param str String to be manipulated
+        @param target Character to be replaced
+        @param replacement Replacement character
+        @return Number of replacements
+    */
+    _UtilExport size_t replaceCharacters(std::string& str, char target, char replacement)
+    {
+        size_t j = 0;
+        for (size_t i = 0; i < str.size(); ++i)
+        {
+            if (str[i] == target)
+            {
+                str[i] = replacement;
+                ++j;
+            }
+        }
+        return j;
+    }
+}

code/trunk/src/util/StringUtils.h

r3280	r3327
77	77	_UtilExport size_t getCommentPosition(const std::string& str);
78	78	_UtilExport size_t getNextCommentPosition(const std::string& str, size_t start = 0);
	79
	80	_UtilExport size_t replaceCharacters(std::string& str, char target, char replacement);
79	81	}
80	82

Context Navigation

Legend:

Download in other formats: