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

19
Nt32Pkg/WinNtGopDxe/WinNtGop.h
View File

@ -46,13 +46,13 @@ Abstract:
// //
// WM_SYSKEYDOWN/WM_SYSKEYUP Notification // WM_SYSKEYDOWN/WM_SYSKEYUP Notification
// lParam // lParam
// bit 24: Specifies whether the key is an extended key, // bit 24: Specifies whether the key is an extended key,
// such as the right-hand ALT and CTRL keys that appear on // such as the right-hand ALT and CTRL keys that appear on
// an enhanced 101- or 102-key keyboard. // an enhanced 101- or 102-key keyboard.
// The value is 1 if it is an extended key; otherwise, it is 0. // The value is 1 if it is an extended key; otherwise, it is 0.
// bit 29:Specifies the context code. // bit 29:Specifies the context code.
// The value is 1 if the ALT key is down while the key is pressed/released; // The value is 1 if the ALT key is down while the key is pressed/released;
// it is 0 if the WM_SYSKEYDOWN message is posted to the active window // it is 0 if the WM_SYSKEYDOWN message is posted to the active window
// because no window has the keyboard focus. // because no window has the keyboard focus.
#define GOP_EXTENDED_KEY (0x1 << 24) #define GOP_EXTENDED_KEY (0x1 << 24)
#define GOP_ALT_KEY_PRESSED (0x1 << 29) #define GOP_ALT_KEY_PRESSED (0x1 << 29)
@ -132,7 +132,7 @@ typedef struct {
EFI_GRAPHICS_OUTPUT_BLT_PIXEL *FillLine; EFI_GRAPHICS_OUTPUT_BLT_PIXEL *FillLine;
// //
// Keyboard Queue used by Simple Text In. // Keyboard Queue used by Simple Text In.
// QueueForRead: WinProc thread adds, and main thread removes. // QueueForRead: WinProc thread adds, and main thread removes.
// QueueForNotify: WinProc thread adds, and timer thread removes. // QueueForNotify: WinProc thread adds, and timer thread removes.
// //
@ -143,7 +143,7 @@ typedef struct {
EFI_KEY_STATE KeyState; EFI_KEY_STATE KeyState;
LIST_ENTRY NotifyList; LIST_ENTRY NotifyList;
BOOLEAN LeftShift; BOOLEAN LeftShift;
BOOLEAN RightShift; BOOLEAN RightShift;
BOOLEAN LeftAlt; BOOLEAN LeftAlt;
BOOLEAN RightAlt; BOOLEAN RightAlt;
BOOLEAN LeftCtrl; BOOLEAN LeftCtrl;
@ -151,10 +151,11 @@ typedef struct {
BOOLEAN LeftLogo; BOOLEAN LeftLogo;
BOOLEAN RightLogo; BOOLEAN RightLogo;
BOOLEAN Menu; BOOLEAN Menu;
BOOLEAN SysReq; BOOLEAN SysReq;
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;

276
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;
} }
@ -170,36 +180,36 @@ Routine Description:
Arguments: Arguments:
RegsiteredData - A pointer to a buffer that is filled in with the keystroke RegsiteredData - A pointer to a buffer that is filled in with the keystroke
state data for the key that was registered. state data for the key that was registered.
InputData - A pointer to a buffer that is filled in with the keystroke InputData - A pointer to a buffer that is filled in with the keystroke
state data for the key that was pressed. state data for the key that was pressed.
Returns: Returns:
TRUE - Key be pressed matches a registered key. TRUE - Key be pressed matches a registered key.
FLASE - Match failed. FLASE - Match failed.
--*/ --*/
{ {
ASSERT (RegsiteredData != NULL && InputData != NULL); ASSERT (RegsiteredData != NULL && InputData != NULL);
if ((RegsiteredData->Key.ScanCode != InputData->Key.ScanCode) || if ((RegsiteredData->Key.ScanCode != InputData->Key.ScanCode) ||
(RegsiteredData->Key.UnicodeChar != InputData->Key.UnicodeChar)) { (RegsiteredData->Key.UnicodeChar != InputData->Key.UnicodeChar)) {
return FALSE; return FALSE;
} }
// //
// Assume KeyShiftState/KeyToggleState = 0 in Registered key data means these state could be ignored. // Assume KeyShiftState/KeyToggleState = 0 in Registered key data means these state could be ignored.
// //
if (RegsiteredData->KeyState.KeyShiftState != 0 && if (RegsiteredData->KeyState.KeyShiftState != 0 &&
RegsiteredData->KeyState.KeyShiftState != InputData->KeyState.KeyShiftState) { RegsiteredData->KeyState.KeyShiftState != InputData->KeyState.KeyShiftState) {
return FALSE; return FALSE;
} }
if (RegsiteredData->KeyState.KeyToggleState != 0 && if (RegsiteredData->KeyState.KeyToggleState != 0 &&
RegsiteredData->KeyState.KeyToggleState != InputData->KeyState.KeyToggleState) { RegsiteredData->KeyState.KeyToggleState != InputData->KeyState.KeyToggleState) {
return FALSE; return FALSE;
} }
return TRUE; return TRUE;
} }
@ -219,29 +229,29 @@ Routine Description:
Arguments: Arguments:
Private - The private structure of WinNt Gop device. Private - The private structure of WinNt Gop device.
KeyData - A pointer to a buffer that is filled in with the keystroke KeyData - A pointer to a buffer that is filled in with the keystroke
state data for the key that was pressed. state data for the key that was pressed.
Returns: Returns:
EFI_SUCCESS - The status light is updated successfully. EFI_SUCCESS - The status light is updated successfully.
--*/ --*/
{ {
LIST_ENTRY *Link; LIST_ENTRY *Link;
WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *CurrentNotify; WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *CurrentNotify;
for (Link = Private->NotifyList.ForwardLink; Link != &Private->NotifyList; Link = Link->ForwardLink) { for (Link = Private->NotifyList.ForwardLink; Link != &Private->NotifyList; Link = Link->ForwardLink) {
CurrentNotify = CR ( CurrentNotify = CR (
Link, Link,
WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY, WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY,
NotifyEntry, NotifyEntry,
WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
); );
if (GopPrivateIsKeyRegistered (&CurrentNotify->KeyData, KeyData)) { if (GopPrivateIsKeyRegistered (&CurrentNotify->KeyData, KeyData)) {
CurrentNotify->KeyNotificationFn (KeyData); CurrentNotify->KeyNotificationFn (KeyData);
} }
} }
} }
VOID VOID
@ -299,7 +309,7 @@ GopPrivateAddKey (
} }
if (Private->LeftShift) { if (Private->LeftShift) {
KeyData.KeyState.KeyShiftState |= EFI_LEFT_SHIFT_PRESSED; KeyData.KeyState.KeyShiftState |= EFI_LEFT_SHIFT_PRESSED;
} }
if (Private->RightShift) { if (Private->RightShift) {
KeyData.KeyState.KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED; KeyData.KeyState.KeyShiftState |= EFI_RIGHT_SHIFT_PRESSED;
} }
@ -314,7 +324,7 @@ GopPrivateAddKey (
} }
if (Private->SysReq) { if (Private->SysReq) {
KeyData.KeyState.KeyShiftState |= EFI_SYS_REQ_PRESSED; KeyData.KeyState.KeyShiftState |= EFI_SYS_REQ_PRESSED;
} }
if (Private->CapsLock) { if (Private->CapsLock) {
KeyData.KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE; KeyData.KeyState.KeyToggleState |= EFI_CAPS_LOCK_ACTIVE;
} }
@ -324,11 +334,14 @@ 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]
// //
if ((Private->LeftCtrl || Private->RightCtrl) && if ((Private->LeftCtrl || Private->RightCtrl) &&
(KeyData.Key.UnicodeChar >= 1) && (KeyData.Key.UnicodeChar <= 26) (KeyData.Key.UnicodeChar >= 1) && (KeyData.Key.UnicodeChar <= 26)
) { ) {
if ((Private->LeftShift || Private->RightShift) == Private->CapsLock) { if ((Private->LeftShift || Private->RightShift) == Private->CapsLock) {
@ -382,16 +395,16 @@ Returns:
EFI_SUCCESS - The status light is updated successfully. EFI_SUCCESS - The status light is updated successfully.
--*/ --*/
{ {
// //
// BUGBUG:Only SendInput/keybd_event function can toggle // BUGBUG:Only SendInput/keybd_event function can toggle
// NumLock, CapsLock and ScrollLock keys. // NumLock, CapsLock and ScrollLock keys.
// Neither of these functions is included in EFI_WIN_NT_THUNK_PROTOCOL. // Neither of these functions is included in EFI_WIN_NT_THUNK_PROTOCOL.
// Thus, return immediately without operation. // Thus, return immediately without operation.
// //
return EFI_SUCCESS; return EFI_SUCCESS;
} }
@ -441,11 +454,12 @@ Returns:
Private->RightLogo = FALSE; Private->RightLogo = FALSE;
Private->Menu = FALSE; Private->Menu = FALSE;
Private->SysReq = FALSE; Private->SysReq = FALSE;
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;
@ -465,25 +479,25 @@ GopPrivateReadKeyStrokeWorker (
/*++ /*++
Routine Description: Routine Description:
Reads the next keystroke from the input device. The WaitForKey Event can Reads the next keystroke from the input device. The WaitForKey Event can
be used to test for existance of a keystroke via WaitForEvent () call. be used to test for existance of a keystroke via WaitForEvent () call.
Arguments: Arguments:
Private - The private structure of WinNt Gop device. Private - The private structure of WinNt Gop device.
KeyData - A pointer to a buffer that is filled in with the keystroke KeyData - A pointer to a buffer that is filled in with the keystroke
state data for the key that was pressed. state data for the key that was pressed.
Returns: Returns:
EFI_SUCCESS - The keystroke information was returned. EFI_SUCCESS - The keystroke information was returned.
EFI_NOT_READY - There was no keystroke data availiable. EFI_NOT_READY - There was no keystroke data availiable.
EFI_DEVICE_ERROR - The keystroke information was not returned due to EFI_DEVICE_ERROR - The keystroke information was not returned due to
hardware errors. hardware errors.
EFI_INVALID_PARAMETER - KeyData is NULL. EFI_INVALID_PARAMETER - KeyData is NULL.
--*/ --*/
{ {
EFI_STATUS Status; EFI_STATUS Status;
EFI_TPL OldTpl; EFI_TPL OldTpl;
if (KeyData == NULL) { if (KeyData == NULL) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
@ -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) {
CopyMem (Key, &KeyData.Key, sizeof (EFI_INPUT_KEY)); Status = GopPrivateReadKeyStrokeWorker (Private, &KeyData);
if (EFI_ERROR (Status)) {
return EFI_SUCCESS; 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;
}
} }
@ -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;
@ -612,26 +638,40 @@ WinNtGopSimpleTextInWaitForKey (
// Enter critical section // Enter critical section
// //
OldTpl = gBS->RaiseTPL (TPL_NOTIFY); OldTpl = gBS->RaiseTPL (TPL_NOTIFY);
// //
// Call hot key callback before telling caller there is a key available // Call hot key callback before telling caller there is a key available
// //
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;
} }
// //
@ -667,7 +707,7 @@ WinNtGopSimpleTextInExResetEx (
GOP_PRIVATE_DATA *Private; GOP_PRIVATE_DATA *Private;
Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This); Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This);
return GopPrivateResetWorker (Private); return GopPrivateResetWorker (Private);
} }
@ -680,20 +720,20 @@ WinNtGopSimpleTextInExReadKeyStrokeEx (
/*++ /*++
Routine Description: Routine Description:
Reads the next keystroke from the input device. The WaitForKey Event can Reads the next keystroke from the input device. The WaitForKey Event can
be used to test for existance of a keystroke via WaitForEvent () call. be used to test for existance of a keystroke via WaitForEvent () call.
Arguments: Arguments:
This - Protocol instance pointer. This - Protocol instance pointer.
KeyData - A pointer to a buffer that is filled in with the keystroke KeyData - A pointer to a buffer that is filled in with the keystroke
state data for the key that was pressed. state data for the key that was pressed.
Returns: Returns:
EFI_SUCCESS - The keystroke information was returned. EFI_SUCCESS - The keystroke information was returned.
EFI_NOT_READY - There was no keystroke data availiable. EFI_NOT_READY - There was no keystroke data availiable.
EFI_DEVICE_ERROR - The keystroke information was not returned due to EFI_DEVICE_ERROR - The keystroke information was not returned due to
hardware errors. hardware errors.
EFI_INVALID_PARAMETER - KeyData is NULL. EFI_INVALID_PARAMETER - KeyData is NULL.
--*/ --*/
{ {
@ -704,7 +744,7 @@ WinNtGopSimpleTextInExReadKeyStrokeEx (
} }
Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This); Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This);
return GopPrivateReadKeyStrokeWorker (Private, KeyData); return GopPrivateReadKeyStrokeWorker (Private, KeyData);
} }
@ -722,17 +762,17 @@ WinNtGopSimpleTextInExSetState (
Arguments: Arguments:
This - Protocol instance pointer. This - Protocol instance pointer.
KeyToggleState - A pointer to the EFI_KEY_TOGGLE_STATE to set the KeyToggleState - A pointer to the EFI_KEY_TOGGLE_STATE to set the
state for the input device. state for the input device.
Returns: Returns:
EFI_SUCCESS - The device state was set successfully. EFI_SUCCESS - The device state was set successfully.
EFI_DEVICE_ERROR - The device is not functioning correctly and could EFI_DEVICE_ERROR - The device is not functioning correctly and could
not have the setting adjusted. not have the setting adjusted.
EFI_UNSUPPORTED - The device does not have the ability to set its state. EFI_UNSUPPORTED - The device does not have the ability to set its state.
EFI_INVALID_PARAMETER - KeyToggleState is NULL. EFI_INVALID_PARAMETER - KeyToggleState is NULL.
--*/ --*/
{ {
EFI_STATUS Status; EFI_STATUS Status;
GOP_PRIVATE_DATA *Private; GOP_PRIVATE_DATA *Private;
@ -745,31 +785,35 @@ WinNtGopSimpleTextInExSetState (
if (((Private->KeyState.KeyToggleState & EFI_TOGGLE_STATE_VALID) != EFI_TOGGLE_STATE_VALID) || if (((Private->KeyState.KeyToggleState & EFI_TOGGLE_STATE_VALID) != EFI_TOGGLE_STATE_VALID) ||
((*KeyToggleState & EFI_TOGGLE_STATE_VALID) != EFI_TOGGLE_STATE_VALID)) { ((*KeyToggleState & EFI_TOGGLE_STATE_VALID) != EFI_TOGGLE_STATE_VALID)) {
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;
} }
if ((*KeyToggleState & EFI_NUM_LOCK_ACTIVE) == EFI_NUM_LOCK_ACTIVE) { if ((*KeyToggleState & EFI_NUM_LOCK_ACTIVE) == EFI_NUM_LOCK_ACTIVE) {
Private->NumLock = TRUE; Private->NumLock = TRUE;
} }
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)) {
return EFI_DEVICE_ERROR; return EFI_DEVICE_ERROR;
} }
Private->KeyState.KeyToggleState = *KeyToggleState; Private->KeyState.KeyToggleState = *KeyToggleState;
return EFI_SUCCESS; return EFI_SUCCESS;
} }
EFI_STATUS EFI_STATUS
@ -787,23 +831,23 @@ WinNtGopSimpleTextInExRegisterKeyNotify (
Arguments: Arguments:
This - Protocol instance pointer. This - Protocol instance pointer.
KeyData - A pointer to a buffer that is filled in with the keystroke KeyData - A pointer to a buffer that is filled in with the keystroke
information data for the key that was pressed. information data for the key that was pressed.
KeyNotificationFunction - Points to the function to be called when the key KeyNotificationFunction - Points to the function to be called when the key
sequence is typed specified by KeyData. sequence is typed specified by KeyData.
NotifyHandle - Points to the unique handle assigned to the registered notification. NotifyHandle - Points to the unique handle assigned to the registered notification.
Returns: Returns:
EFI_SUCCESS - The notification function was registered successfully. EFI_SUCCESS - The notification function was registered successfully.
EFI_OUT_OF_RESOURCES - Unable to allocate resources for necesssary data structures. EFI_OUT_OF_RESOURCES - Unable to allocate resources for necesssary data structures.
EFI_INVALID_PARAMETER - KeyData or NotifyHandle is NULL. EFI_INVALID_PARAMETER - KeyData or NotifyHandle is NULL.
--*/ --*/
{ {
GOP_PRIVATE_DATA *Private; GOP_PRIVATE_DATA *Private;
WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *CurrentNotify; WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *CurrentNotify;
LIST_ENTRY *Link; LIST_ENTRY *Link;
WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *NewNotify; WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *NewNotify;
if (KeyData == NULL || KeyNotificationFunction == NULL || NotifyHandle == NULL) { if (KeyData == NULL || KeyNotificationFunction == NULL || NotifyHandle == NULL) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
@ -816,37 +860,37 @@ WinNtGopSimpleTextInExRegisterKeyNotify (
// //
for (Link = Private->NotifyList.ForwardLink; Link != &Private->NotifyList; Link = Link->ForwardLink) { for (Link = Private->NotifyList.ForwardLink; Link != &Private->NotifyList; Link = Link->ForwardLink) {
CurrentNotify = CR ( CurrentNotify = CR (
Link, Link,
WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY, WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY,
NotifyEntry, NotifyEntry,
WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
); );
if (GopPrivateIsKeyRegistered (&CurrentNotify->KeyData, KeyData)) { if (GopPrivateIsKeyRegistered (&CurrentNotify->KeyData, KeyData)) {
if (CurrentNotify->KeyNotificationFn == KeyNotificationFunction) { if (CurrentNotify->KeyNotificationFn == KeyNotificationFunction) {
*NotifyHandle = CurrentNotify->NotifyHandle; *NotifyHandle = CurrentNotify->NotifyHandle;
return EFI_SUCCESS; return EFI_SUCCESS;
} }
} }
} }
// //
// Allocate resource to save the notification function // Allocate resource to save the notification function
// //
NewNotify = (WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *) AllocateZeroPool (sizeof (WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY)); NewNotify = (WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *) AllocateZeroPool (sizeof (WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY));
if (NewNotify == NULL) { if (NewNotify == NULL) {
return EFI_OUT_OF_RESOURCES; return EFI_OUT_OF_RESOURCES;
} }
NewNotify->Signature = WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE; NewNotify->Signature = WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE;
NewNotify->KeyNotificationFn = KeyNotificationFunction; NewNotify->KeyNotificationFn = KeyNotificationFunction;
NewNotify->NotifyHandle = (EFI_HANDLE) NewNotify; NewNotify->NotifyHandle = (EFI_HANDLE) NewNotify;
CopyMem (&NewNotify->KeyData, KeyData, sizeof (EFI_KEY_DATA)); CopyMem (&NewNotify->KeyData, KeyData, sizeof (EFI_KEY_DATA));
InsertTailList (&Private->NotifyList, &NewNotify->NotifyEntry); InsertTailList (&Private->NotifyList, &NewNotify->NotifyEntry);
*NotifyHandle = NewNotify->NotifyHandle; *NotifyHandle = NewNotify->NotifyHandle;
return EFI_SUCCESS; return EFI_SUCCESS;
} }
EFI_STATUS EFI_STATUS
@ -861,14 +905,14 @@ WinNtGopSimpleTextInExUnregisterKeyNotify (
Remove a registered notification function from a particular keystroke. Remove a registered notification function from a particular keystroke.
Arguments: Arguments:
This - Protocol instance pointer. This - Protocol instance pointer.
NotificationHandle - The handle of the notification function being unregistered. NotificationHandle - The handle of the notification function being unregistered.
Returns: Returns:
EFI_SUCCESS - The notification function was unregistered successfully. EFI_SUCCESS - The notification function was unregistered successfully.
EFI_INVALID_PARAMETER - The NotificationHandle is invalid. EFI_INVALID_PARAMETER - The NotificationHandle is invalid.
--*/ --*/
{ {
GOP_PRIVATE_DATA *Private; GOP_PRIVATE_DATA *Private;
LIST_ENTRY *Link; LIST_ENTRY *Link;
@ -876,28 +920,28 @@ WinNtGopSimpleTextInExUnregisterKeyNotify (
if (NotificationHandle == NULL) { if (NotificationHandle == NULL) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
if (((WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *) NotificationHandle)->Signature != WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE) { if (((WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY *) NotificationHandle)->Signature != WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE) {
return EFI_INVALID_PARAMETER; return EFI_INVALID_PARAMETER;
} }
Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This); Private = GOP_PRIVATE_DATA_FROM_TEXT_IN_EX_THIS (This);
for (Link = Private->NotifyList.ForwardLink; Link != &Private->NotifyList; Link = Link->ForwardLink) { for (Link = Private->NotifyList.ForwardLink; Link != &Private->NotifyList; Link = Link->ForwardLink) {
CurrentNotify = CR ( CurrentNotify = CR (
Link, Link,
WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY, WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY,
NotifyEntry, NotifyEntry,
WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE WIN_NT_GOP_SIMPLE_TEXTIN_EX_NOTIFY_SIGNATURE
); );
if (CurrentNotify->NotifyHandle == NotificationHandle) { if (CurrentNotify->NotifyHandle == NotificationHandle) {
// //
// Remove the notification function from NotifyList and free resources // Remove the notification function from NotifyList and free resources
// //
RemoveEntryList (&CurrentNotify->NotifyEntry); RemoveEntryList (&CurrentNotify->NotifyEntry);
gBS->FreePool (CurrentNotify); gBS->FreePool (CurrentNotify);
return EFI_SUCCESS; return EFI_SUCCESS;
} }
} }
@ -941,7 +985,7 @@ WinNtGopInitializeSimpleTextInForWindow (
&Private->SimpleTextIn.WaitForKey &Private->SimpleTextIn.WaitForKey
); );
Private->SimpleTextInEx.Reset = WinNtGopSimpleTextInExResetEx; Private->SimpleTextInEx.Reset = WinNtGopSimpleTextInExResetEx;
Private->SimpleTextInEx.ReadKeyStrokeEx = WinNtGopSimpleTextInExReadKeyStrokeEx; Private->SimpleTextInEx.ReadKeyStrokeEx = WinNtGopSimpleTextInExReadKeyStrokeEx;
Private->SimpleTextInEx.SetState = WinNtGopSimpleTextInExSetState; Private->SimpleTextInEx.SetState = WinNtGopSimpleTextInExSetState;
@ -949,7 +993,7 @@ WinNtGopInitializeSimpleTextInForWindow (
Private->SimpleTextInEx.UnregisterKeyNotify = WinNtGopSimpleTextInExUnregisterKeyNotify; Private->SimpleTextInEx.UnregisterKeyNotify = WinNtGopSimpleTextInExUnregisterKeyNotify;
Private->SimpleTextInEx.Reset (&Private->SimpleTextInEx, FALSE); Private->SimpleTextInEx.Reset (&Private->SimpleTextInEx, FALSE);
InitializeListHead (&Private->NotifyList); InitializeListHead (&Private->NotifyList);
Status = gBS->CreateEvent ( Status = gBS->CreateEvent (
@ -972,7 +1016,7 @@ WinNtGopInitializeSimpleTextInForWindow (
&Private->TimerEvent &Private->TimerEvent
); );
ASSERT_EFI_ERROR (Status); ASSERT_EFI_ERROR (Status);
Status = gBS->SetTimer ( Status = gBS->SetTimer (
Private->TimerEvent, Private->TimerEvent,
TimerPeriodic, TimerPeriodic,

290
Nt32Pkg/WinNtGopDxe/WinNtGopScreen.c
View File

@ -52,106 +52,154 @@ 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
) )
{ {
switch (*wParam) { switch (*wParam) {
// //
// BUGBUG: Only GetAsyncKeyState() and GetKeyState() can distinguish // BUGBUG: Only GetAsyncKeyState() and GetKeyState() can distinguish
// left and right Ctrl, and Shift key. // left and right Ctrl, and Shift key.
// Neither of the two is defined in EFI_WIN_NT_THUNK_PROTOCOL. // Neither of the two is defined in EFI_WIN_NT_THUNK_PROTOCOL.
// 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;
case VK_LWIN: } 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:
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_F2: Key->ScanCode = SCAN_F2; break;
case VK_F3: Key->ScanCode = SCAN_F3; break;
case VK_F4: Key->ScanCode = SCAN_F4; break;
case VK_F5: Key->ScanCode = SCAN_F5; break;
case VK_F6: Key->ScanCode = SCAN_F6; break;
case VK_F7: Key->ScanCode = SCAN_F7; break;
case VK_F8: Key->ScanCode = SCAN_F8; break;
case VK_F9: Key->ScanCode = SCAN_F9; break;
case VK_F11: Key->ScanCode = SCAN_F11; break;
case VK_F12: Key->ScanCode = SCAN_F12; break;
case VK_F13: Key->ScanCode = SCAN_F13; break; case VK_F1: Key->ScanCode = SCAN_F1; Flag = TRUE; break;
case VK_F14: Key->ScanCode = SCAN_F14; break; case VK_F2: Key->ScanCode = SCAN_F2; Flag = TRUE; break;
case VK_F15: Key->ScanCode = SCAN_F15; break; case VK_F3: Key->ScanCode = SCAN_F3; Flag = TRUE; break;
case VK_F16: Key->ScanCode = SCAN_F16; break; case VK_F4: Key->ScanCode = SCAN_F4; Flag = TRUE; break;
case VK_F17: Key->ScanCode = SCAN_F17; break; case VK_F5: Key->ScanCode = SCAN_F5; Flag = TRUE; break;
case VK_F18: Key->ScanCode = SCAN_F18; break; case VK_F6: Key->ScanCode = SCAN_F6; Flag = TRUE; break;
case VK_F19: Key->ScanCode = SCAN_F19; break; case VK_F7: Key->ScanCode = SCAN_F7; Flag = TRUE; break;
case VK_F20: Key->ScanCode = SCAN_F20; break; case VK_F8: Key->ScanCode = SCAN_F8; Flag = TRUE; break;
case VK_F21: Key->ScanCode = SCAN_F21; break; case VK_F9: Key->ScanCode = SCAN_F9; Flag = TRUE; break;
case VK_F22: Key->ScanCode = SCAN_F22; break; case VK_F11: Key->ScanCode = SCAN_F11; Flag = TRUE; break;
case VK_F23: Key->ScanCode = SCAN_F23; break; case VK_F12: Key->ScanCode = SCAN_F12; Flag = TRUE; break;
case VK_F24: Key->ScanCode = SCAN_F24; break;
case VK_PAUSE: Key->ScanCode = SCAN_PAUSE; break; case VK_F13: Key->ScanCode = SCAN_F13; Flag = TRUE; break;
case VK_F14: Key->ScanCode = SCAN_F14; Flag = TRUE; break;
case VK_F15: Key->ScanCode = SCAN_F15; Flag = TRUE; break;
case VK_F16: Key->ScanCode = SCAN_F16; Flag = TRUE; break;
case VK_F17: Key->ScanCode = SCAN_F17; Flag = TRUE; break;
case VK_F18: Key->ScanCode = SCAN_F18; Flag = TRUE; break;
case VK_F19: Key->ScanCode = SCAN_F19; Flag = TRUE; break;
case VK_F20: Key->ScanCode = SCAN_F20; Flag = TRUE; break;
case VK_F21: Key->ScanCode = SCAN_F21; Flag = TRUE; break;
case VK_F22: Key->ScanCode = SCAN_F22; Flag = TRUE; break;
case VK_F23: Key->ScanCode = SCAN_F23; Flag = TRUE; break;
case VK_F24: Key->ScanCode = SCAN_F24; Flag = TRUE; 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);
break; Flag = TRUE;
break;
case VK_CAPITAL: case VK_CAPITAL:
Private->CapsLock = (BOOLEAN)(!Private->CapsLock); Private->CapsLock = (BOOLEAN)(!Private->CapsLock);
break; Flag = TRUE;
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);
@ -689,92 +739,100 @@ WinNtGopThreadWindowProc (
// //
// F10 and the ALT key do not create a WM_KEYDOWN message, thus this special case // F10 and the ALT key do not create a WM_KEYDOWN message, thus this special case
// WM_SYSKEYDOWN is posted when F10 is pressed or // WM_SYSKEYDOWN is posted when F10 is pressed or
// 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_CHAR:
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:
// //
// 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: