vkchjpn2.cpp

三星2410的BSP开发包

/* 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 */				0xff9a,
/* BB */				0xff8d,		//	He
/* BC */				0xff64,		//	Ku ten
/* BD */				0xff8e,		//	????
/* BE */				0xff61,		//	Tuo ten
/* BF */				0xff65,		//


/* C0 */				0xff9e,
/* 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 */				0xff62,
/* DC */				0xff70,
/* DD */				0xff63,
/* DE */				0xff79,     //	Ke
/* DF */				0,


/* E0 */				0,
/* E1 */				0,
/* E2 */				0xff9b,     //	Ro
/* 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 = 0x7f;
		}

	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
UINT16
VKeyToUnicodeKana(
	UINT32	VKey
	)
{
	UINT16	chRet = 0;

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

	return chRet;
}

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

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

	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;
		}

	if ( KeyStateFlags & KeyShiftKanaFlag )
		{
		uiColumn |= KANA_FLAG;
		}

	if ( KeyStateFlags & KeyShiftAnyAltFlag )
		{
		uiColumn |= ALT_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;





		case KANA_FLAG:
			ch = VKeyToUnicodeKana(VirtualKey);
			break;

		//	Ignore Caps
		case KANA_FLAG | CAPS_FLAG:
			ch = VKeyToUnicodeKana(VirtualKey);
			break;

		case KANA_FLAG | SHIFT_FLAG:
			ch = VKeyToUnicodeKanaShift(VirtualKey);
			break;

		//	Ignore Caps
		case KANA_FLAG | SHIFT_FLAG | CAPS_FLAG:
			ch = VKeyToUnicodeKanaShift(VirtualKey);
			break;


		//	Ignore Kana when Alt
		case KANA_FLAG | ALT_FLAG:
			ch = VKeyToUnicodeBase(VirtualKey);
			break;

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

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

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



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

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

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

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


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

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

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

		//	Ignore Kana when Control
		//	Ignore Alt when Control
		//	Ignore Caps when Control
		case KANA_FLAG | 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 ) )
		{
		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