ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

SI_DeviceKeyboard: Amend variable naming

This commit is contained in:
Lioncash 2017-03-14 18:04:13 -04:00
parent 4478b9bc9a
commit 8b8a1f3b35
2 changed files with 136 additions and 136 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

220
Source/Core/Core/HW/SI/SI_DeviceKeyboard.cpp
View File

@ -11,36 +11,36 @@
#include "InputCommon/KeyboardStatus.h" #include "InputCommon/KeyboardStatus.h"
// --- GameCube keyboard --- // --- GameCube keyboard ---
CSIDevice_Keyboard::CSIDevice_Keyboard(SIDevices device, int _iDeviceNumber) CSIDevice_Keyboard::CSIDevice_Keyboard(SIDevices device, int device_number)
: ISIDevice(device, _iDeviceNumber) : ISIDevice(device, device_number)
{ {
} }
int CSIDevice_Keyboard::RunBuffer(u8* _pBuffer, int _iLength) int CSIDevice_Keyboard::RunBuffer(u8* buffer, int length)
{ {
// For debug logging only // For debug logging only
ISIDevice::RunBuffer(_pBuffer, _iLength); ISIDevice::RunBuffer(buffer, length);
// Read the command // Read the command
EBufferCommands command = static_cast<EBufferCommands>(_pBuffer[3]); EBufferCommands command = static_cast<EBufferCommands>(buffer[3]);
// Handle it // Handle it
switch (command) switch (command)
{ {
case CMD_RESET: case CMD_RESET:
case CMD_ID: case CMD_ID:
*(u32*)&_pBuffer[0] = SI_GC_KEYBOARD; *(u32*)&buffer[0] = SI_GC_KEYBOARD;
break; break;
case CMD_DIRECT: case CMD_DIRECT:
{ {
INFO_LOG(SERIALINTERFACE, "Keyboard - Direct (Length: %d)", _iLength); INFO_LOG(SERIALINTERFACE, "Keyboard - Direct (Length: %d)", length);
u32 high, low; u32 high, low;
GetData(high, low); GetData(high, low);
for (int i = 0; i < (_iLength - 1) / 2; i++) for (int i = 0; i < (length - 1) / 2; i++)
{ {
_pBuffer[i + 0] = (high >> (i * 8)) & 0xff; buffer[i + 0] = (high >> (i * 8)) & 0xff;
_pBuffer[i + 4] = (low >> (i * 8)) & 0xff; buffer[i + 4] = (low >> (i * 8)) & 0xff;
} }
} }
break; break;
@ -52,7 +52,7 @@ int CSIDevice_Keyboard::RunBuffer(u8* _pBuffer, int _iLength)
break; break;
} }
return _iLength; return length;
} }
KeyboardStatus CSIDevice_Keyboard::GetKeyboardStatus() const KeyboardStatus CSIDevice_Keyboard::GetKeyboardStatus() const
@ -60,37 +60,37 @@ KeyboardStatus CSIDevice_Keyboard::GetKeyboardStatus() const
return Keyboard::GetStatus(m_device_number); return Keyboard::GetStatus(m_device_number);
} }
bool CSIDevice_Keyboard::GetData(u32& _Hi, u32& _Low) bool CSIDevice_Keyboard::GetData(u32& hi, u32& low)
{ {
KeyboardStatus KeyStatus = GetKeyboardStatus(); KeyboardStatus key_status = GetKeyboardStatus();
u8 key[3] = {0x00, 0x00, 0x00}; u8 key[3] = {0x00, 0x00, 0x00};
MapKeys(KeyStatus, key); MapKeys(key_status, key);
u8 checksum = key[0] ^ key[1] ^ key[2] ^ m_Counter; u8 checksum = key[0] ^ key[1] ^ key[2] ^ m_counter;
_Hi = m_Counter << 24; hi = m_counter << 24;
_Low = key[0] << 24 | key[1] << 16 | key[2] << 8 | checksum; low = key[0] << 24 | key[1] << 16 | key[2] << 8 | checksum;
return true; return true;
} }
void CSIDevice_Keyboard::SendCommand(u32 _Cmd, u8 _Poll) void CSIDevice_Keyboard::SendCommand(u32 command, u8 poll)
{ {
UCommand command(_Cmd); UCommand keyboard_command(command);
switch (command.Command) switch (keyboard_command.command)
{ {
case 0x00: case 0x00:
break; break;
case CMD_POLL: case CMD_POLL:
{ {
m_Counter++; m_counter++;
m_Counter &= 15; m_counter &= 15;
} }
break; break;
default: default:
{ {
ERROR_LOG(SERIALINTERFACE, "Unknown direct command (0x%x)", _Cmd); ERROR_LOG(SERIALINTERFACE, "Unknown direct command (0x%x)", command);
} }
break; break;
} }
@ -98,519 +98,519 @@ void CSIDevice_Keyboard::SendCommand(u32 _Cmd, u8 _Poll)
void CSIDevice_Keyboard::DoState(PointerWrap& p) void CSIDevice_Keyboard::DoState(PointerWrap& p)
{ {
p.Do(m_Counter); p.Do(m_counter);
} }
void CSIDevice_Keyboard::MapKeys(const KeyboardStatus& KeyStatus, u8* key) void CSIDevice_Keyboard::MapKeys(const KeyboardStatus& key_status, u8* key)
{ {
u8 keys_held = 0; u8 keys_held = 0;
const u8 MAX_KEYS_HELD = 3; const u8 MAX_KEYS_HELD = 3;
if (KeyStatus.key0x & KEYMASK_HOME) if (key_status.key0x & KEYMASK_HOME)
{ {
key[keys_held++] = KEY_HOME; key[keys_held++] = KEY_HOME;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_END) if (key_status.key0x & KEYMASK_END)
{ {
key[keys_held++] = KEY_END; key[keys_held++] = KEY_END;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_PGUP) if (key_status.key0x & KEYMASK_PGUP)
{ {
key[keys_held++] = KEY_PGUP; key[keys_held++] = KEY_PGUP;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_PGDN) if (key_status.key0x & KEYMASK_PGDN)
{ {
key[keys_held++] = KEY_PGDN; key[keys_held++] = KEY_PGDN;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_SCROLLLOCK) if (key_status.key0x & KEYMASK_SCROLLLOCK)
{ {
key[keys_held++] = KEY_SCROLLLOCK; key[keys_held++] = KEY_SCROLLLOCK;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_A) if (key_status.key0x & KEYMASK_A)
{ {
key[keys_held++] = KEY_A; key[keys_held++] = KEY_A;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_B) if (key_status.key0x & KEYMASK_B)
{ {
key[keys_held++] = KEY_B; key[keys_held++] = KEY_B;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_C) if (key_status.key0x & KEYMASK_C)
{ {
key[keys_held++] = KEY_C; key[keys_held++] = KEY_C;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_D) if (key_status.key0x & KEYMASK_D)
{ {
key[keys_held++] = KEY_D; key[keys_held++] = KEY_D;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_E) if (key_status.key0x & KEYMASK_E)
{ {
key[keys_held++] = KEY_E; key[keys_held++] = KEY_E;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_F) if (key_status.key0x & KEYMASK_F)
{ {
key[keys_held++] = KEY_F; key[keys_held++] = KEY_F;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_G) if (key_status.key0x & KEYMASK_G)
{ {
key[keys_held++] = KEY_G; key[keys_held++] = KEY_G;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_H) if (key_status.key0x & KEYMASK_H)
{ {
key[keys_held++] = KEY_H; key[keys_held++] = KEY_H;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_I) if (key_status.key0x & KEYMASK_I)
{ {
key[keys_held++] = KEY_I; key[keys_held++] = KEY_I;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_J) if (key_status.key0x & KEYMASK_J)
{ {
key[keys_held++] = KEY_J; key[keys_held++] = KEY_J;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key0x & KEYMASK_K) if (key_status.key0x & KEYMASK_K)
{ {
key[keys_held++] = KEY_K; key[keys_held++] = KEY_K;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_L) if (key_status.key1x & KEYMASK_L)
{ {
key[keys_held++] = KEY_L; key[keys_held++] = KEY_L;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_M) if (key_status.key1x & KEYMASK_M)
{ {
key[keys_held++] = KEY_M; key[keys_held++] = KEY_M;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_N) if (key_status.key1x & KEYMASK_N)
{ {
key[keys_held++] = KEY_N; key[keys_held++] = KEY_N;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_O) if (key_status.key1x & KEYMASK_O)
{ {
key[keys_held++] = KEY_O; key[keys_held++] = KEY_O;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_P) if (key_status.key1x & KEYMASK_P)
{ {
key[keys_held++] = KEY_P; key[keys_held++] = KEY_P;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_Q) if (key_status.key1x & KEYMASK_Q)
{ {
key[keys_held++] = KEY_Q; key[keys_held++] = KEY_Q;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_R) if (key_status.key1x & KEYMASK_R)
{ {
key[keys_held++] = KEY_R; key[keys_held++] = KEY_R;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_S) if (key_status.key1x & KEYMASK_S)
{ {
key[keys_held++] = KEY_S; key[keys_held++] = KEY_S;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_T) if (key_status.key1x & KEYMASK_T)
{ {
key[keys_held++] = KEY_T; key[keys_held++] = KEY_T;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_U) if (key_status.key1x & KEYMASK_U)
{ {
key[keys_held++] = KEY_U; key[keys_held++] = KEY_U;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_V) if (key_status.key1x & KEYMASK_V)
{ {
key[keys_held++] = KEY_V; key[keys_held++] = KEY_V;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_W) if (key_status.key1x & KEYMASK_W)
{ {
key[keys_held++] = KEY_W; key[keys_held++] = KEY_W;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_X) if (key_status.key1x & KEYMASK_X)
{ {
key[keys_held++] = KEY_X; key[keys_held++] = KEY_X;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_Y) if (key_status.key1x & KEYMASK_Y)
{ {
key[keys_held++] = KEY_Y; key[keys_held++] = KEY_Y;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_Z) if (key_status.key1x & KEYMASK_Z)
{ {
key[keys_held++] = KEY_Z; key[keys_held++] = KEY_Z;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key1x & KEYMASK_1) if (key_status.key1x & KEYMASK_1)
{ {
key[keys_held++] = KEY_1; key[keys_held++] = KEY_1;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_2) if (key_status.key2x & KEYMASK_2)
{ {
key[keys_held++] = KEY_2; key[keys_held++] = KEY_2;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_3) if (key_status.key2x & KEYMASK_3)
{ {
key[keys_held++] = KEY_3; key[keys_held++] = KEY_3;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_4) if (key_status.key2x & KEYMASK_4)
{ {
key[keys_held++] = KEY_4; key[keys_held++] = KEY_4;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_5) if (key_status.key2x & KEYMASK_5)
{ {
key[keys_held++] = KEY_5; key[keys_held++] = KEY_5;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_6) if (key_status.key2x & KEYMASK_6)
{ {
key[keys_held++] = KEY_6; key[keys_held++] = KEY_6;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_7) if (key_status.key2x & KEYMASK_7)
{ {
key[keys_held++] = KEY_7; key[keys_held++] = KEY_7;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_8) if (key_status.key2x & KEYMASK_8)
{ {
key[keys_held++] = KEY_8; key[keys_held++] = KEY_8;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_9) if (key_status.key2x & KEYMASK_9)
{ {
key[keys_held++] = KEY_9; key[keys_held++] = KEY_9;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_0) if (key_status.key2x & KEYMASK_0)
{ {
key[keys_held++] = KEY_0; key[keys_held++] = KEY_0;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_MINUS) if (key_status.key2x & KEYMASK_MINUS)
{ {
key[keys_held++] = KEY_MINUS; key[keys_held++] = KEY_MINUS;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_PLUS) if (key_status.key2x & KEYMASK_PLUS)
{ {
key[keys_held++] = KEY_PLUS; key[keys_held++] = KEY_PLUS;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_PRINTSCR) if (key_status.key2x & KEYMASK_PRINTSCR)
{ {
key[keys_held++] = KEY_PRINTSCR; key[keys_held++] = KEY_PRINTSCR;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_BRACE_OPEN) if (key_status.key2x & KEYMASK_BRACE_OPEN)
{ {
key[keys_held++] = KEY_BRACE_OPEN; key[keys_held++] = KEY_BRACE_OPEN;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_BRACE_CLOSE) if (key_status.key2x & KEYMASK_BRACE_CLOSE)
{ {
key[keys_held++] = KEY_BRACE_CLOSE; key[keys_held++] = KEY_BRACE_CLOSE;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_COLON) if (key_status.key2x & KEYMASK_COLON)
{ {
key[keys_held++] = KEY_COLON; key[keys_held++] = KEY_COLON;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key2x & KEYMASK_QUOTE) if (key_status.key2x & KEYMASK_QUOTE)
{ {
key[keys_held++] = KEY_QUOTE; key[keys_held++] = KEY_QUOTE;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_HASH) if (key_status.key3x & KEYMASK_HASH)
{ {
key[keys_held++] = KEY_HASH; key[keys_held++] = KEY_HASH;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_COMMA) if (key_status.key3x & KEYMASK_COMMA)
{ {
key[keys_held++] = KEY_COMMA; key[keys_held++] = KEY_COMMA;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_PERIOD) if (key_status.key3x & KEYMASK_PERIOD)
{ {
key[keys_held++] = KEY_PERIOD; key[keys_held++] = KEY_PERIOD;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_QUESTIONMARK) if (key_status.key3x & KEYMASK_QUESTIONMARK)
{ {
key[keys_held++] = KEY_QUESTIONMARK; key[keys_held++] = KEY_QUESTIONMARK;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_INTERNATIONAL1) if (key_status.key3x & KEYMASK_INTERNATIONAL1)
{ {
key[keys_held++] = KEY_INTERNATIONAL1; key[keys_held++] = KEY_INTERNATIONAL1;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_F1) if (key_status.key3x & KEYMASK_F1)
{ {
key[keys_held++] = KEY_F1; key[keys_held++] = KEY_F1;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_F2) if (key_status.key3x & KEYMASK_F2)
{ {
key[keys_held++] = KEY_F2; key[keys_held++] = KEY_F2;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_F3) if (key_status.key3x & KEYMASK_F3)
{ {
key[keys_held++] = KEY_F3; key[keys_held++] = KEY_F3;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_F4) if (key_status.key3x & KEYMASK_F4)
{ {
key[keys_held++] = KEY_F4; key[keys_held++] = KEY_F4;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_F5) if (key_status.key3x & KEYMASK_F5)
{ {
key[keys_held++] = KEY_F5; key[keys_held++] = KEY_F5;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_F6) if (key_status.key3x & KEYMASK_F6)
{ {
key[keys_held++] = KEY_F6; key[keys_held++] = KEY_F6;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_F7) if (key_status.key3x & KEYMASK_F7)
{ {
key[keys_held++] = KEY_F7; key[keys_held++] = KEY_F7;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_F8) if (key_status.key3x & KEYMASK_F8)
{ {
key[keys_held++] = KEY_F8; key[keys_held++] = KEY_F8;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_F9) if (key_status.key3x & KEYMASK_F9)
{ {
key[keys_held++] = KEY_F9; key[keys_held++] = KEY_F9;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_F10) if (key_status.key3x & KEYMASK_F10)
{ {
key[keys_held++] = KEY_F10; key[keys_held++] = KEY_F10;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key3x & KEYMASK_F11) if (key_status.key3x & KEYMASK_F11)
{ {
key[keys_held++] = KEY_F11; key[keys_held++] = KEY_F11;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_F12) if (key_status.key4x & KEYMASK_F12)
{ {
key[keys_held++] = KEY_F12; key[keys_held++] = KEY_F12;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_ESC) if (key_status.key4x & KEYMASK_ESC)
{ {
key[keys_held++] = KEY_ESC; key[keys_held++] = KEY_ESC;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_INSERT) if (key_status.key4x & KEYMASK_INSERT)
{ {
key[keys_held++] = KEY_INSERT; key[keys_held++] = KEY_INSERT;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_DELETE) if (key_status.key4x & KEYMASK_DELETE)
{ {
key[keys_held++] = KEY_DELETE; key[keys_held++] = KEY_DELETE;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_TILDE) if (key_status.key4x & KEYMASK_TILDE)
{ {
key[keys_held++] = KEY_TILDE; key[keys_held++] = KEY_TILDE;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_BACKSPACE) if (key_status.key4x & KEYMASK_BACKSPACE)
{ {
key[keys_held++] = KEY_BACKSPACE; key[keys_held++] = KEY_BACKSPACE;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_TAB) if (key_status.key4x & KEYMASK_TAB)
{ {
key[keys_held++] = KEY_TAB; key[keys_held++] = KEY_TAB;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_CAPSLOCK) if (key_status.key4x & KEYMASK_CAPSLOCK)
{ {
key[keys_held++] = KEY_CAPSLOCK; key[keys_held++] = KEY_CAPSLOCK;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_LEFTSHIFT) if (key_status.key4x & KEYMASK_LEFTSHIFT)
{ {
key[keys_held++] = KEY_LEFTSHIFT; key[keys_held++] = KEY_LEFTSHIFT;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_RIGHTSHIFT) if (key_status.key4x & KEYMASK_RIGHTSHIFT)
{ {
key[keys_held++] = KEY_RIGHTSHIFT; key[keys_held++] = KEY_RIGHTSHIFT;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_LEFTCONTROL) if (key_status.key4x & KEYMASK_LEFTCONTROL)
{ {
key[keys_held++] = KEY_LEFTCONTROL; key[keys_held++] = KEY_LEFTCONTROL;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_RIGHTALT) if (key_status.key4x & KEYMASK_RIGHTALT)
{ {
key[keys_held++] = KEY_RIGHTALT; key[keys_held++] = KEY_RIGHTALT;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_LEFTWINDOWS) if (key_status.key4x & KEYMASK_LEFTWINDOWS)
{ {
key[keys_held++] = KEY_LEFTWINDOWS; key[keys_held++] = KEY_LEFTWINDOWS;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_SPACE) if (key_status.key4x & KEYMASK_SPACE)
{ {
key[keys_held++] = KEY_SPACE; key[keys_held++] = KEY_SPACE;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_RIGHTWINDOWS) if (key_status.key4x & KEYMASK_RIGHTWINDOWS)
{ {
key[keys_held++] = KEY_RIGHTWINDOWS; key[keys_held++] = KEY_RIGHTWINDOWS;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key4x & KEYMASK_MENU) if (key_status.key4x & KEYMASK_MENU)
{ {
key[keys_held++] = KEY_MENU; key[keys_held++] = KEY_MENU;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key5x & KEYMASK_LEFTARROW) if (key_status.key5x & KEYMASK_LEFTARROW)
{ {
key[keys_held++] = KEY_LEFTARROW; key[keys_held++] = KEY_LEFTARROW;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key5x & KEYMASK_DOWNARROW) if (key_status.key5x & KEYMASK_DOWNARROW)
{ {
key[keys_held++] = KEY_DOWNARROW; key[keys_held++] = KEY_DOWNARROW;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key5x & KEYMASK_UPARROW) if (key_status.key5x & KEYMASK_UPARROW)
{ {
key[keys_held++] = KEY_UPARROW; key[keys_held++] = KEY_UPARROW;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key5x & KEYMASK_RIGHTARROW) if (key_status.key5x & KEYMASK_RIGHTARROW)
{ {
key[keys_held++] = KEY_RIGHTARROW; key[keys_held++] = KEY_RIGHTARROW;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)
return; return;
} }
if (KeyStatus.key5x & KEYMASK_ENTER) if (key_status.key5x & KEYMASK_ENTER)
{ {
key[keys_held++] = KEY_ENTER; key[keys_held++] = KEY_ENTER;
if (keys_held >= MAX_KEYS_HELD) if (keys_held >= MAX_KEYS_HELD)

52
Source/Core/Core/HW/SI/SI_DeviceKeyboard.h
View File

@ -11,6 +11,25 @@ struct KeyboardStatus;
class CSIDevice_Keyboard : public ISIDevice class CSIDevice_Keyboard : public ISIDevice
{ {
public:
// Constructor
CSIDevice_Keyboard(SIDevices device, int device_number);
// Run the SI Buffer
int RunBuffer(u8* buffer, int length) override;
// Return true on new data
bool GetData(u32& hi, u32& low) override;
KeyboardStatus GetKeyboardStatus() const;
void MapKeys(const KeyboardStatus& key_status, u8* key);
// Send a command directly
void SendCommand(u32 command, u8 poll) override;
// Savestate support
void DoState(PointerWrap& p) override;
protected: protected:
// Commands // Commands
enum EBufferCommands enum EBufferCommands
@ -28,40 +47,21 @@ protected:
union UCommand union UCommand
{ {
u32 Hex = 0; u32 hex = 0;
struct struct
{ {
u32 Parameter1 : 8; u32 parameter1 : 8;
u32 Parameter2 : 8; u32 parameter2 : 8;
u32 Command : 8; u32 command : 8;
u32 : 8; u32 : 8;
}; };
UCommand() = default; UCommand() = default;
UCommand(u32 value) : Hex{value} {} UCommand(u32 value) : hex{value} {}
}; };
// PADAnalogMode // PADAnalogMode
u8 m_Mode = 0; u8 m_mode = 0;
// Internal counter synchonizing GC and keyboard // Internal counter synchonizing GC and keyboard
u8 m_Counter = 0; u8 m_counter = 0;
public:
// Constructor
CSIDevice_Keyboard(SIDevices device, int _iDeviceNumber);
// Run the SI Buffer
int RunBuffer(u8* _pBuffer, int _iLength) override;
// Return true on new data
bool GetData(u32& _Hi, u32& _Low) override;
KeyboardStatus GetKeyboardStatus() const;
void MapKeys(const KeyboardStatus& KeyStatus, u8* key);
// Send a command directly
void SendCommand(u32 _Cmd, u8 _Poll) override;
// Savestate support
void DoState(PointerWrap& p) override;
}; };