device_manager.hpp

//
//  SuperTuxKart - a fun racing game with go-kart
//  Copyright (C) 2010-2015 SuperTuxKart-Team
//
//  This program is free software; you can redistribute it and/or
//  modify it under the terms of the GNU General Public License
//  as published by the Free Software Foundation; either version 3
//  of the License, or (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program; if not, write to the Free Software
//  Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
 
#ifndef DEVICE_MANAGER_HPP
#define DEVICE_MANAGER_HPP
 
#include "input/gamepad_config.hpp"
#include "input/input_manager.hpp"
#include "input/keyboard_config.hpp"
#include "states_screens/state_manager.hpp"
#include "utils/no_copy.hpp"
#include "utils/ptr_vector.hpp"
 
#include <irrArray.h>
#include <IEventReceiver.h>
using namespace irr;
 
class DeviceConfig;
class InputDevice;
class GamePadDevice;
class KeyboardDevice;
class MultitouchDevice;
 
 
enum PlayerAssignMode
{
    NO_ASSIGN,  
    DETECT_NEW, 
    ASSIGN      
};
 
class DeviceManager: public NoCopy
{
private:
 
    PtrVector<KeyboardDevice, HOLD>    m_keyboards;
    PtrVector<GamePadDevice, HOLD>     m_gamepads;
    PtrVector<KeyboardConfig, HOLD>    m_keyboard_configs;
    PtrVector<GamepadConfig, HOLD>     m_gamepad_configs;
    MultitouchDevice*                  m_multitouch_device;
 
    InputDevice*                       m_latest_used_device;
    PlayerAssignMode                   m_assign_mode;
 
 
    StateManager::ActivePlayer* m_single_player;
 
    bool m_map_fire_to_select;
 
 
    InputDevice *mapGamepadInput( Input::InputType type, int deviceID,
                                  int btnID, int axisDir,
                                  int* value /* inout */,
                                  InputManager::InputDriverMode mode,
                                  StateManager::ActivePlayer **player /* out */,
                                  PlayerAction *action /* out */);
    InputDevice *mapKeyboardInput(int button_id,
                                  InputManager::InputDriverMode mode,
                                  StateManager::ActivePlayer **player /* out */,
                                  PlayerAction *action /* out */);
 
    bool load();
    void shutdown();
 
public:
 
 
    DeviceManager();
    ~DeviceManager();
 
    // ---- Assign mode ----
    PlayerAssignMode    getAssignMode() const               { return m_assign_mode; }
    void                setAssignMode(const PlayerAssignMode assignMode);
 
    // ---- Gamepads ----
    void addGamepad(GamePadDevice* d);
    int getGamePadAmount() const                            { return m_gamepads.size(); }
    int getGamePadConfigAmount() const                      { return m_gamepad_configs.size(); }
    GamePadDevice*      getGamePad(const int i)             { return m_gamepads.get(i); }
    GamepadConfig*      getGamepadConfig(const int i)       { return m_gamepad_configs.get(i); }
    GamePadDevice*      getGamePadFromIrrID(const int i);
    void                clearGamepads();
    bool                getConfigForGamepad(const int sdl_id, 
                                            const std::string& name,
                                            GamepadConfig **config);
 
    // ---- Keyboard(s) ----
    void addEmptyKeyboard();
    void addKeyboard(KeyboardDevice* d);
    void                clearKeyboard();
    int                 getKeyboardAmount()                 { return m_keyboards.size(); }
    int                 getActiveKeyboardAmount()
    {
        int active = 0;
        for (unsigned int i=0;i<m_keyboard_configs.size();i++)
        {
            if (m_keyboard_configs[i].isEnabled()) active++;
        }
        return active;
    }
    int                 getKeyboardConfigAmount() const     { return m_keyboard_configs.size(); }
    KeyboardDevice*     getKeyboard(const int i)            { return m_keyboards.get(i); }
    KeyboardConfig*     getKeyboardConfig(const int i)      { return m_keyboard_configs.get(i); }
    KeyboardDevice*     getKeyboardFromBtnID(const int btnID);
 
    // ---- Multitouch device ----
    MultitouchDevice*   getMultitouchDevice()    { return m_multitouch_device; }
    void                clearMultitouchDevices();
    void                updateMultitouchDevice();
 
 
    bool deleteConfig(DeviceConfig* config);
 
    bool translateInput( Input::InputType type,
                         int deviceID,
                         int btnID,
                         int axisDir,
                         int *value /* inout */,
                         InputManager::InputDriverMode mode,
                         StateManager::ActivePlayer** player /* out */,
                         PlayerAction* action /* out */ );
 
    void                clearLatestUsedDevice();
    InputDevice*        getLatestUsedDevice();
    bool initialize();
    void save();
 
    // ------------------------------------------------------------------------
    StateManager::ActivePlayer* getSinglePlayer()  { return m_single_player; }
    // ------------------------------------------------------------------------
    void setSinglePlayer(StateManager::ActivePlayer* p)
    {
        m_single_player = p; 
    }   // setSinglePlayer
    // ------------------------------------------------------------------------
    void mapFireToSelect(bool v) {m_map_fire_to_select = v; }
 
};   // DeviceManager
 
 
#endif