Planet
navi homePPSaboutscreenshotsdownloaddevelopmentforum

source: code/branches/wiimote/src/libraries/core/input/InputManager.cc @ 9853

Last change on this file since 9853 was 9840, checked in by georgr, 11 years ago

made two things static to fix everything

  • Property svn:eol-style set to native
File size: 26.8 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 *      Reto Grieder
24 *   Co-authors:
25 *      ...
26 *
27 */
28
29/**
30@file
31@brief
32    Implementation of the InputManager and a static variable from the InputHandler.
33*/
34
35#include "InputManager.h"
36
37#include <cassert>
38#include <climits>
39#include <ois/OISException.h>
40#include <ois/OISInputManager.h>
41#include <boost/foreach.hpp>
42#include <loki/ScopeGuard.h>
43
44#include "util/Clock.h"
45#include "util/Convert.h"
46#include "util/Exception.h"
47#include "core/CoreIncludes.h"
48#include "core/GraphicsManager.h"
49#include "core/config/ConfigValueIncludes.h"
50#include "core/config/CommandLineParser.h"
51#include "core/command/ConsoleCommand.h"
52#include "core/command/Functor.h"
53
54#include "InputBuffer.h"
55#include "JoyStick.h"
56#include "JoyStickQuantityListener.h"
57#include "Mouse.h"
58#include "Keyboard.h"
59
60#include "WiiMote.h"
61
62
63namespace orxonox
64{
65    SetCommandLineSwitch(keyboard_no_grab).information("Whether not to exclusively grab the keyboard");
66
67    static const std::string __CC_InputManager_name = "InputManager";
68    static const std::string __CC_calibrate_name = "calibrate";
69    static const std::string __CC_reload_name = "reload";
70
71    SetConsoleCommand(__CC_InputManager_name, __CC_calibrate_name, &InputManager::calibrate).addShortcut();
72    SetConsoleCommand(__CC_InputManager_name, __CC_reload_name,    &InputManager::reload   );
73
74    // Abuse of this source file for the InputHandler
75    InputHandler InputHandler::EMPTY;
76
77    InputManager* InputManager::singletonPtr_s = 0;
78
79    //! Defines the |= operator for easier use.
80    inline InputManager::State operator|=(InputManager::State& lval, InputManager::State rval)
81    {
82        return (lval = (InputManager::State)(lval | rval));
83    }
84
85    //! Defines the &= operator for easier use.
86    inline InputManager::State operator&=(InputManager::State& lval, int rval)
87    {
88        return (lval = (InputManager::State)(lval & rval));
89    }
90
91    // ############################################################
92    // #####                  Initialisation                  #####
93    // ##########                                        ##########
94    // ############################################################
95    InputManager::InputManager()
96        : internalState_(Bad)
97        , oisInputManager_(0)
98        , devices_(2)
99        , exclusiveMouse_(false)
100        , emptyState_(0)
101        , calibratorCallbackHandler_(0)
102    {
103        RegisterObject(InputManager);
104
105        orxout(internal_status, context::input) << "InputManager: Constructing..." << endl;
106
107        // Allocate space for the function call buffer
108        this->callBuffer_.reserve(16);
109
110        this->setConfigValues();
111
112        if (GraphicsManager::getInstance().isFullScreen())
113            exclusiveMouse_ = true;
114        this->loadDevices();
115
116        // Lowest priority empty InputState
117        emptyState_ = createInputState("empty", false, false, InputStatePriority::Empty);
118        emptyState_->setHandler(&InputHandler::EMPTY);
119        activeStates_[emptyState_->getPriority()] = emptyState_;
120
121        // Joy stick calibration helper callback
122        InputState* calibrator = createInputState("calibrator", false, false, InputStatePriority::Calibrator);
123        calibrator->setHandler(&InputHandler::EMPTY);
124        calibratorCallbackHandler_ = new InputBuffer();
125        calibratorCallbackHandler_->registerListener(this, &InputManager::stopCalibration, '\r', true);
126        calibrator->setKeyHandler(calibratorCallbackHandler_);
127
128        this->updateActiveStates();
129
130        ModifyConsoleCommand(__CC_InputManager_name, __CC_calibrate_name).setObject(this);
131        ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(this);
132
133        orxout(internal_status, context::input) << "InputManager: Construction complete." << endl;
134        internalState_ = Nothing;
135    }
136
137    void InputManager::setConfigValues()
138    {
139    }
140
141    /**
142    @brief
143        Creates the OIS::InputMananger, the keyboard, the mouse and
144        the joys ticks. If either of the first two fail, this method throws an exception.
145    */
146    void InputManager::loadDevices()
147    {
148        orxout(verbose, context::input) << "InputManager: Loading input devices..." << endl;
149
150        // When loading the devices they should not already be loaded
151        assert(internalState_ & Bad);
152        assert(devices_[InputDeviceEnumerator::Mouse] == 0);
153        assert(devices_[InputDeviceEnumerator::Keyboard] == 0);
154        assert(devices_.size() == InputDeviceEnumerator::FirstJoyStick);
155
156        typedef std::pair<std::string, std::string> StringPair;
157
158        // Fill parameter list
159        OIS::ParamList paramList;
160        size_t windowHnd = GraphicsManager::getInstance().getRenderWindowHandle();
161        paramList.insert(StringPair("WINDOW", multi_cast<std::string>(windowHnd)));
162#if defined(ORXONOX_PLATFORM_WINDOWS)
163        paramList.insert(StringPair("w32_keyboard", "DISCL_NONEXCLUSIVE"));
164        paramList.insert(StringPair("w32_keyboard", "DISCL_FOREGROUND"));
165        paramList.insert(StringPair("w32_mouse", "DISCL_FOREGROUND"));
166        if (exclusiveMouse_ || GraphicsManager::getInstance().isFullScreen())
167        {
168            // Disable Windows key plus special keys (like play, stop, next, etc.)
169            paramList.insert(StringPair("w32_keyboard", "DISCL_NOWINKEY"));
170            paramList.insert(StringPair("w32_mouse", "DISCL_EXCLUSIVE"));
171        }
172        else
173            paramList.insert(StringPair("w32_mouse", "DISCL_NONEXCLUSIVE"));
174#elif defined(ORXONOX_PLATFORM_LINUX)
175        // Enabling this is probably a bad idea, but whenever orxonox crashes, the setting stays on
176        // Trouble might be that the Pressed event occurs a bit too often...
177        paramList.insert(StringPair("XAutoRepeatOn", "true"));
178
179        if (exclusiveMouse_ || GraphicsManager::getInstance().isFullScreen())
180        {
181            if (CommandLineParser::getValue("keyboard_no_grab").get<bool>())
182                paramList.insert(StringPair("x11_keyboard_grab", "false"));
183            else
184                paramList.insert(StringPair("x11_keyboard_grab", "true"));
185            paramList.insert(StringPair("x11_mouse_grab",  "true"));
186            paramList.insert(StringPair("x11_mouse_hide", "true"));
187        }
188        else
189        {
190            paramList.insert(StringPair("x11_keyboard_grab", "false"));
191            paramList.insert(StringPair("x11_mouse_grab",  "false"));
192            paramList.insert(StringPair("x11_mouse_hide", "false"));
193        }
194#endif
195
196        try
197        {
198            oisInputManager_ = OIS::InputManager::createInputSystem(paramList);
199            // Exception-safety
200            Loki::ScopeGuard guard = Loki::MakeGuard(OIS::InputManager::destroyInputSystem, oisInputManager_);
201            orxout(verbose, context::input) << "Created OIS input manager." << endl;
202
203            if (oisInputManager_->getNumberOfDevices(OIS::OISKeyboard) > 0)
204                devices_[InputDeviceEnumerator::Keyboard] = new Keyboard(InputDeviceEnumerator::Keyboard, oisInputManager_);
205            else
206                ThrowException(InitialisationFailed, "InputManager: No keyboard found, cannot proceed!");
207
208            // Successful initialisation
209            guard.Dismiss();
210        }
211        catch (const std::exception& ex)
212        {
213            oisInputManager_ = NULL;
214            internalState_ |= Bad;
215            ThrowException(InitialisationFailed, "Could not initialise the input system: " << ex.what());
216        }
217
218        this->loadMouse();
219        this->loadJoySticks();
220        this->loadWiiMote();
221        // Reorder states in case some joy sticks were added/removed
222        this->updateActiveStates();
223
224        orxout(verbose, context::input) << "Input devices loaded." << endl;
225    }
226
227    void InputManager::loadWiiMote()
228    {
229
230
231
232        static CWii wii; // Defaults to 4 remotes; static because else it will get deleted during InternalReload
233        std::vector< ::CWiimote>::iterator i;
234        int reloadWiimotes = 0;
235        int index;
236
237        // Find and connect to the wiimotes
238        static std::vector<CWiimote>& wiimotes = wii.FindAndConnect(10); //CWiimotes are kept in here in case of InternalReload calls
239        if (!wiimotes.size())
240        {
241                cout << "No wiimotes found." << endl;
242                return;
243                }
244
245            // Setup the wiimotes
246            for(index = 0, i = wiimotes.begin(); i != wiimotes.end(); ++i, ++index)
247            {
248                // Use a reference to make working with the iterator handy.
249            CWiimote & wiimote = *i;
250
251            //Set Leds
252            int LED_MAP[4] =
253              {CWiimote::LED_1, CWiimote::LED_2,
254               CWiimote::LED_3, CWiimote::LED_4};
255            wiimote.SetLEDs(LED_MAP[index]);
256            try
257                       {
258                         orxout()<< "Size of devices vector before wiimote insertion:" << devices_.size() << std::endl;
259                         devices_.push_back(new WiiMote((unsigned int)devices_.size(), *i, wii));
260                         //devices_[2] = new WiiMote(devices_.size(), *(new CWiimote()));
261                         orxout()<< "Size of devices vector after wiimote insertion:" << devices_.size() << std::endl;
262
263                       }
264                       catch(std::exception& e)  //gotta catch em all
265                       {
266                         orxout()<<"Exception loading WiiMote!!!1!11!";
267                       }
268
269
270
271        }
272
273
274    }
275    //! Creates a new orxonox::Mouse
276    void InputManager::loadMouse()
277    {
278        if (oisInputManager_->getNumberOfDevices(OIS::OISMouse) > 0)
279        {
280            try
281            {
282                devices_[InputDeviceEnumerator::Mouse] = new Mouse(InputDeviceEnumerator::Mouse, oisInputManager_);
283            }
284            catch (const std::exception& ex)
285            {
286                orxout(user_warning, context::input) << "Failed to create Mouse:" << ex.what() << '\n'
287                                                     << "Proceeding without mouse support." << endl;
288            }
289        }
290        else
291            orxout(user_warning, context::input) << "No mouse found! Proceeding without mouse support." << endl;
292    }
293
294    //! Creates as many joy sticks as are available.
295    void InputManager::loadJoySticks()
296    {
297        for (int i = 0; i < oisInputManager_->getNumberOfDevices(OIS::OISJoyStick); i++)
298        {
299            try
300            {
301                devices_.push_back(new JoyStick(InputDeviceEnumerator::FirstJoyStick + i, oisInputManager_));
302            }
303            catch (const std::exception& ex)
304            {
305                orxout(user_warning, context::input) << "Failed to create joy stick: " << ex.what() << endl;
306            }
307        }
308
309        // inform all JoyStick Device Number Listeners
310        std::vector<JoyStick*> joyStickList;
311        for (unsigned int i = InputDeviceEnumerator::FirstJoyStick; i < devices_.size(); ++i)
312            joyStickList.push_back(static_cast<JoyStick*>(devices_[i]));
313        JoyStickQuantityListener::changeJoyStickQuantity(joyStickList);
314    }
315
316    // ############################################################
317    // #####                    Destruction                   #####
318    // ##########                                        ##########
319    // ############################################################
320
321    InputManager::~InputManager()
322    {
323        orxout(internal_status, context::input) << "InputManager: Destroying..." << endl;
324
325        // Leave all active InputStates (except "empty")
326        while (this->activeStates_.size() > 1)
327            this->leaveState(this->activeStates_.rbegin()->second->getName());
328        this->activeStates_.clear();
329
330        // Destroy calibrator helper handler and state
331        this->destroyState("calibrator");
332        // Destroy KeyDetector and state
333        delete calibratorCallbackHandler_;
334        // Destroy the empty InputState
335        this->destroyStateInternal(this->emptyState_);
336
337        // Destroy all user InputStates
338        while (statesByName_.size() > 0)
339            this->destroyStateInternal(statesByName_.rbegin()->second);
340
341        if (!(internalState_ & Bad))
342            this->destroyDevices();
343
344        // Reset console commands
345        ModifyConsoleCommand(__CC_InputManager_name, __CC_calibrate_name).setObject(0);
346        ModifyConsoleCommand(__CC_InputManager_name, __CC_reload_name).setObject(0);
347
348        orxout(internal_status, context::input) << "InputManager: Destruction complete." << endl;
349    }
350
351    /**
352    @brief
353        Destoys all input devices (joy sticks, mouse, keyboard and OIS::InputManager)
354    @throw
355        Method does not throw
356    */
357    void InputManager::destroyDevices()
358    {
359        orxout(verbose, context::input) << "InputManager: Destroying devices..." << endl;
360
361        BOOST_FOREACH(InputDevice*& device, devices_)
362        {
363            if (device == NULL)
364                continue;
365            const std::string& className = device->getClassName();
366            delete device;
367            device = 0;
368            orxout(verbose, context::input) << className << " destroyed." << endl;
369        }
370        devices_.resize(InputDeviceEnumerator::FirstJoyStick);
371
372        assert(oisInputManager_ != NULL);
373        try
374        {
375            OIS::InputManager::destroyInputSystem(oisInputManager_);
376        }
377        catch (const OIS::Exception& ex)
378        {
379            orxout(internal_error, context::input) << "OIS::InputManager destruction failed" << ex.eText << '\n'
380                                                   << "Potential resource leak!" << endl;
381        }
382        oisInputManager_ = NULL;
383
384        internalState_ |= Bad;
385        orxout(verbose, context::input) << "Destroyed devices." << endl;
386    }
387
388    // ############################################################
389    // #####                     Reloading                    #####
390    // ##########                                        ##########
391    // ############################################################
392
393    void InputManager::reload()
394    {
395        if (internalState_ & Calibrating)
396            orxout(internal_warning, context::input) << "Cannot reload input system. Joy sticks are currently being calibrated." << endl;
397        else
398            reloadInternal();
399    }
400
401    //! Internal reload method. Destroys the OIS devices and loads them again.
402    void InputManager::reloadInternal()
403    {
404        orxout(verbose, context::input) << "InputManager: Reloading ..." << endl;
405
406        this->destroyDevices();
407        this->loadDevices();
408
409        internalState_ &= ~Bad;
410        orxout(verbose, context::input) << "InputManager: Reloading complete." << endl;
411    }
412
413    // ############################################################
414    // #####                  Runtime Methods                 #####
415    // ##########                                        ##########
416    // ############################################################
417
418    void InputManager::preUpdate(const Clock& time)
419    {
420        if (internalState_ & Bad)
421            ThrowException(General, "InputManager was not correctly reloaded.");
422
423        // check whether a state has changed its EMPTY situation
424        bool bUpdateRequired = false;
425        for (std::map<int, InputState*>::iterator it = activeStates_.begin(); it != activeStates_.end(); ++it)
426        {
427            if (it->second->hasExpired())
428            {
429                it->second->resetExpiration();
430                bUpdateRequired = true;
431            }
432        }
433        if (bUpdateRequired)
434            updateActiveStates();
435
436        // Capture all the input and collect the function calls
437        // No event gets triggered here yet!
438        BOOST_FOREACH(InputDevice* device, devices_)
439            if (device != NULL)
440                device->update(time);
441
442        // Collect function calls for the update
443        for (unsigned int i = 0; i < activeStatesTicked_.size(); ++i)
444            activeStatesTicked_[i]->update(time.getDeltaTime());
445
446        // Execute all cached function calls in order
447        // Why so complicated? The problem is that an InputHandler could trigger
448        // a reload that would destroy the OIS devices or it could even leave and
449        // then destroy its own InputState. That would of course lead to access
450        // violations.
451        // If we delay the calls, then OIS and and the InputStates are not anymore
452        // in the call stack and can therefore be edited.
453        for (size_t i = 0; i < this->callBuffer_.size(); ++i)
454            this->callBuffer_[i]();
455
456        this->callBuffer_.clear();
457    }
458
459    /**
460    @brief
461        Updates the currently active states (according to activeStates_) for each device.
462        Also, a list of all active states (no duplicates!) is compiled for the general preUpdate().
463    */
464    void InputManager::updateActiveStates()
465    {
466        // Calculate the stack of input states
467        // and assign it to the corresponding device
468        for (unsigned int i = 0; i < devices_.size(); ++i)
469        {
470            if (devices_[i] == NULL)
471                continue;
472            std::vector<InputState*>& states = devices_[i]->getStateListRef();
473            bool occupied = false;
474            states.clear();
475            for (std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin(); rit != activeStates_.rend(); ++rit)
476            {
477                orxout() << "Checking ID " << i <<std::endl;
478                orxout() << "Checking condition 1: " << rit->second->isInputDeviceEnabled(i) <<std::endl;
479                orxout() << "Checking condition 2: " << rit->second->bAlwaysGetsInput_ <<std::endl;
480                orxout() << "Checking condition 3: " << !occupied <<std::endl;
481                if (rit->second->isInputDeviceEnabled(i) && (!occupied || rit->second->bAlwaysGetsInput_))
482                {
483                    orxout() << "Success with ID " << i <<std::endl;
484                    states.push_back(rit->second);
485                    if (!rit->second->bTransparent_)
486                        occupied = true;
487                }
488            }
489        }
490
491        // See that we only update each InputState once for each device
492        // Using an std::set to avoid duplicates
493        std::set<InputState*> tempSet;
494        for (unsigned int i = 0; i < devices_.size(); ++i)
495            if (devices_[i] != NULL)
496                for (unsigned int iState = 0; iState < devices_[i]->getStateListRef().size(); ++iState)
497                    tempSet.insert(devices_[i]->getStateListRef()[iState]);
498
499        // Copy the content of the std::set back to the actual vector
500        activeStatesTicked_.clear();
501        for (std::set<InputState*>::const_iterator it = tempSet.begin();it != tempSet.end(); ++it)
502            activeStatesTicked_.push_back(*it);
503
504        // Check whether we have to change the mouse mode
505        tribool requestedMode = dontcare;
506        std::vector<InputState*>& mouseStates = devices_[InputDeviceEnumerator::Mouse]->getStateListRef();
507        if (mouseStates.empty())
508            requestedMode = false;
509        else
510            requestedMode = mouseStates.front()->getMouseExclusive();
511        if (requestedMode != dontcare && exclusiveMouse_ != requestedMode)
512        {
513            assert(requestedMode != dontcare);
514            exclusiveMouse_ = (requestedMode == true);
515            if (!GraphicsManager::getInstance().isFullScreen())
516                this->reloadInternal();
517        }
518    }
519
520    void InputManager::clearBuffers()
521    {
522        BOOST_FOREACH(InputDevice* device, devices_)
523            if (device != NULL)
524                device->clearBuffers();
525    }
526
527    void InputManager::calibrate()
528    {
529        orxout(message) << "Move all joy stick axes fully in all directions." << '\n'
530                        << "When done, put the axex in the middle position and press enter." << endl;
531
532        BOOST_FOREACH(InputDevice* device, devices_)
533            if (device != NULL)
534                device->startCalibration();
535
536        internalState_ |= Calibrating;
537        enterState("calibrator");
538    }
539
540    //! Tells all devices to stop the calibration and evaluate it. Buffers are being cleared as well!
541    void InputManager::stopCalibration()
542    {
543        BOOST_FOREACH(InputDevice* device, devices_)
544            if (device != NULL)
545                device->stopCalibration();
546
547        // restore old input state
548        leaveState("calibrator");
549        internalState_ &= ~Calibrating;
550        // Clear buffers to prevent button hold events
551        this->clearBuffers();
552
553        orxout(message) << "Calibration has been stored." << endl;
554    }
555
556    //! Gets called by WindowEventListener upon focus change --> clear buffers
557    void InputManager::windowFocusChanged(bool bFocus)
558    {
559        this->clearBuffers();
560    }
561
562    std::pair<int, int> InputManager::getMousePosition() const
563    {
564        Mouse* mouse = static_cast<Mouse*>(devices_[InputDeviceEnumerator::Mouse]);
565        if (mouse != NULL)
566        {
567            const OIS::MouseState state = mouse->getOISDevice()->getMouseState();
568            return std::make_pair(state.X.abs, state.Y.abs);
569        }
570        else
571            return std::make_pair(0, 0);
572    }
573
574    // ############################################################
575    // #####                    Input States                  #####
576    // ##########                                        ##########
577    // ############################################################
578
579    InputState* InputManager::createInputState(const std::string& name, bool bAlwaysGetsInput, bool bTransparent, InputStatePriority priority)
580    {
581        if (name.empty())
582            return 0;
583        if (statesByName_.find(name) == statesByName_.end())
584        {
585            if (priority >= InputStatePriority::HighPriority || priority == InputStatePriority::Empty)
586            {
587                // Make sure we don't add two high priority states with the same priority
588                for (std::map<std::string, InputState*>::const_iterator it = this->statesByName_.begin();
589                    it != this->statesByName_.end(); ++it)
590                {
591                    if (it->second->getPriority() == priority)
592                    {
593                        orxout(internal_warning, context::input) << "Could not add an InputState with the same priority '"
594                            << static_cast<int>(priority) << "' != 0." << endl;
595                        return 0;
596                    }
597                }
598            }
599            InputState* state = new InputState(name, bAlwaysGetsInput, bTransparent, priority);
600            statesByName_[name] = state;
601
602            return state;
603        }
604        else
605        {
606            orxout(internal_warning, context::input) << "Could not add an InputState with the same name '" << name << "'." << endl;
607            return 0;
608        }
609    }
610
611    InputState* InputManager::getState(const std::string& name)
612    {
613        std::map<std::string, InputState*>::iterator it = statesByName_.find(name);
614        if (it != statesByName_.end())
615            return it->second;
616        else
617            return 0;
618    }
619
620    bool InputManager::enterState(const std::string& name)
621    {
622        // get pointer from the map with all stored handlers
623        std::map<std::string, InputState*>::const_iterator it = statesByName_.find(name);
624        if (it != statesByName_.end() && activeStates_.find(it->second->getPriority()) == activeStates_.end())
625        {
626            // exists and not active
627            if (it->second->getPriority() == 0)
628            {
629                // Get smallest possible priority between 1 and maxStateStackSize_s
630                for (std::map<int, InputState*>::reverse_iterator rit = activeStates_.rbegin();
631                    rit != activeStates_.rend(); ++rit)
632                {
633                    if (rit->first < InputStatePriority::HighPriority)
634                    {
635                        it->second->setPriority(rit->first + 1);
636                        break;
637                    }
638                }
639                // In case no normal handler was on the stack
640                if (it->second->getPriority() == 0)
641                    it->second->setPriority(1);
642            }
643            activeStates_[it->second->getPriority()] = it->second;
644            updateActiveStates();
645            it->second->entered();
646
647            return true;
648        }
649        return false;
650    }
651
652    bool InputManager::leaveState(const std::string& name)
653    {
654        if (name == "empty")
655        {
656            orxout(internal_warning, context::input) << "InputManager: Leaving the empty state is not allowed!" << endl;
657            return false;
658        }
659        // get pointer from the map with all stored handlers
660        std::map<std::string, InputState*>::const_iterator it = statesByName_.find(name);
661        if (it != statesByName_.end() && activeStates_.find(it->second->getPriority()) != activeStates_.end())
662        {
663            // exists and active
664
665            it->second->left();
666
667            activeStates_.erase(it->second->getPriority());
668            if (it->second->getPriority() < InputStatePriority::HighPriority)
669                it->second->setPriority(0);
670            updateActiveStates();
671
672            return true;
673        }
674        return false;
675    }
676
677    bool InputManager::destroyState(const std::string& name)
678    {
679        if (name == "empty")
680        {
681            orxout(internal_warning, context::input) << "InputManager: Removing the empty state is not allowed!" << endl;
682            return false;
683        }
684        std::map<std::string, InputState*>::iterator it = statesByName_.find(name);
685        if (it != statesByName_.end())
686        {
687            this->leaveState(name);
688            destroyStateInternal(it->second);
689
690            return true;
691        }
692        return false;
693    }
694
695    //! Destroys an InputState internally.
696    void InputManager::destroyStateInternal(InputState* state)
697    {
698        assert(state && this->activeStates_.find(state->getPriority()) == this->activeStates_.end());
699        statesByName_.erase(state->getName());
700        delete state;
701    }
702
703    bool InputManager::setMouseExclusive(const std::string& name, tribool value)
704    {
705        if (name == "empty")
706        {
707            orxout(internal_warning, context::input) << "InputManager: Changing the empty state is not allowed!" << endl;
708            return false;
709        }
710        std::map<std::string, InputState*>::iterator it = statesByName_.find(name);
711        if (it != statesByName_.end())
712        {
713            it->second->setMouseExclusive(value);
714            return true;
715        }
716        return false;
717    }
718}
Note: See TracBrowser for help on using the repository browser.