vkchengus1.cpp

三星2410的BSP开发包

/* F1 */				0,
/* F2 */				0,
/* F3 */				0,
/* F4 */				0,
/* F5 */				0,
/* F6 */				0,
/* F7 */				0,
/* F8 */				0,
/* F9 */				0,
/* FA */				0,
/* FB */				0,
/* FC */				0,
/* FD */				0,
/* FE */				0,
/* FF */				0


};





static
const
UINT16
Column_ShiftCapsLock[COUNT_VKEYS] =
	{
/* 00 */				0,
/* 01 VK_LBUTTON	*/	0,
/* 02 VK_RBUTTON	*/	0,
/* 03 VK_CANCEL		*/	0,
/* 04 VK_MBUTTON	*/	0,
/* 05 */				0,
/* 06 */				0,
/* 07 */				0,
/* 08 VK_BACK		*/	0x08,
/* 09 VK_TAB		*/	0x09,
/* 0A */				0,
/* 0B */				0,
/* 0C VK_CLEAR		*/	0,
/* 0D VK_RETURN		*/	0x0d,
/* 0E */				0,
/* 0F */				0,


/* 10 VK_SHIFT		*/	0,
/* 11 VK_CONTROL	*/	0,
/* 12 VK_MENU		*/	0,
/* 13 VK_PAUSE		*/	0,
/* 14 VK_CAPITAL	*/	0,
/* 15 */				0,
/* 16 */				0,
/* 17 */				0,
/* 18 */				0,
/* 19 */				0,
/* 1A */				0,
/* 1B VK_ESCAPE		*/	0x1b,
/* 1C */				0,
/* 1D */				0,
/* 1E */				0,
/* 1F */				0,


/* 20 VK_SPACE		*/	TEXT(' '),
/* 21 VK_PRIOR		*/	0,
/* 22 VK_NEXT		*/	0,
/* 23 VK_END		*/	0,
/* 24 VK_HOME		*/	0,
/* 25 VK_LEFT		*/	0,
/* 26 VK_UP			*/	0,
/* 27 VK_RIGHT		*/	0,
/* 28 VK_DOWN		*/	0,
/* 29 VK_SELECT		*/	0,
/* 2A VK_PRINT		*/	0,
/* 2B VK_EXECUTE	*/	0,
/* 2C VK_SNAPSHOT	*/	0,
/* 2D VK_INSERT		*/	0,
/* 2E VK_DELETE		*/	0,
/* 2F VK_HELP		*/	0,




/* 30 VK_0 */			TEXT(')'),
/* 31 VK_1 */			TEXT('!'),
/* 32 VK_2 */			TEXT('@'),
/* 33 VK_3 */			TEXT('#'),
/* 34 VK_4 */			TEXT('$'),
/* 35 VK_5 */			TEXT('%'),
/* 36 VK_6 */			TEXT('^'),
/* 37 VK_7 */			TEXT('&'),
/* 38 VK_8 */			TEXT('*'),
/* 39 VK_9 */			TEXT('('),
/* 3A */				0,
/* 3B */				0,
/* 3C */				0,
/* 3D */				0,
/* 3E */				0,
/* 3F */				0,


/* 40 */				0,
/* 41 */				TEXT('a'),
/* 42 */				TEXT('b'),
/* 43 */				TEXT('c'),
/* 44 */				TEXT('d'),
/* 45 */				TEXT('e'),
/* 46 */				TEXT('f'),
/* 47 */				TEXT('g'),
/* 48 */				TEXT('h'),
/* 49 */				TEXT('i'),
/* 4A */				TEXT('j'),
/* 4B */				TEXT('k'),
/* 4C */				TEXT('l'),
/* 4D */				TEXT('m'),
/* 4E */				TEXT('n'),
/* 4F */				TEXT('o'),


/* 50 */				TEXT('p'),
/* 51 */				TEXT('q'),
/* 52 */				TEXT('r'),
/* 53 */				TEXT('s'),
/* 54 */				TEXT('t'),
/* 55 */				TEXT('u'),
/* 56 */				TEXT('v'),
/* 57 */				TEXT('w'),
/* 58 */				TEXT('x'),
/* 59 */				TEXT('y'),
/* 5A */				TEXT('z'),
/* 5B VK_LWIN		*/	0,
/* 5C VK_RWIN		*/	0,
/* 5D VK_APPS		*/	0,
/* 5E */				0,
/* 5F */				0,


/* 60 VK_NUMPAD0	*/	TEXT('0'),
/* 61 VK_NUMPAD1	*/	TEXT('1'),
/* 62 VK_NUMPAD2	*/	TEXT('2'),
/* 63 VK_NUMPAD3	*/	TEXT('3'),
/* 64 VK_NUMPAD4	*/	TEXT('4'),
/* 65 VK_NUMPAD5	*/	TEXT('5'),
/* 66 VK_NUMPAD6	*/	TEXT('6'),
/* 67 VK_NUMPAD7	*/	TEXT('7'),
/* 68 VK_NUMPAD8	*/	TEXT('8'),
/* 69 VK_NUMPAD9	*/	TEXT('9'),
/* 6A VK_MULTIPLY	*/	TEXT('*'),
/* 6B VK_ADD		*/	TEXT('+'),
/* 6C VK_SEPARATOR	*/	0,
/* 6D VK_SUBTRACT	*/	TEXT('-'),
/* 6E VK_DECIMAL	*/	TEXT('.'),
/* 6F VK_DIVIDE		*/	TEXT('/'),


/* 70 VK_F1			*/	0,
/* 71 VK_F2			*/	0,
/* 72 VK_F3			*/	0,
/* 73 VK_F4			*/	0,
/* 74 VK_F5			*/	0,
/* 75 VK_F6			*/	0,
/* 76 VK_F7			*/	0,
/* 77 VK_F8			*/	0,
/* 78 VK_F9			*/	0,
/* 79 VK_F10		*/	0,
/* 7A VK_F11		*/	0,
/* 7B VK_F12		*/	0,
/* 7C VK_F13		*/	0,
/* 7D VK_F14		*/	0,
/* 7E VK_F15		*/	0,
/* 7F VK_F16		*/	0,


/* 80 */				0,
/* 81 */				0,
/* 82 */				0,
/* 83 */				0,
/* 84 */				0,
/* 85 */				0,
/* 86 */				0,
/* 87 */				0,
/* 88 */				0,
/* 89 */				0,
/* 8A */				0,
/* 8B */				0,
/* 8C */				0,
/* 8D */				0,
/* 8E */				0,
/* 8F */				0,


/* 90 VK_NUMLOCK	*/	0,
/* 91 VK_SCROLL		*/	0,
/* 92 */				0,
/* 93 */				0,
/* 94 */				0,
/* 95 */				0,
/* 96 */				0,
/* 97 */				0,
/* 98 */				0,
/* 99 */				0,
/* 9A */				0,
/* 9B */				0,
/* 9C */				0,
/* 9D */				0,
/* 9E */				0,
/* 9F */				0,


/* A0 VK_LSHIFT		*/	0,
/* A1 VK_RSHIFT		*/	0,
/* A2 VK_LCONTROL	*/	0,
/* A3 VK_RCONTROL	*/	0,
/* A4 VK_LMENU		*/	0,
/* A5 VK_RMENU		*/	0,
/* A6 */				0,
/* A7 */				0,
/* A8 */				0,
/* A9 */				0,
/* AA */				0,
/* AB */				0,
/* AC */				0,
/* AD */				0,
/* AE */				0,
/* AF */				0,

/* B0 */				0,
/* B1 */				0,
/* B2 */				0,
/* B3 */				0,
/* B4 */				0,
/* B5 */				0,
/* B6 */				0,
/* B7 */				0,
/* B8 */				0,
/* B9 */				0,
/* BA VK_SEMICOLON	*/	TEXT(':'),
/* BB VK_EQUAL		*/	TEXT('+'),
/* BC VK_COMMA		*/	TEXT('<'),
/* BD VK_HYPHEN		*/	TEXT('_'),
/* BE VK_PERIOD		*/	TEXT('>'),
/* BF VK_SLASH		*/	TEXT('?'),


/* C0 VK_BACKQUOTE	*/	TEXT('~'),
/* C1 */				0,
/* C2 */				0,
/* C3 */				0,
/* C4 */				0,
/* C5 */				0,
/* C6 */				0,
/* C7 */				0,
/* C8 */				0,
/* C9 */				0,
/* CA */				0,
/* CB */				0,
/* CC */				0,
/* CD */				0,
/* CE */				0,
/* CF */				0,


/* D0 */				0,
/* D1 */				0,
/* D2 */				0,
/* D3 */				0,
/* D4 */				0,
/* D5 */				0,
/* D6 */				0,
/* D7 */				0,
/* D8 */				0,
/* D9 */				0,
/* DA */				0,
/* DB VK_LBRACKET	*/	TEXT('{'),
/* DC VK_BACKSLASH	*/	TEXT('|'),
/* DD VK_RBRACKET	*/	TEXT('}'),
/* DE VK_APOSTROPHE	*/	TEXT('"'),
/* DF VK_OFF		*/	0,


/* E0 */				0,
/* E1 */				0,
/* E2 */				0,
/* E3 */				0,
/* E4 */				0,
/* E5 */				0,
/* E6 */				0,
/* E7 */				0,
/* E8 */				0,
/* E9 */				0,
/* EA */				0,
/* EB */				0,
/* EC */				0,
/* ED */				0,
/* EE */				0,
/* EF */				0,


/* F0 */				0,
/* F1 */				0,
/* F2 */				0,
/* F3 */				0,
/* F4 */				0,
/* F5 */				0,
/* F6 */				0,
/* F7 */				0,
/* F8 */				0,
/* F9 */				0,
/* FA */				0,
/* FB */				0,
/* FC */				0,
/* FD */				0,
/* FE */				0,
/* FF */				0


};




//	For all of the lookup tables, we could make them smaller
//	by using ranges but it is better to wait for a little while
//	and make sure that all of the characters are correct first.

static
UINT16
VKeyToUnicodeBase(
	UINT32	VKey
	)
{
	UINT16	chRet = 0;

	if ( VKey < COUNT_VKEYS )
		{
		chRet = Column_Base[VKey];
		}

	return chRet;
}


static
UINT16
VKeyToUnicodeShift(
	UINT32	VKey
	)
{
	UINT16	chRet = 0;

	if ( VKey < COUNT_VKEYS )
		{
		chRet = Column_Shift[VKey];
		}

	return chRet;
}



static
UINT16
VKeyToUnicodeControl(
	UINT32	VKey
	)
{
	UINT16	chRet = 0;

	if ( VKey < COUNT_VKEYS )
		{
		chRet = Column_Control[VKey];
		}

	return chRet;
}


static
UINT16
VKeyToUnicodeCapsLock(
	UINT32	VKey
	)
{
	UINT16	chRet = 0;

	if ( VKey < COUNT_VKEYS )
		{
		chRet = Column_CapsLock[VKey];
		}

	return chRet;
}



static
UINT16
VKeyToUnicodeShiftCapsLock(
	UINT32	VKey
	)
{
	UINT16	chRet = 0;

	if ( VKey < COUNT_VKEYS )
		{
		chRet = Column_ShiftCapsLock[VKey];
		}

	return chRet;
}



static
UINT16
VKeyToUnicodeControlCapsLock(
	UINT32	VKey
	)
{
	UINT16	chRet = 0;

	if ( VKey == VK_RETURN )
		{
		chRet = 0x0a;
		}
	else if ( VKey == VK_BACK )
		{
		chRet = 0x07f;
		}

	return chRet;
}



static
UINT16
VKeyToUnicodeControlShift(
	UINT32	VKey
	)
{
	UINT16	chRet = 0;

	if ( VKey == VK_6 )		//	On U.S. keyboard, shift+6 => ^ and ctrl+^ => 0x1e
		{
		chRet = 0x1e;
		}

	return chRet;
}







static
unsigned int
DetermineLookupColumn(
	KEY_STATE_FLAGS	KeyStateFlags
	)
{
	unsigned int	uiColumn = 0;

	if ( KeyStateFlags & KeyShiftAnyShiftFlag )
		{
		uiColumn |= SHIFT_FLAG;
		}

	if ( KeyStateFlags & KeyShiftAnyCtrlFlag )
		{
		uiColumn |= CONTROL_FLAG;
		}

	if ( KeyStateFlags & KeyShiftCapitalFlag )
		{
		uiColumn |= CAPS_FLAG;
		}

	return uiColumn;
}



/*++

VKeyToUnicode:

Return Value:

Errors:

Notes:

--*/
int
VKeyToUnicode(
	UINT32			VirtualKey,	//	Virtual Key causing the event.
	KEY_STATE_FLAGS	ShiftFlags	//	State of Shift, control, caps and alt keys.
		    )
{
	unsigned int	NewColumn;
	UINT16			ch = 0;

	NewColumn = DetermineLookupColumn(ShiftFlags);

	switch ( NewColumn )
		{
		case BASE_FLAG:
			ch = VKeyToUnicodeBase(VirtualKey);
			break;

		case CAPS_FLAG:
			ch = VKeyToUnicodeCapsLock(VirtualKey);
			break;

		case SHIFT_FLAG:
			ch = VKeyToUnicodeShift(VirtualKey);
			break;

		case SHIFT_FLAG | CAPS_FLAG:
			ch = VKeyToUnicodeShiftCapsLock(VirtualKey);
			break;


		//	Ignore Alt
		case ALT_FLAG:
			ch = VKeyToUnicodeBase(VirtualKey);
			break;

		//	Ignore Alt
		case ALT_FLAG | CAPS_FLAG:
			ch = VKeyToUnicodeCapsLock(VirtualKey);
			break;

		//	Ignore Alt
		case ALT_FLAG | SHIFT_FLAG:
			ch = VKeyToUnicodeShift(VirtualKey);
			break;

		//	Ignore Alt
		case ALT_FLAG | SHIFT_FLAG | CAPS_FLAG:
			ch = VKeyToUnicodeShiftCapsLock(VirtualKey);
			break;




		case CONTROL_FLAG:
			ch = VKeyToUnicodeControl(VirtualKey);
			break;

		//	Ignore Caps when Control
		case CONTROL_FLAG | CAPS_FLAG:
			ch = VKeyToUnicodeControl(VirtualKey);
			break;

		case CONTROL_FLAG | SHIFT_FLAG:
			ch = VKeyToUnicodeControlShift(VirtualKey);
			break;

		//	Ignore Caps when Control
		case CONTROL_FLAG | SHIFT_FLAG | CAPS_FLAG:
			ch = VKeyToUnicodeControlShift(VirtualKey);
			break;


		//	Ignore Alt
		case CONTROL_FLAG | ALT_FLAG:
			ch = VKeyToUnicodeControl(VirtualKey);
			break;

		//	Ignore Alt
		//	Ignore Caps when Control
		case CONTROL_FLAG | ALT_FLAG | CAPS_FLAG:
			ch = VKeyToUnicodeControl(VirtualKey);
			break;

		//	Ignore Alt
		case CONTROL_FLAG | ALT_FLAG | SHIFT_FLAG:
			ch = VKeyToUnicodeControlShift(VirtualKey);
			break;

		//	Ignore Alt
		//	Ignore Caps when Control
		case CONTROL_FLAG | ALT_FLAG | SHIFT_FLAG | CAPS_FLAG:
			ch = VKeyToUnicodeControlShift(VirtualKey);
			break;

		}

	return ch;
}













UINT32
KeybdDriverVKeyToUnicode(
	UINT32			VirtualKey,
	KEY_STATE_FLAGS	KeyEvent,
	KEY_STATE		KeyState,
	void			*pKeybdDriverToUnicodeState,
	UINT32			cBufferSize,
	UINT32			*pcCharacters,
	KEY_STATE_FLAGS	*pShiftStateBuffer,
	UINT32			*pCharacterBuffer)
{
	KEY_STATE_FLAGS	ShiftFlags;
	UINT32			VKeyCommon;

	VirtualKey &= 0xff;

	//	Do special case for MapVirtualKey here.
	if ( KeyState == NULL )
		{
		if ( pCharacterBuffer )
			*pCharacterBuffer = towlower(VirtualKey);
		return ERROR_SUCCESS;
		}

	//	We have ToUnicodeState for demo, so check for it.
	if ( pKeybdDriverToUnicodeState == NULL )
		{
		SetLastError(ERROR_INVALID_PARAMETER);
		return ERROR_INVALID_PARAMETER;
		}

	if ( ( cBufferSize != MAX_TO_UNICODE_CHARACTERS ) ||
		 ( pShiftStateBuffer == NULL ) ||
		 ( pCharacterBuffer == NULL ) )
		{
		SetLastError(ERROR_INVALID_PARAMETER);
		return ERROR_INVALID_PARAMETER;
		}

	// Update the virtual key state.
	KeyState[VirtualKey] = NewKeyStateFlags(KeyState[VirtualKey], KeyEvent);

	// Now check the duplicate keys.
	VKeyCommon = MapLRVKeyToCommonVKey(VirtualKey);
	if ( VKeyCommon != VirtualKey )
		{
		KeyState[VKeyCommon] = NewKeyStateFlags(KeyState[VKeyCommon], KeyEvent);
		VirtualKey = VKeyCommon;
		}

	// Figure out the new shift state flags.
	KeybdDriverKeyStateToShiftFlags(KeyState, VirtualKey, &ShiftFlags);

	if ( ( VirtualKey == VK_CAPITAL ) ||
		 ( VirtualKey == VK_NUMLOCK ) ||
		 ( VirtualKey == 0 ))
		{
		KeybdPdd_ToggleKeyNotification(ShiftFlags);
		}

	// Always return the shift state which counts for one entry.
	*pcCharacters = 1;

	//	Note that ShiftFlags holds the current state of the keyboard when it is
	//	passed to the next routines.  They will look at the current state and
	//	possibly update it depending on whether or not they generate a character.
	if ( AltNumKeyEvent(
			VirtualKey,
			KeyEvent,
			(TO_UNICODE_STATE*)pKeybdDriverToUnicodeState,
			&ShiftFlags,
			pCharacterBuffer) )
		{
		//	If part of Alt+Num sequence, no more to do.
		}
	else if ( KeyEvent & KeyStateDownFlag )
		{
		*pCharacterBuffer = VKeyToUnicode(VirtualKey, ShiftFlags);
		if ( !*pCharacterBuffer )
			{
			ShiftFlags |= KeyShiftNoCharacterFlag;
			}
		}
	else
		{
		ShiftFlags |= KeyShiftNoCharacterFlag;
		}

	*pShiftStateBuffer = ShiftFlags;

	return ERROR_SUCCESS;
}


#ifdef DEBUG
PFN_KEYBD_DRIVER_VKEY_TO_UNICODE v_pfnVKeyToUnicodeTest = KeybdDriverVKeyToUnicode;
#endif



BOOL
KeybdDriverInitStates(
	INT			iKeybdId,
	KEY_STATE   KeyState,
	void        *pKeybdDeviceToUnicodeState
	)
{
	TO_UNICODE_STATE	*pDemoState = (TO_UNICODE_STATE*)pKeybdDeviceToUnicodeState;
	int	i;

	//	We have some demo state, so check for it.  If we had no state,
	//	this parameter could be NULL with no error.
	if ( pDemoState == NULL )
		{
		SetLastError(ERROR_INVALID_PARAMETER);
		return FALSE;
		}

	for ( i = 0; i < COUNT_VKEYS; i++ )
		{
		KeyState[i] = 0;
		}

	return TRUE;
}

#ifdef DEBUG
PFN_KEYBD_DRIVER_INIT_STATES v_pfnInitStatesTest = KeybdDriverInitStates;
#endif



UINT32
KeybdDriverMapVirtualKey(
	UINT32	uCode,
	UINT32	uMapType
	)
{
	UINT32	uRet = 0;

	UINT32			VKeyBuf[16];
	UINT32			ScanCodeBuf[16];
	KEY_STATE_FLAGS	KeyStateFlagsBuf[16];


	switch ( uMapType )
		{
		case 0:
			uCode = MapCommonVKeyToLVKey(uCode);
			uRet = VKeyToScanCode(uCode);
			uRet &= 0xff;
			break;

		case 1:
			uRet = ScanCodeToVKeyEx(uCode, 0, VKeyBuf, ScanCodeBuf, KeyStateFlagsBuf);
			if (uRet != 0) {
			    uRet = MapLRVKeyToCommonVKey(VKeyBuf[0]);
			} else
			    SetLastError(ERROR_INVALID_PARAMETER);
			break;

		case 2:
			KeybdDriverVKeyToUnicode(uCode, 0, NULL, NULL, 0, NULL, NULL, &uRet);
			break;

		case 3:
			uRet = VKeyToScanCode(uCode);
			uRet &= 0xff;
			break;

		default:
			SetLastError(ERROR_INVALID_PARAMETER);
			break;
		}

	return uRet;
}

#ifdef DEBUG
PFN_KEYBD_DRIVER_MAP_VIRTUAL_KEY v_pfnMapVirtualKeyTest = KeybdDriverMapVirtualKey;
#endif