OpenBarnyard
 
Loading...
Searching...
No Matches
Classes | Public Member Functions | Static Public Member Functions | Protected Member Functions | Static Protected Member Functions | List of all members
TInputDXDeviceKeyboard Class Reference

#include <TInputDeviceKeyboard_Win.h>

Inheritance diagram for TInputDXDeviceKeyboard:
TInputDeviceKeyboard TInputDevice TObject TNodeList< T >::TNode

Classes

struct  KeyInfo
 

Public Member Functions

 TDECLARE_CLASS (TInputDXDeviceKeyboard, TInputDeviceKeyboard)
 
 TInputDXDeviceKeyboard ()
 
virtual TBOOL Acquire () override
 
virtual TBOOL Unacquire () override
 
virtual void Release () override
 
virtual void Update (float deltaTime) override
 
virtual TBOOL Flush () override
 
virtual TINT ProcessEvents (TEmitter< TInputInterface, TInputInterface::InputEvent > &emitter, float deltaTime) override
 
virtual TINT GetButtonCount () const override
 
virtual TBOOL IsDown (TINT doodad) const override
 
virtual TBOOL IsEnabled () const override
 
virtual TBOOL IsShiftDown () const override
 
virtual TBOOL IsControlDown () const override
 
virtual TBOOL IsAltDown () const override
 
virtual TBOOL WasDown (TINT doodad) const override
 
virtual TWCHAR * TranslateDoodadToCharacter (TINT doodad) const override
 
virtual TBOOL Initialise ()
 
virtual TBOOL Deinitialise ()
 
virtual void RefreshDirect ()
 
const TBOOL BindToDIDevice (HWND a_hMainWindow, LPCDIDEVICEINSTANCEA a_poDeviceInstance, IDirectInputDevice8A *a_poDXInputDevice)
 
- Public Member Functions inherited from TInputDeviceKeyboard
 TDECLARE_CLASS (TInputDeviceKeyboard, TInputDevice)
 
 TInputDeviceKeyboard ()
 
 ~TInputDeviceKeyboard ()
 
virtual TBOOL GetDoodadProperties (Doodad a_iDoodad, DoodadProperties &doodadProps) const override
 
virtual TINT GetAxisCount () const override
 
virtual const TCHAR * GetButtonFromDoodad (Doodad a_iDoodad) const override
 
virtual TINT GetAxisInt (Doodad a_iDoodad, TINT axis) const override
 
virtual float GetAxisFloat (Doodad a_iDoodad, TINT axis) const override
 
virtual TINT ProcessVirtualButtons (EventEmitter &a_rEmitter, TFLOAT flt)
 
void SetVirtStickDoodads (TINT a_iMapID, Doodad a_iDoodad1, Doodad a_iDoodad2, Doodad a_iDoodad3, Doodad a_iDoodad4)
 
void GetVirtStickDoodads (TINT a_iMapID, Doodad &a_rDoodad1, Doodad &a_rDoodad2, Doodad &a_rDoodad3, Doodad &a_rDoodad4)
 
- Public Member Functions inherited from TInputDevice
 TDECLARE_CLASS (TInputDevice, TObject)
 
 TInputDevice ()
 
 ~TInputDevice ()=default
 
virtual TBOOL StartRepeat (Doodad a_iDoodad, TFLOAT a_fFirstRepeatTime, TFLOAT a_fRepeatTime)
 
virtual void StopRepeat (Doodad a_iDoodad)
 
virtual void StopAllRepeats ()
 
virtual TBOOL IsForceFeedbackDevice ()
 
virtual TINT GetAxisInt2 (Doodad a_iDoodad, TINT axis) const
 
virtual TFLOAT GetAxisFloat2 (Doodad a_iDoodad, TINT axis) const
 
virtual void ThrowRepeatEvent (EventEmitter &emitter, RepeatInfo *repeatInfo, TFLOAT deltaTime)
 
TBOOL IsAcquired () const
 
void SetAcquired (TBOOL a_bAcquired)
 
TInputInterface * GetInputInterface ()
 
void SetInputInterface (TInputInterface *a_pInterface)
 
- Public Member Functions inherited from TObject
virtual Toshi::TClass * GetClass ()
 
virtual void Delete ()
 
virtual ~TObject ()
 
TBOOL IsExactly (TClass *a_pClass)
 
TBOOL IsA (TClass *a_pClass)
 
- Public Member Functions inherited from TNodeList< T >::TNode
constexpr TNode ()
 
constexpr TNode (const TNode &a_rcNode)
 
 TNode (TNode &&a_rNode)
 
T * Next () const
 
T * Prev () const
 
void Remove ()
 
void SetList (TNodeList *list)
 
TNodeList * GetList () const
 
TBOOL IsLinked () const
 

Static Public Member Functions

static BOOL CALLBACK EnumObjectCallback (LPCDIDEVICEOBJECTINSTANCEA a_poObjectInstance, LPVOID a_pvRef)
 
- Static Public Member Functions inherited from TInputDevice
static TInputDevice ** GetRegisteredDevices ()
 
static TUINT GetNumRegisteredDevices ()
 
- Static Public Member Functions inherited from TObject
static Toshi::TObject * CreateTObject ()
 
static Toshi::TObject * CreateTObjectInPlace (void *a_pPtr)
 
static void InitialiseClass ()
 
static void DeinitialiseClass ()
 
static TFORCEINLINE TClass * GetClassStatic ()
 

Protected Member Functions

TBOOL HandleKeyChange (TEmitter< TInputInterface, TInputInterface::InputEvent > &a_Emitter, TINT a_iKeyIndex, uint8_t a_ui8KeyState)
 
- Protected Member Functions inherited from TInputDeviceKeyboard
void UpdateVirtualButtons ()
 
- Protected Member Functions inherited from TInputDevice
TINT ProcessRepeats (EventEmitter &a_rEmitter, TFLOAT a_fDeltaTime)
 

Static Protected Member Functions

static TINT TranslateDXToDoodad (TINT doodad)
 
static TINT TranslateDoodadToDX (TINT dxkey)
 

Additional Inherited Members

- Public Types inherited from TInputDeviceKeyboard
enum  : Doodad {
  DOODAD_START = 0x20000 , VIRTKEY = 0x20001 , VIRTKEY_SHIFT = 0x20002 , VIRTKEY_CONTROL = 0x20003 ,
  VIRTKEY_ALT = 0x20004 , KEY_ESCAPE = 0x20005 , KEY_1 = 0x20006 , KEY_2 = 0x20007 ,
  KEY_3 = 0x20008 , KEY_4 = 0x20009 , KEY_5 = 0x2000A , KEY_6 = 0x2000B ,
  KEY_7 = 0x2000C , KEY_8 = 0x2000D , KEY_9 = 0x2000E , KEY_0 = 0x2000F ,
  KEY_MINUS = 0x20010 , KEY_EQUALS = 0x20011 , KEY_BACK = 0x20012 , KEY_TAB = 0x20013 ,
  KEY_Q = 0x20014 , KEY_W = 0x20015 , KEY_E = 0x20016 , KEY_R = 0x20017 ,
  KEY_T = 0x20018 , KEY_Y = 0x20019 , KEY_U = 0x2001A , KEY_I = 0x2001B ,
  KEY_O = 0x2001C , KEY_P = 0x2001D , KEY_LBRACKET = 0x2001E , KEY_RBRACKET = 0x2001F ,
  KEY_RETURN = 0x20020 , KEY_LCONTROL = 0x20021 , KEY_A = 0x20022 , KEY_S = 0x20023 ,
  KEY_D = 0x20024 , KEY_F = 0x20025 , KEY_G = 0x20026 , KEY_H = 0x20027 ,
  KEY_J = 0x20028 , KEY_K = 0x20029 , KEY_L = 0x2002A , KEY_SEMICOLON = 0x2002B ,
  KEY_APOSTROPHE = 0x2002C , KEY_GRAVE = 0x2002D , KEY_LSHIFT = 0x2002E , KEY_BACKSLASH = 0x2002F ,
  KEY_Z = 0x20030 , KEY_X = 0x20031 , KEY_C = 0x20032 , KEY_V = 0x20033 ,
  KEY_B = 0x20034 , KEY_N = 0x20035 , KEY_M = 0x20036 , KEY_COMMA = 0x20037 ,
  KEY_PERIOD = 0x20038 , KEY_SLASH = 0x20039 , KEY_RSHIFT = 0x2003A , KEY_MULTIPLY = 0x2003B ,
  KEY_LMENU = 0x2003c , KEY_SPACE = 0x2003d , KEY_CAPITAL = 0x2003e , KEY_F1 = 0x2003f ,
  KEY_F2 = 0x20040 , KEY_F3 = 0x20041 , KEY_F4 = 0x20042 , KEY_F5 = 0x20043 ,
  KEY_F6 = 0x20044 , KEY_F7 = 0x20045 , KEY_F8 = 0x20046 , KEY_F9 = 0x20047 ,
  KEY_F10 = 0x20048 , KEY_NUMLOCK = 0x20049 , KEY_SCROLL = 0x2004a , KEY_NUMPAD7 = 0x2004b ,
  KEY_NUMPAD8 = 0x2004c , KEY_NUMPAD9 = 0x2004d , KEY_SUBTRACT = 0x2004e , KEY_NUMPAD4 = 0x2004f ,
  KEY_NUMPAD5 = 0x20050 , KEY_NUMPAD6 = 0x20051 , KEY_ADD = 0x20052 , KEY_NUMPAD1 = 0x20053 ,
  KEY_NUMPAD2 = 0x20054 , KEY_NUMPAD3 = 0x20055 , KEY_NUMPAD0 = 0x20056 , KEY_DECIMAL = 0x20057 ,
  KEY_F11 = 0x20058 , KEY_F12 = 0x20059 , KEY_F13 = 0x2005a , KEY_F14 = 0x2005b ,
  KEY_F15 = 0x2005c , KEY_KANA = 0x2005d , KEY_CONVERT = 0x2005e , KEY_NOCONVERT = 0x2005f ,
  KEY_YEN = 0x20060 , KEY_NUMPADEQUALS = 0x20061 , KEY_CIRCUMFLEX = 0x20062 , KEY_AT = 0x20063 ,
  KEY_COLON = 0x20064 , KEY_UNDERLINE = 0x20065 , KEY_KANJI = 0x20066 , KEY_STOP = 0x20067 ,
  KEY_AX = 0x20068 , KEY_UNLABELED = 0x20069 , KEY_NUMPADENTER = 0x2006a , KEY_RCONTROL = 0x2006b ,
  KEY_NUMPADCOMMA = 0x2006c , KEY_DIVIDE = 0x2006d , KEY_SYSRQ = 0x2006e , KEY_RMENU = 0x2006f ,
  KEY_HOME = 0x20070 , KEY_PAUSE = 0x20071 , KEY_UP = 0x20072 , KEY_PRIOR = 0x20073 ,
  KEY_LEFT = 0x20074 , KEY_RIGHT = 0x20075 , KEY_END = 0x20076 , KEY_DOWN = 0x20077 ,
  KEY_NEXT = 0x20078 , KEY_INSERT = 0x20079 , KEY_DELETE = 0x2007a , KEY_LWIN = 0x2007b ,
  KEY_RWIN = 0x2007c , KEY_APPS = 0x2007d , KEY_POWER = 0x2007e , KEY_SLEEP = 0x2007f ,
  DOODAD_END = 0x20080
}
 
- Public Types inherited from TInputDevice
using EventEmitter = TInputInterface::EventEmitter
 
using Doodad = TINT
 
- Public Types inherited from TObject
enum  { IsTObject = TTRUE }
 
- Static Public Attributes inherited from TInputDeviceKeyboard
static constexpr TUINT KEYBOARD_NUM_DOODADS = 128
 
static constexpr TUINT VIRTSTK_DIRECTIONAL_MAPS = 2
 
- Static Public Attributes inherited from TInputDevice
static constexpr TINT INPUT_DEVICE_MOUSE_BUTTONS = 3
 
static constexpr TINT INPUT_DEVICE_MOUSE_WHEEL = 4
 
- Static Public Attributes inherited from TObject
static constexpr Toshi::TClass * PARENTCLASS = TNULL
 
static constinit Toshi::TClass ms_oClass = Toshi::TClass( "TObject", TObject::CreateTObject, TObject::CreateTObjectInPlace, TObject::InitialiseClass, TObject::DeinitialiseClass, 0, 2, sizeof( TObject ), alignof( TObject ) )
 
- Protected Attributes inherited from TInputDeviceKeyboard
TFLOAT m_aMags [4]
 
VirtStickDoodad m_aVirtStickDoodads [VIRTSTK_DIRECTIONAL_MAPS]
 
- Protected Attributes inherited from TInputDevice
TUINT m_uiDeviceIndex
 
TArray< RepeatInfo > m_Repeats
 
TArray< void * > m_Array2
 
TBOOL m_bUnknown
 
TBOOL m_bIsAcquired
 
TInputInterface * m_pInputInterface
 
- Protected Attributes inherited from TNodeList< T >::TNode
friend TNodeList
 
TNodeList * m_pList
 
T * m_pNext
 
T * m_pPrev
 
- Static Protected Attributes inherited from TInputDevice
static constexpr TUINT MAX_DEVICE_COUNT = 14
 
static TInputDevice * s_aDevices [MAX_DEVICE_COUNT]
 
static TUINT s_uiDeviceCount
 

Detailed Description

Definition at line 9 of file TInputDeviceKeyboard_Win.h.

Constructor & Destructor Documentation

◆ TInputDXDeviceKeyboard()

TInputDXDeviceKeyboard::TInputDXDeviceKeyboard ( )

Definition at line 14 of file TInputDeviceKeyboard_Win.cpp.

15{
16 m_iSomeNum = 0;
17 m_pKeyStates1 = TNULL;
18 m_pKeyStates2 = TNULL;
19 m_poDXInputDevice = TNULL;
20 m_bFlag = TFALSE;
21 m_aKeys.InitialiseAll( { TNULL } );
22}
TNULL
#define TNULL
Definition Typedefs.h:23
TFALSE
#define TFALSE
Definition Typedefs.h:24

Member Function Documentation

◆ Acquire()

TBOOL TInputDXDeviceKeyboard::Acquire ( )
overridevirtual

Implements TInputDevice.

Definition at line 33 of file TInputDeviceKeyboard_Win.cpp.

34{
35 m_bIsUpdating = TFALSE;
36 HRESULT hRes = m_poDXInputDevice->Acquire();
37
38 if ( SUCCEEDED( hRes ) )
39 {
40 SetAcquired( TTRUE );
41
42 if ( hRes != S_FALSE )
43 {
44 RefreshDirect();
45 }
46 }
47 else
48 {
49 SetAcquired( TFALSE );
50 return TFALSE;
51 }
52
53 return TTRUE;
54}
TTRUE
#define TTRUE
Definition Typedefs.h:25
TInputDevice::SetAcquired
void SetAcquired(TBOOL a_bAcquired)
Definition TInputInterface.h:171

◆ BindToDIDevice()

const TBOOL TInputDXDeviceKeyboard::BindToDIDevice ( HWND a_hMainWindow,
LPCDIDEVICEINSTANCEA a_poDeviceInstance,
IDirectInputDevice8A * a_poDXInputDevice )

Definition at line 792 of file TInputDeviceKeyboard_Win.cpp.

793{
794 TASSERT( a_poDeviceInstance != NULL );
795 TASSERT( a_poDXInputDevice != NULL );
796
797 Initialise();
798 Release();
799
800 TUtil::MemCopy( &m_oDeviceInstance, a_poDeviceInstance, sizeof( DIDEVICEINSTANCEA ) );
801
802 m_poDXInputDevice = a_poDXInputDevice;
803 m_DIDevCaps.dwSize = sizeof( DIDEVCAPS );
804
805 m_poDXInputDevice->GetCapabilities( &m_DIDevCaps );
806 HRESULT hr = m_poDXInputDevice->SetDataFormat( &c_dfDIKeyboard );
807
808 if ( hr != DI_OK )
809 {
810 return TFALSE;
811 }
812
813 if ( a_hMainWindow )
814 {
815 if ( m_poDXInputDevice->SetCooperativeLevel( a_hMainWindow, DISCL_FOREGROUND | DISCL_NONEXCLUSIVE ) != DI_OK )
816 {
817 return TFALSE;
818 }
819 }
820
821 m_bIsUpdating = TFALSE;
822 m_poDXInputDevice->EnumObjects( EnumObjectCallback, this, DIDFT_BUTTON );
823 return TTRUE;
824}
TASSERT
#define TASSERT(X,...)
Definition Defines.h:138
TInputDXDeviceKeyboard::EnumObjectCallback
static BOOL CALLBACK EnumObjectCallback(LPCDIDEVICEOBJECTINSTANCEA a_poObjectInstance, LPVOID a_pvRef)
Definition TInputDeviceKeyboard_Win.cpp:826
TInputDXDeviceKeyboard::Release
virtual void Release() override
Definition TInputDeviceKeyboard_Win.cpp:24
TUtil::MemCopy
static void * MemCopy(void *dst, const void *src, TSIZE size)
Definition TUtil.h:90

◆ Deinitialise()

TBOOL TInputDXDeviceKeyboard::Deinitialise ( )
virtual

Definition at line 222 of file TInputDeviceKeyboard_Win.cpp.

223{
224 Release();
225 return TTRUE;
226}

◆ EnumObjectCallback()

BOOL CALLBACK TInputDXDeviceKeyboard::EnumObjectCallback ( LPCDIDEVICEOBJECTINSTANCEA a_poObjectInstance,
LPVOID a_pvRef )
static

Definition at line 826 of file TInputDeviceKeyboard_Win.cpp.

827{
828 TInputDXDeviceKeyboard* pKeyboard = TREINTERPRETCAST( TInputDXDeviceKeyboard*, a_pvRef );
829 TINT iDoodad = TranslateDXToDoodad( a_poObjectInstance->dwOfs );
830
831 if ( iDoodad - 0x20000U < 0x80 )
832 {
833 iDoodad -= 0x20000U;
834
835 // Save name of key
836 auto iKeyNameLength = TStringManager::String8Length( a_poObjectInstance->tszName );
837 delete[] pKeyboard->m_aKeys[ iDoodad ].wszKeyName;
838 TWCHAR* wcsKeyName = new TWCHAR[ iKeyNameLength + 1 ];
839 TStringManager::StringCharToUnicode( wcsKeyName, a_poObjectInstance->tszName, -1 );
840 pKeyboard->m_aKeys[ iDoodad ].wszKeyName = wcsKeyName;
841
842 DIPROPSTRING oKeyName;
843 oKeyName.diph.dwSize = sizeof( DIPROPSTRING );
844 oKeyName.diph.dwHeaderSize = sizeof( DIPROPHEADER );
845 oKeyName.diph.dwHow = 1;
846 oKeyName.diph.dwObj = a_poObjectInstance->dwType >> 8 & 0xffff;
847
848 pKeyboard->m_poDXInputDevice->GetProperty( DIPROP_KEYNAME, &oKeyName.diph );
849
850 DIPROPDWORD oKeyScanCode;
851 oKeyScanCode.diph.dwSize = sizeof( oKeyScanCode );
852 oKeyScanCode.diph.dwHeaderSize = sizeof( DIPROPHEADER );
853 oKeyScanCode.diph.dwHow = 1;
854 oKeyScanCode.diph.dwObj = a_poObjectInstance->dwType >> 8 & 0xffff;
855
856 HRESULT hRes = pKeyboard->m_poDXInputDevice->GetProperty( DIPROP_SCANCODE, &oKeyScanCode.diph );
857
858 if ( hRes == S_OK )
859 pKeyboard->m_aKeys[ iDoodad ].dwKeyScanCode = oKeyScanCode.dwData;
860 else
861 pKeyboard->m_aKeys[ iDoodad ].dwKeyScanCode = -1;
862 }
863
864 return TRUE;
865}
TREINTERPRETCAST
#define TREINTERPRETCAST(TYPE, VALUE)
Definition Defines.h:68
TWCHAR
wchar_t TWCHAR
Definition Typedefs.h:21
TINT
int TINT
Definition Typedefs.h:7
TInputDXDeviceKeyboard::TranslateDXToDoodad
static TINT TranslateDXToDoodad(TINT doodad)
Definition TInputDeviceKeyboard_Win.cpp:282
TStringManager::StringCharToUnicode
static TWCHAR * StringCharToUnicode(TWCHAR *a_UnicodeString, const TCHAR *a_CharString, TUINT32 a_iLength)
Definition TStringManager.cpp:13
TStringManager::String8Length
static TSIZE String8Length(const TCHAR *str)
Definition TStringManager.h:19

◆ Flush()

TBOOL TInputDXDeviceKeyboard::Flush ( )
overridevirtual

Reimplemented from TInputDevice.

Definition at line 70 of file TInputDeviceKeyboard_Win.cpp.

71{
72 if ( IsAcquired() )
73 {
74 DWORD dwNumElements = -1;
75 HRESULT hRes = m_poDXInputDevice->GetDeviceData( sizeof( DIDEVICEOBJECTDATA ), NULL, &dwNumElements, 0 );
76
77 if ( SUCCEEDED( hRes ) )
78 {
79 RefreshDirect();
80 return TTRUE;
81 }
82 else
83 {
84 m_bIsUpdating = TFALSE;
85 }
86 }
87
88 return TFALSE;
89}
TInputDevice::IsAcquired
TBOOL IsAcquired() const
Definition TInputInterface.h:166

◆ GetButtonCount()

TINT TInputDXDeviceKeyboard::GetButtonCount ( ) const
overridevirtual

Implements TInputDevice.

Definition at line 139 of file TInputDeviceKeyboard_Win.cpp.

140{
141 return 0;
142}

◆ HandleKeyChange()

TBOOL TInputDXDeviceKeyboard::HandleKeyChange ( TEmitter< TInputInterface, TInputInterface::InputEvent > & a_Emitter,
TINT a_iKeyIndex,
uint8_t a_ui8KeyState )
protected

Definition at line 249 of file TInputDeviceKeyboard_Win.cpp.

250{
251 TINT iDoodad = TranslateDXToDoodad( a_iKeyIndex );
252
253 if ( iDoodad == KEY_TAB )
254 {
255 if ( IsAltDown() )
256 {
257 return TFALSE;
258 }
259 }
260
261 if ( ( a_ui8KeyState & 0x80 ) == 0 )
262 {
263 // Key released
264 m_pKeyStates1[ a_iKeyIndex ] = 0;
265 m_pKeyStates2[ a_iKeyIndex ] = 0x80;
266
267 a_Emitter.Throw( TInputInterface::InputEvent( this, iDoodad, TInputInterface::EVENT_TYPE_GONE_UP ) );
268 }
269 else
270 {
271 // Key pressed
272 m_pKeyStates1[ a_iKeyIndex ] = 0x80;
273 m_pKeyStates2[ a_iKeyIndex ] = 0;
274
275 TWCHAR* wcsCharacter = TranslateDoodadToCharacter( iDoodad );
276 a_Emitter.Throw( TInputInterface::InputEvent( this, iDoodad, TInputInterface::EVENT_TYPE_GONE_DOWN, wcsCharacter ) );
277 }
278
279 return TTRUE;
280}
TInputDXDeviceKeyboard::IsAltDown
virtual TBOOL IsAltDown() const override
Definition TInputDeviceKeyboard_Win.cpp:174
TInputDXDeviceKeyboard::TranslateDoodadToCharacter
virtual TWCHAR * TranslateDoodadToCharacter(TINT doodad) const override
Definition TInputDeviceKeyboard_Win.cpp:194
TEmitter::Throw
void Throw(Data *pData)
Definition TEvent.h:56

◆ Initialise()

TBOOL TInputDXDeviceKeyboard::Initialise ( )
virtual

Definition at line 211 of file TInputDeviceKeyboard_Win.cpp.

212{
213 m_iSomeNum = 0;
214
215 TUtil::MemClear( m_aBuffer, sizeof( m_aBuffer ) );
216 m_pKeyStates1 = m_aBuffer + m_iSomeNum * 256;
217 m_pKeyStates2 = m_aBuffer + m_iSomeNum * 256 + 256;
218
219 return TTRUE;
220}
TUtil::MemClear
static void MemClear(void *ptr, TSIZE size)
Definition TUtil.h:91

◆ IsAltDown()

TBOOL TInputDXDeviceKeyboard::IsAltDown ( ) const
overridevirtual

Implements TInputDeviceKeyboard.

Definition at line 174 of file TInputDeviceKeyboard_Win.cpp.

175{
176 return ( m_pKeyStates1[ DIK_LALT ] & 0x80 ) || ( m_pKeyStates1[ DIK_RALT ] & 0x80 );
177}

◆ IsControlDown()

TBOOL TInputDXDeviceKeyboard::IsControlDown ( ) const
overridevirtual

Implements TInputDeviceKeyboard.

Definition at line 169 of file TInputDeviceKeyboard_Win.cpp.

170{
171 return ( m_pKeyStates1[ DIK_LCONTROL ] & 0x80 ) || ( m_pKeyStates1[ DIK_RCONTROL ] & 0x80 );
172}

◆ IsDown()

TBOOL TInputDXDeviceKeyboard::IsDown ( TINT doodad) const
overridevirtual

Implements TInputDevice.

Definition at line 144 of file TInputDeviceKeyboard_Win.cpp.

145{
146 if ( !m_bIsUpdating )
147 return TFALSE;
148
149 if ( doodad == VIRTKEY_SHIFT )
150 return IsShiftDown();
151 else if ( doodad == VIRTKEY_CONTROL )
152 return IsControlDown();
153 else if ( doodad == VIRTKEY_ALT )
154 return IsAltDown();
155 else
156 return m_pKeyStates1[ TranslateDoodadToDX( doodad ) ] & 0x80;
157}
TInputDXDeviceKeyboard::TranslateDoodadToDX
static TINT TranslateDoodadToDX(TINT dxkey)
Definition TInputDeviceKeyboard_Win.cpp:537
TInputDXDeviceKeyboard::IsShiftDown
virtual TBOOL IsShiftDown() const override
Definition TInputDeviceKeyboard_Win.cpp:164
TInputDXDeviceKeyboard::IsControlDown
virtual TBOOL IsControlDown() const override
Definition TInputDeviceKeyboard_Win.cpp:169

◆ IsEnabled()

TBOOL TInputDXDeviceKeyboard::IsEnabled ( ) const
overridevirtual

Implements TInputDevice.

Definition at line 159 of file TInputDeviceKeyboard_Win.cpp.

160{
161 return TTRUE;
162}

◆ IsShiftDown()

TBOOL TInputDXDeviceKeyboard::IsShiftDown ( ) const
overridevirtual

Implements TInputDeviceKeyboard.

Definition at line 164 of file TInputDeviceKeyboard_Win.cpp.

165{
166 return ( m_pKeyStates1[ DIK_LSHIFT ] & 0x80 ) || ( m_pKeyStates1[ DIK_RSHIFT ] & 0x80 );
167}

◆ ProcessEvents()

TINT TInputDXDeviceKeyboard::ProcessEvents ( TEmitter< TInputInterface, TInputInterface::InputEvent > & emitter,
float deltaTime )
overridevirtual

Implements TInputDevice.

Definition at line 91 of file TInputDeviceKeyboard_Win.cpp.

92{
93 if ( m_bIsUpdating )
94 {
95 if ( m_bFlag )
96 {
97 for ( TSIZE i = 0; i < 256; i++ )
98 {
99 if ( m_pKeyStates1[ i ] != m_pKeyStates2[ i ] )
100 {
101 HandleKeyChange( emitter, i, m_pKeyStates1[ i ] );
102 }
103 }
104
105 m_bFlag = TFALSE;
106 }
107
108 DWORD dwNumElements = 32;
109 DIDEVICEOBJECTDATA aDeviceData[ 32 ];
110 TUtil::MemClear( aDeviceData, sizeof( aDeviceData ) );
111 HRESULT hRes = m_poDXInputDevice->GetDeviceData( sizeof( DIDEVICEOBJECTDATA ), aDeviceData, &dwNumElements, 0 );
112
113 if ( SUCCEEDED( hRes ) )
114 {
115 TINT iNumProcessed = 0;
116 iNumProcessed += ProcessRepeats( emitter, deltaTime );
117 iNumProcessed += ProcessVirtualButtons( emitter, deltaTime );
118
119 for ( DWORD i = 0; i < dwNumElements; i++ )
120 {
121 HandleKeyChange( emitter, aDeviceData[ i ].dwOfs, TUINT8( aDeviceData[ i ].dwData ) );
122
123 if ( aDeviceData[ i ].dwData != 0 )
124 iNumProcessed++;
125 }
126
127 UpdateVirtualButtons();
128 return iNumProcessed;
129 }
130
131 m_bIsUpdating = TFALSE;
132 Unacquire();
133 Acquire();
134 }
135
136 return 0;
137}
TSIZE
size_t TSIZE
Definition Typedefs.h:9
TUINT8
uint8_t TUINT8
Definition Typedefs.h:17
TInputDeviceKeyboard::ProcessVirtualButtons
virtual TINT ProcessVirtualButtons(EventEmitter &a_rEmitter, TFLOAT flt)
Definition TInputDeviceKeyboard.cpp:46
TInputDevice::ProcessRepeats
TINT ProcessRepeats(EventEmitter &a_rEmitter, TFLOAT a_fDeltaTime)
Definition TInputDevice.cpp:29
TInputDXDeviceKeyboard::HandleKeyChange
TBOOL HandleKeyChange(TEmitter< TInputInterface, TInputInterface::InputEvent > &a_Emitter, TINT a_iKeyIndex, uint8_t a_ui8KeyState)
Definition TInputDeviceKeyboard_Win.cpp:249
TInputDXDeviceKeyboard::Acquire
virtual TBOOL Acquire() override
Definition TInputDeviceKeyboard_Win.cpp:33
TInputDXDeviceKeyboard::Unacquire
virtual TBOOL Unacquire() override
Definition TInputDeviceKeyboard_Win.cpp:56

◆ RefreshDirect()

void TInputDXDeviceKeyboard::RefreshDirect ( )
virtual

Definition at line 228 of file TInputDeviceKeyboard_Win.cpp.

229{
230 if ( !IsAcquired() )
231 return;
232
233 std::swap( m_pKeyStates1, m_pKeyStates2 );
234
235 if ( SUCCEEDED( m_poDXInputDevice->Poll() ) &&
236 m_poDXInputDevice->GetDeviceState( 256, m_pKeyStates1 ) == S_OK )
237 {
238 DWORD dwNumElements = 32;
239 m_poDXInputDevice->GetDeviceData( sizeof( DIDEVICEOBJECTDATA ), NULL, &dwNumElements, 0 );
240 m_bFlag = TTRUE;
241 m_bIsUpdating = TTRUE;
242 }
243 else
244 {
245 m_bIsUpdating = TFALSE;
246 }
247}

◆ Release()

void TInputDXDeviceKeyboard::Release ( )
overridevirtual

Implements TInputDevice.

Definition at line 24 of file TInputDeviceKeyboard_Win.cpp.

25{
26 if ( m_poDXInputDevice )
27 {
28 m_poDXInputDevice->Release();
29 m_poDXInputDevice = TNULL;
30 }
31}

◆ TDECLARE_CLASS()

TInputDXDeviceKeyboard::TDECLARE_CLASS ( TInputDXDeviceKeyboard ,
TInputDeviceKeyboard  )

◆ TranslateDoodadToCharacter()

TWCHAR * TInputDXDeviceKeyboard::TranslateDoodadToCharacter ( TINT doodad) const
overridevirtual

Implements TInputDeviceKeyboard.

Definition at line 194 of file TInputDeviceKeyboard_Win.cpp.

195{
196#pragma warning( disable : 4309 )
197 static TWCHAR s_Buffer[ 2 ];
198 static constexpr TCHAR s_TranslateArrayLowerCase[] = { 0x00, 0x00, 0x00, (TCHAR)0x80, (TCHAR)0xbf, 0x00, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39, 0x30, 0x2d, 0x3d, 0x00, 0x00, 0x71, 0x77, 0x65, 0x72, 0x74, 0x79, 0x75, 0x69, 0x6f, 0x70, 0x5b, 0x5d, 0x00, 0x00, 0x61, 0x73, 0x64, 0x66, 0x67, 0x68, 0x6a, 0x6b, 0x6c, 0x3b, 0x27, 0x60, 0x00, 0x5c, 0x7a, 0x78, 0x63, 0x76, 0x62, 0x6e, 0x6d, 0x2c, 0x2e, 0x2f, 0x00, 0x2a, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
199 static constexpr TCHAR s_TranslateArrayUpperCase[] = { 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x21, 0x40, 0x23, 0x24, 0x25, 0x5e, 0x26, 0x2a, 0x28, 0x29, 0x5f, 0x2b, 0x00, 0x00, 0x51, 0x57, 0x45, 0x52, 0x54, 0x59, 0x55, 0x49, 0x4f, 0x50, 0x7b, 0x7d, 0x00, 0x00, 0x41, 0x53, 0x44, 0x46, 0x47, 0x48, 0x4a, 0x4b, 0x4c, 0x3b, 0x00, 0x7e, 0x00, 0x7c, 0x5a, 0x58, 0x43, 0x56, 0x42, 0x4e, 0x4d, 0x3c, 0x3e, 0x3f, 0x00, 0x2a, 0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00 };
200#pragma warning( default : 4309 )
201
202 if ( !IsShiftDown() )
203 s_Buffer[ 0 ] = TWCHAR( s_TranslateArrayLowerCase[ doodad - 0x20000 ] );
204 else
205 s_Buffer[ 0 ] = TWCHAR( s_TranslateArrayUpperCase[ doodad - 0x20000 ] );
206
207 s_Buffer[ 1 ] = L'\0';
208 return s_Buffer;
209}
TCHAR
char TCHAR
Definition Typedefs.h:20

◆ TranslateDoodadToDX()

TINT TInputDXDeviceKeyboard::TranslateDoodadToDX ( TINT dxkey)
staticprotected

Definition at line 537 of file TInputDeviceKeyboard_Win.cpp.

538{
539 switch ( dxkey )
540 {
541 case TInputDeviceKeyboard::KEY_ESCAPE:
542 return DIK_ESCAPE;
543 case TInputDeviceKeyboard::KEY_1:
544 return DIK_1;
545 case TInputDeviceKeyboard::KEY_2:
546 return DIK_2;
547 case TInputDeviceKeyboard::KEY_3:
548 return DIK_3;
549 case TInputDeviceKeyboard::KEY_4:
550 return DIK_4;
551 case TInputDeviceKeyboard::KEY_5:
552 return DIK_5;
553 case TInputDeviceKeyboard::KEY_6:
554 return DIK_6;
555 case TInputDeviceKeyboard::KEY_7:
556 return DIK_7;
557 case TInputDeviceKeyboard::KEY_8:
558 return DIK_8;
559 case TInputDeviceKeyboard::KEY_9:
560 return DIK_9;
561 case TInputDeviceKeyboard::KEY_0:
562 return DIK_0;
563 case TInputDeviceKeyboard::KEY_MINUS:
564 return DIK_MINUS;
565 case TInputDeviceKeyboard::KEY_EQUALS:
566 return DIK_EQUALS;
567 case TInputDeviceKeyboard::KEY_BACK:
568 return DIK_BACK;
569 case TInputDeviceKeyboard::KEY_TAB:
570 return DIK_TAB;
571 case TInputDeviceKeyboard::KEY_Q:
572 return DIK_Q;
573 case TInputDeviceKeyboard::KEY_W:
574 return DIK_W;
575 case TInputDeviceKeyboard::KEY_E:
576 return DIK_E;
577 case TInputDeviceKeyboard::KEY_R:
578 return DIK_R;
579 case TInputDeviceKeyboard::KEY_T:
580 return DIK_T;
581 case TInputDeviceKeyboard::KEY_Y:
582 return DIK_Y;
583 case TInputDeviceKeyboard::KEY_U:
584 return DIK_U;
585 case TInputDeviceKeyboard::KEY_I:
586 return DIK_I;
587 case TInputDeviceKeyboard::KEY_O:
588 return DIK_O;
589 case TInputDeviceKeyboard::KEY_P:
590 return DIK_P;
591 case TInputDeviceKeyboard::KEY_LBRACKET:
592 return DIK_LBRACKET;
593 case TInputDeviceKeyboard::KEY_RBRACKET:
594 return DIK_RBRACKET;
595 case TInputDeviceKeyboard::KEY_RETURN:
596 return DIK_RETURN;
597 case TInputDeviceKeyboard::KEY_LCONTROL:
598 return DIK_LCONTROL;
599 case TInputDeviceKeyboard::KEY_A:
600 return DIK_A;
601 case TInputDeviceKeyboard::KEY_S:
602 return DIK_S;
603 case TInputDeviceKeyboard::KEY_D:
604 return DIK_D;
605 case TInputDeviceKeyboard::KEY_F:
606 return DIK_F;
607 case TInputDeviceKeyboard::KEY_G:
608 return DIK_G;
609 case TInputDeviceKeyboard::KEY_H:
610 return DIK_H;
611 case TInputDeviceKeyboard::KEY_J:
612 return DIK_J;
613 case TInputDeviceKeyboard::KEY_K:
614 return DIK_K;
615 case TInputDeviceKeyboard::KEY_L:
616 return DIK_L;
617 case TInputDeviceKeyboard::KEY_SEMICOLON:
618 return DIK_SEMICOLON;
619 case TInputDeviceKeyboard::KEY_APOSTROPHE:
620 return DIK_APOSTROPHE;
621 case TInputDeviceKeyboard::KEY_GRAVE:
622 return DIK_GRAVE;
623 case TInputDeviceKeyboard::KEY_LSHIFT:
624 return DIK_LSHIFT;
625 case TInputDeviceKeyboard::KEY_BACKSLASH:
626 return DIK_BACKSLASH;
627 case TInputDeviceKeyboard::KEY_Z:
628 return DIK_Z;
629 case TInputDeviceKeyboard::KEY_X:
630 return DIK_X;
631 case TInputDeviceKeyboard::KEY_C:
632 return DIK_C;
633 case TInputDeviceKeyboard::KEY_V:
634 return DIK_V;
635 case TInputDeviceKeyboard::KEY_B:
636 return DIK_B;
637 case TInputDeviceKeyboard::KEY_N:
638 return DIK_N;
639 case TInputDeviceKeyboard::KEY_M:
640 return DIK_M;
641 case TInputDeviceKeyboard::KEY_COMMA:
642 return DIK_COMMA;
643 case TInputDeviceKeyboard::KEY_PERIOD:
644 return DIK_PERIOD;
645 case TInputDeviceKeyboard::KEY_SLASH:
646 return DIK_SLASH;
647 case TInputDeviceKeyboard::KEY_RSHIFT:
648 return DIK_RSHIFT;
649 case TInputDeviceKeyboard::KEY_MULTIPLY:
650 return DIK_MULTIPLY;
651 case TInputDeviceKeyboard::KEY_LMENU:
652 return DIK_LMENU;
653 case TInputDeviceKeyboard::KEY_SPACE:
654 return DIK_SPACE;
655 case TInputDeviceKeyboard::KEY_CAPITAL:
656 return DIK_CAPITAL;
657 case TInputDeviceKeyboard::KEY_F1:
658 return DIK_F1;
659 case TInputDeviceKeyboard::KEY_F2:
660 return DIK_F2;
661 case TInputDeviceKeyboard::KEY_F3:
662 return DIK_F3;
663 case TInputDeviceKeyboard::KEY_F4:
664 return DIK_F4;
665 case TInputDeviceKeyboard::KEY_F5:
666 return DIK_F5;
667 case TInputDeviceKeyboard::KEY_F6:
668 return DIK_F6;
669 case TInputDeviceKeyboard::KEY_F7:
670 return DIK_F7;
671 case TInputDeviceKeyboard::KEY_F8:
672 return DIK_F8;
673 case TInputDeviceKeyboard::KEY_F9:
674 return DIK_F9;
675 case TInputDeviceKeyboard::KEY_F10:
676 return DIK_F10;
677 case TInputDeviceKeyboard::KEY_NUMLOCK:
678 return DIK_NUMLOCK;
679 case TInputDeviceKeyboard::KEY_SCROLL:
680 return DIK_SCROLL;
681 case TInputDeviceKeyboard::KEY_NUMPAD7:
682 return DIK_NUMPAD7;
683 case TInputDeviceKeyboard::KEY_NUMPAD8:
684 return DIK_NUMPAD8;
685 case TInputDeviceKeyboard::KEY_NUMPAD9:
686 return DIK_NUMPAD9;
687 case TInputDeviceKeyboard::KEY_SUBTRACT:
688 return DIK_SUBTRACT;
689 case TInputDeviceKeyboard::KEY_NUMPAD4:
690 return DIK_NUMPAD4;
691 case TInputDeviceKeyboard::KEY_NUMPAD5:
692 return DIK_NUMPAD5;
693 case TInputDeviceKeyboard::KEY_NUMPAD6:
694 return DIK_NUMPAD6;
695 case TInputDeviceKeyboard::KEY_ADD:
696 return DIK_ADD;
697 case TInputDeviceKeyboard::KEY_NUMPAD1:
698 return DIK_NUMPAD1;
699 case TInputDeviceKeyboard::KEY_NUMPAD2:
700 return DIK_NUMPAD2;
701 case TInputDeviceKeyboard::KEY_NUMPAD3:
702 return DIK_NUMPAD3;
703 case TInputDeviceKeyboard::KEY_NUMPAD0:
704 return DIK_NUMPAD0;
705 case TInputDeviceKeyboard::KEY_DECIMAL:
706 return DIK_DECIMAL;
707 case TInputDeviceKeyboard::KEY_F11:
708 return DIK_F11;
709 case TInputDeviceKeyboard::KEY_F12:
710 return DIK_F12;
711 case TInputDeviceKeyboard::KEY_F13:
712 return DIK_F13;
713 case TInputDeviceKeyboard::KEY_F14:
714 return DIK_F14;
715 case TInputDeviceKeyboard::KEY_F15:
716 return DIK_F15;
717 case TInputDeviceKeyboard::KEY_KANA:
718 return DIK_KANA;
719 case TInputDeviceKeyboard::KEY_CONVERT:
720 return DIK_CONVERT;
721 case TInputDeviceKeyboard::KEY_NOCONVERT:
722 return DIK_NOCONVERT;
723 case TInputDeviceKeyboard::KEY_YEN:
724 return DIK_YEN;
725 case TInputDeviceKeyboard::KEY_NUMPADEQUALS:
726 return DIK_NUMPADEQUALS;
727 case TInputDeviceKeyboard::KEY_CIRCUMFLEX:
728 return DIK_CIRCUMFLEX;
729 case TInputDeviceKeyboard::KEY_AT:
730 return DIK_AT;
731 case TInputDeviceKeyboard::KEY_COLON:
732 return DIK_COLON;
733 case TInputDeviceKeyboard::KEY_UNDERLINE:
734 return DIK_UNDERLINE;
735 case TInputDeviceKeyboard::KEY_KANJI:
736 return DIK_KANJI;
737 case TInputDeviceKeyboard::KEY_STOP:
738 return DIK_STOP;
739 case TInputDeviceKeyboard::KEY_AX:
740 return DIK_AX;
741 case TInputDeviceKeyboard::KEY_UNLABELED:
742 return DIK_UNLABELED;
743 case TInputDeviceKeyboard::KEY_NUMPADENTER:
744 return DIK_NUMPADENTER;
745 case TInputDeviceKeyboard::KEY_RCONTROL:
746 return DIK_RCONTROL;
747 case TInputDeviceKeyboard::KEY_NUMPADCOMMA:
748 return DIK_NUMPADCOMMA;
749 case TInputDeviceKeyboard::KEY_DIVIDE:
750 return DIK_DIVIDE;
751 case TInputDeviceKeyboard::KEY_SYSRQ:
752 return DIK_SYSRQ;
753 case TInputDeviceKeyboard::KEY_RMENU:
754 return DIK_RMENU;
755 case TInputDeviceKeyboard::KEY_PAUSE:
756 return DIK_PAUSE;
757 case TInputDeviceKeyboard::KEY_HOME:
758 return DIK_HOME;
759 case TInputDeviceKeyboard::KEY_UP:
760 return DIK_UP;
761 case TInputDeviceKeyboard::KEY_PRIOR:
762 return DIK_PRIOR;
763 case TInputDeviceKeyboard::KEY_LEFT:
764 return DIK_LEFT;
765 case TInputDeviceKeyboard::KEY_RIGHT:
766 return DIK_RIGHT;
767 case TInputDeviceKeyboard::KEY_END:
768 return DIK_END;
769 case TInputDeviceKeyboard::KEY_DOWN:
770 return DIK_DOWN;
771 case TInputDeviceKeyboard::KEY_NEXT:
772 return DIK_NEXT;
773 case TInputDeviceKeyboard::KEY_INSERT:
774 return DIK_INSERT;
775 case TInputDeviceKeyboard::KEY_DELETE:
776 return DIK_DELETE;
777 case TInputDeviceKeyboard::KEY_LWIN:
778 return DIK_LWIN;
779 case TInputDeviceKeyboard::KEY_RWIN:
780 return DIK_RWIN;
781 case TInputDeviceKeyboard::KEY_APPS:
782 return DIK_APPS;
783 case TInputDeviceKeyboard::KEY_POWER:
784 return DIK_POWER;
785 case TInputDeviceKeyboard::KEY_SLEEP:
786 return DIK_SLEEP;
787 default:
788 return 0;
789 }
790}

◆ TranslateDXToDoodad()

TINT TInputDXDeviceKeyboard::TranslateDXToDoodad ( TINT doodad)
staticprotected

Definition at line 282 of file TInputDeviceKeyboard_Win.cpp.

283{
284 switch ( doodad )
285 {
286 case DIK_ESCAPE:
287 return TInputDeviceKeyboard::KEY_ESCAPE;
288 case DIK_1:
289 return TInputDeviceKeyboard::KEY_1;
290 case DIK_2:
291 return TInputDeviceKeyboard::KEY_2;
292 case DIK_3:
293 return TInputDeviceKeyboard::KEY_3;
294 case DIK_4:
295 return TInputDeviceKeyboard::KEY_4;
296 case DIK_5:
297 return TInputDeviceKeyboard::KEY_5;
298 case DIK_6:
299 return TInputDeviceKeyboard::KEY_6;
300 case DIK_7:
301 return TInputDeviceKeyboard::KEY_7;
302 case DIK_8:
303 return TInputDeviceKeyboard::KEY_8;
304 case DIK_9:
305 return TInputDeviceKeyboard::KEY_9;
306 case DIK_0:
307 return TInputDeviceKeyboard::KEY_0;
308 case DIK_MINUS:
309 return TInputDeviceKeyboard::KEY_MINUS;
310 case DIK_EQUALS:
311 return TInputDeviceKeyboard::KEY_EQUALS;
312 case DIK_BACK:
313 return TInputDeviceKeyboard::KEY_BACK;
314 case DIK_TAB:
315 return TInputDeviceKeyboard::KEY_TAB;
316 case DIK_Q:
317 return TInputDeviceKeyboard::KEY_Q;
318 case DIK_W:
319 return TInputDeviceKeyboard::KEY_W;
320 case DIK_E:
321 return TInputDeviceKeyboard::KEY_E;
322 case DIK_R:
323 return TInputDeviceKeyboard::KEY_R;
324 case DIK_T:
325 return TInputDeviceKeyboard::KEY_T;
326 case DIK_Y:
327 return TInputDeviceKeyboard::KEY_Y;
328 case DIK_U:
329 return TInputDeviceKeyboard::KEY_U;
330 case DIK_I:
331 return TInputDeviceKeyboard::KEY_I;
332 case DIK_O:
333 return TInputDeviceKeyboard::KEY_O;
334 case DIK_P:
335 return TInputDeviceKeyboard::KEY_P;
336 case DIK_LBRACKET:
337 return TInputDeviceKeyboard::KEY_LBRACKET;
338 case DIK_RBRACKET:
339 return TInputDeviceKeyboard::KEY_RBRACKET;
340 case DIK_RETURN:
341 return TInputDeviceKeyboard::KEY_RETURN;
342 case DIK_LCONTROL:
343 return TInputDeviceKeyboard::KEY_LCONTROL;
344 case DIK_A:
345 return TInputDeviceKeyboard::KEY_A;
346 case DIK_S:
347 return TInputDeviceKeyboard::KEY_S;
348 case DIK_D:
349 return TInputDeviceKeyboard::KEY_D;
350 case DIK_F:
351 return TInputDeviceKeyboard::KEY_F;
352 case DIK_G:
353 return TInputDeviceKeyboard::KEY_G;
354 case DIK_H:
355 return TInputDeviceKeyboard::KEY_H;
356 case DIK_J:
357 return TInputDeviceKeyboard::KEY_J;
358 case DIK_K:
359 return TInputDeviceKeyboard::KEY_K;
360 case DIK_L:
361 return TInputDeviceKeyboard::KEY_L;
362 case DIK_SEMICOLON:
363 return TInputDeviceKeyboard::KEY_SEMICOLON;
364 case DIK_APOSTROPHE:
365 return TInputDeviceKeyboard::KEY_APOSTROPHE;
366 case DIK_GRAVE:
367 return TInputDeviceKeyboard::KEY_GRAVE;
368 case DIK_LSHIFT:
369 return TInputDeviceKeyboard::KEY_LSHIFT;
370 case DIK_BACKSLASH:
371 return TInputDeviceKeyboard::KEY_BACKSLASH;
372 case DIK_Z:
373 return TInputDeviceKeyboard::KEY_Z;
374 case DIK_X:
375 return TInputDeviceKeyboard::KEY_X;
376 case DIK_C:
377 return TInputDeviceKeyboard::KEY_C;
378 case DIK_V:
379 return TInputDeviceKeyboard::KEY_V;
380 case DIK_B:
381 return TInputDeviceKeyboard::KEY_B;
382 case DIK_N:
383 return TInputDeviceKeyboard::KEY_N;
384 case DIK_M:
385 return TInputDeviceKeyboard::KEY_M;
386 case DIK_COMMA:
387 return TInputDeviceKeyboard::KEY_COMMA;
388 case DIK_PERIOD:
389 return TInputDeviceKeyboard::KEY_PERIOD;
390 case DIK_SLASH:
391 return TInputDeviceKeyboard::KEY_SLASH;
392 case DIK_RSHIFT:
393 return TInputDeviceKeyboard::KEY_RSHIFT;
394 case DIK_MULTIPLY:
395 return TInputDeviceKeyboard::KEY_MULTIPLY;
396 case DIK_LMENU:
397 return TInputDeviceKeyboard::KEY_LMENU;
398 case DIK_SPACE:
399 return TInputDeviceKeyboard::KEY_SPACE;
400 case DIK_CAPITAL:
401 return TInputDeviceKeyboard::KEY_CAPITAL;
402 case DIK_F1:
403 return TInputDeviceKeyboard::KEY_F1;
404 case DIK_F2:
405 return TInputDeviceKeyboard::KEY_F2;
406 case DIK_F3:
407 return TInputDeviceKeyboard::KEY_F3;
408 case DIK_F4:
409 return TInputDeviceKeyboard::KEY_F4;
410 case DIK_F5:
411 return TInputDeviceKeyboard::KEY_F5;
412 case DIK_F6:
413 return TInputDeviceKeyboard::KEY_F6;
414 case DIK_F7:
415 return TInputDeviceKeyboard::KEY_F7;
416 case DIK_F8:
417 return TInputDeviceKeyboard::KEY_F8;
418 case DIK_F9:
419 return TInputDeviceKeyboard::KEY_F9;
420 case DIK_F10:
421 return TInputDeviceKeyboard::KEY_F10;
422 case DIK_NUMLOCK:
423 return TInputDeviceKeyboard::KEY_NUMLOCK;
424 case DIK_SCROLL:
425 return TInputDeviceKeyboard::KEY_SCROLL;
426 case DIK_NUMPAD7:
427 return TInputDeviceKeyboard::KEY_NUMPAD7;
428 case DIK_NUMPAD8:
429 return TInputDeviceKeyboard::KEY_NUMPAD8;
430 case DIK_NUMPAD9:
431 return TInputDeviceKeyboard::KEY_NUMPAD9;
432 case DIK_SUBTRACT:
433 return TInputDeviceKeyboard::KEY_SUBTRACT;
434 case DIK_NUMPAD4:
435 return TInputDeviceKeyboard::KEY_NUMPAD4;
436 case DIK_NUMPAD5:
437 return TInputDeviceKeyboard::KEY_NUMPAD5;
438 case DIK_NUMPAD6:
439 return TInputDeviceKeyboard::KEY_NUMPAD6;
440 case DIK_ADD:
441 return TInputDeviceKeyboard::KEY_ADD;
442 case DIK_NUMPAD1:
443 return TInputDeviceKeyboard::KEY_NUMPAD1;
444 case DIK_NUMPAD2:
445 return TInputDeviceKeyboard::KEY_NUMPAD2;
446 case DIK_NUMPAD3:
447 return TInputDeviceKeyboard::KEY_NUMPAD3;
448 case DIK_NUMPAD0:
449 return TInputDeviceKeyboard::KEY_NUMPAD0;
450 case DIK_DECIMAL:
451 return TInputDeviceKeyboard::KEY_DECIMAL;
452 case DIK_F11:
453 return TInputDeviceKeyboard::KEY_F11;
454 case DIK_F12:
455 return TInputDeviceKeyboard::KEY_F12;
456 case DIK_F13:
457 return TInputDeviceKeyboard::KEY_F13;
458 case DIK_F14:
459 return TInputDeviceKeyboard::KEY_F14;
460 case DIK_F15:
461 return TInputDeviceKeyboard::KEY_F15;
462 case DIK_KANA:
463 return TInputDeviceKeyboard::KEY_KANA;
464 case DIK_CONVERT:
465 return TInputDeviceKeyboard::KEY_CONVERT;
466 case DIK_NOCONVERT:
467 return TInputDeviceKeyboard::KEY_NOCONVERT;
468 case DIK_YEN:
469 return TInputDeviceKeyboard::KEY_YEN;
470 case DIK_NUMPADEQUALS:
471 return TInputDeviceKeyboard::KEY_NUMPADEQUALS;
472 case DIK_CIRCUMFLEX:
473 return TInputDeviceKeyboard::KEY_CIRCUMFLEX;
474 case DIK_AT:
475 return TInputDeviceKeyboard::KEY_AT;
476 case DIK_COLON:
477 return TInputDeviceKeyboard::KEY_COLON;
478 case DIK_UNDERLINE:
479 return TInputDeviceKeyboard::KEY_UNDERLINE;
480 case DIK_KANJI:
481 return TInputDeviceKeyboard::KEY_KANJI;
482 case DIK_STOP:
483 return TInputDeviceKeyboard::KEY_STOP;
484 case DIK_AX:
485 return TInputDeviceKeyboard::KEY_AX;
486 case DIK_UNLABELED:
487 return TInputDeviceKeyboard::KEY_UNLABELED;
488 case DIK_NUMPADENTER:
489 return TInputDeviceKeyboard::KEY_NUMPADENTER;
490 case DIK_RCONTROL:
491 return TInputDeviceKeyboard::KEY_RCONTROL;
492 case DIK_NUMPADCOMMA:
493 return TInputDeviceKeyboard::KEY_NUMPADCOMMA;
494 case DIK_DIVIDE:
495 return TInputDeviceKeyboard::KEY_DIVIDE;
496 case DIK_SYSRQ:
497 return TInputDeviceKeyboard::KEY_SYSRQ;
498 case DIK_RMENU:
499 return TInputDeviceKeyboard::KEY_RMENU;
500 case DIK_PAUSE:
501 return TInputDeviceKeyboard::KEY_PAUSE;
502 case DIK_HOME:
503 return TInputDeviceKeyboard::KEY_HOME;
504 case DIK_UP:
505 return TInputDeviceKeyboard::KEY_UP;
506 case DIK_PRIOR:
507 return TInputDeviceKeyboard::KEY_PRIOR;
508 case DIK_LEFT:
509 return TInputDeviceKeyboard::KEY_LEFT;
510 case DIK_RIGHT:
511 return TInputDeviceKeyboard::KEY_RIGHT;
512 case DIK_END:
513 return TInputDeviceKeyboard::KEY_END;
514 case DIK_DOWN:
515 return TInputDeviceKeyboard::KEY_DOWN;
516 case DIK_NEXT:
517 return TInputDeviceKeyboard::KEY_NEXT;
518 case DIK_INSERT:
519 return TInputDeviceKeyboard::KEY_INSERT;
520 case DIK_DELETE:
521 return TInputDeviceKeyboard::KEY_DELETE;
522 case DIK_LWIN:
523 return TInputDeviceKeyboard::KEY_LWIN;
524 case DIK_RWIN:
525 return TInputDeviceKeyboard::KEY_RWIN;
526 case DIK_APPS:
527 return TInputDeviceKeyboard::KEY_APPS;
528 case DIK_POWER:
529 return TInputDeviceKeyboard::KEY_POWER;
530 case DIK_SLEEP:
531 return TInputDeviceKeyboard::KEY_SLEEP;
532 default:
533 return 0;
534 }
535}

◆ Unacquire()

TBOOL TInputDXDeviceKeyboard::Unacquire ( )
overridevirtual

Implements TInputDevice.

Definition at line 56 of file TInputDeviceKeyboard_Win.cpp.

57{
58 m_bIsUpdating = TFALSE;
59 SetAcquired( TFALSE );
60
61 return SUCCEEDED( m_poDXInputDevice->Unacquire() );
62}

◆ Update()

void TInputDXDeviceKeyboard::Update ( float deltaTime)
overridevirtual

Implements TInputDevice.

Definition at line 64 of file TInputDeviceKeyboard_Win.cpp.

65{
66 if ( IsAcquired() )
67 m_bIsUpdating = TTRUE;
68}

◆ WasDown()

TBOOL TInputDXDeviceKeyboard::WasDown ( TINT doodad) const
overridevirtual

Implements TInputDeviceKeyboard.

Definition at line 179 of file TInputDeviceKeyboard_Win.cpp.

180{
181 if ( !m_bIsUpdating )
182 return TFALSE;
183
184 if ( doodad == VIRTKEY_SHIFT )
185 return ( m_pKeyStates2[ DIK_LSHIFT ] & 0x80 ) || ( m_pKeyStates2[ DIK_RSHIFT ] & 0x80 );
186 else if ( doodad == VIRTKEY_CONTROL )
187 return ( m_pKeyStates2[ DIK_LCONTROL ] & 0x80 ) || ( m_pKeyStates2[ DIK_RCONTROL ] & 0x80 );
188 else if ( doodad == VIRTKEY_ALT )
189 return ( m_pKeyStates2[ DIK_LALT ] & 0x80 ) || ( m_pKeyStates2[ DIK_RALT ] & 0x80 );
190 else
191 return m_pKeyStates2[ TranslateDXToDoodad( doodad ) ] & 0x80;
192}
The documentation for this class was generated from the following files: