vkremap.cpp

wince.net板级支持包BSP for EP9315

//
// Copyright (c) Microsoft Corporation.  All rights reserved.
//
//
// Use of this source code is subject to the terms of the Microsoft end-user
// license agreement (EULA) under which you licensed this SOFTWARE PRODUCT.
// If you did not accept the terms of the EULA, you are not authorized to use
// this source code. For a copy of the EULA, please see the LICENSE.RTF on your
// install media.
//
/*++
THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF
ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A
PARTICULAR PURPOSE.

	@doc	EXTERNAL DRIVERS

	@module	vkremap.cpp |

This file implements the virtual key remapping part of the platform 
independent code of the keyboard driver.  This is provided as a sample to 
platform driver writers and is expected to be able to be used without 
major modification on most hardware platforms.  

*/

#include <windows.h>
#include <keybddr.h>


//	The real state of certain keys.
static BOOL		v_fLShiftDown = FALSE;
static BOOL		v_fRShiftDown = FALSE;
static BOOL		v_fLAltDown = FALSE;
static BOOL		v_fRAltDown = FALSE;
static BOOL		v_fLCtrlDown = FALSE;
static BOOL		v_fRCtrlDown = FALSE;


//	Use a pseudo Alt key since we fake that the Alt key goes up and down.
static BOOL		v_fLPseudoAltDown = FALSE;
static BOOL		v_fRPseudoAltDown = FALSE;
static BOOL		v_fLastKeyDownWasPseudoAlt = FALSE;


//	Keep track of the last vkey actually sent for keys which have multiple 
//	virtual keys.  
static UINT32	v_LShiftVKeySent = 0;
static UINT32	v_RShiftVKeySent = 0;
static UINT32	v_PeriodVKeySent = 0;
static UINT32	v_CommaVKeySent = 0;
static UINT32	v_BackVKeySent = 0;
static UINT32	v_RightVKeySent = 0;
static UINT32	v_LeftVKeySent = 0;
static UINT32	v_UpVKeySent = 0;
static UINT32	v_DownVKeySent = 0;


#define ANY_ALT_DOWN()		(v_fLAltDown || v_fRAltDown)
#define ANY_CTRL_DOWN()		(v_fLCtrlDown || v_fRCtrlDown)
#define ANY_SHIFT_DOWN()	(v_fLShiftDown || v_fRShiftDown)


/*++

KeybdDriverRemapVKeyDown:

On a key down, do any virtual key re-mapping on the keyboard.


Notes:

The basic pattern for each special key is to see if we are already sending 
a virtual key and auto-repeat it or check if its particular modifier is 
down and send the modified key or just send the unmodified key.  

For modified keys, we need to make it look like the modifier key went up 
and then the desired virtual key went down.  Additionally, when the 
modifier is the Alt key, we need to send a null character before the Alt 
up so that menus do not activate.  

--*/
int
KeybdDriverRemapVKeyDown(
	UINT32			VirtualKey,
	UINT32			VKeyBuf[16],
	KEY_STATE_FLAGS	KeyStateFlagsBuf[16]
	)
{
	int		i = 0;
	UINT32	vkUp = 0;
	UINT32	vkDown;
	BOOL	fSendNull = FALSE;
	UINT32	vkOnly = VirtualKey & 0xff;		//	Just the vkey
	UINT32	vkOther = VirtualKey & ~0xff;	//	Just the other stuff

	
	if ( vkOnly == VK_OFF )
		{
		vkDown = VK_OFF | KEYBD_DEVICE_SILENT_REPEAT;
		}
	else if ( vkOnly == VK_LSHIFT )
		{
		if ( v_LShiftVKeySent )							// Key is auto-repeating.
			{
			vkDown = v_LShiftVKeySent;					// Send out whatever we sent last time.
			}
		else if ( v_fRShiftDown )						// Modifier key is down.
			{
			vkUp = VK_RSHIFT;							// Make the right shift go up.
			vkDown = v_LShiftVKeySent = v_RShiftVKeySent = VK_CAPITAL |	// Send VK_CAPITAL instead of VK_LSHIFT.
												KEYBD_DEVICE_SILENT_REPEAT;
			}
		else
			{
			vkDown = v_LShiftVKeySent = VK_LSHIFT | KEYBD_DEVICE_SILENT_REPEAT;		// No modifier, send VK_LSHIFT.
			}
		v_fLShiftDown = TRUE;
		}
	else if ( vkOnly == VK_RSHIFT )					// etc.
		{
		if ( v_RShiftVKeySent )
			{
			vkDown = v_RShiftVKeySent;
			}
		else if ( v_fLShiftDown )
			{
			vkUp = VK_LSHIFT;
			vkDown = v_RShiftVKeySent = v_LShiftVKeySent = VK_CAPITAL |
										KEYBD_DEVICE_SILENT_REPEAT;
			}
		else
			{
			vkDown = v_RShiftVKeySent = VK_RSHIFT | KEYBD_DEVICE_SILENT_REPEAT;
			}
		v_fRShiftDown = TRUE;
		}
	else if ( vkOnly == VK_BACK )
		{
		if ( v_BackVKeySent )
			{
			vkDown = v_BackVKeySent;
			}
		else if ( v_fLShiftDown )
			{
			vkUp = VK_LSHIFT;
			vkDown = v_BackVKeySent = VK_DELETE;
			}
		else if ( v_fRShiftDown )
			{
			vkUp = VK_RSHIFT;
			vkDown = v_BackVKeySent = VK_DELETE;
			}
		else
			{
			vkDown = v_BackVKeySent = VK_BACK;
			}
		}
	else if ( vkOnly == VK_COMMA )
		{
		if ( v_CommaVKeySent )
			{
			vkDown = v_CommaVKeySent;
			}
		else if ( ANY_ALT_DOWN() && !ANY_CTRL_DOWN() && !ANY_SHIFT_DOWN() )
			{
			fSendNull = TRUE;
			vkUp = VK_MENU;
			vkDown = v_CommaVKeySent = KEYBD_DEVICE_CONTRAST_LESS;
			}
		else
			{
			vkDown = v_CommaVKeySent = VK_COMMA;
			}
		}
	else if ( vkOnly == VK_PERIOD )
		{
		if ( v_PeriodVKeySent )
			{
			vkDown = v_PeriodVKeySent;
			}
		else if ( ANY_ALT_DOWN() && !ANY_CTRL_DOWN() && !ANY_SHIFT_DOWN() )
			{
			fSendNull = TRUE;
			vkUp = VK_MENU;
			vkDown = v_PeriodVKeySent = KEYBD_DEVICE_CONTRAST_MORE;
			}
		else
			{
			vkDown = v_PeriodVKeySent = VK_PERIOD;
			}
		}
	else if ( vkOnly == VK_RIGHT )
		{
		if ( v_RightVKeySent )
			{
			vkDown = v_RightVKeySent;
			}
		else if ( ANY_ALT_DOWN() )
			{
			fSendNull = TRUE;
			vkUp = VK_MENU;
			vkDown = v_RightVKeySent = VK_END;
			}
		else
			{
			vkDown = v_RightVKeySent = VK_RIGHT;
			}
		}
	else if ( vkOnly == VK_LEFT )
		{
		if ( v_LeftVKeySent )
			{
			vkDown = v_LeftVKeySent;
			}
		else if ( ANY_ALT_DOWN() )
			{
			fSendNull = TRUE;
			vkUp = VK_MENU;
			vkDown = v_LeftVKeySent = VK_HOME;
			}
		else
			{
			vkDown = v_LeftVKeySent = VK_LEFT;
			}
		}
	else if ( vkOnly == VK_UP )
		{
		if ( v_UpVKeySent )
			{
			vkDown = v_UpVKeySent;
			}
		else if ( ANY_ALT_DOWN() )
			{
			fSendNull = TRUE;
			vkUp = VK_MENU;
			vkDown = v_UpVKeySent = VK_PRIOR;
			}
		else
			{
			vkDown = v_UpVKeySent = VK_UP;
			}
		}
	else if ( vkOnly == VK_DOWN )
		{
		if ( v_DownVKeySent )
			{
			vkDown = v_DownVKeySent;
			}
		else if ( ANY_ALT_DOWN() )
			{
			fSendNull = TRUE;
			vkUp = VK_MENU;
			vkDown = v_DownVKeySent = VK_NEXT;
			}
		else
			{
			vkDown = v_DownVKeySent = VK_DOWN;
			}
		}
	else if ( vkOnly == VK_LMENU )
		{
		vkDown = VK_LMENU | KEYBD_DEVICE_SILENT_REPEAT;
		v_fLAltDown = TRUE;
		v_fLPseudoAltDown = TRUE;
		}
	else if ( vkOnly == VK_RMENU )
		{
		vkDown = VK_RMENU | KEYBD_DEVICE_SILENT_REPEAT;
		v_fRAltDown = TRUE;
		v_fRPseudoAltDown = TRUE;
		}
	else if ( vkOnly == VK_LCONTROL )
		{
		vkDown = vkOnly | KEYBD_DEVICE_SILENT_REPEAT;
		v_fLCtrlDown = TRUE;
		}
	else if ( vkOnly == VK_RCONTROL )
		{
		vkDown = vkOnly | KEYBD_DEVICE_SILENT_REPEAT;
		v_fRCtrlDown = TRUE;
		}
	else if ( ( vkOnly == VK_LWIN ) ||
			  ( vkOnly == VK_RWIN ) )
		{
		vkDown = vkOnly | KEYBD_DEVICE_SILENT_REPEAT;
		}
	else
		{
		vkDown = vkOnly;
		}

//	May need to send null character to keep menus from activating.
	if ( fSendNull )
		{
		VKeyBuf[i] = KEYBD_DEVICE_SILENT | vkOther;		//	Virtual key == 0 down.
		KeyStateFlagsBuf[i++] = KeyStateDownFlag;

		VKeyBuf[i] = vkOther;							//	Virtual key == 0 up.
		KeyStateFlagsBuf[i++] = 0;
		}

//	Make it look like the modifier(s) went up.
	if ( vkUp )
		{
		if ( vkUp == VK_MENU )
			{
			if ( v_fLAltDown )
				{
				VKeyBuf[i] = VK_LMENU | vkOther;
				KeyStateFlagsBuf[i++] = 0;
				v_fLPseudoAltDown = FALSE;
				}
			if ( v_fRAltDown )
				{
				VKeyBuf[i] = VK_RMENU | vkOther;
				KeyStateFlagsBuf[i++] = 0;
				v_fRPseudoAltDown = FALSE;
				}
			}
		else
			{
			VKeyBuf[i] = vkUp | vkOther;
			KeyStateFlagsBuf[i++] = 0;
			}
		}

	v_fLastKeyDownWasPseudoAlt = FALSE;

//	Finally!  Send the key down.
	VKeyBuf[i] = vkDown | vkOther;
	KeyStateFlagsBuf[i++] = KeyStateDownFlag;

	return i;
}






/*++

KeybdDriverRemapKeyUp:

On a key up, undo all of the virtual key re-mapping on the keyboard.  


Notes:

When a special key is released, we send an up event for whatever virtual 
key was original sent as going down.  

If the special key's modifier key is still down, we send a down event for 
it to keep the state consistent.  (We earlier sent an up event for the modifier
when the special key went down.).

We remember if the modifier key we are resending the down for is the Alt 
key.  If it is, when it is really released, we send a null through the 
system to keep menus from activating.  Otherwise, menus would see this 
down followed directly by an Alt up and so would activate.  

--*/
int
KeybdDriverRemapVKeyUp(
	UINT32			VirtualKey,
	UINT32			VKeyBuf[16],
	KEY_STATE_FLAGS	KeyStateFlagsBuf[16]
	)
{
	int		i = 0;
	UINT32	vkUp;
	UINT32	vkDown = 0;
	BOOL	fSendUp = TRUE;
	BOOL	fSendNull = FALSE;
	UINT32	vkOnly = VirtualKey & 0xff;		// Just the vkey
	UINT32	vkOther = VirtualKey & ~0xff;	// Just the other stuff

//	The key up we send is usually this.
	vkUp = vkOnly;

	if ( vkOnly == VK_LSHIFT )
		{
		vkUp = v_LShiftVKeySent;			// Whatever we sent out is what goes up.
		v_LShiftVKeySent = 0;
		v_fLShiftDown = FALSE;
		if ( v_fRShiftDown )				// Modifier key is still down.
			{
			vkDown = v_RShiftVKeySent = VK_RSHIFT;
			}
		}
	else if ( vkOnly == VK_RSHIFT )			// etc.
		{
		vkUp = v_RShiftVKeySent;			// Whatever we sent out is what goes up.
		v_RShiftVKeySent = 0;
		v_fRShiftDown = FALSE;
		if ( v_fLShiftDown )
			{
			vkDown = v_LShiftVKeySent = VK_LSHIFT;
			}
		}
	else if ( vkOnly == VK_BACK )
		{
		vkUp = v_BackVKeySent;
		v_BackVKeySent = 0;
		if ( v_fLShiftDown )
			{
			vkDown = VK_LSHIFT;
			}
		else if ( v_fRShiftDown )
			{
			vkDown = VK_RSHIFT;
			}
		}
	else if ( vkOnly == VK_COMMA )
		{
		vkUp = v_CommaVKeySent;
		v_CommaVKeySent = 0;
		if ( ANY_ALT_DOWN() )
			{
			vkDown = VK_MENU;
			}
		}
	else if ( vkOnly == VK_PERIOD )
		{
		vkUp = v_PeriodVKeySent;
		v_PeriodVKeySent = 0;
		if ( ANY_ALT_DOWN() )
			{
			vkDown = VK_MENU;
			}
		}
	else if ( vkOnly == VK_RIGHT )
		{
		vkUp = v_RightVKeySent;
		v_RightVKeySent = 0;
		if ( ANY_ALT_DOWN() )
			{
			vkDown = VK_MENU;
			}
		}
	else if ( vkOnly == VK_LEFT )
		{
		vkUp = v_LeftVKeySent;
		v_LeftVKeySent = 0;
		if ( ANY_ALT_DOWN() )
			{
			vkDown = VK_MENU;
			}
		}
	else if ( vkOnly == VK_UP )
		{
		vkUp = v_UpVKeySent;
		v_UpVKeySent = 0;
		if ( ANY_ALT_DOWN() )
			{
			vkDown = VK_MENU;
			}
		}
	else if ( vkOnly == VK_DOWN )
		{
		vkUp = v_DownVKeySent;
		v_DownVKeySent = 0;
		if ( ANY_ALT_DOWN() )
			{
			vkDown = VK_MENU;
			}
		}
	else if ( vkOnly == VK_LMENU )
		{
		v_fLAltDown = FALSE;
//	If we already sent out that the Alt key went up, don't send it again.
		if ( v_fLPseudoAltDown )
			{
			v_fLPseudoAltDown = FALSE;
			}
		else
			{
			fSendUp = FALSE;
			}
		}
	else if ( vkOnly == VK_RMENU )
		{
		v_fRAltDown = FALSE;
//	If we already sent out that the Alt key went up, don't send it again.
		if ( v_fRPseudoAltDown )
			{
			v_fRPseudoAltDown = FALSE;
			}
		else
			{
			fSendUp = FALSE;
			}
		}
	else if ( vkOnly == VK_LCONTROL )
		{
		v_fLCtrlDown = FALSE;
		}
	else if ( vkOnly == VK_RCONTROL )
		{
		v_fRCtrlDown = FALSE;
		}

	if ( fSendUp )
		{
/*	If we are about to release the alt key and the last key down we sent 
was pseudo-alt, send a null character through to keep menus from 
activating.  */ 
		if ( v_fLastKeyDownWasPseudoAlt &&
			 ( ( vkUp == VK_LMENU ) || ( vkUp == VK_RMENU ) ) )
			{
			VKeyBuf[i] = KEYBD_DEVICE_SILENT | vkOther;		//	Virtual key == 0 down.
			KeyStateFlagsBuf[i++] = KeyStateDownFlag;

			VKeyBuf[i] = vkOther;							//	Virtual key == 0 up.
			KeyStateFlagsBuf[i++] = 0;

			}
//	Send the virtual key up.
		VKeyBuf[i] = vkUp|vkOther;
		KeyStateFlagsBuf[i++] = 0;
		}

//	Make it look like the modifier(s) went down.
	if ( vkDown )
		{
		if ( vkDown == VK_MENU )
			{
			if ( v_fLAltDown )
				{
				VKeyBuf[i] = VK_LMENU | vkOther | KEYBD_DEVICE_SILENT;
				KeyStateFlagsBuf[i++] = KeyStateDownFlag;
				v_fLPseudoAltDown = TRUE;
				}
			if ( v_fRAltDown )
				{
				VKeyBuf[i] = VK_RMENU | vkOther | KEYBD_DEVICE_SILENT;
				KeyStateFlagsBuf[i++] = KeyStateDownFlag;
				v_fRPseudoAltDown = TRUE;
				}
			v_fLastKeyDownWasPseudoAlt = TRUE;
			}
		else
			{
			VKeyBuf[i] = vkDown | vkOther | KEYBD_DEVICE_SILENT;
			KeyStateFlagsBuf[i++] = KeyStateDownFlag;
			v_fLastKeyDownWasPseudoAlt = FALSE;
			}
		}

	return i;
}