Changeset 1272 for code/branches/merge/src/core/InputBuffer.cc

Timestamp:

May 14, 2008, 11:44:17 AM (16 years ago)

Author:

rgrieder

Message:

merged input branch into merge branch

File:

• code/branches/merge/src/core/InputBuffer.cc (modified) (2 diffs)

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

@@ -23 +23 @@
  *      Fabian 'x3n' Landau
  *   Co-authors:
- *      ...
+ *      Reto Grieder
  *
  */
@@ -32 +32 @@
 
 #include "util/Clipboard.h"
-#include "InputManager.h"
+#include "CoreIncludes.h"
+#include "ConfigValueIncludes.h"
 
 namespace orxonox
 {
-    InputBuffer::InputBuffer()
-    {
-        //this->bActivated_ = false;
-        this->allowedChars_ = "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZäöüÄÖÜ0123456789 \\\"(){}[]<>.:,;_-+*/=!?|$&%^";
-        this->keyboard_ = InputManager::getKeyboard();
-        this->buffer_ = "";
-
-        //this->keyboard_->setEventCallback(this);
-    }
-
-    InputBuffer::InputBuffer(const std::string allowedChars)
-    {
-        //this->bActivated_ = false;
-        this->allowedChars_ = allowedChars;
-        this->keyboard_ = InputManager::getKeyboard();
-        this->buffer_ = "";
-    }
-/*
-    void InputBuffer::registerListener(InputBufferListener* listener, void (InputBufferListener::*function)(), bool bOnlySingleInput)
-    {
-        struct InputBufferListenerTuple newListener = {listener, function, true, bOnlySingleInput, ' '};
-        this->listeners_.insert(this->listeners_.end(), newListener);
-    }
-
-    void InputBuffer::registerListener(InputBufferListener* listener, void (InputBufferListener::*function)(), char char_, bool bOnlySingleInput)
-    {
-        struct InputBufferListenerTuple newListener = {listener, function, false, bOnlySingleInput, char_};
-        this->listeners_.insert(this->listeners_.end(), newListener);
-    }
-*/
-    void InputBuffer::set(const std::string& input)
-    {
-        this->buffer_ = "";
-        this->append(input);
-    }
-
-    void InputBuffer::append(const std::string& input)
-    {
-        for (unsigned int i = 0; i < input.size(); i++)
-        {
-            if (this->charIsAllowed(input[i]))
-                this->buffer_ += input[i];
-
-            this->updated(input[i], false);
-        }
-        this->updated();
-    }
-
-    void InputBuffer::append(const char& input)
-    {
-        if (this->charIsAllowed(input))
-            this->buffer_ += input;
-
-        this->updated(input, true);
-    }
-
-    void InputBuffer::clear()
-    {
-        this->buffer_ = "";
-        this->updated();
-    }
-
-    void InputBuffer::removeLast()
-    {
-        this->buffer_ = this->buffer_.substr(0, this->buffer_.size() - 1);
-        this->updated();
-    }
-
-    void InputBuffer::updated()
-    {
-        for (std::list<InputBufferListenerTuple>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
-        {
-            if ((*it).bListenToAllChanges_)
-                (*(*it).listener_.*(*it).function_)();
-        }
-    }
-
-    void InputBuffer::updated(const char& update, bool bSingleInput)
-    {
-        for (std::list<InputBufferListenerTuple>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
-        {
-            if (((*it).bListenToAllChanges_ || ((*it).char_ == update)) && (!(*it).bOnlySingleInput_ || bSingleInput))
-                (*(*it).listener_.*(*it).function_)();
-        }
-    }
-
-    /*void InputBuffer::activityChanged() const
-    {
-    }*/
-
-    bool InputBuffer::charIsAllowed(const char& input)
-    {
-        if (this->allowedChars_ == "")
-            return true;
-        else
-            return (this->allowedChars_.find(input) != std::string::npos);
-    }
-
-    bool InputBuffer::keyPressed(const OIS::KeyEvent &e)
-    {
-        /*if (e.key == OIS::KC_NUMPADENTER)
-        {
-            this->setActivated(!this->isActivated());
-            this->clear();
-            return true;
-        }*/
-
-        if (this->keyboard_->isModifierDown(OIS::Keyboard::Ctrl))
-        {
-            if (e.key == OIS::KC_V)
-            {
-                this->append(fromClipboard());
-                return true;
-            }
-            else if (e.key == OIS::KC_C)
-            {
-                toClipboard(this->buffer_);
-                return true;
-            }
-            else if (e.key == OIS::KC_X)
-            {
-                toClipboard(this->buffer_);
-                this->clear();
-                return true;
-            }
-        }
-        else if (this->keyboard_->isModifierDown(OIS::Keyboard::Shift))
-        {
-            if (e.key == OIS::KC_INSERT)
-            {
-                this->append(fromClipboard());
-                return true;
-            }
-            else if (e.key == OIS::KC_DELETE)
-            {
-                toClipboard(this->buffer_);
-                this->clear();
-                return true;
-            }
-        }
-
-        //std::cout << this->keyboard_->getAsString(e.key) << " / " << (char)e.text << std::endl;
-
-        std::string input = this->keyboard_->getAsString(e.key);
-        /*if (input.size() >= 1)
-            this->append(input[0]);*/
-
-        this->append((char)e.text);
-        return true;
-    }
-
-    bool InputBuffer::keyReleased(const OIS::KeyEvent &e)
-    {
-        return true;
-    }
+  InputBuffer::InputBuffer(const std::string allowedChars) :
+    buffer_(""),
+    allowedChars_(allowedChars),
+    lastKey_(KeyCode::Unassigned),
+    timeSinceKeyPressed_(0.0f),
+    timeSinceKeyRepeated_(0.0f),
+    keysToRepeat_(0)
+  {
+    RegisterObject(InputBuffer);
+    setConfigValues();
+  }
+
+  void InputBuffer::setConfigValues()
+  {
+    SetConfigValue(keyRepeatDeleay_, 0.4).description("Key repeat deleay of the input buffer");
+    SetConfigValue(keyRepeatTime_, 0.022).description("Key repeat time of the input buffer");
+    if (keyRepeatDeleay_ < 0.0)
+    {
+      ResetConfigValue(keyRepeatDeleay_);
+    }
+    if (keyRepeatTime_ < 0.0)
+    {
+      ResetConfigValue(keyRepeatTime_);
+    }
+  }
+  /*
+  void InputBuffer::registerListener(InputBufferListener* listener, void (InputBufferListener::*function)(), bool bOnlySingleInput)
+  {
+    struct InputBufferListenerTuple newListener = {listener, function, true, bOnlySingleInput, ' '};
+    listeners_.insert(listeners_.end(), newListener);
+  }
+
+  void InputBuffer::registerListener(InputBufferListener* listener, void (InputBufferListener::*function)(), char char_, bool bOnlySingleInput)
+  {
+    struct InputBufferListenerTuple newListener = {listener, function, false, bOnlySingleInput, char_};
+    listeners_.insert(listeners_.end(), newListener);
+  }
+  */
+  void InputBuffer::set(const std::string& input)
+  {
+    buffer_ = "";
+    append(input);
+  }
+
+  void InputBuffer::append(const std::string& input)
+  {
+    for (unsigned int i = 0; i < input.size(); i++)
+    {
+      if (charIsAllowed(input[i]))
+        buffer_ += input[i];
+
+      updated(input[i], false);
+    }
+    updated();
+  }
+
+  void InputBuffer::append(const char& input)
+  {
+    if (charIsAllowed(input))
+      buffer_ += input;
+
+    updated(input, true);
+  }
+
+  void InputBuffer::clear()
+  {
+    buffer_ = "";
+    updated();
+  }
+
+  void InputBuffer::removeLast()
+  {
+    buffer_ = buffer_.substr(0, buffer_.size() - 1);
+    updated();
+  }
+
+  void InputBuffer::updated()
+  {
+    for (std::list<InputBufferListenerTuple>::iterator it = listeners_.begin(); it != listeners_.end(); ++it)
+    {
+      if ((*it).bListenToAllChanges_)
+        (*(*it).listener_.*(*it).function_)();
+    }
+  }
+
+  void InputBuffer::updated(const char& update, bool bSingleInput)
+  {
+    for (std::list<InputBufferListenerTuple>::iterator it = listeners_.begin(); it != listeners_.end(); ++it)
+    {
+      if (((*it).bListenToAllChanges_ || ((*it).char_ == update)) && (!(*it).bOnlySingleInput_ || bSingleInput))
+        (*(*it).listener_.*(*it).function_)();
+    }
+  }
+
+  bool InputBuffer::charIsAllowed(const char& input)
+  {
+    if (allowedChars_ == "")
+      return true;
+    else
+      return (allowedChars_.find(input) != std::string::npos);
+  }
+
+
+  void InputBuffer::processKey(const KeyEvent &evt)
+  {
+    if (evt.isModifierDown(KeyboardModifier::Ctrl))
+    {
+      if (evt.key == KeyCode::V)
+        append(fromClipboard());
+      else if (evt.key == KeyCode::C)
+        toClipboard(buffer_);
+      else if (evt.key == KeyCode::X)
+      {
+        toClipboard(buffer_);
+        clear();
+      }
+    }
+    else if (evt.isModifierDown(KeyboardModifier::Shift))
+    {
+      if (evt.key == KeyCode::Insert)
+      {
+        append(fromClipboard());
+      }
+      else if (evt.key == KeyCode::Delete)
+      {
+        toClipboard(buffer_);
+        clear();
+      }
+    }
+    //std::string input = keyboard_->getAsString(e.key);
+    /*if (input.size() >= 1)
+    append(input[0]);*/
+
+    append((char)evt.text);
+  }
+
+  void InputBuffer::tick(float dt)
+  {
+    timeSinceKeyPressed_ += dt;
+    if (keysToRepeat_ < 10 && timeSinceKeyPressed_ > keyRepeatDeleay_)
+    {
+      // initial time out has gone by, start repeating keys
+      while (timeSinceKeyPressed_ - timeSinceKeyRepeated_ > keyRepeatTime_)
+      {
+        timeSinceKeyRepeated_ += keyRepeatTime_;
+        keysToRepeat_++;
+      }
+    }
+  }
+
+  bool InputBuffer::keyPressed(const KeyEvent &evt)
+  {
+    lastKey_ = evt.key;
+    timeSinceKeyPressed_ = 0.0;
+    timeSinceKeyRepeated_ = keyRepeatDeleay_;
+    keysToRepeat_ = 0;
+
+    processKey(evt);
+    return true;
+  }
+
+  bool InputBuffer::keyHeld(const KeyEvent& evt)
+  {
+    if (evt.key == lastKey_)
+    {
+      while (keysToRepeat_)
+      {
+        processKey(evt);
+        keysToRepeat_--;
+      }
+    }
+    return true;
+  }
+
 }