534 lines
19 KiB
C++
534 lines
19 KiB
C++
/*
|
|
** Command & Conquer Red Alert(tm)
|
|
** Copyright 2025 Electronic Arts Inc.
|
|
**
|
|
** This program is free software: you can redistribute it and/or modify
|
|
** it under the terms of the GNU General Public License as published by
|
|
** the Free Software Foundation, either version 3 of the License, or
|
|
** (at your option) any later version.
|
|
**
|
|
** This program is distributed in the hope that it will be useful,
|
|
** but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
** GNU General Public License for more details.
|
|
**
|
|
** You should have received a copy of the GNU General Public License
|
|
** along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
/***********************************************************************************************
|
|
* *
|
|
* Project Name : Westwood Keyboard Library *
|
|
* *
|
|
* File Name : KEYBOARD.CPP *
|
|
* *
|
|
* Programmer : Philip W. Gorrow *
|
|
* *
|
|
* Start Date : 10/16/95 *
|
|
* *
|
|
* Last Update : October 26, 1995 [] *
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* WWKeyboardClass::Put -- Logic to insert a key into the keybuffer] *
|
|
* WWKeyboardClass::Get -- Logic to get a metakey from the buffer *
|
|
* WWKeyboardClass::Check -- Checks to see if a key is in the buffer *
|
|
* WWKeyboardClass::Put_Key_Message -- Translates and inserts wParam into Keyboard Buffer *
|
|
* WWKeyboardClass::Buff_Get -- Lowlevel function to get a key from key buffer *
|
|
* WWKeyboardClass::Get_Mouse_X -- Returns the mouses current x position in pixels *
|
|
* WWKeyboardClass::Get_Mouse_Y -- returns the mouses current y position in pixels *
|
|
* WWKeyboardClass::Get_Mouse_XY -- Returns the mouses x,y position via reference vars *
|
|
* Check_Key -- compatability routine for old 32 bit library *
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#include "keyboard.h"
|
|
#include "timer.h"
|
|
#include "mono.h"
|
|
|
|
void Message_Loop(void);
|
|
|
|
WWKeyboardClass *_Kbd;
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::WWKeyBoardClass -- Construction for Westwood Keyboard Class *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/16/1995 PWG : Created. *
|
|
*=============================================================================================*/
|
|
WWKeyboardClass::WWKeyboardClass(void)
|
|
{
|
|
_Kbd = this;
|
|
//
|
|
// Initialize the keyboard remap table for our system (note it would be bad if someone
|
|
// switched keyboard modes after this happened.
|
|
//
|
|
memset(VKRemap, 0, 256);
|
|
memset(AsciiRemap, 0, 2048);
|
|
for (short lp = 31; lp < 255; lp ++) {
|
|
if (isprint(lp)) {
|
|
int vk_key = VkKeyScan((unsigned char)lp);
|
|
if (vk_key > 0 && vk_key < 2048) {
|
|
AsciiRemap[vk_key] = (unsigned char)lp;
|
|
VKRemap[lp] = (unsigned char)(vk_key & 0xFF);
|
|
}
|
|
}
|
|
}
|
|
|
|
//
|
|
// Build a remap table of the different keys which are affected by the caps lock and
|
|
// the num lock.
|
|
//
|
|
memset(ToggleKeys, 0, 256);
|
|
for (lp = 0; lp < 255; lp++ ) {
|
|
if (isalpha(lp) && isupper(lp)) {
|
|
ToggleKeys[lp] = 1;
|
|
}
|
|
if (lp >= VK_NUMPAD0 && lp <= VK_DIVIDE) {
|
|
ToggleKeys[lp] = 2;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Our buffer should start devoid of keys.
|
|
//
|
|
memset(Buffer, 0, 256);
|
|
Head = 0;
|
|
Tail = 0;
|
|
|
|
//
|
|
// There should be no starting queued mouse events for us to have to worry
|
|
// about.
|
|
//
|
|
MouseQX = 0;
|
|
MouseQY = 0;
|
|
MState = 0;
|
|
Conditional = 0;
|
|
CurrentCursor = NULL;
|
|
}
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Buff_Get -- Lowlevel function to get a key from key buffer *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: int - the key value that was pulled from buffer (includes bits) * *
|
|
* *
|
|
* WARNINGS: If the key was a mouse event MouseQX and MouseQY will be updated *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/17/1995 PWG : Created. *
|
|
*=============================================================================================*/
|
|
int WWKeyboardClass::Buff_Get(void)
|
|
{
|
|
while (!Check()) {} // wait for key in buffer
|
|
int temp = Buffer[Head]; // get key out of the buffer
|
|
int newhead = Head; // save off head for manipulation
|
|
if (Is_Mouse_Key(temp)) { // if key is a mouse then
|
|
MouseQX = Buffer[(Head + 1) & 255]; // get the x and y pos
|
|
MouseQY = Buffer[(Head + 2) & 255]; // from the buffer
|
|
newhead += 3; // adjust head forward
|
|
} else {
|
|
newhead += 1; // adjust head forward
|
|
}
|
|
newhead &= 255;
|
|
Head = newhead;
|
|
return(temp);
|
|
}
|
|
|
|
BOOL WWKeyboardClass::Is_Mouse_Key(int key)
|
|
{
|
|
key &= 0xFF;
|
|
return (key == VK_LBUTTON || key == VK_MBUTTON || key == VK_RBUTTON);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Check -- Checks to see if a key is in the buffer *
|
|
* *
|
|
* INPUT: *
|
|
* *
|
|
* OUTPUT: *
|
|
* *
|
|
* WARNINGS: *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/16/1995 PWG : Created. *
|
|
*=============================================================================================*/
|
|
BOOL WWKeyboardClass::Check(void)
|
|
{
|
|
Message_Loop();
|
|
unsigned short temp; // store temp holding spot for key
|
|
if (Head == Tail) return(FALSE); // if no keys in buff then get out
|
|
temp = Buffer[Head]; // get key out of the buffer
|
|
return(temp); // send it back to main program
|
|
}
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Get -- Logic to get a metakey from the buffer *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: int - the meta key taken from the buffer. *
|
|
* *
|
|
* WARNINGS: This routine will not return until a keypress is received *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/16/1995 PWG : Created. *
|
|
*=============================================================================================*/
|
|
int WWKeyboardClass::Get(void)
|
|
{
|
|
int temp,bits; // store temp holding spot for key
|
|
|
|
while (!Check()) {} // wait for key in buffer
|
|
temp = Buff_Get(); // get key from the buffer
|
|
|
|
bits = temp & 0xFF00; // save of keyboard bits
|
|
|
|
if (!(bits & WWKEY_VK_BIT)) { // if its not a virtual key
|
|
temp = AsciiRemap[temp&0x1FF] | bits; // convert to ascii equivalent
|
|
}
|
|
return(temp); // return the key that we pulled out
|
|
}
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Put -- Logic to insert a key into the keybuffer] *
|
|
* *
|
|
* INPUT: int - the key to insert into the buffer *
|
|
* *
|
|
* OUTPUT: bool - true if key is sucessfuly inserted. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/16/1995 PWG : Created. *
|
|
*=============================================================================================*/
|
|
BOOL WWKeyboardClass::Put(int key)
|
|
{
|
|
int temp = (Tail + 1) & 255;
|
|
if (temp != Head)
|
|
{
|
|
Buffer[Tail] = (short)key;
|
|
|
|
//
|
|
// Critical Line
|
|
//
|
|
Tail = temp;
|
|
return(TRUE);
|
|
}
|
|
return(FALSE);
|
|
}
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Put_Key_Message -- Translates and inserts wParam into Keyboard Buffer *
|
|
* *
|
|
* INPUT: *
|
|
* *
|
|
* OUTPUT: *
|
|
* *
|
|
* WARNINGS: *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/16/1995 PWG : Created. *
|
|
*=============================================================================================*/
|
|
WWKeyboardClass::Put_Key_Message(UINT vk_key, BOOL release, BOOL dbl)
|
|
{
|
|
int bits = 0;
|
|
//
|
|
// Get the status of all of the different keyboard modifiers. Note, only pay attention
|
|
// to numlock and caps lock if we are dealing with a key that is affected by them. Note
|
|
// that we do not want to set the shift, ctrl and alt bits for Mouse keypresses as this
|
|
// would be incompatible with the dos version.
|
|
//
|
|
if (vk_key != VK_LBUTTON && vk_key != VK_MBUTTON && vk_key != VK_RBUTTON) {
|
|
int shift = (GetKeyState(VK_SHIFT) & 0xFF00) != 0;
|
|
int ctrl = (GetKeyState(VK_CONTROL) & 0xFF00) != 0;
|
|
int alt = (GetKeyState(VK_MENU) & 0xFF00) != 0;
|
|
int caps = ((GetKeyState(VK_CAPITAL) & 0x00FF) != 0) && (ToggleKeys[vk_key] == 1);
|
|
int nums = ((GetKeyState(VK_NUMLOCK) & 0x00FF) != 0) && (ToggleKeys[vk_key] == 2);
|
|
|
|
//
|
|
// Set the proper bits for whatever the key we got is.
|
|
//
|
|
if (shift || caps || nums) {
|
|
bits |= WWKEY_SHIFT_BIT;
|
|
}
|
|
if (ctrl) {
|
|
bits |= WWKEY_CTRL_BIT;
|
|
}
|
|
if (alt) {
|
|
bits |= WWKEY_ALT_BIT;
|
|
}
|
|
}
|
|
if (!AsciiRemap[vk_key|bits]) {
|
|
bits |= WWKEY_VK_BIT;
|
|
}
|
|
if (release) {
|
|
bits |= WWKEY_RLS_BIT;
|
|
}
|
|
if (dbl) {
|
|
bits |= WWKEY_DBL_BIT;
|
|
}
|
|
//
|
|
// Finally use the put command to enter the key into the keyboard
|
|
// system.
|
|
//
|
|
return(Put(vk_key|bits));
|
|
}
|
|
|
|
void WWKeyboardClass::Clear(void)
|
|
{
|
|
Head = Tail;
|
|
}
|
|
|
|
int WWKeyboardClass::To_ASCII(int key)
|
|
{
|
|
if ( key && WWKEY_RLS_BIT)
|
|
return(KN_NONE);
|
|
return(key);
|
|
}
|
|
|
|
WWKeyboardClass::Down(int key)
|
|
{
|
|
return(GetAsyncKeyState(key&0xFF));
|
|
}
|
|
|
|
VOID WWKeyboardClass::Split(int &key, int &shift, int &ctrl, int &alt, int &rls, int &dbl)
|
|
{
|
|
shift = (key & WWKEY_SHIFT_BIT) != 0;
|
|
ctrl = (key & WWKEY_CTRL_BIT) != 0;
|
|
alt = (key & WWKEY_ALT_BIT) != 0;
|
|
rls = (key & WWKEY_RLS_BIT) != 0;
|
|
dbl = (key & WWKEY_DBL_BIT) != 0;
|
|
key = (key & 0xFF);
|
|
|
|
}
|
|
|
|
|
|
extern "C" {
|
|
void __cdecl Stop_Execution (void);
|
|
}
|
|
|
|
#pragma off(unreferenced)
|
|
void WWKeyboardClass::Message_Handler(HWND , UINT message, UINT wParam, LONG lParam)
|
|
{
|
|
switch (message) {
|
|
case WM_SYSKEYDOWN:
|
|
case WM_KEYDOWN:
|
|
if ( wParam==VK_SCROLL ){
|
|
Stop_Execution();
|
|
} else {
|
|
Put_Key_Message(wParam);
|
|
}
|
|
break;
|
|
|
|
case WM_SYSKEYUP:
|
|
case WM_KEYUP:
|
|
Put_Key_Message(wParam, TRUE);
|
|
break;
|
|
|
|
case WM_LBUTTONDOWN:
|
|
Put_Key_Message(VK_LBUTTON);
|
|
Put(LOWORD(lParam));
|
|
Put(HIWORD(lParam));
|
|
break;
|
|
|
|
case WM_LBUTTONUP:
|
|
Put_Key_Message(VK_LBUTTON, TRUE);
|
|
Put(LOWORD(lParam));
|
|
Put(HIWORD(lParam));
|
|
break;
|
|
|
|
case WM_LBUTTONDBLCLK:
|
|
Put_Key_Message(VK_LBUTTON, TRUE, TRUE);
|
|
Put(LOWORD(lParam));
|
|
Put(HIWORD(lParam));
|
|
break;
|
|
|
|
case WM_MBUTTONDOWN:
|
|
Put_Key_Message(VK_MBUTTON);
|
|
Put(LOWORD(lParam));
|
|
Put(HIWORD(lParam));
|
|
break;
|
|
|
|
case WM_MBUTTONUP:
|
|
Put_Key_Message(VK_MBUTTON, TRUE);
|
|
Put(LOWORD(lParam));
|
|
Put(HIWORD(lParam));
|
|
break;
|
|
|
|
case WM_MBUTTONDBLCLK:
|
|
Put_Key_Message(VK_MBUTTON, TRUE, TRUE);
|
|
Put(LOWORD(lParam));
|
|
Put(HIWORD(lParam));
|
|
break;
|
|
|
|
case WM_RBUTTONDOWN:
|
|
Put_Key_Message(VK_RBUTTON);
|
|
Put(LOWORD(lParam));
|
|
Put(HIWORD(lParam));
|
|
break;
|
|
|
|
case WM_RBUTTONUP:
|
|
Put_Key_Message(VK_RBUTTON, TRUE);
|
|
Put(LOWORD(lParam));
|
|
Put(HIWORD(lParam));
|
|
break;
|
|
|
|
case WM_RBUTTONDBLCLK:
|
|
Put_Key_Message(VK_RBUTTON, TRUE, TRUE);
|
|
Put(LOWORD(lParam));
|
|
Put(HIWORD(lParam));
|
|
break;
|
|
case WM_MOUSEMOVE:
|
|
if (CurrentCursor)
|
|
SetCursor(CurrentCursor);
|
|
break;
|
|
}
|
|
}
|
|
#pragma on(unreferenced)
|
|
|
|
|
|
|
|
|
|
void Message_Loop(void)
|
|
{
|
|
|
|
MSG msg;
|
|
|
|
while (PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE )) {
|
|
if( !GetMessage( &msg, NULL, 0, 0 ) ){
|
|
return;
|
|
}
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
/***************************************************************************
|
|
* CHECK_KEY -- compatability routine for old 32 bit library *
|
|
* *
|
|
* This routine checks to see if there is a key in the keyboard buffer *
|
|
* and returns it to the sender if there is. It does not remove the key *
|
|
* from the buffer. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: The key that was pressed. *
|
|
* *
|
|
* WARNINGS: You must declare a WWKeyboardClass object before calling *
|
|
* this routine. *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/26/1995 : Created. *
|
|
*=========================================================================*/
|
|
int Check_Key(void)
|
|
{
|
|
if (!_Kbd) return(KA_NONE);
|
|
return(_Kbd->Check() & ~WWKEY_SHIFT_BIT);
|
|
}
|
|
|
|
void Clear_KeyBuffer(void)
|
|
{
|
|
if (!_Kbd) return;
|
|
_Kbd->Clear();
|
|
}
|
|
|
|
int Check_Key_Num(void)
|
|
{
|
|
if (!_Kbd) return(KN_NONE);
|
|
int key = _Kbd->Check();
|
|
int flags = key & 0xFF00;
|
|
key = key & 0x00FF;
|
|
|
|
if (isupper(key)) {
|
|
key = tolower(key);
|
|
if ( !flags & WWKEY_VK_BIT ) {
|
|
flags |= WWKEY_SHIFT_BIT;
|
|
}
|
|
}
|
|
|
|
return(key | flags);
|
|
}
|
|
|
|
int Get_Key_Num(void)
|
|
{
|
|
if (!_Kbd) return(KN_NONE);
|
|
int key = _Kbd->Get();
|
|
int flags = key & 0xFF00;
|
|
key = key & 0x00FF;
|
|
|
|
if (isupper(key)) {
|
|
key = tolower(key);
|
|
if ( !flags & WWKEY_VK_BIT ) {
|
|
flags |= WWKEY_SHIFT_BIT;
|
|
}
|
|
}
|
|
return(key | flags);
|
|
}
|
|
|
|
int KN_To_KA(int key)
|
|
{
|
|
if ( key & WWKEY_RLS_BIT) {
|
|
return(KA_NONE);
|
|
}
|
|
if (!(key & WWKEY_VK_BIT)) {
|
|
int flags = key & 0xFF00;
|
|
key = key & 0x00FF;
|
|
if (flags & WWKEY_SHIFT_BIT) {
|
|
key = toupper(key);
|
|
flags &= ~WWKEY_SHIFT_BIT;
|
|
}
|
|
}else{
|
|
/*
|
|
** If its a numeric keypad key then fix it up
|
|
*/
|
|
if ((key & 0xff) >=VK_NUMPAD0 && (key & 0xff) <=VK_NUMPAD9){
|
|
key = (key & 0xff) - VK_NUMPAD0 + KA_0;
|
|
}
|
|
}
|
|
return(key);
|
|
}
|
|
|
|
int KN_To_VK(int key)
|
|
{
|
|
if (!_Kbd) return(KN_NONE);
|
|
if ( key & WWKEY_RLS_BIT) {
|
|
return(VK_NONE);
|
|
}
|
|
|
|
int flags = key & 0xFF00;
|
|
if (!(flags & WWKEY_VK_BIT)) {
|
|
key = _Kbd->VKRemap[key & 0x00FF] | flags;
|
|
}
|
|
key &= ~WWKEY_VK_BIT;
|
|
return(key);
|
|
}
|
|
|
|
int Key_Down(int key)
|
|
{
|
|
if (!_Kbd) return(FALSE);
|
|
return(_Kbd->Down(key));
|
|
}
|
|
|
|
int Get_Key(void)
|
|
{
|
|
int retval;
|
|
|
|
if (!_Kbd) return(KN_NONE);
|
|
retval = _Kbd->Get() & ~WWKEY_SHIFT_BIT;
|
|
if (retval & WWKEY_RLS_BIT) {
|
|
retval = KN_NONE;
|
|
}
|
|
return(retval);
|
|
}
|
|
|