MercuryInput.cpp

Go to the documentation of this file.

#include "MercuryInput.h"
#include "MercuryINI.h"
#include "MercuryUtil.h"
#include "MercuryMessages.h"
#include "MercuryDisplay.h"

MercuryInputManager * INPUTMAN = NULL;
InputDeviceTracker AutoInputDeviceTracker;
InputMappingTracker AutoInputMappingTracker;

//Setup NULL devices incase we don't compile any in.
bool NullResponce = AutoInputDeviceTracker.AddDevice( "Null", new DeviceNull );
//CursorDevice * DefaultCursorDevice = NULL;

bool CursorDevice::m_bHasFocus;



InputMessageStruct::InputMessageStruct()
{
    button = 0;
    code = 0;
    device = 0;
    type = IET_NONE;
}

InputMessageStruct::InputMessageStruct( PStack & toload )
{
    device = toload.PopItem().GetValueI();
    button = toload.PopItem().GetValueI();
    type = (EventType)toload.PopItem().GetValueI();
    code = toload.PopItem().GetValueI();
}

void InputDevice::Update()
{
    //No code
}

#define RegisterInputDevice( y ) \
    bool c = AutoInputDeviceTracker.AddDevice( #y, new y );


bool InputDeviceTracker::AddDevice( MString Name, InputDevice *Device)
{
    if ( m_pDevices == NULL )
        m_pDevices = new std::map < MString, InputDevice * >;

    if ( m_pDevices->find( Name ) != m_pDevices->end() )
    {
        SAFE_DELETE((*m_pDevices)[Name]);
        return true;
    }
    
    (*m_pDevices)[Name] = Device;

    return false;
}

InputDevice* InputDeviceTracker::ToDevice( MString Name )
{
    if ( m_pDevices == NULL )
        return NULL;

    if ( m_pDevices->find( Name ) == m_pDevices->end() )
        return NULL;
    
    return (*m_pDevices)[Name];
}

MString InputDeviceTracker::ListAvailableDevices()
{
    MString ret;
    std::map < MString, InputDevice * >::iterator cur,end;
    end = m_pDevices->end();
    for ( cur = m_pDevices->begin(); cur != end; cur++ )
    {
        if ( cur != m_pDevices->begin() )
            ret += ',';
        ret += cur->first;
    }
    return ret;
}

InputDeviceTracker::~InputDeviceTracker()
{
    std::map < MString, InputDevice * >::iterator cur,end;
    end = m_pDevices->end();
    for ( cur = m_pDevices->begin(); cur != end; cur++ )
        SAFE_DELETE( cur->second );
}

MercuryInputManager::MercuryInputManager()
{
    MString defr = AutoInputDeviceTracker.ListAvailableDevices();
    MString def = PREFSMAN->GetValueS( "Input", "Devices", defr, true );
    if ( def.length() == 0 )
        def = defr;

    const char* devs = def.c_str();
    int curloc = 0;
    while ( (unsigned)curloc < def.length() )
    {
        int nextloc = BytesUntil( devs, ", ", curloc, def.length(), 2 );
        MString DeviceName = def.substr( curloc, nextloc );

        m_vDevices.push_back( AutoInputDeviceTracker.ToDevice( DeviceName ) );
        m_vDevices[m_vDevices.size()-1]->Init(DeviceName);

        curloc += nextloc;
        nextloc = BytesNUntil( devs, ", ", curloc, def.length(), 2 );
        curloc += nextloc;
    }

    AutoInputMappingTracker.ReadInMappingsFromINI();
}

void MercuryInputManager::Update( )
{
    for ( int i = 0; (unsigned)i < m_vDevices.size(); i++ )
    {
        if ( m_vDevices[i] != NULL )
        {
            m_vDevices[i]->Update();
            InputEvent p = m_vDevices[i]->PopLastEvent();
            while ( p.Type != IET_NONE )
            {
                InputMessageStruct *k = new InputMessageStruct;
                k->code = AutoInputMappingTracker.InputEventToCode( p );
                k->button = p.ButtonNumber;
                k->type = p.Type;
                k->device = i;
                if (DISPLAY->GetWindow()->HasFocus())
                    if ( k->code != -1 )
                        MESSAGEMAN->BroadcastMessage( "mappedinput", PStack( PSElement( k->device ), PSElement( k->button ), PSElement( k->type ), PSElement( k->code ) ) );
                    else
                        MESSAGEMAN->BroadcastMessage( "unmappedinput", PStack( PSElement( k->device ), PSElement( k->button ), PSElement( k->type ), PSElement( k->code ) ) );
                SAFE_DELETE( k );
                p = m_vDevices[i]->PopLastEvent();
            }
        }
    }
    if ( DefaultCursorDevice != NULL ) 
        DefaultCursorDevice->Update();
}

bool MercuryInputManager::IsButtonDown( int code )
{
    MVector<InputEvent> buttons;
    AutoInputMappingTracker.CodeToHardware( code, buttons );
    for ( unsigned int i=0; i<buttons.size();i++)
        if ( IsButtonDown( buttons[i].DeviceNumber, buttons[i].ButtonNumber ) )
            return true;
    return false;
}


InputEvent MercuryInputManager::PopLastEvent()
{
    for ( int i = 0; (unsigned)i < m_vDevices.size(); i++ )
    {
        if ( m_vDevices[i] != NULL )
        {
            InputEvent k = m_vDevices[i]->PopLastEvent();
            if ( k.Type != IET_NONE )
            {
                k.DeviceNumber = i;
                return k;
            }
        }
    }
    return InputEvent( 0,0,IET_NONE);
}

int InputMappingTracker::MakeMappingCode( const MString& Name, const MString Default )
{
    if ( m_pAutoCodes == NULL )
    {
        m_pAutoCodes = new map< MString, MString >;
    }
    
    (*m_pAutoCodes)[Name] = Default;

    return MakeMappingCode( Name );
}

int InputMappingTracker::MakeMappingCode( const MString& Name )
{
    if ( m_pMappings == NULL )
    {
        m_pMappings = new map < MString, int >;
        m_iCurMapNumber = 1;
    }

    if ( m_pCodes == NULL )
    {
        m_pCodes = new std::map < MString , int >;
    }

    if ( m_pMappings->find( Name ) == m_pMappings->end() )
    {
        m_iCurMapNumber++;
        (*m_pMappings)[Name] = m_iCurMapNumber;
    }

    return (*m_pMappings)[Name];
}

void InputMappingTracker::ReadInMappingsFromINI()
{
    int CurMapNumber = 2;
    std::map < MString, int >::iterator cur,end;
    end = m_pMappings->end();
    for ( cur = m_pMappings->begin(); cur != end; cur++ )
    {
        MString Name = cur->first;
        CurMapNumber = cur->second;
        MString k = PREFSMAN->GetValueS( "InputMapper", Name, (*m_pAutoCodes)[Name], true );
        const char* devs = k.c_str();
        int curloc = 0;
        while ( (unsigned)curloc < k.length() )
        {
            int nextloc = BytesUntil( devs, ", ", curloc, k.length(), 2 );
            MString MapName = k.substr( curloc, nextloc );
            (*m_pCodes)[MapName] = CurMapNumber;
            
            //Actually decode the code.

            int strt = BytesUntil( MapName.c_str(), "-", 0, MapName.size(), 1 );
            InputEvent ie( 
                atoi( MapName.substr(0,strt).c_str() ), 
                atoi( MapName.substr(strt+1,MapName.length()-strt-1).c_str() ),
                IET_NONE );
            if ( m_vDemapped.size() < (unsigned)CurMapNumber+1 )
                m_vDemapped.resize( CurMapNumber+1 );
            m_vDemapped[CurMapNumber].push_back(ie);
            //Continue parse
            curloc += nextloc;
            nextloc = BytesNUntil( devs, ", ", curloc, k.length(), 2 );
            curloc += nextloc;
        }
        CurMapNumber++;
    }
}

void InputMappingTracker::CodeToHardware( int code, MVector<InputEvent> &out )
{
    if ( (unsigned)code < m_vDemapped.size() )
        out = m_vDemapped[code];
    else
        out.clear();
}

int InputMappingTracker::InputEventNameToCode( const MString & IE )
{ 
    if ( m_pCodes == NULL )
        return -1;
    else
        if ( m_pCodes->find( IE ) == m_pCodes->end() ) 
            return -1;
        else
            return (*m_pCodes)[IE]; 
}

int InputMappingTracker::InputEventToCode( const InputEvent & IE )
{ 
    return InputEventNameToCode( ssprintf( "%d-%d", IE.DeviceNumber, IE.ButtonNumber ));
}

CursorDevice::CursorDevice()
{
    m_x = 0;
    m_y = 0;
    m_bHasFocus = true;
    m_bSubscribed = false;
    m_Xoff = m_Yoff = 200;
}

void CursorDevice::UpdateFocus( const MString &message, void * data, void * info )
{
}

char KeyToChar( char cHardwareChar, bool bShiftPressed )
{
    if ( cHardwareChar == 10 || cHardwareChar == 13 )
        return 10;

    if ( cHardwareChar > 126 || cHardwareChar < 30 )
        return 0;

    if ( bShiftPressed )
    {
        switch ( cHardwareChar )
        {
        case '`': return '~';
        case '1': return '!';
        case '2': return '@';
        case '3': return '#';
        case '4': return '$';
        case '5': return '%';
        case '6': return '^';
        case '7': return '&';
        case '8': return '*';
        case '9': return '(';
        case '0': return ')';
        case '-': return '_';
        case '=': return '+';
        case '\\': return '|';
        case '[': return '{';
        case ']': return '}';
        case ';': return ':';
        case '\'': return '\"';
        case ',': return '<';
        case '.': return '>';
        case '/': return '?';
        case ' ': return ' ';
        }
        if ( ( cHardwareChar >= 'a' ) && ( cHardwareChar <= 'z' ) ) 
            return cHardwareChar - 'a' + 'A';
        return 0;
    } else 
        return cHardwareChar;       
}

/* 
 * 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