Changeset 1637 for code/branches/input/src/core

Timestamp:

Jul 20, 2008, 6:49:24 PM (16 years ago)

Author:

rgrieder

Message:

Finally! The InputManager is now working like I imagined it to. And it's even easier to use it as well.
A little explanation: Every time you change something about the input distribution, it is a change of 'state' represented by the class 'InputState'.
That can be for instance: "console", "game", "gui", etc. Every state has a name and a priority which describes who comes first. Now if one state doesn't handle mouse input or instance, then the one with the next lower priority gets it. To prevent that, you can add the 'EmptyHandler' to the state with setMouseHandler.
InputState is just an abstract base class. There are two classes implementing it: SimpleInputState and ExtendedInputState. The latter allows for multiple input handlers for one single device.

Basically, what you need to know is what you see in Orxonox.cc, InGameConsole.cc and Shell.cc.

Location:

code/branches/input/src/core

Files:

• CMakeLists.txt (modified) (2 diffs)
• CorePrereqs.h (modified) (2 diffs)
• Shell.cc (modified) (3 diffs)
• Shell.h (modified) (2 diffs)
• input/Button.cc (modified) (2 diffs)
• input/Button.h (modified) (1 diff)
• input/CalibratorCallback.cc (modified) (1 diff)
• input/CalibratorCallback.h (modified) (1 diff)
• input/ExtendedInputState.cc (added)
• input/ExtendedInputState.h (added)
• input/InputBuffer.cc (modified) (1 diff)
• input/InputBuffer.h (modified) (1 diff)
• input/InputInterfaces.h (modified) (7 diffs)
• input/InputManager.cc (modified) (51 diffs)
• input/InputManager.h (modified) (12 diffs)
• input/InputState.h (added)
• input/KeyBinder.cc (modified) (4 diffs)
• input/KeyBinder.h (modified) (2 diffs)
• input/KeyDetector.cc (modified) (2 diffs)
• input/KeyDetector.h (modified) (1 diff)
• input/SimpleInputState.cc (added)
• input/SimpleInputState.h (added)

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

@@ -41 +41 @@
   input/Button.cc
   input/CalibratorCallback.cc
+  input/ExtendedInputState.cc
   input/HalfAxis.cc
   input/InputBuffer.cc
@@ -47 +48 @@
   input/KeyBinder.cc
   input/KeyDetector.cc
+  input/SimpleInputState.cc
 
   tolua/tolua_bind.cc

code/branches/input/src/core/CorePrereqs.h

@@ -158 +158 @@
 
   // input
-  //class GUIInputHandler;
   class BaseCommand;
   class BufferedParamCommand;
   class Button;
   class CalibratorCallback;
+  class ExtendedInputState;
   class HalfAxis;
   class InputBuffer;
   class InputManager;
+  class InputState;
   class JoyStickHandler;
   class MouseHandler;
@@ -173 +174 @@
   class ParamCommand;
   class SimpleCommand;
+  class SimpleInputState;
 }
 

code/branches/input/src/core/Shell.cc

@@ -34 +34 @@
 #include "ConsoleCommand.h"
 #include "input/InputInterfaces.h"
+#include "input/SimpleInputState.h"
+#include "input/InputManager.h"
 
 #define SHELL_UPDATE_LISTENERS(function) \
@@ -57 +59 @@
         this->clearLines();
 
-        this->inputBuffer_ = 0;
-        this->setInputBuffer(new InputBuffer());
+        this->inputBuffer_ = new InputBuffer();
+        this->configureInputBuffer();
+        InputManager::createSimpleInputState("console", 40)->setKeyHandler(this->inputBuffer_);
 
         this->outputBuffer_.registerListener(this);
 
         this->setConfigValues();
+    }
+
+    Shell::~Shell()
+    {
+        SimpleInputState * inputState = dynamic_cast<SimpleInputState*>(InputManager::getState("console"));
+        if (inputState)
+        {
+            inputState->removeAndDestroyAllHandlers();
+            InputManager::destroyState("console");
+        }
     }
 
@@ -97 +110 @@
     }
 
-    void Shell::setInputBuffer(InputBuffer* buffer)
-    {
-        if (this->inputBuffer_)
-        {
-            this->inputBuffer_->unregisterListener(this);
-            // TODO: may be very dangerous. InputManager already deletes InputBuffer instance!!!
-            delete this->inputBuffer_;
-        }
-
-        this->inputBuffer_ = buffer;
+    void Shell::configureInputBuffer()
+    {
         this->inputBuffer_->registerListener(this, &Shell::inputChanged, true);
         this->inputBuffer_->registerListener(this, &Shell::execute, '\r', false);

code/branches/input/src/core/Shell.h

@@ -71 +71 @@
             void unregisterListener(ShellListener* listener);
 
-            void setInputBuffer(InputBuffer* buffer);
             inline InputBuffer& getInputBuffer()
                 { return (*this->inputBuffer_); }
@@ -105 +104 @@
             Shell();
             Shell(const Shell& other);
-            virtual ~Shell() {}
+            virtual ~Shell();
+
+            void configureInputBuffer();
 
             void addToHistory(const std::string& command);

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

@@ -88 +88 @@
                     '\\', false, '"', false, '(', ')', false, '\0');
 
-                unsigned int iToken = 0;
-
-                // for real axes, we can feed a ButtonThreshold argument as entire command
-                if (getLowercase(tokens[0]) == "buttonthreshold")
-                {
-                    if (tokens.size() == 1)
-                        continue;
-                    // may fail, but doesn't matter
-                    convertValue(&buttonThreshold_, tokens[1]);
-                    continue;
-                }
-
-                // first argument can be OnPress, OnHold OnRelease or nothing
                 KeybindMode::Enum mode = KeybindMode::None;
-                if (getLowercase(tokens[iToken]) == "onpress")
-                    mode = KeybindMode::OnPress,   iToken++;
-                if (getLowercase(tokens[iToken]) == "onrelease")
-                    mode = KeybindMode::OnRelease, iToken++;
-                if (getLowercase(tokens[iToken]) == "onhold")
-                    mode = KeybindMode::OnHold,    iToken++;
-
-                if (iToken == tokens.size())
-                    continue;
-
-                // second argument can be the amplitude for the case it as an axis command
-                // default amplitude is 1.0f
                 float paramModifier = 1.0f;
-                if (getLowercase(tokens[iToken]) == "scale")
-                {
-                    iToken++;
-                    if (iToken == tokens.size() || !convertValue(&paramModifier, tokens[iToken]))
-                    {
-                        COUT(2) << "Error while parsing key binding " << name_
-                                << ". Numeric expression expected afer 'AxisAmp', switching to default value"
-                                << std::endl;
+                std::string commandStr = "";
+
+                for (unsigned int iToken = 0; iToken < tokens.size(); ++iToken)
+                {
+                    std::string token = getLowercase(tokens[iToken]);
+
+                    if (token == "onpress")
+                        mode = KeybindMode::OnPress;
+                    else if (token == "onrelease")
+                        mode = KeybindMode::OnRelease;
+                    else if (token == "onhold")
+                        mode = KeybindMode::OnHold;
+                    else if (token == "buttonthreshold")
+                    {
+                        // for real axes, we can feed a ButtonThreshold argument
+                        ++iToken;
                         if (iToken == tokens.size())
                             continue;
-                    }
-                    iToken++;
-                }
-
-                // no more arguments expected except for the actual command
-                if (iToken == tokens.size())
+                        // may fail, but doesn't matter (default value already set)
+                        if (!convertValue(&buttonThreshold_, tokens[iToken + 1]))
+                            parseError("Could not parse 'ButtonThreshold' argument. \
+                                Switching to default value.", true);
+                    }
+                    else if (token == "scale")
+                    {
+                        ++iToken;
+                        if (iToken == tokens.size() || !convertValue(&paramModifier, tokens[iToken]))
+                            parseError("Could not parse 'scale' argument. Switching to default value.", true);
+                    }
+                    else
+                    {
+                        // no input related argument
+                        // we interpret everything from here as a command string
+                        while (iToken != tokens.size())
+                            commandStr += tokens[iToken++] + " ";
+                    }
+                }
+
+                if (commandStr == "")
+                {
+                    parseError("No command string given.", false);
                     continue;
-
-                std::string commandStr;
-                while (iToken != tokens.size())
-                    commandStr += tokens[iToken++] + " ";
+                }
 
                 // evaluate the command
                 CommandEvaluation eval = CommandExecutor::evaluate(commandStr);
                 if (!eval.isValid())
+                {
+                    parseError("Command evaluation failed.", true);
                     continue;
+                }
 
                 // check for param command
@@ -215 +215 @@
         return true;
     }
+
+    inline void Button::parseError(std::string message, bool serious)
+    {
+        if (serious)
+        {
+            COUT(2) << "Error while parsing binding for button/axis" << this->name_ << ". "
+                << message << std::endl;
+        }
+        else
+        {
+            COUT(3) << "Warning while parsing binding for button/axis" << this->name_ << ". "
+                << message << std::endl;
+        }
+    }
 }

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

@@ -64 +64 @@
         //! Note: This variable is here to have only one parse() function.
         float buttonThreshold_;
+
+    private:
+        void parseError(std::string message, bool serious);
     };
 }

code/branches/input/src/core/input/CalibratorCallback.cc

@@ -42 +42 @@
         if (evt.key == KeyCode::Return)
         {
-            InputManager::setInputState(InputManager::IS_NOCALIBRATE);
+            //InputManager::setInputState(InputManager::IS_NOCALIBRATE);
         }
     }

code/branches/input/src/core/input/CalibratorCallback.h

@@ -52 +52 @@
         void keyHeld    (const KeyEvent& evt) { }
 
-        void tickInput(float dt, const HandlerState &state) { }
+        void tickInput(float dt) { }
     };
 }

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

@@ -220 +220 @@
         @param dt Delta time
     */
-    void InputBuffer::tickInput(float dt, const HandlerState& state)
+    void InputBuffer::tickInput(float dt)
     {
         timeSinceKeyPressed_ += dt;

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

@@ -170 +170 @@
             void processKey (const KeyEvent &e);
 
-            void tickInput(float dt, const HandlerState& state);
+            void tickInput(float dt);
+            void tickInput(float dt, int device) { }
 
             std::string buffer_;

code/branches/input/src/core/input/InputInterfaces.h

@@ -38 +38 @@
 #include "core/CorePrereqs.h"
 
-#include "src/ois/OISKeyboard.h"
-#include "src/ois/OISMouse.h"
-#include "src/ois/OISJoyStick.h"
+#include "ois/OISKeyboard.h"
+#include "ois/OISMouse.h"
+#include "ois/OISJoyStick.h"
 #include "util/Math.h"
 
@@ -222 +222 @@
         };
     }
+    
+    namespace InputDevice
+    {
+        enum Enum
+        {
+            Keyboard,
+            Mouse,
+            JoyStick0,
+            JoyStick1,
+            JoyStick2,
+            JoyStick3,
+            // note: No problem if there are more joy sticks. This enum is just for convenience.
+        };
+    }
 
     struct _CoreExport Key
@@ -265 +279 @@
         multiple handlers) are active.
     */
-    struct HandlerState
-    {
-        HandlerState() : key(false), mouse(false), joyStick(false) { }
-        bool key;
-        bool mouse;
-        bool joyStick;
-    };
+    //struct HandlerState
+    //{
+    //    HandlerState() : keyboard(false), mouse(false) { }
+    //    bool keyboard;
+    //    bool mouse;
+    //    std::vector<bool> joySticks;
+    //};
 
     class _CoreExport InputTickable
@@ -277 +291 @@
     public:
         virtual ~InputTickable() { }
-        virtual void tickInput(float dt, const HandlerState& state) = 0;
+        virtual void tickInput(float dt) = 0;
+        //virtual void tickInput(float dt, unsigned int device) = 0;
     };
 
@@ -291 +306 @@
         virtual void keyReleased(const KeyEvent& evt) = 0;
         virtual void keyHeld    (const KeyEvent& evt) = 0;
-        //virtual void tickKey    (float dt) { }
+        virtual void tickKey    (float dt) { }
     };
 
@@ -307 +322 @@
         virtual void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize) = 0;
         virtual void mouseScrolled      (int abs, int rel)     = 0;
-        //virtual void tickMouse          (float dt) { }
+        virtual void tickMouse          (float dt) { }
     };
 
@@ -319 +334 @@
     public:
         virtual ~JoyStickHandler() { }
-        virtual void joyStickButtonPressed (int joyStickID, int button) = 0;
-        virtual void joyStickButtonReleased(int joyStickID, int button) = 0;
-        virtual void joyStickButtonHeld    (int joyStickID, int button) = 0;
-        virtual void joyStickAxisMoved     (int joyStickID, int axis, float value) = 0;
-        //virtual bool joyStickVector3Moved  (int joyStickID, int index /*, fill list*/) {return true;}
-        //virtual void tickJoyStick          (float dt) { }
+        virtual void joyStickButtonPressed (unsigned int joyStickID, unsigned int button) = 0;
+        virtual void joyStickButtonReleased(unsigned int joyStickID, unsigned int button) = 0;
+        virtual void joyStickButtonHeld    (unsigned int joyStickID, unsigned int button) = 0;
+        virtual void joyStickAxisMoved     (unsigned int joyStickID, unsigned int axis, float value) = 0;
+        //virtual bool joyStickVector3Moved  (unsigned int joyStickID, unsigned int index /*, fill list*/) {return true;}
+        virtual void tickJoyStick          (float dt, unsigned int device) { }
+    };
+
+    class _CoreExport EmptyHandler : public KeyHandler, public MouseHandler, public JoyStickHandler
+    {
+    private:
+        void tickInput(float dt) { }
+        void tickInput(float dt, unsigned int device) { }
+
+        void keyPressed (const KeyEvent& evt) { }
+        void keyReleased(const KeyEvent& evt) { }
+        void keyHeld    (const KeyEvent& evt) { }
+
+        void mouseButtonPressed (MouseButton::Enum id) { }
+        void mouseButtonReleased(MouseButton::Enum id) { }
+        void mouseButtonHeld    (MouseButton::Enum id) { }
+        void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize) { }
+        void mouseScrolled      (int abs, int rel) { }
+
+        void joyStickButtonPressed (unsigned int joyStickID, unsigned int button) { }
+        void joyStickButtonReleased(unsigned int joyStickID, unsigned int button) { }
+        void joyStickButtonHeld    (unsigned int joyStickID, unsigned int button) { }
+        void joyStickAxisMoved     (unsigned int joyStickID, unsigned int axis, float value) { }
     };
 

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

@@ -38 +38 @@
 #include <limits.h>
 
+#include "ois/OISException.h"
+#include "ois/OISInputManager.h"
+
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
@@ -43 +46 @@
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
-#include "core/Shell.h"               // hack!
 
 #include "InputBuffer.h"
@@ -49 +51 @@
 #include "KeyDetector.h"
 #include "CalibratorCallback.h"
-
-#include "src/ois/OISException.h"
-#include "src/ois/OISInputManager.h"
+#include "InputState.h"
+#include "SimpleInputState.h"
+#include "ExtendedInputState.h"
 
 namespace orxonox
@@ -59 +61 @@
     SetConsoleCommandShortcut(InputManager, calibrate);
 
+    using namespace InputDevice;
+
     // ###############################
     // ###    Internal Methods     ###
@@ -74 +78 @@
         , mouse_(0)
         , joySticksSize_(0)
-        , keyBinder_(0)
-        , keyDetector_(0)
-        , buffer_(0)
-        , calibratorCallback_(0)
-        , state_(IS_UNINIT)
-        , stateRequest_(IS_UNINIT)
-        , savedState_(IS_UNINIT)
+        , devicesNum_(0)
+        , stateDetector_(0)
+        , stateCalibrator_(0)
+        , stateEmpty_(0)
         , keyboardModifiers_(0)
+        , bCalibrating_(false)
     {
         RegisterRootObject(InputManager);
@@ -92 +94 @@
         A reference to the only instance of the InputManager
     */
-    InputManager& InputManager::_getSingleton()
+    InputManager& InputManager::_getInstance()
     {
         static InputManager theOnlyInstance;
@@ -106 +108 @@
         _destroy();
     }
+
+
+    // ############################################################
+    // #####                  Initialisation                  #####
+    // ##########                                        ##########
+    // ############################################################
 
     /**
@@ -121 +129 @@
                                    bool createKeyboard, bool createMouse, bool createJoySticks)
     {
-        if (state_ == IS_UNINIT)
+        if (inputSystem_ == 0)
         {
             CCOUT(3) << "Initialising Input System..." << std::endl;
@@ -160 +168 @@
                 _initialiseJoySticks();
 
+            // set all the std::vector list sizes now that the devices have been created
+            _redimensionLists();
+
             // Set mouse/joystick region
             if (mouse_)
@@ -166 +177 @@
             }
 
-            state_ = IS_NONE;
             CCOUT(ORX_DEBUG) << "Initialising OIS components done." << std::endl;
 
             // InputManager holds the input buffer --> create one and add it.
-            buffer_ = new InputBuffer();
-            addKeyHandler(buffer_, "buffer");
-            Shell::getInstance().setInputBuffer(buffer_);
-
-            keyBinder_ = new KeyBinder();
-            keyBinder_->loadBindings();
-            addKeyHandler(keyBinder_, "keybinder");
-            addMouseHandler(keyBinder_, "keybinder");
-            addJoyStickHandler(keyBinder_, "keybinder");
-
-            keyDetector_ = new KeyDetector();
-            keyDetector_->loadBindings();
-            addKeyHandler(keyDetector_, "keydetector");
-            addMouseHandler(keyDetector_, "keydetector");
-            addJoyStickHandler(keyDetector_, "keydetector");
-
-            calibratorCallback_ = new CalibratorCallback();
-            addKeyHandler(calibratorCallback_, "calibratorcallback");
+            //buffer_ = new InputBuffer();
+            //addKeyHandler(buffer_, "buffer");
+            //Shell::getInstance().setInputBuffer(buffer_);
 
             setConfigValues();
+
+            stateEmpty_ = createSimpleInputState("empty", -1);
+            stateEmpty_->setHandler(new EmptyHandler());
+            activeStates_[stateEmpty_->getPriority()] = stateEmpty_;
+
+            stateDetector_ = createSimpleInputState("detector", 101);
+            KeyDetector* temp = new KeyDetector();
+            temp->loadBindings("storeKeyStroke");
+            stateDetector_->setHandler(temp);
+
+            stateCalibrator_ = createSimpleInputState("calibrator", 100);
+            stateCalibrator_->setHandler(new EmptyHandler());
+            InputBuffer* buffer = new InputBuffer();
+            buffer->registerListener(this, &InputManager::_completeCalibration, '\r', true);
+            stateCalibrator_->setKeyHandler(buffer);
+
+            _updateActiveStates();
 
             CCOUT(ORX_DEBUG) << "Initialising complete." << std::endl;
@@ -232 +244 @@
         catch (OIS::Exception ex)
         {
-            // TODO: Test this output regarding formatting
             CCOUT(ORX_WARNING) << "Warning: Failed to create an OIS keyboard\n"
                 << "OIS error message: \"" << ex.eText << "\"" << std::endl;
@@ -300 +311 @@
                     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);
-                    CCOUT(ORX_DEBUG) << "Created OIS joy stick with ID " << stig->getID() << std::endl;
                     success = true;
                 }
@@ -318 +329 @@
             return false;
         }
+        return success;
+    }
+
+    void InputManager::_redimensionLists()
+    {
         joySticksSize_ = joySticks_.size();
-        activeJoyStickHandlers_.resize(joySticksSize_);
-        joyStickButtonsDown_.resize(joySticksSize_);
-        povStates_.resize(joySticksSize_);
-        sliderStates_.resize(joySticksSize_);
+        devicesNum_ = 2 + joySticksSize_;
+        joyStickButtonsDown_ .resize(joySticksSize_);
+        povStates_           .resize(joySticksSize_);
+        sliderStates_        .resize(joySticksSize_);
         joySticksCalibration_.resize(joySticksSize_);
+
         for (unsigned int iJoyStick = 0; iJoyStick < joySticksSize_; iJoyStick++)
         {
@@ -334 +351 @@
             }
         }
-        return success;
+
+        // state management
+        activeStatesTop_.resize(devicesNum_);
+
+        // inform all registered states
+        for (std::map<int, InputState*>::const_iterator it = inputStatesByPriority_.begin();
+            it != inputStatesByPriority_.end(); ++it)
+            (*it).second->setNumOfJoySticks(joySticksSize_);
     }
 
@@ -392 +416 @@
     }
 
+
+    // ############################################################
+    // #####                    Destruction                   #####
+    // ##########                                        ##########
+    // ############################################################
+
     /**
     @brief
@@ -398 +428 @@
     void InputManager::_destroy()
     {
-        if (state_ != IS_UNINIT)
+        if (inputSystem_)
         {
             CCOUT(ORX_DEBUG) << "Destroying ..." << std::endl;
 
-            if (buffer_)
-                delete buffer_;
-
-            if (keyBinder_)
-                delete keyBinder_;
-
-            if (keyDetector_)
-                delete keyDetector_;
-
-            if (calibratorCallback_)
-                delete calibratorCallback_;
-
-            keyHandlers_.clear();
-            mouseHandlers_.clear();
-            joyStickHandlers_.clear();
-
+            // kick all active states 'nicely'
+            for (std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin();
+                rit != activeStates_.rend(); ++rit)
+                (*rit).second->onLeave();
+            activeStates_.clear();
+
+            // destroy our own states
+            stateEmpty_->removeAndDestroyAllHandlers();
+            stateCalibrator_->removeAndDestroyAllHandlers();
+            stateDetector_->removeAndDestroyAllHandlers();
+            _destroyState(stateEmpty_);
+            _destroyState(stateCalibrator_);
+            _destroyState(stateDetector_);
+            stateEmpty_ = 0;
+            stateCalibrator_ = 0;
+            stateDetector_ = 0;
+
+            // we don't remove the other states yet because the singleton might still exist.
+            // So people can still removeAndDestroy their states
+            //inputStatesByName_.clear();
+            //inputStatesByPriority_.clear();
+
+            // destroy the devices
             _destroyKeyboard();
             _destroyMouse();
             _destroyJoySticks();
 
-            activeHandlers_.clear();
-
-            // inputSystem_ can never be 0, or else the code is mistaken
+            _redimensionLists();
+
             OIS::InputManager::destroyInputSystem(inputSystem_);
             inputSystem_ = 0;
 
-            state_ = IS_UNINIT;
             CCOUT(ORX_DEBUG) << "Destroying done." << std::endl;
         }
@@ -442 +477 @@
             inputSystem_->destroyInputObject(keyboard_);
         keyboard_ = 0;
-        activeKeyHandlers_.clear();
         keysDown_.clear();
         CCOUT(ORX_DEBUG) << "Keyboard destroyed." << std::endl;
@@ -456 +490 @@
             inputSystem_->destroyInputObject(mouse_);
         mouse_ = 0;
-        activeMouseHandlers_.clear();
         mouseButtonsDown_.clear();
         CCOUT(ORX_DEBUG) << "Mouse destroyed." << std::endl;
@@ -475 +508 @@
 
             joySticks_.clear();
-            joySticksSize_ = 0;
-            activeJoyStickHandlers_.clear();
-            joyStickButtonsDown_.clear();
-            povStates_.clear();
-            sliderStates_.clear();
-            joySticksCalibration_.clear();
         }
         CCOUT(ORX_DEBUG) << "Joy sticks destroyed." << std::endl;
     }
 
-    void InputManager::_saveState()
-    {
-        savedHandlers_.activeHandlers_ = activeHandlers_;
-        savedHandlers_.activeJoyStickHandlers_ = activeJoyStickHandlers_;
-        savedHandlers_.activeKeyHandlers_ = activeKeyHandlers_;
-        savedHandlers_.activeMouseHandlers_ = activeMouseHandlers_;
-    }
-
-    void InputManager::_restoreState()
-    {
-        activeHandlers_ = savedHandlers_.activeHandlers_;
-        activeJoyStickHandlers_ = savedHandlers_.activeJoyStickHandlers_;
-        activeKeyHandlers_ = savedHandlers_.activeKeyHandlers_;
-        activeMouseHandlers_ = savedHandlers_.activeMouseHandlers_;
-    }
-
-    void InputManager::_updateTickables()
-    {
-        // we can use a map to have a list of unique pointers (an object can implement all 3 handlers)
-        std::map<InputTickable*, HandlerState> tempSet;
-        for (unsigned int iHandler = 0; iHandler < activeKeyHandlers_.size(); iHandler++)
-            tempSet[activeKeyHandlers_[iHandler]].joyStick = true;
-        for (unsigned int iHandler = 0; iHandler < activeMouseHandlers_.size(); iHandler++)
-            tempSet[activeMouseHandlers_[iHandler]].mouse = true;
-        for (unsigned int iJoyStick  = 0; iJoyStick < joySticksSize_; iJoyStick++)
-            for (unsigned int iHandler = 0; iHandler  < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
-                tempSet[activeJoyStickHandlers_[iJoyStick][iHandler]].joyStick = true;
-
-        // copy the content of the map back to the actual vector
-        activeHandlers_.clear();
-        for (std::map<InputTickable*, HandlerState>::const_iterator itHandler = tempSet.begin();
-            itHandler != tempSet.end(); itHandler++)
-            activeHandlers_.push_back(std::pair<InputTickable*, HandlerState>((*itHandler).first, (*itHandler).second));
-    }
-
-
-    // #################################
-    // ### Private Interface Methods ###
-    // #################################
-    // #################################
-
-    /**
-    @brief
-        Updates the InputManager. Tick is called by Orxonox.
+    void InputManager::_destroyState(InputState* state)
+    {
+        assert(state);
+        inputStatesByPriority_.erase(state->getPriority());
+        inputStatesByName_.erase(state->getName());
+        delete state;
+    }
+
+
+    // ############################################################
+    // #####                  Runtime Methods                 #####
+    // ##########                                        ##########
+    // ############################################################
+
+    /**
+    @brief
+        Updates the InputManager. Tick is called by the Core class.
     @param dt
         Delta time
@@ -534 +534 @@
     void InputManager::_tick(float dt)
     {
-        if (state_ == IS_UNINIT)
+        if (inputSystem_ == 0)
             return;
 
-        if (state_ != stateRequest_)
-        {
-            InputState sr = stateRequest_;
-            switch (sr)
-            {
-            case IS_NORMAL:
-                activeKeyHandlers_.clear();
-                activeMouseHandlers_.clear();
-                for (unsigned int i = 0; i < joySticksSize_; i++)
-                    activeJoyStickHandlers_[i].clear();
-
-                // normal play mode
-                // note: we assume that the handlers exist since otherwise, something's wrong anyway.
-                enableKeyHandler("keybinder");
-                enableMouseHandler("keybinder");
-                enableJoyStickHandler("keybinder", 0);
-                stateRequest_ = IS_NORMAL;
-                state_ = IS_NORMAL;
-                break;
-
-            case IS_GUI:
-                state_ = IS_GUI;
-                break;
-
-            case IS_CONSOLE:
-                activeKeyHandlers_.clear();
-                activeMouseHandlers_.clear();
-                for (unsigned int i = 0; i < joySticksSize_; i++)
-                    activeJoyStickHandlers_[i].clear();
-
-                enableMouseHandler("keybinder");
-                enableJoyStickHandler("keybinder", 0);
-                enableKeyHandler("buffer");
-                stateRequest_ = IS_CONSOLE;
-                state_ = IS_CONSOLE;
-                break;
-
-            case IS_DETECT:
-                savedState_ = state_;
-                _saveState();
-
-                activeKeyHandlers_.clear();
-                activeMouseHandlers_.clear();
-                for (unsigned int i = 0; i < joySticksSize_; i++)
-                    activeJoyStickHandlers_[i].clear();
-
-                enableKeyHandler("keydetector");
-                enableMouseHandler("keydetector");
-                enableJoyStickHandler("keydetector", 0);
-
-                stateRequest_ = IS_DETECT;
-                state_ = IS_DETECT;
-                break;
-
-            case IS_NODETECT:
-                _restoreState();
-                keysDown_.clear();
-                mouseButtonsDown_.clear();
-                for (unsigned int i = 0; i < joySticksSize_; i++)
-                    joyStickButtonsDown_[i].clear();
-                state_ = IS_NODETECT;
-                stateRequest_ = savedState_;
-                break;
-
-            case IS_CALIBRATE:
-                if (joySticksSize_)
-                {
-                    savedState_ = _getSingleton().state_;
-                    for (unsigned int i = 0; i < 24; i++)
-                    {
-                        marginalsMax_[i] = INT_MIN;
-                        marginalsMin_[i] = INT_MAX;
-                    }
-                    COUT(0) << "Move all joy stick axes in all directions a few times. "
-                            << "Then put all axes in zero state and hit enter." << std::endl;
-
-                    savedState_ = state_;
-                    _saveState();
-
-                    activeKeyHandlers_.clear();
-                    activeMouseHandlers_.clear();
-                    for (unsigned int i = 0; i < joySticksSize_; i++)
-                        activeJoyStickHandlers_[i].clear();
-
-                    enableKeyHandler("calibratorcallback");
-                    stateRequest_ = IS_CALIBRATE;
-                    state_ = IS_CALIBRATE;
-                }
-                else
-                {
-                    COUT(3) << "Connot calibrate, no joy stick found!" << std::endl;
-                    stateRequest_ = state_;
-                }
-                break;
-
-            case IS_NOCALIBRATE:
-                _completeCalibration();
-                _restoreState();
-                keyBinder_->resetJoyStickAxes();
-                state_ = IS_NOCALIBRATE;
-                stateRequest_ = savedState_;
-                break;
-
-            case IS_NONE:
-                activeKeyHandlers_.clear();
-                activeMouseHandlers_.clear();
-                for (unsigned int i = 0; i < joySticksSize_; i++)
-                    activeJoyStickHandlers_[i].clear();
-                state_ = IS_NONE;
-
-            default:
-                break;
-            }
+        // check for states to leave (don't use unsigned int!)
+        for (int i = stateLeaveRequests_.size() - 1; i >= 0; --i)
+        {
+            stateLeaveRequests_[i]->onLeave();
+            // just to be sure that the state actually is registered
+            assert(inputStatesByName_.find(stateLeaveRequests_[i]->getName()) != inputStatesByName_.end());
+            
+            activeStates_.erase(stateLeaveRequests_[i]->getPriority());
+            _updateActiveStates();
+            stateLeaveRequests_.pop_back();
+        }
+
+
+        // check for states to enter (don't use unsigned int!)
+        for (int i = stateEnterRequests_.size() - 1; i >= 0; --i)
+        {
+            // just to be sure that the state actually is registered
+            assert(inputStatesByName_.find(stateEnterRequests_[i]->getName()) != inputStatesByName_.end());
+            
+            activeStates_[stateEnterRequests_[i]->getPriority()] = stateEnterRequests_[i];
+            _updateActiveStates();
+            stateEnterRequests_[i]->onEnter();
+            stateEnterRequests_.pop_back();
         }
 
         // Capture all the input. This calls the event handlers in InputManager.
+        if (keyboard_)
+            keyboard_->capture();
         if (mouse_)
             mouse_->capture();
-        if (keyboard_)
-            keyboard_->capture();
         for (unsigned  int i = 0; i < joySticksSize_; i++)
             joySticks_[i]->capture();
 
-        if (state_ != IS_CALIBRATE)
+        if (!bCalibrating_)
         {
             // call all the handlers for the held key events
             for (unsigned int iKey = 0; iKey < keysDown_.size(); iKey++)
-                for (unsigned int iHandler = 0; iHandler < activeKeyHandlers_.size(); iHandler++)
-                    activeKeyHandlers_[iHandler]->keyHeld(KeyEvent(keysDown_[iKey], keyboardModifiers_));
+                activeStatesTop_[Keyboard]->keyHeld(KeyEvent(keysDown_[iKey], keyboardModifiers_));
 
             // call all the handlers for the held mouse button events
             for (unsigned int iButton = 0; iButton < mouseButtonsDown_.size(); iButton++)
-                for (unsigned int iHandler = 0; iHandler < activeMouseHandlers_.size(); iHandler++)
-                    activeMouseHandlers_[iHandler]->mouseButtonHeld(mouseButtonsDown_[iButton]);
+                activeStatesTop_[Mouse]->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 iHandler = 0; iHandler  < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
-                    {
-                        activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickButtonHeld(
-                            iJoyStick, joyStickButtonsDown_[iJoyStick][iButton]);
-                    }
-        }
-
-        // call the ticks for the handlers (need to be treated specially)
-        for (unsigned int iHandler = 0; iHandler < activeHandlers_.size(); iHandler++)
-            activeHandlers_[iHandler].first->tickInput(dt, activeHandlers_[iHandler].second);
+                    activeStatesTop_[JoyStick0 + iJoyStick]
+                        ->joyStickButtonHeld(iJoyStick, joyStickButtonsDown_[iJoyStick][iButton]);
+
+            // tick the handlers for each active handler
+            for (unsigned int i = 0; i < devicesNum_; ++i)
+                activeStatesTop_[i]->tickInput(dt, i);
+
+            // tick the handler with a general tick afterwards
+            for (unsigned int i = 0; i < activeStatesTicked_.size(); ++i)
+                activeStatesTicked_[i]->tickInput(dt);
+        }
+    }
+
+    void InputManager::_updateActiveStates()
+    {
+        for (std::map<int, InputState*>::const_iterator it = activeStates_.begin(); it != activeStates_.end(); ++it)
+            for (unsigned int i = 0; i < devicesNum_; ++i)
+                if ((*it).second->isInputDeviceEnabled(i))
+                    activeStatesTop_[i] = (*it).second;
+
+        // update tickables (every state will only appear once)
+        // Using a std::set to avoid duplicates
+        std::set<InputState*> tempSet;
+        for (unsigned int i = 0; i < devicesNum_; ++i)
+            tempSet.insert(activeStatesTop_[i]);
+
+        // copy the content of the set back to the actual vector
+        activeStatesTicked_.clear();
+        for (std::set<InputState*>::const_iterator it = tempSet.begin();it != tempSet.end(); ++it)
+            activeStatesTicked_.push_back(*it);
     }
 
@@ -744 +672 @@
             cont->set(i, joySticksCalibration_[0].zeroStates[i]);
         }
-    }
+
+        // restore old input state
+        requestLeaveState("calibrator");
+    }
+
+
+    // ############################################################
+    // #####                    OIS events                    #####
+    // ##########                                        ##########
+    // ############################################################
 
     // ###### Key Events ######
@@ -771 +708 @@
             keyboardModifiers_ |= KeyboardModifier::Shift; // shift key
 
-        for (unsigned int i = 0; i < activeKeyHandlers_.size(); i++)
-            activeKeyHandlers_[i]->keyPressed(KeyEvent(e, keyboardModifiers_));
+        activeStatesTop_[Keyboard]->keyPressed(KeyEvent(e, keyboardModifiers_));
 
         return true;
@@ -803 +739 @@
             keyboardModifiers_ &= ~KeyboardModifier::Shift; // shift key
 
-        for (unsigned int i = 0; i < activeKeyHandlers_.size(); i++)
-            activeKeyHandlers_[i]->keyReleased(KeyEvent(e, keyboardModifiers_));
+        activeStatesTop_[Keyboard]->keyReleased(KeyEvent(e, keyboardModifiers_));
 
         return true;
@@ -823 +758 @@
         if (e.state.X.rel != 0 || e.state.Y.rel != 0)
         {
-            for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
-            {
-                activeMouseHandlers_[i]->mouseMoved(IntVector2(e.state.X.abs, e.state.Y.abs),
+            activeStatesTop_[Mouse]->mouseMoved(IntVector2(e.state.X.abs, e.state.Y.abs),
                     IntVector2(e.state.X.rel, e.state.Y.rel), IntVector2(e.state.width, e.state.height));
-            }
         }
 
@@ -833 +765 @@
         if (e.state.Z.rel != 0)
         {
-            for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
-                activeMouseHandlers_[i]->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
+            activeStatesTop_[Mouse]->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
         }
 
@@ -857 +788 @@
             mouseButtonsDown_.push_back((MouseButton::Enum)id);
 
-        for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
-            activeMouseHandlers_[i]->mouseButtonPressed((MouseButton::Enum)id);
+        activeStatesTop_[Mouse]->mouseButtonPressed((MouseButton::Enum)id);
 
         return true;
@@ -883 +813 @@
         }
 
-        for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
-            activeMouseHandlers_[i]->mouseButtonReleased((MouseButton::Enum)id);
+        activeStatesTop_[Mouse]->mouseButtonReleased((MouseButton::Enum)id);
 
         return true;
@@ -898 +827 @@
         unsigned int iJoyStick = 0;
         while (joySticks_[iJoyStick] != joyStick)
-        {
             iJoyStick++;
-            if (iJoyStick == joySticksSize_)
-            {
-                CCOUT(3) << "Unknown joystick fired an event. This means there is a bug somewhere! Aborting." << std::endl;
-                abort();
-            }
-        }
+        // assert: Unknown joystick fired an event.
+        assert(iJoyStick != joySticksSize_);
         return iJoyStick;
     }
@@ -921 +845 @@
             buttonsDown.push_back(button);
 
-        for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
-            activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickButtonPressed(iJoyStick, button);
+        activeStatesTop_[2 + iJoyStick]->joyStickButtonPressed(iJoyStick, button);
 
         return true;
@@ -942 +865 @@
         }
 
-        for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
-            activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickButtonReleased(iJoyStick, button);
+        activeStatesTop_[2 + iJoyStick]->joyStickButtonReleased(iJoyStick, button);
 
         return true;
@@ -950 +872 @@
     void InputManager::_fireAxis(unsigned int iJoyStick, int axis, int value)
     {
-        if (state_ == IS_CALIBRATE)
+        if (bCalibrating_)
         {
             if (value > marginalsMax_[axis])
@@ -965 +887 @@
                 fValue *= joySticksCalibration_[iJoyStick].negativeCoeff[axis];
 
-            for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
-                activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickAxisMoved(iJoyStick, axis, fValue);
+            activeStatesTop_[2 + iJoyStick]->joyStickAxisMoved(iJoyStick, axis, fValue);
         }
     }
@@ -972 +893 @@
     bool InputManager::axisMoved(const OIS::JoyStickEvent &arg, int axis)
     {
-        //if (arg.state.mAxes[axis].abs > 10000 || arg.state.mAxes[axis].abs < -10000)
-        //{ CCOUT(3) << "axis " << axis << " moved" << arg.state.mAxes[axis].abs << std::endl;}
-
         unsigned int iJoyStick = _getJoystick(arg);
 
@@ -985 +903 @@
     bool InputManager::sliderMoved(const OIS::JoyStickEvent &arg, int id)
     {
-        //if (arg.state.mSliders[id].abX > 10000 || arg.state.mSliders[id].abX < -10000)
-        //{CCOUT(3) << "slider " << id << " moved" << arg.state.mSliders[id].abX << std::endl;}
-        //CCOUT(3) << arg.state.mSliders[id].abX << "\t |" << arg.state.mSliders[id].abY << std::endl;
-
         unsigned int iJoyStick = _getJoystick(arg);
 
@@ -1029 +943 @@
     }
 
-    /*bool InputManager::vector3Moved(const OIS::JoyStickEvent &arg, int id)
-    {
-        unsigned int iJoyStick = _getJoystick(arg);
-
-        for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
-        {
-            activeJoyStickHandlers_[iJoyStick][iHandler]
-                ->joyStickVector3Moved(JoyStickState(arg.state, iJoyStick), id);
-            }
-
-        return true;
-    }*/
-
-
-    // ################################
-    // ### Static Interface Methods ###
-    // ################################
-    // ################################
+
+    // ############################################################
+    // #####            Static Interface Methods              #####
+    // ##########                                        ##########
+    // ############################################################
 
     std::string InputManager::bindingCommmandString_s = "";
@@ -1053 +954 @@
         bool createKeyboard, bool createMouse, bool createJoySticks)
     {
-        return _getSingleton()._initialise(windowHnd, windowWidth, windowHeight,
+        return _getInstance()._initialise(windowHnd, windowWidth, windowHeight,
             createKeyboard, createMouse, createJoySticks);
     }
@@ -1059 +960 @@
     bool InputManager::initialiseKeyboard()
     {
-        return _getSingleton()._initialiseKeyboard();
+        return _getInstance()._initialiseKeyboard();
     }
 
     bool InputManager::initialiseMouse()
     {
-        return _getSingleton()._initialiseMouse();
+        return _getInstance()._initialiseMouse();
     }
 
     bool InputManager::initialiseJoySticks()
     {
-        return _getSingleton()._initialiseJoySticks();
+        return _getInstance()._initialiseJoySticks();
     }
 
     int InputManager::numberOfKeyboards()
     {
-        if (_getSingleton().keyboard_ != 0)
+        if (_getInstance().keyboard_ != 0)
             return 1;
         else
@@ -1082 +983 @@
     int InputManager::numberOfMice()
     {
-        if (_getSingleton().mouse_ != 0)
+        if (_getInstance().mouse_ != 0)
             return 1;
         else
@@ -1090 +991 @@
     int InputManager::numberOfJoySticks()
     {
-        return _getSingleton().joySticksSize_;
+        return _getInstance().joySticksSize_;
     }
 
     /*bool InputManager::isKeyDown(KeyCode::Enum key)
     {
-    if (_getSingleton().keyboard_)
-        return _getSingleton().keyboard_->isKeyDown((OIS::KeyCode)key);
+    if (_getInstance().keyboard_)
+        return _getInstance().keyboard_->isKeyDown((OIS::KeyCode)key);
     else
         return false;
@@ -1103 +1004 @@
     /*bool InputManager::isModifierDown(KeyboardModifier::Enum modifier)
     {
-    if (_getSingleton().keyboard_)
+    if (_getInstance().keyboard_)
         return isModifierDown(modifier);
     else
@@ -1111 +1012 @@
     /*const MouseState InputManager::getMouseState()
     {
-    if (_getSingleton().mouse_)
-        return _getSingleton().mouse_->getMouseState();
+    if (_getInstance().mouse_)
+        return _getInstance().mouse_->getMouseState();
     else
         return MouseState();
@@ -1119 +1020 @@
     /*const JoyStickState InputManager::getJoyStickState(unsigned int ID)
     {
-    if (ID < _getSingleton().joySticksSize_)
-        return JoyStickState(_getSingleton().joySticks_[ID]->getJoyStickState(), ID);
+    if (ID < _getInstance().joySticksSize_)
+        return JoyStickState(_getInstance().joySticks_[ID]->getJoyStickState(), ID);
     else
         return JoyStickState();
@@ -1127 +1028 @@
     void InputManager::destroy()
     {
-        _getSingleton()._destroy();
+        _getInstance()._destroy();
     }
 
     void InputManager::destroyKeyboard()
     {
-        return _getSingleton()._destroyKeyboard();
+        return _getInstance()._destroyKeyboard();
     }
 
     void InputManager::destroyMouse()
     {
-        return _getSingleton()._destroyMouse();
+        return _getInstance()._destroyMouse();
     }
 
     void InputManager::destroyJoySticks()
     {
-        return _getSingleton()._destroyJoySticks();
+        return _getInstance()._destroyJoySticks();
     }
 
@@ -1157 +1058 @@
     void InputManager::setWindowExtents(const int width, const int height)
     {
-        if (_getSingleton().mouse_)
+        if (_getInstance().mouse_)
         {
             // Set mouse region (if window resizes, we should alter this to reflect as well)
-            const OIS::MouseState &mouseState = _getSingleton().mouse_->getMouseState();
+            const OIS::MouseState &mouseState = _getInstance().mouse_->getMouseState();
             mouseState.width  = width;
             mouseState.height = height;
@@ -1166 +1067 @@
     }
 
-    /**
-    @brief
-        Sets the input mode to either GUI, inGame or Buffer
-    @param mode
-        The new input mode
-    @remarks
-        Only has an affect if the mode actually changes
-    */
-    void InputManager::setInputState(const InputState state)
-    {
-        _getSingleton().stateRequest_ = state;
-    }
-
-    /**
-    @brief
-        Returns the current input handling method
-    @return
-        The current input mode.
-    */
-    InputManager::InputState InputManager::getInputState()
-    {
-        return _getSingleton().state_;
-    }
-
     void InputManager::storeKeyStroke(const std::string& name)
     {
-        setInputState(IS_NODETECT);
+        requestLeaveState("detector");
         COUT(0) << "Binding string \"" << bindingCommmandString_s << "\" on key '" << name << "'" << std::endl;
         CommandExecutor::execute("config KeyBinder " + name + " " + bindingCommmandString_s, false);
@@ -1200 +1077 @@
     {
         bindingCommmandString_s = command;
-        setInputState(IS_DETECT);
+        requestEnterState("detector");
         COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
     }
@@ -1206 +1083 @@
     void InputManager::calibrate()
     {
-        _getSingleton().setInputState(IS_CALIBRATE);
+        requestEnterState("calibrator");
     }
 
     void InputManager::tick(float dt)
     {
-        _getSingleton()._tick(dt);
-    }
-
-    // ###### KeyHandler ######
+        _getInstance()._tick(dt);
+    }
+
+    // ###### InputStates ######
 
     /**
@@ -1226 +1103 @@
         True if added, false if name already existed.
     */
-    bool InputManager::addKeyHandler(KeyHandler* handler, const std::string& name)
-    {
-        if (!handler)
+    bool InputManager::_configureInputState(InputState* state, const std::string& name, int priority)
+    {
+        if (name == "")
             return false;
-        if (_getSingleton().keyHandlers_.find(name) == _getSingleton().keyHandlers_.end())
-        {
-            _getSingleton().keyHandlers_[name] = handler;
-            return true;
+        if (_getInstance().inputStatesByName_.find(name) == _getInstance().inputStatesByName_.end())
+        {
+            if (_getInstance().inputStatesByPriority_.find(priority)
+                == _getInstance().inputStatesByPriority_.end())
+            {
+                _getInstance().inputStatesByName_[name] = state;
+                _getInstance().inputStatesByPriority_[priority] = state;
+                state->setNumOfJoySticks(numberOfJoySticks());
+                state->setName(name);
+                state->setPriority(priority);
+                return true;
+            }
+            else
+            {
+                COUT(2) << "Warning: Could not add an InputState with the same priority '"
+                    << priority << "'." << std::endl;
+                return false;
+            }
         }
         else
+        {
+            COUT(2) << "Warning: Could not add an InputState with the same name '" << name << "'." << std::endl;
             return false;
+        }
+    }
+
+    SimpleInputState* InputManager::createSimpleInputState(const std::string &name, int priority)
+    {
+        SimpleInputState* state = new SimpleInputState();
+        if (_getInstance()._configureInputState(state, name, priority))
+            return state;
+        else
+        {
+            delete state;
+            return 0;
+        }
+    }
+
+    ExtendedInputState* InputManager::createExtendedInputState(const std::string &name, int priority)
+    {
+        ExtendedInputState* state = new ExtendedInputState();
+        if (_getInstance()._configureInputState(state, name, priority))
+            return state;
+        else
+        {
+            delete state;
+            return 0;
+        }
     }
 
@@ -1247 +1165 @@
         True if removal was successful, false if name was not found.
     */
-    bool InputManager::removeKeyHandler(const std::string &name)
-    {
-        disableKeyHandler(name);
-        std::map<std::string, KeyHandler*>::iterator it = _getSingleton().keyHandlers_.find(name);
-        if (it != _getSingleton().keyHandlers_.end())
-        {
-            _getSingleton().keyHandlers_.erase(it);
+    bool InputManager::destroyState(const std::string& name)
+    {
+        if (name == "empty" || name == "calibrator" || name == "detector")
+        {
+            COUT(2) << "InputManager: Removing the '" << name << "' state is not allowed!" << std::endl;
+            return false;
+        }
+        std::map<std::string, InputState*>::iterator it = _getInstance().inputStatesByName_.find(name);
+        if (it != _getInstance().inputStatesByName_.end())
+        {
+            _getInstance()._destroyState((*it).second);
             return true;
         }
-        else
-            return false;
+        return false;
     }
 
@@ -1268 +1189 @@
         Pointer to the instance, 0 if name was not found.
     */
-    KeyHandler* InputManager::getKeyHandler(const std::string& name)
-    {
-        std::map<std::string, KeyHandler*>::iterator it = _getSingleton().keyHandlers_.find(name);
-        if (it != _getSingleton().keyHandlers_.end())
+    InputState* InputManager::getState(const std::string& name)
+    {
+        std::map<std::string, InputState*>::iterator it = _getInstance().inputStatesByName_.find(name);
+        if (it != _getInstance().inputStatesByName_.end())
             return (*it).second;
         else
             return 0;
+    }
+
+    /**
+    @brief
+        Returns the current input handling method
+    @return
+        The current input mode.
+    */
+    InputState* InputManager::getCurrentState()
+    {
+        return (*_getInstance().activeStates_.rbegin()).second;
     }
 
@@ -1285 +1217 @@
         False if name was not found, true otherwise.
     */
-    bool InputManager::enableKeyHandler(const std::string& name)
+    bool InputManager::requestEnterState(const std::string& name)
     {
         // get pointer from the map with all stored handlers
-        std::map<std::string, KeyHandler*>::const_iterator mapIt = _getSingleton().keyHandlers_.find(name);
-        if (mapIt == _getSingleton().keyHandlers_.end())
-            return false;
-        // see whether the handler already is in the list
-        for (std::vector<KeyHandler*>::iterator it = _getSingleton().activeKeyHandlers_.begin();
-            it != _getSingleton().activeKeyHandlers_.end(); it++)
-        {
-            if ((*it) == (*mapIt).second)
-            {
-                return true;
-            }
-        }
-        _getSingleton().activeKeyHandlers_.push_back((*mapIt).second);
-        _getSingleton().stateRequest_ = IS_CUSTOM;
-        _getSingleton()._updateTickables();
-        return true;
-    }
-
-    /**
-    @brief
-        Disables a specific key handler.
-    @param name
-        Unique name of the handler.
-    @return
-        False if name was not found, true otherwise.
-    */
-    bool InputManager::disableKeyHandler(const std::string &name)
+        std::map<std::string, InputState*>::const_iterator it = _getInstance().inputStatesByName_.find(name);
+        if (it != _getInstance().inputStatesByName_.end())
+        {
+            _getInstance().stateEnterRequests_.push_back((*it).second);
+            return true;
+        }
+        return false;
+    }
+
+    bool InputManager::requestLeaveState(const std::string& name)
     {
         // get pointer from the map with all stored handlers
-        std::map<std::string, KeyHandler*>::const_iterator mapIt = _getSingleton().keyHandlers_.find(name);
-        if (mapIt == _getSingleton().keyHandlers_.end())
-            return false;
-        // look for the handler in the list
-        for (std::vector<KeyHandler*>::iterator it = _getSingleton().activeKeyHandlers_.begin();
-            it != _getSingleton().activeKeyHandlers_.end(); it++)
-        {
-            if ((*it) == (*mapIt).second)
-            {
-                _getSingleton().activeKeyHandlers_.erase(it);
-                _getSingleton().stateRequest_ = IS_CUSTOM;
-                _getSingleton()._updateTickables();
-                return true;
-            }
-        }
-        return true;
-    }
-
-    /**
-    @brief
-        Checks whether a key handler is active
-    @param name
-        Unique name of the handler.
-    @return
-        False if key handler is not active or doesn't exist, true otherwise.
-    */
-    bool InputManager::isKeyHandlerActive(const std::string& name)
-    {
-        // get pointer from the map with all stored handlers
-        std::map<std::string, KeyHandler*>::const_iterator mapIt = _getSingleton().keyHandlers_.find(name);
-        if (mapIt == _getSingleton().keyHandlers_.end())
-            return false;
-        // see whether the handler already is in the list
-        for (std::vector<KeyHandler*>::iterator it = _getSingleton().activeKeyHandlers_.begin();
-            it != _getSingleton().activeKeyHandlers_.end(); it++)
-        {
-            if ((*it) == (*mapIt).second)
-                return true;
+        std::map<std::string, InputState*>::const_iterator it = _getInstance().inputStatesByName_.find(name);
+        if (it != _getInstance().inputStatesByName_.end())
+        {
+            _getInstance().stateLeaveRequests_.push_back((*it).second);
+            return true;
         }
         return false;
     }
-
-
-    // ###### MouseHandler ######
-    /**
-    @brief
-        Adds a new mouse handler.
-    @param handler
-        Pointer to the handler object.
-    @param name
-        Unique name of the handler.
-    @return
-        True if added, false if name already existed.
-    */
-    bool InputManager::addMouseHandler(MouseHandler* handler, const std::string& name)
-    {
-        if (!handler)
-            return false;
-        if (_getSingleton().mouseHandlers_.find(name) == _getSingleton().mouseHandlers_.end())
-        {
-            _getSingleton().mouseHandlers_[name] = handler;
-            return true;
-        }
-        else
-            return false;
-    }
-
-    /**
-    @brief
-        Removes a Mouse handler from the list.
-    @param name
-        Unique name of the handler.
-    @return
-        True if removal was successful, false if name was not found.
-    */
-    bool InputManager::removeMouseHandler(const std::string &name)
-    {
-        disableMouseHandler(name);
-        std::map<std::string, MouseHandler*>::iterator it = _getSingleton().mouseHandlers_.find(name);
-        if (it != _getSingleton().mouseHandlers_.end())
-        {
-            _getSingleton().mouseHandlers_.erase(it);
-            return true;
-        }
-        else
-            return false;
-    }
-
-    /**
-    @brief
-        Returns the pointer to a handler.
-    @param name
-        Unique name of the handler.
-    @return
-        Pointer to the instance, 0 if name was not found.
-    */
-    MouseHandler* InputManager::getMouseHandler(const std::string& name)
-    {
-        std::map<std::string, MouseHandler*>::iterator it = _getSingleton().mouseHandlers_.find(name);
-        if (it != _getSingleton().mouseHandlers_.end())
-        {
-            return (*it).second;
-        }
-        else
-            return 0;
-    }
-
-    /**
-    @brief
-        Enables a specific mouse handler that has already been added.
-    @param name
-        Unique name of the handler.
-    @return
-        False if name was not found, true otherwise.
-    */
-    bool InputManager::enableMouseHandler(const std::string& name)
-    {
-        // get pointer from the map with all stored handlers
-        std::map<std::string, MouseHandler*>::const_iterator mapIt = _getSingleton().mouseHandlers_.find(name);
-        if (mapIt == _getSingleton().mouseHandlers_.end())
-            return false;
-        // see whether the handler already is in the list
-        for (std::vector<MouseHandler*>::iterator it = _getSingleton().activeMouseHandlers_.begin();
-            it != _getSingleton().activeMouseHandlers_.end(); it++)
-        {
-            if ((*it) == (*mapIt).second)
-            {
-                return true;
-            }
-        }
-        _getSingleton().activeMouseHandlers_.push_back((*mapIt).second);
-        _getSingleton().stateRequest_ = IS_CUSTOM;
-        _getSingleton()._updateTickables();
-        return true;
-    }
-
-    /**
-    @brief
-        Disables a specific mouse handler.
-    @param name
-        Unique name of the handler.
-    @return
-        False if name was not found, true otherwise.
-    */
-    bool InputManager::disableMouseHandler(const std::string &name)
-    {
-        // get pointer from the map with all stored handlers
-        std::map<std::string, MouseHandler*>::const_iterator mapIt = _getSingleton().mouseHandlers_.find(name);
-        if (mapIt == _getSingleton().mouseHandlers_.end())
-            return false;
-        // look for the handler in the list
-        for (std::vector<MouseHandler*>::iterator it = _getSingleton().activeMouseHandlers_.begin();
-            it != _getSingleton().activeMouseHandlers_.end(); it++)
-        {
-            if ((*it) == (*mapIt).second)
-            {
-                _getSingleton().activeMouseHandlers_.erase(it);
-                _getSingleton().stateRequest_ = IS_CUSTOM;
-                _getSingleton()._updateTickables();
-                return true;
-            }
-        }
-        return true;
-    }
-
-    /**
-    @brief
-        Checks whether a mouse handler is active
-    @param name
-        Unique name of the handler.
-    @return
-        False if key handler is not active or doesn't exist, true otherwise.
-    */
-    bool InputManager::isMouseHandlerActive(const std::string& name)
-    {
-        // get pointer from the map with all stored handlers
-        std::map<std::string, MouseHandler*>::const_iterator mapIt = _getSingleton().mouseHandlers_.find(name);
-        if (mapIt == _getSingleton().mouseHandlers_.end())
-            return false;
-        // see whether the handler already is in the list
-        for (std::vector<MouseHandler*>::iterator it = _getSingleton().activeMouseHandlers_.begin();
-            it != _getSingleton().activeMouseHandlers_.end(); it++)
-        {
-            if ((*it) == (*mapIt).second)
-                return true;
-        }
-        return false;
-    }
-
-
-    // ###### JoyStickHandler ######
-
-    /**
-    @brief
-        Adds a new joy stick handler.
-    @param handler
-        Pointer to the handler object.
-    @param name
-        Unique name of the handler.
-    @return
-        True if added, false if name already existed.
-    */
-    bool InputManager::addJoyStickHandler(JoyStickHandler* handler, const std::string& name)
-    {
-        if (!handler)
-            return false;
-        if (_getSingleton().joyStickHandlers_.find(name) == _getSingleton().joyStickHandlers_.end())
-        {
-            _getSingleton().joyStickHandlers_[name] = handler;
-            return true;
-        }
-        else
-            return false;
-    }
-
-    /**
-    @brief
-        Removes a JoyStick handler from the list.
-    @param name
-        Unique name of the handler.
-    @return
-        True if removal was successful, false if name was not found.
-    */
-    bool InputManager::removeJoyStickHandler(const std::string &name)
-    {
-        for (std::vector<OIS::JoyStick*>::iterator itstick = _getSingleton().joySticks_.begin();
-            itstick != _getSingleton().joySticks_.end(); itstick++)
-            disableJoyStickHandler(name, itstick - _getSingleton().joySticks_.begin());
-
-        std::map<std::string, JoyStickHandler*>::iterator it = _getSingleton().joyStickHandlers_.find(name);
-        if (it != _getSingleton().joyStickHandlers_.end())
-        {
-            _getSingleton().joyStickHandlers_.erase(it);
-            return true;
-        }
-        else
-            return false;
-    }
-
-    /**
-    @brief
-        Returns the pointer to a handler.
-    @param name
-        Unique name of the handler.
-    @return
-        Pointer to the instance, 0 if name was not found.
-    */
-    JoyStickHandler* InputManager::getJoyStickHandler(const std::string& name)
-    {
-        std::map<std::string, JoyStickHandler*>::iterator it = _getSingleton().joyStickHandlers_.find(name);
-        if (it != _getSingleton().joyStickHandlers_.end())
-        {
-            return (*it).second;
-        }
-        else
-            return 0;
-    }
-
-    /**
-    @brief
-        Enables a specific joy stick handler that has already been added.
-    @param name
-        Unique name of the handler.
-    @return
-        False if name or id was not found, true otherwise.
-    */
-    bool InputManager::enableJoyStickHandler(const std::string& name, unsigned int ID)
-    {
-        // get handler pointer from the map with all stored handlers
-        std::map<std::string, JoyStickHandler*>::const_iterator handlerIt = _getSingleton().joyStickHandlers_.find(name);
-        if (handlerIt == _getSingleton().joyStickHandlers_.end())
-            return false;
-
-        // check for existence of the ID
-        if (ID >= _getSingleton().joySticksSize_)
-            return false;
-
-        // see whether the handler already is in the list
-        for (std::vector<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[ID].begin();
-            it != _getSingleton().activeJoyStickHandlers_[ID].end(); it++)
-        {
-            if ((*it) == (*handlerIt).second)
-            {
-                return true;
-            }
-        }
-        _getSingleton().activeJoyStickHandlers_[ID].push_back((*handlerIt).second);
-        _getSingleton().stateRequest_ = IS_CUSTOM;
-        _getSingleton()._updateTickables();
-        return true;
-    }
-
-    /**
-    @brief
-        Disables a specific joy stick handler.
-    @param name
-        Unique name of the handler.
-    @return
-        False if name or id was not found, true otherwise.
-    */
-    bool InputManager::disableJoyStickHandler(const std::string &name, unsigned int ID)
-    {
-        // get handler pointer from the map with all stored handlers
-        std::map<std::string, JoyStickHandler*>::const_iterator handlerIt = _getSingleton().joyStickHandlers_.find(name);
-        if (handlerIt == _getSingleton().joyStickHandlers_.end())
-            return false;
-
-        // check for existence of the ID
-        if (ID >= _getSingleton().joySticksSize_)
-            return false;
-
-        // look for the handler in the list
-        for (std::vector<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[ID].begin();
-            it != _getSingleton().activeJoyStickHandlers_[ID].end(); it++)
-        {
-            if ((*it) == (*handlerIt).second)
-            {
-                _getSingleton().activeJoyStickHandlers_[ID].erase(it);
-                _getSingleton().stateRequest_ = IS_CUSTOM;
-                _getSingleton()._updateTickables();
-                return true;
-            }
-        }
-        return true;
-    }
-
-    /**
-    @brief
-        Checks whether a joy stick handler is active
-    @param name
-        Unique name of the handler.
-    @return
-        False if key handler is not active or doesn't exist, true otherwise.
-    */
-    bool InputManager::isJoyStickHandlerActive(const std::string& name, unsigned int ID)
-    {
-        // get handler pointer from the map with all stored handlers
-        std::map<std::string, JoyStickHandler*>::const_iterator handlerIt = _getSingleton().joyStickHandlers_.find(name);
-        if (handlerIt == _getSingleton().joyStickHandlers_.end())
-            return false;
-
-        // check for existence of the ID
-        if (ID >= _getSingleton().joySticksSize_)
-            return false;
-
-        // see whether the handler already is in the list
-        for (std::vector<JoyStickHandler*>::iterator it = _getSingleton().activeJoyStickHandlers_[ID].begin();
-            it != _getSingleton().activeJoyStickHandlers_[ID].end(); it++)
-        {
-            if ((*it) == (*handlerIt).second)
-                return true;
-        }
-        return false;
-    }
-
 }

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

@@ -41 +41 @@
 #include <map>
 #include <vector>
+#include <stack>
 #include "util/Math.h"
 #include "core/OrxonoxClass.h"
@@ -68 +69 @@
     };
 
-    /**
-    @brief
-        Struct for storing a custom input state
-    */
-    struct StoredState
-    {
-        std::vector<KeyHandler*>                    activeKeyHandlers_;
-        std::vector<MouseHandler*>                  activeMouseHandlers_;
-        std::vector<std::vector<JoyStickHandler*> > activeJoyStickHandlers_;
-        std::vector<std::pair<InputTickable*, HandlerState> > activeHandlers_;
-    };
-
     struct JoyStickCalibration
     {
@@ -95 +84 @@
         public OIS::KeyListener, public OIS::MouseListener, public OIS::JoyStickListener
     {
-    public: // enumerations
-        /**
-        @brief
-            Designates the way input is handled and redirected.
-        */
-        enum InputState
-        {
-            IS_UNINIT,    //!< InputManager has not yet been initialised.
-            IS_NONE,      //!< Input is discarded.
-            IS_NORMAL,    //!< Normal play state. Key and button bindings are active.
-            IS_GUI,       //!< All OIS input events are passed to CEGUI.
-            IS_CONSOLE,   //!< Keyboard input is redirected to the InputBuffer.
-            IS_DETECT,    //!< All the input additionally goes to the KeyDetector
-            IS_NODETECT,  //!< remove KeyDetector
-            IS_NOCALIBRATE,
-            IS_CALIBRATE,
-            IS_CUSTOM     //!< Any possible configuration.
-        };
-
-    public: // member functions
-        void setConfigValues();
+        // --> setConfigValues is private
+        friend ClassIdentifier<InputManager>;
 
     public: // static functions
@@ -139 +109 @@
         static void setWindowExtents(const int width, const int height);
 
-        static void setInputState(const InputState state);
-        static InputState getInputState();
-
         static void storeKeyStroke(const std::string& name);
         static void keyBind(const std::string& command);
@@ -149 +116 @@
         static void tick(float dt);
 
-        static bool addKeyHandler                 (KeyHandler* handler, const std::string& name);
-        static bool removeKeyHandler              (const std::string& name);
-        static KeyHandler* getKeyHandler          (const std::string& name);
-        static bool enableKeyHandler              (const std::string& name);
-        static bool disableKeyHandler             (const std::string& name);
-        static bool isKeyHandlerActive            (const std::string& name);
-
-        static bool addMouseHandler               (MouseHandler* handler, const std::string& name);
-        static bool removeMouseHandler            (const std::string& name);
-        static MouseHandler* getMouseHandler      (const std::string& name);
-        static bool enableMouseHandler            (const std::string& name);
-        static bool disableMouseHandler           (const std::string& name);
-        static bool isMouseHandlerActive          (const std::string& name);
-
-        static bool addJoyStickHandler            (JoyStickHandler* handler, const std::string& name);
-        static bool removeJoyStickHandler         (const std::string& name);
-        static JoyStickHandler* getJoyStickHandler(const std::string& name);
-        static bool enableJoyStickHandler         (const std::string& name, unsigned int id);
-        static bool disableJoyStickHandler        (const std::string& name, unsigned int id);
-        static bool isJoyStickHandlerActive       (const std::string& name, unsigned int id);
+        static SimpleInputState*   createSimpleInputState  (const std::string& name, int priority);
+        static ExtendedInputState* createExtendedInputState(const std::string& name, int priority);
+        static bool destroyState (const std::string& name);
+        //static bool removeState (const std::string& name);
+        static InputState* getState       (const std::string& name);
+        static InputState* getCurrentState();
+        static bool requestEnterState     (const std::string& name);
+        static bool requestLeaveState     (const std::string& name);
 
     private: // functions
@@ -181 +136 @@
         bool _initialiseMouse();
         bool _initialiseJoySticks();
+        void _redimensionLists();
 
         void _destroy();
@@ -186 +142 @@
         void _destroyMouse();
         void _destroyJoySticks();
-
-        void _updateTickables();
-
-        void _saveState();
-        void _restoreState();
+        void _destroyState(InputState* state);
 
         void _completeCalibration();
@@ -198 +150 @@
 
         void _tick(float dt);
+
+        void _updateActiveStates();
+        bool _configureInputState(InputState* state, const std::string& name, int priority);
 
         // input events
@@ -210 +165 @@
         bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
         bool povMoved      (const OIS::JoyStickEvent &arg, int id);
-        //bool vector3Moved  (const OIS::JoyStickEvent &arg, int id);
-
-        static InputManager& _getSingleton();
-        static InputManager* _getSingletonPtr() { return &_getSingleton(); }
+
+        void setConfigValues();
+
+        static InputManager& _getInstance();
 
     private: // variables
@@ -221 +176 @@
         std::vector<OIS::JoyStick*>                 joySticks_;       //!< OIS joy sticks
         unsigned int                                joySticksSize_;
-
-        KeyBinder*                                  keyBinder_;       //!< KeyBinder instance
-        KeyDetector*                                keyDetector_;     //!< KeyDetector instance
-        InputBuffer*                                buffer_;          //!< InputBuffer instance
-        CalibratorCallback*                         calibratorCallback_;
-
-        InputState state_;
-        InputState stateRequest_;
-        InputState savedState_;
-        unsigned int keyboardModifiers_;
-        StoredState savedHandlers_;
+        unsigned int                                devicesNum_;
+
+        // some internally handled states
+        SimpleInputState*                                 stateDetector_;   //!< KeyDetector instance
+        SimpleInputState*                                 stateCalibrator_;
+        SimpleInputState*                                 stateEmpty_;
+
+        std::map<std::string, InputState*>          inputStatesByName_;
+        std::map<int, InputState*>                  inputStatesByPriority_;
+
+        std::vector<InputState*> stateEnterRequests_;                  //!< Request to enter a new state
+        std::vector<InputState*> stateLeaveRequests_;                    //!< Request to leave the current state
+
+        std::map<int, InputState*> activeStates_;
+        std::vector<InputState*>   activeStatesTop_;    //!< Current input states for joy stick events.
+        std::vector<InputState*>   activeStatesTicked_;    //!< Current input states for joy stick events.
 
         // joystick calibration
@@ -239 +199 @@
         int marginalsMin_[24];
         bool bCalibrated_;
-
+        bool bCalibrating_;
+
+        unsigned int keyboardModifiers_;           //!< Bit mask representing keyboard modifiers
         //! Keeps track of the joy stick POV states
         std::vector<POVStates>                      povStates_;
@@ -246 +208 @@
         std::vector<JoyStickCalibration>            joySticksCalibration_;
 
-        std::map<std::string, KeyHandler*>          keyHandlers_;
-        std::map<std::string, MouseHandler*>        mouseHandlers_;
-        std::map<std::string, JoyStickHandler*>     joyStickHandlers_;
-
-        std::vector<KeyHandler*>                    activeKeyHandlers_;
-        std::vector<MouseHandler*>                  activeMouseHandlers_;
-        std::vector<std::vector<JoyStickHandler*> > activeJoyStickHandlers_;
-        std::vector<std::pair<InputTickable*, HandlerState> > activeHandlers_;
-
         std::vector<Key>                            keysDown_;
         std::vector<MouseButton::Enum>              mouseButtonsDown_;

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

@@ -333 +333 @@
     }
 
-    void KeyBinder::tickInput(float dt, const HandlerState& state)
-    {
-        // we have to process all the analog input since there is e.g. no 'mouseDoesntMove' event.
-        unsigned int iBegin = 8;
-        unsigned int iEnd   = 8;
-        if (state.joyStick)
-            iEnd = nHalfAxes_s;
-        if (state.mouse)
-            iBegin = 0;
-        for (unsigned int i = iBegin; i < iEnd; i++)
-        {
-            if (halfAxes_[i].hasChanged_)
-            {
-                if (!halfAxes_[i].wasDown_ && halfAxes_[i].absVal_ > halfAxes_[i].buttonThreshold_)
-                {
-                    halfAxes_[i].wasDown_ = true;
-                    if (halfAxes_[i].nCommands_[KeybindMode::OnPress])
-                        halfAxes_[i].execute(KeybindMode::OnPress);
-                }
-                else if (halfAxes_[i].wasDown_ && halfAxes_[i].absVal_ < halfAxes_[i].buttonThreshold_)
-                {
-                    halfAxes_[i].wasDown_ = false;
-                    if (halfAxes_[i].nCommands_[KeybindMode::OnRelease])
-                        halfAxes_[i].execute(KeybindMode::OnRelease);
-                }
-                halfAxes_[i].hasChanged_ = false;
-            }
-
-            if (halfAxes_[i].wasDown_)
-            {
-                if (halfAxes_[i].nCommands_[KeybindMode::OnHold])
-                    halfAxes_[i].execute(KeybindMode::OnHold);
-            }
-
-            // these are the actually useful axis bindings for analog input AND output
-            if (halfAxes_[i].relVal_ > analogThreshold_ || halfAxes_[i].absVal_ > analogThreshold_)
-            {
-                //COUT(3) << halfAxes_[i].name_ << "\t" << halfAxes_[i].absVal_ << std::endl;
-                halfAxes_[i].execute();
-            }
-        }
-
-        if (bDeriveMouseInput_ && state.mouse)
+    void KeyBinder::tickMouse(float dt)
+    {
+        tickDevices(0, 8);
+
+        if (bDeriveMouseInput_)
         {
             if (deriveTime_ > derivePeriod_)
@@ -410 +372 @@
                 deriveTime_ += dt;
         }
-
-        // execute all buffered bindings (addional parameter)
+    }
+
+    void KeyBinder::tickJoyStick(float dt, int device)
+    {
+        tickDevices(8, nHalfAxes_s);
+    }
+
+    void KeyBinder::tickInput(float dt)
+    {
+        // execute all buffered bindings (additional parameter)
         for (unsigned int i = 0; i < paramCommandBuffer_.size(); i++)
             paramCommandBuffer_[i]->execute();
 
         // always reset the relative movement of the mouse
-        if (state.mouse)
-            for (unsigned int i = 0; i < 8; i++)
-                halfAxes_[i].relVal_ = 0.0f;
+        for (unsigned int i = 0; i < 8; i++)
+            halfAxes_[i].relVal_ = 0.0f;
+    }
+
+    void KeyBinder::tickDevices(unsigned int begin, unsigned int end)
+    {
+        for (unsigned int i = begin; i < end; i++)
+        {
+            // button mode
+            // TODO: optimize out all the half axes that don't act as a button at the moment
+            if (halfAxes_[i].hasChanged_)
+            {
+                if (!halfAxes_[i].wasDown_ && halfAxes_[i].absVal_ > halfAxes_[i].buttonThreshold_)
+                {
+                    halfAxes_[i].wasDown_ = true;
+                    if (halfAxes_[i].nCommands_[KeybindMode::OnPress])
+                        halfAxes_[i].execute(KeybindMode::OnPress);
+                }
+                else if (halfAxes_[i].wasDown_ && halfAxes_[i].absVal_ < halfAxes_[i].buttonThreshold_)
+                {
+                    halfAxes_[i].wasDown_ = false;
+                    if (halfAxes_[i].nCommands_[KeybindMode::OnRelease])
+                        halfAxes_[i].execute(KeybindMode::OnRelease);
+                }
+                halfAxes_[i].hasChanged_ = false;
+            }
+
+            if (halfAxes_[i].wasDown_)
+            {
+                if (halfAxes_[i].nCommands_[KeybindMode::OnHold])
+                    halfAxes_[i].execute(KeybindMode::OnHold);
+            }
+
+            // these are the actually useful axis bindings for analog input
+            if (halfAxes_[i].relVal_ > analogThreshold_ || halfAxes_[i].absVal_ > analogThreshold_)
+            {
+                //COUT(3) << halfAxes_[i].name_ << "\t" << halfAxes_[i].absVal_ << std::endl;
+                halfAxes_[i].execute();
+            }
+        }
     }
 
@@ -441 +448 @@
 
 
-    void KeyBinder::joyStickButtonPressed (int joyStickID, int button)
+    void KeyBinder::joyStickButtonPressed (unsigned int joyStickID, unsigned int button)
     { joyStickButtons_[button].execute(KeybindMode::OnPress); }
 
-    void KeyBinder::joyStickButtonReleased(int joyStickID, int button)
+    void KeyBinder::joyStickButtonReleased(unsigned int joyStickID, unsigned int button)
     { joyStickButtons_[button].execute(KeybindMode::OnRelease); }
 
-    void KeyBinder::joyStickButtonHeld    (int joyStickID, int button)
+    void KeyBinder::joyStickButtonHeld    (unsigned int joyStickID, unsigned int button)
     { joyStickButtons_[button].execute(KeybindMode::OnHold); }
 
@@ -525 +532 @@
     }
 
-    void KeyBinder::joyStickAxisMoved(int joyStickID, int axis, float value)
-    {
-        // TODO: Use proper calibration values instead of generally 16-bit integer
+    void KeyBinder::joyStickAxisMoved(unsigned int joyStickID, unsigned int axis, float value)
+    {
         int i = 8 + axis * 2;
         if (value >= 0)

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

@@ -64 +64 @@
 
     protected: // functions
-        void tickInput(float dt, const HandlerState& state);
+        void tickInput(float dt);
+        //void tickInput(float dt, int device);
+        void tickKey(float dt) { }
+        void tickMouse(float dt);
+        void tickJoyStick(float dt, int device);
+        void tickDevices(unsigned int begin, unsigned int end);
 
         virtual void readTrigger(Button& button);
@@ -78 +83 @@
         void mouseScrolled      (int abs, int rel);
 
-        void joyStickButtonPressed (int joyStickID, int button);
-        void joyStickButtonReleased(int joyStickID, int button);
-        void joyStickButtonHeld    (int joyStickID, int button);
-        void joyStickAxisMoved     (int joyStickID, int axis, float value);
+        void joyStickButtonPressed (unsigned int joyStickID, unsigned int button);
+        void joyStickButtonReleased(unsigned int joyStickID, unsigned int button);
+        void joyStickButtonHeld    (unsigned int joyStickID, unsigned int button);
+        void joyStickAxisMoved     (unsigned int joyStickID, unsigned int axis, float value);
 
     protected: // variables

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

@@ -66 +66 @@
         True if loading succeeded.
     */
-    void KeyDetector::loadBindings()
+    void KeyDetector::loadBindings(const std::string& command)
     {
         clearBindings();
         setConfigValues();
+        this->command_ = command;
     }
 
@@ -75 +76 @@
     {
         SimpleCommand* cmd = new SimpleCommand();
-        cmd->evaluation_ = CommandExecutor::evaluate("storeKeyStroke " + button.name_);
+        cmd->evaluation_ = CommandExecutor::evaluate(this->command_ + " " + button.name_);
         button.commands_[KeybindMode::OnPress] = new BaseCommand*[1];
         button.commands_[KeybindMode::OnPress][0] = cmd;

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

@@ -47 +47 @@
         KeyDetector();
         ~KeyDetector();
-        void loadBindings();
+        void loadBindings(const std::string& command);
 
     protected:
         void readTrigger(Button& button);
+
+    private:
+        std::string command_;
     };
 }