tyler.durden
/
audk
mirror of https://github.com/acidanthera/audk.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

1. Add Partial Keystroke Support in Nt32 WinNTGopDxe driver. See the Uefi2.3.1a chapter 11.2 

2. Fix the bug of "NT32 Keyboard driver don't support the ALT+ValueKey".

Signed-off-by: qianouyang
Reviewed-by: niruiyu vanjeff


git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@12496 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
qianouyang 2011-09-30 07:30:20 +00:00
parent 5829afe3e4
commit df7499fcc1
3 changed files with 344 additions and 241 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
Nt32Pkg/WinNtGopDxe/WinNtGop.h
View File

@ -155,6 +155,7 @@ typedef struct {
BOOLEAN NumLock; BOOLEAN NumLock;
BOOLEAN ScrollLock; BOOLEAN ScrollLock;
BOOLEAN CapsLock; BOOLEAN CapsLock;
BOOLEAN IsPartialKeySupport;
EFI_EVENT TimerEvent; EFI_EVENT TimerEvent;
} GOP_PRIVATE_DATA; } GOP_PRIVATE_DATA;

100
Nt32Pkg/WinNtGopDxe/WinNtGopInput.c
View File

@ -133,6 +133,16 @@ GopPrivateDeleteQ (
CopyMem (Key, &Queue->Q[Queue->Front], sizeof (EFI_KEY_DATA)); CopyMem (Key, &Queue->Q[Queue->Front], sizeof (EFI_KEY_DATA));
Queue->Front = (Queue->Front + 1) % MAX_Q; Queue->Front = (Queue->Front + 1) % MAX_Q;
if (Key->Key.ScanCode == SCAN_NULL && Key->Key.UnicodeChar == CHAR_NULL) {
if (!Private->IsPartialKeySupport) {
//
// If partial keystrok is not enabled, don't return the partial keystroke.
//
Private->WinNtThunk->LeaveCriticalSection (&Queue->Cs);
ZeroMem (Key, sizeof (EFI_KEY_DATA));
return EFI_NOT_READY;
}
}
Private->WinNtThunk->LeaveCriticalSection (&Queue->Cs); Private->WinNtThunk->LeaveCriticalSection (&Queue->Cs);
return EFI_SUCCESS; return EFI_SUCCESS;
} }
@ -324,6 +334,9 @@ GopPrivateAddKey (
if (Private->ScrollLock) { if (Private->ScrollLock) {
KeyData.KeyState.KeyToggleState |= EFI_SCROLL_LOCK_ACTIVE; KeyData.KeyState.KeyToggleState |= EFI_SCROLL_LOCK_ACTIVE;
} }
if (Private->IsPartialKeySupport) {
KeyData.KeyState.KeyToggleState |= EFI_KEY_STATE_EXPOSED;
}
// //
// Convert Ctrl+[1-26] to Ctrl+[A-Z] // Convert Ctrl+[1-26] to Ctrl+[A-Z]
@ -445,6 +458,7 @@ Returns:
Private->CapsLock = FALSE; Private->CapsLock = FALSE;
Private->NumLock = FALSE; Private->NumLock = FALSE;
Private->ScrollLock = FALSE; Private->ScrollLock = FALSE;
Private->IsPartialKeySupport = FALSE;
Private->KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID; Private->KeyState.KeyShiftState = EFI_SHIFT_STATE_VALID;
Private->KeyState.KeyToggleState = EFI_TOGGLE_STATE_VALID; Private->KeyState.KeyToggleState = EFI_TOGGLE_STATE_VALID;
@ -507,10 +521,14 @@ GopPrivateReadKeyStrokeWorker (
Status = GopPrivateDeleteQ (Private, &Private->QueueForRead, KeyData); Status = GopPrivateDeleteQ (Private, &Private->QueueForRead, KeyData);
if (!EFI_ERROR (Status)) { if (!EFI_ERROR (Status)) {
// //
// Leave critical section and return // If partial keystroke is not enabled, check whether it is value key. If not return
// EFI_NOT_READY.
// //
gBS->RestoreTPL (OldTpl); if (!Private->IsPartialKeySupport) {
return EFI_SUCCESS; if (KeyData->Key.ScanCode == SCAN_NULL && KeyData->Key.UnicodeChar == CHAR_NULL) {
Status = EFI_NOT_READY;
}
}
} }
} }
@ -574,15 +592,22 @@ WinNtGopSimpleTextInReadKeyStroke (
EFI_KEY_DATA KeyData; EFI_KEY_DATA KeyData;
Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This); Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_THIS (This);
//
Status = GopPrivateReadKeyStrokeWorker (Private, &KeyData); // Considering if the partial keystroke is enabled, there maybe a partial
if (EFI_ERROR (Status)) { // keystroke in the queue, so here skip the partial keystroke and get the
return Status; // next key from the queue
//
while (1) {
Status = GopPrivateReadKeyStrokeWorker (Private, &KeyData);
if (EFI_ERROR (Status)) {
return Status;
}
if (KeyData.Key.ScanCode == SCAN_NULL && KeyData.Key.UnicodeChar == CHAR_NULL) {
continue;
}
CopyMem (Key, &KeyData.Key, sizeof (EFI_INPUT_KEY));
return EFI_SUCCESS;
} }
CopyMem (Key, &KeyData.Key, sizeof (EFI_INPUT_KEY));
return EFI_SUCCESS;
} }
@ -605,6 +630,7 @@ WinNtGopSimpleTextInWaitForKey (
GOP_PRIVATE_DATA *Private; GOP_PRIVATE_DATA *Private;
EFI_STATUS Status; EFI_STATUS Status;
EFI_TPL OldTpl; EFI_TPL OldTpl;
EFI_KEY_DATA KeyData;
Private = (GOP_PRIVATE_DATA *) Context; Private = (GOP_PRIVATE_DATA *) Context;
@ -618,20 +644,34 @@ WinNtGopSimpleTextInWaitForKey (
// //
WinNtGopSimpleTextInTimerHandler (NULL, Private); WinNtGopSimpleTextInTimerHandler (NULL, Private);
Status = GopPrivateCheckQ (&Private->QueueForRead); //
if (!EFI_ERROR (Status)) { // WaitforKey doesn't suppor the partial key.
// // Considering if the partial keystroke is enabled, there maybe a partial
// If a there is a key in the queue signal our event. // keystroke in the queue, so here skip the partial keystroke and get the
// // next key from the queue
gBS->SignalEvent (Event); //
} else { while (1) {
// Status = GopPrivateCheckQ (&Private->QueueForRead);
// We need to sleep or NT will schedule this thread with such high if (!EFI_ERROR (Status)) {
// priority that WinProc thread will never run and we will not see //
// keyboard input. This Sleep makes the syste run 10x faster, so don't // If a there is a key in the queue and it is not partial keystroke, signal event.
// remove it. //
// if (Private->QueueForRead.Q[Private->QueueForRead.Front].Key.ScanCode == SCAN_NULL &&
Private->WinNtThunk->Sleep (1); Private->QueueForRead.Q[Private->QueueForRead.Front].Key.UnicodeChar == CHAR_NULL) {
GopPrivateDeleteQ (Private,&Private->QueueForRead,&KeyData);
continue;
}
gBS->SignalEvent (Event);
} else {
//
// We need to sleep or NT will schedule this thread with such high
// priority that WinProc thread will never run and we will not see
// keyboard input. This Sleep makes the syste run 10x faster, so don't
// remove it.
//
Private->WinNtThunk->Sleep (1);
}
break;
} }
// //
@ -748,9 +788,10 @@ WinNtGopSimpleTextInExSetState (
return EFI_UNSUPPORTED; return EFI_UNSUPPORTED;
} }
Private->ScrollLock = FALSE; Private->ScrollLock = FALSE;
Private->NumLock = FALSE; Private->NumLock = FALSE;
Private->CapsLock = FALSE; Private->CapsLock = FALSE;
Private->IsPartialKeySupport = FALSE;
if ((*KeyToggleState & EFI_SCROLL_LOCK_ACTIVE) == EFI_SCROLL_LOCK_ACTIVE) { if ((*KeyToggleState & EFI_SCROLL_LOCK_ACTIVE) == EFI_SCROLL_LOCK_ACTIVE) {
Private->ScrollLock = TRUE; Private->ScrollLock = TRUE;
@ -761,6 +802,9 @@ WinNtGopSimpleTextInExSetState (
if ((*KeyToggleState & EFI_CAPS_LOCK_ACTIVE) == EFI_CAPS_LOCK_ACTIVE) { if ((*KeyToggleState & EFI_CAPS_LOCK_ACTIVE) == EFI_CAPS_LOCK_ACTIVE) {
Private->CapsLock = TRUE; Private->CapsLock = TRUE;
} }
if ((*KeyToggleState & EFI_KEY_STATE_EXPOSED) == EFI_KEY_STATE_EXPOSED) {
Private->IsPartialKeySupport = TRUE;
}
Status = GopPrivateUpdateStatusLight (Private); Status = GopPrivateUpdateStatusLight (Private);
if (EFI_ERROR (Status)) { if (EFI_ERROR (Status)) {

256
Nt32Pkg/WinNtGopDxe/WinNtGopScreen.c
View File

@ -52,10 +52,11 @@ KillNtGopThread (
IN VOID *Context IN VOID *Context
); );
VOID BOOLEAN
WinNtGopConvertParamToEfiKeyShiftState ( WinNtGopConvertParamToEfiKeyShiftState (
IN GOP_PRIVATE_DATA *Private, IN GOP_PRIVATE_DATA *Private,
IN WPARAM *wParam, IN WPARAM *wParam,
IN LPARAM *lParam,
IN BOOLEAN Flag IN BOOLEAN Flag
) )
{ {
@ -67,91 +68,138 @@ WinNtGopConvertParamToEfiKeyShiftState (
// Therefor, we can not set the correct Shift state here. // Therefor, we can not set the correct Shift state here.
// //
case VK_SHIFT: case VK_SHIFT:
Private->LeftShift = Flag; if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
break; Private->RightShift = Flag;
} else {
Private->LeftShift = Flag;
}
return TRUE;
case VK_LSHIFT:
Private->LeftShift = Flag;
return TRUE;
case VK_RSHIFT:
Private->RightShift = Flag;
return TRUE;
case VK_CONTROL: case VK_CONTROL:
Private->LeftCtrl = Flag; if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
break; Private->RightCtrl= Flag;
} else {
Private->LeftCtrl = Flag;
}
return TRUE;
case VK_LCONTROL:
Private->LeftCtrl = Flag;
return TRUE;
case VK_RCONTROL:
Private->RightCtrl = Flag;
return TRUE;
case VK_LWIN: case VK_LWIN:
Private->LeftLogo = Flag; Private->LeftLogo = Flag;
break; return TRUE;
case VK_RWIN: case VK_RWIN:
Private->RightLogo = Flag; Private->RightLogo = Flag;
break; return TRUE;
case VK_APPS: case VK_APPS:
Private->Menu = Flag; Private->Menu = Flag;
break; return TRUE;
// //
// BUGBUG: PrintScreen/SysRq can not trigger WM_KEYDOWN message, // BUGBUG: PrintScreen/SysRq can not trigger WM_KEYDOWN message,
// so SySReq shift state is not supported here. // so SySReq shift state is not supported here.
// //
case VK_PRINT: case VK_PRINT:
Private->SysReq = Flag; Private->SysReq = Flag;
break; return TRUE;
//
// For Alt Keystroke.
//
case VK_MENU:
if ((*lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) {
Private->RightAlt = Flag;
} else {
Private->LeftAlt = Flag;
}
return TRUE;
default:
return FALSE;
} }
} }
VOID BOOLEAN
WinNtGopConvertParamToEfiKey ( WinNtGopConvertParamToEfiKey (
IN GOP_PRIVATE_DATA *Private, IN GOP_PRIVATE_DATA *Private,
IN WPARAM *wParam, IN WPARAM *wParam,
IN LPARAM *lParam,
IN EFI_INPUT_KEY *Key IN EFI_INPUT_KEY *Key
) )
{ {
BOOLEAN Flag;
Flag = FALSE;
switch (*wParam) { switch (*wParam) {
case VK_HOME: Key->ScanCode = SCAN_HOME; break; case VK_HOME: Key->ScanCode = SCAN_HOME; Flag = TRUE; break;
case VK_END: Key->ScanCode = SCAN_END; break; case VK_END: Key->ScanCode = SCAN_END; Flag = TRUE; break;
case VK_LEFT: Key->ScanCode = SCAN_LEFT; break; case VK_LEFT: Key->ScanCode = SCAN_LEFT; Flag = TRUE; break;
case VK_RIGHT: Key->ScanCode = SCAN_RIGHT; break; case VK_RIGHT: Key->ScanCode = SCAN_RIGHT; Flag = TRUE; break;
case VK_UP: Key->ScanCode = SCAN_UP; break; case VK_UP: Key->ScanCode = SCAN_UP; Flag = TRUE; break;
case VK_DOWN: Key->ScanCode = SCAN_DOWN; break; case VK_DOWN: Key->ScanCode = SCAN_DOWN; Flag = TRUE; break;
case VK_DELETE: Key->ScanCode = SCAN_DELETE; break; case VK_DELETE: Key->ScanCode = SCAN_DELETE; Flag = TRUE; break;
case VK_INSERT: Key->ScanCode = SCAN_INSERT; break; case VK_INSERT: Key->ScanCode = SCAN_INSERT; Flag = TRUE; break;
case VK_PRIOR: Key->ScanCode = SCAN_PAGE_UP; break; case VK_PRIOR: Key->ScanCode = SCAN_PAGE_UP; Flag = TRUE; break;
case VK_NEXT: Key->ScanCode = SCAN_PAGE_DOWN; break; case VK_NEXT: Key->ScanCode = SCAN_PAGE_DOWN; Flag = TRUE; break;
case VK_ESCAPE: Key->ScanCode = SCAN_ESC; break; case VK_ESCAPE: Key->ScanCode = SCAN_ESC; Flag = TRUE; break;
case VK_F1: Key->ScanCode = SCAN_F1; break; case VK_F1: Key->ScanCode = SCAN_F1; Flag = TRUE; break;
case VK_F2: Key->ScanCode = SCAN_F2; break; case VK_F2: Key->ScanCode = SCAN_F2; Flag = TRUE; break;
case VK_F3: Key->ScanCode = SCAN_F3; break; case VK_F3: Key->ScanCode = SCAN_F3; Flag = TRUE; break;
case VK_F4: Key->ScanCode = SCAN_F4; break; case VK_F4: Key->ScanCode = SCAN_F4; Flag = TRUE; break;
case VK_F5: Key->ScanCode = SCAN_F5; break; case VK_F5: Key->ScanCode = SCAN_F5; Flag = TRUE; break;
case VK_F6: Key->ScanCode = SCAN_F6; break; case VK_F6: Key->ScanCode = SCAN_F6; Flag = TRUE; break;
case VK_F7: Key->ScanCode = SCAN_F7; break; case VK_F7: Key->ScanCode = SCAN_F7; Flag = TRUE; break;
case VK_F8: Key->ScanCode = SCAN_F8; break; case VK_F8: Key->ScanCode = SCAN_F8; Flag = TRUE; break;
case VK_F9: Key->ScanCode = SCAN_F9; break; case VK_F9: Key->ScanCode = SCAN_F9; Flag = TRUE; break;
case VK_F11: Key->ScanCode = SCAN_F11; break; case VK_F11: Key->ScanCode = SCAN_F11; Flag = TRUE; break;
case VK_F12: Key->ScanCode = SCAN_F12; break; case VK_F12: Key->ScanCode = SCAN_F12; Flag = TRUE; break;
case VK_F13: Key->ScanCode = SCAN_F13; break; case VK_F13: Key->ScanCode = SCAN_F13; Flag = TRUE; break;
case VK_F14: Key->ScanCode = SCAN_F14; break; case VK_F14: Key->ScanCode = SCAN_F14; Flag = TRUE; break;
case VK_F15: Key->ScanCode = SCAN_F15; break; case VK_F15: Key->ScanCode = SCAN_F15; Flag = TRUE; break;
case VK_F16: Key->ScanCode = SCAN_F16; break; case VK_F16: Key->ScanCode = SCAN_F16; Flag = TRUE; break;
case VK_F17: Key->ScanCode = SCAN_F17; break; case VK_F17: Key->ScanCode = SCAN_F17; Flag = TRUE; break;
case VK_F18: Key->ScanCode = SCAN_F18; break; case VK_F18: Key->ScanCode = SCAN_F18; Flag = TRUE; break;
case VK_F19: Key->ScanCode = SCAN_F19; break; case VK_F19: Key->ScanCode = SCAN_F19; Flag = TRUE; break;
case VK_F20: Key->ScanCode = SCAN_F20; break; case VK_F20: Key->ScanCode = SCAN_F20; Flag = TRUE; break;
case VK_F21: Key->ScanCode = SCAN_F21; break; case VK_F21: Key->ScanCode = SCAN_F21; Flag = TRUE; break;
case VK_F22: Key->ScanCode = SCAN_F22; break; case VK_F22: Key->ScanCode = SCAN_F22; Flag = TRUE; break;
case VK_F23: Key->ScanCode = SCAN_F23; break; case VK_F23: Key->ScanCode = SCAN_F23; Flag = TRUE; break;
case VK_F24: Key->ScanCode = SCAN_F24; break; case VK_F24: Key->ScanCode = SCAN_F24; Flag = TRUE; break;
case VK_PAUSE: Key->ScanCode = SCAN_PAUSE; break; case VK_PAUSE: Key->ScanCode = SCAN_PAUSE; Flag = TRUE; break;
// //
// Set toggle state // Set toggle state
// //
case VK_NUMLOCK: case VK_NUMLOCK:
Private->NumLock = (BOOLEAN)(!Private->NumLock); Private->NumLock = (BOOLEAN)(!Private->NumLock);
Flag = TRUE;
break; break;
case VK_SCROLL: case VK_SCROLL:
Private->ScrollLock = (BOOLEAN)(!Private->ScrollLock); Private->ScrollLock = (BOOLEAN)(!Private->ScrollLock);
Flag = TRUE;
break; break;
case VK_CAPITAL: case VK_CAPITAL:
Private->CapsLock = (BOOLEAN)(!Private->CapsLock); Private->CapsLock = (BOOLEAN)(!Private->CapsLock);
Flag = TRUE;
break; break;
} }
WinNtGopConvertParamToEfiKeyShiftState (Private, wParam, TRUE); return (WinNtGopConvertParamToEfiKeyShiftState (Private, wParam, lParam, TRUE)) == TRUE ? TRUE : Flag;
} }
@ -616,6 +664,7 @@ WinNtGopThreadWindowProc (
PAINTSTRUCT PaintStruct; PAINTSTRUCT PaintStruct;
LPARAM Index; LPARAM Index;
EFI_INPUT_KEY Key; EFI_INPUT_KEY Key;
BOOLEAN AltIsPress;
// //
// BugBug - if there are two instances of this DLL in memory (such as is // BugBug - if there are two instances of this DLL in memory (such as is
@ -630,6 +679,7 @@ WinNtGopThreadWindowProc (
// This works since each Gop protocol has a unique Private data instance and // This works since each Gop protocol has a unique Private data instance and
// a unique thread. // a unique thread.
// //
AltIsPress = FALSE;
Private = mWinNt->TlsGetValue (mTlsIndex); Private = mWinNt->TlsGetValue (mTlsIndex);
ASSERT (NULL != Private); ASSERT (NULL != Private);
@ -693,88 +743,96 @@ WinNtGopThreadWindowProc (
// holds down ALT key and then presses another key. // holds down ALT key and then presses another key.
// //
case WM_SYSKEYDOWN: case WM_SYSKEYDOWN:
Key.ScanCode = 0;
Key.ScanCode = 0;
Key.UnicodeChar = CHAR_NULL;
switch (wParam) { switch (wParam) {
case VK_F10: case VK_F10:
Key.ScanCode = SCAN_F10; Key.ScanCode = SCAN_F10;
Key.UnicodeChar = 0; Key.UnicodeChar = CHAR_NULL;
GopPrivateAddKey (Private, Key); GopPrivateAddKey (Private, Key);
return 0; return 0;
} }
if ((lParam & GOP_ALT_KEY_PRESSED) == GOP_ALT_KEY_PRESSED) { //
// // If ALT or ALT + modifier key is pressed.
// ALT is pressed with another key pressed //
// if (WinNtGopConvertParamToEfiKey (Private, &wParam, &lParam, &Key)) {
WinNtGopConvertParamToEfiKey (Private, &wParam, &Key); if (Key.ScanCode != 0){
//
if ((lParam & GOP_EXTENDED_KEY) == GOP_EXTENDED_KEY) { // If ALT is pressed with other ScanCode.
Private->RightAlt = TRUE; // Always revers the left Alt for simple.
} else { //
Private->LeftAlt = TRUE; Private->LeftAlt = TRUE;
} }
if (Private->RightAlt && Private->LeftAlt) {
Private->LeftAlt = FALSE;
}
}
if (Key.ScanCode != 0) {
Key.UnicodeChar = 0;
GopPrivateAddKey (Private, Key); GopPrivateAddKey (Private, Key);
}
return 0;
case WM_SYSKEYUP:
if ((lParam & GOP_ALT_KEY_PRESSED) == GOP_ALT_KEY_PRESSED) {
// //
// ALT is pressed with another key released // When Alt is released there is no windoes message, so
// // clean it after using it.
WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, FALSE);
//
// Actually ALT key is still held down here.
// Change the ALT key state when another key is released
// by user because we did not find a better solution to
// get a released ALT key.
// //
Private->RightAlt = FALSE; Private->RightAlt = FALSE;
Private->LeftAlt = FALSE; Private->LeftAlt = FALSE;
return 0;
} }
AltIsPress = TRUE;
return 0;
case WM_KEYDOWN:
Key.ScanCode = 0;
WinNtGopConvertParamToEfiKey (Private, &wParam, &Key);
if (Key.ScanCode != 0) {
Key.UnicodeChar = 0;
GopPrivateAddKey (Private, Key);
}
return 0;
case WM_KEYUP:
WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, FALSE);
return 0;
case WM_CHAR: case WM_CHAR:
// //
// The ESC key also generate WM_CHAR. // The ESC key also generate WM_CHAR.
// //
if (wParam == 0x1B) { if (wParam == 0x1B) {
return 0; return 0;
} }
if (AltIsPress == TRUE) {
//
// If AltIsPress is true that means the Alt key is pressed.
//
Private->LeftAlt = TRUE;
}
for (Index = 0; Index < (lParam & 0xffff); Index++) { for (Index = 0; Index < (lParam & 0xffff); Index++) {
if (wParam != 0) { if (wParam != 0) {
Key.UnicodeChar = (CHAR16) wParam; Key.UnicodeChar = (CHAR16) wParam;
Key.ScanCode = 0; Key.ScanCode = SCAN_NULL;
GopPrivateAddKey (Private, Key); GopPrivateAddKey (Private, Key);
} }
} }
if (AltIsPress == TRUE) {
//
// When Alt is released there is no windoes message, so
// clean it after using it.
//
Private->LeftAlt = FALSE;
Private->RightAlt = FALSE;
}
return 0;
case WM_SYSKEYUP:
//
// ALT is pressed with another key released
//
WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, &lParam, FALSE);
return 0;
case WM_KEYDOWN:
Key.ScanCode = SCAN_NULL;
//
// A value key press will cause a WM_KEYDOWN first, then cause a WM_CHAR
// So if there is no modifier key updated, skip the WM_KEYDOWN even.
//
if (WinNtGopConvertParamToEfiKey (Private, &wParam, &lParam, &Key)) {
if (Key.ScanCode != SCAN_NULL) {
Key.UnicodeChar = CHAR_NULL;
}
//
// Support the partial keystroke, add all keydown event into the queue.
//
GopPrivateAddKey (Private, Key);
}
return 0;
case WM_KEYUP:
WinNtGopConvertParamToEfiKeyShiftState (Private, &wParam, &lParam, FALSE);
return 0; return 0;
case WM_CLOSE: case WM_CLOSE: