device_config.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 HEADER_DEVICE_CONFIG_HPP
#define HEADER_DEVICE_CONFIG_HPP
 
#include "input/binding.hpp"
#include "input/input.hpp"
#include "utils/no_copy.hpp"
 
#include <assert.h>
#include <iosfwd>
#include <irrString.h>
#include <string>
 
//==== D E V I C E C O N F I G =================================================
 
class DeviceConfig : public NoCopy
{
 
private:
    bool m_enabled;
 
    int m_plugged; 
 
    std::string m_name;
 
    irr::core::stringw m_config_name;
 
protected:
 
    Binding  m_bindings[PA_COUNT];
 
    DeviceConfig();
 
    bool doGetAction(Input::InputType    type,
                     const int           id,
                     int*                value, /* inout */
                     const PlayerAction  firstActionToCheck,
                     const PlayerAction  lastActionToCheck,
                     PlayerAction*       action /* out */ );
protected:
    friend class GamePadDevice;
    friend class KeyboardDevice;
    bool getGameAction(Input::InputType       type,
                       const int              id,
                       int*                   value, /* inout */
                       PlayerAction*          action /* out */);
 
public:
 
    virtual ~DeviceConfig() {}
 
    static DeviceConfig* create(const XMLNode *config);
    irr::core::stringw toString();
    bool hasBindingFor(const int buttonID) const;
    bool hasBindingFor(const int buttonID, PlayerAction from,
                       PlayerAction to) const;
    void setBinding(const PlayerAction     action,
                    const Input::InputType type,
                    const int              id,
                    Input::AxisDirection   direction = Input::AD_NEUTRAL,
                    Input::AxisRange       range     = Input::AR_HALF);
    bool getMenuAction(Input::InputType       type,
                       const int              id,
                       int*                   value,
                       PlayerAction*          action /* out */);
    irr::core::stringw getMappingIdString (const PlayerAction action) const;
    virtual irr::core::stringw getBindingAsString(const PlayerAction action) const;
    virtual bool isGamePad()  const = 0;
    virtual bool isKeyboard() const = 0;
 
    virtual void save(std::ofstream& stream);
    virtual bool load(const XMLNode *config);
 
    // ------------------------------------------------------------------------
    virtual bool isAnalog(Input::InputType type, int id) const { return false;}
    // ------------------------------------------------------------------------
    virtual bool desensitize() const { return false;}
    // ------------------------------------------------------------------------
    virtual int getNumberOfButtons() const
    {
        assert(false); return 0;
    }   // getNumberOfButtons
 
    // ------------------------------------------------------------------------
    virtual int getNumberOfAxes() const
    {
        assert(false); return 0;
    }   // getNumberOfAxes
 
    // ------------------------------------------------------------------------
    void setName(const std::string &name) { m_name = name; }
 
    // ------------------------------------------------------------------------
    const std::string& getName() const { return m_name; };
 
    // ------------------------------------------------------------------------
    void setPlugged() { m_plugged++; }
 
    // ------------------------------------------------------------------------
    bool isPlugged() const { return m_plugged > 0; }
 
    // ------------------------------------------------------------------------
    void unPlugged()
    {
        m_plugged--;
        assert(m_plugged >= 0);
    }
 
    // ------------------------------------------------------------------------
    int getNumberOfDevices() const { return m_plugged;     }
 
    // ------------------------------------------------------------------------
    const Binding& getBinding(int i) const {return m_bindings[i];}
 
    // ------------------------------------------------------------------------
    bool isEnabled() const { return m_enabled; }
 
    // ------------------------------------------------------------------------
    void setEnabled(bool new_value) { m_enabled = new_value; }
 
    // ------------------------------------------------------------------------
    irr::core::stringw getConfigName() const { return m_config_name;  }
 
    // ------------------------------------------------------------------------
    void setConfigName( irr::core::stringw config_name ) { m_config_name = config_name; }
};   // class DeviceConfig
 
#endif