mirror of
https://github.com/electronicarts/CnC_Remastered_Collection
synced 2024-04-24 23:42:17 +12:00
03416d24e1
Initial commit of original Tiberian Dawn and Red Alert source code converted to build as DLLs, and compatible with the release version of Command & Conquer Remastered.
759 lines
40 KiB
C++
759 lines
40 KiB
C++
//
|
|
// Copyright 2020 Electronic Arts Inc.
|
|
//
|
|
// TiberianDawn.DLL and RedAlert.dll and corresponding source code 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.
|
|
|
|
// TiberianDawn.DLL and RedAlert.dll and corresponding source code is distributed
|
|
// in the hope that it will be useful, but with permitted additional restrictions
|
|
// under Section 7 of the GPL. See the GNU General Public License in LICENSE.TXT
|
|
// distributed with this program. You should have received a copy of the
|
|
// GNU General Public License along with permitted additional restrictions
|
|
// with this program. If not, see https://github.com/electronicarts/CnC_Remastered_Collection
|
|
|
|
/* $Header: /CounterStrike/KEY.CPP 1 3/03/97 10:25a Joe_bostic $ */
|
|
/***********************************************************************************************
|
|
* *
|
|
* Project Name : Westwood Keyboard Library *
|
|
* *
|
|
* File Name : KEYBOARD.CPP *
|
|
* *
|
|
* Programmer : Philip W. Gorrow *
|
|
* *
|
|
* Start Date : 10/16/95 *
|
|
* *
|
|
* Last Update : November 2, 1996 [JLB] *
|
|
* *
|
|
*---------------------------------------------------------------------------------------------*
|
|
* Functions: *
|
|
* WWKeyboardClass::Buff_Get -- Lowlevel function to get a key from key buffer *
|
|
* WWKeyboardClass::Check -- Checks to see if a key is in the buffer *
|
|
* WWKeyboardClass::Clear -- Clears the keyboard buffer. *
|
|
* WWKeyboardClass::Down -- Checks to see if the specified key is being held down. *
|
|
* WWKeyboardClass::Fetch_Element -- Extract the next element in the keyboard buffer. *
|
|
* WWKeyboardClass::Fill_Buffer_From_Syste -- Extract and process any queued windows messages*
|
|
* WWKeyboardClass::Get -- Logic to get a metakey from the buffer *
|
|
* WWKeyboardClass::Get_Mouse_X -- Returns the mouses current x position in pixels *
|
|
* WWKeyboardClass::Get_Mouse_XY -- Returns the mouses x,y position via reference vars *
|
|
* WWKeyboardClass::Get_Mouse_Y -- returns the mouses current y position in pixels *
|
|
* WWKeyboardClass::Is_Buffer_Empty -- Checks to see if the keyboard buffer is empty. *
|
|
* WWKeyboardClass::Is_Buffer_Full -- Determines if the keyboard buffer is full. *
|
|
* WWKeyboardClass::Is_Mouse_Key -- Checks to see if specified key refers to the mouse. *
|
|
* WWKeyboardClass::Message_Handler -- Process a windows message as it relates to the keyboar*
|
|
* WWKeyboardClass::Peek_Element -- Fetches the next element in the keyboard buffer. *
|
|
* WWKeyboardClass::Put -- Logic to insert a key into the keybuffer] *
|
|
* WWKeyboardClass::Put_Element -- Put a keyboard data element into the buffer. *
|
|
* WWKeyboardClass::Put_Key_Message -- Translates and inserts wParam into Keyboard Buffer *
|
|
* WWKeyboardClass::To_ASCII -- Convert the key value into an ASCII representation. *
|
|
* WWKeyboardClass::Available_Buffer_Room -- Fetch the quantity of free elements in the keybo*
|
|
* WWKeyboardClass::Put_Mouse_Message -- Stores a mouse type message into the keyboard buffer*
|
|
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
|
|
|
|
#include "key.h"
|
|
|
|
#include "monoc.h"
|
|
|
|
//void Message_Loop(void);
|
|
|
|
//WWKeyboardClass * _Kbd = NULL;
|
|
|
|
|
|
#define ARRAY_SIZE(x) int(sizeof(x)/sizeof(x[0]))
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::WWKeyBoardClass -- Construction for Westwood Keyboard Class *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/16/1995 PWG : Created. *
|
|
*=============================================================================================*/
|
|
WWKeyboardClass::WWKeyboardClass(void) :
|
|
MouseQX(0),
|
|
MouseQY(0),
|
|
Head(0),
|
|
Tail(0)
|
|
{
|
|
// _Kbd = this;
|
|
|
|
memset(KeyState, '\0', sizeof(KeyState));
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* 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. *
|
|
*=============================================================================================*/
|
|
unsigned short WWKeyboardClass::Buff_Get(void)
|
|
{
|
|
while (!Check()) {} // wait for key in buffer
|
|
|
|
unsigned short temp = Fetch_Element();
|
|
if (Is_Mouse_Key(temp)) {
|
|
MouseQX = Fetch_Element();
|
|
MouseQY = Fetch_Element();
|
|
}
|
|
return(temp);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Is_Mouse_Key -- Checks to see if specified key refers to the mouse. *
|
|
* *
|
|
* This checks the specified key code to see if it refers to the mouse buttons. *
|
|
* *
|
|
* INPUT: key -- The key to check. *
|
|
* *
|
|
* OUTPUT: bool; Is the key a mouse button key? *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 09/30/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
bool WWKeyboardClass::Is_Mouse_Key(unsigned short 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. *
|
|
* 09/24/1996 JLB : Converted to new style keyboard system. *
|
|
*=============================================================================================*/
|
|
unsigned short WWKeyboardClass::Check(void) const
|
|
{
|
|
((WWKeyboardClass *)this)->Fill_Buffer_From_System();
|
|
if (Is_Buffer_Empty()) return(false);
|
|
return(Peek_Element());
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* 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. *
|
|
*=============================================================================================*/
|
|
unsigned short WWKeyboardClass::Get(void)
|
|
{
|
|
while (!Check()) {} // wait for key in buffer
|
|
return (Buff_Get());
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* 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(unsigned short key)
|
|
{
|
|
if (!Is_Buffer_Full()) {
|
|
Put_Element(key);
|
|
return(true);
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Put_Key_Message -- Translates and inserts wParam into Keyboard Buffer *
|
|
* *
|
|
* INPUT: *
|
|
* *
|
|
* OUTPUT: *
|
|
* *
|
|
* WARNINGS: *
|
|
* *
|
|
* HISTORY: *
|
|
* 10/16/1995 PWG : Created. *
|
|
*=============================================================================================*/
|
|
bool WWKeyboardClass::Put_Key_Message(unsigned short vk_key, bool release)
|
|
{
|
|
/*
|
|
** 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 (!Is_Mouse_Key(vk_key)) {
|
|
if (((GetKeyState(VK_SHIFT) & 0x8000) != 0) ||
|
|
((GetKeyState(VK_CAPITAL) & 0x0008) != 0) ||
|
|
((GetKeyState(VK_NUMLOCK) & 0x0008) != 0)) {
|
|
|
|
vk_key |= WWKEY_SHIFT_BIT;
|
|
}
|
|
if ((GetKeyState(VK_CONTROL) & 0x8000) != 0) {
|
|
vk_key |= WWKEY_CTRL_BIT;
|
|
}
|
|
if ((GetKeyState(VK_MENU) & 0x8000) != 0) {
|
|
vk_key |= WWKEY_ALT_BIT;
|
|
}
|
|
}
|
|
|
|
if (release) {
|
|
vk_key |= WWKEY_RLS_BIT;
|
|
}
|
|
|
|
/*
|
|
** Finally use the put command to enter the key into the keyboard
|
|
** system.
|
|
*/
|
|
return(Put(vk_key));
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Put_Mouse_Message -- Stores a mouse type message into the keyboard buffer. *
|
|
* *
|
|
* This routine will store the mouse type event into the keyboard buffer. It also checks *
|
|
* to ensure that there is enough room in the buffer so that partial mouse events won't *
|
|
* be recorded. *
|
|
* *
|
|
* INPUT: vk_key -- The mouse key message itself. *
|
|
* *
|
|
* x,y -- The mouse coordinates at the time of the event. *
|
|
* *
|
|
* release -- Is this a mouse button release? *
|
|
* *
|
|
* OUTPUT: bool; Was the event stored sucessfully into the keyboard buffer? *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 11/02/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
bool WWKeyboardClass::Put_Mouse_Message(unsigned short vk_key, int x, int y, bool release)
|
|
{
|
|
if (Available_Buffer_Room() >= 3 && Is_Mouse_Key(vk_key)) {
|
|
Put_Key_Message(vk_key, release);
|
|
Put((unsigned short)x);
|
|
Put((unsigned short)y);
|
|
return(true);
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::To_ASCII -- Convert the key value into an ASCII representation. *
|
|
* *
|
|
* This routine will convert the key code specified into an ASCII value. This takes into *
|
|
* consideration the language and keyboard mapping of the host Windows system. *
|
|
* *
|
|
* INPUT: key -- The key code to convert into ASCII. *
|
|
* *
|
|
* OUTPUT: Returns with the key converted into ASCII. If the key has no ASCII equivalent, *
|
|
* then '\0' is returned. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 09/30/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
char WWKeyboardClass::To_ASCII(unsigned short key)
|
|
{
|
|
/*
|
|
** Released keys never translate into an ASCII value.
|
|
*/
|
|
if (key & WWKEY_RLS_BIT) {
|
|
return('\0');
|
|
}
|
|
|
|
/*
|
|
** Set the KeyState buffer to reflect the shift bits stored in the key value.
|
|
*/
|
|
if (key & WWKEY_SHIFT_BIT) {
|
|
KeyState[VK_SHIFT] = 0x80;
|
|
}
|
|
if (key & WWKEY_CTRL_BIT) {
|
|
KeyState[VK_CONTROL] = 0x80;
|
|
}
|
|
if (key & WWKEY_ALT_BIT) {
|
|
KeyState[VK_MENU] = 0x80;
|
|
}
|
|
|
|
/*
|
|
** Ask windows to translate the key into an ASCII equivalent.
|
|
*/
|
|
char buffer[10];
|
|
int result = 1;
|
|
int scancode = 0;
|
|
|
|
scancode = MapVirtualKey(key & 0xFF, 0);
|
|
result = ToAscii((UINT)(key & 0xFF), (UINT)scancode, (PBYTE)KeyState, (LPWORD)buffer, (UINT)0);
|
|
|
|
/*
|
|
** Restore the KeyState buffer back to pristine condition.
|
|
*/
|
|
if (key & WWKEY_SHIFT_BIT) {
|
|
KeyState[VK_SHIFT] = 0;
|
|
}
|
|
if (key & WWKEY_CTRL_BIT) {
|
|
KeyState[VK_CONTROL] = 0;
|
|
}
|
|
if (key & WWKEY_ALT_BIT) {
|
|
KeyState[VK_MENU] = 0;
|
|
}
|
|
|
|
/*
|
|
** If Windows could not perform the translation as expected, then
|
|
** return with a null ASCII value.
|
|
*/
|
|
if (result != 1) {
|
|
return('\0');
|
|
}
|
|
|
|
return(buffer[0]);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Down -- Checks to see if the specified key is being held down. *
|
|
* *
|
|
* This routine will examine the key specified to see if it is currently being held down. *
|
|
* *
|
|
* INPUT: key -- The key to check. *
|
|
* *
|
|
* OUTPUT: bool; Is the specified key currently being held down? *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 09/30/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
bool WWKeyboardClass::Down(unsigned short key)
|
|
{
|
|
return(GetAsyncKeyState(key & 0xFF) == 0 ? false : true);
|
|
}
|
|
|
|
|
|
extern "C" {
|
|
void __cdecl Stop_Execution (void);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Fetch_Element -- Extract the next element in the keyboard buffer. *
|
|
* *
|
|
* This routine will extract the next pending element in the keyboard queue. If there is *
|
|
* no element available, then NULL is returned. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with the element extracted from the queue. An empty queue is signified *
|
|
* by a 0 return value. *
|
|
* *
|
|
* WARNINGS: *
|
|
* *
|
|
* HISTORY: *
|
|
* 09/30/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
unsigned short WWKeyboardClass::Fetch_Element(void)
|
|
{
|
|
unsigned short val = 0;
|
|
if (Head != Tail) {
|
|
val = Buffer[Head];
|
|
|
|
Head = (Head + 1) % ARRAY_SIZE(Buffer);
|
|
}
|
|
return(val);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Peek_Element -- Fetches the next element in the keyboard buffer. *
|
|
* *
|
|
* This routine will examine and return with the next element in the keyboard buffer but *
|
|
* it will not alter or remove that element. Use this routine to see what is pending in *
|
|
* the keyboard queue. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with the next element in the keyboard queue. If the keyboard buffer is *
|
|
* empty, then 0 is returned. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 09/30/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
unsigned short WWKeyboardClass::Peek_Element(void) const
|
|
{
|
|
if (!Is_Buffer_Empty()) {
|
|
return(Buffer[Head]);
|
|
}
|
|
return(0);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Put_Element -- Put a keyboard data element into the buffer. *
|
|
* *
|
|
* This will put one keyboard data element into the keyboard buffer. Typically, this data *
|
|
* is a key code, but it might be mouse coordinates. *
|
|
* *
|
|
* INPUT: val -- The data element to add to the keyboard buffer. *
|
|
* *
|
|
* OUTPUT: bool; Was the keyboard element added successfully? A failure would indicate that *
|
|
* the keyboard buffer is full. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 09/30/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
bool WWKeyboardClass::Put_Element(unsigned short val)
|
|
{
|
|
if (!Is_Buffer_Full()) {
|
|
int temp = (Tail+1) % ARRAY_SIZE(Buffer);
|
|
Buffer[Tail] = val;
|
|
Tail = temp;
|
|
return(true);
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Is_Buffer_Full -- Determines if the keyboard buffer is full. *
|
|
* *
|
|
* This routine will examine the keyboard buffer to determine if it is completely *
|
|
* full of queued keyboard events. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: bool; Is the keyboard buffer completely full? *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 09/30/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
bool WWKeyboardClass::Is_Buffer_Full(void) const
|
|
{
|
|
if ((Tail + 1) % ARRAY_SIZE(Buffer) == Head) {
|
|
return(true);
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Is_Buffer_Empty -- Checks to see if the keyboard buffer is empty. *
|
|
* *
|
|
* This routine will examine the keyboard buffer to see if it contains no events at all. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: bool; Is the keyboard buffer currently without any pending events queued? *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 09/30/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
bool WWKeyboardClass::Is_Buffer_Empty(void) const
|
|
{
|
|
if (Head == Tail) {
|
|
return(true);
|
|
}
|
|
return(false);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Fill_Buffer_From_Syste -- Extract and process any queued windows messages. *
|
|
* *
|
|
* This routine will extract and process any windows messages in the windows message *
|
|
* queue. It is presumed that the normal message handler will call the keyboard *
|
|
* message processing function. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 09/30/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
void WWKeyboardClass::Fill_Buffer_From_System(void)
|
|
{
|
|
if (!Is_Buffer_Full()) {
|
|
MSG msg;
|
|
while (PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
|
|
if (!GetMessage( &msg, NULL, 0, 0 )) {
|
|
return;
|
|
}
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Clear -- Clears the keyboard buffer. *
|
|
* *
|
|
* This routine will clear the keyboard buffer of all pending keyboard events. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: none *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 09/30/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
void WWKeyboardClass::Clear(void)
|
|
{
|
|
/*
|
|
** Extract any windows pending keyboard message events and then clear out the keyboard
|
|
** buffer.
|
|
*/
|
|
Fill_Buffer_From_System();
|
|
Head = Tail;
|
|
|
|
/*
|
|
** Perform a second clear to handle the rare case of the keyboard buffer being full and there
|
|
** still remains keyboard related events in the windows message queue.
|
|
*/
|
|
Fill_Buffer_From_System();
|
|
Head = Tail;
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Message_Handler -- Process a windows message as it relates to the keyboard *
|
|
* *
|
|
* This routine will examine the Windows message specified. If the message relates to an *
|
|
* event that the keyboard input system needs to process, then it will be processed *
|
|
* accordingly. *
|
|
* *
|
|
* INPUT: window -- Handle to the window receiving the message. *
|
|
* *
|
|
* message -- The message number of this event. *
|
|
* *
|
|
* wParam -- The windows specific word parameter (meaning depends on message). *
|
|
* *
|
|
* lParam -- The windows specific long word parameter (meaning is message dependant)*
|
|
* *
|
|
* OUTPUT: bool; Was this keyboard message recognized and processed? A 'false' return value *
|
|
* means that the message should be processed normally. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 09/30/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
bool WWKeyboardClass::Message_Handler(HWND window, UINT message, UINT wParam, LONG lParam)
|
|
{
|
|
// ST - 5/13/2019
|
|
#if (0)
|
|
bool processed = false;
|
|
|
|
/*
|
|
** Examine the message to see if it is one that should be processed. Only keyboard and
|
|
** pertinant mouse messages are processed.
|
|
*/
|
|
switch (message) {
|
|
|
|
/*
|
|
** System key has been pressed. This is the normal keyboard event message.
|
|
*/
|
|
case WM_SYSKEYDOWN:
|
|
case WM_KEYDOWN:
|
|
if (wParam == VK_SCROLL) {
|
|
Stop_Execution();
|
|
} else {
|
|
Put_Key_Message((unsigned short)wParam);
|
|
}
|
|
processed = true;
|
|
break;
|
|
|
|
/*
|
|
** The key has been released. This is the normal key release message.
|
|
*/
|
|
case WM_SYSKEYUP:
|
|
case WM_KEYUP:
|
|
Put_Key_Message((unsigned short)wParam, true);
|
|
processed = true;
|
|
break;
|
|
|
|
/*
|
|
** Press of the left mouse button.
|
|
*/
|
|
case WM_LBUTTONDOWN:
|
|
Put_Mouse_Message(VK_LBUTTON, LOWORD(lParam), HIWORD(lParam));
|
|
processed = true;
|
|
break;
|
|
|
|
/*
|
|
** Release of the left mouse button.
|
|
*/
|
|
case WM_LBUTTONUP:
|
|
Put_Mouse_Message(VK_LBUTTON, LOWORD(lParam), HIWORD(lParam), true);
|
|
processed = true;
|
|
break;
|
|
|
|
/*
|
|
** Double click of the left mouse button. Fake this into being
|
|
** just a rapid click of the left button twice.
|
|
*/
|
|
case WM_LBUTTONDBLCLK:
|
|
Put_Mouse_Message(VK_LBUTTON, LOWORD(lParam), HIWORD(lParam));
|
|
Put_Mouse_Message(VK_LBUTTON, LOWORD(lParam), HIWORD(lParam), true);
|
|
Put_Mouse_Message(VK_LBUTTON, LOWORD(lParam), HIWORD(lParam));
|
|
Put_Mouse_Message(VK_LBUTTON, LOWORD(lParam), HIWORD(lParam), true);
|
|
processed = true;
|
|
break;
|
|
|
|
/*
|
|
** Press of the middle mouse button.
|
|
*/
|
|
case WM_MBUTTONDOWN:
|
|
Put_Mouse_Message(VK_MBUTTON, LOWORD(lParam), HIWORD(lParam));
|
|
processed = true;
|
|
break;
|
|
|
|
/*
|
|
** Release of the middle mouse button.
|
|
*/
|
|
case WM_MBUTTONUP:
|
|
Put_Mouse_Message(VK_MBUTTON, LOWORD(lParam), HIWORD(lParam), true);
|
|
processed = true;
|
|
break;
|
|
|
|
/*
|
|
** Middle button double click gets translated into two
|
|
** regular middle button clicks.
|
|
*/
|
|
case WM_MBUTTONDBLCLK:
|
|
Put_Mouse_Message(VK_MBUTTON, LOWORD(lParam), HIWORD(lParam));
|
|
Put_Mouse_Message(VK_MBUTTON, LOWORD(lParam), HIWORD(lParam), true);
|
|
Put_Mouse_Message(VK_MBUTTON, LOWORD(lParam), HIWORD(lParam));
|
|
Put_Mouse_Message(VK_MBUTTON, LOWORD(lParam), HIWORD(lParam), true);
|
|
processed = true;
|
|
break;
|
|
|
|
/*
|
|
** Right mouse button press.
|
|
*/
|
|
case WM_RBUTTONDOWN:
|
|
Put_Mouse_Message(VK_RBUTTON, LOWORD(lParam), HIWORD(lParam));
|
|
processed = true;
|
|
break;
|
|
|
|
/*
|
|
** Right mouse button release.
|
|
*/
|
|
case WM_RBUTTONUP:
|
|
Put_Mouse_Message(VK_RBUTTON, LOWORD(lParam), HIWORD(lParam), true);
|
|
processed = true;
|
|
break;
|
|
|
|
/*
|
|
** Translate a double click of the right button
|
|
** into being just two regular right button clicks.
|
|
*/
|
|
case WM_RBUTTONDBLCLK:
|
|
Put_Mouse_Message(VK_RBUTTON, LOWORD(lParam), HIWORD(lParam));
|
|
Put_Mouse_Message(VK_RBUTTON, LOWORD(lParam), HIWORD(lParam), true);
|
|
Put_Mouse_Message(VK_RBUTTON, LOWORD(lParam), HIWORD(lParam));
|
|
Put_Mouse_Message(VK_RBUTTON, LOWORD(lParam), HIWORD(lParam), true);
|
|
processed = true;
|
|
break;
|
|
|
|
/*
|
|
** If the message is not pertinant to the keyboard system,
|
|
** then do nothing.
|
|
*/
|
|
default:
|
|
break;
|
|
}
|
|
|
|
/*
|
|
** If this message has been processed, then pass it on to the system
|
|
** directly.
|
|
*/
|
|
if (processed) {
|
|
DefWindowProc(window, message, wParam, lParam);
|
|
return(true);
|
|
}
|
|
#endif
|
|
return(false);
|
|
}
|
|
|
|
|
|
/***********************************************************************************************
|
|
* WWKeyboardClass::Available_Buffer_Room -- Fetch the quantity of free elements in the keyboa *
|
|
* *
|
|
* This examines the keyboard buffer queue and determine how many elements are available *
|
|
* for use before the buffer becomes full. Typical use of this would be when inserting *
|
|
* mouse events that require more than one element. Such an event must detect when there *
|
|
* would be insufficient room in the buffer and bail accordingly. *
|
|
* *
|
|
* INPUT: none *
|
|
* *
|
|
* OUTPUT: Returns with the number of elements that may be stored in to the keyboard buffer *
|
|
* before it becomes full and cannot accept any more elements. *
|
|
* *
|
|
* WARNINGS: none *
|
|
* *
|
|
* HISTORY: *
|
|
* 11/02/1996 JLB : Created. *
|
|
*=============================================================================================*/
|
|
int WWKeyboardClass::Available_Buffer_Room(void) const
|
|
{
|
|
int avail;
|
|
if (Head == Tail) {
|
|
avail = ARRAY_SIZE(Buffer);
|
|
}
|
|
if (Head < Tail) {
|
|
avail = Tail - Head;
|
|
}
|
|
if (Head > Tail) {
|
|
avail = (Tail + ARRAY_SIZE(Buffer)) - Head;
|
|
}
|
|
return(avail);
|
|
}
|