able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/base/ntsetup/textmode/kernel/spkbd.c

1170 lines
23 KiB
C
Raw Permalink Normal View History

Add source files
2020-09-26 03:20:57 -05:00
/*++
Copyright (c) 1993 Microsoft Corporation
Module Name:
spkbd.c
Abstract:
Text setup keyboard support routines.
Author:
Ted Miller (tedm) 30-July-1993
Revision History:
--*/
#include "spprecmp.h"
#pragma hdrstop
#include <kbd.h>
#include <ntddkbd.h>
PKBDTABLES KeyboardTable;
HANDLE hKeyboard;
BOOLEAN KeyboardInitialized = FALSE;
BOOLEAN KbdLayoutInitialized = FALSE;
USHORT CurrentLEDs;
//
// Globals for async I/O calls
//
KEYBOARD_INDICATOR_PARAMETERS asyncKbdParams;
IO_STATUS_BLOCK asyncIoStatusBlock;
#define MAX_KEYBOARD_ITEMS 10
VOID
spkbdApcProcedure(
IN PVOID ApcContext,
IN PIO_STATUS_BLOCK IoStatusBlock,
IN ULONG Reserved
);
VOID
spkbdSetLEDs(
VOID
);
VOID
SpkbdInitialize(
VOID
);
VOID
SpkbdTerminate(
VOID
);
VOID
SpkbdLoadLayoutDll(
IN PVOID SifHandle,
IN PWSTR Directory
);
ULONG
SpkbdGetKeypress(
VOID
);
BOOLEAN
SpkbdIsKeyWaiting(
VOID
);
VOID
SpkbdDrain(
VOID
);
//
// Buffer for one character.
//
volatile ULONG KbdNextChar;
//
// The following are used in async calls to NtReadFile and so
// cannot be on the stack.
//
IO_STATUS_BLOCK IoStatusKeyboard;
KEYBOARD_INPUT_DATA KeyboardInputData[MAX_KEYBOARD_ITEMS];
LARGE_INTEGER DontCareLargeInteger;
//
// Current state of shift, control, alt keys.
//
USHORT ModifierBits = 0;
#define START_KEYBOARD_READ() \
\
ZwReadFile( \
hKeyboard, \
NULL, \
spkbdApcProcedure, \
NULL, \
&IoStatusKeyboard, \
KeyboardInputData, \
sizeof(KeyboardInputData), \
&DontCareLargeInteger, \
NULL \
)
VOID
SpInputInitialize(
VOID
)
/*++
Routine Description:
Initialize all input support. This includes
- opening the serial port and checking for a terminal.
- opening the keyboard device.
Arguments:
None.
Return Value:
None. Does not return if not successful.
--*/
{
SpkbdInitialize();
SpTermInitialize();
}
VOID
SpInputTerminate(
VOID
)
/*++
Routine Description:
Terminate all input support. This includes
- closing the serial port.
- closing the keyboard device.
Arguments:
None.
Return Value:
None.
--*/
{
SpkbdTerminate();
SpTermTerminate();
}
VOID
SpInputLoadLayoutDll(
IN PVOID SifHandle,
IN PWSTR Directory
)
{
SpkbdLoadLayoutDll(SifHandle, Directory);
}
ULONG
SpInputGetKeypress(
VOID
)
/*++
Routine Description:
Wait for a keypress and return it to the caller.
The return value will be an ASCII value (ie, not a scan code).
Arguments:
None.
Return Value:
ASCII value.
--*/
{
ULONG Tmp;
//
// If we are in upgrade graphics mode then
// switch to textmode
//
SpvidSwitchToTextmode();
while (TRUE) {
if (SpTermIsKeyWaiting()) {
Tmp = SpTermGetKeypress();
if (Tmp != 0) {
return Tmp;
}
}
if (SpkbdIsKeyWaiting()) {
return SpkbdGetKeypress();
}
}
}
BOOLEAN
SpInputIsKeyWaiting(
VOID
)
/*++
Routine Description:
Tell the caller if a keypress is waiting to be fetched by
a call to SpInputGetKeypress().
Arguments:
None.
Return Value:
TRUE is key waiting; FALSE otherwise.
--*/
{
return (SpTermIsKeyWaiting() || SpkbdIsKeyWaiting());
}
VOID
SpInputDrain(
VOID
)
{
SpTermDrain();
SpkbdDrain();
}
//
//
// Below here are all the functions for keyboard operations...
//
//
VOID
SpkbdInitialize(
VOID
)
/*++
Routine Description:
Initialize keyboard support. This includes
- opening the keyboard device.
Arguments:
None.
Return Value:
None. Does not return if not successful.
--*/
{
NTSTATUS Status;
OBJECT_ATTRIBUTES Attributes;
IO_STATUS_BLOCK IoStatusBlock;
UNICODE_STRING UnicodeString;
ASSERT(!KeyboardInitialized);
if(KeyboardInitialized) {
return;
}
//
// Open the keyboard.
//
RtlInitUnicodeString(&UnicodeString,DD_KEYBOARD_DEVICE_NAME_U L"0");
InitializeObjectAttributes(
&Attributes,
&UnicodeString,
OBJ_CASE_INSENSITIVE,
NULL,
NULL
);
Status = ZwCreateFile(
&hKeyboard,
GENERIC_READ | SYNCHRONIZE | FILE_READ_ATTRIBUTES,
&Attributes,
&IoStatusBlock,
NULL, // allocation size
FILE_ATTRIBUTE_NORMAL,
0, // no sharing
FILE_OPEN,
0,
NULL, // no EAs
0
);
if(!NT_SUCCESS(Status)) {
KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: NtOpenFile of " DD_KEYBOARD_DEVICE_NAME "0 returns %lx\n",Status));
SpFatalKbdError(SP_SCRN_KBD_OPEN_FAILED);
}
//
// Initialize LEDs.
//
//
// No NEC98 has NumLock and NumLock LED.
// Num keys must be act as Numlock alternated keys.
//
CurrentLEDs = (!IsNEC_98 ? 0 : KEYBOARD_NUM_LOCK_ON);
spkbdSetLEDs();
KeyboardInitialized = TRUE;
//
// Do not initialize keyboard input yet because we don't have a layout.
//
}
VOID
SpkbdTerminate(
VOID
)
/*++
Routine Description:
Terminate keyboard support. This includes
- closing the keyboard device.
Arguments:
None.
Return Value:
None.
--*/
{
NTSTATUS Status;
ASSERT(KeyboardInitialized);
if(KeyboardInitialized) {
Status = ZwClose(hKeyboard);
if(!NT_SUCCESS(Status)) {
KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Unable to close " DD_KEYBOARD_DEVICE_NAME "0 (status = %lx)\n",Status));
}
KeyboardInitialized = FALSE;
}
}
VOID
SpkbdLoadLayoutDll(
IN PVOID SifHandle,
IN PWSTR Directory
)
{
PWSTR p,LayoutDll;
NTSTATUS Status;
//
// Determine layout name.
//
if(p = SpGetSectionKeyIndex(SifHandle,SIF_NLS,SIF_DEFAULTLAYOUT,1)) {
LayoutDll = p;
} else {
p = SpGetSectionKeyIndex(SifHandle,SIF_NLS,SIF_DEFAULTLAYOUT,0);
if(!p) {
SpFatalSifError(SifHandle,SIF_NLS,SIF_DEFAULTLAYOUT,0,0);
}
LayoutDll = SpGetSectionKeyIndex(SifHandle,SIF_KEYBOARDLAYOUTFILES,p,0);
if(!LayoutDll) {
SpFatalSifError(SifHandle,SIF_KEYBOARDLAYOUTFILES,p,0,0);
}
}
SpDisplayStatusText(SP_STAT_LOADING_KBD_LAYOUT,DEFAULT_STATUS_ATTRIBUTE,LayoutDll);
//
// Bugcheck if we can't load the layout dll, because we won't be able
// to put up a screen and ask the user to hit f3, etc.
//
Status = SpLoadKbdLayoutDll(Directory,LayoutDll,&KeyboardTable);
if(!NT_SUCCESS(Status)) {
KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Unable to load layout dll %ws (%lx)\n",LayoutDll,Status));
SpFatalKbdError(SP_SCRN_KBD_LAYOUT_FAILED, LayoutDll);
}
//
// Erase status text line.
//
SpDisplayStatusOptions(DEFAULT_STATUS_ATTRIBUTE,0);
//
// Now that we've loaded the layout, we can start accepting keyboard input.
//
START_KEYBOARD_READ();
KbdLayoutInitialized = TRUE;
}
ULONG
SpkbdGetKeypress(
VOID
)
/*++
Routine Description:
Wait for a keypress and return it to the caller.
The return value will be an ASCII value (ie, not a scan code).
Arguments:
None.
Return Value:
ASCII value.
--*/
{
ULONG k;
//
// Shouldn't be calling this until we have loaded a keyboard layout.
//
ASSERT(KeyboardTable);
//
// Wait for the user to press a key.
//
while(!KbdNextChar) {
;
}
k = KbdNextChar;
KbdNextChar = 0;
return(k);
}
BOOLEAN
SpkbdIsKeyWaiting(
VOID
)
/*++
Routine Description:
Tell the caller if a keypress is waiting to be fetched by
a call to SpkbdGetKeypress().
Arguments:
None.
Return Value:
TRUE is key waiting; FALSE otherwise.
--*/
{
//
// Shouldn't be calling this until we have loaded a keyboard layout.
//
ASSERT(KeyboardTable);
return((BOOLEAN)(KbdNextChar != 0));
}
VOID
SpkbdDrain(
VOID
)
/*++
Routine Description:
Drain the keyboard buffer, throwing away any keystrokes
in the buffer waiting to be fetched.
Arguments:
None.
Return Value:
TRUE is key waiting; FALSE otherwise.
--*/
{
ASSERT(KeyboardTable);
KbdNextChar = 0;
}
ULONG
spkbdScanCodeToChar(
IN UCHAR Prefix,
IN USHORT ScanCode,
IN BOOLEAN Break
);
VOID
spkbdApcProcedure(
IN PVOID ApcContext,
IN PIO_STATUS_BLOCK IoStatusBlock,
IN ULONG Reserved
)
/*++
Routine Description:
Async Procedure Call routine for keyboard reads. The I/O
system will call this routine when the keyboard class driver
wants to return some data to us.
Arguments:
Return Value:
None.
--*/
{
UCHAR bPrefix;
PKEYBOARD_INPUT_DATA pkei;
ULONG k;
UNREFERENCED_PARAMETER(ApcContext);
UNREFERENCED_PARAMETER(Reserved);
for(pkei = KeyboardInputData;
(PUCHAR)pkei < (PUCHAR)KeyboardInputData + IoStatusBlock->Information;
pkei++)
{
if(pkei->Flags & KEY_E0) {
bPrefix = 0xE0;
} else if (pkei->Flags & KEY_E1) {
bPrefix = 0xE1;
} else {
bPrefix = 0;
}
k = spkbdScanCodeToChar(
bPrefix,
pkei->MakeCode,
(BOOLEAN)((pkei->Flags & KEY_BREAK) != 0)
);
if(k) {
KbdNextChar = k;
}
}
//
// Keyboard might have been terminated.
//
if(KeyboardInitialized) {
START_KEYBOARD_READ();
}
}
WCHAR SavedDeadChar = 0;
UCHAR AltNumpadAccum = 0;
struct {
BYTE CursorKey;
BYTE NumberKey;
BYTE Value;
} NumpadCursorToNumber[] = { { VK_INSERT, VK_NUMPAD0, 0 },
{ VK_END , VK_NUMPAD1, 1 },
{ VK_DOWN , VK_NUMPAD2, 2 },
{ VK_NEXT , VK_NUMPAD3, 3 },
{ VK_LEFT , VK_NUMPAD4, 4 },
{ VK_CLEAR , VK_NUMPAD5, 5 },
{ VK_RIGHT , VK_NUMPAD6, 6 },
{ VK_HOME , VK_NUMPAD7, 7 },
{ VK_UP , VK_NUMPAD8, 8 },
{ VK_PRIOR , VK_NUMPAD9, 9 },
{ VK_DELETE, VK_DECIMAL, 10 }, // no value.
{ 0 , 0 , 0 }
};
ULONG
spkbdScanCodeToChar(
IN UCHAR Prefix,
IN USHORT ScanCode,
IN BOOLEAN Break
)
{
USHORT VKey = 0;
PVSC_VK VscVk;
PVK_TO_WCHAR_TABLE pVKT;
PVK_TO_WCHARS1 pVK;
USHORT Modifier;
USHORT ModBits,ModNum;
WCHAR deadChar;
ScanCode &= 0x7f;
if(Prefix == 0) {
if(ScanCode < KeyboardTable->bMaxVSCtoVK) {
//
// Index directly into non-prefix scan code table.
//
VKey = KeyboardTable->pusVSCtoVK[ScanCode];
if(VKey == 0) {
KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Unknown scan code 0x%x\n",ScanCode));
return (0);
}
} else {
KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Unknown scan code 0x%x\n",ScanCode));
return(0);
}
} else {
if(Prefix == 0xe0) {
//
// Ignore the SHIFT keystrokes generated by the hardware
//
if((ScanCode == SCANCODE_LSHIFT) || (ScanCode == SCANCODE_RSHIFT)) {
return(0);
}
VscVk = KeyboardTable->pVSCtoVK_E0;
} else if(Prefix == 0xe1) {
VscVk = KeyboardTable->pVSCtoVK_E1;
} else {
KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Unknown keyboard scan prefix 0x%x\n",Prefix));
return(0);
}
while(VscVk->Vk) {
if(VscVk->Vsc == ScanCode) {
VKey = VscVk->Vk;
break;
}
VscVk++;
}
if(VKey == 0) {
KdPrintEx((DPFLTR_SETUP_ID, DPFLTR_ERROR_LEVEL, "SETUP: Unknown keyboard scan prefix/code 0x%x/0x%x\n",Prefix,ScanCode));
return(0);
}
}
//
// VirtualKey --> modifier bits. This translation is also
// mapped out in the pCharModifiers field in the keyboard layout
// table but that seems redundant.
//
Modifier = 0;
switch(VKey & 0xff) {
case VK_LSHIFT:
case VK_RSHIFT:
Modifier = KBDSHIFT;
break;
case VK_LCONTROL:
case VK_RCONTROL:
Modifier = KBDCTRL;
break;
case VK_RMENU:
//
// AltGr ==> control+alt modifier.
//
if(KeyboardTable->fLocaleFlags & KLLF_ALTGR) {
Modifier = KBDCTRL;
}
// fall through
case VK_LMENU:
Modifier |= KBDALT;
break;
}
if(Break) {
//
// Key is being released.
// If it's not a modifer, ignore it.
//
if(!Modifier) {
return(0);
}
//
// Key being released is a modifier.
//
ModifierBits &= ~Modifier;
//
// If it's ALT going up and we have a numpad key being entered,
// return it.
//
if((Modifier & KBDALT) && AltNumpadAccum) {
WCHAR UnicodeChar;
RtlOemToUnicodeN(
&UnicodeChar,
sizeof(UnicodeChar),
NULL,
&AltNumpadAccum,
1
);
AltNumpadAccum = 0;
return(UnicodeChar);
}
return(0);
} else {
if(Modifier) {
//
// Key is being pressed and is a modifier.
//
ModifierBits |= Modifier;
//
// If ALT is going down, reset alt+numpad value.
//
if(Modifier & KBDALT) {
AltNumpadAccum = 0;
}
return(0);
}
}
//
// If we get here, we've got a non-modifier key being made (pressed).
// If the previous key was a dead key, the user gets only
// one try to get a valid second half.
//
deadChar = SavedDeadChar;
SavedDeadChar = 0;
//
// Special processing if the key is a numeric keypad key.
//
if(VKey & KBDNUMPAD) {
int i;
for(i=0; NumpadCursorToNumber[i].CursorKey; i++) {
if(NumpadCursorToNumber[i].CursorKey == (BYTE)VKey) {
//
// Key is a numeric keypad key. If ALT (and only alt) is down,
// then we have an alt+numpad code being entered.
//
if(((ModifierBits & ~KBDALT) == 0) && (NumpadCursorToNumber[i].Value < 10)) {
AltNumpadAccum = (AltNumpadAccum * 10) + NumpadCursorToNumber[i].Value;
}
//
// If numlock is on, translate the key from cursor movement
// to a number key.
//
if(CurrentLEDs & KEYBOARD_NUM_LOCK_ON) {
VKey = NumpadCursorToNumber[i].NumberKey;
}
break;
}
}
}
//
// We need to filter out keystrokes that we know are not part of any
// character set here.
//
if((!deadChar)) {
switch(VKey & 0xff) {
case VK_CAPITAL:
if(CurrentLEDs & KEYBOARD_CAPS_LOCK_ON) {
CurrentLEDs &= ~KEYBOARD_CAPS_LOCK_ON;
} else {
CurrentLEDs |= KEYBOARD_CAPS_LOCK_ON;
}
spkbdSetLEDs();
return(0);
case VK_NUMLOCK:
if(CurrentLEDs & KEYBOARD_NUM_LOCK_ON) {
CurrentLEDs &= ~KEYBOARD_NUM_LOCK_ON;
} else {
CurrentLEDs |= KEYBOARD_NUM_LOCK_ON;
}
spkbdSetLEDs();
return(0);
case VK_PRIOR:
return(KEY_PAGEUP);
case VK_NEXT:
return(KEY_PAGEDOWN);
case VK_UP:
return(KEY_UP);
case VK_DOWN:
return(KEY_DOWN);
case VK_LEFT:
return(KEY_LEFT);
case VK_RIGHT:
return(KEY_RIGHT);
case VK_HOME:
return(KEY_HOME);
case VK_END:
return(KEY_END);
case VK_INSERT:
return(KEY_INSERT);
case VK_DELETE:
return(KEY_DELETE);
case VK_F1:
return(KEY_F1);
case VK_F2:
return(KEY_F2);
case VK_F3:
return(KEY_F3);
case VK_F4:
return(KEY_F4);
case VK_F5:
return(KEY_F5);
case VK_F6:
return(KEY_F6);
case VK_F7:
return(KEY_F7);
case VK_F8:
return(KEY_F8);
case VK_F9:
return(KEY_F9);
case VK_F10:
return(KEY_F10);
case VK_F11:
return(KEY_F11);
case VK_F12:
return(KEY_F12);
}
}
//
// We think the character is probably a 'real' character.
// Scan through all the shift-state tables until a matching Virtual
// Key is found.
//
for(pVKT = KeyboardTable->pVkToWcharTable; pVKT->pVkToWchars; pVKT++) {
pVK = pVKT->pVkToWchars;
while(pVK->VirtualKey) {
if(pVK->VirtualKey == (BYTE)VKey) {
goto VK_Found;
}
pVK = (PVK_TO_WCHARS1)((PBYTE)pVK + pVKT->cbSize);
}
}
//
// Key is not valid with requested modifiers.
//
return(0);
VK_Found:
ModBits = ModifierBits;
//
// If CapsLock affects this key and it is on: toggle SHIFT state
// only if no other state is on.
// (CapsLock doesn't affect SHIFT state if Ctrl or Alt are down).
//
if((pVK->Attributes & CAPLOK) && ((ModBits & ~KBDSHIFT) == 0)
&& (CurrentLEDs & KEYBOARD_CAPS_LOCK_ON))
{
ModBits ^= KBDSHIFT;
}
//
// Get the modification number.
//
if(ModBits > KeyboardTable->pCharModifiers->wMaxModBits) {
return(0); // invalid keystroke
}
ModNum = KeyboardTable->pCharModifiers->ModNumber[ModBits];
if(ModNum == SHFT_INVALID) {
return(0); // invalid keystroke
}
if(ModNum >= pVKT->nModifications) {
//
// Key is not valid with current modifiers.
// Could still be a control char that we can convert directly.
//
if((ModBits == KBDCTRL) || (ModBits == (KBDCTRL | KBDSHIFT))) {
if(((UCHAR)VKey >= 'A') && ((UCHAR)VKey <= 'Z')) {
return((ULONG)VKey & 0x1f);
}
}
return(0); // invalid keystroke
}
if(pVK->wch[ModNum] == WCH_NONE) {
return(0);
}
if((pVK->wch[ModNum] == WCH_DEAD)) {
if(!deadChar) {
//
// Remember the current dead character, whose value follows
// the current entry in the modifier mapping table.
//
SavedDeadChar = ((PVK_TO_WCHARS1)((PUCHAR)pVK + pVKT->cbSize))->wch[ModNum];
}
return(0);
}
//
// The keyboard layout table contains some dead key mappings.
// If previous key was a dead key, attempt to compose it with the
// current character by scanning the keyboard layout table for a match.
//
if(deadChar) {
ULONG chr;
PDEADKEY DeadKeyEntry;
chr = MAKELONG(pVK->wch[ModNum],deadChar);
if(DeadKeyEntry = KeyboardTable->pDeadKey) {
while(DeadKeyEntry->dwBoth) {
if(DeadKeyEntry->dwBoth == chr) {
//
// Got a match. Return the composed character.
//
return((ULONG)DeadKeyEntry->wchComposed);
}
DeadKeyEntry++;
}
}
//
// If we get here, then the previous key was a dead char,
// but the current key could not be composed with it.
// So return nothing. Note that the dead key has been forgotten.
//
return(0);
}
return((ULONG)pVK->wch[ModNum]);
}
VOID
spkbdSetLEDs(
VOID
)
{
asyncKbdParams.UnitId = 0;
asyncKbdParams.LedFlags = CurrentLEDs;
ZwDeviceIoControlFile(
hKeyboard,
NULL,
NULL,
NULL,
&asyncIoStatusBlock,
IOCTL_KEYBOARD_SET_INDICATORS,
&asyncKbdParams,
sizeof(asyncKbdParams),
NULL,
0
);
}
VOID
SpSelectAndLoadLayoutDll(
IN PWSTR Directory,
IN PVOID SifHandle,
IN BOOLEAN ShowStatus
)
/*++
Routine Description:
Allows the user to select a keyboard layout DLL and loads it.
Arguments:
Directory - The setup startup directory
SifHandle - Handle to txtsetup.sif
ShowStatus - Whether status should be displayed or not
Return Value:
None
--*/
{
ULONG SelectedLayout;
ULONG DefLayout = -1;
PWSTR TempPtr = 0;
PWSTR LayoutDll = 0;
NTSTATUS Status;
//
// Get the default layout (index)
//
TempPtr = SpGetSectionKeyIndex(SifHandle, SIF_NLS, SIF_DEFAULTLAYOUT, 0);
if(!TempPtr) {
SpFatalSifError(SifHandle, SIF_NLS, SIF_DEFAULTLAYOUT, 0, 0);
}
DefLayout = SpGetKeyIndex(SifHandle, SIF_KEYBOARDLAYOUTDESC, TempPtr);
if(DefLayout == -1) {
SpFatalSifError(SifHandle, SIF_NLS, SIF_DEFAULTLAYOUT, 0, 0);
}
SelectedLayout = -1;
//
// Let the user select the layout which he wants
//
if (SpSelectSectionItem(SifHandle, SIF_KEYBOARDLAYOUTDESC,
SP_SELECT_KBDLAYOUT, DefLayout, &SelectedLayout)) {
//
// Load the layout if its not already loaded
//
if (DefLayout != SelectedLayout) {
//
// get the key
//
TempPtr = SpGetKeyName(SifHandle, SIF_KEYBOARDLAYOUTDESC, SelectedLayout);
if (TempPtr) {
//
// get the KDB layout dll name
//
LayoutDll = SpGetSectionKeyIndex(SifHandle, SIF_KEYBOARDLAYOUTFILES,
TempPtr, 0);
if (LayoutDll) {
if (ShowStatus) {
SpDisplayStatusText(SP_STAT_LOADING_KBD_LAYOUT,
DEFAULT_STATUS_ATTRIBUTE, LayoutDll);
}
//
// Load the new KDB layout dll
//
Status = SpLoadKbdLayoutDll(Directory, LayoutDll, &KeyboardTable);
}
else
Status = STATUS_INVALID_PARAMETER;
if (!NT_SUCCESS(Status)) {
CLEAR_ENTIRE_SCREEN();
SpFatalKbdError(SP_SCRN_KBD_LAYOUT_FAILED, LayoutDll);
} else {
if (ShowStatus) {
//
// Erase status text line.
//
SpDisplayStatusOptions(DEFAULT_STATUS_ATTRIBUTE, 0);
}
//
// Now that we've loaded the layout,
// we can start accepting keyboard input.
//
START_KEYBOARD_READ();
KbdLayoutInitialized = TRUE;
}
} else {
CLEAR_ENTIRE_SCREEN();
SpFatalSifError(SifHandle, SIF_KEYBOARDLAYOUTDESC, 0, 0, 0);
}
}
}
}
Reference in a new issue Copy permalink