Changeset 1638 for code/branches/gui/src

code/branches/gui

Property svn:mergeinfo set to
/code/branches/input merged eligible

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

-                      r1612
+                      r1638
   Core.cc
   Error.cc
+  Exception.cc
   Language.cc
   OrxonoxClass.cc
 …
   input/Button.cc
   input/CalibratorCallback.cc
+  input/ExtendedInputState.cc
   input/HalfAxis.cc
   input/InputBuffer.cc
 …
   input/KeyBinder.cc
   input/KeyDetector.cc
+  input/SimpleInputState.cc
   tolua/tolua_bind.cc

code/branches/gui/src/core/ClassTreeMask.h

r1505	r1638
60	60	step back, and so on.
61	61
62		Example: A and B are child~~s of BaseObject, A1 and A2 are childs of A, B1 and B2 are childs~~ of B.
	62	Example: A and B are children of BaseObject, A1 and A2 are children of A, B1 and B2 are children of B.
63	63	The ClassTreeMaskIterator would move trough the tree in the following order:
64	64	BaseObject, A, A1, A2, B, B1, B2.

code/branches/gui/src/core/CommandExecutor.h

-                      r1505
+                      r1638
 #include "CommandEvaluation.h"
 namespace orxonox
+{
+namespace orxonox // tolua_export
+{ // tolua_export
     class _CoreExport CommandExecutor
+    /*
+    class CommandExecutor { // tolua_export
+    */
+    {
         public:
             static bool execute(const std::string& command, bool useTcl = true);
+            static bool execute(const std::string& command, bool useTcl = true); // tolua_export
             static std::string complete(const std::string& command);
             static std::string hint(const std::string& command);
 …
             std::map<std::string, ConsoleCommand*> consoleCommandShortcuts_;
             std::map<std::string, ConsoleCommand*> consoleCommandShortcuts_LC_;
     };
+}
+    }; // tolua_export
+} // tolua_export
 #endif /* _CommandExecutor_H__ */

code/branches/gui/src/core/Core.cc

r1535	r1638
23	23	* Fabian 'x3n' Landau
24	24	* Co-authors:
25		* ~~...~~
	25	* Reto Grieder
26	26	*
27	27	*/

code/branches/gui/src/core/Core.h

-                      r1535
+                      r1638
  *      Fabian 'x3n' Landau
  *   Co-authors:
  *      ...
+ *      Reto Grieder
+ *
  */
 …
 /**
     @file Core.h
     @brief Definition of the Core class.
+    @brief Declaration of the Core class.
     The Core class is a singleton, only used to configure some variables

code/branches/gui/src/core/CoreIncludes.h

r1543	r1638
105	105	@param StringOrInt The name or the network ID of the class
106	106	*/
107		#define ID(StringOrInt) \
	107	#define GetIdentifier(StringOrInt) \
108	108	orxonox::Factory::getIdentifier(StringOrInt)
109	109

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

-                      r1543
+                      r1638
   // 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;
 …
   class ParamCommand;
   class SimpleCommand;
+  class SimpleInputState;
+}

code/branches/gui/src/core/Error.cc

-                      r1505
+                      r1638
 namespace orxonox
+{
         Error::Error(std::string errorMsg, int errorCode)
+        {
                 COUT(1) << "############################ "<< std::endl
                                                         << "#         Error "<<errorCode<< "          #"<< std::endl
                                                         << "############################ "<< std::endl
                                                         << "An error occured in Orxonox: "<< std::endl;
+    Error::Error(std::string errorMsg, int errorCode)
+    {
+        COUT(1) << "############################ "<< std::endl
+                            << "#         Error "<<errorCode<< "          #"<< std::endl
+                            << "############################ "<< std::endl
+                            << "An error occured in Orxonox: "<< std::endl;
                 if (errorMsg=="")
+                {
                         switch (errorCode)
+                        {
                                 case 1:
                                         errorMsg = "Some error!";
                                         break;
                                 default:
                                         errorMsg = "Unknown error!";
+                        }
+                }
                 COUT(1) << errorMsg << std::endl<< std::endl;
+        }
+        if (errorMsg=="")
+        {
+            switch (errorCode)
+            {
+                case 1:
+                    errorMsg = "Some error!";
+                    break;
+                default:
+                    errorMsg = "Unknown error!";
+            }
+        }
+        COUT(1) << errorMsg << std::endl<< std::endl;
+    }
+}

code/branches/gui/src/core/Error.h

-                      r1505
+                      r1638
 /**
     @file Error.h
     @brief Definition of the Error class.
+    @brief Declaration of the Error class.
 */
 …
 namespace orxonox
+{
         class _CoreExport Error
+        {
         public:
                 Error(std::string errorMsg = "", int errorCode = 0);
         private:
+    class _CoreExport Error
+    {
+    public:
+        Error(std::string errorMsg = "", int errorCode = 0);
+    private:
         };
+    };
+}

code/branches/gui/src/core/Identifier.h

r1543	r1638
76	76	- the name
77	77	- a list with all objects
78		- parents and childs
	78	- parents and children
79	79	- the factory (if available)
80	80	- the networkID that can be synchronised with the server

code/branches/gui/src/core/OrxonoxClass.h

r1505	r1638
29	29	/**
30	30	@file OrxonoxClass.h
31		@brief De~~fini~~tion of the OrxonoxClass Class.
	31	@brief Declaration of the OrxonoxClass Class.
32	32
33	33	All objects and interfaces of the game-logic (not the engine) are derived from OrxonoxClass.

code/branches/gui/src/core/Script.cc

r1555	r1638
60	60	luaopen_debug(luaState_);
61	61	#endif
62		tolua_core_open(luaState_);
	62	tolua_Core_open(luaState_);
63	63	output_ = "";
64	64	}

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

-                      r1540
+                      r1638
 #include "ConsoleCommand.h"
 #include "input/InputInterfaces.h"
+#include "input/SimpleInputState.h"
+#include "input/InputManager.h"
 #define SHELL_UPDATE_LISTENERS(function) \
 …
         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");
+        }
+    }
 …
+    }
+    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/gui/src/core/Shell.h

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

code/branches/gui/src/core/SignalHandler.h

r1505	r1638
29	29	/**
30	30	@file SignalHandler.h
31		@brief De~~fini~~tion of the SignalHandler class.
	31	@brief Declaration of the SignalHandler class.
32	32	*/
33	33

code/branches/gui/src/core/XMLPort.h

r1628	r1638
288	288	for (ticpp::Iterator<ticpp::Element> child = xmlsubelement->FirstChildElement(false); child != child.end(); child++)
289	289	{
290		Identifier* identifier = ID(child->Value());
	290	Identifier* identifier = GetIdentifier(child->Value());
291	291	if (identifier)
292	292	{

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

-                      r1535
+                      r1638
 /**
+ @file
+ @brief Implementation of the different input handlers.
+ */
+@file
+@brief
+    Implementation of the different input handlers.
+*/
 #include "Button.h"
 …
 namespace orxonox
+{
+  void Button::clear()
+  {
+    for (unsigned int j = 0; j < 3; j++)
+    {
+      if (nCommands_[j])
+      {
+        // delete all commands and the command pointer array
+        for (unsigned int i = 0; i < nCommands_[j]; i++)
+          delete commands_[j][i];
+        delete[] commands_[j];
+        commands_[j] = 0;
+        nCommands_[j] = 0;
+      }
+      else
+      {
+        commands_[j] = 0;
+      }
+    }
+  }
+  void Button::parse(std::vector<BufferedParamCommand*>& paramCommandBuffer)
+  {
+    if (isEmpty(bindingString_))
+    {
+      clear();
+      return;
+    }
+    // use std::vector for a temporary dynamic array
+    std::vector<BaseCommand*> commands[3];
+    // separate the commands
+    SubString commandStrings(bindingString_, "|", SubString::WhiteSpaces, false,
+        '\\', false, '"', false, '(', ')', false, '\0');
+    for (unsigned int iCommand = 0; iCommand < commandStrings.size(); iCommand++)
+    {
+      if (commandStrings[iCommand] != "")
+      {
+        SubString tokens(commandStrings[iCommand], " ", SubString::WhiteSpaces, false,
+    void Button::clear()
+    {
+        for (unsigned int j = 0; j < 3; j++)
+        {
+            if (nCommands_[j])
+            {
+                // delete all commands and the command pointer array
+                for (unsigned int i = 0; i < nCommands_[j]; i++)
+                    delete commands_[j][i];
+                delete[] commands_[j];
+                commands_[j] = 0;
+                nCommands_[j] = 0;
+            }
+            else
+            {
+                commands_[j] = 0;
+            }
+        }
+    }
+    void Button::parse(std::vector<BufferedParamCommand*>& paramCommandBuffer)
+    {
+        if (isEmpty(bindingString_))
+        {
+            clear();
+            return;
+        }
+        // use std::vector for a temporary dynamic array
+        std::vector<BaseCommand*> commands[3];
+        // separate the commands
+        SubString commandStrings(bindingString_, "|", SubString::WhiteSpaces, false,
             '\\', 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;
+            if (iToken == tokens.size())
+              continue;
+          }
+          iToken++;
+        }
+        // no more arguments expected except for the actual command
+        if (iToken == tokens.size())
+          continue;
+        std::string commandStr;
+        while (iToken != tokens.size())
+          commandStr += tokens[iToken++] + " ";
+        // evaluate the command
+        CommandEvaluation eval = CommandExecutor::evaluate(commandStr);
+        if (!eval.isValid())
+          continue;
+        // check for param command
+        int paramIndex = eval.getConsoleCommand()->getAxisParamIndex();
+        if (paramIndex >= 0)
+        {
+          // parameter supported command
+          ParamCommand* cmd = new ParamCommand();
+          cmd->paramModifier_ = paramModifier;
+          cmd->bRelative_ = eval.getConsoleCommand()->getIsAxisRelative();
+          // add command to the buffer if not yet existing
+          for (unsigned int iParamCmd = 0; iParamCmd < paramCommandBuffer.size(); iParamCmd++)
+          {
+            if (getLowercase(paramCommandBuffer[iParamCmd]->evaluation_.getOriginalCommand())
+                == getLowercase(commandStr))
+            {
+              // already in list
+              cmd->paramCommand_ = paramCommandBuffer[iParamCmd];
+              break;
+            }
+          }
+          if (cmd->paramCommand_ == 0)
+          {
+            cmd->paramCommand_ = new BufferedParamCommand();
+            paramCommandBuffer.push_back(cmd->paramCommand_);
+            cmd->paramCommand_->evaluation_ = eval;
+            cmd->paramCommand_->paramIndex_ = paramIndex;
+          }
+          // we don't know whether this is an actual axis or just a button
+          if (mode == KeybindMode::None)
+          {
+            if (!addParamCommand(cmd))
+            {
+              mode = eval.getConsoleCommand()->getKeybindMode();
+              commands[mode].push_back(cmd);
+            }
+          }
+        for (unsigned int iCommand = 0; iCommand < commandStrings.size(); iCommand++)
+        {
+            if (commandStrings[iCommand] != "")
+            {
+                SubString tokens(commandStrings[iCommand], " ", SubString::WhiteSpaces, false,
+                    '\\', false, '"', false, '(', ')', false, '\0');
+                KeybindMode::Enum mode = KeybindMode::None;
+                float paramModifier = 1.0f;
+                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;
+                        // 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;
+                }
+                // evaluate the command
+                CommandEvaluation eval = CommandExecutor::evaluate(commandStr);
+                if (!eval.isValid())
+                {
+                    parseError("Command evaluation failed.", true);
+                    continue;
+                }
+                // check for param command
+                int paramIndex = eval.getConsoleCommand()->getAxisParamIndex();
+                if (paramIndex >= 0)
+                {
+                    // parameter supported command
+                    ParamCommand* cmd = new ParamCommand();
+                    cmd->paramModifier_ = paramModifier;
+                    cmd->bRelative_ = eval.getConsoleCommand()->getIsAxisRelative();
+                    // add command to the buffer if not yet existing
+                    for (unsigned int iParamCmd = 0; iParamCmd < paramCommandBuffer.size(); iParamCmd++)
+                    {
+                        if (getLowercase(paramCommandBuffer[iParamCmd]->evaluation_.getOriginalCommand())
+                            == getLowercase(commandStr))
+                        {
+                            // already in list
+                            cmd->paramCommand_ = paramCommandBuffer[iParamCmd];
+                            break;
+                        }
+                    }
+                    if (cmd->paramCommand_ == 0)
+                    {
+                        cmd->paramCommand_ = new BufferedParamCommand();
+                        paramCommandBuffer.push_back(cmd->paramCommand_);
+                        cmd->paramCommand_->evaluation_ = eval;
+                        cmd->paramCommand_->paramIndex_ = paramIndex;
+                    }
+                    // we don't know whether this is an actual axis or just a button
+                    if (mode == KeybindMode::None)
+                    {
+                        if (!addParamCommand(cmd))
+                        {
+                            mode = eval.getConsoleCommand()->getKeybindMode();
+                            commands[mode].push_back(cmd);
+                        }
+                    }
+                }
+                else
+                {
+                    SimpleCommand* cmd = new SimpleCommand();
+                    cmd->evaluation_ = eval;
+                    if (mode == KeybindMode::None)
+                        mode = eval.getConsoleCommand()->getKeybindMode();
+                    commands[mode].push_back(cmd);
+                }
+            }
+        }
+        for (unsigned int j = 0; j < 3; j++)
+        {
+            nCommands_[j] = commands[j].size();
+            if (nCommands_[j])
+            {
+                commands_[j] = new BaseCommand*[nCommands_[j]];
+                for (unsigned int i = 0; i < commands[j].size(); i++)
+                    commands_[j][i] = commands[j][i];
+            }
+            else
+                commands_[j] = 0;
+        }
+    }
+    bool Button::execute(KeybindMode::Enum mode, float abs, float rel)
+    {
+        // execute all the parsed commands in the string
+        for (unsigned int iCommand = 0; iCommand < nCommands_[mode]; iCommand++)
+            commands_[mode][iCommand]->execute(abs, rel);
+        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
+        {
+          SimpleCommand* cmd = new SimpleCommand();
+          cmd->evaluation_ = eval;
+          if (mode == KeybindMode::None)
+            mode = eval.getConsoleCommand()->getKeybindMode();
+          commands[mode].push_back(cmd);
+        }
+      }
+    }
+    for (unsigned int j = 0; j < 3; j++)
+    {
+      nCommands_[j] = commands[j].size();
+      if (nCommands_[j])
+      {
+        commands_[j] = new BaseCommand*[nCommands_[j]];
+        for (unsigned int i = 0; i < commands[j].size(); i++)
+          commands_[j][i] = commands[j][i];
+      }
+      else
+        commands_[j] = 0;
+    }
+  }
+  bool Button::execute(KeybindMode::Enum mode, float abs, float rel)
+  {
+    // execute all the parsed commands in the string
+    for (unsigned int iCommand = 0; iCommand < nCommands_[mode]; iCommand++)
+      commands_[mode][iCommand]->execute(abs, rel);
+    return true;
+  }
+            COUT(3) << "Warning while parsing binding for button/axis" << this->name_ << ". "
+                << message << std::endl;
+        }
+    }
+}

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

-                      r1535
+                      r1638
 /**
+ @file
+ @brief Different definitions of input processing.
+ */
+@file
+@brief
+    Different definitions of input processing.
+*/
 #ifndef _Button_H__
 …
 namespace orxonox
+{
   class _CoreExport Button
+  {
   public:
     Button() { nCommands_[0]=0; nCommands_[1]=0; nCommands_[2]=0; clear(); }
     virtual ~Button() { clear(); }
     virtual void clear();
     virtual bool addParamCommand(ParamCommand* command) { return false; }
     void parse(std::vector<BufferedParamCommand*>& paramCommandBuffer);
     bool execute(KeybindMode::Enum mode, float abs = 1.0f, float rel = 1.0f);
+    class _CoreExport Button
+    {
+    public:
+        Button() { nCommands_[0]=0; nCommands_[1]=0; nCommands_[2]=0; clear(); }
+        virtual ~Button() { clear(); }
+        virtual void clear();
+        virtual bool addParamCommand(ParamCommand* command) { return false; }
+        void parse(std::vector<BufferedParamCommand*>& paramCommandBuffer);
+        bool execute(KeybindMode::Enum mode, float abs = 1.0f, float rel = 1.0f);
+    //! The configured string value
+    std::string bindingString_;
+    //! Name of the trigger as strings
+    std::string name_;
+    //! Basic commands for OnPress, OnHold and OnRelease
+    BaseCommand** commands_[3];
+    //! Number of basic commands
+    unsigned int nCommands_[3];
+    //! Says how much it takes for an analog axis to trigger a button
+    //! Note: This variable is here to have only one parse() function.
+    float buttonThreshold_;
+  };
+        //! The configured string value
+        std::string bindingString_;
+        //! Name of the trigger as strings
+        std::string name_;
+        //! Basic commands for OnPress, OnHold and OnRelease
+        BaseCommand** commands_[3];
+        //! Number of basic commands
+        unsigned int nCommands_[3];
+        //! Says how much it takes for an analog axis to trigger a button
+        //! Note: This variable is here to have only one parse() function.
+        float buttonThreshold_;
+    private:
+        void parseError(std::string message, bool serious);
+    };
+}

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

-                      r1535
+                      r1638
 /**
+ @file
+ @brief Implementation of the different input handlers.
+ */
+@file
+@brief
+    Implementation of the different input handlers.
+*/
 #include "CalibratorCallback.h"
 …
 namespace orxonox
+{
+  void CalibratorCallback::keyPressed(const orxonox::KeyEvent &evt)
+  {
+    if (evt.key == KeyCode::Return)
+    void CalibratorCallback::keyPressed(const orxonox::KeyEvent &evt)
+    {
+      InputManager::setInputState(InputManager::IS_NOCALIBRATE);
+        if (evt.key == KeyCode::Return)
+        {
+            //InputManager::setInputState(InputManager::IS_NOCALIBRATE);
+        }
+    }
+  }
+}

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

-                      r1535
+                      r1638
 /**
+ @file
+ @brief Different definitions of input processing.
+ */
+@file
+@brief
+    Different definitions of input processing.
+*/
 #ifndef _CalibratorCallback_H__
 …
 #include "core/CorePrereqs.h"
 #include "InputInterfaces.h"
 namespace orxonox
+{
   class _CoreExport CalibratorCallback : public KeyHandler
+  {
   public:
     CalibratorCallback() {}
     ~CalibratorCallback() {}
+    class _CoreExport CalibratorCallback : public KeyHandler
+    {
+    public:
+        CalibratorCallback()  { }
+        ~CalibratorCallback() { }
   private:
     void keyPressed (const KeyEvent& evt);
     void keyReleased(const KeyEvent& evt) {}
     void keyHeld    (const KeyEvent& evt) {}
+    private:
+        void keyPressed (const KeyEvent& evt);
+        void keyReleased(const KeyEvent& evt) { }
+        void keyHeld    (const KeyEvent& evt) { }
     void tickInput(float dt, const HandlerState &state) { }
   };
+        void tickInput(float dt) { }
+    };
+}

code/branches/gui/src/core/input/HalfAxis.cc

-                      r1535
+                      r1638
 /**
+ @file
+ @brief Implementation of the different input handlers.
+ */
+@file
+@brief
+    Implementation of the different input handlers.
+*/
 #include "HalfAxis.h"
 …
 namespace orxonox
+{
+  void HalfAxis::clear()
+  {
+    Button::clear();
+    if (nParamCommands_)
+    void HalfAxis::clear()
+    {
+      // delete all commands and the command pointer array
+      for (unsigned int i = 0; i < nParamCommands_; i++)
+        delete paramCommands_[i];
+      delete[] paramCommands_;
+      nParamCommands_ = 0;
+        Button::clear();
+        if (nParamCommands_)
+        {
+            // delete all commands and the command pointer array
+            for (unsigned int i = 0; i < nParamCommands_; i++)
+                delete paramCommands_[i];
+            delete[] paramCommands_;
+            nParamCommands_ = 0;
+        }
+        else
+        {
+            nParamCommands_ = 0; nParamCommands_ = 0;
+        }
+    }
+    else
+    bool HalfAxis::addParamCommand(ParamCommand* command)
+    {
+      nParamCommands_ = 0; nParamCommands_ = 0;
+        ParamCommand** cmds = paramCommands_;
+        paramCommands_ = new ParamCommand*[++nParamCommands_];
+        unsigned int i;
+        for (i = 0; i < nParamCommands_ - 1; i++)
+            paramCommands_[i] = cmds[i];
+        paramCommands_[i] = command;
+        if (nParamCommands_ > 1)
+            delete[] cmds;
+        return true;
+    }
+  }
+  bool HalfAxis::addParamCommand(ParamCommand* command)
+  {
+    ParamCommand** cmds = paramCommands_;
+    paramCommands_ = new ParamCommand*[++nParamCommands_];
+    unsigned int i;
+    for (i = 0; i < nParamCommands_ - 1; i++)
+      paramCommands_[i] = cmds[i];
+    paramCommands_[i] = command;
+    if (nParamCommands_ > 1)
+      delete[] cmds;
+    return true;
+  }
+  bool HalfAxis::execute()
+  {
+    bool success = true;
+    for (unsigned int i = 0; i < nParamCommands_; i++)
+      success = success && paramCommands_[i]->execute(absVal_, relVal_);
+    return success;
+  }
+    bool HalfAxis::execute()
+    {
+        bool success = true;
+        for (unsigned int i = 0; i < nParamCommands_; i++)
+            success = success && paramCommands_[i]->execute(absVal_, relVal_);
+        return success;
+    }
+}

code/branches/gui/src/core/input/HalfAxis.h

-                      r1535
+                      r1638
 /**
+ @file
+ @brief Different definitions of input processing.
+ */
+@file
+@brief
+    Different definitions of input processing.
+*/
 #ifndef _HalfAxis_H__
 …
 namespace orxonox
+{
+  class _CoreExport HalfAxis : public Button
+  {
+  public:
+    HalfAxis() : relVal_(0.0f), absVal_(0.0f), paramCommands_(0), nParamCommands_(0),
+                 wasDown_(false), hasChanged_(false) { }
+    using Button::execute;
+    bool execute();
+    bool addParamCommand(ParamCommand* command);
+    void clear();
+    class _CoreExport HalfAxis : public Button
+    {
+    public:
+        HalfAxis()
+            : relVal_(0.0f)
+            , absVal_(0.0f)
+            , paramCommands_(0)
+            , nParamCommands_(0)
+            , wasDown_(false)
+            , hasChanged_(false)
+        { }
+        using Button::execute;
+        bool execute();
+        bool addParamCommand(ParamCommand* command);
+        void clear();
     // axis related
     float relVal_;
     float absVal_;
     ParamCommand** paramCommands_;
     unsigned int nParamCommands_;
+        // axis related
+        float relVal_;
+        float absVal_;
+        ParamCommand** paramCommands_;
+        unsigned int nParamCommands_;
     // button related
     bool wasDown_;
     bool hasChanged_;
   };
+        // button related
+        bool wasDown_;
+        bool hasChanged_;
+    };
+}

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

r1535	r1638
220	220	@param dt Delta time
221	221	*/
222		void InputBuffer::tickInput(float dt~~, const HandlerState& state~~)
	222	void InputBuffer::tickInput(float dt)
223	223	{
224	224	timeSinceKeyPressed_ += dt;

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

-                      r1535
+                      r1638
             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/gui/src/core/input/InputCommands.cc

-                      r1535
+                      r1638
 /**
+ @file
+ @brief Implementation of the different input handlers.
+ */
+@file
+@brief
+    Implementation of the different input handlers.
+*/
 #include "InputCommands.h"
 …
 namespace orxonox
+{
   // ###############################
   // ###  BufferedParamCommand   ###
   // ###############################
+    // ###############################
+    // ###  BufferedParamCommand   ###
+    // ###############################
   /**
   * Executes a buffered command. This is used for commands with additional
   * parameters.
   * @return True if command execution was successful or value was zero.
   */
   bool BufferedParamCommand::execute()
+  {
     if (nValuesAdded_)
+    /**
+    @brief
+        Executes a buffered command. This is used for commands with additional
+        parameters.
+    @return
+        True if command execution was successful or value was zero.
+    */
+    bool BufferedParamCommand::execute()
+    {
+      BufferedParamCommand& cmd = *this;
+      cmd.evaluation_.setEvaluatedParameter(cmd.paramIndex_, cmd.value_);
+      // reset
+      cmd.nValuesAdded_ = 0;
+      cmd.value_ = 0;
+      return cmd.evaluation_.execute();
+        if (nValuesAdded_)
+        {
+            BufferedParamCommand& cmd = *this;
+            cmd.evaluation_.setEvaluatedParameter(cmd.paramIndex_, cmd.value_);
+            // reset
+            cmd.nValuesAdded_ = 0;
+            cmd.value_ = 0;
+            return cmd.evaluation_.execute();
+        }
+        else
+            return true;
+    }
-    else
-      return true;
+  }
   // ###############################
   // #####    SimpleCommand    #####
   // ###############################
+    // ###############################
+    // #####    SimpleCommand    #####
+    // ###############################
+  /**
+  * Executes a simple command with no additional paramters.
+  * @return True if command execution was successful, false otherwise.
+  */
+  bool SimpleCommand::execute(float abs, float rel)
+  {
+    return evaluation_.execute();
+  }
+    /**
+    @brief
+        Executes a simple command with no additional paramters.
+    @return
+        True if command execution was successful, false otherwise.
+    */
+    bool SimpleCommand::execute(float abs, float rel)
+    {
+        return evaluation_.execute();
+    }
   // ###############################
   // #####    ParamCommand     #####
   // ###############################
+    // ###############################
+    // #####    ParamCommand     #####
+    // ###############################
+  /**
+  * Executes a parameter command. The commmand string is not directly executed,
+  * but instead stored in a buffer list so that values can be combined.
+  * @return Always true.
+  */
+  bool ParamCommand::execute(float abs, float rel)
+  {
+    BufferedParamCommand& cmd = *paramCommand_;
+    // command has an additional parameter
+    if (bRelative_)
+    /**
+    @brief
+        Executes a parameter command. The commmand string is not directly executed,
+        but instead stored in a buffer list so that values can be combined.
+    @return
+        Always true.
+    */
+    bool ParamCommand::execute(float abs, float rel)
+    {
+      if (rel != 0.0f)
+      {
+        // we have to calculate a relative movement.
+        // paramModifier_ says how much one keystroke is
+        cmd.value_ += paramModifier_ * rel;
+      }
+        BufferedParamCommand& cmd = *paramCommand_;
+        // command has an additional parameter
+        if (bRelative_)
+        {
+            if (rel != 0.0f)
+            {
+                // we have to calculate a relative movement.
+                // paramModifier_ says how much one keystroke is
+                cmd.value_ += paramModifier_ * rel;
+            }
+        }
+        else if (abs != 0.0f)
+        {
+            // Usually, joy sticks create 'noise' (they return values if they're in 0 position)
+            // and normally this is caught in tickInput(), but that threshold cannot be to high
+            // in order to preserve accuracy. Instead, we have to catch the problem here. An example:
+            // Someone only uses buttons with an active joystick. The joy stick value could then
+            // be 0.05 for instance and the the key value 1. Without handling the problem, the final
+            // value would be computed to (1+0.05)/2=0.5025 which is not what the user expects.
+            float absQ = abs * abs;
+            float valueQ = cmd.value_ * cmd.value_;
+            if (absQ > 50.0f * valueQ) // ease up comparison by using quadratics
+            {
+                cmd.value_ = abs * paramModifier_;
+                cmd.nValuesAdded_ = 1;
+            }
+            else if (absQ * 50.0f < valueQ)
+            {
+                // abs is too small, we just don't do anything
+            }
+            else
+            {
+                // we have to calculate the absolute position of the axis.
+                // Since there might be another axis that is affected, we have to wait and
+                // store the result in a temporary place
+                cmd.value_ = (cmd.value_ * cmd.nValuesAdded_ + paramModifier_ * abs) / ++cmd.nValuesAdded_;
+            }
+        }
+        return true;
+    }
-    else if (abs != 0.0f)
+    {
-      // Usually, joy sticks create 'noise' (they return values if they're in 0 position)
-      // and normally this is caught in tickInput(), but that threshold cannot be to high
-      // in order to preserve accuracy. Instead, we have to catch the problem here. An example:
-      // Someone only uses buttons with an active joystick. The joy stick value could then
-      // be 0.05 for instance and the the key value 1. Without handling the problem, the final
-      // value would be computed to (1+0.05)/2=0.5025 which is not what the user expects.
-      float absQ = abs * abs;
-      float valueQ = cmd.value_ * cmd.value_;
-      if (absQ > 50.0f * valueQ) // ease up comparison by using quadratics
+      {
-        cmd.value_ = abs * paramModifier_;
-        cmd.nValuesAdded_ = 1;
+      }
-      else if (absQ * 50.0f < valueQ)
+      {
-        // abs is too small, we just don't do anything
+      }
-      else
+      {
-        // we have to calculate the absolute position of the axis.
-        // Since there might be another axis that is affected, we have to wait and
-        // store the result in a temporary place
-        cmd.value_ = (cmd.value_ * cmd.nValuesAdded_ + paramModifier_ * abs) / ++cmd.nValuesAdded_;
+      }
+    }
-    return true;
+  }
+}

code/branches/gui/src/core/input/InputCommands.h

-                      r1535
+                      r1638
 /**
+ @file
+ @brief Different definitions of input processing.
+ */
+@file
+@brief
+    Different definitions of input processing.
+*/
 #ifndef _InputCommands_H__
 …
 namespace orxonox
+{
   class _CoreExport BufferedParamCommand
+  {
   public:
     BufferedParamCommand() : value_(0.0f), nValuesAdded_(0), paramIndex_(-1) { }
     bool execute();
+    class _CoreExport BufferedParamCommand
+    {
+    public:
+        BufferedParamCommand() : value_(0.0f), nValuesAdded_(0), paramIndex_(-1) { }
+        bool execute();
     float value_;
     unsigned int nValuesAdded_;
     int paramIndex_;
     CommandEvaluation evaluation_;
   };
+        float value_;
+        unsigned int nValuesAdded_;
+        int paramIndex_;
+        CommandEvaluation evaluation_;
+    };
   class _CoreExport BaseCommand
+  {
   public:
     virtual ~BaseCommand() { }
     virtual bool execute(float abs = 1.0f, float rel = 1.0f) = 0;
   };
+    class _CoreExport BaseCommand
+    {
+    public:
+        virtual ~BaseCommand() { }
+        virtual bool execute(float abs = 1.0f, float rel = 1.0f) = 0;
+    };
   class _CoreExport SimpleCommand : public BaseCommand
+  {
   public:
     bool execute(float abs = 1.0f, float rel = 1.0f);
+    class _CoreExport SimpleCommand : public BaseCommand
+    {
+    public:
+        bool execute(float abs = 1.0f, float rel = 1.0f);
     CommandEvaluation evaluation_;
   };
+        CommandEvaluation evaluation_;
+    };
   class _CoreExport ParamCommand : public BaseCommand
+  {
   public:
     ParamCommand() : bRelative_(false), paramModifier_(1.0f), paramCommand_(0) { }
     bool execute(float abs = 1.0f, float rel = 1.0f);
+    class _CoreExport ParamCommand : public BaseCommand
+    {
+    public:
+        ParamCommand() : bRelative_(false), paramModifier_(1.0f), paramCommand_(0) { }
+        bool execute(float abs = 1.0f, float rel = 1.0f);
     bool bRelative_;
     float paramModifier_;
     BufferedParamCommand* paramCommand_;
   };
+        bool bRelative_;
+        float paramModifier_;
+        BufferedParamCommand* paramCommand_;
+    };
+}

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

-                      r1556
+                      r1638
 /**
+ @file
+ @brief Declarations of various interface classes for the input management.
+@file
+@brief
+    Declarations of various interface classes for the input management.
 */
 …
 #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"
 namespace orxonox
+{
+  namespace KeyCode
+  {
+    // note: KeyCode comments were directly taken from OISKeyboard.h
+    enum Enum
+    {
+      Unassigned    = OIS::KC_UNASSIGNED,
+      Escape        = OIS::KC_ESCAPE,
+      NumRow1       = OIS::KC_1,
+      NumRow2       = OIS::KC_2,
+      NumRow3       = OIS::KC_3,
+      NumRow4       = OIS::KC_4,
+      NumRow5       = OIS::KC_5,
+      NumRow6       = OIS::KC_6,
+      NumRow7       = OIS::KC_7,
+      NumRow8       = OIS::KC_8,
+      NumRow9       = OIS::KC_9,
+      NumRow0       = OIS::KC_0,
+      Minus         = OIS::KC_MINUS,           // - on main keyboard
+      Equals        = OIS::KC_EQUALS,
+      Back          = OIS::KC_BACK,            // backspace
+      Tab           = OIS::KC_TAB,
+      Q             = OIS::KC_Q,
+      W             = OIS::KC_W,
+      E             = OIS::KC_E,
+      R             = OIS::KC_R,
+      T             = OIS::KC_T,
+      Y             = OIS::KC_Y,
+      U             = OIS::KC_U,
+      I             = OIS::KC_I,
+      O             = OIS::KC_O,
+      P             = OIS::KC_P,
+      LeftBracket   = OIS::KC_LBRACKET,
+      RightBracket  = OIS::KC_RBRACKET,
+      Return        = OIS::KC_RETURN,          // Enter on main keyboard
+      LeftControl   = OIS::KC_LCONTROL,
+      A             = OIS::KC_A,
+      S             = OIS::KC_S,
+      D             = OIS::KC_D,
+      F             = OIS::KC_F,
+      G             = OIS::KC_G,
+      H             = OIS::KC_H,
+      J             = OIS::KC_J,
+      K             = OIS::KC_K,
+      L             = OIS::KC_L,
+      Semicolon     = OIS::KC_SEMICOLON,
+      Apostrophe    = OIS::KC_APOSTROPHE,
+      Grave         = OIS::KC_GRAVE,           // accent
+      LeftShift     = OIS::KC_LSHIFT,
+      Backslash     = OIS::KC_BACKSLASH,
+      Z             = OIS::KC_Z,
+      X             = OIS::KC_X,
+      C             = OIS::KC_C,
+      V             = OIS::KC_V,
+      B             = OIS::KC_B,
+      N             = OIS::KC_N,
+      M             = OIS::KC_M,
+      Comma         = OIS::KC_COMMA,
+      Period        = OIS::KC_PERIOD,          // . on main keyboard
+      Slash         = OIS::KC_SLASH,           // / on main keyboard
+      RightShift    = OIS::KC_RSHIFT,
+      Multiply      = OIS::KC_MULTIPLY,        // * on numeric keypad
+      LeftAlt       = OIS::KC_LMENU,           // left Alt
+      Space         = OIS::KC_SPACE,
+      CapsLock      = OIS::KC_CAPITAL,
+      F1            = OIS::KC_F1,
+      F2            = OIS::KC_F2,
+      F3            = OIS::KC_F3,
+      F4            = OIS::KC_F4,
+      F5            = OIS::KC_F5,
+      F6            = OIS::KC_F6,
+      F7            = OIS::KC_F7,
+      F8            = OIS::KC_F8,
+      F9            = OIS::KC_F9,
+      F10           = OIS::KC_F10,
+      Numlock       = OIS::KC_NUMLOCK,
+      Scrolllock    = OIS::KC_SCROLL,          // Scroll Lock
+      Numpad7       = OIS::KC_NUMPAD7,
+      Numpad8       = OIS::KC_NUMPAD8,
+      Numpad9       = OIS::KC_NUMPAD9,
+      NumpadSubtract= OIS::KC_SUBTRACT,        // - on numeric keypad
+      Numpad4       = OIS::KC_NUMPAD4,
+      Numpad5       = OIS::KC_NUMPAD5,
+      Numpad6       = OIS::KC_NUMPAD6,
+      NumpadAdd     = OIS::KC_ADD,             // + on numeric keypad
+      Numpad1       = OIS::KC_NUMPAD1,
+      Numpad2       = OIS::KC_NUMPAD2,
+      Numpad3       = OIS::KC_NUMPAD3,
+      Numpad0       = OIS::KC_NUMPAD0,
+      NumpadPeriod  = OIS::KC_DECIMAL,         // . on numeric keypad
+      LessThan      = OIS::KC_OEM_102,         // < > | on UK/Germany keyboards
+      F11           = OIS::KC_F11,
+      F12           = OIS::KC_F12,
+      F13           = OIS::KC_F13,             //                     (NEC PC98)
+      F14           = OIS::KC_F14,             //                     (NEC PC98)
+      F15           = OIS::KC_F15,             //                     (NEC PC98)
+      Kana          = OIS::KC_KANA,            // (Japanese keyboard)
+      ABNT_C1       = OIS::KC_ABNT_C1,         // / ? on Portugese (Brazilian) keyboards
+      Convert       = OIS::KC_CONVERT,         // (Japanese keyboard)
+      NoConvert     = OIS::KC_NOCONVERT,       // (Japanese keyboard)
+      Yen           = OIS::KC_YEN,             // (Japanese keyboard)
+      ABNT_C2       = OIS::KC_ABNT_C2,         // Numpad . on Portugese (Brazilian) keyboards
+      NumpadEquals  = OIS::KC_NUMPADEQUALS,    // = on numeric keypad (NEC PC98)
+      PreviousTrack = OIS::KC_PREVTRACK,       // Previous Track (KC_CIRCUMFLEX on Japanese keyboard)
+      AT            = OIS::KC_AT,              //                     (NEC PC98)
+      Colon         = OIS::KC_COLON,           //                     (NEC PC98)
+      Underline     = OIS::KC_UNDERLINE,       //                     (NEC PC98)
+      Kanji         = OIS::KC_KANJI,           // (Japanese keyboard)
+      Stop          = OIS::KC_STOP,            //                     (NEC PC98)
+      AX            = OIS::KC_AX,              //                     (Japan AX)
+      Unlabeled     = OIS::KC_UNLABELED,       //                        (J3100)
+      NextTrack     = OIS::KC_NEXTTRACK,       // Next Track
+      NumpadEnter   = OIS::KC_NUMPADENTER,     // Enter on numeric keypad
+      RightControl  = OIS::KC_RCONTROL,
+      Mute          = OIS::KC_MUTE,            // Mute
+      Calculator    = OIS::KC_CALCULATOR,      // Calculator
+      PlayPause     = OIS::KC_PLAYPAUSE,       // Play / Pause
+      MediaStop     = OIS::KC_MEDIASTOP,       // Media Stop
+      VolumeDown    = OIS::KC_VOLUMEDOWN,      // Volume -
+      VolumeUp      = OIS::KC_VOLUMEUP,        // Volume +
+      WebHome       = OIS::KC_WEBHOME,         // Web home
+      NumpadComma   = OIS::KC_NUMPADCOMMA,     // , on numeric keypad (NEC PC98)
+      Divide        = OIS::KC_DIVIDE,          // / on numeric keypad
+      SYSRQ         = OIS::KC_SYSRQ,
+      RightAlt      = OIS::KC_RMENU,           // right Alt
+      Pause         = OIS::KC_PAUSE,           // Pause
+      Home          = OIS::KC_HOME,            // Home on arrow keypad
+      Up            = OIS::KC_UP,              // UpArrow on arrow keypad
+      PageUp        = OIS::KC_PGUP,            // PgUp on arrow keypad
+      Left          = OIS::KC_LEFT,            // LeftArrow on arrow keypad
+      Right         = OIS::KC_RIGHT,           // RightArrow on arrow keypad
+      End           = OIS::KC_END,             // End on arrow keypad
+      Down          = OIS::KC_DOWN,            // DownArrow on arrow keypad
+      PageDown      = OIS::KC_PGDOWN,          // PgDn on arrow keypad
+      Insert        = OIS::KC_INSERT,          // Insert on arrow keypad
+      Delete        = OIS::KC_DELETE,          // Delete on arrow keypad
+      LeftWindows   = OIS::KC_LWIN,            // Left Windows key
+      RightWindows  = OIS::KC_RWIN,            // Right Windows key
+      Apps          = OIS::KC_APPS,            // AppMenu key
+      Power         = OIS::KC_POWER,           // System Power
+      Sleep         = OIS::KC_SLEEP,           // System Sleep
+      Wake          = OIS::KC_WAKE,            // System Wake
+      WebSearch     = OIS::KC_WEBSEARCH,       // Web Search
+      WebFavorites  = OIS::KC_WEBFAVORITES,    // Web Favorites
+      WebRefresh    = OIS::KC_WEBREFRESH,      // Web Refresh
+      WebStop       = OIS::KC_WEBSTOP,         // Web Stop
+      WebForward    = OIS::KC_WEBFORWARD,      // Web Forward
+      WebBack       = OIS::KC_WEBBACK,         // Web Back
+      MyComputer    = OIS::KC_MYCOMPUTER,      // My Computer
+      Mail          = OIS::KC_MAIL,            // Mail
+      MediaSelect   = OIS::KC_MEDIASELECT      // Media Select
+    };
+  }
+  namespace MouseButton
+  {
+    enum Enum
+    {
+      Left    = OIS::MB_Left,
+      Right   = OIS::MB_Right,
+      Middle  = OIS::MB_Middle,
+      Button3 = OIS::MB_Button3,
+      Button4 = OIS::MB_Button4,
+      Button5 = OIS::MB_Button5,
+      Button6 = OIS::MB_Button6,
+      Button7 = OIS::MB_Button7
+    };
+  }
+  namespace KeyboardModifier
+  {
+    enum Enum
+    {
+      Shift = 0x0000001,
+      Ctrl  = 0x0000010,
+      Alt   = 0x0000100
+    };
+  }
+  struct _CoreExport Key
+  {
+    Key(const OIS::KeyEvent& evt) : key((KeyCode::Enum)evt.key), text(evt.text) { }
+    KeyCode::Enum key;
+    unsigned int text;
+  };
+  class _CoreExport KeyEvent
+  {
+  public:
+    KeyEvent(KeyCode::Enum key, unsigned int text) : key(key), text(text) { }
+    KeyEvent(const OIS::KeyEvent& evt, unsigned int mod) : key((KeyCode::Enum)evt.key), text(evt.text), modifiers(mod) { }
+    KeyEvent(const Key& key, unsigned int mod) : key(key.key), text(key.text), modifiers(mod) { }
+    bool isModifierDown(KeyboardModifier::Enum modifier) const { return (KeyboardModifier::Enum)modifier&modifiers; }
+    const KeyCode::Enum key;
+    unsigned int text;
+    unsigned int modifiers;
+  };
+  //typedef OIS::MouseState MouseState;
+  /*class _CoreExport JoyStickState
+  {
+  public:
+    JoyStickState(const OIS::JoyStickState& state, int ID) : OIS::JoyStickState(state), mJoyStickID(ID) { }
+    JoyStickState() { clear(); }
+    int mJoyStickID;
+                JoyStickState() { clear(); }
+                std::vector<bool> mButtons;
+                int axes[16];
+                std::vector<Vector3> mVectors;
+  };*/
+  /**
+  * Helper struct to determine which handlers of an object (can implement
+  * multiple handlers) are active.
+  */
+  struct HandlerState
+  {
+    HandlerState() : key(false), mouse(false), joyStick(false) { }
+    bool key;
+    bool mouse;
+    bool joyStick;
+  };
+  class _CoreExport InputTickable
+  {
+  public:
+    virtual ~InputTickable() { }
+    virtual void tickInput(float dt, const HandlerState& state) = 0;
+  };
+  /**
+    @brief Interface class used for key input listeners.
+  */
+  class _CoreExport KeyHandler : virtual public InputTickable
+  {
+  public:
+    virtual ~KeyHandler() { }
+    virtual void keyPressed (const KeyEvent& evt) = 0;
+    virtual void keyReleased(const KeyEvent& evt) = 0;
+    virtual void keyHeld    (const KeyEvent& evt) = 0;
+    //virtual void tickKey    (float dt) { }
+  };
+  /**
+    @brief Interface class used for mouse input listeners.
+  */
+  class _CoreExport MouseHandler : virtual public InputTickable
+  {
+  public:
+    virtual ~MouseHandler() { }
+    virtual void mouseButtonPressed (MouseButton::Enum id) = 0;
+    virtual void mouseButtonReleased(MouseButton::Enum id) = 0;
+    virtual void mouseButtonHeld    (MouseButton::Enum id) = 0;
+    virtual void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize) = 0;
+    virtual void mouseScrolled      (int abs, int rel)     = 0;
+    //virtual void tickMouse          (float dt) { }
+  };
+  /**
+    @brief Interface class used for joy stick input listeners.
+  */
+  class _CoreExport JoyStickHandler : virtual public InputTickable
+  {
+  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) { }
+  };
+    namespace KeyCode
+    {
+        // note: KeyCode comments were directly copied from OISKeyboard.h
+        enum Enum
+        {
+            Unassigned    = OIS::KC_UNASSIGNED,
+            Escape        = OIS::KC_ESCAPE,
+            NumRow1       = OIS::KC_1,
+            NumRow2       = OIS::KC_2,
+            NumRow3       = OIS::KC_3,
+            NumRow4       = OIS::KC_4,
+            NumRow5       = OIS::KC_5,
+            NumRow6       = OIS::KC_6,
+            NumRow7       = OIS::KC_7,
+            NumRow8       = OIS::KC_8,
+            NumRow9       = OIS::KC_9,
+            NumRow0       = OIS::KC_0,
+            Minus         = OIS::KC_MINUS,           // - on main keyboard
+            Equals        = OIS::KC_EQUALS,
+            Back          = OIS::KC_BACK,            // backspace
+            Tab           = OIS::KC_TAB,
+            Q             = OIS::KC_Q,
+            W             = OIS::KC_W,
+            E             = OIS::KC_E,
+            R             = OIS::KC_R,
+            T             = OIS::KC_T,
+            Y             = OIS::KC_Y,
+            U             = OIS::KC_U,
+            I             = OIS::KC_I,
+            O             = OIS::KC_O,
+            P             = OIS::KC_P,
+            LeftBracket   = OIS::KC_LBRACKET,
+            RightBracket  = OIS::KC_RBRACKET,
+            Return        = OIS::KC_RETURN,          // Enter on main keyboard
+            LeftControl   = OIS::KC_LCONTROL,
+            A             = OIS::KC_A,
+            S             = OIS::KC_S,
+            D             = OIS::KC_D,
+            F             = OIS::KC_F,
+            G             = OIS::KC_G,
+            H             = OIS::KC_H,
+            J             = OIS::KC_J,
+            K             = OIS::KC_K,
+            L             = OIS::KC_L,
+            Semicolon     = OIS::KC_SEMICOLON,
+            Apostrophe    = OIS::KC_APOSTROPHE,
+            Grave         = OIS::KC_GRAVE,           // accent
+            LeftShift     = OIS::KC_LSHIFT,
+            Backslash     = OIS::KC_BACKSLASH,
+            Z             = OIS::KC_Z,
+            X             = OIS::KC_X,
+            C             = OIS::KC_C,
+            V             = OIS::KC_V,
+            B             = OIS::KC_B,
+            N             = OIS::KC_N,
+            M             = OIS::KC_M,
+            Comma         = OIS::KC_COMMA,
+            Period        = OIS::KC_PERIOD,          // . on main keyboard
+            Slash         = OIS::KC_SLASH,           // / on main keyboard
+            RightShift    = OIS::KC_RSHIFT,
+            Multiply      = OIS::KC_MULTIPLY,        // * on numeric keypad
+            LeftAlt       = OIS::KC_LMENU,           // left Alt
+            Space         = OIS::KC_SPACE,
+            CapsLock      = OIS::KC_CAPITAL,
+            F1            = OIS::KC_F1,
+            F2            = OIS::KC_F2,
+            F3            = OIS::KC_F3,
+            F4            = OIS::KC_F4,
+            F5            = OIS::KC_F5,
+            F6            = OIS::KC_F6,
+            F7            = OIS::KC_F7,
+            F8            = OIS::KC_F8,
+            F9            = OIS::KC_F9,
+            F10           = OIS::KC_F10,
+            Numlock       = OIS::KC_NUMLOCK,
+            Scrolllock    = OIS::KC_SCROLL,          // Scroll Lock
+            Numpad7       = OIS::KC_NUMPAD7,
+            Numpad8       = OIS::KC_NUMPAD8,
+            Numpad9       = OIS::KC_NUMPAD9,
+            NumpadSubtract= OIS::KC_SUBTRACT,        // - on numeric keypad
+            Numpad4       = OIS::KC_NUMPAD4,
+            Numpad5       = OIS::KC_NUMPAD5,
+            Numpad6       = OIS::KC_NUMPAD6,
+            NumpadAdd     = OIS::KC_ADD,             // + on numeric keypad
+            Numpad1       = OIS::KC_NUMPAD1,
+            Numpad2       = OIS::KC_NUMPAD2,
+            Numpad3       = OIS::KC_NUMPAD3,
+            Numpad0       = OIS::KC_NUMPAD0,
+            NumpadPeriod  = OIS::KC_DECIMAL,         // . on numeric keypad
+            LessThan      = OIS::KC_OEM_102,         // < > | on UK/Germany keyboards
+            F11           = OIS::KC_F11,
+            F12           = OIS::KC_F12,
+            F13           = OIS::KC_F13,             //                     (NEC PC98)
+            F14           = OIS::KC_F14,             //                     (NEC PC98)
+            F15           = OIS::KC_F15,             //                     (NEC PC98)
+            Kana          = OIS::KC_KANA,            // (Japanese keyboard)
+            ABNT_C1       = OIS::KC_ABNT_C1,         // / ? on Portugese (Brazilian) keyboards
+            Convert       = OIS::KC_CONVERT,         // (Japanese keyboard)
+            NoConvert     = OIS::KC_NOCONVERT,       // (Japanese keyboard)
+            Yen           = OIS::KC_YEN,             // (Japanese keyboard)
+            ABNT_C2       = OIS::KC_ABNT_C2,         // Numpad . on Portugese (Brazilian) keyboards
+            NumpadEquals  = OIS::KC_NUMPADEQUALS,    // = on numeric keypad (NEC PC98)
+            PreviousTrack = OIS::KC_PREVTRACK,       // Previous Track (KC_CIRCUMFLEX on Japanese keyboard)
+            AT            = OIS::KC_AT,              //                     (NEC PC98)
+            Colon         = OIS::KC_COLON,           //                     (NEC PC98)
+            Underline     = OIS::KC_UNDERLINE,       //                     (NEC PC98)
+            Kanji         = OIS::KC_KANJI,           // (Japanese keyboard)
+            Stop          = OIS::KC_STOP,            //                     (NEC PC98)
+            AX            = OIS::KC_AX,              //                     (Japan AX)
+            Unlabeled     = OIS::KC_UNLABELED,       //                        (J3100)
+            NextTrack     = OIS::KC_NEXTTRACK,       // Next Track
+            NumpadEnter   = OIS::KC_NUMPADENTER,     // Enter on numeric keypad
+            RightControl  = OIS::KC_RCONTROL,
+            Mute          = OIS::KC_MUTE,            // Mute
+            Calculator    = OIS::KC_CALCULATOR,      // Calculator
+            PlayPause     = OIS::KC_PLAYPAUSE,       // Play / Pause
+            MediaStop     = OIS::KC_MEDIASTOP,       // Media Stop
+            VolumeDown    = OIS::KC_VOLUMEDOWN,      // Volume -
+            VolumeUp      = OIS::KC_VOLUMEUP,        // Volume +
+            WebHome       = OIS::KC_WEBHOME,         // Web home
+            NumpadComma   = OIS::KC_NUMPADCOMMA,     // , on numeric keypad (NEC PC98)
+            Divide        = OIS::KC_DIVIDE,          // / on numeric keypad
+            SYSRQ         = OIS::KC_SYSRQ,
+            RightAlt      = OIS::KC_RMENU,           // right Alt
+            Pause         = OIS::KC_PAUSE,           // Pause
+            Home          = OIS::KC_HOME,            // Home on arrow keypad
+            Up            = OIS::KC_UP,              // UpArrow on arrow keypad
+            PageUp        = OIS::KC_PGUP,            // PgUp on arrow keypad
+            Left          = OIS::KC_LEFT,            // LeftArrow on arrow keypad
+            Right         = OIS::KC_RIGHT,           // RightArrow on arrow keypad
+            End           = OIS::KC_END,             // End on arrow keypad
+            Down          = OIS::KC_DOWN,            // DownArrow on arrow keypad
+            PageDown      = OIS::KC_PGDOWN,          // PgDn on arrow keypad
+            Insert        = OIS::KC_INSERT,          // Insert on arrow keypad
+            Delete        = OIS::KC_DELETE,          // Delete on arrow keypad
+            LeftWindows   = OIS::KC_LWIN,            // Left Windows key
+            RightWindows  = OIS::KC_RWIN,            // Right Windows key
+            Apps          = OIS::KC_APPS,            // AppMenu key
+            Power         = OIS::KC_POWER,           // System Power
+            Sleep         = OIS::KC_SLEEP,           // System Sleep
+            Wake          = OIS::KC_WAKE,            // System Wake
+            WebSearch     = OIS::KC_WEBSEARCH,       // Web Search
+            WebFavorites  = OIS::KC_WEBFAVORITES,    // Web Favorites
+            WebRefresh    = OIS::KC_WEBREFRESH,      // Web Refresh
+            WebStop       = OIS::KC_WEBSTOP,         // Web Stop
+            WebForward    = OIS::KC_WEBFORWARD,      // Web Forward
+            WebBack       = OIS::KC_WEBBACK,         // Web Back
+            MyComputer    = OIS::KC_MYCOMPUTER,      // My Computer
+            Mail          = OIS::KC_MAIL,            // Mail
+            MediaSelect   = OIS::KC_MEDIASELECT      // Media Select
+        };
+    }
+    namespace MouseButton
+    {
+        enum Enum
+        {
+            Left    = OIS::MB_Left,
+            Right   = OIS::MB_Right,
+            Middle  = OIS::MB_Middle,
+            Button3 = OIS::MB_Button3,
+            Button4 = OIS::MB_Button4,
+            Button5 = OIS::MB_Button5,
+            Button6 = OIS::MB_Button6,
+            Button7 = OIS::MB_Button7
+        };
+    }
+    namespace KeyboardModifier
+    {
+        enum Enum
+        {
+            Shift = 0x0000001,
+            Ctrl  = 0x0000010,
+            Alt   = 0x0000100
+        };
+    }
+    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
+    {
+        Key(const OIS::KeyEvent& evt) : key((KeyCode::Enum)evt.key), text(evt.text) { }
+        KeyCode::Enum key;
+        unsigned int text;
+    };
+    class _CoreExport KeyEvent
+    {
+    public:
+        KeyEvent(KeyCode::Enum key, unsigned int text) : key(key), text(text) { }
+        KeyEvent(const OIS::KeyEvent& evt, unsigned int mod)
+            : key((KeyCode::Enum)evt.key), text(evt.text), modifiers(mod) { }
+        KeyEvent(const Key& key, unsigned int mod) : key(key.key), text(key.text), modifiers(mod) { }
+        bool isModifierDown(KeyboardModifier::Enum modifier) const
+            { return (KeyboardModifier::Enum)modifier&modifiers; }
+        const KeyCode::Enum key;
+        unsigned int text;
+        unsigned int modifiers;
+    };
+    //typedef OIS::MouseState MouseState;
+    /*class _CoreExport JoyStickState
+    {
+    public:
+        JoyStickState(const OIS::JoyStickState& state, int ID) : OIS::JoyStickState(state), mJoyStickID(ID) { }
+        JoyStickState() { clear(); }
+        int mJoyStickID;
+        JoyStickState() { clear(); }
+        std::vector<bool> mButtons;
+        int axes[16];
+        std::vector<Vector3> mVectors;
+    };*/
+    /**
+    @brief
+        Helper struct to determine which handlers of an object (can implement
+        multiple handlers) are active.
+    */
+    //struct HandlerState
+    //{
+    //    HandlerState() : keyboard(false), mouse(false) { }
+    //    bool keyboard;
+    //    bool mouse;
+    //    std::vector<bool> joySticks;
+    //};
+    class _CoreExport InputTickable
+    {
+    public:
+        virtual ~InputTickable() { }
+        virtual void tickInput(float dt) = 0;
+        //virtual void tickInput(float dt, unsigned int device) = 0;
+    };
+    /**
+    @brief
+        Interface class used for key input listeners.
+    */
+    class _CoreExport KeyHandler : virtual public InputTickable
+    {
+    public:
+        virtual ~KeyHandler() { }
+        virtual void keyPressed (const KeyEvent& evt) = 0;
+        virtual void keyReleased(const KeyEvent& evt) = 0;
+        virtual void keyHeld    (const KeyEvent& evt) = 0;
+        virtual void tickKey    (float dt) { }
+    };
+    /**
+    @brief
+        Interface class used for mouse input listeners.
+    */
+    class _CoreExport MouseHandler : virtual public InputTickable
+    {
+    public:
+        virtual ~MouseHandler() { }
+        virtual void mouseButtonPressed (MouseButton::Enum id) = 0;
+        virtual void mouseButtonReleased(MouseButton::Enum id) = 0;
+        virtual void mouseButtonHeld    (MouseButton::Enum id) = 0;
+        virtual void mouseMoved         (IntVector2 abs, IntVector2 rel, IntVector2 clippingSize) = 0;
+        virtual void mouseScrolled      (int abs, int rel)     = 0;
+        virtual void tickMouse          (float dt) { }
+    };
+    /**
+    @brief
+        Interface class used for joy stick input listeners.
+    */
+    class _CoreExport JoyStickHandler : virtual public InputTickable
+    {
+    public:
+        virtual ~JoyStickHandler() { }
+        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/gui/src/core/input/InputManager.cc

-                      r1555
+                      r1638
 /**
+  @file
+  @brief Implementation of the InputManager that captures all the input from OIS
+         and redirects it to handlers.
+@file
+@brief
+    Implementation of the InputManager that captures all the input from OIS
+    and redirects it to handlers.
  */
 #include "InputManager.h"
+#include <limits.h>
+#include <climits>
+#include <cassert>
+#include "ois/OISException.h"
+#include "ois/OISInputManager.h"
 #include "core/CoreIncludes.h"
 …
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
-#include "core/Shell.h"               // hack!
 #include "InputBuffer.h"
 …
 #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
+{
+  SetConsoleCommandShortcut(InputManager, keyBind);
+  SetConsoleCommandShortcut(InputManager, storeKeyStroke);
+  SetConsoleCommandShortcut(InputManager, calibrate);
+  // ###############################
+  // ###    Internal Methods     ###
+  // ###############################
+  // ###############################
+  /**
+    @brief Constructor only sets member fields to initial zero values
+           and registers the class in the class hierarchy.
+  */
+  InputManager::InputManager() :
+      inputSystem_(0), keyboard_(0), mouse_(0),
+      joySticksSize_(0),
+      keyBinder_(0), keyDetector_(0), buffer_(0), calibratorCallback_(0),
+      state_(IS_UNINIT), stateRequest_(IS_UNINIT), savedState_(IS_UNINIT),
+      keyboardModifiers_(0)
+  {
+    RegisterRootObject(InputManager);
+  }
+  /**
+    @brief The one instance of the InputManager is stored in this function.
+    @return A reference to the only instance of the InputManager
+  */
+  InputManager& InputManager::_getSingleton()
+  {
+    static InputManager theOnlyInstance;
+    return theOnlyInstance;
+  }
+  /**
+    @brief Destructor only called at the end of the program, after main.
+  */
+  InputManager::~InputManager()
+  {
+    _destroy();
+  }
+  /**
+    @brief Creates the OIS::InputMananger, the keyboard, the mouse and
+           the joysticks and assigns the key bindings.
+    @param windowHnd The window handle of the render window
+    @param windowWidth The width of the render window
+    @param windowHeight The height of the render window
+  */
+  bool InputManager::_initialise(const size_t windowHnd, int windowWidth, int windowHeight,
+    SetConsoleCommandShortcut(InputManager, keyBind);
+    SetConsoleCommandShortcut(InputManager, storeKeyStroke);
+    SetConsoleCommandShortcut(InputManager, calibrate);
+    using namespace InputDevice;
+    // ###############################
+    // ###    Internal Methods     ###
+    // ###############################
+    // ###############################
+    /**
+    @brief
+        Constructor only sets member fields to initial zero values
+        and registers the class in the class hierarchy.
+    */
+    InputManager::InputManager()
+        : inputSystem_(0)
+        , keyboard_(0)
+        , mouse_(0)
+        , joySticksSize_(0)
+        , devicesNum_(0)
+        , stateDetector_(0)
+        , stateCalibrator_(0)
+        , stateEmpty_(0)
+        , keyboardModifiers_(0)
+        , bCalibrating_(false)
+    {
+        RegisterRootObject(InputManager);
+    }
+    /**
+    @brief
+        The one instance of the InputManager is stored in this function.
+    @return
+        A reference to the only instance of the InputManager
+    */
+    InputManager& InputManager::_getInstance()
+    {
+        static InputManager theOnlyInstance;
+        return theOnlyInstance;
+    }
+    /**
+    @brief
+        Destructor only called at the end of the program, after main.
+    */
+    InputManager::~InputManager()
+    {
+        _destroy();
+    }
+    // ############################################################
+    // #####                  Initialisation                  #####
+    // ##########                                        ##########
+    // ############################################################
+    /**
+    @brief
+        Creates the OIS::InputMananger, the keyboard, the mouse and
+        the joysticks and assigns the key bindings.
+    @param windowHnd
+        The window handle of the render window
+    @param windowWidth
+        The width of the render window
+    @param windowHeight
+        The height of the render window
+    */
+    bool InputManager::_initialise(const size_t windowHnd, int windowWidth, int windowHeight,
+                                   bool createKeyboard, bool createMouse, bool createJoySticks)
+    {
+        if (inputSystem_ == 0)
+        {
+            CCOUT(3) << "Initialising Input System..." << std::endl;
+            CCOUT(ORX_DEBUG) << "Initialising OIS components..." << std::endl;
+            OIS::ParamList paramList;
+            std::ostringstream windowHndStr;
+            // Fill parameter list
+            windowHndStr << (unsigned int)windowHnd;
+            paramList.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
+            //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_NONEXCLUSIVE")));
+            //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND")));
+//#if defined OIS_LINUX_PLATFORM
+            //paramList.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
+//#endif
+            try
+            {
+                inputSystem_ = OIS::InputManager::createInputSystem(paramList);
+                CCOUT(ORX_DEBUG) << "Created OIS input system" << std::endl;
+            }
+            catch (OIS::Exception ex)
+            {
+                CCOUT(ORX_ERROR) << "Error: Failed creating an OIS input system."
+                    << "OIS message: \"" << ex.eText << "\"" << std::endl;
+                inputSystem_ = 0;
+                return false;
+            }
+            if (createKeyboard)
+                _initialiseKeyboard();
+            if (createMouse)
+                _initialiseMouse();
+            if (createJoySticks)
+                _initialiseJoySticks();
+            // set all the std::vector list sizes now that the devices have been created
+            _redimensionLists();
+            // Set mouse/joystick region
+            if (mouse_)
+            {
+                setWindowExtents(windowWidth, windowHeight);
+            }
+            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_);
+            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;
+        }
+        else
+        {
+            CCOUT(ORX_WARNING) << "Warning: OIS compoments already initialised, skipping" << std::endl;
+        }
+        return true;
+    }
+    /**
+    @brief
+        Creates a keyboard and sets the event handler.
+    @return
+        False if keyboard stays uninitialised, true otherwise.
+    */
+    bool InputManager::_initialiseKeyboard()
+    {
+        if (keyboard_ != 0)
+        {
+            CCOUT(2) << "Warning: Keyboard already initialised, skipping." << std::endl;
+            return true;
+        }
+        try
+        {
+            if (inputSystem_->getNumberOfDevices(OIS::OISKeyboard) > 0)
+            {
+                keyboard_ = (OIS::Keyboard*)inputSystem_->createInputObject(OIS::OISKeyboard, true);
+                // register our listener in OIS.
+                keyboard_->setEventCallback(this);
+                // note: OIS will not detect keys that have already been down when the keyboard was created.
+                CCOUT(ORX_DEBUG) << "Created OIS keyboard" << std::endl;
+                return true;
+            }
+            else
+            {
+                CCOUT(ORX_WARNING) << "Warning: No keyboard found!" << std::endl;
+                return false;
+            }
+        }
+        catch (OIS::Exception ex)
+        {
+            CCOUT(ORX_WARNING) << "Warning: Failed to create an OIS keyboard\n"
+                << "OIS error message: \"" << ex.eText << "\"" << std::endl;
+            keyboard_ = 0;
+            return false;
+        }
+    }
+    /**
+    @brief
+        Creates a mouse and sets the event handler.
+    @return
+        False if mouse stays uninitialised, true otherwise.
+    */
+    bool InputManager::_initialiseMouse()
+    {
+        if (mouse_ != 0)
+        {
+            CCOUT(2) << "Warning: Mouse already initialised, skipping." << std::endl;
+            return true;
+        }
+        try
+        {
+            if (inputSystem_->getNumberOfDevices(OIS::OISMouse) > 0)
+            {
+                mouse_ = static_cast<OIS::Mouse*>(inputSystem_->createInputObject(OIS::OISMouse, true));
+                // register our listener in OIS.
+                mouse_->setEventCallback(this);
+                CCOUT(ORX_DEBUG) << "Created OIS mouse" << std::endl;
+                return true;
+            }
+            else
+            {
+                CCOUT(ORX_WARNING) << "Warning: No mouse found!" << std::endl;
+                return false;
+            }
+        }
+        catch (OIS::Exception ex)
+        {
+            CCOUT(ORX_WARNING) << "Warning: Failed to create an OIS mouse\n"
+                << "OIS error message: \"" << ex.eText << "\"" << std::endl;
+            mouse_ = 0;
+            return false;
+        }
+    }
+    /**
+    @brief
+        Creates all joy sticks and sets the event handler.
+    @return
+        False joy stick stay uninitialised, true otherwise.
+    */
+    bool InputManager::_initialiseJoySticks()
+    {
+        if (joySticksSize_ > 0)
+        {
+            CCOUT(2) << "Warning: Joy sticks already initialised, skipping." << std::endl;
+            return true;
+        }
+        bool success = false;
+        if (inputSystem_->getNumberOfDevices(OIS::OISJoyStick) > 0)
+        {
+            for (int i = 0; i < inputSystem_->getNumberOfDevices(OIS::OISJoyStick); i++)
+            {
+                try
+                {
+                    OIS::JoyStick* stig = static_cast<OIS::JoyStick*>
+                        (inputSystem_->createInputObject(OIS::OISJoyStick, true));
+                    CCOUT(ORX_DEBUG) << "Created OIS joy stick with ID " << stig->getID() << std::endl;
+                    joySticks_.push_back(stig);
+                    // register our listener in OIS.
+                    stig->setEventCallback(this);
+                    success = true;
+                }
+                catch (OIS::Exception ex)
+                {
+                    CCOUT(ORX_WARNING) << "Warning: Failed to create OIS joy number" << i << "\n"
+                        << "OIS error message: \"" << ex.eText << "\"" << std::endl;
+                }
+            }
+        }
+        else
+        {
+            CCOUT(ORX_WARNING) << "Warning: Joy stick support requested, but no joy stick was found" << std::endl;
+            return false;
+        }
+        return success;
+    }
+    void InputManager::_redimensionLists()
+    {
+        joySticksSize_ = joySticks_.size();
+        devicesNum_ = 2 + joySticksSize_;
+        joyStickButtonsDown_ .resize(joySticksSize_);
+        povStates_           .resize(joySticksSize_);
+        sliderStates_        .resize(joySticksSize_);
+        joySticksCalibration_.resize(joySticksSize_);
+        for (unsigned int iJoyStick = 0; iJoyStick < joySticksSize_; iJoyStick++)
+        {
+            // reset the calibration with default values
+            for (unsigned int i = 0; i < 24; i++)
+            {
+                joySticksCalibration_[iJoyStick].negativeCoeff[i] = 1.0f/32767.0f;
+                joySticksCalibration_[iJoyStick].positiveCoeff[i] = 1.0f/32768.0f;
+                joySticksCalibration_[iJoyStick].zeroStates[i] = 0;
+            }
+        }
+        // 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_);
+    }
+    /**
+    @brief
+        Sets the configurable values. Use keybindings.ini as file..
+    */
+    void InputManager::setConfigValues()
+    {
+        if (joySticksSize_)
+        {
+            std::vector<MultiTypeMath> coeffPos;
+            std::vector<MultiTypeMath> coeffNeg;
+            std::vector<MultiTypeMath> zero;
+            coeffPos.resize(24);
+            coeffNeg.resize(24);
+            zero.resize(24);
+            for (unsigned int i = 0; i < 24; i++)
+            {
+                coeffPos[i] =  1.0f/32767.0f;
+                coeffNeg[i] =  1.0f/32768.0f;
+                zero[i]     =  0;
+            }
+            ConfigValueContainer* cont = getIdentifier()->getConfigValueContainer("CoeffPos");
+            if (!cont)
+            {
+                cont = new ConfigValueContainer(CFT_Keybindings, getIdentifier(), "CoeffPos", coeffPos);
+                getIdentifier()->addConfigValueContainer("CoeffPos", cont);
+            }
+            cont->getValue(&coeffPos);
+            cont = getIdentifier()->getConfigValueContainer("CoeffNeg");
+            if (!cont)
+            {
+                cont = new ConfigValueContainer(CFT_Keybindings, getIdentifier(), "CoeffNeg", coeffNeg);
+                getIdentifier()->addConfigValueContainer("CoeffNeg", cont);
+            }
+            cont->getValue(&coeffNeg);
+            cont = getIdentifier()->getConfigValueContainer("Zero");
+            if (!cont)
+            {
+                cont = new ConfigValueContainer(CFT_Keybindings, getIdentifier(), "Zero", zero);
+                getIdentifier()->addConfigValueContainer("Zero", cont);
+            }
+            cont->getValue(&zero);
+            // copy values to our own variables
+            for (unsigned int i = 0; i < 24; i++)
+            {
+                joySticksCalibration_[0].positiveCoeff[i] = coeffPos[i];
+                joySticksCalibration_[0].negativeCoeff[i] = coeffNeg[i];
+                joySticksCalibration_[0].zeroStates[i]    = zero[i];
+            }
+        }
+    }
+    // ############################################################
+    // #####                    Destruction                   #####
+    // ##########                                        ##########
+    // ############################################################
+    /**
+    @brief
+        Destroys all the created input devices and sets the InputManager to construction state.
+    */
+    void InputManager::_destroy()
+    {
+        if (inputSystem_)
+        {
+            CCOUT(ORX_DEBUG) << "Destroying ..." << std::endl;
+            // kick all active states 'nicely'
+            for (std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin();
+                rit != activeStates_.rend(); ++rit)
+                (*rit).second->onLeave();
+            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();
+            _redimensionLists();
+            OIS::InputManager::destroyInputSystem(inputSystem_);
+            inputSystem_ = 0;
+            CCOUT(ORX_DEBUG) << "Destroying done." << std::endl;
+        }
+    }
+    /**
+    @brief
+        Destroys the keyboard and sets it to 0.
+    */
+    void InputManager::_destroyKeyboard()
+    {
+        if (keyboard_)
+            inputSystem_->destroyInputObject(keyboard_);
+        keyboard_ = 0;
+        keysDown_.clear();
+        CCOUT(ORX_DEBUG) << "Keyboard destroyed." << std::endl;
+    }
+    /**
+    @brief
+        Destroys the mouse and sets it to 0.
+    */
+    void InputManager::_destroyMouse()
+    {
+        if (mouse_)
+            inputSystem_->destroyInputObject(mouse_);
+        mouse_ = 0;
+        mouseButtonsDown_.clear();
+        CCOUT(ORX_DEBUG) << "Mouse destroyed." << std::endl;
+    }
+    /**
+    @brief
+        Destroys all the joy sticks and resizes the lists to 0.
+    */
+    void InputManager::_destroyJoySticks()
+    {
+        if (joySticksSize_ > 0)
+        {
+            // note: inputSystem_ can never be 0, or else the code is mistaken
+            for (unsigned int i = 0; i < joySticksSize_; i++)
+                if (joySticks_[i] != 0)
+                    inputSystem_->destroyInputObject(joySticks_[i]);
+            joySticks_.clear();
+        }
+        CCOUT(ORX_DEBUG) << "Joy sticks destroyed." << std::endl;
+    }
+    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
+    */
+    void InputManager::_tick(float dt)
+    {
+        if (inputSystem_ == 0)
+            return;
+        // 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();
+        for (unsigned  int i = 0; i < joySticksSize_; i++)
+            joySticks_[i]->capture();
+        if (!bCalibrating_)
+        {
+            // call all the handlers for the held key events
+            for (unsigned int iKey = 0; iKey < keysDown_.size(); iKey++)
+                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++)
+                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++)
+                    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);
+    }
+    void InputManager::_completeCalibration()
+    {
+        for (unsigned int i = 0; i < 24; i++)
+        {
+            // positive coefficient
+            if (marginalsMax_[i] == INT_MIN)
+                marginalsMax_[i] =  32767;
+            // coefficients
+            if (marginalsMax_[i] - joySticksCalibration_[0].zeroStates[i])
+            {
+                joySticksCalibration_[0].positiveCoeff[i]
+                    = 1.0f/(marginalsMax_[i] - joySticksCalibration_[0].zeroStates[i]);
+            }
+            else
+                joySticksCalibration_[0].positiveCoeff[i] =  1.0f;
+            // config value
+            ConfigValueContainer* cont = getIdentifier()->getConfigValueContainer("CoeffPos");
+            assert(cont);
+            cont->set(i, joySticksCalibration_[0].positiveCoeff[i]);
+            // negative coefficient
+            if (marginalsMin_[i] == INT_MAX)
+                marginalsMin_[i] = -32768;
+            // coefficients
+            if (marginalsMin_[i] - joySticksCalibration_[0].zeroStates[i])
+            {
+                joySticksCalibration_[0].negativeCoeff[i] = -1.0f
+                    / (marginalsMin_[i] - joySticksCalibration_[0].zeroStates[i]);
+            }
+            else
+                joySticksCalibration_[0].negativeCoeff[i] =  1.0f;
+            // config value
+            cont = getIdentifier()->getConfigValueContainer("CoeffNeg");
+            assert(cont);
+            cont->set(i, joySticksCalibration_[0].negativeCoeff[i]);
+            // zero states
+            if (i < 8)
+            {
+                if (!(i & 1))
+                    joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mSliders[i/2].abX;
+                else
+                    joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mSliders[i/2].abY;
+            }
+            else
+            {
+                if (i - 8 < joySticks_[0]->getJoyStickState().mAxes.size())
+                    joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mAxes[i - 8].abs;
+                else
+                    joySticksCalibration_[0].zeroStates[i] = 0;
+            }
+            // config value
+            cont = getIdentifier()->getConfigValueContainer("Zero");
+            assert(cont);
+            cont->set(i, joySticksCalibration_[0].zeroStates[i]);
+        }
+        // restore old input state
+        requestLeaveState("calibrator");
+    }
+    // ############################################################
+    // #####                    OIS events                    #####
+    // ##########                                        ##########
+    // ############################################################
+    // ###### Key Events ######
+    /**
+    @brief
+        Event handler for the keyPressed Event.
+    @param e
+        Event information
+    */
+    bool InputManager::keyPressed(const OIS::KeyEvent &e)
+    {
+        // check whether the key already is in the list (can happen when focus was lost)
+        unsigned int iKey = 0;
+        while (iKey < keysDown_.size() && keysDown_[iKey].key != (KeyCode::Enum)e.key)
+            iKey++;
+        if (iKey == keysDown_.size())
+            keysDown_.push_back(Key(e));
+        // update modifiers
+        if(e.key == OIS::KC_RMENU    || e.key == OIS::KC_LMENU)
+            keyboardModifiers_ |= KeyboardModifier::Alt;   // alt key
+        if(e.key == OIS::KC_RCONTROL || e.key == OIS::KC_LCONTROL)
+            keyboardModifiers_ |= KeyboardModifier::Ctrl;  // ctrl key
+        if(e.key == OIS::KC_RSHIFT   || e.key == OIS::KC_LSHIFT)
+            keyboardModifiers_ |= KeyboardModifier::Shift; // shift key
+        activeStatesTop_[Keyboard]->keyPressed(KeyEvent(e, keyboardModifiers_));
+        return true;
+    }
+    /**
+    @brief
+        Event handler for the keyReleased Event.
+    @param e
+        Event information
+    */
+    bool InputManager::keyReleased(const OIS::KeyEvent &e)
+    {
+        // remove the key from the keysDown_ list
+        for (unsigned int iKey = 0; iKey < keysDown_.size(); iKey++)
+        {
+            if (keysDown_[iKey].key == (KeyCode::Enum)e.key)
+            {
+                keysDown_.erase(keysDown_.begin() + iKey);
+                break;
+            }
+        }
+        // update modifiers
+        if(e.key == OIS::KC_RMENU    || e.key == OIS::KC_LMENU)
+            keyboardModifiers_ &= ~KeyboardModifier::Alt;   // alt key
+        if(e.key == OIS::KC_RCONTROL || e.key == OIS::KC_LCONTROL)
+            keyboardModifiers_ &= ~KeyboardModifier::Ctrl;  // ctrl key
+        if(e.key == OIS::KC_RSHIFT   || e.key == OIS::KC_LSHIFT)
+            keyboardModifiers_ &= ~KeyboardModifier::Shift; // shift key
+        activeStatesTop_[Keyboard]->keyReleased(KeyEvent(e, keyboardModifiers_));
+        return true;
+    }
+    // ###### Mouse Events ######
+    /**
+    @brief
+        Event handler for the mouseMoved Event.
+    @param e
+        Event information
+    */
+    bool InputManager::mouseMoved(const OIS::MouseEvent &e)
+    {
+        // check for actual moved event
+        if (e.state.X.rel != 0 || e.state.Y.rel != 0)
+        {
+            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));
+        }
+        // check for mouse scrolled event
+        if (e.state.Z.rel != 0)
+        {
+            activeStatesTop_[Mouse]->mouseScrolled(e.state.Z.abs, e.state.Z.rel);
+        }
+        return true;
+    }
+    /**
+    @brief
+        Event handler for the mousePressed Event.
+    @param e
+        Event information
+    @param id
+        The ID of the mouse button
+    */
+    bool InputManager::mousePressed(const OIS::MouseEvent &e, OIS::MouseButtonID id)
+    {
+        // check whether the button already is in the list (can happen when focus was lost)
+        unsigned int iButton = 0;
+        while (iButton < mouseButtonsDown_.size() && mouseButtonsDown_[iButton] != (MouseButton::Enum)id)
+            iButton++;
+        if (iButton == mouseButtonsDown_.size())
+            mouseButtonsDown_.push_back((MouseButton::Enum)id);
+        activeStatesTop_[Mouse]->mouseButtonPressed((MouseButton::Enum)id);
+        return true;
+    }
+    /**
+    @brief
+        Event handler for the mouseReleased Event.
+    @param e
+        Event information
+    @param id
+        The ID of the mouse button
+    */
+    bool InputManager::mouseReleased(const OIS::MouseEvent &e, OIS::MouseButtonID id)
+    {
+        // remove the button from the keysDown_ list
+        for (unsigned int iButton = 0; iButton < mouseButtonsDown_.size(); iButton++)
+        {
+            if (mouseButtonsDown_[iButton] == (MouseButton::Enum)id)
+            {
+                mouseButtonsDown_.erase(mouseButtonsDown_.begin() + iButton);
+                break;
+            }
+        }
+        activeStatesTop_[Mouse]->mouseButtonReleased((MouseButton::Enum)id);
+        return true;
+    }
+    // ###### Joy Stick Events ######
+    inline unsigned int InputManager::_getJoystick(const OIS::JoyStickEvent& arg)
+    {
+        // use the device to identify which one called the method
+        OIS::JoyStick* joyStick = (OIS::JoyStick*)arg.device;
+        unsigned int iJoyStick = 0;
+        while (joySticks_[iJoyStick] != joyStick)
+            iJoyStick++;
+        // assert: Unknown joystick fired an event.
+        assert(iJoyStick != joySticksSize_);
+        return iJoyStick;
+    }
+    bool InputManager::buttonPressed(const OIS::JoyStickEvent &arg, int button)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        // check whether the button already is in the list (can happen when focus was lost)
+        std::vector<int>& buttonsDown = joyStickButtonsDown_[iJoyStick];
+        unsigned int iButton = 0;
+        while (iButton < buttonsDown.size() && buttonsDown[iButton] != button)
+            iButton++;
+        if (iButton == buttonsDown.size())
+            buttonsDown.push_back(button);
+        activeStatesTop_[2 + iJoyStick]->joyStickButtonPressed(iJoyStick, button);
+        return true;
+    }
+    bool InputManager::buttonReleased(const OIS::JoyStickEvent &arg, int button)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        // remove the button from the joyStickButtonsDown_ list
+        std::vector<int>& buttonsDown = joyStickButtonsDown_[iJoyStick];
+        for (unsigned int iButton = 0; iButton < buttonsDown.size(); iButton++)
+        {
+            if (buttonsDown[iButton] == button)
+            {
+                buttonsDown.erase(buttonsDown.begin() + iButton);
+                break;
+            }
+        }
+        activeStatesTop_[2 + iJoyStick]->joyStickButtonReleased(iJoyStick, button);
+        return true;
+    }
+    void InputManager::_fireAxis(unsigned int iJoyStick, int axis, int value)
+    {
+        if (bCalibrating_)
+        {
+            if (value > marginalsMax_[axis])
+                marginalsMax_[axis] = value;
+            if (value < marginalsMin_[axis])
+                marginalsMin_[axis] = value;
+        }
+        else
+        {
+            float fValue = value - joySticksCalibration_[iJoyStick].zeroStates[axis];
+            if (fValue > 0.0f)
+                fValue *= joySticksCalibration_[iJoyStick].positiveCoeff[axis];
+            else
+                fValue *= joySticksCalibration_[iJoyStick].negativeCoeff[axis];
+            activeStatesTop_[2 + iJoyStick]->joyStickAxisMoved(iJoyStick, axis, fValue);
+        }
+    }
+    bool InputManager::axisMoved(const OIS::JoyStickEvent &arg, int axis)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        // keep in mind that the first 8 axes are reserved for the sliders
+        _fireAxis(iJoyStick, axis + 8, arg.state.mAxes[axis].abs);
+        return true;
+    }
+    bool InputManager::sliderMoved(const OIS::JoyStickEvent &arg, int id)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        if (sliderStates_[iJoyStick].sliderStates[id].x != arg.state.mSliders[id].abX)
+            _fireAxis(iJoyStick, id * 2, arg.state.mSliders[id].abX);
+        else if (sliderStates_[iJoyStick].sliderStates[id].y != arg.state.mSliders[id].abY)
+            _fireAxis(iJoyStick, id * 2 + 1, arg.state.mSliders[id].abY);
+        return true;
+    }
+    bool InputManager::povMoved(const OIS::JoyStickEvent &arg, int id)
+    {
+        unsigned int iJoyStick = _getJoystick(arg);
+        // translate the POV into 8 simple buttons
+        int lastState = povStates_[iJoyStick][id];
+        if (lastState & OIS::Pov::North)
+            buttonReleased(arg, 32 + id * 4 + 0);
+        if (lastState & OIS::Pov::South)
+            buttonReleased(arg, 32 + id * 4 + 1);
+        if (lastState & OIS::Pov::East)
+            buttonReleased(arg, 32 + id * 4 + 2);
+        if (lastState & OIS::Pov::West)
+            buttonReleased(arg, 32 + id * 4 + 3);
+        povStates_[iJoyStick].povStates[id] = arg.state.mPOV[id].direction;
+        int currentState = povStates_[iJoyStick][id];
+        if (currentState & OIS::Pov::North)
+            buttonPressed(arg, 32 + id * 4 + 0);
+        if (currentState & OIS::Pov::South)
+            buttonPressed(arg, 32 + id * 4 + 1);
+        if (currentState & OIS::Pov::East)
+            buttonPressed(arg, 32 + id * 4 + 2);
+        if (currentState & OIS::Pov::West)
+            buttonPressed(arg, 32 + id * 4 + 3);
+        return true;
+    }
+    // ############################################################
+    // #####            Static Interface Methods              #####
+    // ##########                                        ##########
+    // ############################################################
+    std::string InputManager::bindingCommmandString_s = "";
+    bool InputManager::initialise(const size_t windowHnd, int windowWidth, int windowHeight,
         bool createKeyboard, bool createMouse, bool createJoySticks)
+  {
+    if (state_ == IS_UNINIT)
+    {
+      CCOUT(3) << "Initialising Input System..." << std::endl;
+      CCOUT(ORX_DEBUG) << "Initialising OIS components..." << std::endl;
+      OIS::ParamList paramList;
+      std::ostringstream windowHndStr;
+      // Fill parameter list
+      windowHndStr << (unsigned int)windowHnd;
+      paramList.insert(std::make_pair(std::string("WINDOW"), windowHndStr.str()));
+      //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_NONEXCLUSIVE")));
+      //paramList.insert(std::make_pair(std::string("w32_mouse"), std::string("DISCL_FOREGROUND")));
+//#if defined OIS_LINUX_PLATFORM
+//      paramList.insert(std::make_pair(std::string("XAutoRepeatOn"), std::string("true")));
+//#endif
+      try
+      {
+        inputSystem_ = OIS::InputManager::createInputSystem(paramList);
+        CCOUT(ORX_DEBUG) << "Created OIS input system" << std::endl;
+      }
+      catch (OIS::Exception ex)
+      {
+        CCOUT(ORX_ERROR) << "Error: Failed creating an OIS input system."
+            << "OIS message: \"" << ex.eText << "\"" << std::endl;
+        inputSystem_ = 0;
+    {
+        return _getInstance()._initialise(windowHnd, windowWidth, windowHeight,
+            createKeyboard, createMouse, createJoySticks);
+    }
+    bool InputManager::initialiseKeyboard()
+    {
+        return _getInstance()._initialiseKeyboard();
+    }
+    bool InputManager::initialiseMouse()
+    {
+        return _getInstance()._initialiseMouse();
+    }
+    bool InputManager::initialiseJoySticks()
+    {
+        return _getInstance()._initialiseJoySticks();
+    }
+    int InputManager::numberOfKeyboards()
+    {
+        if (_getInstance().keyboard_ != 0)
+            return 1;
+        else
+            return 0;
+    }
+    int InputManager::numberOfMice()
+    {
+        if (_getInstance().mouse_ != 0)
+            return 1;
+        else
+            return 0;
+    }
+    int InputManager::numberOfJoySticks()
+    {
+        return _getInstance().joySticksSize_;
+    }
+    /*bool InputManager::isKeyDown(KeyCode::Enum key)
+    {
+    if (_getInstance().keyboard_)
+        return _getInstance().keyboard_->isKeyDown((OIS::KeyCode)key);
+    else
         return false;
+      }
+      if (createKeyboard)
+        _initialiseKeyboard();
+      if (createMouse)
+        _initialiseMouse();
+      if (createJoySticks)
+        _initialiseJoySticks();
+      // Set mouse/joystick region
+      if (mouse_)
+      {
+        setWindowExtents(windowWidth, windowHeight);
+      }
+      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");
+      setConfigValues();
+      CCOUT(ORX_DEBUG) << "Initialising complete." << std::endl;
+    }
+    }*/
+    /*bool InputManager::isModifierDown(KeyboardModifier::Enum modifier)
+    {
+    if (_getInstance().keyboard_)
+        return isModifierDown(modifier);
     else
+    {
-      CCOUT(ORX_WARNING) << "Warning: OIS compoments already initialised, skipping" << std::endl;
+    }
-    return true;
+  }
-  /**
-    @brief Creates a keyboard and sets the event handler.
-    @return False if keyboard stays uninitialised, true otherwise.
-  */
-  bool InputManager::_initialiseKeyboard()
+  {
-    if (keyboard_ != 0)
+    {
-      CCOUT(2) << "Warning: Keyboard already initialised, skipping." << std::endl;
-      return true;
+    }
-    try
+    {
-      if (inputSystem_->getNumberOfDevices(OIS::OISKeyboard) > 0)
+      {
-        keyboard_ = (OIS::Keyboard*)inputSystem_->createInputObject(OIS::OISKeyboard, true);
-        // register our listener in OIS.
-        keyboard_->setEventCallback(this);
-        // note: OIS will not detect keys that have already been down when the keyboard was created.
-        CCOUT(ORX_DEBUG) << "Created OIS keyboard" << std::endl;
-        return true;
+      }
-      else
+      {
-        CCOUT(ORX_WARNING) << "Warning: No keyboard found!" << std::endl;
         return false;
+      }
+    }
+    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;
+      keyboard_ = 0;
+      return false;
+    }
+  }
+  /**
+    @brief Creates a mouse and sets the event handler.
+    @return False if mouse stays uninitialised, true otherwise.
+  */
+  bool InputManager::_initialiseMouse()
+  {
+    if (mouse_ != 0)
+    {
+      CCOUT(2) << "Warning: Mouse already initialised, skipping." << std::endl;
+      return true;
+    }
+    try
+    {
+      if (inputSystem_->getNumberOfDevices(OIS::OISMouse) > 0)
+      {
+        mouse_ = static_cast<OIS::Mouse*>(inputSystem_->createInputObject(OIS::OISMouse, true));
+        // register our listener in OIS.
+        mouse_->setEventCallback(this);
+        CCOUT(ORX_DEBUG) << "Created OIS mouse" << std::endl;
+        return true;
+      }
+      else
+      {
+        CCOUT(ORX_WARNING) << "Warning: No mouse found!" << std::endl;
+    }*/
+    /*const MouseState InputManager::getMouseState()
+    {
+    if (_getInstance().mouse_)
+        return _getInstance().mouse_->getMouseState();
+    else
+        return MouseState();
+    }*/
+    /*const JoyStickState InputManager::getJoyStickState(unsigned int ID)
+    {
+    if (ID < _getInstance().joySticksSize_)
+        return JoyStickState(_getInstance().joySticks_[ID]->getJoyStickState(), ID);
+    else
+        return JoyStickState();
+    }*/
+    void InputManager::destroy()
+    {
+        _getInstance()._destroy();
+    }
+    void InputManager::destroyKeyboard()
+    {
+        return _getInstance()._destroyKeyboard();
+    }
+    void InputManager::destroyMouse()
+    {
+        return _getInstance()._destroyMouse();
+    }
+    void InputManager::destroyJoySticks()
+    {
+        return _getInstance()._destroyJoySticks();
+    }
+    /**
+    @brief
+        Adjusts the mouse window metrics.
+        This method has to be called every time the size of the window changes.
+    @param width
+        The new width of the render window
+    @param^height
+        The new height of the render window
+    */
+    void InputManager::setWindowExtents(const int width, const int height)
+    {
+        if (_getInstance().mouse_)
+        {
+            // Set mouse region (if window resizes, we should alter this to reflect as well)
+            const OIS::MouseState &mouseState = _getInstance().mouse_->getMouseState();
+            mouseState.width  = width;
+            mouseState.height = height;
+        }
+    }
+    void InputManager::storeKeyStroke(const std::string& name)
+    {
+        requestLeaveState("detector");
+        COUT(0) << "Binding string \"" << bindingCommmandString_s << "\" on key '" << name << "'" << std::endl;
+        CommandExecutor::execute("config KeyBinder " + name + " " + bindingCommmandString_s, false);
+    }
+    void InputManager::keyBind(const std::string& command)
+    {
+        bindingCommmandString_s = command;
+        requestEnterState("detector");
+        COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
+    }
+    void InputManager::calibrate()
+    {
+        requestEnterState("calibrator");
+    }
+    void InputManager::tick(float dt)
+    {
+        _getInstance()._tick(dt);
+    }
+    // ###### InputStates ######
+    /**
+    @brief
+        Adds a new key 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::_configureInputState(InputState* state, const std::string& name, int priority)
+    {
+        if (name == "")
+            return false;
+        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;
+        }
+    }
+    /**
+    @brief
+        Removes a Key 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::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;
+        }
         return false;
+      }
+    }
+    catch (OIS::Exception ex)
+    {
+      CCOUT(ORX_WARNING) << "Warning: Failed to create an OIS mouse\n"
+          << "OIS error message: \"" << ex.eText << "\"" << std::endl;
+      mouse_ = 0;
+      return false;
+    }
+  }
+  /**
+    @brief Creates all joy sticks and sets the event handler.
+    @return False joy stick stay uninitialised, true otherwise.
+  */
+  bool InputManager::_initialiseJoySticks()
+  {
+    if (joySticksSize_ > 0)
+    {
+      CCOUT(2) << "Warning: Joy sticks already initialised, skipping." << std::endl;
+      return true;
+    }
+    bool success = false;
+    if (inputSystem_->getNumberOfDevices(OIS::OISJoyStick) > 0)
+    {
+      for (int i = 0; i < inputSystem_->getNumberOfDevices(OIS::OISJoyStick); i++)
+      {
+        try
+        {
+          OIS::JoyStick* stig = static_cast<OIS::JoyStick*>(inputSystem_->createInputObject(OIS::OISJoyStick, true));
+          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;
+        }
+        catch (OIS::Exception ex)
+        {
+          CCOUT(ORX_WARNING) << "Warning: Failed to create OIS joy number" << i << "\n"
+              << "OIS error message: \"" << ex.eText << "\"" << std::endl;
+        }
+      }
+    }
+    else
+    {
+      CCOUT(ORX_WARNING) << "Warning: Joy stick support requested, but no joy stick was found" << std::endl;
+      return false;
+    }
+    joySticksSize_ = joySticks_.size();
+    activeJoyStickHandlers_.resize(joySticksSize_);
+    joyStickButtonsDown_.resize(joySticksSize_);
+    povStates_.resize(joySticksSize_);
+    sliderStates_.resize(joySticksSize_);
+    joySticksCalibration_.resize(joySticksSize_);
+    for (unsigned int iJoyStick = 0; iJoyStick < joySticksSize_; iJoyStick++)
+    {
+      // reset the calibration with default values
+      for (unsigned int i = 0; i < 24; i++)
+      {
+        joySticksCalibration_[iJoyStick].negativeCoeff[i] = 1.0f/32767.0f;
+        joySticksCalibration_[iJoyStick].positiveCoeff[i] = 1.0f/32768.0f;
+        joySticksCalibration_[iJoyStick].zeroStates[i] = 0;
+      }
+    }
+    return success;
+  }
+  /**
+    @brief Sets the configurable values. Use keybindings.ini as file..
+  */
+  void InputManager::setConfigValues()
+  {
+    if (joySticksSize_)
+    {
+      std::vector<MultiTypeMath> coeffPos;
+      std::vector<MultiTypeMath> coeffNeg;
+      std::vector<MultiTypeMath> zero;
+      coeffPos.resize(24);
+      coeffNeg.resize(24);
+      zero.resize(24);
+      for (unsigned int i = 0; i < 24; i++)
+      {
+        coeffPos[i] =  1.0f/32767.0f;
+        coeffNeg[i] =  1.0f/32768.0f;
+        zero[i]     =  0;
+      }
+      ConfigValueContainer* cont = getIdentifier()->getConfigValueContainer("CoeffPos");
+      if (!cont)
+      {
+          cont = new ConfigValueContainer(CFT_Keybindings, getIdentifier(), "CoeffPos", coeffPos);
+          getIdentifier()->addConfigValueContainer("CoeffPos", cont);
+      }
+      cont->getValue(&coeffPos);
+      cont = getIdentifier()->getConfigValueContainer("CoeffNeg");
+      if (!cont)
+      {
+          cont = new ConfigValueContainer(CFT_Keybindings, getIdentifier(), "CoeffNeg", coeffNeg);
+          getIdentifier()->addConfigValueContainer("CoeffNeg", cont);
+      }
+      cont->getValue(&coeffNeg);
+      cont = getIdentifier()->getConfigValueContainer("Zero");
+      if (!cont)
+      {
+          cont = new ConfigValueContainer(CFT_Keybindings, getIdentifier(), "Zero", zero);
+          getIdentifier()->addConfigValueContainer("Zero", cont);
+      }
+      cont->getValue(&zero);
+      // copy values to our own variables
+      for (unsigned int i = 0; i < 24; i++)
+      {
+        joySticksCalibration_[0].positiveCoeff[i] = coeffPos[i];
+        joySticksCalibration_[0].negativeCoeff[i] = coeffNeg[i];
+        joySticksCalibration_[0].zeroStates[i]    = zero[i];
+      }
+    }
+  }
+  /**
+    @brief Destroys all the created input devices and sets the InputManager to construction state.
+  */
+  void InputManager::_destroy()
+  {
+    if (state_ != IS_UNINIT)
+    {
+      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();
+      _destroyKeyboard();
+      _destroyMouse();
+      _destroyJoySticks();
+      activeHandlers_.clear();
+      // inputSystem_ can never be 0, or else the code is mistaken
+      OIS::InputManager::destroyInputSystem(inputSystem_);
+      inputSystem_ = 0;
+      state_ = IS_UNINIT;
+      CCOUT(ORX_DEBUG) << "Destroying done." << std::endl;
+    }
+  }
+  /**
+    @brief Destroys the keyboard and sets it to 0.
+  */
+  void InputManager::_destroyKeyboard()
+  {
+    if (keyboard_)
+      // inputSystem_ can never be 0, or else the code is mistaken
+      inputSystem_->destroyInputObject(keyboard_);
+    keyboard_ = 0;
+    activeKeyHandlers_.clear();
+    keysDown_.clear();
+    CCOUT(ORX_DEBUG) << "Keyboard destroyed." << std::endl;
+  }
+  /**
+    @brief Destroys the mouse and sets it to 0.
+  */
+  void InputManager::_destroyMouse()
+  {
+    if (mouse_)
+      // inputSystem_ can never be 0, or else the code is mistaken
+      inputSystem_->destroyInputObject(mouse_);
+    mouse_ = 0;
+    activeMouseHandlers_.clear();
+    mouseButtonsDown_.clear();
+    CCOUT(ORX_DEBUG) << "Mouse destroyed." << std::endl;
+  }
+  /**
+    @brief Destroys all the joy sticks and resizes the lists to 0.
+  */
+  void InputManager::_destroyJoySticks()
+  {
+    if (joySticksSize_ > 0)
+    {
+      // note: inputSystem_ can never be 0, or else the code is mistaken
+      for (unsigned int i = 0; i < joySticksSize_; i++)
+        if (joySticks_[i] != 0)
+          inputSystem_->destroyInputObject(joySticks_[i]);
+      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.
+    @param dt Delta time
+  */
+  void InputManager::_tick(float dt)
+  {
+    if (state_ == IS_UNINIT)
+      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;
+        }
+    }
+    /**
+    @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.
+    */
+    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
+        {
+          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;
+      }
+    }
+    // Capture all the input. This calls the event handlers in InputManager.
+    if (mouse_)
+      mouse_->capture();
+    if (keyboard_)
+      keyboard_->capture();
+    for (unsigned  int i = 0; i < joySticksSize_; i++)
+      joySticks_[i]->capture();
+    if (state_ != IS_CALIBRATE)
+    {
+      // 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_));
+      // 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]);
+      // 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);
+  }
+  void InputManager::_completeCalibration()
+  {
+    for (unsigned int i = 0; i < 24; i++)
+    {
+      // positive coefficient
+      if (marginalsMax_[i] == INT_MIN)
+        marginalsMax_[i] =  32767;
+      // coefficients
+      if (marginalsMax_[i] - joySticksCalibration_[0].zeroStates[i])
+        joySticksCalibration_[0].positiveCoeff[i] =  1.0f/(marginalsMax_[i] - joySticksCalibration_[0].zeroStates[i]);
+      else
+        joySticksCalibration_[0].positiveCoeff[i] =  1.0f;
+      // config value
+      ConfigValueContainer* cont = getIdentifier()->getConfigValueContainer("CoeffPos");
+      assert(cont);
+      cont->set(i, joySticksCalibration_[0].positiveCoeff[i]);
+      // negative coefficient
+      if (marginalsMin_[i] == INT_MAX)
+        marginalsMin_[i] = -32768;
+      // coefficients
+      if (marginalsMin_[i] - joySticksCalibration_[0].zeroStates[i])
+        joySticksCalibration_[0].negativeCoeff[i] = -1.0f/(marginalsMin_[i] - joySticksCalibration_[0].zeroStates[i]);
+      else
+        joySticksCalibration_[0].negativeCoeff[i] =  1.0f;
+      // config value
+      cont = getIdentifier()->getConfigValueContainer("CoeffNeg");
+      assert(cont);
+      cont->set(i, joySticksCalibration_[0].negativeCoeff[i]);
+      // zero states
+      if (i < 8)
+      {
+        if (!(i & 1))
+          joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mSliders[i/2].abX;
+        else
+          joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mSliders[i/2].abY;
+      }
+      else
+      {
+        if (i - 8 < joySticks_[0]->getJoyStickState().mAxes.size())
+          joySticksCalibration_[0].zeroStates[i] = joySticks_[0]->getJoyStickState().mAxes[i - 8].abs;
+        else
+          joySticksCalibration_[0].zeroStates[i] = 0;
+      }
+      // config value
+      cont = getIdentifier()->getConfigValueContainer("Zero");
+      assert(cont);
+      cont->set(i, joySticksCalibration_[0].zeroStates[i]);
+    }
+  }
+  // ###### Key Events ######
+  /**
+    @brief Event handler for the keyPressed Event.
+    @param e Event information
+  */
+  bool InputManager::keyPressed(const OIS::KeyEvent &e)
+  {
+    // check whether the key already is in the list (can happen when focus was lost)
+    unsigned int iKey = 0;
+    while (iKey < keysDown_.size() && keysDown_[iKey].key != (KeyCode::Enum)e.key)
+      iKey++;
+    if (iKey == keysDown_.size())
+      keysDown_.push_back(Key(e));
+    // update modifiers
+    if(e.key == OIS::KC_RMENU    || e.key == OIS::KC_LMENU)
+      keyboardModifiers_ |= KeyboardModifier::Alt;   // alt key
+    if(e.key == OIS::KC_RCONTROL || e.key == OIS::KC_LCONTROL)
+      keyboardModifiers_ |= KeyboardModifier::Ctrl;  // ctrl key
+    if(e.key == OIS::KC_RSHIFT   || e.key == OIS::KC_LSHIFT)
+      keyboardModifiers_ |= KeyboardModifier::Shift; // shift key
+    for (unsigned int i = 0; i < activeKeyHandlers_.size(); i++)
+      activeKeyHandlers_[i]->keyPressed(KeyEvent(e, keyboardModifiers_));
+    return true;
+  }
+  /**
+    @brief Event handler for the keyReleased Event.
+    @param e Event information
+  */
+  bool InputManager::keyReleased(const OIS::KeyEvent &e)
+  {
+    // remove the key from the keysDown_ list
+    for (unsigned int iKey = 0; iKey < keysDown_.size(); iKey++)
+    {
+      if (keysDown_[iKey].key == (KeyCode::Enum)e.key)
+      {
+        keysDown_.erase(keysDown_.begin() + iKey);
+        break;
+      }
+    }
+    // update modifiers
+    if(e.key == OIS::KC_RMENU    || e.key == OIS::KC_LMENU)
+      keyboardModifiers_ &= ~KeyboardModifier::Alt;   // alt key
+    if(e.key == OIS::KC_RCONTROL || e.key == OIS::KC_LCONTROL)
+      keyboardModifiers_ &= ~KeyboardModifier::Ctrl;  // ctrl key
+    if(e.key == OIS::KC_RSHIFT   || e.key == OIS::KC_LSHIFT)
+      keyboardModifiers_ &= ~KeyboardModifier::Shift; // shift key
+    for (unsigned int i = 0; i < activeKeyHandlers_.size(); i++)
+      activeKeyHandlers_[i]->keyReleased(KeyEvent(e, keyboardModifiers_));
+    return true;
+  }
+  // ###### Mouse Events ######
+  /**
+    @brief Event handler for the mouseMoved Event.
+    @param e Event information
+  */
+  bool InputManager::mouseMoved(const OIS::MouseEvent &e)
+  {
+    // check for actual moved event
+    if (e.state.X.rel != 0 || e.state.Y.rel != 0)
+    {
+      for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
+        activeMouseHandlers_[i]->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));
+    }
+    // check for mouse scrolled event
+    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);
+    }
+    return true;
+  }
+  /**
+    @brief Event handler for the mousePressed Event.
+    @param e Event information
+    @param id The ID of the mouse button
+  */
+  bool InputManager::mousePressed(const OIS::MouseEvent &e, OIS::MouseButtonID id)
+  {
+    // check whether the button already is in the list (can happen when focus was lost)
+    unsigned int iButton = 0;
+    while (iButton < mouseButtonsDown_.size() && mouseButtonsDown_[iButton] != (MouseButton::Enum)id)
+      iButton++;
+    if (iButton == mouseButtonsDown_.size())
+      mouseButtonsDown_.push_back((MouseButton::Enum)id);
+    for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
+      activeMouseHandlers_[i]->mouseButtonPressed((MouseButton::Enum)id);
+    return true;
+  }
+  /**
+    @brief Event handler for the mouseReleased Event.
+    @param e Event information
+    @param id The ID of the mouse button
+  */
+  bool InputManager::mouseReleased(const OIS::MouseEvent &e, OIS::MouseButtonID id)
+  {
+    // remove the button from the keysDown_ list
+    for (unsigned int iButton = 0; iButton < mouseButtonsDown_.size(); iButton++)
+    {
+      if (mouseButtonsDown_[iButton] == (MouseButton::Enum)id)
+      {
+        mouseButtonsDown_.erase(mouseButtonsDown_.begin() + iButton);
+        break;
+      }
+    }
+    for (unsigned int i = 0; i < activeMouseHandlers_.size(); i++)
+      activeMouseHandlers_[i]->mouseButtonReleased((MouseButton::Enum)id);
+    return true;
+  }
+  // ###### Joy Stick Events ######
+  inline unsigned int InputManager::_getJoystick(const OIS::JoyStickEvent& arg)
+  {
+    // use the device to identify which one called the method
+    OIS::JoyStick* joyStick = (OIS::JoyStick*)arg.device;
+    unsigned int iJoyStick = 0;
+    while (joySticks_[iJoyStick] != joyStick)
+    {
+      iJoyStick++;
+      if (iJoyStick == joySticksSize_)
+      {
+        CCOUT(3) << "Unknown joystick fired an event. This means there is a bug somewhere! Aborting." << std::endl;
+        abort();
+      }
+    }
+    return iJoyStick;
+  }
+  bool InputManager::buttonPressed(const OIS::JoyStickEvent &arg, int button)
+  {
+    unsigned int iJoyStick = _getJoystick(arg);
+    // check whether the button already is in the list (can happen when focus was lost)
+    std::vector<int>& buttonsDown = joyStickButtonsDown_[iJoyStick];
+    unsigned int iButton = 0;
+    while (iButton < buttonsDown.size() && buttonsDown[iButton] != button)
+      iButton++;
+    if (iButton == buttonsDown.size())
+      buttonsDown.push_back(button);
+    for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
+      activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickButtonPressed(iJoyStick, button);
+    return true;
+  }
+  bool InputManager::buttonReleased(const OIS::JoyStickEvent &arg, int button)
+  {
+    unsigned int iJoyStick = _getJoystick(arg);
+    // remove the button from the joyStickButtonsDown_ list
+    std::vector<int>& buttonsDown = joyStickButtonsDown_[iJoyStick];
+    for (unsigned int iButton = 0; iButton < buttonsDown.size(); iButton++)
+    {
+      if (buttonsDown[iButton] == button)
+      {
+        buttonsDown.erase(buttonsDown.begin() + iButton);
+        break;
+      }
+    }
+    for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
+      activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickButtonReleased(iJoyStick, button);
+    return true;
+  }
+  void InputManager::_fireAxis(unsigned int iJoyStick, int axis, int value)
+  {
+    if (state_ == IS_CALIBRATE)
+    {
+      if (value > marginalsMax_[axis])
+        marginalsMax_[axis] = value;
+      if (value < marginalsMin_[axis])
+        marginalsMin_[axis] = value;
+    }
+    else
+    {
+      float fValue = value - joySticksCalibration_[iJoyStick].zeroStates[axis];
+      if (fValue > 0.0f)
+        fValue *= joySticksCalibration_[iJoyStick].positiveCoeff[axis];
+      else
+        fValue *= joySticksCalibration_[iJoyStick].negativeCoeff[axis];
+      for (unsigned int iHandler = 0; iHandler < activeJoyStickHandlers_[iJoyStick].size(); iHandler++)
+        activeJoyStickHandlers_[iJoyStick][iHandler]->joyStickAxisMoved(iJoyStick, axis, fValue);
+    }
+  }
+  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);
+    // keep in mind that the first 8 axes are reserved for the sliders
+    _fireAxis(iJoyStick, axis + 8, arg.state.mAxes[axis].abs);
+    return true;
+  }
+  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);
+    if (sliderStates_[iJoyStick].sliderStates[id].x != arg.state.mSliders[id].abX)
+      _fireAxis(iJoyStick, id * 2, arg.state.mSliders[id].abX);
+    else if (sliderStates_[iJoyStick].sliderStates[id].y != arg.state.mSliders[id].abY)
+      _fireAxis(iJoyStick, id * 2 + 1, arg.state.mSliders[id].abY);
+    return true;
+  }
+  bool InputManager::povMoved(const OIS::JoyStickEvent &arg, int id)
+  {
+    unsigned int iJoyStick = _getJoystick(arg);
+    // translate the POV into 8 simple buttons
+    int lastState = povStates_[iJoyStick][id];
+    if (lastState & OIS::Pov::North)
+      buttonReleased(arg, 32 + id * 4 + 0);
+    if (lastState & OIS::Pov::South)
+      buttonReleased(arg, 32 + id * 4 + 1);
+    if (lastState & OIS::Pov::East)
+      buttonReleased(arg, 32 + id * 4 + 2);
+    if (lastState & OIS::Pov::West)
+      buttonReleased(arg, 32 + id * 4 + 3);
+    povStates_[iJoyStick].povStates[id] = arg.state.mPOV[id].direction;
+    int currentState = povStates_[iJoyStick][id];
+    if (currentState & OIS::Pov::North)
+      buttonPressed(arg, 32 + id * 4 + 0);
+    if (currentState & OIS::Pov::South)
+      buttonPressed(arg, 32 + id * 4 + 1);
+    if (currentState & OIS::Pov::East)
+      buttonPressed(arg, 32 + id * 4 + 2);
+    if (currentState & OIS::Pov::West)
+      buttonPressed(arg, 32 + id * 4 + 3);
+    return true;
+  }
+  /*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 ###
+  // ################################
+  // ################################
+  std::string InputManager::bindingCommmandString_s = "";
+  bool InputManager::initialise(const size_t windowHnd, int windowWidth, int windowHeight,
+    bool createKeyboard, bool createMouse, bool createJoySticks)
+  {
+    return _getSingleton()._initialise(windowHnd, windowWidth, windowHeight,
+          createKeyboard, createMouse, createJoySticks);
+  }
+  bool InputManager::initialiseKeyboard()
+  {
+    return _getSingleton()._initialiseKeyboard();
+  }
+  bool InputManager::initialiseMouse()
+  {
+    return _getSingleton()._initialiseMouse();
+  }
+  bool InputManager::initialiseJoySticks()
+  {
+    return _getSingleton()._initialiseJoySticks();
+  }
+  int InputManager::numberOfKeyboards()
+  {
+    if (_getSingleton().keyboard_ != 0)
+      return 1;
+    else
+      return 0;
+  }
+  int InputManager::numberOfMice()
+  {
+    if (_getSingleton().mouse_ != 0)
+      return 1;
+    else
+      return 0;
+  }
+  int InputManager::numberOfJoySticks()
+  {
+    return _getSingleton().joySticksSize_;
+  }
+  /*bool InputManager::isKeyDown(KeyCode::Enum key)
+  {
+    if (_getSingleton().keyboard_)
+      return _getSingleton().keyboard_->isKeyDown((OIS::KeyCode)key);
+    else
+      return false;
+  }*/
+  /*bool InputManager::isModifierDown(KeyboardModifier::Enum modifier)
+  {
+    if (_getSingleton().keyboard_)
+      return isModifierDown(modifier);
+    else
+      return false;
+  }*/
+  /*const MouseState InputManager::getMouseState()
+  {
+    if (_getSingleton().mouse_)
+      return _getSingleton().mouse_->getMouseState();
+    else
+      return MouseState();
+  }*/
+  /*const JoyStickState InputManager::getJoyStickState(unsigned int ID)
+  {
+    if (ID < _getSingleton().joySticksSize_)
+      return JoyStickState(_getSingleton().joySticks_[ID]->getJoyStickState(), ID);
+    else
+      return JoyStickState();
+  }*/
+  void InputManager::destroy()
+  {
+    _getSingleton()._destroy();
+  }
+  void InputManager::destroyKeyboard()
+  {
+    return _getSingleton()._destroyKeyboard();
+  }
+  void InputManager::destroyMouse()
+  {
+    return _getSingleton()._destroyMouse();
+  }
+  void InputManager::destroyJoySticks()
+  {
+    return _getSingleton()._destroyJoySticks();
+  }
+  /**
+    @brief Adjusts the mouse window metrics.
+    This method has to be called every time the size of the window changes.
+    @param width The new width of the render window
+    @param height the new height of the render window
+  */
+  void InputManager::setWindowExtents(const int width, const int height)
+  {
+    if (_getSingleton().mouse_)
+    {
+      // Set mouse region (if window resizes, we should alter this to reflect as well)
+      const OIS::MouseState &mouseState = _getSingleton().mouse_->getMouseState();
+      mouseState.width  = width;
+      mouseState.height = height;
+    }
+  }
+  /**
+    @brief Sets the input mode to either GUI, inGame or Buffer
+    @param mode The new input mode
+    @remark 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);
+    COUT(0) << "Binding string \"" << bindingCommmandString_s << "\" on key '" << name << "'" << std::endl;
+    CommandExecutor::execute("config KeyBinder " + name + " " + bindingCommmandString_s, false);
+  }
+  void InputManager::keyBind(const std::string& command)
+  {
+    bindingCommmandString_s = command;
+    setInputState(IS_DETECT);
+    COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
+  }
+  void InputManager::calibrate()
+  {
+    _getSingleton().setInputState(IS_CALIBRATE);
+  }
+  void InputManager::tick(float dt)
+  {
+    _getSingleton()._tick(dt);
+  }
+  // ###### KeyHandler ######
+  /**
+    @brief Adds a new key 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::addKeyHandler(KeyHandler* handler, const std::string& name)
+  {
+    if (!handler)
+      return false;
+    if (_getSingleton().keyHandlers_.find(name) == _getSingleton().keyHandlers_.end())
+    {
+      _getSingleton().keyHandlers_[name] = handler;
+      return true;
+    }
+    else
+      return false;
+  }
+  /**
+    @brief Removes a Key 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::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);
+      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.
+  */
+  KeyHandler* InputManager::getKeyHandler(const std::string& name)
+  {
+    std::map<std::string, KeyHandler*>::iterator it = _getSingleton().keyHandlers_.find(name);
+    if (it != _getSingleton().keyHandlers_.end())
+    {
+      return (*it).second;
+    }
+    else
+      return 0;
+  }
+  /**
+    @brief Enables a specific key handler that has already been added.
+    @param name Unique name of the handler.
+    @return False if name was not found, true otherwise.
+  */
+  bool InputManager::enableKeyHandler(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)
+  {
+    // 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;
+    }
+    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;
+  }
+            return 0;
+    }
+    /**
+    @brief
+        Returns the current input handling method
+    @return
+        The current input mode.
+    */
+    InputState* InputManager::getCurrentState()
+    {
+        return (*_getInstance().activeStates_.rbegin()).second;
+    }
+    /**
+    @brief
+        Enables a specific key handler that has already been added.
+    @param name
+        Unique name of the handler.
+    @return
+        False if name was not found, true otherwise.
+    */
+    bool InputManager::requestEnterState(const std::string& name)
+    {
+        // get pointer from the map with all stored handlers
+        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, InputState*>::const_iterator it = _getInstance().inputStatesByName_.find(name);
+        if (it != _getInstance().inputStatesByName_.end())
+        {
+            _getInstance().stateLeaveRequests_.push_back((*it).second);
+            return true;
+        }
+        return false;
+    }
+}

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

-                      r1555
+                      r1638
 /**
+ @file
+ @brief Implementation of a little Input handler that distributes everything
+        coming from OIS.
+ */
+@file
+@brief
+    Implementation of a little Input handler that distributes everything
+    coming from OIS.
+*/
 #ifndef _InputManager_H__
 …
 #include <map>
 #include <vector>
+#include <stack>
 #include "util/Math.h"
 #include "core/OrxonoxClass.h"
 …
 namespace orxonox
+{
+  /**
+  * Helper class to realise a vector<int[4]>
+  */
+  class POVStates
+  {
+  public:
+    int operator[](unsigned int index) { return povStates[index]; }
+    int povStates[4];
+  };
+  /**
+  * Helper class to realise a vector< {int[4], int[4]} >
+  */
+  class SliderStates
+  {
+  public:
+    IntVector2 sliderStates[4];
+  };
+  /**
+  * 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
+  {
+    int zeroStates[24];
+    float positiveCoeff[24];
+    float negativeCoeff[24];
+  };
+  /**
+    @brief Captures and distributes mouse and keyboard input.
+  */
+  class _CoreExport InputManager
+    /**
+    @brief
+        Helper class to realise a vector<int[4]>
+    */
+    class POVStates
+    {
+    public:
+        int operator[](unsigned int index) { return povStates[index]; }
+        int povStates[4];
+    };
+    /**
+    @brief
+        Helper class to realise a vector< {int[4], int[4]} >
+    */
+    class SliderStates
+    {
+    public:
+        IntVector2 sliderStates[4];
+    };
+    struct JoyStickCalibration
+    {
+        int zeroStates[24];
+        float positiveCoeff[24];
+        float negativeCoeff[24];
+    };
+    /**
+    @brief
+        Captures and distributes mouse and keyboard input.
+    */
+    class _CoreExport InputManager
         : public OrxonoxClass,
+          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();
+  public: // static functions
+    static bool initialise(const size_t windowHnd, int windowWidth, int windowHeight,
+          bool createKeyboard = true, bool createMouse = true, bool createJoySticks = false);
+    static bool initialiseKeyboard();
+    static bool initialiseMouse();
+    static bool initialiseJoySticks();
+    static int  numberOfKeyboards();
+    static int  numberOfMice();
+    static int  numberOfJoySticks();
+    static void destroy();
+    static void destroyKeyboard();
+    static void destroyMouse();
+    static void destroyJoySticks();
+    //static bool isModifierDown(KeyboardModifier::Enum modifier);
+    //static bool isKeyDown(KeyCode::Enum key);
+    //static const MouseState getMouseState();
+    //static const JoyStickState getJoyStickState(unsigned int ID);
+    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);
+    static void calibrate();
+    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);
+  private: // functions
+    // don't mess with a Singleton
+    InputManager ();
+    InputManager (const InputManager&);
+    ~InputManager();
+    // Intenal methods
+    bool _initialise(const size_t, int, int, bool, bool, bool);
+    bool _initialiseKeyboard();
+    bool _initialiseMouse();
+    bool _initialiseJoySticks();
+    void _destroy();
+    void _destroyKeyboard();
+    void _destroyMouse();
+    void _destroyJoySticks();
+    void _updateTickables();
+    void _saveState();
+    void _restoreState();
+    void _completeCalibration();
+    void _fireAxis(unsigned int iJoyStick, int axis, int value);
+    unsigned int _getJoystick(const OIS::JoyStickEvent& arg);
+    void _tick(float dt);
+    // input events
+    bool mousePressed  (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
+    bool mouseReleased (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
+    bool mouseMoved    (const OIS::MouseEvent    &arg);
+    bool keyPressed    (const OIS::KeyEvent      &arg);
+    bool keyReleased   (const OIS::KeyEvent      &arg);
+    bool buttonPressed (const OIS::JoyStickEvent &arg, int button);
+    bool buttonReleased(const OIS::JoyStickEvent &arg, int button);
+    bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
+    bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
+    bool povMoved      (const OIS::JoyStickEvent &arg, int id);
+    //bool vector3Moved  (const OIS::JoyStickEvent &arg, int id);
+    static InputManager& _getSingleton();
+    static InputManager* _getSingletonPtr() { return &_getSingleton(); }
+  private: // variables
+    OIS::InputManager*                          inputSystem_;     //!< OIS input manager
+    OIS::Keyboard*                              keyboard_;        //!< OIS mouse
+    OIS::Mouse*                                 mouse_;           //!< OIS keyboard
+    std::vector<OIS::JoyStick*>                 joySticks_;       //!< OIS joy sticks
+    unsigned int                                joySticksSize_;
+    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_;
+    // joystick calibration
+    //std::vector<int> marginalsMaxConfig_;
+    //std::vector<int> marginalsMinConfig_;
+    int marginalsMax_[24];
+    int marginalsMin_[24];
+    bool bCalibrated_;
+    //! Keeps track of the joy stick POV states
+    std::vector<POVStates>                      povStates_;
+    //! Keeps track of the possibly two slider axes
+    std::vector<SliderStates>                   sliderStates_;
+    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_;
+    std::vector<std::vector<int> >              joyStickButtonsDown_;
+    static std::string                          bindingCommmandString_s;
+  };
+        public OIS::KeyListener, public OIS::MouseListener, public OIS::JoyStickListener
+    {
+        // --> setConfigValues is private
+        friend ClassIdentifier<InputManager>;
+    public: // static functions
+        static bool initialise(const size_t windowHnd, int windowWidth, int windowHeight,
+                               bool createKeyboard = true, bool createMouse = true, bool createJoySticks = false);
+        static bool initialiseKeyboard();
+        static bool initialiseMouse();
+        static bool initialiseJoySticks();
+        static int  numberOfKeyboards();
+        static int  numberOfMice();
+        static int  numberOfJoySticks();
+        static void destroy();
+        static void destroyKeyboard();
+        static void destroyMouse();
+        static void destroyJoySticks();
+        //static bool isModifierDown(KeyboardModifier::Enum modifier);
+        //static bool isKeyDown(KeyCode::Enum key);
+        //static const MouseState getMouseState();
+        //static const JoyStickState getJoyStickState(unsigned int ID);
+        static void setWindowExtents(const int width, const int height);
+        static void storeKeyStroke(const std::string& name);
+        static void keyBind(const std::string& command);
+        static void calibrate();
+        static void tick(float dt);
+        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
+        // don't mess with a Singleton
+        InputManager ();
+        InputManager (const InputManager&);
+        ~InputManager();
+        // Intenal methods
+        bool _initialise(const size_t, int, int, bool, bool, bool);
+        bool _initialiseKeyboard();
+        bool _initialiseMouse();
+        bool _initialiseJoySticks();
+        void _redimensionLists();
+        void _destroy();
+        void _destroyKeyboard();
+        void _destroyMouse();
+        void _destroyJoySticks();
+        void _destroyState(InputState* state);
+        void _completeCalibration();
+        void _fireAxis(unsigned int iJoyStick, int axis, int value);
+        unsigned int _getJoystick(const OIS::JoyStickEvent& arg);
+        void _tick(float dt);
+        void _updateActiveStates();
+        bool _configureInputState(InputState* state, const std::string& name, int priority);
+        // input events
+        bool mousePressed  (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
+        bool mouseReleased (const OIS::MouseEvent    &arg, OIS::MouseButtonID id);
+        bool mouseMoved    (const OIS::MouseEvent    &arg);
+        bool keyPressed    (const OIS::KeyEvent      &arg);
+        bool keyReleased   (const OIS::KeyEvent      &arg);
+        bool buttonPressed (const OIS::JoyStickEvent &arg, int button);
+        bool buttonReleased(const OIS::JoyStickEvent &arg, int button);
+        bool axisMoved     (const OIS::JoyStickEvent &arg, int axis);
+        bool sliderMoved   (const OIS::JoyStickEvent &arg, int id);
+        bool povMoved      (const OIS::JoyStickEvent &arg, int id);
+        void setConfigValues();
+        static InputManager& _getInstance();
+    private: // variables
+        OIS::InputManager*                          inputSystem_;     //!< OIS input manager
+        OIS::Keyboard*                              keyboard_;        //!< OIS mouse
+        OIS::Mouse*                                 mouse_;           //!< OIS keyboard
+        std::vector<OIS::JoyStick*>                 joySticks_;       //!< OIS joy sticks
+        unsigned int                                joySticksSize_;
+        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
+        //std::vector<int> marginalsMaxConfig_;
+        //std::vector<int> marginalsMinConfig_;
+        int marginalsMax_[24];
+        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_;
+        //! Keeps track of the possibly two slider axes
+        std::vector<SliderStates>                   sliderStates_;
+        std::vector<JoyStickCalibration>            joySticksCalibration_;
+        std::vector<Key>                            keysDown_;
+        std::vector<MouseButton::Enum>              mouseButtonsDown_;
+        std::vector<std::vector<int> >              joyStickButtonsDown_;
+        static std::string                          bindingCommmandString_s;
+    };
+}

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

-                      r1567
+                      r1638
 namespace orxonox
+{
+  /**
+    @brief Constructor that does as little as necessary.
+  */
+  KeyBinder::KeyBinder() : deriveTime_(0.0f)
+  {
+    mouseRelative_[0] = 0;
+    mouseRelative_[1] = 0;
+    mousePosition_[0] = 0;
+    mousePosition_[1] = 0;
+    RegisterRootObject(KeyBinder);
+    // keys
+    std::string keyNames[] = {
+      "UNASSIGNED",
+      "ESCAPE",
+      "1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
+      "MINUS", "EQUALS", "BACK", "TAB",
+      "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P",
+      "LBRACKET", "RBRACKET",
+      "RETURN", "LCONTROL",
+      "A", "S", "D", "F", "G", "H", "J", "K", "L",
+      "SEMICOLON", "APOSTROPHE", "GRAVE",
+      "LSHIFT", "BACKSLASH",
+      "Z", "X", "C", "V", "B", "N", "M",
+      "COMMA", "PERIOD", "SLASH",
+      "RSHIFT",
+      "MULTIPLY",
+      "LMENU",
+      "SPACE",
+      "CAPITAL",
+      "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10",
+      "NUMLOCK", "SCROLL",
+      "NUMPAD7", "NUMPAD8", "NUMPAD9",
+      "SUBTRACT",
+      "NUMPAD4", "NUMPAD5", "NUMPAD6",
+      "ADD",
+      "NUMPAD1", "NUMPAD2", "NUMPAD3", "NUMPAD0",
+      "DECIMAL",
+      "","",
+      "OEM_102",
+      "F11", "F12",
+      "","","","","","","","","","","",
+      "F13", "F14", "F15",
+      "","","","","","","","","","",
+      "KANA",
+      "","",
+      "ABNT_C1",
+      "","","","","",
+      "CONVERT",
+      "",
+      "NOCONVERT",
+      "",
+      "YEN",
+      "ABNT_C2",
+      "","","","","","","","","","","","","","",
+      "NUMPADEQUALS",
+      "","",
+      "PREVTRACK",
+      "AT",
+      "COLON", "UNDERLINE",
+      "KANJI",
+      "STOP",
+      "AX",
+      "UNLABELED",
+      "NEXTTRACK",
+      "","",
+      "NUMPADENTER",
+      "RCONTROL",
+      "","",
+      "MUTE",
+      "CALCULATOR",
+      "PLAYPAUSE",
+      "",
+      "MEDIASTOP",
+      "","","","","","","","","",
+      "VOLUMEDOWN",
+      "",
+      "VOLUMEUP",
+      "",
+      "WEBHOME",
+      "NUMPADCOMMA",
+      "",
+      "DIVIDE",
+      "",
+      "SYSRQ",
+      "RMENU",
+      "","","","","","","","","","","","",
+      "PAUSE",
+      "",
+      "HOME",
+      "UP",
+      "PGUP",
+      "",
+      "LEFT",
+      "",
+      "RIGHT",
+      "",
+      "END", "DOWN", "PGDOWN", "INSERT", "DELETE",
+      "","","","","","","",
+      "LWIN", "RWIN", "APPS",
+      "POWER", "SLEEP",
+      "","","",
+      "WAKE",
+      "",
+      "WEBSEARCH", "WEBFAVORITES", "WEBREFRESH", "WEBSTOP", "WEBFORWARD", "WEBBACK",
+      "MYCOMPUTER", "MAIL", "MEDIASELECT"
+    };
+    for (unsigned int i = 0; i < nKeys_s; i++)
+      keys_[i].name_ = "Key" + keyNames[i];
+    // mouse buttons
+    std::string mouseButtonNames[] = {
+      "MouseLeft", "MouseRight", "MouseMiddle",
+      "MouseButton3", "MouseButton4", "MouseButton5",
+      "MouseButton6", "MouseButton7",
+      "MouseWheel1Up", "MouseWheel1Down",
+      "MouseWheel2Up", "MouseWheel2Down" };
+    for (unsigned int i = 0; i < nMouseButtons_s; i++)
+      mouseButtons_[i].name_ = mouseButtonNames[i];
+    // joy stick buttons
+    for (unsigned int i = 0; i < 32; i++)
+      joyStickButtons_[i].name_ = "JoyButton" + getConvertedValue<int, std::string>(i);
+    for (unsigned int i = 32; i < nJoyStickButtons_s; i += 4)
+    {
+                  joyStickButtons_[i + 0].name_ = "JoyPOV" + getConvertedValue<int, std::string>((i - 32)/4 + 1) + "North";
+                  joyStickButtons_[i + 1].name_ = "JoyPOV" + getConvertedValue<int, std::string>((i - 32)/4 + 1) + "South";
+                  joyStickButtons_[i + 2].name_ = "JoyPOV" + getConvertedValue<int, std::string>((i - 32)/4 + 1) + "East";
+                  joyStickButtons_[i + 3].name_ = "JoyPOV" + getConvertedValue<int, std::string>((i - 32)/4 + 1) + "West";
+    }
+    // half axes
+    std::string rawNames[nHalfAxes_s/2];
+    rawNames[0] = "MouseX";
+    rawNames[1] = "MouseY";
+    rawNames[2] = "Empty1";
+    rawNames[3] = "Empty2";
+    for (unsigned int i = 4; i < nHalfAxes_s/2; i++)
+      rawNames[i] = "JoyAxis" + getConvertedValue<int, std::string>(i - 3);
+    for (unsigned int i = 0; i < nHalfAxes_s/2; i++)
+    {
+      halfAxes_[i * 2 + 0].name_ = rawNames[i] + "Pos";
+      halfAxes_[i * 2 + 1].name_ = rawNames[i] + "Neg";
+    }
+    for (unsigned int i = 0; i < this->nHalfAxes_s; i++)
+      halfAxes_[i].buttonThreshold_ = buttonThreshold_;
+  }
+  /**
+    @brief Destructor
+  */
+  KeyBinder::~KeyBinder()
+  {
+    // almost no destructors required because most of the arrays are static.
+    clearBindings(); // does some destruction work
+  }
+  /**
+    @brief Loads the key and button bindings.
+    @return True if loading succeeded.
+  */
+  void KeyBinder::loadBindings()
+  {
+    COUT(3) << "KeyBinder: Loading key bindings..." << std::endl;
+    clearBindings();
+    std::ifstream infile;
+    infile.open("keybindings.ini");
+    if (!infile)
+    {
+      ConfigFileManager::getSingleton()->setFile(CFT_Keybindings, "def_keybindings.ini");
+      ConfigFileManager::getSingleton()->save(CFT_Keybindings, "keybindings.ini");
+    }
+    else
+      infile.close();
+    ConfigFileManager::getSingleton()->setFile(CFT_Keybindings, "keybindings.ini");
+    // parse key bindings
+    setConfigValues();
+    COUT(3) << "KeyBinder: Loading key bindings done." << std::endl;
+  }
+  /**
+    @brief Loader for the key bindings, managed by config values.
+  */
+  void KeyBinder::setConfigValues()
+  {
+    SetConfigValueGeneric(KeyBinder, analogThreshold_, 0.05f)  .description("Threshold for analog axes until which the state is 0.");
+    SetConfigValueGeneric(KeyBinder, mouseSensitivity_, 1.0f)  .description("Mouse sensitivity.");
+    SetConfigValueGeneric(KeyBinder, bDeriveMouseInput_, false).description("Whether or not to derive moues movement for the absolute value.");
+    SetConfigValueGeneric(KeyBinder, derivePeriod_, 0.05f).description("Accuracy of the mouse input deriver. The higher the more precise, but laggier.");
+    SetConfigValueGeneric(KeyBinder, mouseSensitivityDerived_, 1.0f).description("Mouse sensitivity if mouse input is derived.");
+    SetConfigValueGeneric(KeyBinder, bClipMouse_, true).description("Whether or not to clip absolute value of mouse in non derive mode.");
+    float oldThresh = buttonThreshold_;
+    SetConfigValueGeneric(KeyBinder, buttonThreshold_, 0.80f).description("Threshold for analog axes until which the button is not pressed.");
+    if (oldThresh != buttonThreshold_)
+      for (unsigned int i = 0; i < nHalfAxes_s; i++)
+        if (halfAxes_[i].buttonThreshold_ == oldThresh)
+          halfAxes_[i].buttonThreshold_ = buttonThreshold_;
+    // keys
+    for (unsigned int i = 0; i < nKeys_s; i++)
+      readTrigger(keys_[i]);
+    // mouse buttons
+    for (unsigned int i = 0; i < nMouseButtons_s; i++)
+      readTrigger(mouseButtons_[i]);
+    // joy stick buttons
+    for (unsigned int i = 0; i < nJoyStickButtons_s; i++)
+      readTrigger(joyStickButtons_[i]);
+    // half axes
+    for (unsigned int i = 0; i < nHalfAxes_s; i++)
+      readTrigger(halfAxes_[i]);
+  }
+  void KeyBinder::readTrigger(Button& button)
+  {
+    // config value stuff
+    ConfigValueContainer* cont = ClassIdentifier<KeyBinder>::getIdentifier()->getConfigValueContainer(button.name_);
+    if (!cont)
+    {
+      cont = new ConfigValueContainer(CFT_Keybindings, ClassIdentifier<KeyBinder>::getIdentifier(), button.name_, "");
+      ClassIdentifier<KeyBinder>::getIdentifier()->addConfigValueContainer(button.name_, cont);
+    }
+    std::string old = button.bindingString_;
+    cont->getValue(&button.bindingString_);
+    // keybinder stuff
+    if (old != button.bindingString_)
+    {
+      // clear everything so we don't get old axis ParamCommands mixed up
+      button.clear();
+      // binding has changed
+      button.parse(paramCommandBuffer_);
+    }
+  }
+  /**
+    @brief Overwrites all bindings with ""
+  */
+  void KeyBinder::clearBindings()
+  {
+    for (unsigned int i = 0; i < nKeys_s; i++)
+      keys_[i].clear();
+    for (unsigned int i = 0; i < nMouseButtons_s; i++)
+      mouseButtons_[i].clear();
+    for (unsigned int i = 0; i < nJoyStickButtons_s; i++)
+      joyStickButtons_[i].clear();
+    for (unsigned int i = 0; i < nHalfAxes_s; i++)
+      halfAxes_[i].clear();
+    for (unsigned int i = 0; i < paramCommandBuffer_.size(); i++)
+      delete paramCommandBuffer_[i];
+    paramCommandBuffer_.clear();
+  }
+  void KeyBinder::resetJoyStickAxes()
+  {
+    for (unsigned int i = 8; i < nHalfAxes_s; i++)
+    {
+      halfAxes_[i].absVal_ = 0.0f;
+      halfAxes_[i].relVal_ = 0.0f;
+    }
+  }
+  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)
+    {
+      if (deriveTime_ > derivePeriod_)
+      {
+        //CCOUT(3) << "mouse abs: ";
+    /**
+    @brief
+        Constructor that does as little as necessary.
+    */
+    KeyBinder::KeyBinder()
+        : deriveTime_(0.0f)
+    {
+        mouseRelative_[0] = 0;
+        mouseRelative_[1] = 0;
+        mousePosition_[0] = 0;
+        mousePosition_[1] = 0;
+        RegisterRootObject(KeyBinder);
+        // keys
+        std::string keyNames[] = {
+        "UNASSIGNED",
+        "ESCAPE",
+        "1", "2", "3", "4", "5", "6", "7", "8", "9", "0",
+        "MINUS", "EQUALS", "BACK", "TAB",
+        "Q", "W", "E", "R", "T", "Y", "U", "I", "O", "P",
+        "LBRACKET", "RBRACKET",
+        "RETURN", "LCONTROL",
+        "A", "S", "D", "F", "G", "H", "J", "K", "L",
+        "SEMICOLON", "APOSTROPHE", "GRAVE",
+        "LSHIFT", "BACKSLASH",
+        "Z", "X", "C", "V", "B", "N", "M",
+        "COMMA", "PERIOD", "SLASH",
+        "RSHIFT",
+        "MULTIPLY",
+        "LMENU",
+        "SPACE",
+        "CAPITAL",
+        "F1", "F2", "F3", "F4", "F5", "F6", "F7", "F8", "F9", "F10",
+        "NUMLOCK", "SCROLL",
+        "NUMPAD7", "NUMPAD8", "NUMPAD9",
+        "SUBTRACT",
+        "NUMPAD4", "NUMPAD5", "NUMPAD6",
+        "ADD",
+        "NUMPAD1", "NUMPAD2", "NUMPAD3", "NUMPAD0",
+        "DECIMAL",
+        "","",
+        "OEM_102",
+        "F11", "F12",
+        "","","","","","","","","","","",
+        "F13", "F14", "F15",
+        "","","","","","","","","","",
+        "KANA",
+        "","",
+        "ABNT_C1",
+        "","","","","",
+        "CONVERT",
+        "",
+        "NOCONVERT",
+        "",
+        "YEN",
+        "ABNT_C2",
+        "","","","","","","","","","","","","","",
+        "NUMPADEQUALS",
+        "","",
+        "PREVTRACK",
+        "AT",
+        "COLON", "UNDERLINE",
+        "KANJI",
+        "STOP",
+        "AX",
+        "UNLABELED",
+        "NEXTTRACK",
+        "","",
+        "NUMPADENTER",
+        "RCONTROL",
+        "","",
+        "MUTE",
+        "CALCULATOR",
+        "PLAYPAUSE",
+        "",
+        "MEDIASTOP",
+        "","","","","","","","","",
+        "VOLUMEDOWN",
+        "",
+        "VOLUMEUP",
+        "",
+        "WEBHOME",
+        "NUMPADCOMMA",
+        "",
+        "DIVIDE",
+        "",
+        "SYSRQ",
+        "RMENU",
+        "","","","","","","","","","","","",
+        "PAUSE",
+        "",
+        "HOME",
+        "UP",
+        "PGUP",
+        "",
+        "LEFT",
+        "",
+        "RIGHT",
+        "",
+        "END", "DOWN", "PGDOWN", "INSERT", "DELETE",
+        "","","","","","","",
+        "LWIN", "RWIN", "APPS",
+        "POWER", "SLEEP",
+        "","","",
+        "WAKE",
+        "",
+        "WEBSEARCH", "WEBFAVORITES", "WEBREFRESH", "WEBSTOP", "WEBFORWARD", "WEBBACK",
+        "MYCOMPUTER", "MAIL", "MEDIASELECT"
+        };
+        for (unsigned int i = 0; i < nKeys_s; i++)
+            keys_[i].name_ = "Key" + keyNames[i];
+        // mouse buttons
+        std::string mouseButtonNames[] = {
+            "MouseLeft",     "MouseRight",   "MouseMiddle",
+            "MouseButton3",  "MouseButton4", "MouseButton5",
+            "MouseButton6",  "MouseButton7",
+            "MouseWheel1Up", "MouseWheel1Down",
+            "MouseWheel2Up", "MouseWheel2Down"
+        };
+        for (unsigned int i = 0; i < nMouseButtons_s; i++)
+            mouseButtons_[i].name_ = mouseButtonNames[i];
+        // joy stick buttons
+        for (unsigned int i = 0; i < 32; i++)
+            joyStickButtons_[i].name_ = "JoyButton" + getConvertedValue<int, std::string>(i);
+        for (unsigned int i = 32; i < nJoyStickButtons_s; i += 4)
+        {
+            joyStickButtons_[i + 0].name_ = "JoyPOV" + convertToString((i - 32)/4 + 1) + "North";
+            joyStickButtons_[i + 1].name_ = "JoyPOV" + convertToString((i - 32)/4 + 1) + "South";
+            joyStickButtons_[i + 2].name_ = "JoyPOV" + convertToString((i - 32)/4 + 1) + "East";
+            joyStickButtons_[i + 3].name_ = "JoyPOV" + convertToString((i - 32)/4 + 1) + "West";
+        }
+        // half axes
+        std::string rawNames[nHalfAxes_s/2];
+        rawNames[0] = "MouseX";
+        rawNames[1] = "MouseY";
+        rawNames[2] = "Empty1";
+        rawNames[3] = "Empty2";
+        for (unsigned int i = 4; i < nHalfAxes_s/2; i++)
+            rawNames[i] = "JoyAxis" + convertToString(i - 3);
+        for (unsigned int i = 0; i < nHalfAxes_s/2; i++)
+        {
+            halfAxes_[i * 2 + 0].name_ = rawNames[i] + "Pos";
+            halfAxes_[i * 2 + 1].name_ = rawNames[i] + "Neg";
+        }
+        for (unsigned int i = 0; i < this->nHalfAxes_s; i++)
+            halfAxes_[i].buttonThreshold_ = buttonThreshold_;
+    }
+    /**
+    @brief
+        Destructor
+    */
+    KeyBinder::~KeyBinder()
+    {
+        // almost no destructors required because most of the arrays are static.
+        clearBindings(); // does some destruction work
+    }
+    /**
+    @brief
+        Loads the key and button bindings.
+    @return
+        True if loading succeeded.
+    */
+    void KeyBinder::loadBindings()
+    {
+        COUT(3) << "KeyBinder: Loading key bindings..." << std::endl;
+        clearBindings();
+        std::ifstream infile;
+        infile.open("keybindings.ini");
+        if (!infile)
+        {
+            ConfigFileManager::getSingleton()->setFile(CFT_Keybindings, "def_keybindings.ini");
+            ConfigFileManager::getSingleton()->save(CFT_Keybindings, "keybindings.ini");
+        }
+        else
+            infile.close();
+        ConfigFileManager::getSingleton()->setFile(CFT_Keybindings, "keybindings.ini");
+        // parse key bindings
+        setConfigValues();
+        COUT(3) << "KeyBinder: Loading key bindings done." << std::endl;
+    }
+    /**
+    @brief
+        Loader for the key bindings, managed by config values.
+    */
+    void KeyBinder::setConfigValues()
+    {
+        SetConfigValueGeneric(KeyBinder, analogThreshold_, 0.05f)
+            .description("Threshold for analog axes until which the state is 0.");
+        SetConfigValueGeneric(KeyBinder, mouseSensitivity_, 1.0f)
+            .description("Mouse sensitivity.");
+        SetConfigValueGeneric(KeyBinder, bDeriveMouseInput_, false)
+            .description("Whether or not to derive moues movement for the absolute value.");
+        SetConfigValueGeneric(KeyBinder, derivePeriod_, 0.05f)
+            .description("Accuracy of the mouse input deriver. The higher the more precise, but laggier.");
+        SetConfigValueGeneric(KeyBinder, mouseSensitivityDerived_, 1.0f)
+            .description("Mouse sensitivity if mouse input is derived.");
+        SetConfigValueGeneric(KeyBinder, bClipMouse_, true)
+            .description("Whether or not to clip absolute value of mouse in non derive mode.");
+        float oldThresh = buttonThreshold_;
+        SetConfigValueGeneric(KeyBinder, buttonThreshold_, 0.80f)
+            .description("Threshold for analog axes until which the button is not pressed.");
+        if (oldThresh != buttonThreshold_)
+            for (unsigned int i = 0; i < nHalfAxes_s; i++)
+                if (halfAxes_[i].buttonThreshold_ == oldThresh)
+                    halfAxes_[i].buttonThreshold_ = buttonThreshold_;
+        // keys
+        for (unsigned int i = 0; i < nKeys_s; i++)
+            readTrigger(keys_[i]);
+        // mouse buttons
+        for (unsigned int i = 0; i < nMouseButtons_s; i++)
+            readTrigger(mouseButtons_[i]);
+        // joy stick buttons
+        for (unsigned int i = 0; i < nJoyStickButtons_s; i++)
+            readTrigger(joyStickButtons_[i]);
+        // half axes
+        for (unsigned int i = 0; i < nHalfAxes_s; i++)
+            readTrigger(halfAxes_[i]);
+    }
+    void KeyBinder::readTrigger(Button& button)
+    {
+        // config value stuff
+        ConfigValueContainer* cont
+            = ClassIdentifier<KeyBinder>::getIdentifier()->getConfigValueContainer(button.name_);
+        if (!cont)
+        {
+            cont = new ConfigValueContainer
+                (CFT_Keybindings, ClassIdentifier<KeyBinder>::getIdentifier(), button.name_, "");
+            ClassIdentifier<KeyBinder>::getIdentifier()->addConfigValueContainer(button.name_, cont);
+        }
+        std::string old = button.bindingString_;
+        cont->getValue(&button.bindingString_);
+        // keybinder stuff
+        if (old != button.bindingString_)
+        {
+            // clear everything so we don't get old axis ParamCommands mixed up
+            button.clear();
+            // binding has changed
+            button.parse(paramCommandBuffer_);
+        }
+    }
+    /**
+    @brief
+        Overwrites all bindings with ""
+    */
+    void KeyBinder::clearBindings()
+    {
+        for (unsigned int i = 0; i < nKeys_s; i++)
+            keys_[i].clear();
+        for (unsigned int i = 0; i < nMouseButtons_s; i++)
+            mouseButtons_[i].clear();
+        for (unsigned int i = 0; i < nJoyStickButtons_s; i++)
+            joyStickButtons_[i].clear();
+        for (unsigned int i = 0; i < nHalfAxes_s; i++)
+            halfAxes_[i].clear();
+        for (unsigned int i = 0; i < paramCommandBuffer_.size(); i++)
+            delete paramCommandBuffer_[i];
+        paramCommandBuffer_.clear();
+    }
+    void KeyBinder::resetJoyStickAxes()
+    {
+        for (unsigned int i = 8; i < nHalfAxes_s; i++)
+        {
+            halfAxes_[i].absVal_ = 0.0f;
+            halfAxes_[i].relVal_ = 0.0f;
+        }
+    }
+    void KeyBinder::tickMouse(float dt)
+    {
+        tickDevices(0, 8);
+        if (bDeriveMouseInput_)
+        {
+            if (deriveTime_ > derivePeriod_)
+            {
+                //CCOUT(3) << "mouse abs: ";
+                for (int i = 0; i < 2; i++)
+                {
+                    if (mouseRelative_[i] > 0)
+                    {
+                        halfAxes_[2*i + 0].absVal_
+                            =  mouseRelative_[i] / deriveTime_ * 0.0005 * mouseSensitivityDerived_;
+                        halfAxes_[2*i + 1].absVal_ = 0.0f;
+                    }
+                    else if (mouseRelative_[i] < 0)
+                    {
+                        halfAxes_[2*i + 0].absVal_ = 0.0f;
+                        halfAxes_[2*i + 1].absVal_
+                            = -mouseRelative_[i] / deriveTime_ * 0.0005 * mouseSensitivityDerived_;
+                    }
+                    else
+                    {
+                        halfAxes_[2*i + 0].absVal_ = 0.0f;
+                        halfAxes_[2*i + 1].absVal_ = 0.0f;
+                    }
+                    //COUT(3) << mouseRelative_[i] << " | ";
+                    mouseRelative_[i] = 0;
+                    halfAxes_[2*i + 0].hasChanged_ = true;
+                    halfAxes_[2*i + 1].hasChanged_ = true;
+                }
+                deriveTime_ = 0.0f;
+                //COUT(3) << std::endl;
+            }
+            else
+                deriveTime_ += dt;
+        }
+    }
+    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
+        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();
+            }
+        }
+    }
+    void KeyBinder::keyPressed (const KeyEvent& evt)
+    { keys_[evt.key].execute(KeybindMode::OnPress); }
+    void KeyBinder::keyReleased(const KeyEvent& evt)
+    { keys_[evt.key].execute(KeybindMode::OnRelease); }
+    void KeyBinder::keyHeld    (const KeyEvent& evt)
+    { keys_[evt.key].execute(KeybindMode::OnHold); }
+    void KeyBinder::mouseButtonPressed (MouseButton::Enum id)
+    { mouseButtons_[id].execute(KeybindMode::OnPress); }
+    void KeyBinder::mouseButtonReleased(MouseButton::Enum id)
+    { mouseButtons_[id].execute(KeybindMode::OnRelease); }
+    void KeyBinder::mouseButtonHeld    (MouseButton::Enum id)
+    { mouseButtons_[id].execute(KeybindMode::OnHold); }
+    void KeyBinder::joyStickButtonPressed (unsigned int joyStickID, unsigned int button)
+    { joyStickButtons_[button].execute(KeybindMode::OnPress); }
+    void KeyBinder::joyStickButtonReleased(unsigned int joyStickID, unsigned int button)
+    { joyStickButtons_[button].execute(KeybindMode::OnRelease); }
+    void KeyBinder::joyStickButtonHeld    (unsigned int joyStickID, unsigned int button)
+    { joyStickButtons_[button].execute(KeybindMode::OnHold); }
+    /**
+    @brief
+        Event handler for the mouseMoved Event.
+    @param e
+        Mouse state information
+    */
+    void KeyBinder::mouseMoved(IntVector2 abs_, IntVector2 rel_, IntVector2 clippingSize)
+    {
+        // y axis of mouse input is inverted
+        int rel[] = { rel_.x, -rel_.y };
+        if (!bDeriveMouseInput_)
+        {
+            for (int i = 0; i < 2; i++)
+            {
+                if (rel[i])
+                {
+                    // absolute
+                    halfAxes_[2*i + 0].hasChanged_ = true;
+                    halfAxes_[2*i + 1].hasChanged_ = true;
+                    mousePosition_[i] += rel[i];
+                    if (bClipMouse_)
+                    {
+                        if (mousePosition_[i] > 1024)
+                            mousePosition_[i] =  1024;
+                        if (mousePosition_[i] < -1024)
+                            mousePosition_[i] = -1024;
+                    }
+                    if (mousePosition_[i] >= 0)
+                    {
+                        halfAxes_[2*i + 0].absVal_ =   mousePosition_[i]/1024.0f * mouseSensitivity_;
+                        halfAxes_[2*i + 1].absVal_ =  0.0f;
+                    }
+                    else
+                    {
+                        halfAxes_[2*i + 0].absVal_ =  0.0f;
+                        halfAxes_[2*i + 1].absVal_ =  -mousePosition_[i]/1024.0f * mouseSensitivity_;
+                    }
+                }
+            }
+        }
+        else
+        {
+            mouseRelative_[0] += rel[0];
+            mouseRelative_[1] += rel[1];
+        }
+        // relative
         for (int i = 0; i < 2; i++)
+        {
+          if (mouseRelative_[i] > 0)
+          {
+            halfAxes_[2*i + 0].absVal_ =  mouseRelative_[i] / deriveTime_ * 0.0005 * mouseSensitivityDerived_;
+            halfAxes_[2*i + 1].absVal_ = 0.0f;
+          }
+          else if (mouseRelative_[i] < 0)
+          {
+            halfAxes_[2*i + 0].absVal_ = 0.0f;
+            halfAxes_[2*i + 1].absVal_ = -mouseRelative_[i] / deriveTime_ * 0.0005 * mouseSensitivityDerived_;
+          }
+          else
+          {
+            halfAxes_[2*i + 0].absVal_ = 0.0f;
+            halfAxes_[2*i + 1].absVal_ = 0.0f;
+          }
+          //COUT(3) << mouseRelative_[i] << " | ";
+          mouseRelative_[i] = 0;
+          halfAxes_[2*i + 0].hasChanged_ = true;
+          halfAxes_[2*i + 1].hasChanged_ = true;
+        }
+        deriveTime_ = 0.0f;
+        //COUT(3) << std::endl;
+      }
+      else
+        deriveTime_ += dt;
+    }
+    // execute all buffered bindings (addional 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;
+  }
+  void KeyBinder::keyPressed (const KeyEvent& evt)
+  { keys_[evt.key].execute(KeybindMode::OnPress); }
+  void KeyBinder::keyReleased(const KeyEvent& evt)
+  { keys_[evt.key].execute(KeybindMode::OnRelease); }
+  void KeyBinder::keyHeld    (const KeyEvent& evt)
+  { keys_[evt.key].execute(KeybindMode::OnHold); }
+  void KeyBinder::mouseButtonPressed (MouseButton::Enum id)
+  { mouseButtons_[id].execute(KeybindMode::OnPress); }
+  void KeyBinder::mouseButtonReleased(MouseButton::Enum id)
+  { mouseButtons_[id].execute(KeybindMode::OnRelease); }
+  void KeyBinder::mouseButtonHeld    (MouseButton::Enum id)
+  { mouseButtons_[id].execute(KeybindMode::OnHold); }
+  void KeyBinder::joyStickButtonPressed (int joyStickID, int button)
+  { joyStickButtons_[button].execute(KeybindMode::OnPress); }
+  void KeyBinder::joyStickButtonReleased(int joyStickID, int button)
+  { joyStickButtons_[button].execute(KeybindMode::OnRelease); }
+  void KeyBinder::joyStickButtonHeld    (int joyStickID, int button)
+  { joyStickButtons_[button].execute(KeybindMode::OnHold); }
+  /**
+    @brief Event handler for the mouseMoved Event.
+    @param e Mouse state information
+  */
+  void KeyBinder::mouseMoved(IntVector2 abs_, IntVector2 rel_, IntVector2 clippingSize)
+  {
+    // y axis of mouse input is inverted
+    int rel[] = { rel_.x, -rel_.y };
+    if (!bDeriveMouseInput_)
+    {
+      for (int i = 0; i < 2; i++)
+      {
+        if (rel[i])
+        {
+          // absolute
+          halfAxes_[2*i + 0].hasChanged_ = true;
+          halfAxes_[2*i + 1].hasChanged_ = true;
+          mousePosition_[i] += rel[i];
+          if (bClipMouse_)
+          {
+            if (mousePosition_[i] > 1024)
+              mousePosition_[i] =  1024;
+            if (mousePosition_[i] < -1024)
+              mousePosition_[i] = -1024;
+          }
+          if (mousePosition_[i] >= 0)
+          {
+            halfAxes_[2*i + 0].absVal_ =   mousePosition_[i]/1024.0f * mouseSensitivity_;
+            halfAxes_[2*i + 1].absVal_ =  0.0f;
+          }
+          else
+          {
+            halfAxes_[2*i + 0].absVal_ =  0.0f;
+            halfAxes_[2*i + 1].absVal_ =  -mousePosition_[i]/1024.0f * mouseSensitivity_;
+          }
+        }
+      }
+    }
+    else
+    {
+      mouseRelative_[0] += rel[0];
+      mouseRelative_[1] += rel[1];
+    }
+    // relative
+    for (int i = 0; i < 2; i++)
+    {
+      if (rel[i] > 0)
+        halfAxes_[0 + 2*i].relVal_ =  ((float)rel[i])/1024 * mouseSensitivity_;
+      else
+        halfAxes_[1 + 2*i].relVal_ = -((float)rel[i])/1024 * mouseSensitivity_;
+    }
+  }
+  /**
+            if (rel[i] > 0)
+                halfAxes_[0 + 2*i].relVal_ =  ((float)rel[i])/1024 * mouseSensitivity_;
+            else
+                halfAxes_[1 + 2*i].relVal_ = -((float)rel[i])/1024 * mouseSensitivity_;
+        }
+    }
+    /**
     @brief Event handler for the mouseScrolled Event.
     @param e Mouse state information
+  */
+  void KeyBinder::mouseScrolled(int abs, int rel)
+  {
+    //COUT(3) << mouseButtons_[8].name_ << "   " << abs << " | " << rel << std::endl;
+    if (rel > 0)
+      for (int i = 0; i < rel/120; i++)
+        mouseButtons_[8].execute(KeybindMode::OnPress, ((float)abs)/120.0f);
+    else
+      for (int i = 0; i < -rel/120; i++)
+        mouseButtons_[9].execute(KeybindMode::OnPress, ((float)abs)/120.0f);
+  }
+  void KeyBinder::joyStickAxisMoved(int joyStickID, int axis, float value)
+  {
+    // TODO: Use proper calibration values instead of generally 16-bit integer
+    int i = 8 + axis * 2;
+    if (value >= 0)
+    {
+      //if (value > 10000)
+      //{ CCOUT(3) << halfAxes_[i].name_ << std::endl; }
+      halfAxes_[i].absVal_ = value;
+      halfAxes_[i].relVal_ = value;
+      halfAxes_[i].hasChanged_ = true;
+      if (halfAxes_[i + 1].absVal_ > 0.0f)
+      {
+        halfAxes_[i + 1].absVal_ = -0.0f;
+        halfAxes_[i + 1].relVal_ = -0.0f;
+        halfAxes_[i + 1].hasChanged_ = true;
+      }
+    }
+    else
+    {
+      //if (value < -10000)
+      //{ CCOUT(3) << halfAxes_[i + 1].name_ << std::endl; }
+      halfAxes_[i + 1].absVal_ = -value;
+      halfAxes_[i + 1].relVal_ = -value;
+      halfAxes_[i + 1].hasChanged_ = true;
+      if (halfAxes_[i].absVal_ > 0.0f)
+      {
+        halfAxes_[i].absVal_ = -0.0f;
+        halfAxes_[i].relVal_ = -0.0f;
+        halfAxes_[i].hasChanged_ = true;
+      }
+    }
+  }
+    */
+    void KeyBinder::mouseScrolled(int abs, int rel)
+    {
+        //COUT(3) << mouseButtons_[8].name_ << "   " << abs << " | " << rel << std::endl;
+        if (rel > 0)
+            for (int i = 0; i < rel/120; i++)
+                mouseButtons_[8].execute(KeybindMode::OnPress, ((float)abs)/120.0f);
+        else
+            for (int i = 0; i < -rel/120; i++)
+                mouseButtons_[9].execute(KeybindMode::OnPress, ((float)abs)/120.0f);
+    }
+    void KeyBinder::joyStickAxisMoved(unsigned int joyStickID, unsigned int axis, float value)
+    {
+        int i = 8 + axis * 2;
+        if (value >= 0)
+        {
+            //if (value > 10000)
+            //{ CCOUT(3) << halfAxes_[i].name_ << std::endl; }
+            halfAxes_[i].absVal_ = value;
+            halfAxes_[i].relVal_ = value;
+            halfAxes_[i].hasChanged_ = true;
+            if (halfAxes_[i + 1].absVal_ > 0.0f)
+            {
+                halfAxes_[i + 1].absVal_ = -0.0f;
+                halfAxes_[i + 1].relVal_ = -0.0f;
+                halfAxes_[i + 1].hasChanged_ = true;
+            }
+        }
+        else
+        {
+            //if (value < -10000)
+            //{ CCOUT(3) << halfAxes_[i + 1].name_ << std::endl; }
+            halfAxes_[i + 1].absVal_ = -value;
+            halfAxes_[i + 1].relVal_ = -value;
+            halfAxes_[i + 1].hasChanged_ = true;
+            if (halfAxes_[i].absVal_ > 0.0f)
+            {
+                halfAxes_[i].absVal_ = -0.0f;
+                halfAxes_[i].relVal_ = -0.0f;
+                halfAxes_[i].hasChanged_ = true;
+            }
+        }
+    }
+}

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

-                      r1535
+                      r1638
 /**
+ @file
+ @brief Different definitions of input processing.
+ */
+@file
+@brief
+    Different definitions of input processing.
+*/
 #ifndef _KeyBinder_H__
 …
 namespace orxonox
+{
+  /**
+    @brief Handles mouse, keyboard and joy stick input while in the actual game mode.
+           Manages the key bindings.
+  */
+  class _CoreExport KeyBinder : public KeyHandler, public MouseHandler, public JoyStickHandler, public OrxonoxClass
+  {
+  public:
+    KeyBinder ();
+    virtual ~KeyBinder();
+    /**
+    @brief
+        Handles mouse, keyboard and joy stick input while in the actual game mode.
+        Manages the key bindings.
+    */
+    class _CoreExport KeyBinder : public KeyHandler, public MouseHandler, public JoyStickHandler, public OrxonoxClass
+    {
+    public:
+        KeyBinder ();
+        virtual ~KeyBinder();
     void loadBindings();
     void clearBindings();
     void setConfigValues();
     void resetJoyStickAxes();
+        void loadBindings();
+        void clearBindings();
+        void setConfigValues();
+        void resetJoyStickAxes();
+  protected: // functions
+    void tickInput(float dt, const HandlerState& state);
+    protected: // functions
+        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);
+        virtual void readTrigger(Button& button);
     void keyPressed (const KeyEvent& evt);
     void keyReleased(const KeyEvent& evt);
     void keyHeld    (const KeyEvent& evt);
+        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 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 (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
     //! denotes the number of different keys there are in OIS.
     static const unsigned int nKeys_s = 0xEE;
     //! Actual key bindings as bundle for Press, Hold and Release
     Button keys_ [nKeys_s];
+    protected: // variables
+        //! denotes the number of different keys there are in OIS.
+        static const unsigned int nKeys_s = 0xEE;
+        //! Actual key bindings as bundle for Press, Hold and Release
+        Button keys_ [nKeys_s];
     //! denotes the number of different mouse buttons there are in OIS.
     static const unsigned int nMouseButtons_s = 8 + 2*2; // 8 buttons and 2 scroll wheels
     //! Actual key bindings as bundle for Press, Hold and Release
     Button mouseButtons_ [nMouseButtons_s];
+        //! denotes the number of different mouse buttons there are in OIS.
+        static const unsigned int nMouseButtons_s = 8 + 2*2; // 8 buttons and 2 scroll wheels
+        //! Actual key bindings as bundle for Press, Hold and Release
+        Button mouseButtons_ [nMouseButtons_s];
     //! denotes the number of different joy stick buttons there are in OIS.
     static const unsigned int nJoyStickButtons_s = 32 + 4 * 4; // 32 buttons and 4 POVs with 4 buttons
     //! Actual key bindings as bundle for Press, Hold and Release
     Button joyStickButtons_ [nJoyStickButtons_s];
+        //! denotes the number of different joy stick buttons there are in OIS.
+        static const unsigned int nJoyStickButtons_s = 32 + 4 * 4; // 32 buttons and 4 POVs with 4 buttons
+        //! Actual key bindings as bundle for Press, Hold and Release
+        Button joyStickButtons_ [nJoyStickButtons_s];
     //! denotes the number of half axes (every axis twice) there can be.
     static const unsigned int nHalfAxes_s = 56;
     /**
     * Array with all the half axes for mouse and joy sticks.
     * Keep in mind that the positions are fixed and that the first entry is the
     * positive one and the second is negative.
     * Sequence is as follows:
     *  0 -  3: Mouse x and y
     *  4 -  7: empty
     *  8 - 23: joy stick slider axes 1 to 8
     * 24 - 55: joy stick axes 1 - 16
     */
     HalfAxis halfAxes_[nHalfAxes_s];
+        //! denotes the number of half axes (every axis twice) there can be.
+        static const unsigned int nHalfAxes_s = 56;
+        /**
+        * Array with all the half axes for mouse and joy sticks.
+        * Keep in mind that the positions are fixed and that the first entry is the
+        * positive one and the second is negative.
+        * Sequence is as follows:
+        *  0 -  3: Mouse x and y
+        *  4 -  7: empty
+        *  8 - 23: joy stick slider axes 1 to 8
+        * 24 - 55: joy stick axes 1 - 16
+        */
+        HalfAxis halfAxes_[nHalfAxes_s];
+    /**
+    * Commands that have additional parameters (axes) are executed at the end of
+    * the tick() so that all values can be buffered for single execution.
+    */
+    std::vector<BufferedParamCommand*> paramCommandBuffer_;
+        /**
+        @brief
+            Commands that have additional parameters (axes) are executed at the end of
+            the tick() so that all values can be buffered for single execution.
+        */
+        std::vector<BufferedParamCommand*> paramCommandBuffer_;
     //! Keeps track of the absolute mouse value (incl. scroll wheel)
     int mousePosition_[2];
     //! Used to derive mouse input if requested
     int mouseRelative_[2];
     float deriveTime_;
+        //! Keeps track of the absolute mouse value (incl. scroll wheel)
+        int mousePosition_[2];
+        //! Used to derive mouse input if requested
+        int mouseRelative_[2];
+        float deriveTime_;
+    //##### ConfigValues #####
+    //! Threshold for analog triggers until which the state is 0.
+    float analogThreshold_;
+    //! Threshold for analog triggers until which the button is not pressed.
+    float buttonThreshold_;
+    //! Derive mouse input for absolute values?
+    bool bDeriveMouseInput_;
+    //! Accuracy of the mouse input deriver. The higher the more precise, but laggier.
+    float derivePeriod_;
+    //! mouse sensitivity
+    float mouseSensitivity_;
+    //! mouse sensitivity if mouse input is derived
+    float mouseSensitivityDerived_;
+    //! Whether or not to clip abslute mouse values to 1024
+    bool bClipMouse_;
+  };
+        //##### ConfigValues #####
+        //! Threshold for analog triggers until which the state is 0.
+        float analogThreshold_;
+        //! Threshold for analog triggers until which the button is not pressed.
+        float buttonThreshold_;
+        //! Derive mouse input for absolute values?
+        bool bDeriveMouseInput_;
+        //! Accuracy of the mouse input deriver. The higher the more precise, but laggier.
+        float derivePeriod_;
+        //! mouse sensitivity
+        float mouseSensitivity_;
+        //! mouse sensitivity if mouse input is derived
+        float mouseSensitivityDerived_;
+        //! Whether or not to clip abslute mouse values to 1024
+        bool bClipMouse_;
+    };
+}

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

-                      r1535
+                      r1638
 /**
+ @file
+ @brief Implementation of the different input handlers.
+ */
+@file
+@brief
+    Implementation of the different input handlers.
+*/
 #include "KeyDetector.h"
 …
 namespace orxonox
+{
+  /**
+    @brief Constructor
+  */
+  KeyDetector::KeyDetector()
+  {
+    RegisterObject(KeyDetector);
+  }
+    /**
+    @brief
+        Constructor
+    */
+    KeyDetector::KeyDetector()
+    {
+        RegisterObject(KeyDetector);
+    }
+  /**
+    @brief Destructor
+  */
+  KeyDetector::~KeyDetector()
+  {
+  }
+    /**
+    @brief
+        Destructor
+    */
+    KeyDetector::~KeyDetector()
+    {
+    }
+  /**
+    @brief Loads the key and button bindings.
+    @return True if loading succeeded.
+  */
+  void KeyDetector::loadBindings()
+  {
+    clearBindings();
+    setConfigValues();
+  }
+    /**
+    @brief
+        Loads the key and button bindings.
+    @return
+        True if loading succeeded.
+    */
+    void KeyDetector::loadBindings(const std::string& command)
+    {
+        clearBindings();
+        setConfigValues();
+        this->command_ = command;
+    }
   void KeyDetector::readTrigger(Button& button)
+  {
     SimpleCommand* cmd = new SimpleCommand();
     cmd->evaluation_ = CommandExecutor::evaluate("storeKeyStroke " + button.name_);
     button.commands_[KeybindMode::OnPress] = new BaseCommand*[1];
     button.commands_[KeybindMode::OnPress][0] = cmd;
     button.nCommands_[KeybindMode::OnPress] = 1;
+  }
+    void KeyDetector::readTrigger(Button& button)
+    {
+        SimpleCommand* cmd = new SimpleCommand();
+        cmd->evaluation_ = CommandExecutor::evaluate(this->command_ + " " + button.name_);
+        button.commands_[KeybindMode::OnPress] = new BaseCommand*[1];
+        button.commands_[KeybindMode::OnPress][0] = cmd;
+        button.nCommands_[KeybindMode::OnPress] = 1;
+    }
+}

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

-                      r1535
+                      r1638
 /**
+ @file
+ @brief Different definitions of input processing.
+ */
+@file
+@brief
+    Different definitions of input processing.
+*/
 #ifndef _KeyDetector_H__
 …
 namespace orxonox
+{
   class _CoreExport KeyDetector : public KeyBinder
+  {
   public:
     KeyDetector();
     ~KeyDetector();
     void loadBindings();
+    class _CoreExport KeyDetector : public KeyBinder
+    {
+    public:
+        KeyDetector();
+        ~KeyDetector();
+        void loadBindings(const std::string& command);
+  protected:
+    void readTrigger(Button& button);
+  };
+    protected:
+        void readTrigger(Button& button);
+    private:
+        std::string command_;
+    };
+}

code/branches/gui/src/core/tolua/tolua.pkg

r1505	r1638
1	1	$cfile "../../src/core/Script_clean.h"
	2	$cfile "../../src/core/CommandExecutor.h"

code/branches/gui/src/network/Client.cc

-                      r1534
+                      r1638
   void Client::processClassid(classid *clid){
     orxonox::Identifier *id;
     id=ID(std::string(clid->message));
+    id=GetIdentifier(std::string(clid->message));
     if(id!=NULL)
       id->setNetworkID(clid->clid);
     COUT(4) << "Client: received and set network id: " << clid->clid << "; classname: " << clid->message << std::endl;
     COUT(4) << "id(classid)->getName " << ID((unsigned int)clid->clid)->getName() << std::endl;
+    COUT(4) << "id(classid)->getName " << GetIdentifier((unsigned int)clid->clid)->getName() << std::endl;
     delete clid;
     return;

code/branches/gui/src/network/ClientConnection.cc

r1534	r1638
42	42	#include <iostream>
43	43	// boost.thread library for multithreading support
	44	#include <boost/thread/thread.hpp>
44	45	#include <boost/bind.hpp>
45	46

code/branches/gui/src/network/ClientConnection.h

-                      r1534
+                      r1638
 #include <string>
 #include <enet/enet.h>
+#include <boost/thread/thread.hpp>
+#include <boost/thread/recursive_mutex.hpp>
+#include "PacketBuffer.h"
+#include "PacketBuffer.h"
+namespace boost { class thread; }
 namespace network

code/branches/gui/src/network/ConnectionManager.cc

r1534	r1638
40	40	#include <iostream>
41	41	// boost.thread library for multithreading support
	42	#include <boost/thread/thread.hpp>
42	43	#include <boost/bind.hpp>
43	44

code/branches/gui/src/network/ConnectionManager.h

-                      r1505
+                      r1638
 // enet library for networking support
 #include <enet/enet.h>
-#include <boost/thread/thread.hpp>
 #include <boost/thread/recursive_mutex.hpp>
 #include "PacketBuffer.h"
 #include "PacketManager.h"
+namespace boost { class thread; }
 namespace std

code/branches/gui/src/network/GameStateClient.cc

r1625	r1638
177	177	///sigsegv may happen here again for some reason
178	178	///sigsegv is receved after the COUT(4) above
179		orxonox::Identifier* id = ID((unsigned int)sync.classID);
	179	orxonox::Identifier* id = GetIdentifier((unsigned int)sync.classID);
180	180	if(!id){
181	181	COUT(3) << "We could not identify a new object; classid: " << sync.classID << " uint: " << (unsigned int)sync.classID << " objectID: " << sync.objectID << " size: " << sync.length << std::endl;

code/branches/gui/src/network/GameStateManager.cc

-                      r1534
+                      r1638
 #include <iostream>
 #include <zlib.h>
 #include <assert.h>
+#include <cassert>
 #include "core/CoreIncludes.h"
 …
         COUT(4) << "loadsnapshot: creating new object " << std::endl;
         //COUT(4) << "loadSnapshot:\tclassid: " << sync.classID << ", name: " << ID((unsigned int) sync.classID)->getName() << std::endl;
         orxonox::Identifier* id = ID((unsigned int)sync.classID);
+        orxonox::Identifier* id = GetIdentifier((unsigned int)sync.classID);
         if(!id){
           COUT(4) << "We could not identify a new object; classid: " << sync.classID << std::endl;

code/branches/gui/src/network/Server.cc

-                      r1556
+                      r1638
 #include <iostream>
+#include <cassert>
 …
     if(!client)
       return false;
     orxonox::Identifier* id = ID("SpaceShip");
+    orxonox::Identifier* id = GetIdentifier("SpaceShip");
     if(!id){
       COUT(4) << "We could not create the SpaceShip for client: " << client->getID() << std::endl;

code/branches/gui/src/orxonox/GraphicsEngine.cc

-                      r1625
+                      r1638
  */
+ /**
+    @file orxonox.cc
+    @brief Orxonox class
+  */
+/**
+@file
+@brief
+    Implementation of an partial interface to Ogre.
+*/
 #include "OrxonoxStableHeaders.h"
 …
 #include "core/CommandExecutor.h"
 #include "core/ConsoleCommand.h"
+#include "core/Exception.h"
 #include "overlays/console/InGameConsole.h"
 …
 #include "tools/WindowEventListener.h"
+#include "objects/CameraHandler.h"
 namespace orxonox
+{
+  /**
+    @brief Returns the singleton instance and creates it the first time.
+    @return The only instance of GraphicsEngine.
+  */
+  /*static*/ GraphicsEngine& GraphicsEngine::getSingleton()
+  {
+    static GraphicsEngine theOnlyInstance;
+    return theOnlyInstance;
+  }
+  /**
+    @brief Only use constructor to initialise variables and pointers!
+  */
+  GraphicsEngine::GraphicsEngine() :
+    root_(0),
+    scene_(0),
+    renderWindow_(0)
+  {
+    RegisterObject(GraphicsEngine);
+    this->detailLevelParticle_ = 0;
+    this->setConfigValues();
+    CCOUT(4) << "Constructed" << std::endl;
+  }
+  void GraphicsEngine::setConfigValues()
+  {
+    SetConfigValue(resourceFile_,    "resources.cfg").description("Location of the resources file in the data path.");
+    SetConfigValue(ogreConfigFile_,  "ogre.cfg").description("Location of the Ogre config file");
+    SetConfigValue(ogrePluginsFile_, "plugins.cfg").description("Location of the Ogre plugins file");
+    SetConfigValue(ogreLogFile_,     "ogre.log").description("Logfile for messages from Ogre. \
+                                                             Use \"\" to suppress log file creation.");
+    SetConfigValue(ogreLogLevelTrivial_ , 5).description("Corresponding orxonox debug level for ogre Trivial");
+    SetConfigValue(ogreLogLevelNormal_  , 4).description("Corresponding orxonox debug level for ogre Normal");
+    SetConfigValue(ogreLogLevelCritical_, 2).description("Corresponding orxonox debug level for ogre Critical");
+    unsigned int old = this->detailLevelParticle_;
+    SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high");
+    if (this->detailLevelParticle_ != old)
+      for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
+        it->detailLevelChanged(this->detailLevelParticle_);
+  }
+  /**
+    @brief Called after main() --> call destroyObjects()!
+  */
+  GraphicsEngine::~GraphicsEngine()
+  {
+    this->destroy();
+  }
+  /**
+    @brief Destroys all the internal objects. Call this method when you
+           normally would call the destructor.
+  */
+  void GraphicsEngine::destroy()
+  {
+    CCOUT(4) << "Destroying objects..." << std::endl;
+    Ogre::WindowEventUtilities::removeWindowEventListener(this->renderWindow_, this);
+    if (this->root_)
+      delete this->root_;
+    this->root_ = 0;
+    this->scene_ = 0;
+    this->renderWindow_ = 0;
+    // delete the ogre log and the logManager (since we have created it).
+    if (Ogre::LogManager::getSingletonPtr() != 0)
+    {
+      Ogre::LogManager::getSingleton().getDefaultLog()->removeListener(this);
+      Ogre::LogManager::getSingleton().destroyLog(Ogre::LogManager::getSingleton().getDefaultLog());
+      delete Ogre::LogManager::getSingletonPtr();
+    }
+    CCOUT(4) << "Destroying objects done" << std::endl;
+  }
+  /**
+    @brief Creates the Ogre Root object and sets up the ogre log.
+  */
+  bool GraphicsEngine::setup()
+  {
+    CCOUT(3) << "Setting up..." << std::endl;
+    // temporary overwrite of dataPath, change ini file for permanent change
+// TODO: LogManager doesn't work on specific systems. The why is unknown yet.
+    GraphicsEngine* GraphicsEngine::singletonRef_s = 0;
+    /**
+    @brief
+        Returns the singleton instance.
+    @return
+        The only instance of GraphicsEngine.
+    */
+    /*static*/ GraphicsEngine& GraphicsEngine::getSingleton()
+    {
+        assert(singletonRef_s);
+        return *singletonRef_s;
+    }
+    /**
+    @brief
+        Non-initialising constructor.
+    */
+    GraphicsEngine::GraphicsEngine()
+        : root_(0)
+        , renderWindow_(0)
+        , levelSceneManager_(0)
+        , levelViewport_(0)
+    {
+        RegisterObject(GraphicsEngine);
+        singletonRef_s = this;
+        this->detailLevelParticle_ = 0;
+        this->setConfigValues();
+        CCOUT(4) << "Constructed" << std::endl;
+    }
+    void GraphicsEngine::setConfigValues()
+    {
+        SetConfigValue(resourceFile_,    "resources.cfg").description("Location of the resources file in the data path.");
+        SetConfigValue(ogreConfigFile_,  "ogre.cfg").description("Location of the Ogre config file");
+        SetConfigValue(ogrePluginsFile_, "plugins.cfg").description("Location of the Ogre plugins file");
+        SetConfigValue(ogreLogFile_,     "ogre.log").description("Logfile for messages from Ogre. \
+                                                                 Use \"\" to suppress log file creation.");
+        SetConfigValue(ogreLogLevelTrivial_ , 5).description("Corresponding orxonox debug level for ogre Trivial");
+        SetConfigValue(ogreLogLevelNormal_  , 4).description("Corresponding orxonox debug level for ogre Normal");
+        SetConfigValue(ogreLogLevelCritical_, 2).description("Corresponding orxonox debug level for ogre Critical");
+        unsigned int old = this->detailLevelParticle_;
+        SetConfigValue(detailLevelParticle_, 2).description("O: off, 1: low, 2: normal, 3: high");
+        if (this->detailLevelParticle_ != old)
+            for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
+                it->detailLevelChanged(this->detailLevelParticle_);
+    }
+    /**
+    @brief
+        Destroys all the Ogre related objects
+    */
+    GraphicsEngine::~GraphicsEngine()
+    {
+        CCOUT(4) << "Destroying objects..." << std::endl;
+        Ogre::WindowEventUtilities::removeWindowEventListener(this->renderWindow_, this);
+        if (this->root_)
+            delete this->root_;
+        this->root_ = 0;
+        this->levelSceneManager_ = 0;
+        this->renderWindow_ = 0;
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
+    // create a logManager
+    // note: If there's already a logManager, Ogre will complain by a failed assertation.
+    // but that shouldn't happen, since this is the first time to create a logManager..
+    Ogre::LogManager* logger = new Ogre::LogManager();
+    CCOUT(4) << "Ogre LogManager created" << std::endl;
+    // create our own log that we can listen to
+    Ogre::Log *myLog;
+    if (this->ogreLogFile_ == "")
+      myLog = logger->createLog("ogre.log", true, false, true);
+    else
+      myLog = logger->createLog(this->ogreLogFile_, true, false, false);
+    CCOUT(4) << "Ogre Log created" << std::endl;
+    myLog->setLogDetail(Ogre::LL_BOREME);
+    myLog->addListener(this);
+        // delete the ogre log and the logManager (since we have created it).
+        if (Ogre::LogManager::getSingletonPtr() != 0)
+        {
+            Ogre::LogManager::getSingleton().getDefaultLog()->removeListener(this);
+            Ogre::LogManager::getSingleton().destroyLog(Ogre::LogManager::getSingleton().getDefaultLog());
+            delete Ogre::LogManager::getSingletonPtr();
+        }
+        CCOUT(4) << "Destroying objects done" << std::endl;
 #endif
+    // Root will detect that we've already created a Log
+    CCOUT(4) << "Creating Ogre Root..." << std::endl;
+    if (ogrePluginsFile_ == "")
+    {
+      COUT(1) << "Error: Ogre plugins file set to \"\". Cannot load." << std::endl;
+      return false;
+    }
+    if (ogreConfigFile_ == "")
+    {
+      COUT(1) << "Error: Ogre config file set to \"\". Cannot load." << std::endl;
+      return false;
+    }
+    if (ogreLogFile_ == "")
+    {
+      COUT(1) << "Error: Ogre log file set to \"\". Cannot load." << std::endl;
+      return false;
+    }
+    try
+    {
+      root_ = new Ogre::Root(ogrePluginsFile_, ogreConfigFile_, ogreLogFile_);
+    }
+    catch (Ogre::Exception ex)
+    {
+      COUT(2) << "Error: There was an exception when creating Ogre Root." << std::endl;
+      return false;
+    }
+    if (!root_->getInstalledPlugins().size())
+    {
+      COUT(1) << "Error: No plugins declared. Cannot load Ogre." << std::endl;
+      COUT(0) << "Is the plugins file correctly declared?" << std::endl;
+      return false;
+    }
+#if 0
+    // tame the ogre ouput so we don't get all the mess in the console
+    Ogre::Log* defaultLog = Ogre::LogManager::getSingleton().getDefaultLog();
+    defaultLog->setDebugOutputEnabled(false);
+    defaultLog->setLogDetail(Ogre::LL_BOREME);
+    defaultLog->addListener(this);
+        singletonRef_s = 0;
+    }
+    /**
+    @brief
+        Creates the Ogre Root object and sets up the ogre log.
+    */
+    void GraphicsEngine::setup()
+    {
+        CCOUT(3) << "Setting up..." << std::endl;
+        // TODO: LogManager doesn't work on linux platform. The why is yet unknown.
+#if ORXONOX_PLATFORM == ORXONOX_PLATFORM_WIN32
+        // create a new logManager
+        Ogre::LogManager* logger = new Ogre::LogManager();
+        CCOUT(4) << "Ogre LogManager created" << std::endl;
+        // create our own log that we can listen to
+        Ogre::Log *myLog;
+        if (this->ogreLogFile_ == "")
+            myLog = logger->createLog("ogre.log", true, false, true);
+        else
+            myLog = logger->createLog(this->ogreLogFile_, true, false, false);
+        CCOUT(4) << "Ogre Log created" << std::endl;
+        myLog->setLogDetail(Ogre::LL_BOREME);
+        myLog->addListener(this);
 #endif
+    CCOUT(4) << "Creating Ogre Root done" << std::endl;
+    // specify where Ogre has to look for resources. This call doesn't parse anything yet!
+    if (!declareRessourceLocations())
+      return false;
+    CCOUT(3) << "Set up done." << std::endl;
+    return true;
+  }
+  bool GraphicsEngine::declareRessourceLocations()
+  {
+    CCOUT(4) << "Declaring Resources" << std::endl;
+    //TODO: Specify layout of data file and maybe use xml-loader
+    //TODO: Work with ressource groups (should be generated by a special loader)
+    if (resourceFile_ == "")
+    {
+      COUT(1) << "Error: Resource file set to \"\". Cannot load." << std::endl;
+      return false;
+    }
+    // Load resource paths from data file using configfile ressource type
+    Ogre::ConfigFile cf;
+    try
+    {
+      cf.load(Settings::getDataPath() + resourceFile_);
+    }
+    catch (Ogre::Exception ex)
+    {
+      COUT(1) << "Error: Could not load resources.cfg in path " << Settings::getDataPath() << std::endl;
+      COUT(0) << "Have you forgotten to set the data path in orxnox.ini?" << std::endl;
+      return false;
+    }
+    // Go through all sections & settings in the file
+    Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
+    std::string secName, typeName, archName;
+    while (seci.hasMoreElements())
+    {
+      try
+      {
+        secName = seci.peekNextKey();
+        Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
+        Ogre::ConfigFile::SettingsMultiMap::iterator i;
+        for (i = settings->begin(); i != settings->end(); ++i)
+        {
+          typeName = i->first; // for instance "FileSystem" or "Zip"
+          archName = i->second; // name (and location) of archive
+          Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
+              std::string(Settings::getDataPath() + archName), typeName, secName);
+        }
+      }
+      catch (Ogre::Exception ex)
+      {
+        COUT(2) << "Exception while reading resources.cfg. Proceeding.." << ex.getDescription() << std::endl;
+      }
+    }
+    return true;
+  }
+  bool GraphicsEngine::loadRenderer()
+  {
+    CCOUT(4) << "Configuring Renderer" << std::endl;
+    // check for file existence because Ogre displays exceptions if not
+    std::ifstream probe;
+    probe.open(ogreConfigFile_.c_str());
+    if (!probe)
+    {
+      // create a zero sized file
+      std::ofstream creator;
+      creator.open(ogreConfigFile_.c_str());
+      creator.close();
+    }
+    else
+      probe.close();
+    if (!root_->restoreConfig())
+      if (!root_->showConfigDialog())
+        return false;
+    CCOUT(4) << "Creating render window" << std::endl;
+    try
+    {
+      this->renderWindow_ = root_->initialise(true, "OrxonoxV2");
+    }
+    catch (Ogre::Exception ex)
+    {
+      COUT(2) << "Error: There was an exception when initialising Ogre Root." << std::endl;
+      return false;
+    }
+    if (!root_->isInitialised())
+    {
+      CCOUT(2) << "Error: Initialising Ogre root object failed." << std::endl;
+      return false;
+    }
+    Ogre::WindowEventUtilities::addWindowEventListener(this->renderWindow_, this);
+    Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
+    return true;
+  }
+  bool GraphicsEngine::initialiseResources()
+  {
+    CCOUT(4) << "Initialising resources" << std::endl;
+    //TODO: Do NOT load all the groups, why are we doing that? And do we really do that? initialise != load...
+    try
+    {
+      Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
+      /*Ogre::StringVector str = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
+      for (unsigned int i = 0; i < str.size(); i++)
+      {
+        Ogre::ResourceGroupManager::getSingleton().loadResourceGroup(str[i]);
+      }*/
+    }
+    catch (Ogre::Exception e)
+    {
+      CCOUT(2) << "Error: There was an Error when initialising the resources." << std::endl;
+      CCOUT(2) << "ErrorMessage: " << e.getFullDescription() << std::endl;
+      return false;
+    }
+    return true;
+  }
+  /**
+   * @brief Creates the SceneManager
+   */
+  bool GraphicsEngine::createNewScene()
+  {
+    CCOUT(4) << "Creating new SceneManager..." << std::endl;
+    if (scene_)
+    {
+      CCOUT(2) << "SceneManager already exists! Skipping." << std::endl;
+      return false;
+    }
+    scene_ = root_->createSceneManager(Ogre::ST_GENERIC, "Default SceneManager");
+    CCOUT(3) << "Created SceneManager: " << scene_ << std::endl;
+    return true;
+  }
+  /**
+    Returns the window handle of the render window.
+    At least the InputHandler uses this to create the OIS::InputManager
+    @return The window handle of the render window
+  */
+  size_t GraphicsEngine::getWindowHandle()
+  {
+    if (this->renderWindow_)
+    {
+      size_t windowHnd = 0;
+      this->renderWindow_->getCustomAttribute("WINDOW", &windowHnd);
+      return windowHnd;
+    }
+    else
+      return 0;
+  }
+  /**
+    Get the width of the current render window
+    @return The width of the current render window
+  */
+  int GraphicsEngine::getWindowWidth() const
+  {
+    if (this->renderWindow_)
+      return this->renderWindow_->getWidth();
+    else
+      return 0;
+  }
+  /**
+    Get the height of the current render window
+    @return The height of the current render window
+  */
+  int GraphicsEngine::getWindowHeight() const
+  {
+    if (this->renderWindow_)
+      return this->renderWindow_->getHeight();
+    else
+      return 0;
+  }
+  /**
+    @brief Returns the window aspect ratio height/width.
+    @return The ratio
+  */
+  float GraphicsEngine::getWindowAspectRatio() const
+  {
+    if (this->renderWindow_)
+        return (float)this->renderWindow_->getHeight() / (float)this->renderWindow_->getWidth();
+    else
+        return 1.0f;
+  }
+  /**
+    @brief Method called by the LogListener interface from Ogre.
+    We use it to capture Ogre log messages and handle it ourselves.
+    @param message The message to be logged
+    @param lml The message level the log is using
+    @param maskDebug If we are printing to the console or not
+    @param logName the name of this log (so you can have several listeners
+                   for different logs, and identify them)
+  */
+  void GraphicsEngine::messageLogged(const std::string& message,
+    Ogre::LogMessageLevel lml, bool maskDebug, const std::string &logName)
+  {
+    int orxonoxLevel;
+    switch (lml)
+    {
+      case Ogre::LML_TRIVIAL:
+        orxonoxLevel = this->ogreLogLevelTrivial_;
+        break;
+      case Ogre::LML_NORMAL:
+        orxonoxLevel = this->ogreLogLevelNormal_;
+        break;
+      case Ogre::LML_CRITICAL:
+        orxonoxLevel = this->ogreLogLevelCritical_;
+        break;
+      default:
+        orxonoxLevel = 0;
+    }
+    OutputHandler::getOutStream().setOutputLevel(orxonoxLevel)
+        << "Ogre: " << message << std::endl;
+  }
+  /**
+  * Window has moved.
+  * @param rw The render window it occured in
+  */
+  void GraphicsEngine::windowMoved(Ogre::RenderWindow *rw)
+  {
+    for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+      it->windowMoved();
+  }
+  /**
+  * Window has resized.
+  * @param rw The render window it occured in
+  * @note GraphicsEngine has a render window stored itself. This is the same
+  *       as rw. But we have to be careful when using multiple render windows!
+  */
+  void GraphicsEngine::windowResized(Ogre::RenderWindow *rw)
+  {
+    for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+      it->windowResized(this->renderWindow_->getWidth(), this->renderWindow_->getHeight());
+  }
+  /**
+  * Window has changed Focus.
+  * @param rw The render window it occured in
+  */
+  void GraphicsEngine::windowFocusChanged(Ogre::RenderWindow *rw)
+  {
+    for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+      it->windowFocusChanged();
+  }
+  /**
+  * Window was closed.
+  * @param rw The render window it occured in
+  */
+  void GraphicsEngine::windowClosed(Ogre::RenderWindow *rw)
+  {
+    // using CommandExecutor in order to avoid depending on Orxonox.h.
+    CommandExecutor::execute("exit", false);
+  }
+        // Root will detect that we've already created a Log
+        CCOUT(4) << "Creating Ogre Root..." << std::endl;
+        if (ogrePluginsFile_ == "")
+        {
+            COUT(2) << "Warning: Ogre plugins file set to \"\". Defaulting to plugins.cfg" << std::endl;
+            ModifyConfigValue(ogrePluginsFile_, tset, "plugins.cfg");
+        }
+        if (ogreConfigFile_ == "")
+        {
+            COUT(2) << "Warning: Ogre config file set to \"\". Defaulting to config.cfg" << std::endl;
+            ModifyConfigValue(ogreConfigFile_, tset, "config.cfg");
+        }
+        if (ogreLogFile_ == "")
+        {
+            COUT(2) << "Warning: Ogre log file set to \"\". Defaulting to ogre.log" << std::endl;
+            ModifyConfigValue(ogreLogFile_, tset, "ogre.log");
+        }
+        root_ = new Ogre::Root(ogrePluginsFile_, ogreConfigFile_, ogreLogFile_);
+        if (!root_->getInstalledPlugins().size())
+        {
+            ThrowException(PluginsNotFound, "No Ogre plugins declared. Cannot load Ogre.");
+        }
+#if 0 // Ogre 1.4.3 doesn't support setDebugOutputEnabled(.)
+//#if ORXONOX_PLATFORM != ORXONOX_PLATFORM_WIN32
+        // tame the ogre ouput so we don't get all the mess in the console
+        Ogre::Log* defaultLog = Ogre::LogManager::getSingleton().getDefaultLog();
+        defaultLog->setDebugOutputEnabled(false);
+        defaultLog->setLogDetail(Ogre::LL_BOREME);
+        defaultLog->addListener(this);
+#endif
+        CCOUT(4) << "Creating Ogre Root done" << std::endl;
+        // specify where Ogre has to look for resources. This call doesn't parse anything yet!
+        declareRessourceLocations();
+        CCOUT(3) << "Set up done." << std::endl;
+    }
+    void GraphicsEngine::declareRessourceLocations()
+    {
+        CCOUT(4) << "Declaring Resources" << std::endl;
+        //TODO: Specify layout of data file and maybe use xml-loader
+        //TODO: Work with ressource groups (should be generated by a special loader)
+        if (resourceFile_ == "")
+        {
+            COUT(2) << "Warning: Ogre resource file set to \"\". Defaulting to resources.cfg" << std::endl;
+            ModifyConfigValue(resourceFile_, tset, "resources.cfg");
+        }
+        // Load resource paths from data file using configfile ressource type
+        Ogre::ConfigFile cf;
+        try
+        {
+            cf.load(Settings::getDataPath() + resourceFile_);
+        }
+        catch (Ogre::Exception& ex)
+        {
+            COUT(1) << ex.getFullDescription() << std::endl;
+            COUT(0) << "Have you forgotten to set the data path in orxnox.ini?" << std::endl;
+            throw;
+        }
+        // Go through all sections & settings in the file
+        Ogre::ConfigFile::SectionIterator seci = cf.getSectionIterator();
+        std::string secName, typeName, archName;
+        while (seci.hasMoreElements())
+        {
+            try
+            {
+                secName = seci.peekNextKey();
+                Ogre::ConfigFile::SettingsMultiMap *settings = seci.getNext();
+                Ogre::ConfigFile::SettingsMultiMap::iterator i;
+                for (i = settings->begin(); i != settings->end(); ++i)
+                {
+                    typeName = i->first; // for instance "FileSystem" or "Zip"
+                    archName = i->second; // name (and location) of archive
+                    Ogre::ResourceGroupManager::getSingleton().addResourceLocation(
+                        std::string(Settings::getDataPath() + archName), typeName, secName);
+                }
+            }
+            catch (Ogre::Exception& ex)
+            {
+                COUT(1) << ex.getFullDescription() << std::endl;
+            }
+        }
+    }
+    bool GraphicsEngine::loadRenderer()
+    {
+        CCOUT(4) << "Configuring Renderer" << std::endl;
+        // check for file existence because Ogre displays exceptions if not
+        std::ifstream probe;
+        probe.open(ogreConfigFile_.c_str());
+        if (!probe)
+        {
+            // create a zero sized file
+            std::ofstream creator;
+            creator.open(ogreConfigFile_.c_str());
+            creator.close();
+        }
+        else
+            probe.close();
+        if (!root_->restoreConfig())
+            if (!root_->showConfigDialog())
+                return false;
+        CCOUT(4) << "Creating render window" << std::endl;
+        try
+        {
+            this->renderWindow_ = root_->initialise(true, "OrxonoxV2");
+        }
+        catch (...)
+        {
+            COUT(2) << "Error: There was an exception when initialising Ogre Root." << std::endl;
+            return false;
+        }
+        if (!root_->isInitialised())
+        {
+            CCOUT(2) << "Error: Initialising Ogre root object failed." << std::endl;
+            return false;
+        }
+        Ogre::WindowEventUtilities::addWindowEventListener(this->renderWindow_, this);
+        //Ogre::TextureManager::getSingleton().setDefaultNumMipmaps(5);
+        // create a full screen viewport in which to render the scene and the loading screen
+        // The GUI uses its own one to be able to render on top of everything.
+        // That explains why the Z order here is only 1 and not 0 (top most)
+        this->levelViewport_ = this->renderWindow_->addViewport(0, 1);
+        return true;
+    }
+    bool GraphicsEngine::initialiseResources()
+    {
+        CCOUT(4) << "Initialising resources" << std::endl;
+        //TODO: Do NOT load all the groups, why are we doing that? And do we really do that? initialise != load...
+        try
+        {
+            Ogre::ResourceGroupManager::getSingleton().initialiseAllResourceGroups();
+            /*Ogre::StringVector str = Ogre::ResourceGroupManager::getSingleton().getResourceGroups();
+            for (unsigned int i = 0; i < str.size(); i++)
+            {
+            Ogre::ResourceGroupManager::getSingleton().loadResourceGroup(str[i]);
+            }*/
+        }
+        catch (Ogre::Exception& e)
+        {
+            CCOUT(2) << "Error: There was an Error when initialising the resources." << std::endl;
+            CCOUT(2) << "ErrorMessage: " << e.getFullDescription() << std::endl;
+            return false;
+        }
+        return true;
+    }
+    /**
+    @brief
+        Creates the SceneManager
+    */
+    bool GraphicsEngine::createNewScene()
+    {
+        CCOUT(4) << "Creating new SceneManager..." << std::endl;
+        if (levelSceneManager_)
+        {
+            CCOUT(2) << "SceneManager already exists! Skipping." << std::endl;
+            return false;
+        }
+        this->levelSceneManager_ = this->root_->createSceneManager(Ogre::ST_GENERIC, "LevelSceneManager");
+        CCOUT(3) << "Created SceneManager: " << levelSceneManager_ << std::endl;
+        return true;
+    }
+    /**
+    @brief
+        Returns the window handle of the render window.
+        At least the InputHandler uses this to create the OIS::InputManager
+    @return
+        The window handle of the render window
+    */
+    size_t GraphicsEngine::getWindowHandle()
+    {
+        if (this->renderWindow_)
+        {
+            size_t windowHnd = 0;
+            this->renderWindow_->getCustomAttribute("WINDOW", &windowHnd);
+            return windowHnd;
+        }
+        else
+            return 0;
+    }
+    /**
+    @brief
+        Get the width of the render window
+    @return
+        The width of the render window
+    */
+    int GraphicsEngine::getWindowWidth() const
+    {
+        if (this->renderWindow_)
+            return this->renderWindow_->getWidth();
+        else
+            return 0;
+    }
+    /**
+    @brief
+        Get the height of the render window
+    @return
+        The height of the render window
+    */
+    int GraphicsEngine::getWindowHeight() const
+    {
+        if (this->renderWindow_)
+            return this->renderWindow_->getHeight();
+        else
+            return 0;
+    }
+    /**
+    @brief
+        Returns the window aspect ratio height/width.
+    @return
+        The window aspect ratio
+    */
+    float GraphicsEngine::getWindowAspectRatio() const
+    {
+        if (this->renderWindow_)
+            return (float)this->renderWindow_->getHeight() / (float)this->renderWindow_->getWidth();
+        else
+            return 1.0f;
+    }
+    /**
+    @brief
+        Method called by the LogListener interface from Ogre.
+        We use it to capture Ogre log messages and handle it ourselves.
+    @param message
+        The message to be logged
+    @param lml
+        The message level the log is using
+    @param maskDebug
+        If we are printing to the console or not
+    @param logName
+        The name of this log (so you can have several listeners
+        for different logs, and identify them)
+    */
+    void GraphicsEngine::messageLogged(const std::string& message,
+        Ogre::LogMessageLevel lml, bool maskDebug, const std::string &logName)
+    {
+        int orxonoxLevel;
+        switch (lml)
+        {
+        case Ogre::LML_TRIVIAL:
+            orxonoxLevel = this->ogreLogLevelTrivial_;
+            break;
+        case Ogre::LML_NORMAL:
+            orxonoxLevel = this->ogreLogLevelNormal_;
+            break;
+        case Ogre::LML_CRITICAL:
+            orxonoxLevel = this->ogreLogLevelCritical_;
+            break;
+        default:
+            orxonoxLevel = 0;
+        }
+        OutputHandler::getOutStream().setOutputLevel(orxonoxLevel)
+            << "Ogre: " << message << std::endl;
+    }
+    /**
+    @brief
+        Window has moved.
+    @param rw
+        The render window it occured in
+    */
+    void GraphicsEngine::windowMoved(Ogre::RenderWindow *rw)
+    {
+        for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+            it->windowMoved();
+    }
+    /**
+    @brief
+        Window has resized.
+    @param rw
+        The render window it occured in
+    @note
+        GraphicsEngine has a render window stored itself. This is the same
+        as rw. But we have to be careful when using multiple render windows!
+    */
+    void GraphicsEngine::windowResized(Ogre::RenderWindow *rw)
+    {
+        for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+            it->windowResized(this->renderWindow_->getWidth(), this->renderWindow_->getHeight());
+    }
+    /**
+    @brief
+        Window focus has changed.
+    @param rw
+        The render window it occured in
+    */
+    void GraphicsEngine::windowFocusChanged(Ogre::RenderWindow *rw)
+    {
+        for (Iterator<orxonox::WindowEventListener> it = ObjectList<orxonox::WindowEventListener>::start(); it; ++it)
+            it->windowFocusChanged();
+    }
+    /**
+    @brief
+        Window was closed.
+    @param rw
+        The render window it occured in
+    */
+    void GraphicsEngine::windowClosed(Ogre::RenderWindow *rw)
+    {
+        // using CommandExecutor in order to avoid depending on Orxonox.h.
+        CommandExecutor::execute("exit", false);
+    }
+}

code/branches/gui/src/orxonox/GraphicsEngine.h

-                      r1625
+                      r1638
     class _OrxonoxExport GraphicsEngine : public Ogre::WindowEventListener, public Ogre::LogListener, public OrxonoxClass
+    {
+        public:
+            void setConfigValues();
+            bool setup();
+            bool declareRessourceLocations();
+            bool loadRenderer();
+            bool initialiseResources();
+            bool createNewScene();
+    public:
+        GraphicsEngine();
+        ~GraphicsEngine();
+            void destroy();
+        void setConfigValues();
+        void setup();
+        void declareRessourceLocations();
+        bool loadRenderer();
+        bool initialiseResources();
+        bool createNewScene();
+            Ogre::SceneManager* getSceneManager() { return scene_; }
+        void setLevelSceneManager(Ogre::SceneManager* sceneMgr) { this->levelSceneManager_ = sceneMgr; }
+        Ogre::SceneManager* getLevelSceneManager() { return levelSceneManager_; }
+            // several window properties
+            Ogre::RenderWindow* getRenderWindow() { return this->renderWindow_; }
+            size_t getWindowHandle();
+            int getWindowWidth() const;
+            int getWindowHeight() const;
+            float getWindowAspectRatio() const;
+            float getAverageFramesPerSecond() const { return this->avgFramesPerSecond_; }
+            float getAverageTickTime() const { return this->avgTickTime_; }
+            void setAverageTickTime(float tickTime) { this->avgTickTime_ = tickTime; }
+            void setAverageFramesPerSecond(float fps) { this->avgFramesPerSecond_ = fps; }
+        Ogre::Viewport* getLevelViewport() { return this->levelViewport_; }
+            void setWindowActivity(bool activity)
+            { if (this->renderWindow_) this->renderWindow_->setActive(activity); }
+        // several window properties
+        Ogre::RenderWindow* getRenderWindow() { return this->renderWindow_; }
+        size_t getWindowHandle();
+        int getWindowWidth() const;
+        int getWindowHeight() const;
+        float getWindowAspectRatio() const;
+        float getAverageFramesPerSecond() const   { return this->avgFramesPerSecond_; }
+        float getAverageTickTime() const          { return this->avgTickTime_; }
+        void setAverageTickTime(float tickTime)   { this->avgTickTime_ = tickTime; }
+        void setAverageFramesPerSecond(float fps) { this->avgFramesPerSecond_ = fps; }
+            void windowMoved       (Ogre::RenderWindow* rw);
+            void windowResized     (Ogre::RenderWindow* rw);
+            void windowFocusChanged(Ogre::RenderWindow* rw);
+            void windowClosed      (Ogre::RenderWindow* rw);
+        void setWindowActivity(bool activity)
+        { if (this->renderWindow_) this->renderWindow_->setActive(activity); }
             inline unsigned int getDetailLevelParticle() const
               { return this->detailLevelParticle_; }
+        inline unsigned int getDetailLevelParticle() const
+        { return this->detailLevelParticle_; }
             static GraphicsEngine& getSingleton();
             static GraphicsEngine* getSingletonPtr() { return &getSingleton(); }
+        static GraphicsEngine& getSingleton();
+        static GraphicsEngine* getSingletonPtr() { return &getSingleton(); }
+    private:
+        // don't mess with singletons
+        GraphicsEngine(GraphicsEngine&) { }
+        private:
+            // don't mess with singletons
+            GraphicsEngine();
+            ~GraphicsEngine();
+            GraphicsEngine(GraphicsEngine&) { }
+        //! Method called by the LogListener from Ogre
+        void messageLogged(const std::string&, Ogre::LogMessageLevel,
+            bool, const std::string&);
+            //! Method called by the LogListener from Ogre
+            void messageLogged(const std::string&, Ogre::LogMessageLevel,
+                             bool, const std::string&);
+        // window events from Ogre::WindowEventListener
+        void windowMoved       (Ogre::RenderWindow* rw);
+        void windowResized     (Ogre::RenderWindow* rw);
+        void windowFocusChanged(Ogre::RenderWindow* rw);
+        void windowClosed      (Ogre::RenderWindow* rw);
+            Ogre::Root*         root_;                  //!< Ogre's root
+            Ogre::SceneManager* scene_;                 //!< scene manager of the game
+            Ogre::RenderWindow* renderWindow_;          //!< the current render window
+            std::string         resourceFile_;          //!< resources file name
+            std::string         ogreConfigFile_;        //!< ogre config file name
+            std::string         ogrePluginsFile_;       //!< ogre plugins file name
+            std::string         ogreLogFile_;           //!< log file name for Ogre log messages
+            int                 ogreLogLevelTrivial_;   //!< Corresponding Orxonx debug level for LL_TRIVIAL
+            int                 ogreLogLevelNormal_;    //!< Corresponding Orxonx debug level for LL_NORMAL
+            int                 ogreLogLevelCritical_;  //!< Corresponding Orxonx debug level for LL_CRITICAL
+            unsigned int        detailLevelParticle_;   //!< Detail level of particle effects (0: off, 1: low, 2: normal, 3: high)
+            float               avgTickTime_;           //!< time in ms to tick() one frame
+            float               avgFramesPerSecond_;    //!< number of frames processed in one second
+        Ogre::Root*         root_;                  //!< Ogre's root
+        Ogre::RenderWindow* renderWindow_;          //!< the current render window
+        Ogre::SceneManager* levelSceneManager_;     //!< scene manager of the game
+        Ogre::Viewport*     levelViewport_;         //!< default full size viewport for the level
+        // stats
+        float               avgTickTime_;           //!< time in ms to tick() one frame
+        float               avgFramesPerSecond_;    //!< number of frames processed in one second
+        // config values
+        std::string         resourceFile_;          //!< resources file name
+        std::string         ogreConfigFile_;        //!< ogre config file name
+        std::string         ogrePluginsFile_;       //!< ogre plugins file name
+        std::string         ogreLogFile_;           //!< log file name for Ogre log messages
+        int                 ogreLogLevelTrivial_;   //!< Corresponding Orxonx debug level for LL_TRIVIAL
+        int                 ogreLogLevelNormal_;    //!< Corresponding Orxonx debug level for LL_NORMAL
+        int                 ogreLogLevelCritical_;  //!< Corresponding Orxonx debug level for LL_CRITICAL
+        unsigned int        detailLevelParticle_;   //!< Detail level of particle effects (0: off, 1: low, 2: normal, 3: high)
+        static GraphicsEngine* singletonRef_s;      //!< Pointer to the Singleton
     };
+}

code/branches/gui/src/orxonox/Main.cc

-                      r1535
+                      r1638
  *   Author:
  *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
+ *      Reto Grieder
  *   Co-authors:
  *      ...
 …
 #include <exception>
+#include <cassert>
 #include "util/OrxonoxPlatform.h"
+#include "util/ArgReader.h"
 #include "core/SignalHandler.h"
+#include "core/Debug.h"
+#include "network/ClientConnection.h"
+#include "Settings.h"
 #include "Orxonox.h"
 using namespace orxonox;
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE
 #include <CoreFoundation/CoreFoundation.h>
 …
              std::string macBundlePath()
+{
   char path[1024];
   CFBundleRef mainBundle = CFBundleGetMainBundle();
   assert(mainBundle);
+    char path[1024];
+    CFBundleRef mainBundle = CFBundleGetMainBundle();
+    assert(mainBundle);
   CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle);
   assert(mainBundleURL);
+    CFURLRef mainBundleURL = CFBundleCopyBundleURL(mainBundle);
+    assert(mainBundleURL);
   CFStringRef cfStringRef = CFURLCopyFileSystemPath( mainBundleURL, kCFURLPOSIXPathStyle);
   assert(cfStringRef);
+    CFStringRef cfStringRef = CFURLCopyFileSystemPath( mainBundleURL, kCFURLPOSIXPathStyle);
+    assert(cfStringRef);
   CFStringGetCString(cfStringRef, path, 1024, kCFStringEncodingASCII);
+    CFStringGetCString(cfStringRef, path, 1024, kCFStringEncodingASCII);
   CFRelease(mainBundleURL);
   CFRelease(cfStringRef);
+    CFRelease(mainBundleURL);
+    CFRelease(cfStringRef);
   return std::string(path);
+    return std::string(path);
+}
 #endif
+bool parseCommandLine(int argc, char** argv)
+{
+    ArgReader args;
+    std::string errorStr = args.parse(argc, argv);
+    if (errorStr != "")
+    {
+        COUT(1) << "Command Line: Parsing failed.\n" << errorStr << std::endl;
+        return false;
+    }
+    // Argument reader parses the command line to check syntax.
+    // Settings Singleton then stores the arguments. It always
+    // expects a default value.
+    bool success = true;
+    success &= Settings::addCommandLineArgument<std::string>
+        ("mode",     args.getArgument("mode"),     "standalone");
+    success &= Settings::addCommandLineArgument<std::string>
+        ("dataPath", args.getArgument("dataPath"), "./");
+    success &= Settings::addCommandLineArgument<std::string>
+        ("ip",       args.getArgument("ip"),       "127.0.0.0");
+    success &= Settings::addCommandLineArgument<int>
+        ("port",     args.getArgument("port"),     NETWORK_PORT);
+    if (!success)
+        return false;
+    if (!args.allChecked())
+    {
+        COUT(1) << "Command Line: Parsing failed.\nNot all arguments were matched." << std::endl;
+        return false;
+    }
+    return true;
+}
 #ifdef __cplusplus
 …
 #endif
 int main(int argc, char **argv)
+int main(int argc, char** argv)
+{
   //try {
+    // create a signal handler (only works for linux)
     SignalHandler::getInstance()->doCatch(argv[0], "orxonox.log");
-    Orxonox* orx = Orxonox::getSingleton();
+    bool res = false;
+    if (!parseCommandLine(argc, argv))
+    {
+        COUT(0) << "Usage:" << std::endl << "orxonox [--mode client|server|dedicated|standalone] "
+                << "[--data PATH] [--ip IP] [--port PORT]" << std::endl;
+        return 0;
+    }
+    Orxonox orxonoxInstance;
+    try
+    {
 #if ORXONOX_PLATFORM == ORXONOX_PLATFORM_APPLE
     res = orx->init(argc, argv, macBundlePath());
+        orxonoxInstance.start(macBundlePath());
 #else
     res = orx->init(argc, argv);
+        orxonoxInstance.start();
 #endif
+    }
+    catch (std::exception& ex)
+    {
+        COUT(1) << ex.what() << std::endl;
+        COUT(1) << "Abort." << std::endl;
+    }
+    if (res)
+      orx->start();
+    orx->destroySingleton();
+  /*}
+  catch (std::exception &ex)
+  {
+    std::cerr << "Exception:\n";
+    std::cerr << ex.what() << "\n";
+    return 1;
+  }*/
+  return 0;
+    return 0;
+}

code/branches/gui/src/orxonox/Orxonox.cc

-                      r1625
+                      r1638
  *   Author:
  *      Reto Grieder
+ *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
  *   Co-authors:
  *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
+ *      ...
+ *
  */
 …
 //****** STD *******
 #include <deque>
+#include <cassert>
 //****** OGRE ******
 …
 // util
 //#include "util/Sleep.h"
-#include "util/ArgReader.h"
 // core
 #include "core/ConfigFileManager.h"
+#include "core/ConfigValueIncludes.h"
 #include "core/ConsoleCommand.h"
 #include "core/Debug.h"
 #include "core/Loader.h"
+#include "core/Exception.h"
 #include "core/input/InputManager.h"
+#include "core/input/SimpleInputState.h"
+#include "core/input/KeyBinder.h"
 #include "core/TclBind.h"
 #include "core/Core.h"
 …
 // objects and tools
-#include "overlays/OverlayGroup.h"
 #include "overlays/console/InGameConsole.h"
 #include "objects/Tickable.h"
 #include "objects/Backlight.h"
 #include "tools/ParticleInterface.h"
+#include "gui/GUIManager.h"
 #include "GraphicsEngine.h"
 …
 namespace orxonox
+{
+  SetConsoleCommandShortcut(Orxonox, exit).setKeybindMode(KeybindMode::OnPress);
+  SetConsoleCommandShortcut(Orxonox, slomo).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0).setAxisParamIndex(0).setIsAxisRelative(false);
+  SetConsoleCommandShortcut(Orxonox, setTimeFactor).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0);
+  SetConsoleCommand(Orxonox, exit, true).setKeybindMode(KeybindMode::OnPress);
+  SetConsoleCommand(Orxonox, slomo, true).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0).setAxisParamIndex(0).setIsAxisRelative(false);
+  SetConsoleCommand(Orxonox, setTimeFactor, true).setAccessLevel(AccessLevel::Offline).setDefaultValue(0, 1.0);
+  SetConsoleCommand(Orxonox, loadGame, true).setAccessLevel(AccessLevel::User).setDefaultValue(0, "standalone");
   /**
 …
     , bAbort_(false)
     , timefactor_(1.0f)
+    , mode_(STANDALONE)
+    , serverIp_("")
+    , serverPort_(NETWORK_PORT)
+  {
+    , mode_(GameMode::GM_Unspecified)
+    , debugRefreshTime_(0.0f)
+  {
+    RegisterRootObject(Orxonox);
+    assert(singletonRef_s == 0);
+    singletonRef_s = this;
+  }
 …
+  {
     // keep in mind: the order of deletion is very important!
     Loader::unload(startLevel_);
+    Loader::unload();
     if (this->startLevel_)
       delete this->startLevel_;
 …
       delete this->timer_;
     InputManager::destroy();
+    GraphicsEngine::getSingleton().destroy();
+    if (this->ogre_)
+      delete ogre_;
     if (network::Client::getSingleton())
 …
     if (server_g)
       delete network::Server::getSingleton();
+    singletonRef_s = 0;
+  }
+  void Orxonox::setConfigValues()
+  {
+    SetConfigValue(debugRefreshTime_, 0.2).description("Sets the time interval at which average fps, etc. get updated.");
+  }
 …
    * @return singleton reference
    */
+  Orxonox* Orxonox::getSingleton()
+  {
+    if (!singletonRef_s)
+      singletonRef_s = new Orxonox();
+    return singletonRef_s;
+  }
+  /**
+    @brief Destroys the Orxonox singleton.
+  */
+  void Orxonox::destroySingleton()
+  {
+    if (singletonRef_s)
+      delete singletonRef_s;
+    singletonRef_s = 0;
+  Orxonox& Orxonox::getSingleton()
+  {
+    assert(singletonRef_s);
+    return *singletonRef_s;
+  }
 …
   void Orxonox::setTimeFactor(float factor)
+  {
     float change = factor / Orxonox::getSingleton()->getTimeFactor();
     Orxonox::getSingleton()->timefactor_ = factor;
+    float change = factor / Orxonox::getSingleton().getTimeFactor();
+    Orxonox::getSingleton().timefactor_ = factor;
     for (Iterator<ParticleInterface> it = ObjectList<ParticleInterface>::begin(); it; ++it)
         it->setSpeedFactor(it->getSpeedFactor() * change);
     for (Iterator<Backlight> it = ObjectList<Backlight>::begin(); it; ++it)
+        it->setTimeFactor(Orxonox::getSingleton()->getTimeFactor());
+  }
+  /**
+   * initialization of Orxonox object
+   * @param argc argument counter
+   * @param argv list of argumenst
+        it->setTimeFactor(Orxonox::getSingleton().getTimeFactor());
+  }
+  /**
+   * Starts the whole Game.
    * @param path path to config (in home dir or something)
    */
   bool Orxonox::init(int argc, char **argv)
+  void Orxonox::start()
+  {
 #ifdef _DEBUG
 …
     Factory::createClassHierarchy();
+    std::string mode;
+    std::string tempDataPath;
+    ArgReader ar(argc, argv);
+    ar.checkArgument("mode", &mode, false);
+    ar.checkArgument("data", &tempDataPath, false);
+    ar.checkArgument("ip",   &serverIp_, false);
+    ar.checkArgument("port", &serverPort_, false);
+    if(ar.errorHandling())
+    {
+      COUT(1) << "Error while parsing command line arguments" << std::endl;
+      COUT(1) << ar.getErrorString();
+      COUT(0) << "Usage:" << std::endl << "orxonox [mode client|server|dedicated|standalone] "
+        << "[--data PATH] [--ip IP] [--port PORT]" << std::endl;
+      return false;
+    }
+    if (mode == "client")
+      mode_ = CLIENT;
+    else if (mode == "server")
+      mode_ = SERVER;
+    else if (mode == "dedicated")
+      mode_ = DEDICATED;
+    else
+    {
+      if (mode == "")
+        mode = "standalone";
+      if (mode != "standalone")
+    setConfigValues();
+    const Settings::CommandLineArgument* mode = Settings::getCommandLineArgument("mode");
+    assert(mode);
+    if (!mode->bHasDefaultValue_)
+    {
+      Settings::setGameMode(mode->value_);
+      this->mode_ = Settings::getGameMode();
+    }
+    COUT(3) << "Orxonox: Game mode is " << mode_.name << "." << std::endl;
+    const Settings::CommandLineArgument* dataPath = Settings::getCommandLineArgument("dataPath");
+    assert(dataPath);
+    if (!dataPath->bHasDefaultValue_)
+    {
+      if (*dataPath->value_.getString().end() != '/' && *dataPath->value_.getString().end() != '\\')
+        Settings::tsetDataPath(dataPath->value_.getString() + "/");
+      else
+        Settings::tsetDataPath(dataPath->value_.getString());
+    }
+    try
+    {
+        // initialise TCL
+        TclBind::getInstance().setDataPath(Settings::getDataPath());
+        ogre_ = new GraphicsEngine();
+        ogre_->setup();       // creates ogre root and other essentials
+        if (mode_.showsGraphics)
+        {
+          ogre_->loadRenderer();    // creates the render window
+          // TODO: Spread this so that this call only initialises things needed for the Console and GUI
+          ogre_->initialiseResources();
+          // Calls the InputManager which sets up the input devices.
+          // The render window width and height are used to set up the mouse movement.
+          InputManager::initialise(ogre_->getWindowHandle(),
+                ogre_->getWindowWidth(), ogre_->getWindowHeight(), true, true, true);
+          KeyBinder* keyBinder = new KeyBinder();
+          InputManager::createSimpleInputState("game", 20)->setHandler(keyBinder);
+          // Load the InGameConsole
+          InGameConsole::getInstance().initialise();
+          // load the CEGUI interface
+          GUIManager::getInstance().initialise();
+        }
+        bool showGUI = true;
+        if (mode_.mode != GameMode::Unspecified)
+        {
+          showGUI = false;
+          // a game mode was specified with the command line
+          // we therefore load the game and level directly
+          if (!loadLevel(this->mode_))
+          {
+            COUT(1) << "Loading with predefined mode failed. Showing main menu." << std::endl;
+            showGUI = true;
+            mode_ = GameMode::GM_Unspecified;
+          }
+        }
+        if (showGUI)
+        {
+          // show main menu
+          //GraphicsEngine::getSingleton().createNewScene();
+          GUIManager::getInstance().showGUI("MainMenu", true);
+        }
+    }
+    catch (std::exception& ex)
+    {
+      COUT(1) << ex.what() << std::endl;
+      COUT(1) << "Loading sequence aborted." << std::endl;
+      return;
+    }
+    modeRequest_ = mode_;
+    // here happens the game
+    startRenderLoop();
+    if (mode_.mode == GameMode::Client)
+      network::Client::getSingleton()->closeConnection();
+    if (mode_.hasServer)
+      server_g->close();
+  }
+  void Orxonox::loadGame(const std::string& name)
+  {
+      const GameMode& mode = Settings::getGameMode(name);
+      if (mode.mode == GameMode::None)
+          return;
+      getSingleton().modeRequest_ = mode;
+  }
+  bool Orxonox::loadLevel(const GameMode& mode)
+  {
+      bool success = true;
+      if (mode.showsGraphics)
+      {
+        COUT(2) << "Warning: mode \"" << mode << "\" doesn't exist. "
+          << "Defaulting to standalone" << std::endl;
+        mode = "standalone";
+        // create Ogre SceneManager for the level
+        ogre_->createNewScene();
+        if (!loadPlayground())
+            return false;
+      }
+      mode_ = STANDALONE;
+    }
+    COUT(3) << "Orxonox: Mode is " << mode << "." << std::endl;
+    if (tempDataPath != "")
+    {
+      if (tempDataPath[tempDataPath.size() - 1] != '/')
+        tempDataPath += "/";
+      Settings::tsetDataPath(tempDataPath);
+    }
+    // initialise TCL
+    TclBind::getInstance().setDataPath(Settings::getDataPath());
+    //if (mode_ == DEDICATED)
+      // TODO: decide what to do here
+    //else
+    // for playable server, client and standalone, the startup
+    // procedure until the GUI is identical
+    ogre_ = &GraphicsEngine::getSingleton();
+    if (!ogre_->setup())       // creates ogre root and other essentials
+      return false;
+    return true;
+  }
+  /**
+   * start modules
+   */
+  bool Orxonox::start()
+  {
+    if (mode_ == DEDICATED)
+    {
+      // do something else
+    }
+    else
+    { // not dedicated server
+      if (!ogre_->loadRenderer())    // creates the render window
+        return false;
+      // TODO: Spread this so that this call only initialises things needed for the Console
+      if (!ogre_->initialiseResources())
+        return false;
+      // Load the InGameConsole
+      InGameConsole::getInstance().initialise();
+      // Calls the InputManager which sets up the input devices.
+      // The render window width and height are used to set up the mouse movement.
+      if (!InputManager::initialise(ogre_->getWindowHandle(),
+            ogre_->getWindowWidth(), ogre_->getWindowHeight(), true, true, true))
+        return false;
+      // TOOD: load the GUI here
+      // set InputManager to GUI mode
+      InputManager::setInputState(InputManager::IS_GUI);
+      // TODO: run GUI here
+      // The following lines depend very much on the GUI output, so they're probably misplaced here..
+      InputManager::setInputState(InputManager::IS_NONE);
+      // create Ogre SceneManager
+      ogre_->createNewScene();
+      if (!loadPlayground())
+        return false;
+    }
+    switch (mode_)
+    {
+    case SERVER:
+      if (!serverLoad())
+        return false;
+      break;
+    case CLIENT:
+      if (!clientLoad())
+        return false;
+      break;
+    case DEDICATED:
+      if (!serverLoad())
+        return false;
+      break;
+    default:
+      if (!standaloneLoad())
+        return false;
+    }
+    InputManager::setInputState(InputManager::IS_NORMAL);
+    return startRenderLoop();
+      switch (mode.mode)
+      {
+      case GameMode::Server:
+        success &= serverLoad();
+        break;
+      case GameMode::Client:
+        success &= clientLoad();
+        break;
+      case GameMode::Dedicated:
+        success &= serverLoad();
+        break;
+      case GameMode::Standalone:
+        success &= standaloneLoad();
+        break;
+      default: // never happens
+          assert(false);
+      }
+      if (success)
+        InputManager::requestEnterState("game");
+      return success;
+  }
 …
   bool Orxonox::loadPlayground()
+  {
+    // Init audio
+    //auMan_ = new audio::AudioManager();
+    //auMan_->ambientAdd("a1");
+    //auMan_->ambientAdd("a2");
+    //auMan_->ambientAdd("a3");
+    //auMan->ambientAdd("ambient1");
+    //auMan_->ambientStart();
+    // Start the Radar
+    this->radar_ = new Radar();
     // Load the HUD
     COUT(3) << "Orxonox: Loading HUD" << std::endl;
     hud_ = new Level(Settings::getDataPath() + "overlay/hud.oxo");
+    Loader::load(hud_);
+    // Start the Radar
+    this->radar_ = new Radar();
+    return true;
+    return Loader::load(hud_);
+  }
+  /**
+   * Helper method to load a level.
+   */
+  bool Orxonox::loadScene()
+  {
+    COUT(0) << "Loading level..." << std::endl;
+    startLevel_ = new Level(Settings::getDataPath() + "levels/sample.oxw");
+    return Loader::open(startLevel_);
+  }
 …
     COUT(0) << "Loading level in server mode" << std::endl;
+    assert(Settings::getCommandLineArgument("port"));
+    int serverPort = Settings::getCommandLineArgument("port")->value_;
     //server_g = new network::Server(serverPort_);
     server_g = network::Server::createSingleton(serverPort_);
+    server_g = network::Server::createSingleton(serverPort);
     if (!loadScene())
 …
     COUT(0) << "Loading level in client mode" << std::endl;\
+    if (serverIp_.compare("") == 0)
+    assert(Settings::getCommandLineArgument("port"));
+    assert(Settings::getCommandLineArgument("ip"));
+    int serverPort = Settings::getCommandLineArgument("port")->value_;
+    std::string serverIP = Settings::getCommandLineArgument("ip")->value_;
+    if (serverIP.compare("") == 0)
       client_g = network::Client::createSingleton();
     else
+      client_g = network::Client::createSingleton(serverIp_, serverPort_);
+      client_g = network::Client::createSingleton(serverIP, serverPort);
     if(!client_g->establishConnection())
 …
   /**
-   * Helper method to load a level.
-   */
-  bool Orxonox::loadScene()
+  {
-    startLevel_ = new Level("levels/sample.oxw");
-    Loader::open(startLevel_);
-    return true;
+  }
-  /**
     Main loop of the orxonox game.
+    About the loop: The design is almost exactly like the one in ogre, so that
+    if any part of ogre registers a framelisteners, it will still behave
+    correctly. Furthermore the time smoothing feature from ogre has been
+    implemented too. If turned on (see orxonox constructor), it will calculate
+    the dt_n by means of the recent most dt_n-1, dt_n-2, etc.
+    We use the Ogre::Timer to measure time since it uses the most precise
+    method an a platform (however the windows timer lacks time when under
+    heavy kernel load!).
+    There is a simple mechanism to measure the average time spent in our
+    ticks as it may indicate performance issues.
+    A note about the Ogre::FrameListener: Even though we don't use them,
+    they still get called. However, the delta times are not correct (except
+    for timeSinceLastFrame, which is the most important). A little research
+    as shown that there is probably only one FrameListener that doesn't even
+    need the time. So we shouldn't run into problems.
   */
+  bool Orxonox::startRenderLoop()
+  {
+    // first check whether ogre root object has been created
+    if (Ogre::Root::getSingletonPtr() == 0)
+    {
+      COUT(2) << "Orxonox Error: Could not start rendering. No Ogre root object found" << std::endl;
+      return false;
+    }
+  void Orxonox::startRenderLoop()
+  {
     Ogre::Root& ogreRoot = Ogre::Root::getSingleton();
     // use the ogre timer class to measure time.
 …
     unsigned long frameCount = 0;
+    // TODO: this would very well fit into a configValue
+    const unsigned long refreshTime = 200000;
+    const unsigned long refreshTime = debugRefreshTime_ * 1000000.0f;
     unsigned long refreshStartTime = 0;
     unsigned long tickTime = 0;
 …
     unsigned long timeAfterTick = 0;
+    int sleepTime = 0;
+    // TODO: Update time in seconds every 7 seconds to avoid any overflow (7 secs is very tight)
     COUT(3) << "Orxonox: Starting the main loop." << std::endl;
+    try
+    {
     timer_->reset();
     while (!bAbort_)
+    {
+      // get current time
+      timeBeforeTickOld = timeBeforeTick;
+      timeBeforeTick    = timer_->getMicroseconds();
+      float dt = (timeBeforeTick - timeBeforeTickOld) / 1000000.0;
+      // tick the core (needs real time for input and tcl thread management)
+      Core::tick(dt);
+      // Call those objects that need the real time
+      for (Iterator<TickableReal> it = ObjectList<TickableReal>::start(); it; ++it)
+        it->tick(dt);
+      // Call the scene objects
+      for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
+        it->tick(dt * this->timefactor_);
+      // call server/client with normal dt
+      if (client_g)
+        client_g->tick(dt * this->timefactor_);
+      if (server_g)
+        server_g->tick(dt * this->timefactor_);
+      // get current time once again
+      timeAfterTick = timer_->getMicroseconds();
+      tickTime += timeAfterTick - timeBeforeTick;
+      if (timeAfterTick > refreshStartTime + refreshTime)
+      {
+        GraphicsEngine::getSingleton().setAverageTickTime(
+            (float)tickTime * 0.001 / (frameCount - oldFrameCount));
+        GraphicsEngine::getSingleton().setAverageFramesPerSecond(
+            (float)(frameCount - oldFrameCount) / (timeAfterTick - refreshStartTime) * 1000000.0);
+        oldFrameCount = frameCount;
+        tickTime = 0;
+        refreshStartTime = timeAfterTick;
+      }
+      // don't forget to call _fireFrameStarted in ogre to make sure
+      // everything goes smoothly
+      Ogre::FrameEvent evt;
+      evt.timeSinceLastFrame = dt;
+      evt.timeSinceLastEvent = dt; // note: same time, but shouldn't matter anyway
+      ogreRoot._fireFrameStarted(evt);
+      if (mode_ != DEDICATED)
+      {
+        // Pump messages in all registered RenderWindows
+        // This calls the WindowEventListener objects.
+        Ogre::WindowEventUtilities::messagePump();
+        // make sure the window stays active even when not focused
+        // (probably only necessary on windows)
+        GraphicsEngine::getSingleton().setWindowActivity(true);
+        // render
+        ogreRoot._updateAllRenderTargets();
+      }
+      // again, just to be sure ogre works fine
+      ogreRoot._fireFrameEnded(evt); // note: uses the same time as _fireFrameStarted
+      ++frameCount;
+    }
+    if (mode_ == CLIENT)
+      network::Client::getSingleton()->closeConnection();
+    else if (mode_ == SERVER)
+      server_g->close();
+    return true;
+        // get current time
+        timeBeforeTickOld = timeBeforeTick;
+        timeBeforeTick    = timer_->getMicroseconds();
+        float dt = (timeBeforeTick - timeBeforeTickOld) / 1000000.0;
+        // check whether we have to load a game
+        if (mode_.mode != modeRequest_.mode && mode_.mode == GameMode::Unspecified)
+        {
+            this->loadLevel(modeRequest_);
+            this->modeRequest_ = GameMode::GM_None;
+        }
+        // tick the core (needs real time for input and tcl thread management)
+        Core::tick(dt);
+        // Call those objects that need the real time
+        for (Iterator<TickableReal> it = ObjectList<TickableReal>::start(); it; ++it)
+          it->tick(dt);
+        // Call the scene objects
+        for (Iterator<Tickable> it = ObjectList<Tickable>::start(); it; ++it)
+          it->tick(dt * this->timefactor_);
+        // call server/client with normal dt
+        if (client_g)
+          client_g->tick(dt * this->timefactor_);
+        if (server_g)
+          server_g->tick(dt * this->timefactor_);
+        // get current time once again
+        timeAfterTick = timer_->getMicroseconds();
+        tickTime += timeAfterTick - timeBeforeTick;
+        if (timeAfterTick > refreshStartTime + refreshTime)
+        {
+          GraphicsEngine::getSingleton().setAverageTickTime(
+              (float)tickTime * 0.001 / (frameCount - oldFrameCount));
+          float avgFPS = (float)(frameCount - oldFrameCount) / (timeAfterTick - refreshStartTime) * 1000000.0;
+          GraphicsEngine::getSingleton().setAverageFramesPerSecond(avgFPS);
+          if (avgFPS > 60.0)
+            sleepTime++;
+          else
+            sleepTime--;
+          if (sleepTime < 0)
+              sleepTime = 0;
+          oldFrameCount = frameCount;
+          tickTime = 0;
+          refreshStartTime = timeAfterTick;
+        }
+        // do some sleeping when the frameRate is over 60
+        if (sleepTime > 0)
+          msleep(sleepTime);
+        // don't forget to call _fireFrameStarted in ogre to make sure
+        // everything goes smoothly
+        Ogre::FrameEvent evt;
+        evt.timeSinceLastFrame = dt;
+        evt.timeSinceLastEvent = dt; // note: same time, but shouldn't matter anyway
+        ogreRoot._fireFrameStarted(evt);
+        if (mode_.showsGraphics)
+        {
+          // Pump messages in all registered RenderWindows
+          // This calls the WindowEventListener objects.
+          Ogre::WindowEventUtilities::messagePump();
+          // make sure the window stays active even when not focused
+          // (probably only necessary on windows)
+          GraphicsEngine::getSingleton().setWindowActivity(true);
+          // tick CEGUI
+          GUIManager::getInstance().tick(dt);
+          // render
+          ogreRoot._updateAllRenderTargets();
+        }
+        // again, just to be sure ogre works fine
+        ogreRoot._fireFrameEnded(evt); // note: uses the same time as _fireFrameStarted
+        ++frameCount;
+    }
+    }
+    catch (std::exception& ex)
+    {
+      // something went wrong.
+      COUT(1) << ex.what() << std::endl;
+      COUT(1) << "Main loop was stopped by an unhandled exception. Shutting down." << std::endl;
+    }
+  }
+}

code/branches/gui/src/orxonox/Orxonox.h

-                      r1625
+                      r1638
  *   Author:
  *      Reto Grieder
+ *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
  *   Co-authors:
  *      Benjamin Knecht <beni_at_orxonox.net>, (C) 2007
+ *      ...
+ *
  */
 …
 #include <OgrePrerequisites.h>
+#include "core/OrxonoxClass.h"
 #include "audio/AudioPrereqs.h"
+#include "GraphicsEngine.h"
+#include "Settings.h"
+#include "GraphicsEngine.h"
+namespace orxonox {
+  enum gameMode{
+    SERVER,
+    CLIENT,
+    STANDALONE,
+    DEDICATED
+  };
+namespace orxonox
+{
   //! Orxonox singleton class
   class _OrxonoxExport Orxonox
+    class _OrxonoxExport Orxonox : public OrxonoxClass
+  {
     public:
+      bool init(int argc, char **argv);
+      bool start();
+      Orxonox();
+      ~Orxonox();
+      void start();
+      void setConfigValues();
       void abortRequest();
+      static Orxonox* getSingleton();
+      static void destroySingleton();
+      static Orxonox& getSingleton();
+      static inline void slomo(float factor) { Orxonox::setTimeFactor(factor); }
+      static void slomo(float factor) { Orxonox::setTimeFactor(factor); }
+      static float getTimeFactor()    { return Orxonox::getSingleton().timefactor_; }
+      static void loadGame(const std::string& name);
+      static void exit()              { Orxonox::getSingleton().abortRequest(); }
       static void setTimeFactor(float factor = 1.0);
-      static inline float getTimeFactor() { return Orxonox::getSingleton()->timefactor_; }
-      static inline void exit() { Orxonox::getSingleton()->abortRequest(); }
    private:
       // don't mess with singletons
-      Orxonox();
       Orxonox(Orxonox& instance);
-      Orxonox& operator=(const Orxonox& instance);
-      ~Orxonox();
+      bool loadPlayground();
+      bool loadLevel(const GameMode& mode);
       bool serverLoad();
       bool clientLoad();
       bool standaloneLoad();
+      bool loadPlayground();
       bool loadScene();
+      bool startRenderLoop();
+      float calculateEventTime(unsigned long, std::deque<unsigned long>&);
+      void startRenderLoop();
     private:
 …
       // this is used to identify the mode (server/client/...) we're in
+      gameMode              mode_;
+      std::string           serverIp_;
+      int                   serverPort_;
+      GameMode              mode_;
+      GameMode              modeRequest_;
+      // config values
+      float                 debugRefreshTime_;
       static Orxonox *singletonRef_s;

code/branches/gui/src/orxonox/OrxonoxStableHeaders.h

-                      r1631
+                      r1638
 #  define WIN32_LEAN_AND_MEAN
 #endif
+// not including the entire Ogre.h doesn't exceed the default heap size for pch
+//#include <Ogre.h>
+#include <OgreBillboardSet.h>
+#include <OgreCamera.h>
+#include <OgreColourValue.h>
+#include <OgreConfigFile.h>
+#include <OgreEntity.h>
+#include <OgreException.h>
+#include <OgreFrameListener.h>
+#include <OgreLight.h>
+#include <OgreLog.h>
+#include <OgreLogManager.h>
+#include <OgreMath.h>
+#include <OgreMatrix3.h>
+#include <OgreMatrix4.h>
+#include <OgreMesh.h>
+#include <OgreOverlay.h>
+#include <OgreOverlayElement.h>
+#include <OgreOverlayManager.h>
+#include <OgreParticleEmitter.h>
+#include <OgreParticleSystem.h>
+#include <OgreQuaternion.h>
+#include <OgreResourceGroupManager.h>
+#include <OgreRenderWindow.h>
+#include <OgreRoot.h>
+#include <OgreSceneManager.h>
+#include <OgreSceneNode.h>
+#include <OgreString.h>
+#include <OgreStringConverter.h>
+#include <OgreTextureManager.h>
+#include <OgreTimer.h>
+#include <OgreVector2.h>
+#include <OgreVector3.h>
+#include <OgreVector3.h>
+#include <OgreViewport.h>
+#include <OgreWindowEventUtilities.h>
+#include <Ogre.h>
+#include <CEGUI.h>
+#include <boost/thread/recursive_mutex.hpp>
 //-----------------------------------------------------------------------
 …
 //-----------------------------------------------------------------------
-#include "ois/OIS.h"
-#include "cpptcl/CppTcl.h"
 #include "tinyxml/ticpp.h"
 #include "tinyxml/tinyxml.h"
 …
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
+#include "core/CommandExecutor.h"
 #include "core/Debug.h"
+#include "core/Executor.h"
 #include "core/OutputBuffer.h"
 #include "core/OutputHandler.h"
-#include "core/Executor.h"
 #include "core/XMLPort.h"

code/branches/gui/src/orxonox/Radar.cc

-                      r1625
+                      r1638
 #include "OrxonoxStableHeaders.h"
 #include "Radar.h"
+#include <float.h>
+#include <cfloat>
+#include <cassert>
 #include "objects/WorldEntity.h"
 #include "objects/SpaceShip.h"

code/branches/gui/src/orxonox/RadarViewable.h

r1625	r1638
32	32	#include "OrxonoxPrereqs.h"
33	33	#include <string>
	34	#include <cassert>
34	35	#include "util/Math.h"
35	36	#include "core/Debug.h"

code/branches/gui/src/orxonox/Settings.cc

-                      r1535
+                      r1638
 /**
+    @file
+    @brief Implementation of the Settings class.
+@file
+@brief
+    Implementation of the Settings class.
 */
 …
 #include "Settings.h"
+#include "util/String.h"
 #include "core/CoreIncludes.h"
 #include "core/ConfigValueIncludes.h"
 …
 namespace orxonox
+{
-  /**
-    @brief Constructor: Registers the object and sets the config-values.
-  */
-  Settings::Settings()
+  {
-    RegisterRootObject(Settings);
-    setConfigValues();
+  }
+  Settings::~Settings()
+  {
+  }
+// Using a macro makes the above list much more readable.
+// Settings::addGameMode adds the mode in a map, so we can access game modes by string.
+#define CreateGameMode(name, showsGraphics, isMaster, hasServer)                                        \
+    const GameMode GameMode::GM_##name = { GameMode::name, showsGraphics, isMaster, hasServer, #name }; \
+    bool temporaryVariable##name = Settings::addGameMode(&GameMode::GM_##name)
+  /**
+    @brief Returns a unique instance of Core.
+    @return The instance
+  */
+  Settings& Settings::getSingleton()
+  {
+    static Settings instance;
+    return instance;
+  }
+    //                          showsGraphics  isMaster  hasServer
+    CreateGameMode(None,        false,         false,    false);
+    CreateGameMode(Unspecified, true,          false,    false);
+    CreateGameMode(Server,      true,          true,     true );
+    CreateGameMode(Client,      true,          false,    false);
+    CreateGameMode(Standalone,  true,          true,     false);
+    CreateGameMode(Dedicated,   false,         true,     true );
+  /**
+    @brief Function to collect the SetConfigValue-macro calls.
+  */
+  void Settings::setConfigValues()
+  {
+    SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.");
+    if (dataPath_ != "" && dataPath_[dataPath_.size() - 1] != '/')
+    /**
+    @brief
+        Constructor: Registers the object and sets the config-values.
+    */
+    Settings::Settings()
+    {
+      ModifyConfigValue(dataPath_, set, dataPath_ + "/");
+        RegisterRootObject(Settings);
+        gameMode_ = GameMode::GM_Unspecified;
+        setConfigValues();
+    }
+    if (dataPath_ == "")
+    /**
+    @brief
+        Returns a unique instance of Core.
+    @return
+        The instance
+    */
+    Settings& Settings::getInstance()
+    {
       ModifyConfigValue(dataPath_, set, "/");
       COUT(2) << "Warning: Data path set to \"/\", is that really correct?" << std::endl;
+        static Settings instance;
+        return instance;
+    }
+  }
+  /**
+    @brief Temporary sets the data path
+    @param path The new data path
+  */
+  void Settings::_tsetDataPath(const std::string& path)
+  {
+    ModifyConfigValue(dataPath_, tset, path);
+  }
+    /**
+    @brief
+        Function to collect the SetConfigValue-macro calls.
+    */
+    void Settings::setConfigValues()
+    {
+        SetConfigValue(dataPath_, "../../Media/").description("Relative path to the game data.");
+        if (dataPath_ != "" && dataPath_[dataPath_.size() - 1] != '/')
+        {
+            ModifyConfigValue(dataPath_, set, dataPath_ + "/");
+        }
+  /*static*/ void Settings::tsetDataPath(const std::string& path)
+  {
+    getSingleton()._tsetDataPath(path);
+  }
+        if (dataPath_ == "")
+        {
+            ModifyConfigValue(dataPath_, set, "/");
+            COUT(2) << "Warning: Data path set to \"/\", is that really correct?" << std::endl;
+        }
+    }
+  /**
+    @brief Returns the relative path to the game data.
+    @return The path to the game data
+  */
+  /*static*/ const std::string& Settings::getDataPath()
+  {
+    return getSingleton().dataPath_;
+  }
+    /**
+    @brief
+        Temporary sets the data path
+    @param path
+        The new data path
+    */
+    void Settings::_tsetDataPath(const std::string& path)
+    {
+        ModifyConfigValue(dataPath_, tset, path);
+    }
+    /**
+    @brief
+        Sets the game mode.
+    */
+    /*static*/ void Settings::setGameMode(const std::string& mode)
+    {
+        std::string modeL = getLowercase(mode);
+        std::map<std::string, const GameMode*>::const_iterator it = getInstance().gameModes_.find(modeL);
+        if (it != getInstance().gameModes_.end())
+            getInstance().gameMode_ = *(*it).second;
+        else
+        {
+            COUT(2) << "Warning: mode \"" << mode << "\" doesn't exist. "
+                    << "Defaulting to 'Standalone'" << std::endl;
+            getInstance().gameMode_ = GameMode::GM_Standalone;
+        }
+    }
+    /*static*/ bool Settings::addGameMode(const GameMode* mode)
+    {
+        getInstance().gameModes_[getLowercase(mode->name)] = mode;
+        return true;
+    }
+    /**
+    @brief
+        Gets an argument from the command line by name.
+    @return
+        Is 0 if name was not found.
+    */
+    /*static*/ const Settings::CommandLineArgument* Settings::getCommandLineArgument(const std::string &name)
+    {
+        std::map<std::string, CommandLineArgument>::const_iterator it = getInstance().commandArguments_.find(name);
+        if (it != getInstance().commandArguments_.end())
+        {
+            return &((*it).second);
+        }
+        else
+            return 0;
+    }
+}

code/branches/gui/src/orxonox/Settings.h

-                      r1535
+                      r1638
 /**
     @file Core.h
     @brief Definition of the Settings class.
+    @brief Declaration of the Settings class.
     The static Settings class is only used to configure some variables
 …
 #include <string>
 #include "core/OrxonoxClass.h"
+#include "core/Debug.h"
+#include "util/MultiTypeMath.h"
+#include "util/Convert.h"
 namespace orxonox
+{
+  class _OrxonoxExport Settings : public OrxonoxClass
+  {
+    /**
+    @brief
+        Defines a bit field structure that holds the mode as enum plus
+        the attributes as single named bits.
+        Every different GameMode is stored as static const, but if you wish to
+        compare two modes, you will have to use the 'mode' member variable.
+    */
+    struct GameMode
+    {
+        enum Mode
+        {
+            None,
+            Unspecified,
+            Server,
+            Client,
+            Standalone,
+            Dedicated,
+        };
+        Mode mode;
+        bool showsGraphics;
+        bool isMaster;
+        bool hasServer;
+        std::string name;
+        static const GameMode GM_None;
+        static const GameMode GM_Unspecified;
+        static const GameMode GM_Server;
+        static const GameMode GM_Client;
+        static const GameMode GM_Standalone;
+        static const GameMode GM_Dedicated;
+    };
+    class _OrxonoxExport Settings : public OrxonoxClass
+    {
     public:
+      void setConfigValues();
+        struct CommandLineArgument
+        {
+            std::string name_;
+            MultiTypeMath value_;
+            bool bHasDefaultValue_;
+        };
       static const std::string& getDataPath();
+        void setConfigValues();
+      static void tsetDataPath(const std::string& path);
+        static const std::string& getDataPath();
+        static void tsetDataPath(const std::string& path);
+        static const GameMode& getGameMode();
+        static const GameMode& getGameMode(const std::string& name);
+        static void setGameMode(const GameMode& mode);
+        static void setGameMode(const std::string& mode);
+        static bool addGameMode(const GameMode* mode);
+        static const CommandLineArgument* getCommandLineArgument(const std::string& name);
+        template <class T>
+        static bool addCommandLineArgument(const std::string &name, const std::string& valueStr, const T& defaultValue);
     private:
       Settings();
       Settings(const Settings& instance);
       ~Settings();
       static Settings& getSingleton();
+        Settings();
+        Settings(const Settings& instance);
+        ~Settings() { }
+        static Settings& getInstance();
       void _tsetDataPath(const std::string& path);
+        void _tsetDataPath(const std::string& path);
+      std::string dataPath_;               //!< Path to the game data
+  };
+        std::string dataPath_;                                        //!< Path to the game data
+        GameMode gameMode_;                                           //!< Current game mode
+        std::map<std::string, const GameMode*> gameModes_;            //!< Holds all game modes for easy string access
+        //! holds all command line arguments (even if not given!)
+        std::map<std::string, CommandLineArgument> commandArguments_;
+    };
+    /**
+    @brief
+        Returns the relative path to the game data.
+    */
+    inline const std::string& Settings::getDataPath()
+    {
+        return getInstance().dataPath_;
+    }
+    inline void Settings::tsetDataPath(const std::string& path)
+    {
+        getInstance()._tsetDataPath(path);
+    }
+    inline const GameMode& Settings::getGameMode()
+    {
+        return getInstance().gameMode_;
+    }
+    inline const GameMode& Settings::getGameMode(const std::string& name)
+    {
+        if (getInstance().gameModes_.find(name) != getInstance().gameModes_.end())
+            return *getInstance().gameModes_[name];
+        else
+        {
+            COUT(2) << "Warning: GameMode '" << name << "' doesn't exist." << std::endl;
+            return GameMode::GM_None;
+        }
+    }
+    inline void Settings::setGameMode(const GameMode& mode)
+    {
+        getInstance().gameMode_ = mode;
+    }
+    /**
+    @brief
+        Adds one argument of the command line to the map of command line arguments.
+    @param name
+        Name of the command line option.
+    @param valueStr
+        The value of the command line option as string
+    @param defaultValue
+        Default value for the option (marked when used).
+    @return
+        Dummy return value to enable code execution before main().
+    */
+    template <class T>
+    bool Settings::addCommandLineArgument(const std::string &name, const std::string& valueStr, const T& defaultValue)
+    {
+        T value;
+        bool useDefault = false;
+        if (valueStr == "")
+        {
+            // note: ArgReader only returns "" for not found arguments, " " otherwise for empty ones.
+            value = defaultValue;
+            useDefault = true;
+        }
+        else if (!convertValue(&value, valueStr))
+        {
+            COUT(1) << "Command Line: Couldn't read option '" << name << "'." << std::endl;
+            return false;
+        }
+        CommandLineArgument arg = { name, MultiTypeMath(value), useDefault };
+        getInstance().commandArguments_[name] = arg;
+        return true;
+    }
+}

code/branches/gui/src/orxonox/objects/Ambient.cc

r1625	r1638
65	65
66	66	bool Ambient::create(){
67		GraphicsEngine::getSingleton().getSceneManager()->setAmbientLight(ambientLight_);
	67	GraphicsEngine::getSingleton().getLevelSceneManager()->setAmbientLight(ambientLight_);
68	68	return Synchronisable::create();
69	69	}
…	…
76	76	void Ambient::setAmbientLight(const ColourValue& colour)
77	77	{
78		~~GraphicsEngine::getSingleton().get~~SceneManager()->setAmbientLight(colour);
	78	GraphicsEngine::getSingleton().getLevelSceneManager()->setAmbientLight(colour);
79	79	ambientLight_=colour;
80	80	}

code/branches/gui/src/orxonox/objects/Backlight.cc

-                      r1608
+                      r1638
         this->attachObject(this->billboard_.getBillboardSet());
         this->ribbonTrail_ = GraphicsEngine::getSingleton().getSceneManager()->createRibbonTrail(this->getName() + "RibbonTrail");
         this->ribbonTrailNode_ = GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName() + "RibbonTrailNode");
+        this->ribbonTrail_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createRibbonTrail(this->getName() + "RibbonTrail");
+        this->ribbonTrailNode_ = GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName() + "RibbonTrailNode");
         this->ribbonTrailNode_->attachObject(this->ribbonTrail_);
         this->ribbonTrail_->addNode(this->getNode());
 …
         this->ribbonTrail_->setMaterialName("Trail/backlighttrail");
         this->setTimeFactor(Orxonox::getSingleton()->getTimeFactor());
+        this->setTimeFactor(Orxonox::getSingleton().getTimeFactor());
+    }
 …
+        {
             this->detachObject(this->billboard_.getBillboardSet());
             GraphicsEngine::getSingleton().getSceneManager()->destroySceneNode(this->getName() + "RibbonTrailNode");
             GraphicsEngine::getSingleton().getSceneManager()->destroyRibbonTrail(this->ribbonTrail_);
+            GraphicsEngine::getSingleton().getLevelSceneManager()->destroySceneNode(this->getName() + "RibbonTrailNode");
+            GraphicsEngine::getSingleton().getLevelSceneManager()->destroyRibbonTrail(this->ribbonTrail_);
+        }
+    }

code/branches/gui/src/orxonox/objects/Camera.cc

r1505	r1638
52	52	{
53	53	this->bHasFocus_ = false;
54		this->cameraNode_ = GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->createChildSceneNode(node->getName() + "Camera");
	54	this->cameraNode_ = GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(node->getName() + "Camera");
55	55	if( node != NULL )
56	56	this->setPositionNode(node);
…	…
60	60	{
61	61	CameraHandler::getInstance()->releaseFocus(this);
62		GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
	62	GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->removeAndDestroyChild(cameraNode_->getName());
63	63	}
64	64

code/branches/gui/src/orxonox/objects/CameraHandler.cc

-                      r1505
+                      r1638
   CameraHandler::CameraHandler()
+  {
+    this->cam_ = GraphicsEngine::getSingleton().getSceneManager()->createCamera("Cam");
+    GraphicsEngine::getSingleton().getRenderWindow()->addViewport(this->cam_);
+    this->cam_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createCamera("Cam");
+    GraphicsEngine::getSingleton().getLevelViewport()->setCamera(this->cam_);
+    GraphicsEngine::getSingleton().getRenderWindow()->addViewport(this->cam_, 2, 0.4, 0.4, 0.2, 0.2);
     /*this->activeCamera_ = *ObjectList<Camera>::begin();
     this->activeCamera_->cam_ = this->cam_;*/

code/branches/gui/src/orxonox/objects/ParticleSpawner.cc

r1608	r1638
79	79	this->setPosition(this->getNode()->getParent()->getPosition());
80	80	this->getNode()->getParent()->removeChild(this->getNode());
81		GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->addChild(this->getNode());
	81	GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->addChild(this->getNode());
82	82	if (this->particle_)
83	83	this->particle_->setEnabled(false);

code/branches/gui/src/orxonox/objects/Projectile.cc

r1602	r1638
75	75	SetConfigValue(speed_, 5000.0).description("The speed of a projectile in units per second");
76	76
77		if(this->owner_)
	77	if(this->owner_)
78	78	this->setVelocity(this->owner_->getInitialDir() * this->speed_);
79	79	}

code/branches/gui/src/orxonox/objects/Skybox.cc

r1558	r1638
56	56	void Skybox::setSkybox(const std::string& skyboxname)
57	57	{
58		~~GraphicsEngine::getSingleton().get~~SceneManager()->setSkyBox(true, skyboxname);
	58	GraphicsEngine::getSingleton().getLevelSceneManager()->setSkyBox(true, skyboxname);
59	59	}
60	60
…	…
92	92	{
93	93	BaseObject::changedVisibility();
94		GraphicsEngine::getSingleton().getSceneManager()->setSkyBox(this->isVisible(), this->skyboxSrc_);
	94	GraphicsEngine::getSingleton().getLevelSceneManager()->setSkyBox(this->isVisible(), this->skyboxSrc_);
95	95	}
96	96	}

code/branches/gui/src/orxonox/objects/Tickable.h

r1535	r1638
29	29	/*!
30	30	@file Tickable.h
31		@brief De~~fini~~tion of the Tickable interface.
	31	@brief Declaration of the Tickable interface.
32	32
33	33	The Tickable interface provides a tick(dt) function, that gets called every frame.

code/branches/gui/src/orxonox/objects/WorldEntity.cc

r1625	r1638
49	49	RegisterObject(WorldEntity);
50	50
51		if (GraphicsEngine::getSingleton().getSceneManager())
	51	if (GraphicsEngine::getSingleton().getLevelSceneManager())
52	52	{
53	53	std::ostringstream name;
54	54	name << (WorldEntity::worldEntityCounter_s++);
55	55	this->setName("WorldEntity" + name.str());
56		this->node_ = GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName());
	56	this->node_ = GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->createChildSceneNode(this->getName());
57	57
58	58	registerAllVariables();
…	…
77	77	{
78	78	this->getNode()->removeAndDestroyAllChildren();
79		GraphicsEngine::getSingleton().getSceneManager()->destroySceneNode(this->getName());
	79	GraphicsEngine::getSingleton().getLevelSceneManager()->destroySceneNode(this->getName());
80	80	}
81	81	}
…	…
178	178	void WorldEntity::attachObject(const WorldEntity& obj) const
179	179	{
180		GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->removeChild(obj.getNode());
	180	GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->removeChild(obj.getNode());
181	181	this->getNode()->addChild(obj.getNode());
182	182	}
…	…
184	184	void WorldEntity::attachObject(WorldEntity* obj) const
185	185	{
186		GraphicsEngine::getSingleton().getSceneManager()->getRootSceneNode()->removeChild(obj->getNode());
	186	GraphicsEngine::getSingleton().getLevelSceneManager()->getRootSceneNode()->removeChild(obj->getNode());
187	187	this->getNode()->addChild(obj->getNode());
188	188	}

code/branches/gui/src/orxonox/overlays/console/InGameConsole.cc

-                      r1633
+                      r1638
         @brief Constructor: Creates and initializes the InGameConsole.
     */
+    InGameConsole::InGameConsole() :
+        consoleOverlay_(0), consoleOverlayContainer_(0),
+        consoleOverlayNoise_(0), consoleOverlayCursor_(0), consoleOverlayBorder_(0),
+        consoleOverlayTextAreas_(0)
+    InGameConsole::InGameConsole()
+        : consoleOverlay_(0)
+        , consoleOverlayContainer_(0)
+        , consoleOverlayNoise_(0)
+        , consoleOverlayCursor_(0)
+        , consoleOverlayBorder_(0)
+        , consoleOverlayTextAreas_(0)
+        , emptySceneManager_(0)
+        , emptyCamera_(0)
+        , viewport_(0)
+    {
         RegisterObject(InGameConsole);
 …
         Shell::getInstance().addOutputLevel(true);
+        // create a sceneManager in order to render in our own viewport
+        this->emptySceneManager_ = Ogre::Root::getSingleton()
+            .createSceneManager(Ogre::ST_GENERIC, "Console/EmptySceneManager");
+        this->emptyCamera_ = this->emptySceneManager_->createCamera("Console/EmptyCamera");
+        this->viewport_ = GraphicsEngine::getSingleton().getRenderWindow()->addViewport(emptyCamera_, 10);
+        this->viewport_->setOverlaysEnabled(true);
+        this->viewport_->setClearEveryFrame(false);
         COUT(4) << "Info: InGameConsole initialized" << std::endl;
 …
+        {
             this->bActive_ = true;
             InputManager::setInputState(InputManager::IS_CONSOLE);
+            InputManager::requestEnterState("console");
             Shell::getInstance().registerListener(this);
 …
+        {
             this->bActive_ = false;
             InputManager::setInputState(InputManager::IS_NORMAL);
+            InputManager::requestLeaveState("console");
             Shell::getInstance().unregisterListener(this);

code/branches/gui/src/orxonox/overlays/console/InGameConsole.h

-                      r1625
+                      r1638
     class _OrxonoxExport InGameConsole : public TickableReal, public ShellListener, public WindowEventListener
+    {
         public: // functions
             void initialise();
             void destroy();
             void setConfigValues();
+    public: // functions
+        void initialise();
+        void destroy();
+        void setConfigValues();
             void tick(float dt);
+        void tick(float dt);
             static InGameConsole& getInstance();
+        static InGameConsole& getInstance();
             static void openConsole();
             static void closeConsole();
+        static void openConsole();
+        static void closeConsole();
         private: // functions
             InGameConsole();
             InGameConsole(const InGameConsole& other) {}
             ~InGameConsole();
+    private: // functions
+        InGameConsole();
+        InGameConsole(const InGameConsole& other) {}
+        ~InGameConsole();
             void activate();
             void deactivate();
+        void activate();
+        void deactivate();
             void linesChanged();
             void onlyLastLineChanged();
             void lineAdded();
             void inputChanged();
             void cursorChanged();
             void exit();
+        void linesChanged();
+        void onlyLastLineChanged();
+        void lineAdded();
+        void inputChanged();
+        void cursorChanged();
+        void exit();
             void shiftLines();
             void colourLine(int colourcode, int index);
             void setCursorPosition(unsigned int pos);
             void print(const std::string& text, int index, bool alwaysShift = false);
+        void shiftLines();
+        void colourLine(int colourcode, int index);
+        void setCursorPosition(unsigned int pos);
+        void print(const std::string& text, int index, bool alwaysShift = false);
             void windowResized(int newWidth, int newHeight);
+        void windowResized(int newWidth, int newHeight);
             static Ogre::UTFString convert2UTF(std::string s);
+        static Ogre::UTFString convert2UTF(std::string s);
         private: // variables
             bool bActive_;
             int windowW_;
             int windowH_;
             int desiredTextWidth_;
             unsigned int maxCharsPerLine_;
             unsigned int numLinesShifted_;
             int scroll_;
             float cursor_;
             unsigned int inputWindowStart_;
             bool bShowCursor_;
             std::string displayedText_;
             Ogre::Overlay* consoleOverlay_;
             Ogre::OverlayContainer* consoleOverlayContainer_;
             Ogre::PanelOverlayElement* consoleOverlayNoise_;
             Ogre::TextAreaOverlayElement* consoleOverlayCursor_;
             Ogre::BorderPanelOverlayElement* consoleOverlayBorder_;
             Ogre::TextAreaOverlayElement** consoleOverlayTextAreas_;
+    private: // variables
+        bool bActive_;
+        int windowW_;
+        int windowH_;
+        int desiredTextWidth_;
+        unsigned int maxCharsPerLine_;
+        unsigned int numLinesShifted_;
+        int scroll_;
+        float cursor_;
+        unsigned int inputWindowStart_;
+        bool bShowCursor_;
+        std::string displayedText_;
+        Ogre::Overlay* consoleOverlay_;
+        Ogre::OverlayContainer* consoleOverlayContainer_;
+        Ogre::PanelOverlayElement* consoleOverlayNoise_;
+        Ogre::TextAreaOverlayElement* consoleOverlayCursor_;
+        Ogre::BorderPanelOverlayElement* consoleOverlayBorder_;
+        Ogre::TextAreaOverlayElement** consoleOverlayTextAreas_;
+            // config values
+            float relativeWidth;
+            float relativeHeight;
+            float blinkTime;
+            float scrollSpeed_;
+            float noiseSize_;
+            char cursorSymbol_;
+        Ogre::SceneManager* emptySceneManager_;     //!< dummy SceneManager to render overlays in empty windows
+        Ogre::Camera*       emptyCamera_;           //!< dummy camera to render overlays in empty windows
+        Ogre::Viewport*     viewport_;
+        // config values
+        float relativeWidth;
+        float relativeHeight;
+        float blinkTime;
+        float scrollSpeed_;
+        float noiseSize_;
+        char cursorSymbol_;
     };
+}

code/branches/gui/src/orxonox/overlays/hud/HUDSpeedBar.cc

r1626	r1638
54	54	float v = ship->getVelocity().length();
55	55	float value = v / ship->getMaxSpeed();
56		if (value != this->getValue())
	56	if (value != this->getValue())
57	57	this->setValue(value);
58	58	}

code/branches/gui/src/orxonox/tolua/tolua.pkg

r1505	r1638
	1	$cfile "../../src/orxonox/gui/GUIManager.h"

code/branches/gui/src/orxonox/tools/BillboardSet.cc

-                      r1602
+                      r1638
         std::ostringstream name;
         name << (BillboardSet::billboardSetCounter_s++);
         this->billboardSet_ = GraphicsEngine::getSingleton().getSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
         this->billboardSet_->createBillboard(Vector3::ZERO);
         this->billboardSet_->setMaterialName(file);
 …
         std::ostringstream name;
         name << (BillboardSet::billboardSetCounter_s++);
         this->billboardSet_ = GraphicsEngine::getSingleton().getSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
         this->billboardSet_->createBillboard(Vector3::ZERO, colour);
         this->billboardSet_->setMaterialName(file);
 …
         std::ostringstream name;
         name << (BillboardSet::billboardSetCounter_s++);
         this->billboardSet_ = GraphicsEngine::getSingleton().getSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
         this->billboardSet_->createBillboard(position);
         this->billboardSet_->setMaterialName(file);
 …
         std::ostringstream name;
         name << (BillboardSet::billboardSetCounter_s++);
         this->billboardSet_ = GraphicsEngine::getSingleton().getSceneManager()->createBillboardSet("Billboard" + name.str(), count);
+        this->billboardSet_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createBillboardSet("Billboard" + name.str(), count);
         this->billboardSet_->createBillboard(position, colour);
         this->billboardSet_->setMaterialName(file);
 …
+    {
         if (this->billboardSet_)
             GraphicsEngine::getSingleton().getSceneManager()->destroyBillboardSet(this->billboardSet_);
+            GraphicsEngine::getSingleton().getLevelSceneManager()->destroyBillboardSet(this->billboardSet_);
+    }
+}

code/branches/gui/src/orxonox/tools/Light.cc

r1505	r1638
49	49	std::ostringstream name;
50	50	name << (Light::lightCounter_s++);
51		this->light_ = GraphicsEngine::getSingleton().getSceneManager()->createLight("Light" + name.str());
	51	this->light_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createLight("Light" + name.str());
52	52	this->light_->setType(type);
53	53	this->light_->setDiffuseColour(diffuse);
…	…
58	58	{
59	59	if (this->light_)
60		GraphicsEngine::getSingleton().getSceneManager()->destroyLight(this->light_);
	60	GraphicsEngine::getSingleton().getLevelSceneManager()->destroyLight(this->light_);
61	61	}
62	62	}

code/branches/gui/src/orxonox/tools/Mesh.cc

r1505	r1638
49	49	std::ostringstream name;
50	50	name << (Mesh::meshCounter_s++);
51		this->entity_ = GraphicsEngine::getSingleton().getSceneManager()->createEntity("Mesh" + name.str(), file);
	51	this->entity_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createEntity("Mesh" + name.str(), file);
52	52	}
53	53
…	…
55	55	{
56	56	if (this->entity_)
57		GraphicsEngine::getSingleton().getSceneManager()->destroyEntity(this->entity_);
	57	GraphicsEngine::getSingleton().getLevelSceneManager()->destroyEntity(this->entity_);
58	58	}
59	59	}

code/branches/gui/src/orxonox/tools/ParticleInterface.cc

r1563	r1638
55	55	this->bEnabled_ = true;
56	56	this->detaillevel_ = (unsigned int)detaillevel;
57		this->particleSystem_ = GraphicsEngine::getSingleton().getSceneManager()->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
58		this->particleSystem_->setSpeedFactor(Orxonox::getSingleton()->getTimeFactor());
	57	this->particleSystem_ = GraphicsEngine::getSingleton().getLevelSceneManager()->createParticleSystem("particles" + getConvertedValue<unsigned int, std::string>(ParticleInterface::counter_s++), templateName);
	58	this->particleSystem_->setSpeedFactor(Orxonox::getSingleton().getTimeFactor());
59	59
60	60	if (GraphicsEngine::getSingleton().getDetailLevelParticle() < (unsigned int)this->detaillevel_)
…	…
72	72	{
73	73	this->particleSystem_->removeAllEmitters();
74		GraphicsEngine::getSingleton().getSceneManager()->destroyParticleSystem(particleSystem_);
	74	GraphicsEngine::getSingleton().getLevelSceneManager()->destroyParticleSystem(particleSystem_);
75	75	}
76	76
…	…
171	171	void ParticleInterface::setSpeedFactor(float factor)
172	172	{
173		this->particleSystem_->setSpeedFactor(Orxonox::getSingleton()->getTimeFactor() * factor);
	173	this->particleSystem_->setSpeedFactor(Orxonox::getSingleton().getTimeFactor() * factor);
174	174	}
175	175	float ParticleInterface::getSpeedFactor() const
176	176	{
177		return (this->particleSystem_->getSpeedFactor() / Orxonox::getSingleton()->getTimeFactor());
	177	return (this->particleSystem_->getSpeedFactor() / Orxonox::getSingleton().getTimeFactor());
178	178	}
179	179

code/branches/gui/src/orxonox/tools/WindowEventListener.h

-                      r1625
+                      r1638
         virtual ~WindowEventListener() { }
                     /** Window has moved position */
                     virtual void windowMoved() { }
+            /** Window has moved position */
+            virtual void windowMoved() { }
                     /** Window has resized */
                     virtual void windowResized(int newWidth, int newHeight) { }
+            /** Window has resized */
+            virtual void windowResized(int newWidth, int newHeight) { }
                     /** Window has lost/gained focus */
                     virtual void windowFocusChanged() { }
+            /** Window has lost/gained focus */
+            virtual void windowFocusChanged() { }
     };
+}

code/branches/gui/src/tolua/tolua++.h

-                      r1505
+                      r1638
 #define TOLUA_H
+/* original code */
+/*
 #ifndef TOLUA_API
 #define TOLUA_API extern
 #endif
+*/
+/********************************
+******* ORXONOX CHANGES *********
+********************************/
+#if (defined( __WIN32__ ) || defined( _WIN32 )) && !defined( TOLUA_STATIC_BUILD )
+#  ifdef TOLUA_SHARED_BUILD
+#    define TOLUA_API __declspec(dllexport)
+#  else
+#    if defined( __MINGW32__ )
+#      define TOLUA_API
+#    else
+#      define TOLUA_API __declspec(dllimport)
+#    endif
+#  endif
+#else
+#  define TOLUA_API extern
+#endif
+/********************************
+****** END ORXONOX CHANGES ******
+********************************/
 #define TOLUA_VERSION "tolua++-1.0.92"

code/branches/gui/src/tolua/toluabind.c

-                      r1505
+                      r1638
 /* Exported function */
 TOLUA_API int  tolua_tolua_open (lua_State* tolua_S);
+int  tolua_tolua_open (lua_State* tolua_S);
 …
 /* Open function */
 TOLUA_API int tolua_tolua_open (lua_State* tolua_S)
+int tolua_tolua_open (lua_State* tolua_S)
+{
  tolua_open(tolua_S);
 …
 #if defined(LUA_VERSION_NUM) && LUA_VERSION_NUM >= 501
  TOLUA_API int luaopen_tolua (lua_State* tolua_S) {
+ int luaopen_tolua (lua_State* tolua_S) {
  return tolua_tolua_open(tolua_S);
 };

code/branches/gui/src/util/ArgReader.cc

-                      r1535
+                      r1638
  *   Author:
  *      Reto Grieder
+ *      Benjamin Knecht <beni_at_orxonox.net>
  *   Co-authors:
  *      Benjamin Knecht <beni_at_orxonox.net>
+ *      ...
+ *
  */
 …
 #include "SubString.h"
 ArgReader::ArgReader(int argc, char **argv)
+std::string ArgReader::parse(int argc, char **argv)
+{
+  failure_ = false;
+  errorString_ = "";
+  CmdLineArg arg;
+    std::string errorString;
+    CmdLineArg arg;
+    int i = 1;
+    while (i < argc)
+    {
+        if (argv[i][0] == '-' && argv[i][1] == '-') // name
+        {
+            if (argv[i][2] == '\0')
+            {
+                errorString += "Expected word after \"--\".\n";
+            }
+            arg.bChecked_ = false;
+            arg.name_ = argv[i] + 2;
+            arg.value_ = " ";
+            arguments_.push_back(arg);
+        }
+        else // value
+        {
+            if (arguments_.size() == 0)
+            {
+                errorString += "Expected \"--\" in command line arguments.\n";
+                arg.bChecked_ = false;
+                arg.name_ = "";
+                arg.value_ = " ";
+                arguments_.push_back(arg);
+            }
+  int i = 1;
+  while (i < argc)
+  {
+    if (argv[i][0] == '-' && argv[i][1] == '-') // name
+    {
+      if (argv[i][2] == '\0')
+      {
+        failure_ = true;
+        errorString_ += "Expected word after \"--\".\n";
+      }
+      arg.bChecked_ = false;
+      arg.name_ = argv[i] + 2;
+      arg.value_ = "";
+      arguments_.push_back(arg);
+            if (arguments_.back().value_ != " ")
+                arguments_.back().value_ += " " + std::string(argv[i]);
+            else
+                arguments_.back().value_ = argv[i];
+        }
+        ++i;
+    }
+    else // value
+    {
+      if (arguments_.size() == 0)
+      {
+        failure_ = true;
+        errorString_ += "Expected \"--\" in command line arguments.\n";
+        arg.bChecked_ = false;
+        arg.name_ = "";
+        arg.value_ = "";
+        arguments_.push_back(arg);
+      }
+      if (arguments_.back().value_ != "")
+        arguments_.back().value_ += " " + std::string(argv[i]);
+      else
+        arguments_.back().value_ = argv[i];
+    }
+    ++i;
+  }
+    return errorString;
+}
 bool ArgReader::errorHandling()
+const std::string& ArgReader::getArgument(const std::string& option)
+{
+  bool argumentsChecked = true;
+  for (unsigned int i = 1; i < arguments_.size(); ++i)
+    argumentsChecked &= arguments_[i].bChecked_;
+  if (!argumentsChecked)
+    errorString_ += "Not all arguments could be matched.\n";
+  return !argumentsChecked || failure_;
+    unsigned int iArg = 0;
+    while (iArg < arguments_.size())
+    {
+        if (arguments_[iArg].name_ == option)
+        {
+            arguments_[iArg].bChecked_ = true;
+            return arguments_[iArg].value_;
+        }
+        ++iArg;
+    }
+    return blankString;
+}
 const std::string& ArgReader::getErrorString()
+bool ArgReader::allChecked()
+{
+  return errorString_;
+    bool argumentsChecked = true;
+    for (unsigned int i = 1; i < arguments_.size(); ++i)
+        argumentsChecked &= arguments_[i].bChecked_;
+    return argumentsChecked;
+}

code/branches/gui/src/util/ArgReader.h

-                      r1535
+                      r1638
  *   Author:
  *      Reto Grieder
+ *      Benjamin Knecht <beni_at_orxonox.net>
  *   Co-authors:
  *      Benjamin Knecht <beni_at_orxonox.net>
+ *      ...
+ *
  */
 …
 #include "Convert.h"
-struct _UtilExport CmdLineArg
+{
-  std::string name_;
-  std::string value_;
-  bool bChecked_;
-};
 class _UtilExport ArgReader
+{
+  public:
+    ArgReader(int argc, char **argv);
+    template <class T>
+    void checkArgument(std::string option, T* value, bool must = false);
+    bool errorHandling();
+    const std::string& getErrorString();
+public:
+    ArgReader() { }
+    std::string parse(int argc, char **argv);
+    const std::string& getArgument(const std::string& option);
+    bool allChecked();
+  private:
+private:
+    struct CmdLineArg
+    {
+        std::string name_;
+        std::string value_;
+        bool bChecked_;
+    };
     std::vector<CmdLineArg> arguments_;
-    bool failure_;
-    std::string errorString_;
 };
-template <class T>
-void ArgReader::checkArgument(std::string option, T* value, bool must)
+{
-  unsigned int iArg = 0;
-  while (iArg < arguments_.size())
+  {
-    if (arguments_[iArg].name_ == option)
-      break;
-    ++iArg;
+  }
-  if (iArg == arguments_.size())
+  {
-    if (must)
+    {
-      failure_ = true;
-      errorString_ += "Cannot find mandatory argument \"" + option + "\"\n";
-      return;
+    }
-    else
-      return;
+  }
-  arguments_[iArg].bChecked_ = true;
-  if (!convertValue(value, arguments_[iArg].value_))
+  {
-    failure_ = true;
-    errorString_ += "Cannot convert argument value for option \"" + option + "\"\n";
+  }
+}
-template <>
-void ArgReader::checkArgument(std::string option, bool* value, bool must)
+{
-  // for type bool, only check whether the option was set or not
-  unsigned int iArg = 0;
-  while (iArg < arguments_.size())
+  {
-    if (arguments_[iArg].name_ == option)
+    {
-      arguments_[iArg].bChecked_ = true;
-      *value = true;
-      break;
+    }
-    ++iArg;
+  }
-  if (iArg == arguments_.size())
-    *value = false;
+}
 #endif /* _ArgReader_H__ */

code/branches/gui/src/util/OrxonoxPlatform.h

-                      r1505
+                      r1638
 #else
 #  define ORXONOX_ARCH_TYPE ORXONOX_ARCHITECTURE_32
+#endif
+// try to define function information
+#ifndef __FUNCTIONNAME__
+#  if ORXONOX_COMPILER == ORXONOX_COMPILER_BORL
+#    define __FUNCTIONNAME__ __FUNC__
+#  elif ORXONOX_COMPILER == ORXONOX_COMPILER_GNUC
+#    define __FUNCTIONNAME__ __PRETTY_FUNCTION__
+#  elif ORXONOX_COMPILER == ORXONOX_COMPILER_MSVC
+#    define __FUNCTIONNAME__ __FUNCTION__
+#  else
+#    define __FUNCTIONNAME__
+#  endif
 #endif
 …
 // generated code from nvparse etc). I doubt very much that these calls
 // will ever be actually removed from VC anyway, it would break too much code.
 //#     pragma warning( disable: 4996)
+//# pragma warning( disable: 4996)
 // disable: "conditional expression constant", always occurs on

code/branches/gui/src/util/Sleep.h

r1505	r1638
29	29	/**
30	30	@file Sleep.h
31		@brief ~~Macro~~s for using sleep() and usleep() under windows
	31	@brief Functions for using sleep() and usleep() under windows
32	32	*/
33	33

Context Navigation

Legend:

Download in other formats: