Changeset 1502 for code/trunk/src/core/InputBuffer.cc

Timestamp:

Jun 1, 2008, 3:54:20 PM (16 years ago)

Author:

rgrieder

Message:

• @everyone: Do not create a branch until I've added the svn:eol-style property correctly. Otherwise this would cost me another 4 hours or so when we want to merge back.
• merged network branch back to trunk
• I had to omit the changes from last evening concerning the line endings
• might not work yet because of the line endings
• @beni: script branch is the only branch still open. you probably will have to apply a patch because of inconsistent new lines

File:

• code/trunk/src/core/InputBuffer.cc (modified) (1 diff)

code/trunk/src/core/InputBuffer.cc

@@ -37 +37 @@
 namespace orxonox
 {
-  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);
-  }
-
-  /**
-  * This tick() function is called by the InputManager if the InputBuffer is active.
-  * @param dt Delta time
-  */
-  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_++;
-      }
-    }
-  }
-
-  void InputBuffer::keyPressed(const KeyEvent &evt)
-  {
-    lastKey_ = evt.key;
-    timeSinceKeyPressed_ = 0.0;
-    timeSinceKeyRepeated_ = keyRepeatDeleay_;
-    keysToRepeat_ = 0;
-
-    processKey(evt);
-  }
-
-  void InputBuffer::keyHeld(const KeyEvent& evt)
-  {
-    if (evt.key == lastKey_)
-    {
-      while (keysToRepeat_)
-      {
+    InputBuffer::InputBuffer()
+    {
+        RegisterObject(InputBuffer);
+
+        this->buffer_ = "";
+        this->cursor_ = 0;
+        this->allowedChars_ = "abcdefghijklmnopqrstuvwxyz \
+                               ABCDEFGHIJKLMNOPQRSTUVWXYZ \
+                               äëïöüÄËÏÖÜáâàéêèíîìóôòúûù \
+                               0123456789 \
+                               \\\"(){}[]<>.:,;_-+*/=!?|$&%^~#";
+
+        this->lastKey_ = KeyCode::Unassigned;
+        this->timeSinceKeyPressed_ = 0.0f;
+        this->timeSinceKeyRepeated_ = 0.0f;
+        this->keysToRepeat_ = 0;
+
+        setConfigValues();
+    }
+
+    InputBuffer::InputBuffer(const std::string allowedChars)
+    {
+        RegisterObject(InputBuffer);
+
+        this->allowedChars_ = allowedChars;
+        this->buffer_ = "";
+        this->cursor_ = 0;
+
+        this->lastKey_ = KeyCode::Unassigned;
+        this->timeSinceKeyPressed_ = 0.0f;
+        this->timeSinceKeyRepeated_ = 0.0f;
+        this->keysToRepeat_ = 0;
+
+        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::set(const std::string& input, bool update)
+    {
+        this->clear(false);
+        this->insert(input, update);
+    }
+
+    void InputBuffer::insert(const std::string& input, bool update)
+    {
+        for (unsigned int i = 0; i < input.size(); ++i)
+        {
+            this->insert(input[i], false);
+
+            if (update)
+                this->updated(input[i], false);
+        }
+
+        if (update)
+            this->updated();
+    }
+
+    void InputBuffer::insert(const char& input, bool update)
+    {
+        if (this->charIsAllowed(input))
+        {
+            this->buffer_.insert(this->cursor_, 1, input);
+            ++this->cursor_;
+        }
+
+        if (update)
+            this->updated(input, true);
+    }
+
+    void InputBuffer::clear(bool update)
+    {
+        this->buffer_ = "";
+        this->cursor_ = 0;
+
+        if (update)
+            this->updated();
+    }
+
+    void InputBuffer::removeBehindCursor(bool update)
+    {
+        if (this->cursor_ > 0)
+        {
+            --this->cursor_;
+            this->buffer_.erase(this->cursor_, 1);
+
+            if (update)
+                this->updated();
+        }
+    }
+
+    void InputBuffer::removeAtCursor(bool update)
+    {
+        if (this->cursor_ < this->buffer_.size())
+        {
+            this->buffer_.erase(this->cursor_, 1);
+
+            if (update)
+                this->updated();
+        }
+    }
+
+    void InputBuffer::updated()
+    {
+        for (std::list<BaseInputBufferListenerTuple*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
+        {
+            if ((*it)->bListenToAllChanges_)
+                (*it)->callFunction();
+        }
+    }
+
+    void InputBuffer::updated(const char& update, bool bSingleInput)
+    {
+        for (std::list<BaseInputBufferListenerTuple*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
+        {
+            if ((!(*it)->trueKeyFalseChar_) && ((*it)->bListenToAllChanges_ || ((*it)->char_ == update)) && (!(*it)->bOnlySingleInput_ || bSingleInput))
+                (*it)->callFunction();
+        }
+    }
+
+    bool InputBuffer::charIsAllowed(const char& input)
+    {
+        if (this->allowedChars_ == "")
+            return true;
+        else
+            return (this->allowedChars_.find(input) != std::string::npos);
+    }
+
+
+    void InputBuffer::processKey(const KeyEvent &evt)
+    {
+        if (evt.isModifierDown(KeyboardModifier::Alt) && evt.key == KeyCode::Tab)
+            return;
+
+        for (std::list<BaseInputBufferListenerTuple*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); ++it)
+        {
+            if ((*it)->trueKeyFalseChar_ && ((*it)->key_ == evt.key))
+                (*it)->callFunction();
+        }
+
+        if (evt.isModifierDown(KeyboardModifier::Ctrl))
+        {
+            if (evt.key == KeyCode::V)
+                this->insert(fromClipboard());
+            else if (evt.key == KeyCode::C)
+                toClipboard(this->buffer_);
+            else if (evt.key == KeyCode::X)
+            {
+                toClipboard(this->buffer_);
+                this->clear();
+            }
+        }
+        else if (evt.isModifierDown(KeyboardModifier::Shift))
+        {
+            if (evt.key == KeyCode::Insert)
+                this->insert(fromClipboard());
+            else if (evt.key == KeyCode::Delete)
+            {
+                toClipboard(this->buffer_);
+                this->clear();
+            }
+        }
+
+        this->insert((char)evt.text);
+    }
+
+    /**
+        @brief This tick() function is called by the InputManager if the InputBuffer is active.
+        @param dt Delta time
+    */
+    void InputBuffer::tickInput(float dt, const HandlerState& state)
+    {
+        timeSinceKeyPressed_ += dt;
+        if (keysToRepeat_ < 10 && timeSinceKeyPressed_ > keyRepeatDeleay_)
+        {
+            // initial time out has gone by, start repeating keys
+            while (timeSinceKeyPressed_ - timeSinceKeyRepeated_ > keyRepeatTime_)
+            {
+                timeSinceKeyRepeated_ += keyRepeatTime_;
+                keysToRepeat_++;
+            }
+        }
+    }
+
+    void InputBuffer::keyPressed(const KeyEvent &evt)
+    {
+        lastKey_ = evt.key;
+        timeSinceKeyPressed_ = 0.0;
+        timeSinceKeyRepeated_ = keyRepeatDeleay_;
+        keysToRepeat_ = 0;
+
         processKey(evt);
-        keysToRepeat_--;
-      }
-    }
-  }
-
+    }
+
+    void InputBuffer::keyHeld(const KeyEvent& evt)
+    {
+        if (evt.key == lastKey_)
+        {
+            while (keysToRepeat_)
+            {
+                processKey(evt);
+                keysToRepeat_--;
+            }
+        }
+    }
 }