Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/archive/lod/src/core/input/InputBuffer.h @ 12412

Last change on this file since 12412 was 1887, checked in by rgrieder, 16 years ago

FIRST THINGS FIRST: Delete or rename your keybindings.ini (def_keybindings.ini already has the most important bindings) or else you won't be able to do anything!

Changes:

  • Multiple joy stick support should now fully work with KeyBinder too (only tested with 0/1 joystick)
  • Reloading the OIS Devices now works with KeyBinder too
  • Modified ConfigValueContainer to accept arbitrary section names
  • added tkeybind to temporary bind a command to a key
  • Fixed dlleport issue in ArgumentCompletionFunctions.h

Internal changes:

  • General cleanup in initialisation of KeyBinder
  • All names of keys/buttons/axes are now statically saved in InputInterfaces.h
  • Move a magic value in KeyBinder to a configValue (MouseWheelStepSize_)
  • Separated ConfigValues from Keybinding ConfigValueContainer in KeyBinder (looks much nicer now ;))
  • Moved some performance critical small function to the inline section
  • Removed the ugly keybind function construct from the InputManager
  • More 'harmonising' work in KeyBinder
  • Property svn:eol-style set to native
File size: 7.6 KB
Line 
1/*
2 *   ORXONOX - the hottest 3D action shooter ever to exist
3 *                    > www.orxonox.net <
4 *
5 *
6 *   License notice:
7 *
8 *   This program is free software; you can redistribute it and/or
9 *   modify it under the terms of the GNU General Public License
10 *   as published by the Free Software Foundation; either version 2
11 *   of the License, or (at your option) any later version.
12 *
13 *   This program is distributed in the hope that it will be useful,
14 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
15 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16 *   GNU General Public License for more details.
17 *
18 *   You should have received a copy of the GNU General Public License
19 *   along with this program; if not, write to the Free Software
20 *   Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.
21 *
22 *   Author:
23 *      Fabian 'x3n' Landau
24 *   Co-authors:
25 *      Reto Grieder
26 *
27 */
28
29#ifndef _InputBuffer_H__
30#define _InputBuffer_H__
31
32#include "core/CorePrereqs.h"
33
34#include <string>
35#include <list>
36
37#include "core/OrxonoxClass.h"
38#include "InputInterfaces.h"
39
40namespace orxonox
41{
42    class BaseInputBufferListenerTuple
43    {
44    public:
45        BaseInputBufferListenerTuple(bool bListenToAllChanges, bool bOnlySingleInput,
46            bool trueKeyFalseChar, char _char, KeyCode::ByEnum key)
47            : bListenToAllChanges_(bListenToAllChanges), bOnlySingleInput_(bOnlySingleInput),
48              trueKeyFalseChar_(trueKeyFalseChar), char_(_char), key_(key)
49        { }
50        virtual ~BaseInputBufferListenerTuple() { }
51        virtual void callFunction() = 0;
52        bool bListenToAllChanges_;
53        bool bOnlySingleInput_;
54        bool trueKeyFalseChar_;
55        char char_;
56        KeyCode::ByEnum key_;
57    };
58
59    template <class T>
60    class InputBufferListenerTuple : public BaseInputBufferListenerTuple
61    {
62    public:
63        InputBufferListenerTuple(T* listener, void (T::*function)(), bool bListenToAllChanges,
64            bool bOnlySingleInput, bool trueKeyFalseChar, char _char, KeyCode::ByEnum key)
65            : BaseInputBufferListenerTuple(bListenToAllChanges, bOnlySingleInput, trueKeyFalseChar, _char, key),
66              listener_(listener), function_(function)
67        { }
68        virtual ~InputBufferListenerTuple() { }
69        void callFunction()
70        {
71            (listener_->*function_)();
72        }
73        T* listener_;
74        void (T::*function_)();
75    };
76
77    class _CoreExport InputBuffer : public KeyHandler, public OrxonoxClass
78    {
79        public:
80            InputBuffer();
81            InputBuffer(const std::string allowedChars);
82
83            void setConfigValues();
84
85            template <class T>
86            void registerListener(T* listener, void (T::*function)(), bool bOnlySingleInput)
87            {
88                InputBufferListenerTuple<T>* newTuple = new InputBufferListenerTuple<T>(listener, (void (T::*)())function, true, bOnlySingleInput, false, '\0', KeyCode::Unassigned);
89                this->listeners_.insert(this->listeners_.end(), newTuple);
90            }
91            template <class T>
92            void registerListener(T* listener, void (T::*function)() const, bool bOnlySingleInput)
93            {
94                InputBufferListenerTuple<T>* newTuple = new InputBufferListenerTuple<T>(listener, (void (T::*)())function, true, bOnlySingleInput, false, '\0', KeyCode::Unassigned);
95                this->listeners_.insert(this->listeners_.end(), newTuple);
96            }
97            template <class T>
98            void registerListener(T* listener, void (T::*function)(), char _char, bool bOnlySingleInput)
99            {
100                InputBufferListenerTuple<T>* newTuple = new InputBufferListenerTuple<T>(listener, (void (T::*)())function, false, bOnlySingleInput, false, _char, KeyCode::Unassigned);
101                this->listeners_.insert(this->listeners_.end(), newTuple);
102            }
103            template <class T>
104            void registerListener(T* listener, void (T::*function)() const, char _char, bool bOnlySingleInput)
105            {
106                InputBufferListenerTuple<T>* newTuple = new InputBufferListenerTuple<T>(listener, (void (T::*)())function, false, bOnlySingleInput, false, _char, KeyCode::Unassigned);
107                this->listeners_.insert(this->listeners_.end(), newTuple);
108            }
109
110            template <class T>
111            void registerListener(T* listener, void (T::*function)(), KeyCode::ByEnum key)
112            {
113                InputBufferListenerTuple<T>* newTuple = new InputBufferListenerTuple<T>(listener, (void (T::*)())function, false, true, true, '\0', key);
114                this->listeners_.insert(this->listeners_.end(), newTuple);
115            }
116            template <class T>
117            void registerListener(T* listener, void (T::*function)() const, KeyCode::ByEnum key)
118            {
119                InputBufferListenerTuple<T>* newTuple = new InputBufferListenerTuple<T>(listener, (void (T::*)())function, false, true, true, '\0', key);
120                this->listeners_.insert(this->listeners_.end(), newTuple);
121            }
122
123            template <class T>
124            void unregisterListener(T* listener)
125            {
126                for (std::list<BaseInputBufferListenerTuple*>::iterator it = this->listeners_.begin(); it != this->listeners_.end(); )
127                {
128                    InputBufferListenerTuple<T>* refListener = dynamic_cast<InputBufferListenerTuple<T>*>(*it);
129                    if (refListener && refListener->listener_ == listener)
130                        this->listeners_.erase(it++);
131                    else
132                        it++;
133                }
134            }
135
136            void set(const std::string& input, bool update = true);
137            void insert(const std::string& input, bool update = true);
138            void insert(const char& input, bool update = true);
139            void clear(bool update = true);
140            void removeAtCursor(bool update = true);
141            void removeBehindCursor(bool update = true);
142
143            void updated();
144            void updated(const char& update, bool bSingleInput);
145
146            inline std::string get() const
147                { return this->buffer_; }
148            inline unsigned int getSize() const
149                { return this->buffer_.size(); }
150
151            inline unsigned int getCursorPosition() const
152                { return this->cursor_; }
153            inline void setCursorPosition(unsigned int cursor)
154                { if (cursor <= this->buffer_.size()) { this->cursor_ = cursor; } }
155            inline void setCursorToEnd()
156                { this->cursor_ = this->buffer_.size(); }
157            inline void setCursorToBegin()
158                { this->cursor_ = 0; }
159            inline void increaseCursor()
160                { if (this->cursor_ < this->buffer_.size()) { ++this->cursor_; } }
161            inline void decreaseCursor()
162                { if (this->cursor_ > 0) { --this->cursor_; } }
163
164        private:
165            bool charIsAllowed(const char& input);
166
167            void keyPressed (const KeyEvent& evt);
168            void keyReleased(const KeyEvent& evt) { }
169            void keyHeld    (const KeyEvent& evt);
170            void processKey (const KeyEvent &e);
171
172            void tickInput(float dt);
173            void tickKey(float dt) { }
174
175            std::string buffer_;
176            std::list<BaseInputBufferListenerTuple*> listeners_;
177            std::string allowedChars_;
178            unsigned int cursor_;
179
180            KeyCode::ByEnum lastKey_;
181            float timeSinceKeyPressed_;
182            float timeSinceKeyRepeated_;
183            int keysToRepeat_;
184
185            float keyRepeatDeleay_;
186            float keyRepeatTime_;
187    };
188}
189
190#endif /* _InputBuffer_H__ */
Note: See TracBrowser for help on using the repository browser.