Changeset 6412 for code/branches/pickup2/src/libraries/core/input

Timestamp:

Dec 25, 2009, 1:18:03 PM (15 years ago)

Author:

dafrick

Message:

Merged presentation2 branch into pickup2 branch.

Location:

code/branches/pickup2

Files:

• . (modified) (1 prop)
• src/libraries/core/input/Button.cc (modified) (4 diffs)
• src/libraries/core/input/Button.h (modified) (1 diff)
• src/libraries/core/input/InputBuffer.cc (modified) (9 diffs)
• src/libraries/core/input/InputBuffer.h (modified) (3 diffs)
• src/libraries/core/input/InputCommands.h (modified) (1 diff)
• src/libraries/core/input/InputDevice.h (modified) (2 diffs)
• src/libraries/core/input/InputHandler.h (modified) (2 diffs)
• src/libraries/core/input/InputManager.cc (modified) (13 diffs)
• src/libraries/core/input/InputManager.h (modified) (11 diffs)
• src/libraries/core/input/InputPrereqs.h (modified) (1 diff)
• src/libraries/core/input/InputState.cc (modified) (1 diff)
• src/libraries/core/input/JoyStick.cc (modified) (3 diffs)
• src/libraries/core/input/JoyStickQuantityListener.h (modified) (1 diff)
• src/libraries/core/input/KeyBinder.cc (modified) (15 diffs)
• src/libraries/core/input/KeyBinder.h (modified) (9 diffs)
• src/libraries/core/input/KeyBinderManager.cc (modified) (7 diffs)
• src/libraries/core/input/KeyBinderManager.h (modified) (7 diffs)
• src/libraries/core/input/KeyDetector.cc (modified) (2 diffs)
• src/libraries/core/input/KeyDetector.h (modified) (3 diffs)
• src/libraries/core/input/Keyboard.cc (modified) (1 diff)

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

@@ -116 +116 @@
         for (unsigned int iCommand = 0; iCommand < commandStrings.size(); iCommand++)
         {
-            if (commandStrings[iCommand] != "")
+            if (!commandStrings[iCommand].empty())
             {
                 SubString tokens(commandStrings[iCommand], " ", SubString::WhiteSpaces, false,
@@ -123 +123 @@
                 KeybindMode::Value mode = KeybindMode::None;
                 float paramModifier = 1.0f;
-                std::string commandStr = "";
+                std::string commandStr;
 
                 for (unsigned int iToken = 0; iToken < tokens.size(); ++iToken)
                 {
-                    std::string token = getLowercase(tokens[iToken]);
+                    const std::string& token = getLowercase(tokens[iToken]);
 
                     if (token == "onpress")
@@ -159 +159 @@
                         // we interpret everything from here as a command string
                         while (iToken != tokens.size())
-                            commandStr += tokens[iToken++] + " ";
-                    }
-                }
-
-                if (commandStr == "")
+                            commandStr += tokens[iToken++] + ' ';
+                    }
+                }
+
+                if (commandStr.empty())
                 {
                     parseError("No command string given.", false);
@@ -242 +242 @@
     }
 
-    inline void Button::parseError(std::string message, bool serious)
+    inline void Button::parseError(const std::string& message, bool serious)
     {
         if (serious)

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

@@ -76 +76 @@
 
     private:
-        void parseError(std::string message, bool serious);
+        void parseError(const std::string& message, bool serious);
     };
 

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

@@ -39 +39 @@
         RegisterRootObject(InputBuffer);
 
-        this->buffer_ = "";
         this->cursor_ = 0;
+        this->maxLength_ = 1024;
         this->allowedChars_ = "abcdefghijklmnopqrstuvwxyz \
                                ABCDEFGHIJKLMNOPQRSTUVWXYZ \
@@ -59 +59 @@
         RegisterRootObject(InputBuffer);
 
+        this->maxLength_ = 1024;
         this->allowedChars_ = allowedChars;
-        this->buffer_ = "";
         this->cursor_ = 0;
 
@@ -80 +80 @@
     void InputBuffer::setConfigValues()
     {
-        SetConfigValue(keyRepeatDeleay_, 0.4).description("Key repeat deleay of the input buffer");
+        SetConfigValue(keyRepeatDeleay_, 0.4).description("Key repeat delay of the input buffer");
         SetConfigValue(keyRepeatTime_, 0.022).description("Key repeat time of the input buffer");
 
@@ -91 +91 @@
             ResetConfigValue(keyRepeatTime_);
         }
+    }
+
+    void InputBuffer::setMaxLength(unsigned int length)
+    {
+        this->maxLength_ = length;
+        if (this->buffer_.size() > length)
+            this->buffer_.resize(length);
     }
 
@@ -117 +124 @@
         if (this->charIsAllowed(input))
         {
+            if (this->buffer_.size() >= this->maxLength_)
+                return;
             this->buffer_.insert(this->cursor_, 1, input);
             ++this->cursor_;
@@ -127 +136 @@
     void InputBuffer::clear(bool update)
     {
-        this->buffer_ = "";
+        this->buffer_.clear();
         this->cursor_ = 0;
 
@@ -177 +186 @@
     bool InputBuffer::charIsAllowed(const char& input)
     {
-        if (this->allowedChars_ == "")
+        if (this->allowedChars_.empty())
             return true;
         else
@@ -186 +195 @@
     void InputBuffer::processKey(const KeyEvent& evt)
     {
+        // Prevent disaster when switching applications
         if (evt.isModifierDown(KeyboardModifier::Alt) && evt.getKeyCode() == KeyCode::Tab)
             return;
@@ -222 +232 @@
 
     /**
-        @brief This update() function is called by the InputManager if the InputBuffer is active.
+        @brief This update() function is called by the InputState if the InputBuffer is active.
         @param dt Delta time
     */

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

@@ -83 +83 @@
             void setConfigValues();
 
+            unsigned int getMaxLength() const { return this->maxLength_; }
+            void setMaxLength(unsigned int length);
+
             template <class T>
             void registerListener(T* listener, void (T::*function)(), bool bOnlySingleInput)
@@ -162 +165 @@
                 { if (this->cursor_ > 0) { --this->cursor_; } }
 
+            void buttonPressed(const KeyEvent& evt);
+
         private:
             bool charIsAllowed(const char& input);
 
-            void buttonPressed(const KeyEvent& evt);
             void buttonHeld   (const KeyEvent& evt);
             void processKey   (const KeyEvent& evt);
@@ -174 +178 @@
             std::list<BaseInputBufferListenerTuple*> listeners_;
             std::string allowedChars_;
+            unsigned int maxLength_;
             unsigned int cursor_;
 

code/branches/pickup2/src/libraries/core/input/InputCommands.h

@@ -71 +71 @@
     @brief
         Executes a simple command with no additional paramters.
-    @return 
+    @return
         True if command execution was successful, false otherwise.
     */

code/branches/pickup2/src/libraries/core/input/InputDevice.h

@@ -203 +203 @@
         {
             // remove the button from the pressedButtons_ list
+            bool found = false;
             for (unsigned int iButton = 0; iButton < pressedButtons_.size(); iButton++)
             {
@@ -208 +209 @@
                 {
                     pressedButtons_.erase(pressedButtons_.begin() + iButton);
+                    found = true;
                     break;
                 }
             }
+            if (!found)
+                return; // We ignore release strokes when the press was not captured
 
             // Call states

code/branches/pickup2/src/libraries/core/input/InputHandler.h

@@ -73 +73 @@
             , modifiers_(0)
         { }
+        KeyEvent(KeyCode::ByEnum key, unsigned int text, int modifiers)
+            : key_(key)
+            , text_(text)
+            , modifiers_(modifiers)
+        { }
         bool operator==(const KeyEvent& rhs) const
             { return rhs.key_ == key_; }
@@ -97 +102 @@
 
         Derive from this class if you wish to receive input events.
-        But keep in mind that this is pointless wihtout first having an InputState.
+        But keep in mind that this is pointless without 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.
+        to avoid redundant code in the input devices.
     */
     class _CoreExport InputHandler

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

@@ -48 +48 @@
 #include "core/ConfigValueIncludes.h"
 #include "core/ConsoleCommand.h"
-#include "core/CommandLine.h"
+#include "core/CommandLineParser.h"
 #include "core/Functor.h"
 #include "core/GraphicsManager.h"
@@ -170 +170 @@
         if (mouseMode_ == MouseMode::Exclusive || GraphicsManager::getInstance().isFullScreen())
         {
-            if (CommandLine::getValue("keyboard_no_grab").getBool())
+            if (CommandLineParser::getValue("keyboard_no_grab").getBool())
                 paramList.insert(std::make_pair("x11_keyboard_grab", "false"));
             else
@@ -190 +190 @@
             // Exception-safety
             Loki::ScopeGuard guard = Loki::MakeGuard(OIS::InputManager::destroyInputSystem, oisInputManager_);
-            CCOUT(ORX_DEBUG) << "Created OIS input manager." << std::endl;
+            CCOUT(4) << "Created OIS input manager." << std::endl;
 
             if (oisInputManager_->getNumberOfDevices(OIS::OISKeyboard) > 0)
@@ -232 +232 @@
         }
         else
-            CCOUT(ORX_WARNING) << "Warning: No mouse found! Proceeding without mouse support." << std::endl;
+            CCOUT(2) << "Warning: No mouse found! Proceeding without mouse support." << std::endl;
     }
 
@@ -275 +275 @@
         // destroy all user InputStates
         while (statesByName_.size() > 0)
-            this->destroyStateInternal((*statesByName_.rbegin()).second);
+            this->destroyStateInternal(statesByName_.rbegin()->second);
 
         if (!(internalState_ & Bad))
@@ -297 +297 @@
             if (device == NULL)
                 continue;
-            std::string className = device->getClassName();
+            const std::string& className = device->getClassName();
             try
             {
@@ -366 +366 @@
     // ############################################################
 
-    void InputManager::update(const Clock& time)
+    void InputManager::preUpdate(const Clock& time)
     {
         if (internalState_ & Bad)
@@ -466 +466 @@
     @brief
         Updates the currently active states (according to activeStates_) for each device.
-        Also, a list of all active states (no duplicates!) is compiled for the general update().
+        Also, a list of all active states (no duplicates!) is compiled for the general preUpdate().
     */
     void InputManager::updateActiveStates()
@@ -508 +508 @@
         if (mouseStates.empty())
             requestedMode = MouseMode::Nonexclusive;
-        else 
+        else
             requestedMode = mouseStates.front()->getMouseMode();
         if (requestedMode != MouseMode::Dontcare && mouseMode_ != requestedMode)
@@ -554 +554 @@
     }
 
-    //! Gets called by WindowEventListener upon focus change --> clear buffers 
+    //! Gets called by WindowEventListener upon focus change --> clear buffers
     void InputManager::windowFocusChanged()
     {
@@ -579 +579 @@
     InputState* InputManager::createInputState(const std::string& name, bool bAlwaysGetsInput, bool bTransparent, InputStatePriority priority)
     {
-        if (name == "")
+        if (name.empty())
             return 0;
         if (statesByName_.find(name) == statesByName_.end())
@@ -631 +631 @@
                 {
                     // not scheduled for destruction
-                    // prevents a state being added multiple times
+                    // prevents a state from being added multiple times
                     stateEnterRequests_.insert(it->second);
                     return true;
                 }
             }
+            else if (this->stateLeaveRequests_.find(it->second) != this->stateLeaveRequests_.end())
+            {
+                // State already scheduled for leaving --> cancel
+                this->stateLeaveRequests_.erase(this->stateLeaveRequests_.find(it->second));
+            }
         }
         return false;
@@ -658 +663 @@
                 return true;
             }
+            else if (this->stateEnterRequests_.find(it->second) != this->stateEnterRequests_.end())
+            {
+                // State already scheduled for entering --> cancel
+                this->stateEnterRequests_.erase(this->stateEnterRequests_.find(it->second));
+            }
         }
         return false;

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

@@ -41 +41 @@
 #include "InputState.h"
 
+// tolua_begin
 namespace orxonox
 {
@@ -47 +48 @@
         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
+        Every input device has its own wrapper class which does the actually input event
         distribution. The InputManager only creates reloads (on request) those devices.
 
@@ -58 +59 @@
           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
+          You best access them internally 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 _CoreExport InputManager : public Singleton<InputManager>, public WindowEventListener
-    {
+    class _CoreExport InputManager
+// tolua_end
+        : public Singleton<InputManager>, public WindowEventListener
+    { // tolua_export
         friend class Singleton<InputManager>;
     public:
@@ -80 +83 @@
         @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.
@@ -94 +97 @@
 
             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);
+            was submitted while updating, the request will be postponed until the next update call.
+        */
+        void preUpdate(const Clock& time);
         //! Clears all input device buffers. This usually only includes the pressed button list.
         void clearBuffers();
@@ -105 +108 @@
             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.
+            Only reloads immediately if the call stack doesn't include the preUpdate() method.
         */
         void reload();
@@ -135 +138 @@
         @brief
             Activates a specific input state.
-            It might not be actually activated if the priority is too low!
+            It might not actually be activated if the priority is too low!
         @return
             False if name was not found, true otherwise.
         */
-        bool enterState(const std::string& name);
+        bool enterState(const std::string& name); // tolua_export
         /**
         @brief
@@ -146 +149 @@
             False if name was not found, true otherwise.
         */
-        bool leaveState(const std::string& name);
+        bool leaveState(const std::string& name); // tolua_export
         /**
         @brief
@@ -154 +157 @@
         @remarks
             - You can't remove the internal states "empty", "calibrator" and "detector".
-            - The removal process is being postponed if InputManager::update() is currently running.
+            - The removal process is being postponed if InputManager::preUpdate() is currently running.
         */
         bool destroyState(const std::string& name);
@@ -168 +171 @@
         std::pair<int, int> getMousePosition() const;
 
+        static InputManager& getInstance() { return Singleton<InputManager>::getInstance(); } // tolua_export
+
     private: // functions
         // don't mess with a Singleton
         InputManager(const InputManager&);
 
-        // Intenal methods
+        // Internal methods
         void loadDevices();
         void loadMouse();
@@ -207 +212 @@
 
         static InputManager*                singletonPtr_s;        //!< Pointer reference to the singleton
-    };
-}
+    }; // tolua_export
+} // tolua_export
 
 #endif /* _InputManager_H__ */

code/branches/pickup2/src/libraries/core/input/InputPrereqs.h

@@ -202 +202 @@
             MediaSelect   = OIS::KC_MEDIASELECT      // Media Select
         };
-        
+
         //! Key codes as strings
         const char* const ByString[] =

code/branches/pickup2/src/libraries/core/input/InputState.cc

@@ -102 +102 @@
         if (enterFunctor_)
             (*enterFunctor_)();
-            
+
     }
 

code/branches/pickup2/src/libraries/core/input/JoyStick.cc

@@ -33 +33 @@
 #include <boost/foreach.hpp>
 
+#include "util/StringUtils.h"
 #include "core/ConfigFileManager.h"
 #include "core/ConfigValueIncludes.h"
@@ -61 +62 @@
             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_ = 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));
@@ -74 +75 @@
             {
                 // Make the ID unique for this execution time.
-                deviceName_ += "_" + multi_cast<std::string>(this->getDeviceName());
+                deviceName_ += '_' + multi_cast<std::string>(this->getDeviceName());
                 break;
             }

code/branches/pickup2/src/libraries/core/input/JoyStickQuantityListener.h

@@ -29 +29 @@
 /**
 @file
-@brief 
+@brief
 */
 

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

@@ -29 +29 @@
 #include "KeyBinder.h"
 
+#include <algorithm>
+#include <sstream>
 #include "util/Convert.h"
 #include "util/Debug.h"
@@ -50 +52 @@
         mouseRelative_[0] = 0;
         mouseRelative_[1] = 0;
-        mousePosition_[0] = 0;
-        mousePosition_[1] = 0;
+        mousePosition_[0] = 0.0;
+        mousePosition_[1] = 0.0;
 
         RegisterRootObject(KeyBinder);
@@ -59 +61 @@
         for (unsigned int i = 0; i < KeyCode::numberOfKeys; i++)
         {
-            std::string keyname = KeyCode::ByString[i];
+            const std::string& keyname = KeyCode::ByString[i];
             if (!keyname.empty())
                 keys_[i].name_ = std::string("Key") + keyname;
             else
-                keys_[i].name_ = "";
+                keys_[i].name_.clear();
             keys_[i].paramCommandBuffer_ = &paramCommandBuffer_;
             keys_[i].groupName_ = "Keys";
@@ -126 +128 @@
         SetConfigValue(bFilterAnalogNoise_, false)
             .description("Specifies whether to filter small analog values like joy stick fluctuations.");
-        SetConfigValue(mouseSensitivity_, 1.0f)
+        SetConfigValue(mouseSensitivity_, 3.0f)
             .description("Mouse sensitivity.");
+        this->totalMouseSensitivity_ = this->mouseSensitivity_ / this->mouseClippingSize_;
         SetConfigValue(bDeriveMouseInput_, false)
             .description("Whether or not to derive moues movement for the absolute value.");
@@ -185 +188 @@
         this->joyStickButtons_.resize(joySticks_.size());
 
-        // reinitialise all joy stick binings (doesn't overwrite the old ones)
+        // reinitialise all joy stick bindings (doesn't overwrite the old ones)
         for (unsigned int iDev = 0; iDev < joySticks_.size(); iDev++)
         {
-            std::string deviceName = joySticks_[iDev]->getDeviceName();
+            const std::string& deviceName = joySticks_[iDev]->getDeviceName();
             // joy stick buttons
             for (unsigned int i = 0; i < JoyStickButtonCode::numberOfButtons; i++)
@@ -218 +221 @@
         for (unsigned int i = 0; i < KeyCode::numberOfKeys; i++)
             if (!keys_[i].name_.empty())
-                allButtons_[keys_[i].groupName_ + "." + 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].groupName_ + "." + 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].groupName_ + "." + mouseAxes_[i].name_] = mouseAxes_ + i;
+            allButtons_[mouseAxes_[i].groupName_ + '.' + mouseAxes_[i].name_] = mouseAxes_ + i;
             allHalfAxes_.push_back(mouseAxes_ + i);
         }
@@ -229 +232 @@
         {
             for (unsigned int i = 0; i < JoyStickButtonCode::numberOfButtons; i++)
-                allButtons_[(*joyStickButtons_[iDev])[i].groupName_ + "." + (*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].groupName_ + "." + (*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]));
             }
@@ -253 +256 @@
         // Parse bindings and create the ConfigValueContainers if necessary
         for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
+        {
             it->second->readConfigValue(this->configFile_);
+            addButtonToCommand(it->second->bindingString_, it->second);
+        }
 
         COUT(3) << "KeyBinder: Loading key bindings done." << std::endl;
@@ -263 +269 @@
         if (it != allButtons_.end())
         {
+            addButtonToCommand(binding, it->second);
             if (bTemporary)
                 it->second->configContainer_->tset(binding);
@@ -275 +282 @@
             return false;
         }
+    }
+
+     void KeyBinder::addButtonToCommand(const std::string& command, Button* button)
+     {
+        std::ostringstream stream;
+        stream << button->groupName_  << '.' << button->name_;
+
+        std::vector<std::string>& oldKeynames = this->allCommands_[button->bindingString_];
+        std::vector<std::string>::iterator it = std::find(oldKeynames.begin(), oldKeynames.end(), stream.str());
+        if(it != oldKeynames.end())
+        {
+            oldKeynames.erase(it);
+        }
+
+        if (!command.empty())
+        {
+            std::vector<std::string>& keynames = this->allCommands_[command];
+            if( std::find(keynames.begin(), keynames.end(), stream.str()) == keynames.end())
+            {
+                this->allCommands_[command].push_back(stream.str());
+            }
+        }
+     }
+
+    /**
+    @brief
+        Return the first key name for a specific command
+    */
+    const std::string& KeyBinder::getBinding(const std::string& commandName)
+    {
+        if( this->allCommands_.find(commandName) != this->allCommands_.end())
+        {
+            std::vector<std::string>& keynames = this->allCommands_[commandName];
+            return keynames.front();
+        }
+
+        return BLANKSTRING;
+    }
+
+    /**
+    @brief
+        Return the key name for a specific command at a given index.
+    @param commandName
+        The command name the key name is returned for.
+    @param index
+        The index at which the key name is returned for.
+    */
+    const std::string& KeyBinder::getBinding(const std::string& commandName, unsigned int index)
+    {
+        if( this->allCommands_.find(commandName) != this->allCommands_.end())
+        {
+            std::vector<std::string>& keynames = this->allCommands_[commandName];
+            if(index < keynames.size())
+            {
+                return keynames[index];
+            }
+
+            return BLANKSTRING;
+        }
+
+        return BLANKSTRING;
+    }
+
+    /**
+    @brief
+        Get the number of different key bindings of a specific command.
+    @param commandName
+        The command.
+    */
+    unsigned int KeyBinder::getNumberOfBindings(const std::string& commandName)
+    {
+        if( this->allCommands_.find(commandName) != this->allCommands_.end())
+        {
+            std::vector<std::string>& keynames = this->allCommands_[commandName];
+            return keynames.size();
+        }
+
+        return 0;
     }
 
@@ -395 +480 @@
 
         // these are the actually useful axis bindings for analog input
-        if (!bFilterAnalogNoise_ || halfAxis.relVal_ > analogThreshold_ || halfAxis.absVal_ > analogThreshold_)
-        {
-            halfAxis.execute();
-        }
+        halfAxis.execute();
     }
 
@@ -426 +508 @@
                     mouseAxes_[2*i + 0].hasChanged_ = true;
                     mouseAxes_[2*i + 1].hasChanged_ = true;
-                    mousePosition_[i] += rel[i];
+                    mousePosition_[i] += rel[i] * totalMouseSensitivity_;
 
                     // clip absolute position
-                    if (mousePosition_[i] > mouseClippingSize_)
-                        mousePosition_[i] =  mouseClippingSize_;
-                    if (mousePosition_[i] < -mouseClippingSize_)
-                        mousePosition_[i] = -mouseClippingSize_;
-
-                    if (mousePosition_[i] < 0)
+                    if (mousePosition_[i] > 1.0)
+                        mousePosition_[i] =  1.0;
+                    if (mousePosition_[i] < -1.0)
+                        mousePosition_[i] = -1.0;
+
+                    if (mousePosition_[i] < 0.0)
                     {
-                        mouseAxes_[2*i + 0].absVal_ = -mouseSensitivity_ * mousePosition_[i] / mouseClippingSize_;
+                        mouseAxes_[2*i + 0].absVal_ = -mousePosition_[i];
                         mouseAxes_[2*i + 1].absVal_ = 0.0f;
                     }
@@ -442 +524 @@
                     {
                         mouseAxes_[2*i + 0].absVal_ = 0.0f;
-                        mouseAxes_[2*i + 1].absVal_ =  mouseSensitivity_ * mousePosition_[i] / mouseClippingSize_;
+                        mouseAxes_[2*i + 1].absVal_ =  mousePosition_[i];
                     }
                 }
@@ -452 +534 @@
         {
             if (rel[i] < 0)
-                mouseAxes_[0 + 2*i].relVal_ = -mouseSensitivity_ * rel[i] / mouseClippingSize_;
+                mouseAxes_[0 + 2*i].relVal_ = -rel[i] * totalMouseSensitivity_;
             else
-                mouseAxes_[1 + 2*i].relVal_ =  mouseSensitivity_ * rel[i] / mouseClippingSize_;
+                mouseAxes_[1 + 2*i].relVal_ =  rel[i] * totalMouseSensitivity_;
         }
     }
@@ -474 +556 @@
     void KeyBinder::axisMoved(unsigned int device, unsigned int axisID, float value)
     {
+        // Filter analog noise
+        if (this->bFilterAnalogNoise_ && std::abs(value) < this->analogThreshold_)
+            value = 0.0;
         int i = axisID * 2;
         JoyStickAxisVector& axis = *joyStickAxes_[device];

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

@@ -35 +35 @@
 #include <string>
 #include <vector>
+#include <map>
 #include <boost/shared_ptr.hpp>
 
@@ -43 +44 @@
 #include "JoyStickQuantityListener.h"
 
+// tolua_begin
 namespace orxonox
 {
+    // tolua_end
     /**
     @brief
@@ -54 +57 @@
         KeyBinders. If you need to load other bindings, just create a new one.
     */
-    class _CoreExport KeyBinder : public InputHandler, public JoyStickQuantityListener
-    {
+    class _CoreExport KeyBinder // tolua_export
+        : public InputHandler, public JoyStickQuantityListener
+    { // tolua_export
     public:
         KeyBinder (const std::string& filename);
@@ -62 +66 @@
         void clearBindings();
         bool setBinding(const std::string& binding, const std::string& name, bool bTemporary = false);
+        const std::string& getBinding(const std::string& commandName); //tolua_export
+        const std::string& getBinding(const std::string& commandName, unsigned int index); //tolua_export
+        unsigned int getNumberOfBindings(const std::string& commandName); //tolua_export
+
         const std::string& getBindingsFilename()
             { return this->filename_; }
@@ -130 +138 @@
         //! Pointer list with all half axes
         std::vector<HalfAxis*> allHalfAxes_;
+        //! Maps input commands to all Button names, including half axes
+        std::map< std::string, std::vector<std::string> > allCommands_;
 
         /**
@@ -138 +148 @@
         std::vector<BufferedParamCommand*> paramCommandBuffer_;
 
-        //! Keeps track of the absolute mouse value (incl. scroll wheel)
-        int mousePosition_[2];
+        //! Keeps track of the absolute mouse value
+        float mousePosition_[2];
         //! Used to derive mouse input if requested
         int mouseRelative_[2];
@@ -150 +160 @@
 
     private:
+        void addButtonToCommand(const std::string& command, Button* button);
+
         //##### ConfigValues #####
         //! Whether to filter small value analog input
@@ -165 +177 @@
         //! mouse sensitivity if mouse input is derived
         float mouseSensitivityDerived_;
-        //! Equals one step of the mousewheel
+        //! Equals one step of the mouse wheel
         int mouseWheelStepSize_;
+
+        //! Multiplication of mouse sensitivity and clipping size
+        float totalMouseSensitivity_;
 
         //##### Constant config variables #####
         // Use some value at about 1000. This can be configured with mouseSensitivity_ anyway.
         static const int mouseClippingSize_ = 1024;
-    };
+    };// tolua_export
 
 
@@ -216 +231 @@
             mouseAxes_[i].relVal_ = 0.0f;
     }
-}
+}// tolua_export
 
 #endif /* _KeyBinder_H__ */

code/branches/pickup2/src/libraries/core/input/KeyBinderManager.cc

@@ -40 +40 @@
 namespace orxonox
 {
-    KeyBinderManager* KeyBinderManager::singletonPtr_s = 0;
     ManageScopedSingleton(KeyBinderManager, ScopeID::Graphics, false);
 
@@ -48 +47 @@
         , bBinding_(false)
     {
-        this->callbackFunction_ = createFunctor(&KeyBinderManager::callback, this);
-
         RegisterObject(KeyBinderManager);
         this->setConfigValues();
@@ -57 +54 @@
             .defaultValues("");
         CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(createFunctor(&KeyBinderManager::tkeybind, this), "tkeybind"))
+            .defaultValues("");
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(createFunctor(&KeyBinderManager::unbind, this), "unbind"))
+            .defaultValues("");
+        CommandExecutor::addConsoleCommandShortcut(createConsoleCommand(createFunctor(&KeyBinderManager::tunbind, this), "tunbind"))
             .defaultValues("");
 
@@ -68 +69 @@
         for (std::map<std::string, KeyBinder*>::const_iterator it = this->binders_.begin(); it != this->binders_.end(); ++it)
             delete it->second;
-        delete this->callbackFunction_;
     }
 
@@ -91 +91 @@
         else
             this->bDefaultFileLoaded_ = false;
+    }
+
+    inline void KeyBinderManager::unbind(const std::string& binding)
+    {
+        this->currentBinder_->setBinding("", binding, false);
+    }
+
+    inline void KeyBinderManager::tunbind(const std::string& binding)
+    {
+        this->currentBinder_->setBinding("", binding, true);
     }
 
@@ -146 +156 @@
         {
             COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
-            KeyDetector::getInstance().setCallback(callbackFunction_);
+            KeyDetector::getInstance().setCallback(shared_ptr<Functor>(createFunctor(&KeyBinderManager::keybindKeyPressed, this)));
             InputManager::getInstance().enterState("detector");
             this->command_ = command;
@@ -156 +166 @@
 
     // Gets called by the KeyDetector (registered with a Functor)
-    void KeyBinderManager::callback(const std::string& keyName)
+    void KeyBinderManager::keybindKeyPressed(const std::string& keyName)
     {
         if (this->bBinding_)
         {
-            COUT(0) << "Binding string \"" << command_ << "\" on key '" << keyName << "'" << std::endl;
-            this->currentBinder_->setBinding(command_, keyName, bTemporary_);
+            if (keyName == "Keys.KeyEscape")
+            {
+                COUT(0) << "Keybinding aborted." << std::endl;
+            }
+            else
+            {
+                COUT(0) << "Binding string \"" << command_ << "\" on key '" << keyName << "'" << std::endl;
+                this->currentBinder_->setBinding(command_, keyName, bTemporary_);
+            }
             InputManager::getInstance().leaveState("detector");
+            // inform whatever was calling the command
+            if (this->callbackFunction_)
+                (*this->callbackFunction_)();
             this->bBinding_ = false;
         }

code/branches/pickup2/src/libraries/core/input/KeyBinderManager.h

@@ -34 +34 @@
 #include <map>
 #include <string>
+#include <boost/shared_ptr.hpp>
+
 #include "util/Singleton.h"
 #include "core/OrxonoxClass.h"
 
-namespace orxonox
-{
+namespace orxonox //tolua_export
+{ //tolua_export
     /**
     @brief
@@ -46 +48 @@
         maps to the currently active KeyBinder. You can set that with setCurrent().
         There is also a default one, retrieved with getDefault(). The idea is that
-        mostly the default KeyBinder is active except for special situtations (mini-game for inst).
+        mostly the default KeyBinder is active except for special situations (mini-game for inst).
     @remarks
         You are not forced to use the KeyBinder imposed by getCurrent(). But be aware that "keybind"
         will not work as expected!
     */
-    class _CoreExport KeyBinderManager : public Singleton<KeyBinderManager>, public OrxonoxClass
-    {
+    class _CoreExport KeyBinderManager //tolua_export
+        : public Singleton<KeyBinderManager>, public OrxonoxClass
+    { //tolua_export
         friend class Singleton<KeyBinderManager>;
     public:
@@ -59 +62 @@
         void setConfigValues();
 
+        static KeyBinderManager& getInstance() { return Singleton<KeyBinderManager>::getInstance(); } //tolua_export
         //! Returns the currently selected KeyBinder
-        KeyBinder*    getCurrent()
-            { return this->currentBinder_; }
+        KeyBinder* getCurrent() { return this->currentBinder_; } //tolua_export
         //! Like getCurrent(), but returns it as InputHandler* (so you don't have to include KeyBinder.h)
         InputHandler* getCurrentAsHandler();
@@ -68 +71 @@
 
         //! Returns the default KeyBinder
-        KeyBinder*    getDefault()
+        KeyBinder* getDefault()
             { return binders_[this->defaultFilename_]; }
         //! Returns the default KeyBinder as InputHandler* (so you don't have to include KeyBinder.h)
@@ -80 +83 @@
 
         //! Returns a pointer to a KeyBinder (creates it if not yet loaded)
-        KeyBinder*    get(const std::string& name);
+        KeyBinder* get(const std::string& name);
         //! Like get() but return value is of type InputHandler* (so you don't have to include KeyBinder.h)
         InputHandler* getAsHandler(const std::string& name);
 
         //! Loads a KeyBinder by creating it (no different from get() except for the return value)
-        void load  (const std::string& filename);
+        void load(const std::string& filename);
         //! Destroys a KeyBinder completely (does nothing if not yet loaded)
         void unload(const std::string& filename);
 
         //! Bind 'command' to any key pressed after this call (use with care!)
-        inline void keybind(const std::string& command)
-            { this->keybindInternal(command, false); }
+        inline void keybind(const std::string& command) { this->keybindInternal(command, false); } //tolua_export
         //! Bind 'command' to any key pressed after this call (use with care!), but temporarily (no file save)
         inline void tkeybind(const std::string& command)
             { this->keybindInternal(command, true); }
+        void unbind(const std::string& binding); //tolua_export
+        void tunbind(const std::string& binding);
+        inline void registerKeybindCallback(Functor* function) { this->callbackFunction_.reset(function); } // tolua_export
 
     private:
         KeyBinderManager(const KeyBinderManager&);
         void keybindInternal(const std::string& command, bool bTemporary);
-        void callback(const std::string& keyName);
+        void keybindKeyPressed(const std::string& keyName);
         void defaultFilenameChanged();
 
@@ -109 +114 @@
 
         // keybind command related
-        Functor* callbackFunction_;                  //! Function to be called when key was pressed after "keybind" command
+        shared_ptr<Functor> callbackFunction_;       //! Function to be called when key was pressed after "keybind" command
         bool bBinding_;                              //! Tells whether a key binding process is active
         bool bTemporary_;                            //! Stores tkeybind/keybind value
@@ -115 +120 @@
 
         static KeyBinderManager* singletonPtr_s;
-    };
-}
+    }; //tolua_export
+} //tolua_export
 
 #endif /* _KeyBinderManager_H__ */

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

@@ -39 +39 @@
 {
     std::string KeyDetector::callbackCommand_s = "KeyDetectorKeyPressed";
-    KeyDetector* KeyDetector::singletonPtr_s = 0;
     ManageScopedSingleton(KeyDetector, ScopeID::Graphics, false);
 
@@ -68 +67 @@
         for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
         {
-            it->second->bindingString_ = callbackCommand_s + " " + it->second->groupName_ + "." + it->second->name_;
+            it->second->bindingString_ = callbackCommand_s + ' ' + it->second->groupName_ + "." + it->second->name_;
             it->second->parse();
         }

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

@@ -32 +32 @@
 #include "InputPrereqs.h"
 
+#include <boost/shared_ptr.hpp>
 #include "util/Singleton.h"
 #include "KeyBinder.h"
@@ -45 +46 @@
         ~KeyDetector();
 
-        void setCallback(Functor* function) { this->callbackFunction_ = function; }
+        void setCallback(const shared_ptr<Functor>& function) { this->callbackFunction_ = function; }
 
     private:
@@ -54 +55 @@
         void assignCommands();
 
-        Functor* callbackFunction_;
+        shared_ptr<Functor> callbackFunction_;
         InputState* inputState_;
         static std::string callbackCommand_s;

code/branches/pickup2/src/libraries/core/input/Keyboard.cc

@@ -43 +43 @@
             modifiers_ |= KeyboardModifier::Shift; // shift key
 
+        // Do not distribute the alt+tab event (messes with the operating system)
+        if ((modifiers_ & KeyboardModifier::Alt) != 0 && arg.key == OIS::KC_TAB)
+            return true;
+
         KeyEvent evt(arg);
         super::buttonPressed(evt);