765 lines
15 KiB
C++
765 lines
15 KiB
C++
/**
|
|
* @file Input.cpp
|
|
* @brief Input class
|
|
* @author 재영
|
|
*/
|
|
|
|
#include "SunClientPrecompiledHeader.h"
|
|
|
|
#include "Input.h"
|
|
#include "InterfaceManager.h"
|
|
#include "KeyMapMgr.h"
|
|
#include "GlobalFunc.h"
|
|
|
|
#pragma comment( lib, "dxguid.lib" )
|
|
#pragma comment( lib, "dxerr9.lib" )
|
|
#pragma comment( lib, "dinput8.lib" )
|
|
|
|
const int kKeyEventMax = 10;
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
Input::Input( void )
|
|
{
|
|
m_pDI = NULL; // DirectInput object
|
|
m_pKeyboard = NULL; // DirectInput keyboard device
|
|
m_pMouse = NULL; // DirectInput mouse device
|
|
|
|
for( int i = 0 ; i < MAX_KEY_BUFFER ; ++i )
|
|
{
|
|
m_Key[i] = 0;
|
|
m_PreKey[i] = 0;
|
|
}
|
|
|
|
|
|
memset( &m_MouseState, 0, sizeof(DIMOUSESTATE2) );
|
|
memset( &m_PreMouseState, 0, sizeof(DIMOUSESTATE2) );
|
|
|
|
m_bUIMouseInput = FALSE;
|
|
|
|
for( i = 0 ; i < MAX_MOUSE_BUTTON ; ++i )
|
|
{
|
|
m_dwClickTimer_Start[i] = 0;
|
|
m_iClickState[i] = EXT_MOUSE_BUTTON_NONE;
|
|
}
|
|
|
|
m_dwLockKeyboard=0;
|
|
|
|
m_bMouseChange = FALSE;
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
Input::~Input( void )
|
|
{
|
|
Destroy();
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
void
|
|
Input::Reset()
|
|
{
|
|
memset( &m_MouseState, 0, sizeof(DIMOUSESTATE2) );
|
|
memset( &m_PreMouseState, 0, sizeof(DIMOUSESTATE2));
|
|
m_dwLockKeyboard=0;
|
|
|
|
|
|
m_bUIMouseInput = FALSE;
|
|
for( int i = 0 ; i < MAX_KEY_BUFFER ; ++i )
|
|
{
|
|
m_Key[i] = 0;
|
|
m_Event[i] =0;
|
|
m_PreKey[i] = 0;
|
|
}
|
|
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
void
|
|
Input::ResetKeyBuffer()
|
|
{
|
|
memset(m_Key, 0, MAX_KEY_BUFFER);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
HRESULT
|
|
Input::Create( HWND hWnd )
|
|
{
|
|
HRESULT hr;
|
|
|
|
// Create a IDirectInput8*
|
|
if( FAILED( hr = DirectInput8Create( GetModuleHandle(NULL), DIRECTINPUT_VERSION, IID_IDirectInput8, (VOID**)&m_pDI, NULL ) ) )
|
|
return DXTRACE_ERR( _T("DirectInput8Create"), hr );
|
|
|
|
// Create a IDirectInputDevice8* for the keyboard
|
|
if( FAILED( hr = m_pDI->CreateDevice( GUID_SysKeyboard, &m_pKeyboard, NULL ) ) )
|
|
return DXTRACE_ERR( _T("CreateDevice keyboard"), hr );
|
|
|
|
// Set the keyboard data format
|
|
if( FAILED( hr = m_pKeyboard->SetDataFormat( &c_dfDIKeyboard ) ) )
|
|
return DXTRACE_ERR( _T("SetDataFormat keyboard"), hr );
|
|
|
|
// Set the cooperative level on the keyboard
|
|
if( FAILED( hr = m_pKeyboard->SetCooperativeLevel( hWnd, DISCL_NONEXCLUSIVE | DISCL_FOREGROUND | DISCL_NOWINKEY ) ) )
|
|
return DXTRACE_ERR( _T("SetCooperativeLevel keyboard"), hr );
|
|
|
|
|
|
// 버퍼생성 최대 10개
|
|
DIPROPDWORD dipdw;
|
|
dipdw.diph.dwSize = sizeof(DIPROPDWORD);
|
|
dipdw.diph.dwHeaderSize = sizeof(DIPROPHEADER);
|
|
dipdw.diph.dwObj = 0;
|
|
dipdw.diph.dwHow = DIPH_DEVICE;
|
|
dipdw.dwData = kKeyEventMax;
|
|
hr = m_pKeyboard->SetProperty(DIPROP_BUFFERSIZE, &dipdw.diph);
|
|
|
|
// Acquire the keyboard
|
|
m_pKeyboard->Acquire();
|
|
|
|
|
|
|
|
|
|
|
|
hr = m_pDI->CreateDevice( GUID_SysMouse, &m_pMouse, NULL );
|
|
if( FAILED( hr ) )
|
|
{
|
|
return DXTRACE_ERR( _T("CreateDevice Mouse"), hr );
|
|
}
|
|
|
|
// 데이터 포멧 설정
|
|
hr = m_pMouse->SetDataFormat( &c_dfDIMouse2 );
|
|
if( FAILED( hr ) )
|
|
{
|
|
return DXTRACE_ERR( _T("SetDataFormat Mouse"), hr );
|
|
}
|
|
|
|
hr = m_pMouse->SetCooperativeLevel( hWnd, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE );
|
|
if( FAILED( hr ) )
|
|
{
|
|
return DXTRACE_ERR( _T("SetCooperativeLevel Mouse"), hr );
|
|
}
|
|
|
|
m_pMouse->Acquire();
|
|
|
|
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
void Input::Destroy( void )
|
|
{
|
|
// Cleanup DirectX input objects
|
|
if( m_pKeyboard )
|
|
m_pKeyboard->Unacquire();
|
|
SAFE_RELEASE( m_pKeyboard );
|
|
|
|
if( m_pMouse )
|
|
m_pMouse->Unacquire();
|
|
|
|
SAFE_RELEASE( m_pMouse );
|
|
|
|
SAFE_RELEASE( m_pDI );
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
int Input::Update( BOOL bRet, BOOL bPreData )
|
|
{
|
|
if (!m_pKeyboard || !m_pMouse)
|
|
return INPUT_SUCCESS_ALL;
|
|
|
|
m_bUIMouseInput = bRet;
|
|
|
|
|
|
HRESULT hr;
|
|
int iCode = INPUT_SUCCESS_ALL;
|
|
|
|
if( bPreData )
|
|
{
|
|
memcpy( m_PreKey, m_Key, MAX_KEY_BUFFER );
|
|
}
|
|
|
|
DIDEVICEOBJECTDATA rgdod[kKeyEventMax];
|
|
DWORD dwItems = kKeyEventMax;
|
|
HRESULT hres = m_pKeyboard->GetDeviceData(
|
|
sizeof(DIDEVICEOBJECTDATA),
|
|
rgdod,
|
|
&dwItems,
|
|
0);
|
|
|
|
if (SUCCEEDED(hres))
|
|
{
|
|
ZeroMemory(m_Event,sizeof(m_Event));
|
|
if (hres == DI_BUFFEROVERFLOW)
|
|
{
|
|
ZeroMemory(m_Key,MAX_KEY_BUFFER);
|
|
}
|
|
else
|
|
{
|
|
DWORD key_code = 0;
|
|
for (size_t a = 0; a < dwItems; a++)
|
|
{
|
|
key_code = rgdod[a].dwOfs;
|
|
if (key_code >= MAX_KEY_BUFFER)
|
|
{
|
|
continue;
|
|
}
|
|
|
|
if (rgdod[a].dwData)
|
|
{
|
|
m_Event[key_code] = KS_DOWN;
|
|
}
|
|
else
|
|
{
|
|
m_Event[key_code] = KS_UP;
|
|
}
|
|
|
|
m_Key[key_code] = (BYTE)rgdod[a].dwData;
|
|
}
|
|
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_pKeyboard->Acquire();
|
|
ZeroMemory(m_Key,MAX_KEY_BUFFER);
|
|
|
|
}
|
|
|
|
|
|
|
|
if( bPreData )
|
|
{
|
|
memcpy( &m_PreMouseState, &m_MouseState, sizeof(DIMOUSESTATE2) );
|
|
}
|
|
|
|
hr = m_pMouse->GetDeviceState( sizeof(DIMOUSESTATE2), &m_MouseState );
|
|
if( FAILED( hr ) )
|
|
{
|
|
m_pMouse->Acquire();
|
|
iCode |= INPUT_ERROR_MOUSE;
|
|
|
|
return iCode;
|
|
}
|
|
|
|
m_MouseX += m_MouseState.lX;
|
|
m_MouseY += m_MouseState.lY;
|
|
|
|
if( m_MouseX < 0 )
|
|
{
|
|
m_MouseX = 0;
|
|
}
|
|
if( m_MouseY < 0 )
|
|
{
|
|
m_MouseY = 0;
|
|
}
|
|
|
|
if (m_MouseState.lZ)
|
|
m_MouseZ = m_MouseState.lZ < 0 ? MOUSE_WHEEL_DOWN : MOUSE_WHEEL_UP;
|
|
else
|
|
m_MouseZ = MOUSE_WHEEL_NONE;
|
|
|
|
return iCode;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
int Input::UpdateEx( BOOL bRet, BYTE *pKey, DWORD dwBufferSize )
|
|
{
|
|
m_bUIMouseInput = bRet;
|
|
|
|
|
|
HRESULT hr;
|
|
int iCode = INPUT_SUCCESS_ALL;
|
|
|
|
// Get the input's device state, and put the state in dims
|
|
ZeroMemory( pKey, dwBufferSize );
|
|
hr = m_pKeyboard->GetDeviceState( dwBufferSize, pKey );
|
|
if( FAILED(hr) )
|
|
{
|
|
m_pKeyboard->Acquire();
|
|
iCode |= INPUT_ERROR_KEY;
|
|
}
|
|
|
|
memcpy( &m_PreMouseState, &m_MouseState, sizeof(DIMOUSESTATE2) );
|
|
|
|
if( m_pMouse->GetDeviceState( sizeof(DIMOUSESTATE2), &m_MouseState ) == (DIERR_INPUTLOST | DIERR_NOTACQUIRED) )
|
|
{
|
|
m_pMouse->Acquire();
|
|
iCode |= INPUT_ERROR_MOUSE;
|
|
}
|
|
|
|
return iCode;
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
BOOL
|
|
Input::IsPressShiftKey()
|
|
{
|
|
return GetState( DIK_LSHIFT, KS_KEY ) || GetState( DIK_RSHIFT, KS_KEY );
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
BOOL
|
|
Input::IsPressCtrlKey()
|
|
{
|
|
return GetState( DIK_LCONTROL, KS_KEY ) || GetState( DIK_RCONTROL, KS_KEY );
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
BOOL
|
|
Input::IsPressAltKey()
|
|
{
|
|
return GetState( DIK_LALT, KS_KEY ) || GetState( DIK_RALT, KS_KEY );
|
|
}
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
BOOL
|
|
Input::IsPressAnyExtKey()
|
|
{
|
|
|
|
BOOL bPress = ( GetState( DIK_LSHIFT, KS_KEY ) || GetState( DIK_RSHIFT, KS_KEY ) ||
|
|
GetState( DIK_LCONTROL, KS_KEY ) || GetState( DIK_RCONTROL, KS_KEY ) ||
|
|
GetState( DIK_LALT, KS_KEY ) || GetState( DIK_RALT, KS_KEY )
|
|
);
|
|
return bPress;
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
BOOL
|
|
Input::IsPressQuickExtKey()
|
|
{
|
|
BOOL bPress = ( GetState( DIK_LSHIFT, KS_KEY ) || GetState( DIK_RSHIFT, KS_KEY ));
|
|
return bPress;
|
|
}
|
|
|
|
|
|
|
|
//----------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
BOOL
|
|
Input::IsPressAnyKey()
|
|
{
|
|
for (int i = 0; i < MAX_KEY_BUFFER; ++i)
|
|
{
|
|
if ( m_Key[i] )
|
|
return TRUE;
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
BOOL
|
|
Input::IsPressAnyKeyExceptExt()
|
|
{
|
|
for (int i = 0; i < MAX_KEY_BUFFER; ++i)
|
|
{
|
|
switch (i)
|
|
{
|
|
case DIK_LSHIFT: case DIK_RSHIFT:
|
|
case DIK_LCONTROL: case DIK_RCONTROL:
|
|
case DIK_LALT: case DIK_RALT:
|
|
{
|
|
continue;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
{
|
|
if ( m_Key[i] )
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
BOOL
|
|
Input::IsDownAltKey()
|
|
{
|
|
return GetState( DIK_LALT, KS_DOWN ) || GetState( DIK_RALT, KS_DOWN );
|
|
}
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
BOOL
|
|
Input::ScanCurKeyInfo(KeyCodeVec & IN rVecCode)
|
|
{
|
|
if ( g_Input.IsPressAnyKey() )
|
|
{
|
|
// 확장키를 받아놓는다.
|
|
KEY_SET_ITR itr = KeyMapMgr::Instance()->GetBegin();
|
|
|
|
while (itr != KeyMapMgr::Instance()->GetEnd())
|
|
{
|
|
WORD wKEY_CODE = (WORD)itr->first;
|
|
|
|
switch (wKEY_CODE)
|
|
{
|
|
case DIK_LSHIFT: case DIK_RSHIFT:
|
|
case DIK_LCONTROL: case DIK_RCONTROL:
|
|
case DIK_LALT: case DIK_RALT:
|
|
{
|
|
if ( g_Input.GetState(wKEY_CODE, KS_KEY , TRUE) || g_Input.GetState(wKEY_CODE, IKS_KEY , TRUE) )
|
|
{
|
|
rVecCode.push_back(wKEY_CODE);
|
|
}
|
|
}
|
|
break;
|
|
default:{}
|
|
}
|
|
|
|
itr++;
|
|
}
|
|
|
|
// 확장키를 제외한 키를 받아놓는다.
|
|
itr = KeyMapMgr::Instance()->GetBegin();
|
|
while (itr != KeyMapMgr::Instance()->GetEnd())
|
|
{
|
|
WORD wKEY_CODE = (WORD)itr->first;
|
|
|
|
switch (wKEY_CODE)
|
|
{
|
|
case DIK_LSHIFT: case DIK_RSHIFT:
|
|
case DIK_LCONTROL: case DIK_RCONTROL:
|
|
case DIK_LALT: case DIK_RALT:
|
|
{
|
|
}
|
|
break;
|
|
default:
|
|
{
|
|
if ( g_Input.GetState(wKEY_CODE, KS_DOWN , TRUE) || g_Input.GetState(wKEY_CODE, IKS_DOWN , TRUE) )
|
|
{
|
|
rVecCode.push_back(wKEY_CODE);
|
|
return TRUE;
|
|
}
|
|
}
|
|
}
|
|
|
|
itr++;
|
|
}
|
|
|
|
}
|
|
|
|
return FALSE;
|
|
}
|
|
|
|
|
|
BOOL Input::GetState( int Key, int iKeyState , BOOL bForceInput)
|
|
{
|
|
if (GlobalFunc::BeforeLoadingInputLock())
|
|
{
|
|
//nop
|
|
}
|
|
else if (g_InterfaceManager.IsLockDlg() && bForceInput == FALSE)
|
|
{
|
|
return FALSE;
|
|
}
|
|
|
|
if(m_bMouseChange)
|
|
{
|
|
if(Key == MOUSE_LBUTTON) Key = MOUSE_RBUTTON;
|
|
|
|
else if(Key == MOUSE_RBUTTON) Key = MOUSE_LBUTTON;
|
|
}
|
|
|
|
unsigned int chKey ;
|
|
|
|
if( Key < MAX_KEY_BUFFER )
|
|
{
|
|
// 키보드
|
|
chKey = KS_NONE;
|
|
|
|
if (m_Key[Key] & 0x80)
|
|
{
|
|
chKey |= KS_KEY;
|
|
}
|
|
|
|
if (m_Event[Key] & KS_DOWN)
|
|
{
|
|
chKey |= KS_DOWN;
|
|
|
|
}
|
|
|
|
if (m_Event[Key] & KS_UP)
|
|
{
|
|
chKey |= KS_UP;
|
|
}
|
|
|
|
if( g_InterfaceManager.GetDialogManager()->GetActiveEditCount() )
|
|
{
|
|
#ifdef _NA_004859_20120518_FORCE_INPUT_SCREENSHOT_KEY
|
|
if( Key != DIK_SYSRQ )
|
|
{
|
|
if((DIK_LSHIFT != Key) && (DIK_RSHIFT != Key) && (DIK_LCONTROL != Key) && (DIK_RCONTROL != Key) && (DIK_LALT != Key) && (DIK_RALT != Key))
|
|
{
|
|
chKey >>= 4;
|
|
}
|
|
}
|
|
#else
|
|
if((DIK_LSHIFT != Key) && (DIK_RSHIFT != Key) && (DIK_LCONTROL != Key) && (DIK_RCONTROL != Key) && (DIK_LALT != Key) && (DIK_RALT != Key))
|
|
{
|
|
chKey >>= 4;
|
|
}
|
|
|
|
#endif // _NA_004859_20120518_FORCE_INPUT_SCREENSHOT_KEY
|
|
}
|
|
|
|
return BOOL( chKey & iKeyState);
|
|
}
|
|
else
|
|
{
|
|
// 마우스
|
|
chKey = KS_MOUSE_NONE;
|
|
|
|
if( (Key - MAX_KEY_BUFFER) < 0 && (Key - MAX_KEY_BUFFER) > MAX_MOUSE_BUTTON )
|
|
{
|
|
chKey = IKS_MOUSE_NONE;
|
|
}
|
|
|
|
Key = Key - MAX_KEY_BUFFER;
|
|
|
|
if (Key >= MAX_MOUSE_BUTTON)
|
|
{
|
|
int wheel_state = (Key - MAX_MOUSE_BUTTON) + 1;
|
|
if ((wheel_state == m_MouseZ) &&
|
|
(m_bUIMouseInput == FALSE))
|
|
{
|
|
return TRUE;
|
|
}
|
|
return FALSE;
|
|
}
|
|
else if( m_PreMouseState.rgbButtons[Key] == 0 && m_MouseState.rgbButtons[Key] )
|
|
{
|
|
// 처음 눌렀을 때
|
|
chKey = KS_MOUSE_DOWN;
|
|
|
|
m_dwClickTimer_Start[Key] = timeGetTime();
|
|
m_iClickState[Key] = EXT_MOUSE_BUTTON_CLICK_SHORT;
|
|
}
|
|
else if( m_PreMouseState.rgbButtons[Key] && m_MouseState.rgbButtons[Key] )
|
|
{
|
|
// 계속 누르고 있을 때
|
|
chKey = KS_MOUSE_KEY;
|
|
|
|
DWORD dwTimer = timeGetTime();
|
|
|
|
// 마우스 버튼 클릭 시간 체크( 누른 상태로 얼마나 오래 있었나 )
|
|
if( (dwTimer - m_dwClickTimer_Start[Key]) <= MOUSE_CLICK_TIME_SHORT )
|
|
{
|
|
m_dwClickTimer_Start[Key] = dwTimer;
|
|
m_iClickState[Key] = EXT_MOUSE_BUTTON_CLICK_SHORT;
|
|
}
|
|
else if( (dwTimer - m_dwClickTimer_Start[Key]) > MOUSE_CLICK_TIME_LONG )
|
|
{
|
|
m_dwClickTimer_Start[Key] = dwTimer;
|
|
m_iClickState[Key] = EXT_MOUSE_BUTTON_CLICK_LONG;
|
|
}
|
|
else
|
|
{
|
|
m_dwClickTimer_Start[Key] = dwTimer;
|
|
m_iClickState[Key] = EXT_MOUSE_BUTTON_CLICK_MID;
|
|
}
|
|
}
|
|
else if( m_PreMouseState.rgbButtons[Key] && m_MouseState.rgbButtons[Key] == 0 )
|
|
{
|
|
// 누르다가 처음 띄었을 때( 버튼 업 )
|
|
chKey = KS_MOUSE_UP;
|
|
|
|
m_dwClickTimer_Start[Key] = timeGetTime();
|
|
m_iClickState[Key] = EXT_MOUSE_BUTTON_NONE;
|
|
}
|
|
|
|
if( m_bUIMouseInput )
|
|
{
|
|
chKey >>= 4;
|
|
}
|
|
|
|
}
|
|
return BOOL( iKeyState == chKey);
|
|
}
|
|
|
|
void Input::InvalidateState( int Key)
|
|
{
|
|
unsigned int chKey;
|
|
|
|
if( Key < MAX_KEY_BUFFER )
|
|
{
|
|
// 키보드
|
|
chKey = KS_NONE;
|
|
|
|
m_Key[Key] = 0;
|
|
m_Event[Key] = 0;
|
|
|
|
}
|
|
else
|
|
{
|
|
// 마우스 는 아직 없다
|
|
}
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
int Input::GetMouseClickState( int iKey )
|
|
{
|
|
iKey = iKey - MAX_KEY_BUFFER;
|
|
if( iKey >= 0 && iKey < MAX_MOUSE_BUTTON )
|
|
{
|
|
return m_iClickState[iKey];
|
|
}
|
|
|
|
return EXT_MOUSE_BUTTON_NONE;
|
|
}
|
|
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
BOOL
|
|
Input::ConvertCodeToStr(KeyCodeVec & IN rVecCode, util::_tstring & OUT rKeyStrInfo)
|
|
{
|
|
util::_tstring strTemp;
|
|
|
|
int iSize = rVecCode.size();
|
|
for ( int i = 0; i < iSize; ++i)
|
|
{
|
|
strTemp += KeyMapMgr::Instance()->GetKeyString( rVecCode[i] );
|
|
if (iSize != 1 && i != iSize - 1)
|
|
{
|
|
strTemp += _T("+");
|
|
}
|
|
}
|
|
|
|
rKeyStrInfo.clear();
|
|
rKeyStrInfo = strTemp;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
BOOL
|
|
Input::ConvertStrToCode(util::_tstring & KeyStrInfo, KeyCodeVec & OUT rVecCode)
|
|
{
|
|
TCHAR * pszString = (TCHAR *)(const TCHAR *)KeyStrInfo.c_str();
|
|
|
|
std::vector< util::_tstring > tokenVec;
|
|
|
|
basic_string<TCHAR>::size_type indexBegin = 0, indexEnd = 0;
|
|
basic_string<TCHAR>::size_type notPos = -1;
|
|
int iDelta = 0;
|
|
|
|
while(1)
|
|
{
|
|
indexEnd = KeyStrInfo.find_first_of(_T("+"), indexBegin);
|
|
|
|
if (indexEnd == notPos)
|
|
{
|
|
indexEnd = KeyStrInfo.size();
|
|
iDelta = indexEnd - indexBegin;
|
|
util::_tstring subStr = KeyStrInfo.substr(indexBegin, iDelta);
|
|
tokenVec.push_back(subStr);
|
|
|
|
break;
|
|
}
|
|
|
|
iDelta = indexEnd - indexBegin;
|
|
util::_tstring subStr = KeyStrInfo.substr(indexBegin, iDelta);
|
|
tokenVec.push_back(subStr);
|
|
indexBegin = indexEnd+1;
|
|
}
|
|
|
|
int iTokenSize= tokenVec.size();
|
|
for ( int i = 0; i < iTokenSize; ++i )
|
|
{
|
|
KEY_SET_ITR itr = KeyMapMgr::Instance()->GetBegin();
|
|
|
|
while (itr != KeyMapMgr::Instance()->GetEnd())
|
|
{
|
|
int iCompLen = _tcslen( itr->second.c_str() );
|
|
pszString = (TCHAR *)(const TCHAR *)tokenVec[i].c_str();
|
|
int iOrgLen = _tcslen( tokenVec[i].c_str() );
|
|
|
|
if ( iOrgLen != iCompLen )
|
|
{
|
|
itr++;
|
|
continue;
|
|
}
|
|
|
|
TCHAR * pszComp = (TCHAR *)(const TCHAR *)itr->second.c_str();
|
|
if ( _Strincmp( pszString, iOrgLen, pszComp, iOrgLen) )
|
|
{
|
|
rVecCode.push_back((WORD)itr->first);
|
|
break;
|
|
}
|
|
|
|
itr++;
|
|
}
|
|
}
|
|
|
|
tokenVec.clear();
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
|
|
void Input::SetMouseChange(BOOL val)
|
|
{
|
|
m_bMouseChange = val;
|
|
};
|
|
|
|
BOOL Input::GetMouseChange()
|
|
{
|
|
return m_bMouseChange;
|
|
};
|
|
|
|
|
|
//-------------------------------------------------------------------------------------------
|
|
/**
|
|
*/
|
|
BOOL
|
|
Input::IsValidDevice()
|
|
{
|
|
return BOOL( m_pKeyboard && m_pMouse );
|
|
}
|
|
|