Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

Ignore:
Timestamp:
Oct 3, 2009, 5:33:31 PM (15 years ago)
Author:
rgrieder
Message:

New class: KeyBinderManager (yes, it really was necessary, I'm not such a Fan of zillions of classes as well) and moved the keybind command to it from GSLevel.
This new Singleton simply maps the keybind command to the right KeyBinder, selected by KeyBinderManager::setCurrent().
There is also a default KeyBinder (with keybindings.ini as file), which should do the Trick for now. Other Keybinders should only server special purposes (like in mini games or so).

DELETE YOUR keybindings.ini FILE! =
Location:
code/branches/core5/src
Files:
2 added
13 edited

Legend:

Unmodified
Added
Removed
  • code/branches/core5/src/libraries/core/Core.cc

    r5855 r5863  
    6969#include "TclThreadManager.h"
    7070#include "input/InputManager.h"
     71#include "input/KeyBinderManager.h"
    7172
    7273namespace orxonox
     
    288289        inputManager_.reset(new InputManager());
    289290
     291        // Manages KeyBinders and makes them available
     292        keyBinderManager_.reset(new KeyBinderManager());
     293
    290294        // load the CEGUI interface
    291295        guiManager_.reset(new GUIManager(graphicsManager_->getRenderWindow(),
     
    304308        this->graphicsScope_.reset();
    305309        this->guiManager_.reset();
     310        this->keyBinderManager_.reset();
    306311        this->inputManager_.reset();
    307312        this->graphicsManager_.reset();
  • code/branches/core5/src/libraries/core/Core.h

    r5850 r5863  
    100100            scoped_ptr<GraphicsManager>   graphicsManager_;     //!< Interface to OGRE
    101101            scoped_ptr<InputManager>      inputManager_;        //!< Interface to OIS
     102            scoped_ptr<KeyBinderManager>  keyBinderManager_;    //!< Manages all KeyBinders
    102103            scoped_ptr<GUIManager>        guiManager_;          //!< Interface to GUI
    103104            scoped_ptr<Scope<ScopeID::Root> >     rootScope_;
  • code/branches/core5/src/libraries/core/CorePrereqs.h

    r5858 r5863  
    212212    class JoyStick;
    213213    class KeyBinder;
     214    class KeyBinderManager;
    214215    class Keyboard;
    215216    class KeyDetector;
  • code/branches/core5/src/libraries/core/input/CMakeLists.txt

    r5738 r5863  
    99  JoyStickQuantityListener.cc
    1010  KeyBinder.cc
     11  KeyBinderManager.cc
    1112  Keyboard.cc
    1213  KeyDetector.cc
  • code/branches/core5/src/libraries/core/input/InputManager.cc

    r5855 r5863  
    264264    }
    265265
    266     void InputManager::setKeyDetectorCallback(const std::string& command)
    267     {
    268         this->keyDetector_->setCallbackCommand(command);
    269     }
    270 
    271266    // ############################################################
    272267    // #####                    Destruction                   #####
  • code/branches/core5/src/libraries/core/input/InputManager.h

    r5738 r5863  
    161161        // Various getters and setters
    162162        //-------------------------------
    163         //! Sets the the name of the command used by the KeyDetector as callback.
    164         void setKeyDetectorCallback(const std::string& command);
    165163        //! Returns the number of joy stick that have been created since the c'tor or last call to reload().
    166164        unsigned int getJoyStickQuantity() const
  • code/branches/core5/src/libraries/core/input/KeyBinder.cc

    r5738 r5863  
    2727 */
    2828
    29 /**
    30  @file
    31  @brief Implementation of the different input handlers.
    32  */
    33 
    3429#include "KeyBinder.h"
    3530
    3631#include "util/Convert.h"
    3732#include "util/Debug.h"
     33#include "util/Exception.h"
    3834#include "core/ConfigValueIncludes.h"
    3935#include "core/CoreIncludes.h"
     
    4844        Constructor that does as little as necessary.
    4945    */
    50     KeyBinder::KeyBinder()
     46    KeyBinder::KeyBinder(const std::string& filename)
    5147        : deriveTime_(0.0f)
     48        , filename_(filename)
    5249    {
    5350        mouseRelative_[0] = 0;
     
    103100        // set them here to use allHalfAxes_
    104101        setConfigValues();
     102
     103        // Load the bindings if filename was given
     104        if (!this->filename_.empty())
     105            this->loadBindings();
    105106    }
    106107
     
    240241    @brief
    241242        Loads the key and button bindings.
    242     @return
    243         True if loading succeeded.
    244     */
    245     void KeyBinder::loadBindings(const std::string& filename)
     243    */
     244    void KeyBinder::loadBindings()
    246245    {
    247246        COUT(3) << "KeyBinder: Loading key bindings..." << std::endl;
    248247
    249         if (filename.empty())
    250             return;
    251 
    252         if (this->configFile_ == ConfigFileType::NoType)
    253         {
    254             // Get a new ConfigFileType from the ConfigFileManager
    255             this->configFile_ = ConfigFileManager::getInstance().getNewConfigFileType();
    256         }
    257 
    258         ConfigFileManager::getInstance().setFilename(this->configFile_, filename);
     248        // Get a new ConfigFileType from the ConfigFileManager
     249        this->configFile_ = ConfigFileManager::getInstance().getNewConfigFileType();
     250
     251        ConfigFileManager::getInstance().setFilename(this->configFile_, this->filename_);
    259252
    260253        // Parse bindings and create the ConfigValueContainers if necessary
    261         clearBindings();
    262254        for (std::map<std::string, Button*>::const_iterator it = allButtons_.begin(); it != allButtons_.end(); ++it)
    263255            it->second->readConfigValue(this->configFile_);
  • code/branches/core5/src/libraries/core/input/KeyBinder.h

    r5738 r5863  
    2626 *
    2727 */
    28 
    29 /**
    30 @file
    31 @brief
    32     Different definitions of input processing.
    33 */
    3428
    3529#ifndef _KeyBinder_H__
     
    5347    /**
    5448    @brief
    55         Handles mouse, keyboard and joy stick input while in the actual game mode.
    56         Manages the key bindings.
     49        Maps mouse, keyboard and joy stick input to command strings and executes them.
     50
     51        The bindings are stored in ini-files (like the one for configValues) in the config Path.
     52    @remarks
     53        You cannot change the filename because the KeyBinderManager maps these filenames to the
     54        KeyBinders. If you need to load other bindings, just create a new one.
    5755    */
    5856    class _CoreExport KeyBinder : public InputHandler, public JoyStickQuantityListener
    5957    {
    6058    public:
    61         KeyBinder ();
     59        KeyBinder (const std::string& filename);
    6260        virtual ~KeyBinder();
    6361
    64         void loadBindings(const std::string& filename);
    6562        void clearBindings();
    6663        bool setBinding(const std::string& binding, const std::string& name, bool bTemporary = false);
     64        const std::string& getBindingsFilename()
     65            { return this->filename_; }
    6766        void setConfigValues();
    6867        void resetJoyStickAxes();
    6968
    7069    protected: // functions
     70        void loadBindings();
     71        void buttonThresholdChanged();
     72        void initialiseJoyStickBindings();
     73        void compilePointerLists();
     74        // from JoyStickQuantityListener interface
     75        virtual void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
     76
    7177        void allDevicesUpdated(float dt);
    7278        void mouseUpdated(float dt);
     
    7480        // internal
    7581        void tickHalfAxis(HalfAxis& halfAxis);
    76 
    77         void buttonThresholdChanged();
    78         // from JoyStickQuantityListener interface
    79         virtual void JoyStickQuantityChanged(const std::vector<JoyStick*>& joyStickList);
    80         void initialiseJoyStickBindings();
    81         void compilePointerLists();
    8282
    8383        void buttonPressed (const KeyEvent& evt);
     
    144144        float deriveTime_;
    145145
     146        //! Name of the file used in this KeyBinder (constant!)
     147        const std::string filename_;
    146148        //! Config file used. ConfigFileType::NoType in case of KeyDetector. Also indicates whether we've already loaded.
    147149        ConfigFileType configFile_;
     
    171173    };
    172174
     175
    173176    inline void KeyBinder::buttonPressed (const KeyEvent& evt)
    174177    { assert(!keys_[evt.getKeyCode()].name_.empty()); keys_[evt.getKeyCode()].execute(KeybindMode::OnPress); }
  • code/branches/core5/src/orxonox/gamestates/GSGraphics.cc

    r5855 r5863  
    4141#include "core/Game.h"
    4242#include "core/GUIManager.h"
    43 #include "core/input/InputManager.h"
    44 #include "core/input/KeyBinder.h"
    45 #include "core/input/InputState.h"
    4643#include "core/Loader.h"
    4744#include "core/XMLFile.h"
     
    5653    GSGraphics::GSGraphics(const GameStateInfo& info)
    5754        : GameState(info)
    58         , masterKeyBinder_(0)
    59         , masterInputState_(0)
    6055        , debugOverlay_(0)
    6156    {
    62         // load master key bindings
    63         masterInputState_ = InputManager::getInstance().createInputState("master", true);
    64         masterKeyBinder_ = new KeyBinder();
    65         masterInputState_->setKeyHandler(masterKeyBinder_);
    6657    }
    6758
    6859    GSGraphics::~GSGraphics()
    6960    {
    70         InputManager::getInstance().destroyState("master");
    71         this->masterKeyBinder_->destroy();
    7261    }
    7362
     
    9483        Loader::open(debugOverlay_);
    9584
    96         masterKeyBinder_->loadBindings("masterKeybindings.ini");
    97 
    9885        // add console command to toggle GUI
    9986        this->ccToggleGUI_ = createConsoleCommand(createFunctor(&GSGraphics::toggleGUI, this), "toggleGUI");
    10087        CommandExecutor::addConsoleCommandShortcut(this->ccToggleGUI_);
    101 
    102         // enable master input
    103         InputManager::getInstance().enterState("master");
    10488    }
    10589
  • code/branches/core5/src/orxonox/gamestates/GSGraphics.h

    r5850 r5863  
    6060
    6161    private:
    62         KeyBinder*            masterKeyBinder_;     //!< Key binder for master key bindings
    63         InputState*           masterInputState_;    //!< Special input state for master input
    6462        XMLFile*              debugOverlay_;
    6563        ConsoleCommand*       ccToggleGUI_;         //!< Console command to toggle GUI
  • code/branches/core5/src/orxonox/gamestates/GSLevel.cc

    r5855 r5863  
    3535#include "core/input/InputManager.h"
    3636#include "core/input/InputState.h"
    37 #include "core/input/KeyBinder.h"
     37#include "core/input/KeyBinderManager.h"
    3838#include "core/ConsoleCommand.h"
    3939#include "core/ConfigValueIncludes.h"
     
    5757    GSLevel::GSLevel(const GameStateInfo& info)
    5858        : GameState(info)
    59         , keyBinder_(0)
    6059        , gameInputState_(0)
    6160        , guiMouseOnlyInputState_(0)
     
    6362    {
    6463        RegisterObject(GSLevel);
    65 
    66         this->ccKeybind_ = 0;
    67         this->ccTkeybind_ = 0;
    6864    }
    6965
     
    7470    void GSLevel::setConfigValues()
    7571    {
    76         SetConfigValue(keyDetectorCallbackCode_, "KeybindBindingStringKeyName=");
    7772    }
    7873
     
    8479        {
    8580            gameInputState_ = InputManager::getInstance().createInputState("game");
    86             keyBinder_ = new KeyBinder();
    87             keyBinder_->loadBindings("keybindings.ini");
    88             gameInputState_->setHandler(keyBinder_);
     81            gameInputState_->setHandler(KeyBinderManager::getInstance().getDefaultAsHandler());
     82            KeyBinderManager::getInstance().setToDefault();
    8983
    9084            guiMouseOnlyInputState_ = InputManager::getInstance().createInputState("guiMouseOnly");
     
    10296        if (GameMode::showsGraphics())
    10397        {
    104             // keybind console command
    105             ccKeybind_ = createConsoleCommand(createFunctor(&GSLevel::keybind, this), "keybind");
    106             CommandExecutor::addConsoleCommandShortcut(ccKeybind_);
    107             ccTkeybind_ = createConsoleCommand(createFunctor(&GSLevel::tkeybind, this), "tkeybind");
    108             CommandExecutor::addConsoleCommandShortcut(ccTkeybind_);
    109             // set our console command as callback for the key detector
    110             InputManager::getInstance().setKeyDetectorCallback(std::string("keybind ") + keyDetectorCallbackCode_);
    111 
    11298            // level is loaded: we can start capturing the input
    11399            InputManager::getInstance().enterState("game");
     
    136122    void GSLevel::deactivate()
    137123    {
    138 /*
    139         // destroy console commands
    140         if (this->ccKeybind_)
    141         {
    142             delete this->ccKeybind_;
    143             this->ccKeybind_ = 0;
    144         }
    145         if (this->ccTkeybind_)
    146         {
    147             delete this->ccTkeybind_;
    148             this->ccTkeybind_ = 0;
    149         }
    150 */
    151 
    152124        if (GameMode::showsGraphics())
    153125        {
     
    181153            InputManager::getInstance().destroyState("guiKeysOnly");
    182154            InputManager::getInstance().destroyState("guiMouseOnly");
    183             if (this->keyBinder_)
    184             {
    185                 this->keyBinder_->destroy();
    186                 this->keyBinder_ = 0;
    187             }
    188155        }
    189156    }
     
    211178        delete startFile_s;
    212179    }
    213 
    214     void GSLevel::keybind(const std::string &command)
    215     {
    216         this->keybindInternal(command, false);
    217     }
    218 
    219     void GSLevel::tkeybind(const std::string &command)
    220     {
    221         this->keybindInternal(command, true);
    222     }
    223 
    224     /**
    225     @brief
    226         Assigns a command string to a key/button/axis. The name is determined via KeyDetector.
    227     @param command
    228         Command string that can be executed by the CommandExecutor
    229         OR: Internal string "KeybindBindingStringKeyName=" used for the second call to identify
    230         the key/button/axis that has been activated. This is configured above in activate().
    231     */
    232     void GSLevel::keybindInternal(const std::string& command, bool bTemporary)
    233     {
    234         if (GameMode::showsGraphics())
    235         {
    236             static std::string bindingString = "";
    237             static bool bTemporarySaved = false;
    238             static bool bound = true;
    239             // note: We use a long name to make 'sure' that the user doesn't use it accidentally.
    240             // Howerver there will be no real issue if it happens anyway.
    241             if (command.find(keyDetectorCallbackCode_) != 0)
    242             {
    243                 if (bound)
    244                 {
    245                     COUT(0) << "Press any button/key or move a mouse/joystick axis" << std::endl;
    246                     InputManager::getInstance().enterState("detector");
    247                     bindingString = command;
    248                     bTemporarySaved = bTemporary;
    249                     bound = false;
    250                 }
    251                 //else:  We're still in a keybind command. ignore this call.
    252             }
    253             else
    254             {
    255                 if (!bound)
    256                 {
    257                     // user has pressed the key
    258                     std::string name = command.substr(this->keyDetectorCallbackCode_.size());
    259                     COUT(0) << "Binding string \"" << bindingString << "\" on key '" << name << "'" << std::endl;
    260                     this->keyBinder_->setBinding(bindingString, name, bTemporarySaved);
    261                     InputManager::getInstance().leaveState("detector");
    262                     bound = true;
    263                 }
    264                 // else: A key was pressed within the same tick, ignore it.
    265             }
    266         }
    267     }
    268180}
  • code/branches/core5/src/orxonox/gamestates/GSLevel.h

    r5850 r5863  
    5757        void unloadLevel();
    5858
    59         // console commands
    60         void keybind(const std::string& command);
    61         void tkeybind(const std::string& command);
    62         void keybindInternal(const std::string& command, bool bTemporary);
    63 
    64         KeyBinder*               keyBinder_;               //!< tool that loads and manages the input bindings
    6559        InputState*              gameInputState_;          //!< input state for normal ingame playing
    6660        InputState*              guiMouseOnlyInputState_;  //!< input state if we only need the mouse to use the GUI
    6761        InputState*              guiKeysOnlyInputState_;   //!< input state if we only need the keys to use the GUI
    68 
    69         //##### ConfigValues #####
    70         std::string           keyDetectorCallbackCode_;
    71 
    72         // console commands
    73         ConsoleCommand*       ccKeybind_;
    74         ConsoleCommand*       ccTkeybind_;
    7562    };
    7663}
  • code/branches/core5/src/orxonox/gamestates/GSMainMenu.cc

    r5855 r5863  
    3434#include "core/input/InputManager.h"
    3535#include "core/input/InputState.h"
     36#include "core/input/KeyBinderManager.h"
    3637#include "core/Game.h"
    3738#include "core/ConsoleCommand.h"
     
    5152        inputState_ = InputManager::getInstance().createInputState("mainMenu");
    5253        inputState_->setHandler(GUIManager::getInstancePtr());
     54        inputState_->setKeyHandler(KeyBinderManager::getInstance().getDefaultAsHandler());
    5355        inputState_->setJoyStickHandler(&InputHandler::EMPTY);
    5456        inputState_->setIsExclusiveMouse(false);
     
    8688        CommandExecutor::addConsoleCommandShortcut(this->ccStartMainMenu_);
    8789
     90        KeyBinderManager::getInstance().setToDefault();
    8891        InputManager::getInstance().enterState("mainMenu");
    8992
Note: See TracChangeset for help on using the changeset viewer.