MercuryInput.h

Go to the documentation of this file.

#ifndef _MERCURY_INPUT_H
#define _MERCURY_INPUT_H

#include <map>
#include "MercuryString.h"
#include "MercuryVector.h"

enum EventType
{
    IET_NONE,
    IET_DOWN,
    IET_RELEASE,
    IET_REPEAT,
};

class InputEvent
{
public:
    InputEvent( ) : DeviceNumber( 0 ), ButtonNumber( 0 ), Type( IET_NONE ) { }
    InputEvent( int DevNum, int BtnNum, EventType IET ) :
        DeviceNumber( DevNum ), ButtonNumber( BtnNum ), Type ( IET )
        {   }
    int DeviceNumber;
    int ButtonNumber;
    EventType Type;
};

class InputDevice
{
public:
    virtual ~InputDevice() {};

    virtual void    Init( MString Name ) = 0;
    virtual bool    IsButtonDown( int ButtonNumber ) = 0;
    virtual int     NumButtons() = 0;
    virtual void    Update( );
    virtual InputEvent  PopLastEvent() = 0;
};

class InputDeviceTracker
{
public:
    ~InputDeviceTracker();
    bool AddDevice( MString Name, InputDevice * Device );
    InputDevice* ToDevice( MString Name );
    MString ListAvailableDevices();
private:
    std::map < MString, InputDevice * > *m_pDevices;
};

extern InputDeviceTracker AutoInputDeviceTracker;

class CursorDevice
{
public: 
    CursorDevice();
    virtual ~CursorDevice() {};

    virtual void GetPosition( int &x, int &y ) = 0;
    virtual void Update( ) = 0;
    static void UpdateFocus( const MString &message, void * data, void * info );
protected:
    int m_x, m_y;
    int m_Xoff, m_Yoff;
    static bool m_bHasFocus;
    bool    m_bSubscribed;
};

extern CursorDevice * DefaultCursorDevice;

class MercuryInputManager
{
public:
    MercuryInputManager( );
    ~MercuryInputManager( ) { };

    void Update();

    bool IsButtonDown( int DeviceNumber, int ButtonNumber )
    { return m_vDevices[DeviceNumber]->IsButtonDown( ButtonNumber); }

    bool IsButtonDown( int code );

    InputEvent  PopLastEvent();

    bool GetCursorPosition( int &x, int &y ) 
    { if ( DefaultCursorDevice != NULL ) {
    DefaultCursorDevice->GetPosition( x, y ); 
    return true; } return false;}

private:
    MVector< InputDevice * > m_vDevices;
};

extern MercuryInputManager * INPUTMAN;

class InputMappingTracker   
{
public:
    ~InputMappingTracker() 
    { delete m_pMappings; }

    void ReadInMappingsFromINI();
    int MakeMappingCode( const MString& Name );
    int MakeMappingCode( const MString& Name, const MString Default );

    int InputEventNameToCode( const MString & IE );
    int InputEventToCode( const InputEvent & IE );
    void CodeToHardware( int code, MVector<InputEvent> &out );
private:
    std::map < MString, int >   *m_pMappings;
    std::map < MString, int >   *m_pCodes;
    std::map < MString, MString >   *m_pAutoCodes;
    MVector< MVector<InputEvent> >      m_vDemapped;
    int m_iCurMapNumber;
};

extern InputMappingTracker AutoInputMappingTracker;

#define KeyMapping( x ) \
    const int x = AutoInputMappingTracker.MakeMappingCode( #x )

#define KeyMappingWithCode( x, y ) \
    const int x = AutoInputMappingTracker.MakeMappingCode( #x, y )

class PStack;
struct InputMessageStruct
{
    InputMessageStruct();
    InputMessageStruct( PStack & toload );
    int device;
    int button;
    int code;
    EventType type;
};

class DeviceNull : public InputDevice
{
public:
    virtual ~DeviceNull() {};

    virtual void    Init( MString Name ) { };
    virtual bool    IsButtonDown( int ButtonNumber ) { return false; }
    virtual int     NumButtons() { return 0; }
    virtual void    Update( ) { }
    virtual InputEvent  PopLastEvent() { return InputEvent( 0,0,IET_NONE); }
};

enum AllKBKeys
{
    KB_0,
    KB_MOUSE1,
    KB_MOUSE2,
    KB_3,
    KB_4,
    KB_5
};

char KeyToChar( char cHardwareChar, bool bShiftPressed );

#endif

/* 
 * Copyright (c) 2005-2006, Charles Lohr
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or
 * without modification, are permitted provided that the following
 * conditions are met:
 *  -   Redistributions of source code must retain the above
 *      copyright notice, this list of conditions and the following disclaimer.
 *  -   Redistributions in binary form must reproduce the above copyright
 *      notice, this list of conditions and the following disclaimer in
 *      the documentation and/or other materials provided with the distribution.
 *  -   Neither the name of the Mercury Engine nor the names of its
 *      contributors may be used to endorse or promote products derived from
 *      this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
 * USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */

---

Hosted by