path: root/private/os2/os2ses/kbdrqust.c

/*++

Copyright (c) 1989  Microsoft Corporation

Module Name:

    kbdrqust.c

Abstract:

    This module contains the Kbd requests thread and
    the handler for Kbd requests.

Author:

    Michael Jarus (mjarus) 23-Oct-1991

Environment:

    User Mode Only

Revision History:

--*/

#define WIN32_ONLY
#include "os2ses.h"
#include "trans.h"
#include "event.h"
#include "kbd.h"
#include "os2win.h"
#include <stdio.h>

#define OS2_SCAN_INSERT_0         0x52
#define OS2_SCAN_END_1            0x4F
#define OS2_SCAN_CTRL_END_1       0x75
#define OS2_SCAN_DOWN_2           0x50
#define OS2_SCAN_LEFT_4           0x4B
#define OS2_SCAN_CTRL_LEFT_4      0x73
#define OS2_SCAN_RIGHT_6          0x4D
#define OS2_SCAN_CTRL_RIGHT_6     0x74
#define OS2_SCAN_HOME_7           0x47
#define OS2_SCAN_CTRL_HOME_7      0x77
#define OS2_SCAN_UP_8             0x48
#define OS2_SCAN_DEL              0x53

DWORD
Ow2GetOs2KbdEventIntoQueue();

DWORD
Ow2VioUpdateCurPos(
    IN  COORD  CurPos
    );

DWORD
Ow2VioReadCurPos(
    );

DWORD
Ow2VioReadCurType();

VOID
KbdSetTable(
    IN ULONG KbdCP
    );

#if DBG
BYTE KbdEchoCharToConsoleStr[] = "KbdEchoCharToConsole";
BYTE KbdEchoCharStr[] = "KbdEchoChar";
BYTE KbdEchoStringToConsoleStr[] = "KbdEchoStringToConsole";
BYTE KbdEchoAStringStr[] = "KbdEchoAString";
BYTE KbdEchoBSAndFillSpacesStr[] = "KbdEchoBSAndFillSpaces";
BYTE KbdEchoESCStr[] = "KbdEchoESC";
BYTE KbdCueMoveToRightStr[] = "KbdCueMoveToRight";
#endif

#define KEYBOARD_NEW_MASK (USHORT)(KEYBOARD_2B_TURNAROUND | KEYBOARD_SHIFT_REPORT)
#define KEYBOARD_ECHO     (USHORT)(KEYBOARD_ECHO_ON | KEYBOARD_ECHO_OFF)
#define KEYBOARD_INPUT    (USHORT)(KEYBOARD_ASCII_MODE | KEYBOARD_BINARY_MODE)

#define KEYBOARD_BINARY_SHIFT (KEYBOARD_BINARY_MODE | KEYBOARD_SHIFT_REPORT)
#define MODE_BINARY_SHIFT     (SHIFT_REPORT_MODE | BINARY_MODE)

#define KEYBOARD_SHIFT_ASCII_INPUT    (USHORT)(KEYBOARD_ASCII_MODE | KEYBOARD_SHIFT_REPORT)
#define KEYBOARD_INPUT_RESERVED                                                      \
    ~( KEYBOARD_ECHO_ON | KEYBOARD_ECHO_OFF | KEYBOARD_BINARY_MODE |                 \
       KEYBOARD_ASCII_MODE | KEYBOARD_MODIFY_STATE | KEYBOARD_MODIFY_INTERIM |       \
       KEYBOARD_MODIFY_TURNAROUND | KEYBOARD_2B_TURNAROUND | KEYBOARD_SHIFT_REPORT )

#define KbdBuffSize 256
#define KBD_BUFFER_ADDRESS ((PUCHAR)KbdAddress)     // used for ECHO to console
#define KBD_BUFFER_SIZE    OS2_KBD_PORT_MSG_SIZE

#define ALPHANUM_CHAR(BuffIndex)                                \
        ((((Char = LineInputBuff[BuffIndex].Char) >= '0') &&    \
                           (Char <= '9')) ||                    \
         ((Char >= 'a') && (Char <= 'z')) ||                    \
         ((Char >= 'A') && (Char <= 'Z')))                      \

#define GET_CURRENT_COORD (SesGrp->WinCoord)

typedef struct  _LINE_EDIT_KBD
{
    UCHAR       Char;
    SHORT       X_Pos;      // Used as X Coordinate for edit
                            // Used as offset for CUE
} LINE_EDIT_KBD;

typedef enum
{
    CharMode,
    AsciiMode,
    BinaryMode
} KBDMODE;

//CONSOLE_SCREEN_BUFFER_INFO KbdConsoleInfo;
KBDMODE     KbdState;               // state for HandleKeyboardInput
ULONG       KbdWaitFlag;            // flags for KbdCheckPackage and
                                    //    arg to GetKeyboardInput
/* (from event.h)
                                   CharIn    Peek    String    Read
                                   ------    ----    ------    ----
   WAIT_MASK             0x01     User    NOWAIT    User     WAIT  (0 IO_WAIT, 1 IO_NOWAIT)
   ENABLE_SHIFT_KEY      0x02   <if SHIFT report>
   ENABLE_NON_ASCII_KEY  0x04      +        +        <if BINARY>
   ENABLE_LN_EDITOR_KEY  0x08                        <if ASCII (for KEYS OFF)>
   ENABLE_KEYS_ON_KEY    0x10                        <if ASCII and KEYS ON>
 */

#define  ENABLE_SHIFT_KEY      0x02   /* enable shift report keys (and break for them) */

/*
 *  for Command line editing
 */

PUCHAR      KbdCueBuffer = NULL;    // 64K CUE buffer for KEYS ON
                                    // This is a cyclic bufffer and all
                                    // pointers are index of type USHORT.
BOOL        KbdLineWasEdited;       // TRUE if user edited the current line
USHORT      KbdNextLinePointer;     // where to put next input line
USHORT      KbdCurrentLine;         // index of current line in KbdCueBuffer
USHORT      KbdIndexInLine;         // index of current char in input line
BOOL        KbdCueUpRowIsCurrent;   // flag set after CR to indicate UP arrow
                                    // returns the current line

/*
 * for GetOs2KbdRead
 */

USHORT      KbdBuffNextPtr;         // when string typed was longer the size (ASCII read only)
                                    // it points to the remain string
USHORT      KbdBuffNextLen;         // remaining bytes in the string

/*
 * for for HandleKeyboardInput.CharMode:
 */

BOOL        KbdPeekFlag;            // called by CharIn (0) or Peek(1)

/*
 * for for HandleKeyboardInput.Ascii/BinaryMode:
 */

USHORT      KbdInputLength;         // the current string length (num of chars
                                    // already in input buffer for the user)
ULONG       KbdMaxLength;           // maximun input length (String.cb
                                    // for StringIn, KbdBuffSize for Read)
USHORT      KbdLength;              // On enter: the requested length,
                                    // On exit: the returned string length
USHORT      KbdEndLength;           // length of Turn Around string

/*
 * for for HandleKeyboardInput.AsciiMode:
 */

LINE_EDIT_KBD   LineInputBuff[KbdBuffSize];  // the current input buffer
UCHAR       KbdLastBuff[KbdBuffSize];   // holds the previous "Buff"
USHORT      KbdLastBuffPtr;         // points to the char in KbdLastBuff to take (if F1)
USHORT      LastStringLength;       // length of the previous "Buff"
USHORT      KbdEditFlag;            // support EDIT line (F1 .. F4, ->, <-, Ins, Del)
USHORT      KbdReadMode;            // called by StringIn (0) or Read(1)
USHORT      KbdFxWaitForChar;       // waiting for char after F2(1) or F4(2)
BOOL        KbdEchoFlag;            // set if ECHO ON
BOOL        KbdInsertOn;            // INSERT key current state (1 - ON)
BOOL        KbdEchoString;          // copy string from last buffer (F2 and F3)
USHORT      KbdTurnAroundChar;      // turn around char to look for
BOOLEAN     KbdTurnAroundCharTwo;   // 2-byte turn around char (KEYBOARD_2B_TURNAROUND)
USHORT      KbdDelIndex;
SHORT       KbdFirstColumn;         // first column for this input request
SHORT       KbdStartOfLine;         // first column on this line

BOOLEAN     KbdSetupTurnAroundCharTwo;  // KbsSetStatus of KbdTurnAroundCharTwo:
                                        // before new read KbdTurnAroundCharTwo
                                        // is updated from this.

#ifdef JAPAN
// MSKK May.07.1993 V-AkihiS
/*
 * for KBDGetKbdType
 */
extern USHORT KbdType, KbdSubType;
extern BYTE OemId, OemSubType;
#endif

/*
 * internal functions
 */

DWORD
GetOs2KbdKey(
    IN  BOOL        PeekFlag,
    IN  USHORT      WaitFlag,
    OUT PKBDKEYINFO KeyInfo,
    IN  PVOID       pMsg,
    OUT PULONG      pReply
    );

DWORD
GetOs2KbdString(
    IN     USHORT       WaitFlag,
    IN OUT PKBDREQUEST  PReq,
    IN     PVOID        pMsg,
    OUT    PULONG       pReply
    );

DWORD
GetOs2KbdRead(
    IN PULONG   Length,
    IN  PVOID   pMsg,
    OUT PULONG  pReply
    );

VOID
KbdNewSetup(
    IN PKBDINFO LastSetup
    );

DWORD
GetOs2KbdStringRead(
    IN      USHORT  WaitFlag,
    IN      USHORT  EditFlag,
    IN      USHORT  ReadMode,
    IN      ULONG   MaxLength,
    IN OUT  PUSHORT Length,
    IN      PVOID   pMsg,
    OUT     PULONG  pReply
    );

DWORD
HandleKeyboardInput(
    IN  PKEYEVENTINFO   pKbd
    );

DWORD
Ow2KbdSetStatus(
    IN  PKBDREQUEST     PReq
    );

BOOL
KbdKeyIsTurnAround(
    IN  UCHAR   Char,
    IN  UCHAR   Scan
    );

/*
 *   Echo functions for KbdStringIn/Read (ASCII)
 */

DWORD
KbdEchoNL(
    IN ULONG    Count
    );

DWORD
KbdEchoESC(
    IN ULONG    Count,
    IN ULONG    HorzMove
    );

DWORD
KbdEchoBSAndFillSpaces(
    IN ULONG    BSCount,
    IN ULONG    SpaceCount
    );

DWORD
KbdEchoBeep(
    IN ULONG    Count
    );

DWORD
KbdEchoChar(
    IN UCHAR    Char,
    IN ULONG    Count
    );

DWORD
KbdEchoAString(
    IN PUCHAR   String,
    IN ULONG    Length
    );

/*
 *  CUE functions
 */

VOID
KbdCueEraseAndDisplayLine(
    IN ULONG    NewLineIndex
    );

VOID
KbdCueMoveToRight(
    IN  ULONG   StartIndex,
    IN  ULONG   StringLength,
    IN  ULONG   UpdateLVB
    );

VOID
KbdCueMoveToLeft(
    IN  ULONG   StartIndex,
    IN  ULONG   MoveLength
    );

VOID
KbdCueUpdateBufferOffset(
    IN  ULONG   StartIndex,
    IN  ULONG   StringLength,
    IN  ULONG   StartOffset
    );

VOID
KbdCueDeleteCharAndShift(
    IN  ULONG   StartIndex,
    IN  ULONG   NumChar
    );

VOID
KbdCueHandleChar(
    IN  UCHAR       Char,
    IN  ULONG       Count
    );

VOID
KbdCueSetCurTypeToHalf();

VOID
KbdCueSetCurTypeToQuater();


DWORD
KbdInit(IN VOID)
{
    KBDINFO     LastSetup;

    if (InitQueue(&KbdQueue))
    {
        return(TRUE);
    }

    KbdMonQueue = PhyKbdQueue = KbdQueue;

    KbdQueue->Setup.cb = sizeof(KBDINFO);
    KbdQueue->Setup.fsMask = KEYBOARD_ECHO_ON | KEYBOARD_ASCII_MODE;
    KbdQueue->Setup.chTurnAround = 0x0D;  /* default: <ENTER>/<CR> */
    KbdQueue->Setup.fsInterim = 0;
    KbdQueue->Setup.fsState = 0;
    KbdQueue->bNlsShift = 0;
    KbdQueue->LastKeyFlag = FALSE;

    LastSetup.fsMask = KEYBOARD_BINARY_MODE;
    KbdNewSetup(&LastSetup);

    KbdAddress = ((PCHAR)Os2SessionCtrlDataBaseAddress) + KBD_OFFSET;

    Ow2KbdXlateVars.OtherFlags = InterruptTime;

    return(FALSE);
}


DWORD
KbdInitAfterSesGrp(IN VOID)
{
    if (SesGrp->KeysOnFlag)
    {
        KbdCueBuffer = HeapAlloc(HandleHeap, 0, 64 * 1024);
        if ( KbdCueBuffer == NULL )
        {
#if DBG
            KdPrint(("OS2SES(KbdRequset): unable to allocate Cue buffer\n"));
#endif
            return ERROR_KBD_NO_MORE_HANDLE;
        }
    }
    return(FALSE);
}


BOOL
ServeKbdRequest(IN  PKBDREQUEST     PReq,
                OUT PVOID           PStatus,
                IN  PVOID           pMsg,
                OUT PULONG          pReply)
{
    DWORD               Rc;
    KBDINFO             LastSetup;
    PKEY_EVENT_QUEUE    TempKbdQueue;
    KEYEVENTINFO        In;

    Rc = 0;
    TempKbdQueue = (PKEY_EVENT_QUEUE) PReq->hKbd;

#if DBG
    if (( PReq->Request != KBDNewFocus ) &&
        ( PReq->Request != KBDNewCountry ) &&
        ( PReq->Request != KBDOpen ) &&
        (KbdQueue != TempKbdQueue))
    {
        KdPrint(("OS2SES(KbdRequest-%u): illegal handle\n",
                PReq->Request));
    }
#endif

    switch (PReq->Request)
    {
        case KBDOpen:
            if((Rc = InitQueue(&TempKbdQueue)) == NO_ERROR)
            {
                PReq->hKbd = TempKbdQueue;
            }
            break;

        case KBDClose:
            if (( TempKbdQueue != PhyKbdQueue) && TempKbdQueue->Count )
            {
                if ( !--TempKbdQueue->Count )
                {
                    HeapFree(HandleHeap, 0,
                             (LPSTR)  TempKbdQueue->MonHdr.MemoryStartAddress);
                }
            }
            break;

        case KBDDupLogHandle:
            if (TempKbdQueue != PhyKbdQueue)
            {
                TempKbdQueue->Count++ ;
            }
            break;

        case KBDReadStdIn:
            if (!hStdInConsoleType)
            {
#if DBG
                KdPrint(("OS2SES(KbdRequest-KbdReadStdIn): illegal request\n"));
#endif
                Rc = ERROR_INVALID_HANDLE;
                break;
            }
            // falls into KBDRead

        case KBDRead:
            Rc = GetOs2KbdRead(&PReq->Length,
                               pMsg,
                               pReply);
            break;


        case KBDCharIn:
            Rc = GetOs2KbdKey(0,                /* CharIn/Peek flag */
                              (USHORT)PReq->fWait,
                              &PReq->d.KeyInfo,
                              pMsg,
                              pReply);
            break;

        case KBDStringIn:
            Rc = GetOs2KbdString((USHORT)PReq->fWait,
                                 PReq,
                                 pMsg,
                                 pReply);
            break;

        case KBDPeek:
            Rc = GetOs2KbdKey(1,                /* CharIn/Peek flag */
                              IO_NOWAIT,
                              &PReq->d.KeyInfo,
                              pMsg,
                              pReply);
            break;

        case KBDFlushBuffer:
            In.wRepeatCount = 0x7FFF;
            while (TRUE)
            {
                KbdQueue->LastKeyFlag = FALSE;
                KbdQueue->Out == KbdQueue->In;

                Rc = GetKeyboardInput( IO_NOWAIT,
                                       &In,
                                       pMsg,
                                       pReply);

                if ( !Rc )                          /* no char & NO_WAIT */
                   break;
            }
            break;

        case KBDGetStatus:
            if (PReq->d.KbdInfo.cb < 10 )
            {   Rc = ERROR_KBD_INVALID_LENGTH;
                break;
            }
            Ow2GetOs2KbdEventIntoQueue();
            PReq->d.KbdInfo = KbdQueue->Setup;
#ifdef DBCS
// MSKK May.18.1992 KazuM
            GetNlsMode(&KbdQueue->Setup);
#endif
            PReq->d.KbdInfo.fsState &= KBDINFO_STATE_MASK;
            break;

        case KBDSetStatus:
            Rc = Ow2KbdSetStatus(PReq);
            break;

        case KBDFreeFocus:
            LastSetup = KbdQueue->Setup;
            KbdQueue = PhyKbdQueue;
            NewKbdQueue(KbdQueue);
            KbdNewSetup(&LastSetup);
            break;

        case KBDNewFocus:
            LastSetup = KbdQueue->Setup;
            KbdQueue = TempKbdQueue;
            NewKbdQueue(KbdQueue);
            KbdNewSetup(&LastSetup);
            break;

// BUGBUG?? - do the following requests working on the current/last-focused
//           logical keyboard, on the physical keyboard or on a logical
//            keyboard passed as a parameter

        case KBDGetInputMode:
            switch (KbdQueue->Setup.fsMask & KEYBOARD_BINARY_SHIFT)
            {
                case KEYBOARD_BINARY_SHIFT:
                    PReq->d.InputMode = MODE_BINARY_SHIFT;
                    break;

                case KEYBOARD_BINARY_MODE:
                    PReq->d.InputMode = BINARY_MODE;
                    break;

                default:
                    PReq->d.InputMode = ASCII_MODE;
                    break;
            }
            break;

        case KBDGetInterimFlag:
#ifdef DBCS
// MSKK May.18.1992 KazuM
            GetNlsMode(&KbdQueue->Setup);
#endif
            PReq->d.Interim = (UCHAR)(KbdQueue->Setup.fsInterim &
                                      (CONVERSION_REQUEST | INTERIM_CHAR));
            break;

        case KBDGetKbdType:
#ifdef JAPAN
// MSKK May.07.1993 V-AkihiS
            if (KbdType == KBD_TYPE_JAPAN && OemId == SUB_KBD_TYPE_MICROSOFT)
            {
                switch(OemSubType)
                {
                    case MICROSOFT_KBD_101_TYPE:
                        PReq->d.KbdType[0] = 0x0001;
                        PReq->d.KbdType[1] = 0x0000;
                        PReq->d.KbdType[2] = 0x0000;
                        break;
                    case MICROSOFT_KBD_AX_TYPE:
                        PReq->d.KbdType[0] = 0x0010;
                        PReq->d.KbdType[1] = 0x0000;
                        PReq->d.KbdType[2] = 0x0001;
                        break;
                    case MICROSOFT_KBD_106_TYPE:
                        PReq->d.KbdType[0] = 0x0001;
                        PReq->d.KbdType[1] = 0x82B3;
                        PReq->d.KbdType[2] = 0x0032;
                        break;
                    case MICROSOFT_KBD_002_TYPE:
                        PReq->d.KbdType[0] = 0x0006;
                        PReq->d.KbdType[1] = 0x82B3;
                        PReq->d.KbdType[2] = 0x0032;
                        break;
                    default:
                        PReq->d.KbdType[0] = 0x0001;
                        PReq->d.KbdType[1] = 0x0000;
                        PReq->d.KbdType[2] = 0x0000;
#if DBG
                        KdPrint(("OS2SES(Kbd) This keyboard isn't supported yet.\n"));
#endif
                }
            } else
            {
                PReq->d.KbdType[0] = 0x0001;
                PReq->d.KbdType[1] = 0x0000;
                PReq->d.KbdType[2] = 0x0000;
#if DBG
                KdPrint(("OS2SES(Kbd) This keyboard isn't supported yet.\n"));
#endif
            }
#else
            PReq->d.KbdType = 0x0001;  // BUGBUG
#endif
            break;

        case KBDGetHotKey:
            // BUGBUG   PReq->d.HotKey =
    /*

    if ((*pParm != HOTKEY_MAX_COUNT) &&
        (*pParm != HOTKEY_CURRENT_COUNT))
    {
    }
#define HOTKEY_MAX_COUNT    0x0000
#define HOTKEY_CURRENT_COUNT    0x0001
     */

            break;

        case KBDGetShiftState:
#ifdef DBCS
// MSKK Oct.20.1992 V-AkihiS
            GetNlsMode(&KbdQueue->Setup);
            PReq->d.Shift.fNLS = HIBYTE(KbdQueue->Setup.fsInterim);
#else
            PReq->d.Shift.fNLS = KbdQueue->bNlsShift;
#endif
            PReq->d.Shift.fsState = KbdQueue->Setup.fsState;
            break;

        case KBDSetInputMode:
            LastSetup = KbdQueue->Setup;
            KbdQueue->Setup.fsMask = (USHORT)
                ((KbdQueue->Setup.fsMask & ~(KEYBOARD_INPUT | KEYBOARD_SHIFT_REPORT)) |
                ((PReq->d.InputMode  & SHIFT_REPORT_MODE) ? KEYBOARD_SHIFT_REPORT : 0) |
                ((PReq->d.InputMode & BINARY_MODE ) ?
                    KEYBOARD_BINARY_MODE : KEYBOARD_ASCII_MODE));
            KbdNewSetup(&LastSetup);
            break;

        case KBDSetShiftState:
            LastSetup = KbdQueue->Setup;
            KbdQueue->Setup.fsState = PReq->d.Shift.fsState;
            // BUGBUG : SHIFTSTATE.fbNLS       PReq->d.Shift.fNLS
#ifdef DBCS
// MSKK Oct.20.1992 V-AkihiS
            KbdQueue->Setup.fsInterim = MAKEWORD(
                                            KbdQueue->Setup.fsInterim,
                                            PReq->d.Shift.fNLS
                                           );
            SetNlsMode(KbdQueue->Setup);
#endif
            KbdNewSetup(&LastSetup);
            break;

        case KBDSetTypamaticRate:
            Rc = !SystemParametersInfo(
                        SPI_SETKEYBOARDDELAY,
                        PReq->d.RateDelay.usDelay,
                        NULL,
                        0);
            if (!Rc)
            {
                Rc = !SystemParametersInfo(
                            SPI_SETKEYBOARDSPEED,
                            PReq->d.RateDelay.usRate,
                            NULL,
                            0
                           );
            }
            break;

        case KBDSetInTerimFlag:
            LastSetup = KbdQueue->Setup;
#ifdef DBCS
// MSKK Mar.03.1993 V-AkihiS
            KbdQueue->Setup.fsInterim = MAKEWORD(
                                            PReq->d.Interim,
                                            HIBYTE(KbdQueue->Setup.fsInterim)
                                           );
            SetNlsMode(KbdQueue->Setup);
#else
            KbdQueue->Setup.fsInterim = (USHORT)PReq->d.Interim;
#endif
            KbdNewSetup(&LastSetup);
            break;

        case KBDGetCp:
            PReq->d.CodePage = SesGrp->KbdCP;
            break;

        case KBDSetCp:
            Rc = KbdNewCp(PReq->d.CodePage);
            break;

        case KBDNewCountry:
            SesGrp->KeyboardCountry = PReq->d.CodePage; //Hack - Not Really CodePage
            KbdSetTable(SesGrp->KbdCP);
            *pReply = 0;

            break;

        case KBDXlate:
            /*
            {
                KBD_XLATE_VARS  XlateVars;
                KBD_MON_PACKAGE KeyInfo[3];
                PKBDTRANS       pKbdXlate = &PReq->d.KbdTrans;

                RtlZeroMemory(&XlateVars, sizeof(KBD_XLATE_VARS));
                if (pKbdXlate->fsShift != 0)
                {
                    // continue translation

                    //? = pKbdXlate->fsShift;
                }

                RtlZeroMemory(&Os2KeyInfo[0], 3 * sizeof(KBD_MON_PACKAGE));

                //KeyInfo[0].MonitorFlag = pKbdXlate->...;
                //KeyInfo[0].DeviceFlag = pKbdXlate->...;
                KeyInfo[0].KeyInfo.chChar = pKbdXlate->chChar;
                KeyInfo[0].KeyInfo.chScan = pKbdXlate->chScan;
                KeyInfo[0].KeyInfo.fbStatus = pKbdXlate->fbStatus;
                KeyInfo[0].KeyInfo.bNlsShift = pKbdXlate->bNlsShift;
                KeyInfo[0].KeyInfo.fsState = pKbdXlate->fsState;
                KeyInfo[0].KeyBoardFlag = pKbdXlate->fsDD;

                KeyInfo[0].KeyInfo.fbStatus = 0x40;

                //? XlateVars.XlateFlags |= SecPrefix;        // Have seen E0 prefix

                Rc = Ow2KbdXlate(
                                 pKbdXlate->chScan,             // ScanCode,
                                 &XlateVars,                    // pFlagArea,
                                 &KeyInfo[0],                   // pMonitorPack,
                                 Ow2KbdScanTable                // pTransTable
                                );

                //? which packet - KeyInfo[?]
                pKbdXlate->chChar = KeyInfo[0].KeyInfo.chChar;
                pKbdXlate->chScan = KeyInfo[0].KeyInfo.chScan;
                pKbdXlate->fbStatus = KeyInfo[0].KeyInfo.fbStatus;
                pKbdXlate->bNlsShift = KeyInfo[0].KeyInfo.bNlsShift;
                pKbdXlate->fsState = KeyInfo[0].KeyInfo.fsState;
                pKbdXlate->fsDD = KeyInfo[0].KeyBoardFlag;
                //? pKbdXlate->fsXlate = ;
                //? pKbdXlate->fsShift = ;
            }
                */
        case KBDSetCustXt:
                /*  from ???               */
        default:
            Rc = (DWORD)-1L; //STATUS_INVALID_PARAMETER;
#if DBG
            IF_OD2_DEBUG2( KBD, OS2_EXE )
                KdPrint(("OS2SES(KbdRequest): Unknown Kbd request = %X\n", PReq->Request));
#endif
    }

    if ( Rc == 1 )
    {
       Rc = GetLastError();
    }

    *(PDWORD) PStatus = Rc;
    return(TRUE);  // Continue
}


DWORD
Ow2KbdSetStatus(IN  PKBDREQUEST     PReq)
{
    KBDINFO         LastSetup, *pKbdSetup;
    USHORT          KbdMask, Mask;

    /*
     *  check legalty of parameters:
     *
     *    1. sizeof structure
     *    2. reserved bits
     *    3. mutuex bits (ECHO_ON & ECHO_OFF, ASCII & BINARY, ASCII & SHIFT)
     */

    LastSetup = KbdQueue->Setup;
    if (PReq->d.KbdInfo.cb != 10 )
    {
        return ERROR_KBD_INVALID_LENGTH;
    }

    KbdMask = PReq->d.KbdInfo.fsMask;
    pKbdSetup = &KbdQueue->Setup;

    if (KbdMask & KEYBOARD_INPUT_RESERVED)
    {
        return ERROR_KBD_INVALID_INPUT_MASK;
    }

    if ((KbdMask & KEYBOARD_ECHO ) == KEYBOARD_ECHO)
    {
        return ERROR_KBD_INVALID_ECHO_MASK;
    }

    if ((KbdMask & KEYBOARD_INPUT) == KEYBOARD_INPUT)
    {
        return ERROR_KBD_INVALID_INPUT_MASK;
    }

    if ((KbdMask & KEYBOARD_SHIFT_ASCII_INPUT) == KEYBOARD_SHIFT_ASCII_INPUT)
    {
        return ERROR_KBD_INVALID_INPUT_MASK;
    }

    /*
     *  check modified bits and set the flags according:
     *
     *    1. STATE      - set fsState
     *    2. INTERIM    - set fsInterim
     *    3. TURNAROUND - set chTurnAround
     */

#ifdef DBCS
// MSKK Jul.1993 V-AKihiS
    if (KbdMask & KEYBOARD_MODIFY_STATE)
    {
        pKbdSetup->fsState = PReq->d.KbdInfo.fsState;
        pKbdSetup->fsInterim = MAKEWORD(
                                   LOBYTE(pKbdSetup->fsInterim),
                                   HIBYTE(PReq->d.KbdInfo.fsInterim)
                                  );
        SetNlsMode(*pKbdSetup);
    }

    if (KbdMask & KEYBOARD_MODIFY_INTERIM)
        pKbdSetup->fsInterim = MAKEWORD(
                                   LOBYTE(PReq->d.KbdInfo.fsInterim),
                                   HIBYTE(pKbdSetup->fsInterim)
                                  );
#else
    if (KbdMask & KEYBOARD_MODIFY_STATE)
        pKbdSetup->fsState = PReq->d.KbdInfo.fsState;

    if (KbdMask & KEYBOARD_MODIFY_INTERIM)
        pKbdSetup->fsInterim = PReq->d.KbdInfo.fsInterim;
#endif

    if (KbdMask & KEYBOARD_MODIFY_TURNAROUND)
        pKbdSetup->chTurnAround = PReq->d.KbdInfo.chTurnAround;

    /*
     *  update mask:
     *
     *    1. update mask of new bits SHIFT_REPORT & 2B_TURNAROUND
     *    2. if new mask includes new ECHO then update mask
     *    3. if new mask includes new INPUT then update mask
     */

    Mask = KEYBOARD_NEW_MASK;

    if (KbdMask & KEYBOARD_ECHO)
    {
        Mask |= KEYBOARD_ECHO;
    }

    if (KbdMask & KEYBOARD_INPUT)
    {
        Mask |= KEYBOARD_INPUT;
    }

    pKbdSetup->fsMask =
                (pKbdSetup->fsMask & ~Mask) | (KbdMask & Mask);

    KbdNewSetup(&LastSetup);

    return (0L);
}


DWORD
GetOs2KbdKey( IN  BOOL        PeekFlag,
              IN  USHORT      WaitFlag,
              OUT PKBDKEYINFO KeyInfo,
              IN  PVOID       pMsg,
              OUT PULONG      pReply)
/*++

Routine Description:

    This routine get kbd char for KbdCharIn and KbdPeek

Arguments:

    PeekFlag - TRUE if peek (0 - CharIn, 1 - Peek)

    WaitFlag - Wait if no input (IO_WAIT or IO_NOWAIT)

    KeyInfo - Where to return the key input record

    pMsg - Pointer to the LPC message

    pReply - Pointer to flag if return reply on LPC

Return Value:


Note:

    If no event and IO_WAIT: save pMsg, put 0 into *pReply and
    the reply is postponed.

--*/
{

    DWORD           Rc;
    KEYEVENTINFO    In;


    RtlZeroMemory(KeyInfo, sizeof(KBDKEYINFO));
    KeyInfo->fsState = 1;

    if ( KbdQueue->Setup.fsMask & KEYBOARD_ASCII_MODE )
    {
        KbdAsciiMode = 1;
    } else
    {
        KbdAsciiMode = 0;
        if ((KbdQueue->Setup.fsMask & KEYBOARD_BINARY_SHIFT) == KEYBOARD_BINARY_SHIFT)
        {
            WaitFlag |= ENABLE_SHIFT_KEY;
        }
    }

    WaitFlag |= ENABLE_NON_ASCII_KEY;

    KbdState = CharMode;
    KbdWaitFlag = (ULONG)WaitFlag;
    KbdPeekFlag = PeekFlag;

    for(;;)
    {
        if (KbdQueue->LastKeyFlag)
        {
            In = KbdQueue->LastKey;
            KbdQueue->LastKeyFlag = FALSE;
        } else
        {
            In.wRepeatCount = 0x7FFF;
            Rc = GetKeyboardInput( KbdWaitFlag,
                                   &In,
                                   pMsg,
                                   pReply);

            if ( !Rc )                          /* no char & (NO_WAIT or postponed reply) */
               return(Rc);
        }

        if (( HandleKeyboardInput(
                                 &In
                                 )) == NO_ERROR )
        {
            *KeyInfo = In.KeyInfo[0].KeyInfo;
            return(0L);
        }
    }
}


DWORD
GetOs2KbdString( IN     USHORT       WaitFlag,
                 //IN OUT KBDRW        *Length,
                 IN OUT PKBDREQUEST  PReq,
                 IN     PVOID        pMsg,
                 OUT    PULONG       pReply)
{

    DWORD           Rc;
    USHORT          EditFlag = 0;
    STRINGINBUF     String = PReq->d.String;

    KbdAsciiMode = (BOOL)(( KbdQueue->Setup.fsMask & KEYBOARD_ASCII_MODE ) ? 1 : 0);

    if ( String.cchIn && ( String.cchIn <= String.cb ) &&
         ( KbdLastBuff[String.cchIn] == '\r' ))
    {
        EditFlag = 1;
    }

    String.cchIn = String.cb;

    Rc = GetOs2KbdStringRead( WaitFlag,
                              EditFlag,
                              0,
                              (ULONG)String.cb,
                              &String.cchIn,
                              pMsg,
                              pReply);
    if ( pReply )
    {
        PReq->Length = (ULONG)KbdLength;
        String.cchIn = KbdLength;
        if ( String.cchIn != String.cb )
            PReq->Length++ ;             // ASCII mode - copy the CR
    }

    return(Rc);

}


DWORD
GetOs2KbdRead(IN    PULONG  Length,
              IN    PVOID   pMsg,
              OUT   PULONG  pReply)
{
    DWORD           Rc, i;

    KbdAsciiMode = (BOOL)(( KbdQueue->Setup.fsMask & KEYBOARD_ASCII_MODE ) ? 1 : 0);

    /*
     *  ignore previously-typed-but-not-returned character in binary mode
     */

    if ( !KbdAsciiMode || !KbdBuffNextLen)
    {

        Rc = GetOs2KbdStringRead( IO_WAIT,
                                  TRUE,
                                  1,
                                  KbdBuffSize - 2,
                                  (PUSHORT)Length,
                                  pMsg,
                                  pReply);

        return(Rc);

    }

    /*
     *
     * Copy from kbd buffer
     *
     */

    if (*Length > (ULONG)KbdBuffNextLen)
        *Length = KbdBuffNextLen;

    for (i = 0 ; i < *Length ; i++ )
    {
        if ((KBD_BUFFER_ADDRESS[i] = KbdLastBuff[i + KbdBuffNextPtr]) == '\n')
        {
            *Length = i + 1;
            break;
        }
    }

    KbdBuffNextLen -= *((PUSHORT)Length);
    KbdBuffNextPtr += (USHORT)*Length;

    return(0L);
}


DWORD
GetOs2KbdStringRead(IN      USHORT  WaitFlag,
                    IN      USHORT  EditFlag,
                    IN      USHORT  ReadMode,
                    IN      ULONG   MaxLength,
                    IN OUT  PUSHORT Length,
                    IN      PVOID   pMsg,
                    OUT     PULONG  pReply)
/*++

Routine Description:

    This routine get kbd string for KbdStringIn and Read("KBD$" or non-redirected
    STD-IN).

Arguments:

    WaitFlag - Wait if no input (IO_WAIT or IO_NOWAIT)

    EditFlag - TRUE if edit last line(0/1 according to cchIn - StringIn, 1 - Read)

    ReadMode - Called by StringIn (0) or Read(1)

    MaxLength - Maximun input length (String.cb for StringIn, KbdBuffSize
        for Read)

    Length - On enter: the requested length, on exit: the returned string
        length (String.cchIn for StringIn, Length field in LPC for Read)

    pMsg - Pointer to the LPC message

    pReply - Pointer to flag if return reply on LPC

Return Value:


Note:

    If no event and IO_WAIT: save pMsg, put 0 into *pReply and
    the reply is postponed.

--*/
{
    KEYEVENTINFO    In;
    DWORD           Rc;

    KbdLastBuffPtr = KbdInputLength = KbdFxWaitForChar = KbdDelIndex = 0;
    KbdIndexInLine = 0;
    KbdInsertOn = KbdEchoString = KbdLineWasEdited = FALSE;
    //KbdSecondTurnAround = KbdEndFlag = FALSE;
    KbdLength = *Length;

    if ( KbdAsciiMode )
    {
        /*
         *   ASCII  mode
         */

        KbdWaitFlag = (ULONG)(WaitFlag | ENABLE_LN_EDITOR_KEY);

        /*
         *
         * Get Start Cursor-Position
         *
         */

        // force SesGrp->WinCoord and CurType params to get updated

        Ow2VioReadCurPos();
        Ow2VioReadCurType();

        if (SesGrp->KeysOnFlag)
        {
            KbdWaitFlag |= ENABLE_KEYS_ON_KEY;
            KbdCueSetCurTypeToQuater();
        }
        KbdMaxLength = MaxLength - 1;    /* leave space for the TurnAround char at the end */
        KbdEndLength = 1;
        KbdReadMode = ReadMode;

        KbdEchoFlag = (BOOL)(( KbdQueue->Setup.fsMask & KEYBOARD_ECHO_ON ) ? 1 : 0);
        KbdTurnAroundChar = KbdQueue->Setup.chTurnAround;
        KbdTurnAroundCharTwo = KbdSetupTurnAroundCharTwo;

        //if (KbdQueue->Setup.chTurnAround & 0x80)
        if(KbdTurnAroundCharTwo)
        {   KbdMaxLength--;          /* need another space for 2-byte-TurnAround */
            KbdEndLength++;
        }

        KbdEditFlag = EditFlag;

        LineInputBuff[KbdInputLength].X_Pos = KbdStartOfLine = KbdFirstColumn =
                GET_CURRENT_COORD.X;

        KbdState = AsciiMode;

    } else
    {
        KbdWaitFlag = (ULONG)(WaitFlag | ENABLE_NON_ASCII_KEY);
        KbdState = BinaryMode;
    }

    for(;;)
    {
        /*
         *
         * Restore saved Input Key if any
         *
         */

        if (KbdQueue->LastKeyFlag)
        {
            In = KbdQueue->LastKey;
            KbdQueue->LastKeyFlag = FALSE;
        } else
        {
            /*
             *
             * Get Input Key if any
             *
             */

            In.wRepeatCount = 0x7FFF;
            Rc = GetKeyboardInput( KbdWaitFlag,
                                   &In,
                                   pMsg,
                                   pReply);

            if ( !Rc )                          /* no char & NO_WAIT */
               return(Rc);
        }

        if (( HandleKeyboardInput(
                                 &In
                                 )) == NO_ERROR )
        {
            *Length = KbdLength;
            return(0L);
        }
    }
}


DWORD
HandleKeyboardInput(IN  PKEYEVENTINFO   pKbd)
{
    DWORD           NumChar = 0;
    UCHAR           Char, Scan, *puchLastString;
    USHORT          i, usIndex, StringLengthToEcho, NumBeep = 0;
    SHORT           X_Pos, Offset;

    Scan = pKbd->KeyInfo[0].KeyInfo.chScan;
    Char = pKbd->KeyInfo[0].KeyInfo.chChar;

#if DBG
    IF_OD2_DEBUG(KBD)
    {
        KdPrint(("HandleKeyboardInput: %s - Char %x, Scan %x, Status %x, State %x, Flag %x\n",
            (KbdState == CharMode) ? "CharMode" :
            (KbdState == AsciiMode) ? "AsciiMode" : "BinaryMode",
            Char, Scan, pKbd->KeyInfo[0].KeyInfo.fbStatus,
            pKbd->KeyInfo[0].KeyInfo.fsState, pKbd->KeyInfo[0].KeyboardFlag));
    }
#endif
    switch (KbdState)
    {
        case CharMode:
            if ( KbdPeekFlag || (pKbd->wRepeatCount > 1))
            {
                KbdQueue->LastKey = *pKbd;
                KbdQueue->LastKeyFlag = TRUE;
                if (!KbdPeekFlag)
                {
                    KbdQueue->LastKey.wRepeatCount--;
                }
            }

            return (NO_ERROR);
            break;

        case AsciiMode:

            KbdQueue->LastKey = *pKbd;           // prepare it in case we read only one copy of the char
            KbdQueue->LastKey.wRepeatCount--;

           /*
            *
            * Handle CR (TurnAround Char)
            *
            *   1. put in buffer (if there is a room), beep otherwise
            *   2. echo if echo_on
            *   3. (READ only) add LF to CR (if there is a place)
            *
            */

            if ( !KbdFxWaitForChar && KbdKeyIsTurnAround(Char, Scan) )
            {
                if ( pKbd->wRepeatCount > 1 )
                {
                    KbdQueue->LastKeyFlag = TRUE;
                }

                if (( KbdReadMode == 1 ) && KbdInputLength &&
                    ( LineInputBuff[0].Char == 0x1A ))        // ^Z
                {
                    NumChar = KbdInputLength = 0;
                } else
                {
                    NumChar = KbdInputLength;

                    /*
                     *  Add the TurnAround char at the end of the buffer
                     */

                    LineInputBuff[KbdInputLength++].Char = Char;

                    if (KbdTurnAroundCharTwo)
                    {
                        if ( KbdReadMode == 1 )
                        {
                            LineInputBuff[KbdInputLength - 1].Char = '\r';
                            Scan = '\n';
                        }
                        LineInputBuff[KbdInputLength++].Char = Scan;
                    } else if (( KbdReadMode == 1 ) && ( Char == '\r' ) &&
                               ( KbdInputLength <= (USHORT)KbdMaxLength ))
                    {
                        LineInputBuff[KbdInputLength++].Char = '\n';
                    }

                }

                /*
                 *  Echo the TurnAround char to console
                 */

                if (KbdEchoFlag && !KbdTurnAroundCharTwo)
                {
                    KbdEchoNL(1);
                }

                /*
                 *
                 * Save string length and data in buffer for editing keys
                 *
                 */

                for ( i = 0 ; i < KbdInputLength ; i++ )
                {
                    KbdLastBuff[i] = LineInputBuff[i].Char;
                }

                if (KbdReadMode == 0)
                {
                    KbdInputLength = (USHORT)NumChar;
                }
                LastStringLength = (USHORT)NumChar;     // not include the TurnAround char

                /*
                 *
                 * Copy to application buffer
                 *
                 */

                if ( KbdLength > KbdInputLength )
                    KbdLength = KbdInputLength;

                RtlMoveMemory(KbdAddress, KbdLastBuff, KbdLength);

                if ( KbdReadMode == 0 )
                    KBD_BUFFER_ADDRESS[KbdLength] = Char;          // add the CR at the end

                /*
                 *
                 * Keep info for Read in case we don't return all the string
                 *
                 */

                KbdBuffNextPtr = KbdLength;
                KbdBuffNextLen = KbdInputLength - KbdLength;

                /*
                 *
                 * Copy string to CUE buffer if active
                 *
                 */

                if ( SesGrp->KeysOnFlag )
                {
                    if( KbdLineWasEdited && NumChar )
                    {
                        KbdCurrentLine = KbdNextLinePointer;

                        for ( i = 0, usIndex = KbdNextLinePointer ;
                              i < NumChar ; i++, usIndex++ )
                        {
                            KbdCueBuffer[usIndex] = KbdLastBuff[i];
                        }

                        KbdNextLinePointer = usIndex + 1;

                        while (KbdCueBuffer[usIndex])
                        {
                            // zero the end of the last string we copy the new
                            // one on (fill with NULL till start of next line)

                            KbdCueBuffer[usIndex++] = 0;
                        }
                    }

                    KbdCueUpRowIsCurrent = TRUE;
                }

                return(0L);
            }

           /*
            *
            * Check for Speciel Keys (PFx, enhanced ...)
            *
            */

            if (( Char == 0 ) || ( Char == 0xE0 ))
            {
                if (SesGrp->KeysOnFlag)
                {
                    if ( Scan == OS2_SCAN_RIGHT_6 )                 // Right
                    {
                        if (( NumChar = KbdInputLength - KbdIndexInLine ) >
                            pKbd->wRepeatCount )
                        {
                            NumChar = pKbd->wRepeatCount;
                        }

                        KbdCueMoveToRight(
                                    KbdIndexInLine,
                                    (USHORT)NumChar,
                                    FALSE
                                   );

                    } else if ( Scan == OS2_SCAN_LEFT_4 )           // Left
                    {
                        NumChar = ( KbdIndexInLine < pKbd->wRepeatCount ) ?
                                    KbdIndexInLine : pKbd->wRepeatCount;

                        KbdCueMoveToLeft(
                                    KbdIndexInLine,
                                    (USHORT)NumChar
                                   );

                    } else if ( Scan == OS2_SCAN_UP_8 )             // Up
                    {
                        /*
                         *  Find previous command in the command queue
                         */

                        if (KbdCueBuffer[KbdCurrentLine])  // if anything at the CUE buffer
                        {
                            if (KbdCueUpRowIsCurrent)
                            {
                                pKbd->wRepeatCount--;
                                KbdCueUpRowIsCurrent = FALSE;
                            }

                            usIndex = KbdCurrentLine;
                            for ( i = 0 ; i < pKbd->wRepeatCount ; i++ )
                            {
                                usIndex--;
                                while (!KbdCueBuffer[--usIndex]);  // skip all null
                                while (KbdCueBuffer[--usIndex]);   // go to start of command

                                usIndex++;
                            }
                            KbdCurrentLine = usIndex;
                        } else
                        {
                            usIndex = KbdCurrentLine;
                        }

                        KbdCueEraseAndDisplayLine(usIndex);
                    } else if ( Scan == OS2_SCAN_DOWN_2 )           // Down
                    {
                        /*
                         *  Find next command in the command queue
                         */

                        if (KbdCueBuffer[KbdCurrentLine])  // if anything at the CUE buffer
                        {
                            usIndex = KbdCurrentLine;
                            KbdCueUpRowIsCurrent = FALSE;

                            for ( i = 0 ; i < pKbd->wRepeatCount ; i++ )
                            {
                                while (KbdCueBuffer[++usIndex]);
                                while (!KbdCueBuffer[++usIndex]);
                            }
                            KbdCurrentLine = usIndex;
                        } else
                        {
                            usIndex = KbdCurrentLine;
                        }

                        KbdCueEraseAndDisplayLine(usIndex);
                    } else if ( Scan == OS2_SCAN_HOME_7 )           // Home
                    {
                        KbdCueMoveToLeft(
                                    KbdIndexInLine,
                                    KbdIndexInLine
                                   );
                    } else if ( Scan == OS2_SCAN_END_1 )            // End
                    {
                        KbdCueMoveToRight(
                                    KbdIndexInLine,
                                    (USHORT)(KbdInputLength - KbdIndexInLine),
                                    FALSE
                                   );

                    } else if ( Scan == OS2_SCAN_CTRL_LEFT_4 )      // ^Left
                    {
                        USHORT      PrevIndex = KbdIndexInLine;

                        for ( i = 0;
                              (i < pKbd->wRepeatCount) && PrevIndex ;
                              i++ )
                        {
                            /* for each char:
                             *   go one char left
                             *   skip all non-alphanumeric chars
                             *   akip all alphanumeric chars
                             * while points to alpha, which is not the original
                             */

                            usIndex = PrevIndex - 1;

                            while (usIndex && !ALPHANUM_CHAR(usIndex))
                            {
                                usIndex--;
                            }

                            while (usIndex && ALPHANUM_CHAR(usIndex))
                            {
                                usIndex--;
                            }

                            if (usIndex || !ALPHANUM_CHAR(usIndex))
                            {
                                usIndex++;
                            }

                            if (!ALPHANUM_CHAR(usIndex) ||
                                (PrevIndex == usIndex))
                            {
                                break;
                            }

                            PrevIndex = usIndex;
                        }
                        if (NumChar = KbdIndexInLine - PrevIndex)
                        {
                            KbdCueMoveToLeft(
                                        KbdIndexInLine,
                                        (USHORT)NumChar
                                       );
                        }
                    } else if ( Scan == OS2_SCAN_CTRL_RIGHT_6 )     // ^Right
                    {
                        USHORT      PrevIndex = KbdIndexInLine;

                        for ( i = 0;
                              (i < pKbd->wRepeatCount) && (PrevIndex < KbdInputLength);
                              i++ )
                        {
                            /* for each char:
                             *   go one char right
                             *   akip all alphanumeric chars
                             *   skip all non-alphanumeric chars
                             * while points to alpha, which is not the original
                             */

                            usIndex = PrevIndex;

                            while ((usIndex < KbdInputLength) &&
                                   ALPHANUM_CHAR(usIndex))
                            {
                                usIndex++;
                            }

                            while ((usIndex < KbdInputLength) &&
                                   !ALPHANUM_CHAR(usIndex))
                            {
                                usIndex++;
                            }

                            if ((usIndex >= KbdInputLength) ||
                                !ALPHANUM_CHAR(usIndex))
                            {
                                break;
                            }

                            PrevIndex = usIndex;
                        }
                        if (NumChar = PrevIndex - KbdIndexInLine)
                        {
                            KbdCueMoveToRight(
                                        KbdIndexInLine,
                                        (USHORT)NumChar,
                                        FALSE
                                       );
                        }
                    } else if ( Scan == OS2_SCAN_CTRL_END_1 )       // ^End
                    {
                        KbdLineWasEdited = TRUE;
                        KbdEchoBSAndFillSpaces(0, LineInputBuff[KbdInputLength].X_Pos -
                                        LineInputBuff[KbdIndexInLine].X_Pos);

                        KbdInputLength = KbdIndexInLine;
                    } else if ( Scan == OS2_SCAN_DEL )              // Del
                    {
                        KbdLineWasEdited = TRUE;
                        if (( NumChar = KbdInputLength - KbdIndexInLine ) >
                            pKbd->wRepeatCount )
                        {
                            NumChar = pKbd->wRepeatCount;
                        }

                        KbdCueDeleteCharAndShift(
                                    KbdIndexInLine,
                                    (USHORT)NumChar
                                   );
                    } else if ( Scan == OS2_SCAN_CTRL_HOME_7 )      // ^Home
                    {
                        if (NumChar = KbdIndexInLine)
                        {
                            KbdLineWasEdited = TRUE;
                            KbdCueMoveToLeft(
                                        KbdIndexInLine,
                                        (USHORT)NumChar
                                       );

                            KbdCueDeleteCharAndShift(
                                        KbdIndexInLine,
                                        (USHORT)NumChar
                                       );
                        }
                    } else if ( Scan == OS2_SCAN_INSERT_0 )         // Ins
                    {
                        if ( pKbd->wRepeatCount % 2 )
                        {
                            if( KbdInsertOn = ~KbdInsertOn )
                            {
                                KbdCueSetCurTypeToHalf();
                            } else
                            {
                                KbdCueSetCurTypeToQuater();
                            }
                        }
                    }

                    break;
                } else
                {
                    if ( KbdFxWaitForChar )
                    {
                        KbdFxWaitForChar = 0;
                        if (--pKbd->wRepeatCount)
                        {
                            KbdQueue->LastKey.wRepeatCount--;
                            KbdQueue->LastKeyFlag = TRUE;
                        } else
                        {
                            break;
                        }
                    }

                    if ( Scan == 0x40 )
                    {
                        Char = 0x1A;       // F6  =>  ^Z
                    } else if ( Scan == 0x41 )
                    {
                        Char = 0x00;       // F7  =>  ^@
                    } else if (KbdEditFlag)
                    {
                        if (( Scan == 0x3B ) ||                     // F1
                            ( Scan == OS2_SCAN_RIGHT_6 ))           // Right
                        {
                            KbdInsertOn = FALSE;
                            if ((USHORT)(KbdDelIndex + KbdLastBuffPtr) < LastStringLength)
                            {
                                Char = KbdLastBuff[KbdDelIndex + KbdLastBuffPtr];    // => previous char
                            } else
                                break;

                        } else if ( Scan == 0x3C )                  // F2
                        {
                            KbdInsertOn = FALSE;
                            if (pKbd->wRepeatCount % 2)
                            {
                                KbdFxWaitForChar = 1;
                            }
                            break;
                        } else if ( Scan == 0x3D )                  // F3
                        {
                            KbdInsertOn = FALSE;
                            if ((USHORT)(KbdDelIndex + KbdLastBuffPtr) < LastStringLength)
                            {
                                StringLengthToEcho = LastStringLength - KbdDelIndex - KbdLastBuffPtr;
                                KbdEchoString = TRUE;
                            } else
                                break;

                        } else if ( Scan == 0x3E )                  // F4
                        {
                            KbdInsertOn = FALSE;
                            if (pKbd->wRepeatCount % 2)
                            {
                                KbdFxWaitForChar = 2;
                            }
                            break;
                        } else if  ( Scan == OS2_SCAN_DEL )         // Del
                        {
                            KbdDelIndex += pKbd->wRepeatCount;
                            if(KbdDelIndex > LastStringLength)
                            {
                                KbdDelIndex = LastStringLength;
                            }
                            break;
                        } else if  ( Scan == OS2_SCAN_INSERT_0 )    // Ins
                        {
                            if (pKbd->wRepeatCount % 2)
                            {
                                KbdInsertOn = ~KbdInsertOn;
                            }

                            break;

                        } else if  ( Scan == OS2_SCAN_LEFT_4 )      // Left
                        {
                            Char = '\b';                    // => BS
                            KbdInsertOn = FALSE;
                        } else
                            break;
                    } else
                        break;
                }
            }

           /*
            *
            * Search for char in KbdLastBuff (for F2 & F4)
            *
            */

            if (KbdFxWaitForChar)
            {
                if (pKbd->wRepeatCount > 1)
                {
                    KbdQueue->LastKeyFlag = TRUE;
                }
                for ( i = KbdDelIndex + KbdLastBuffPtr ;
                      (i < LastStringLength) && (KbdLastBuff[i] != Char) ; i++ );
                if ((i == (USHORT)(KbdDelIndex + KbdLastBuffPtr)) ||
                    (KbdLastBuff[i] != Char))
                {
                    KbdFxWaitForChar = 0;
                    break;
                }

                StringLengthToEcho = i - (KbdDelIndex + KbdLastBuffPtr);

                if (KbdFxWaitForChar == 1)            // F2
                {
                    KbdFxWaitForChar = 0;
                    KbdEchoString = TRUE;
                } else                                // F4
                {
                    KbdDelIndex += i;
                    KbdFxWaitForChar = 0;
                    break;
                }
            }

           /*
            *
            * Echo string from KbdLastBuff (for F2 & F3)
            *
            * StringLengthToEcho - is the string length
            */

            if (KbdEchoString)
            {
                X_Pos = GET_CURRENT_COORD.X;
                NumChar = 0;

                for ( i = KbdDelIndex + KbdLastBuffPtr, puchLastString = &KbdLastBuff[i] ;
                      StringLengthToEcho && (KbdInputLength < (USHORT)KbdMaxLength) ; StringLengthToEcho-- )
                {
                    Char = KbdLastBuff[i++];
                    NumChar++ ;

                    LineInputBuff[KbdInputLength++].Char = Char;
                    if (Char == '\t')  // TAB
                    {
                        X_Pos += 8 - (X_Pos % 8);
                    } else if (Char < ' ')
                    {
                        X_Pos += 2;
                    } else
                    {
                        X_Pos++;
                    }

                    if (X_Pos >= SesGrp->ScreenColNum)
                    {
                        X_Pos -= SesGrp->ScreenColNum;
                        KbdStartOfLine = 0;
                    }

                    LineInputBuff[KbdInputLength].X_Pos = X_Pos;
                }

                if (KbdEchoFlag && NumChar)
                {
                    KbdEchoAString(puchLastString, NumChar);
                }

                KbdLastBuffPtr += (USHORT)NumChar;

                if (StringLengthToEcho)
                {
                    KbdEchoBeep(i);
                }

                KbdEchoString = FALSE;
                break;
            }

           /*
            *
            * Handle BS
            *
            */

            if (( Char == '\b' ) || ( Char == 0x7F ))
            {
                if (SesGrp->KeysOnFlag)
                {
                    if ( NumChar = KbdIndexInLine )
                    {
                        if ( NumChar > pKbd->wRepeatCount )
                        {
                            NumChar = pKbd->wRepeatCount;
                        }

                        KbdCueMoveToLeft(
                                    KbdIndexInLine,
                                    (USHORT)NumChar
                                   );

                        KbdCueDeleteCharAndShift(
                                    KbdIndexInLine,
                                    (USHORT)NumChar
                                   );

                        KbdLineWasEdited = TRUE;
                    }

                    break;
                } else
                {
                    KbdInsertOn = FALSE;

                    for ( i = 0 ; (i < pKbd->wRepeatCount) && KbdInputLength &&
                                   (LineInputBuff[KbdInputLength].X_Pos != KbdStartOfLine) ; i++ )
                    {
                        if (KbdLastBuffPtr)
                        {
                            KbdLastBuffPtr--;
                        } else if (KbdDelIndex)
                        {
                            KbdDelIndex--;
                        }

                        KbdInputLength--;
                    }

                    NumChar = GET_CURRENT_COORD.X - LineInputBuff[KbdInputLength].X_Pos;

                    if(KbdEchoFlag && NumChar)
                    {
                        KbdEchoBSAndFillSpaces(NumChar, NumChar);
                    }

                    break;
                }
            }

            if (!SesGrp->KeysOnFlag)
            {
               /*
                *
                * Handle LF
                *
                */

                if (Char == '\n')
                {
                    if (KbdEchoFlag)
                    {
                        KbdEchoNL(pKbd->wRepeatCount);
                    }

                    LineInputBuff[KbdInputLength].X_Pos = 0;
                    KbdStartOfLine = 0;

                    break;
                }

               /*
                *
                * Handle ^W
                *
                */

                if (Char == 0x17)
                {
                    USHORT      PrevIndex = KbdIndexInLine;

                    KbdInsertOn = FALSE;

                    for ( i = 0;
                          (i < pKbd->wRepeatCount) && ( PrevIndex > KbdStartOfLine ) ;
                          i++ )
                    {
                        /* for each char:
                         *   go one char left
                         *   skip all non-alphanumeric chars
                         *   akip all alphanumeric chars
                         * while points to alpha, which is not the original
                         */

                        usIndex = PrevIndex - 1;

                        while (( usIndex > KbdStartOfLine ) &&
                               !ALPHANUM_CHAR(usIndex))
                        {
                            usIndex--;
                        }

                        while (( usIndex > KbdStartOfLine ) &&
                               ALPHANUM_CHAR(usIndex))
                        {
                            usIndex--;
                        }

                        if (( usIndex > KbdStartOfLine ) ||
                            !ALPHANUM_CHAR(usIndex))
                        {
                            usIndex++;
                        }

                        if (!ALPHANUM_CHAR(usIndex) ||
                            (PrevIndex == usIndex))
                        {
                            break;
                        }

                        PrevIndex = usIndex;
                    }

                    NumChar = LineInputBuff[KbdIndexInLine].X_Pos -
                                        LineInputBuff[PrevIndex].X_Pos ;

                    if(KbdEchoFlag && NumChar)
                    {
                        KbdEchoBSAndFillSpaces(NumChar, NumChar);
                    }

                    KbdIndexInLine = KbdInputLength = PrevIndex;
                    //KbdLastBuffPtr = 0;
                    break;
                }
            }

           /*
            *
            * Handle ESC
            *
            */

            if (Char == 0x1B)
            {
                // ^[  =>  Write '\'<NL> & Clear Buff

                KbdInsertOn = FALSE;

                KbdLastBuffPtr = KbdDelIndex = 0;
                if (SesGrp->KeysOnFlag)
                {
                    if (KbdCueBuffer[KbdCurrentLine])
                    {
                        usIndex = KbdCurrentLine - 1;
                    } else
                    {
                        usIndex = KbdCurrentLine;
                    }

                    KbdCueEraseAndDisplayLine(usIndex);     // don't display anything
                } else if (KbdEchoFlag)
                {
                    KbdEchoESC(pKbd->wRepeatCount, KbdFirstColumn);
                }

                KbdStartOfLine = LineInputBuff[0].X_Pos = KbdFirstColumn;
                KbdInputLength = 0;
                break;
            }

           /*
            *
            * Handle ^F
            *
            */

            if (Char == 0x6)
            {
                break;
            }

           /*
            *
            * Handle char :
            *
            *   1. put in buffer (if there is a room), beep otherwise
            *   2. save in buffer cursor position of next char
            *   3. echo if echo_on
            *
            */

            NumChar = 0;

            if (SesGrp->KeysOnFlag)
            {
                KbdCueHandleChar(Char, pKbd->wRepeatCount);
            } else
            {
                X_Pos = GET_CURRENT_COORD.X;

                if (Char < ' ')
                {
                    if (Char == '\t')  // TAB
                    {
                        Offset = 8;
                        X_Pos &= ~7;
                    } else
                    {
                        Offset = 2;
                    }
                } else
                {
                    Offset = 1;
                }

                for ( i = 0 ; (i < pKbd->wRepeatCount) &&
                              (KbdInputLength < (USHORT)KbdMaxLength) ; i++ )
                {
                    if (!KbdInsertOn)
                    {
                        KbdLastBuffPtr++;
                    }

                    LineInputBuff[KbdInputLength++].Char = Char;
                    X_Pos += Offset;

                    if (X_Pos >= SesGrp->ScreenColNum)
                    {
                        X_Pos -= SesGrp->ScreenColNum;
                        KbdStartOfLine = 0;
                    }
                    LineInputBuff[KbdInputLength].X_Pos = X_Pos;
                }

                if (KbdEchoFlag && i)
                {
                    KbdEchoChar(Char, i);
                }

                if (i < pKbd->wRepeatCount)
                {
                    KbdEchoBeep(pKbd->wRepeatCount - i);
                }
            }
            break;

        case BinaryMode:
            /*
             *
             * Binary mode
             *
             */

            /*
             *
             * Handle char :
             *
             *   put in buffer (if a place exist)
             *   if enhanced - put also scan code
             *
             */

            for ( i = 0 ; (i < pKbd->wRepeatCount) && (KbdInputLength < KbdLength); i++ )
            {
                KBD_BUFFER_ADDRESS[KbdInputLength++] = Char;

                if ((Char == 0x0) && (KbdInputLength < KbdLength))
                {
                    KBD_BUFFER_ADDRESS[KbdInputLength++] = Scan;
                }
            }

            if ( KbdInputLength < KbdLength )
            {
                break;
            } else if ( i < pKbd->wRepeatCount )
            {
                KbdQueue->LastKey = *pKbd;           // prepare it in case we read only one copy of the char
                KbdQueue->LastKey.wRepeatCount -= i;
                KbdQueue->LastKeyFlag = TRUE;
            }

            /*
             *
             * Copy to application buffer
             *
             */

            if ( KbdLength > KbdInputLength )
                KbdLength = KbdInputLength;

           /*
            *
            * Keep info for Read in case we don't return all the string
            *
            */

            KbdBuffNextPtr = KbdLength;
            KbdBuffNextLen = KbdInputLength - KbdLength;

            /*
             *
             * No editing keys in binary mode
             *
             */

            LastStringLength = 0;

            return(0L);

        default:
            break;
    }

#if DBG
    IF_OD2_DEBUG( KBD )
    {
        if ( KbdState == AsciiMode )
        {
            USHORT  CurrentIdx;
            CONSOLE_SCREEN_BUFFER_INFO ConsoleScreenBufferInfo;

            CurrentIdx = (SesGrp->KeysOnFlag) ? KbdIndexInLine : KbdInputLength;

            if (!GetConsoleScreenBufferInfo(
                                         hConOut,
                                         &ConsoleScreenBufferInfo
                                        ))
            {
                ConsoleScreenBufferInfo.dwCursorPosition.X =
                    ConsoleScreenBufferInfo.dwCursorPosition.Y = 255;
                KdPrint(("OS2SES(Ow2VioReadCurPos): Rc %lu\n", GetLastError()));
                ASSERT( FALSE );        // should not happend
            }
            KdPrint(("HandleKeyboardInput: Len %u, CUE-Idx %u, Cur-Offset %u, Prev-Offset %u, Col %u, Pos %u:%u\n",
                    KbdInputLength, KbdIndexInLine,
                    LineInputBuff[CurrentIdx].X_Pos,
                    (CurrentIdx) ? LineInputBuff[CurrentIdx - 1].X_Pos : 255,
                    SesGrp->WinCoord.X,
                    ConsoleScreenBufferInfo.dwCursorPosition.Y,
                    ConsoleScreenBufferInfo.dwCursorPosition.X
                   ));
            if (KbdEchoFlag)
            {
                ASSERT( ConsoleScreenBufferInfo.dwCursorPosition.X == SesGrp->WinCoord.X );
                ASSERT( ConsoleScreenBufferInfo.dwCursorPosition.Y == SesGrp->WinCoord.Y );
                ASSERT( (LineInputBuff[CurrentIdx].X_Pos % SesGrp->ScreenColNum) ==
                        SesGrp->WinCoord.X );
            }
        }
    }
#endif

    return(1L);
}


DWORD
KbdHandlePackage(IN  PKEY_EVENT_QUEUE    NextKbdMon,
                 IN  PKBD_MON_PACKAGE    KbdPackage)
{
    KEYEVENTINFO    In;

    if ( KbdCheckPackage( KbdPackage ))
    {
        return (0L);                // ignore key
    }

#ifdef DBCS
// MSKK Jul.23.1992 KazuM
    In.wRepeatCount = NextKbdMon->In->wRepeatCount;
#else
    In.wRepeatCount = 1;
#endif
    In.KeyInfo[0] = *KbdPackage;

    if ( HandleKeyboardInput( &In ))
    {
        return (0L);                // not time to send reply yet
    }

    NextKbdMon->MonHdr.WaitForEvent = FALSE;

#if DBG
    IF_OD2_DEBUG( KBD )
    {
        KdPrint(("KbdHandlePackage: %s respond\n",
                (KbdRequestSaveArea.Request == KBDCharIn) ? "KbdCharIn" :
                (KbdRequestSaveArea.Request == KBDStringIn) ? "KbdStringIn" :
                "KbdRead"));
    }
#endif
    if ( KbdRequestSaveArea.Request == KBDCharIn )
    {
        KbdRequestSaveArea.d.KeyInfo = In.KeyInfo[0].KeyInfo;

        SendKbdReply((PVOID)NextKbdMon->MonHdr.MemoryStartAddress,
                     (PVOID)&KbdRequestSaveArea,
                     KbdAddress,
                     0);
    } else
    {
        KbdRequestSaveArea.Length = (ULONG)KbdLength;

        if ( KbdRequestSaveArea.Request == KBDStringIn )
        {
            KbdRequestSaveArea.d.String.cchIn = KbdLength;
            if ( KbdRequestSaveArea.d.String.cchIn != KbdRequestSaveArea.d.String.cb )
                KbdRequestSaveArea.Length++ ;             // ASCII mode - copy the CR
        }

        SendKbdReply ((PVOID)NextKbdMon->MonHdr.MemoryStartAddress,
                     (PVOID)&KbdRequestSaveArea,
                     KbdAddress,
                     0);
    }

    return (1L);
}


DWORD
KbdCheckPackage(IN  PKBD_MON_PACKAGE    KbdPackage)
{
    BOOL    IgnoreKey = FALSE;
    UCHAR   Scan, Char;

    Char = KbdPackage->KeyInfo.chChar;
    Scan = KbdPackage->KeyInfo.chScan;

    if (( Char == 0 ) && ( Scan == 0 ))
    {
        if(!( ENABLE_SHIFT_KEY & KbdWaitFlag ))
        {
            /*
             *  Ignore shift keys if { in ASCII mode or shift report off }
             */
#if DBG
            IF_OD2_DEBUG(KBD)
            {
                KdPrint(("                              - ignore since shift report disable\n"));
            }
#endif
            IgnoreKey = TRUE;             // ignore shift report
        } else if(!( KbdPackage->KeyInfo.fbStatus & 1))
        {
            /*
             *  Ignore non-shift keys
             */
#if DBG
            IF_OD2_DEBUG(KBD)
            {
                KdPrint(("                              - ignore since non-shift key\n"));
            }
#endif
            IgnoreKey = TRUE;
        }
    } else if ( KbdPackage->KeyboardFlag & KBD_KEY_BREAK )
    {
        /*
         *  Ignore Break if non-shift
         */

#if DBG
        IF_OD2_DEBUG( KBD )
        {
            KdPrint(("KbdCheckPackage: ignore key release\n"));
        }
#endif
        IgnoreKey = TRUE;         // ignore KEY_UP
    } else if (( KbdWaitFlag & ENABLE_LN_EDITOR_KEY ) &&
                KbdKeyIsTurnAround(Char, Scan) )
    {
        // don't ignore the turn around char in ASCII mode

    } else if ( !( KbdWaitFlag & ENABLE_NON_ASCII_KEY ) &&
                (( Char == 0 ) || ( Char == 0xE0 )))
    {
        IgnoreKey = TRUE;         // ignore NON_ASCII

        if ( KbdWaitFlag & ENABLE_KEYS_ON_KEY )
        {
            if (( Scan == OS2_SCAN_HOME_7 )       ||      // Home
                ( Scan == OS2_SCAN_CTRL_HOME_7 )  ||      // ^Home
                ( Scan == OS2_SCAN_END_1 )        ||      // End
                ( Scan == OS2_SCAN_CTRL_END_1 )   ||      // ^End
                ( Scan == OS2_SCAN_LEFT_4 )       ||      // Left
                ( Scan == OS2_SCAN_CTRL_LEFT_4 )  ||      // ^Left
                ( Scan == OS2_SCAN_RIGHT_6 )      ||      // Right
                ( Scan == OS2_SCAN_CTRL_RIGHT_6 ) ||      // ^Right
                ( Scan == OS2_SCAN_UP_8 )         ||      // Up
                ( Scan == OS2_SCAN_DOWN_2 )       ||      // Down
                ( Scan == OS2_SCAN_DEL )          ||      // Del
                ( Scan == OS2_SCAN_INSERT_0 ))            // Ins
            {
                IgnoreKey = FALSE;         // don't ignore CUE keys
            }
        } else if ( KbdWaitFlag & ENABLE_LN_EDITOR_KEY )
        {
            if (( Scan == 0x3B )                  ||      // F1
                ( Scan == 0x3C )                  ||      // F2
                ( Scan == 0x3D )                  ||      // F3
                ( Scan == 0x3E )                  ||      // F4
                ( Scan == 0x40 )                  ||      // F6
                ( Scan == 0x41 )                  ||      // F7
                ( Scan == OS2_SCAN_LEFT_4 )       ||      // Left
                ( Scan == OS2_SCAN_RIGHT_6 )      ||      // Right
                ( Scan == OS2_SCAN_DEL )          ||      // Del
                ( Scan == OS2_SCAN_INSERT_0 ))            // Ins
            {
                IgnoreKey = FALSE;         // don't ignore editing keys
            }
        }

        if (IgnoreKey)
        {
#if DBG
            IF_OD2_DEBUG( KBD )
            {
                KdPrint(("KbdCheckPackage: ignore non-ASCII key\n"));
            }
#endif
        }
    } else if ( KbdAsciiMode )
    {
        /*
         *
         * Ignore speciel CTRL-Keys in ASCII mode
         *
         */

        if (( Char == 0x03 ) ||     // ^C
            ( Char == 0x10 ) ||     // ^P
                                    // ^Q: in non-US kbd(AZARTY) ^Q is passed
                                    //  and ^A not (mjarus 7/5/93)
            (( Scan == 0x10 ) &&
             ((KbdPackage->KeyInfo.fsState & (OS2_CONTROL | OS2_ALT)) == OS2_CONTROL)) ||
            ( Char == 0x13 ))       // ^S
        {
#if DBG
            IF_OD2_DEBUG(KBD)
            {
                KdPrint(("                              - ignore Char %x in ASCII\n",
                        Char));
            }
#endif
            IgnoreKey = TRUE;         // ignore NON_ASCII
        }
    }

    return ( (DWORD)IgnoreKey );
}


VOID
KbdNewSetup(
    IN PKBDINFO  LastSetup
    )
{
    PKBDINFO    NewSetup = &KbdQueue->Setup;
    USHORT      Mask;

//    if (*LastSetup == *NewSetup)
//        return;

    /* BUGBUG=> handle new setup */

    SesGrp->ModeFlag = (USHORT)((NewSetup->fsMask & KEYBOARD_BINARY_MODE ) ? 1 : 0);

    Mask = NewSetup->fsMask & (KEYBOARD_BINARY_MODE | KEYBOARD_SHIFT_REPORT);

    Ow2KbdXlateVars.XInputMode = (Mask) ?
        ((Mask & KEYBOARD_SHIFT_REPORT) ? (BINARY_MODE | SHIFT_REPORT_MODE) :
            BINARY_MODE) : 0;

    if ((NewSetup->fsMask & KEYBOARD_ASCII_MODE ) &&
        (LastSetup->fsMask & KEYBOARD_BINARY_MODE ))
    {
        LastStringLength = 0;
        KbdBuffNextPtr = 0;
        KbdBuffNextLen = 0;
    }

    KbdAsciiMode = (BOOL)(( NewSetup->fsMask & KEYBOARD_ASCII_MODE ) ? 1 : 0);

    if (NewSetup->fsMask & KEYBOARD_2B_TURNAROUND)
    {
        KbdSetupTurnAroundCharTwo = (BOOLEAN)TRUE;
    } else
    {
        KbdSetupTurnAroundCharTwo = (BOOLEAN)FALSE;
    }

    return;
}


VOID
KbdCueEraseAndDisplayLine(
    IN ULONG    NewLineIndex
    )
/*++

Routine Description:

    This routine erase the current input line and display new one.

Arguments:

    NewLineIndex - pointer in CUE buffer for new line (or to NULL
    if nothing to diaply).

Return Value:


Note:

    ASCII CUE string mode.

    Used by UP-ARROW, DOWN-ARROW and ESC.

    1. Erase the active command line being displayed and
    2. Display the new command in the command queue.

    Uses:

    -   KbdInputLength - active command line length.
    -   KbdIndexInLine - current index in command line.
    -   LineInputBuff[0, KbdIndexInLine, KbdInputLength].X_Pos
    -   KbdCueBuffer[NewLineIndex..]

    Updates:

    -   KbdInputLength - new line length.
    -   KbdIndexInLine - 0.
    -   LineInputBuff[0..KbdInputLength].Char and .X_Pos
    -   console display
    -   LVB
    -   SesGrp->WinCoord - by other routines.

    Calls:

    -   KbdEchoBSAndFillSpaces
    -   KbdCueUpdateBufferOffset
    -   KbdCueMoveToRight
    -   KbdCueMoveToLeft

--*/
{
    /*
     *  Erase the active command line being displayed.
     */

    if ( KbdInputLength )
    {
        KbdEchoBSAndFillSpaces(
                    LineInputBuff[KbdIndexInLine].X_Pos - LineInputBuff[0].X_Pos,
                    LineInputBuff[KbdInputLength].X_Pos - LineInputBuff[0].X_Pos
                    );

        KbdIndexInLine = 0;
        KbdInputLength = 0;
    }

    /*
     *  Display the new command in the command queue
     */

    for ( KbdInputLength = 0 ;
          LineInputBuff[KbdInputLength].Char = KbdCueBuffer[NewLineIndex + KbdInputLength] ;
          KbdInputLength++ );

    if (KbdInputLength)
    {
        KbdCueUpdateBufferOffset(
                    0,
                    KbdInputLength,
                    LineInputBuff[0].X_Pos
                   );

        KbdCueMoveToRight(
                    0,
                    KbdInputLength,
                    TRUE
                   );

        KbdCueMoveToLeft(
                    KbdInputLength,
                    KbdInputLength
                   );
    }
}


VOID
KbdCueMoveToRight(
    IN  ULONG   StartIndex,
    IN  ULONG   StringLength,
    IN  ULONG   UpdateLVB
    )
/*++

Routine Description:

    This routine moves the console cursor position to the right
    while sending the active command line to the console.

Arguments:

    StartIndex - index in LineInputBuff[] (the active command line) to start
    moving right from.

    StringLength - number of character to move right.

    UpdateLVB - flag if to set LVB also (for new info)

Return Value:


Note:

    ASCII CUE string mode.

    Used by RIGHT-ARROW, END, ^RIGHT-ARROW, KbdCueEraseAndDisplayLine,
    KbdCueDeleteCharAndShift and KbdCueHandleChar.

    1. Send to console
    2. Update Coord
    3. Update LVB
    4. Update position

    Uses:

    -   LineInputBuff[0..KbdInputLength].Char and .X_Pos

    Updates:

    -   KbdInputLength - NO.
    -   KbdIndexInLine - add StringLength.
    -   LineInputBuff[0..KbdInputLength].Char and .X_Pos - NO
    -   console display
    -   LVB (if UpdateLVB)
    -   SesGrp->WinCoord - add StringLength.

    Calls:

    -   Or2WinWriteConsoleA
    -   Ow2VioUpdateCurPos
    -   VioLVBScrollBuff
    -   VioLVBCopyStr

--*/
{
    UCHAR       Char;
    ULONG       NumChar, NumBytes, NumWritten, NumLines = 0;
    COORD       OldCoord, Coord;

    OldCoord = Coord = GET_CURRENT_COORD;

    /*
     *  Copy to temp buffer
     */

    for ( NumBytes = 0, NumChar = 0 ; NumChar < StringLength ; NumChar++ )
    {
        if ((Char = LineInputBuff[StartIndex + NumChar].Char) < ' ')
        {
            KBD_BUFFER_ADDRESS[NumBytes++] = '^';
            KBD_BUFFER_ADDRESS[NumBytes++] = (UCHAR)(Char + '@');
        } else
        {
            KBD_BUFFER_ADDRESS[NumBytes++] = Char;
        }
    }

    if (!NumBytes)
    {
        return ;
    }

    if ( KbdEchoFlag )
    {
        /*
         *   Send to console
         */

        if(!Or2WinWriteConsoleA(
                    #if DBG
                    KbdCueMoveToRightStr,
                    #endif
                    hConOut,
                    (LPSTR)KBD_BUFFER_ADDRESS,
                    NumBytes,
                    &NumWritten,
                    NULL
                   ))
        {
#if DBG
            ASSERT1("OS2SES(KbdCueMoveToRight): failed on WriteConsoleA", FALSE);
#endif
        }

#if DBG
        if ( NumBytes != NumWritten )
        {
            KdPrint(("OS2SES(KbdCueMoveToRight): partial data WriteConsoleA (%u from %u)\n",
                    NumWritten, NumBytes));
            ASSERT( FALSE );
        }
#endif

        /*
         *  Update Coord
         */

        Coord.X += (SHORT)NumWritten;
        while ( Coord.X >= SesGrp->ScreenColNum )
        {
            Coord.Y++;
            Coord.X -= SesGrp->ScreenColNum;
        }

        if ( Coord.Y >= SesGrp->ScreenRowNum )
        {
            NumLines = Coord.Y - SesGrp->ScreenRowNum + 1;
            Coord.Y = SesGrp->ScreenRowNum - 1;
        }

        Ow2VioUpdateCurPos(Coord);

        /*
         *  Update LVB
         */

        if ( UpdateLVB )
        {
            if ( NumLines && ( SesGrp->ScreenSize < 512 ))
            {
                ULONG   NumChar1 = SesGrp->ScreenRowNum - OldCoord.X;
                UCHAR   *Ptr = &KBD_BUFFER_ADDRESS[0];

                while ( NumWritten )
                {
                    VioLVBCopyStr(
                               Ptr,
                               OldCoord,
                               NumChar1
                              );

                    VioLVBFillAtt(
                               SesGrp->AnsiCellAttr,
                               OldCoord,
                               NumChar1
                              );

                    OldCoord.X = 0;

                    if ( ++OldCoord.Y >= SesGrp->ScreenRowNum )
                    {
                        OldCoord.Y--;
                        VioLVBScrollBuff(1);
                        NumLines--;
                    }

                    NumWritten -= NumChar1;

                    if (( NumChar1 = NumWritten ) > (ULONG)SesGrp->ScreenColNum )
                    {
                        NumChar1 = SesGrp->ScreenColNum;
                    }
                }

                ASSERT( NumLines == 0 );
            } else
            {
                if ( NumLines )
                {
                    OldCoord.Y -= (SHORT)NumLines;
                    VioLVBScrollBuff(NumLines);
                }

                VioLVBCopyStr(
                           KBD_BUFFER_ADDRESS,
                           OldCoord,
                           NumWritten
                          );

                VioLVBFillAtt(
                           SesGrp->AnsiCellAttr,
                           OldCoord,
                           NumWritten
                          );
            }
        }
    }

    /*
     *  Update position index
     */

    KbdIndexInLine += (USHORT)StringLength;
}


VOID
KbdCueMoveToLeft(
    IN  ULONG   StartIndex,
    IN  ULONG   MoveLength
    )
/*++

Routine Description:

    This routine moves the console cursor position to the left
    using '\b'.

Arguments:

    StartIndex - index in LineInputBuff[] (the active command line) to start
    moving left from.

    MoveLength - number of character to move left.

Return Value:


Note:

    ASCII CUE string mode.

    Used by LEFT-ARROW, HOME, ^LEFT-ARROW, ^HOME, BS, KbdCueEraseAndDisplayLine,
    KbdCueDeleteCharAndShift and KbdCueHandleChar.

    1. Send to console
    2. Update position

    Uses:

    -   LineInputBuff[StartIndex - MoveLength,StartIndex].X_Pos
    -   LineInputBuff[StartIndex - MoveLength..StartIndex].Char

    Updates:

    -   KbdInputLength - NO.
    -   KbdIndexInLine - sub MoveLength.
    -   LineInputBuff[0..KbdInputLength].Char and .X_Pos - NO
    -   console display - NO
    -   LVB - NO
    -   SesGrp->WinCoord - by other routines.

    Calls:

    -   KbdEchoBSAndFillSpaces

--*/
{
    ULONG       NumBytes;

    /*
     *  Calculate byte count
     */

    NumBytes = LineInputBuff[StartIndex].X_Pos - LineInputBuff[StartIndex - MoveLength].X_Pos;

    if (!NumBytes)
    {
        return ;
    }

    if ( KbdEchoFlag )
    {
        if ( SesGrp->ScreenSize < 512 )
        {
            ULONG   Row1, Row2;

            Row1 = LineInputBuff[StartIndex - MoveLength].X_Pos / SesGrp->ScreenColNum;
            Row2 = LineInputBuff[KbdInputLength].X_Pos / SesGrp->ScreenColNum;

            if (( Row2 - Row1 + 1 ) > (ULONG)SesGrp->ScreenRowNum )
            {
                NumBytes += LineInputBuff[StartIndex - MoveLength].X_Pos % SesGrp->ScreenColNum;
                NumBytes -= (Row2 - Row1 + 1 - SesGrp->ScreenRowNum) * SesGrp->ScreenColNum;
            }
        }

        /*
         *   Send to console and update coord
         */

        KbdEchoBSAndFillSpaces(NumBytes, 0);
    }

    /*
     *  Update position index
     */

    KbdIndexInLine -= (USHORT)MoveLength;
}


VOID
KbdCueUpdateBufferOffset(
    IN  ULONG   StartIndex,
    IN  ULONG   StringLength,
    IN  ULONG   StartOffset
    )
/*++

Routine Description:

    This routine updates the offset in buffer for the active command line.
    This is done from StartIndex for StringLength + 1 (to update the offset
    of the next char according to the last char in string). The StartIndex
    gets X_Pos of StartOffset and the following are updated according the
    char type (char under 0x20 holds two columns for ^X).

Arguments:

    StartIndex - index in LineInputBuff[] (the active command line) to start
    updaing the X_Pos field from.

    StringLength - number of character to update X_Pos for.

    StartOffset - X_Pos for the first character.

Return Value:


Note:

    ASCII CUE string mode.

    Used by KbdCueEraseAndDisplayLine, KbdCueDeleteCharAndShift and
    KbdCueHandleChar.

    1. Updates the X_Pos field in LineInputBuff[].

    Uses:

    -   KbdInputLength - active command line length.
    -   KbdIndexInLine - current index in command line.
    -   LineInputBuff[0, KbdIndexInLine, KbdInputLength].X_Pos
    -   KbdCueBuffer[NewLineIndex..]

--*/
{
    ULONG       NumChar, Index, Offset;

    /*
     *  Update the offset in buffer. This is done for StringLength + 1
     *  to update the offset of the next char according to the last char
     *  in string.
     */

    for ( Index = StartIndex, Offset = StartOffset, NumChar = 0 ;
          NumChar <= StringLength ; NumChar++ )
    {
        LineInputBuff[Index].X_Pos = (USHORT)Offset++;

        if ( LineInputBuff[Index++].Char < ' ' )
        {
            Offset++;
        }
    }
}


VOID
KbdCueDeleteCharAndShift(
    IN  ULONG   StartIndex,
    IN  ULONG   NumChar
    )
/*++

Routine Description:

    This routine delete character and shift the remaining command line
    input to the left.

Arguments:

    StartIndex - index in LineInputBuff[] (the active command line) to start
    deleting from.

    NumChar - number of character to delete.

Return Value:


Note:

    ASCII CUE string mode.

    Used by DEL, ^HOME and BS.

    1  Shift buffer info (Char field)
    2  Update X_Pos (Offset) field in the shifted area
    3  Send the shifted string to console and LVB
    4  Clear remaining line
    5  Return to the cursor position

    Uses:

    -   LineInputBuff[].X_Pos and Char

    Updates:

    -   KbdInputLength - sub NumChar.
    -   KbdIndexInLine - NO
    -   LineInputBuff[0..KbdInputLength].Char and .X_Pos
    -   console display
    -   LVB
    -   SesGrp->WinCoord - by other routines.

    Calls:

    -   KbdCueUpdateBufferOffset
    -   KbdCueMoveToRight
    -   KbdEchoBSAndFillSpaces
    -   KbdCueMoveToLeft

--*/
{
    if (NumChar)
    {
        ULONG       Offset = LineInputBuff[StartIndex].X_Pos;
        ULONG       Delta = LineInputBuff[StartIndex + NumChar].X_Pos - Offset;
        ULONG       NumShift = KbdInputLength - StartIndex - NumChar;

        if ( NumShift )
        {
            /*
             *  Shift buffer info (Char field)
             */

            RtlMoveMemory(
                        &LineInputBuff[StartIndex].Char,
                        &LineInputBuff[StartIndex + NumChar].Char,
                        NumShift * sizeof(LINE_EDIT_KBD)
                       );

            /*
             *  Update X_Pos (Offset) field in the shifted area
             */

            KbdCueUpdateBufferOffset(
                        StartIndex,
                        NumShift,
                        Offset
                       );

            /*
             *  Send the shifted string to console and LVB
             */

            KbdCueMoveToRight(
                        StartIndex,
                        NumShift,
                        TRUE
                       );
        }

        /*
         *  Clear remaining line
         */

        KbdEchoBSAndFillSpaces(0, Delta);

        /*
         *  Return to the cursor position
         */

        KbdCueMoveToLeft(
                    StartIndex + NumShift,
                    NumShift
                   );

        KbdInputLength -= (USHORT)NumChar;
    }
}


VOID
KbdCueHandleChar(
    IN  UCHAR       Char,
    IN  ULONG       Count
    )
/*++

Routine Description:

    This routine handle new char at CUE mode.

Arguments:

    Char - char to handle.

    NumChar - number of character.

Return Value:


Note:

    ASCII CUE string mode.

    Used by CHAR.

    For INSERT:
    1  Shift buffer info (Char field)
    2  Fill new char
    3  Update X_Pos (Offset) field
    4  Send the new+old string to console and LVB
    5  Return to the cursor position
    6  Beep if no place
    Else:
    1  Shift buffer info (Char field)
    2  Fill new char
    3  Update X_Pos (Offset) field
    4  Send the shifted string to console and LVB
    5  Clear remaining line
    6  Return to the cursor position
    7  Beep if no place

    Uses:

    -   LineInputBuff[].X_Pos and Char
    -   KbdInsertOn
    -   KbdIndexInLine
    -   KbdMaxLength
    -   KbdInputLength

    Updates:

    -   KbdInputLength
    -   KbdIndexInLine
    -   LineInputBuff[0..KbdInputLength].Char and .X_Pos
    -   console display
    -   LVB
    -   SesGrp->WinCoord - by other routines.

    Calls:

    -   KbdCueUpdateBufferOffset
    -   KbdCueMoveToRight
    -   KbdCueMoveToLeft
    -   KbdEchoBSAndFillSpaces
    -   KbdEchoBeep
    -   RtlMoveMemory

--*/
{
    ULONG   NumChar, NumBeep = 0, NumShift, UpdateRight, i;
    ULONG   LastOffset = LineInputBuff[KbdInputLength].X_Pos;

    if ( KbdInsertOn )
    {
        if (( NumChar = KbdMaxLength - KbdInputLength ) > Count )
        {
            NumChar = Count;
        } else
        {
            NumBeep = Count - NumChar;
        }

        /*
         *  Shift buffer info (Char field) to free space for new char
         */

        NumShift = KbdInputLength - KbdIndexInLine;

        RtlMoveMemory(
                    &LineInputBuff[KbdIndexInLine + NumChar].Char,
                    &LineInputBuff[KbdIndexInLine].Char,
                    NumShift * sizeof(LINE_EDIT_KBD)
                   );
        /*
         *  Fill new char
         */

        for ( i = 0 ; i < NumChar ; i++ )
        {
            LineInputBuff[KbdIndexInLine + i].Char = Char;
        }

        /*
         *  Update X_Pos (Offset) field in the shifted and new areas
         */

        KbdCueUpdateBufferOffset(
                    KbdIndexInLine,
                    NumChar + NumShift,
                    LineInputBuff[KbdIndexInLine].X_Pos
                   );

        /*
         *  Send the shifted string to console and LVB
         */

        KbdCueMoveToRight(
                    KbdIndexInLine,
                    NumChar + NumShift,
                    TRUE
                   );

        /*
         *  Return to the cursor position
         */

        KbdCueMoveToLeft(
                    KbdIndexInLine,
                    NumShift
                   );

        KbdInputLength += (USHORT)NumChar;
    } else
    {
        if (( NumChar = KbdMaxLength - KbdIndexInLine ) > Count )
        {
            NumChar = Count;
        } else
        {
            NumBeep = Count - NumChar;
        }

        UpdateRight = max(NumChar, (ULONG)(KbdInputLength - KbdIndexInLine));

        /*
         *  Fill new char
         */

        for ( i = 0 ; i < NumChar ; i++ )
        {
            LineInputBuff[KbdIndexInLine + i].Char = Char;
        }

        /*
         *  Update X_Pos (Offset) field in the old and new areas
         */

        KbdCueUpdateBufferOffset(
                    KbdIndexInLine,
                    UpdateRight,
                    LineInputBuff[KbdIndexInLine].X_Pos
                   );

        /*
         *  Send the shifted string to console and LVB
         */

        KbdCueMoveToRight(
                    KbdIndexInLine,
                    UpdateRight,
                    TRUE
                   );

        if ( LastOffset > (ULONG)LineInputBuff[KbdIndexInLine].X_Pos )
        {
            /*
             *  Fill spaces at the EOL if needed
             */

            KbdEchoBSAndFillSpaces(
                        0,
                        LastOffset - LineInputBuff[KbdIndexInLine].X_Pos
                       );
        }

        if ( UpdateRight != NumChar )
        {
            /*
             *  Return to the cursor position
             */

            KbdCueMoveToLeft(
                        KbdIndexInLine,
                        UpdateRight - NumChar
                       );
        }

        if ( KbdIndexInLine > KbdInputLength )
        {
            KbdInputLength = KbdIndexInLine;
        }
    }

    if ( NumBeep != Count )
    {
        KbdLineWasEdited = TRUE;
    }

    if ( NumBeep )
    {
        KbdEchoBeep(NumBeep);
    }
}


VOID
KbdCueSetCurTypeToHalf()
{
    VIOCURSORINFO  CurType;

    //Ow2VioGetCurType((PVOID)&CurType);
    //CurType = SesGrp->CursorInfo;

    //CurType.cEnd = SesGrp->CellVSize;
    CurType.cEnd = SesGrp->CursorInfo.cEnd;
    CurType.yStart = (CurType.cEnd + 1 ) / 2;
    CurType.cx = 1;
    CurType.attr = 0;

    Ow2VioSetCurType((PVOID)&CurType);
}


VOID
KbdCueSetCurTypeToQuater()
{
    VIOCURSORINFO  CurType;

    //Ow2VioGetCurType((PVOID)&CurType);
    //CurType = SesGrp->CursorInfo;

    //CurType.cEnd = SesGrp->CellVSize;
    CurType.cEnd = SesGrp->CursorInfo.cEnd;
    CurType.yStart = (CurType.cEnd + 1 ) * 3 / 4;
    CurType.cx = 1;
    CurType.attr = 0;

    Ow2VioSetCurType((PVOID)&CurType);
}


DWORD
KbdEchoCharToConsole(
    IN UCHAR    Char,
    IN ULONG    Count
    )
/*++

Routine Description:

    This routine write <Char> to console <Count> times.

Arguments:

    Char - character to write.

    Count - number of times to write char

Return Value:


Note:

    ASCII CUE/EDIT string mode.

    Used by KbdEchoNL, KbdEchoBSAndFillSpaces, KbdEchoBeep and KbdEchoChar.

    Calls:

    -   Or2WinWriteConsoleA

--*/
{
    ULONG   NumChar, NumWritten, MaxCount = Count;

    NumChar = (MaxCount > KBD_BUFFER_SIZE) ? KBD_BUFFER_SIZE : MaxCount;
    memset(KBD_BUFFER_ADDRESS, Char, NumChar);

    while (MaxCount)
    {
        if(!Or2WinWriteConsoleA(
                           #if DBG
                           KbdEchoCharToConsoleStr,
                           #endif
                           hConOut,
                           (LPSTR)KBD_BUFFER_ADDRESS,
                           NumChar,
                           &NumWritten,
                           NULL))
        {
#if DBG
            ASSERT1("OS2SES(KbdEchoCharToConsole): failed on WriteConsoleA", FALSE);
#endif
        }

#if DBG
        if ( NumChar != NumWritten )
        {
            KdPrint(("OS2SES(KbdEchoCharToConsole): partial data WriteConsoleA %u from %u\n",
                    NumWritten, NumChar));
            ASSERT( FALSE );
        }
#endif

        MaxCount -= NumChar;
        NumChar = (MaxCount > KBD_BUFFER_SIZE) ? KBD_BUFFER_SIZE : MaxCount;
    }

    return(NO_ERROR);
}


DWORD
KbdEchoNL(
    IN ULONG    Count
    )
/*++

Routine Description:

    This routine write NL to console <Count> times and update LVB.

Arguments:

    Count - number of times to write char

Return Value:


Note:

    ASCII CUE/EDIT string mode.

    Used by LF (EDIT only) and CR.

    Updates:

    -   SesGrp->WinCoord
    -   LVB

    Calls:

    -   KbdEchoCharToConsole
    -   VioLVBScrollBuff

--*/
{
    ULONG       NumLines = 0;
    COORD       Coord = GET_CURRENT_COORD;

    Coord.X = 0;
    Coord.Y += (SHORT)Count;
    if ( Coord.Y >= SesGrp->ScreenRowNum )
    {
        NumLines = Coord.Y - SesGrp->ScreenRowNum + 1;
        Coord.Y = SesGrp->ScreenRowNum - 1;
    }

    KbdEchoCharToConsole('\n', Count);
    Ow2VioUpdateCurPos(Coord);

    if (NumLines)
    {
        VioLVBScrollBuff(NumLines);
    }

    return(NO_ERROR);
}


DWORD
KbdEchoESC(
    IN ULONG    Count,
    IN ULONG    HorzMove
    )
/*++

Routine Description:

    This routine write <ESC> to console <Count> times with <HorzMove>
    number of spaces on the next line. It also update LVB.

Arguments:

    Count - number of times to write char

    HorzMove - number of spaces on the start of the new line.

Return Value:


Note:

    ASCII EDIT string mode.

    Used by ESC.

    Updates:

    -   SesGrp->WinCoord
    -   LVB

    Calls:

    -   Or2WinWriteConsoleA
    -   VioLVBScrollBuff

--*/
{
    ULONG       NumChar, NumWritten, MaxCount = Count, NumLines = 0, Length = HorzMove + 1;
    COORD       OldCoord, Coord;

    OldCoord = Coord = GET_CURRENT_COORD;

    KBD_BUFFER_ADDRESS[0] = '\\';
    KBD_BUFFER_ADDRESS[1] = '\n';
    memset(&KBD_BUFFER_ADDRESS[2], ' ', HorzMove);
    KBD_BUFFER_ADDRESS[HorzMove + 2] = '\\';
    NumChar = HorzMove + 2;

    Coord.Y += (SHORT)Count;
    Coord.X = (SHORT)HorzMove;

    if ( Coord.Y >= SesGrp->ScreenRowNum )
    {
        NumLines = Coord.Y - SesGrp->ScreenRowNum + 1;
        Coord.Y = SesGrp->ScreenRowNum - 1;
    }

    while ( MaxCount )
    {
        if(!Or2WinWriteConsoleA(
                           #if DBG
                           KbdEchoESCStr,
                           #endif
                           hConOut,
                           (LPSTR)KBD_BUFFER_ADDRESS,
                           NumChar,
                           &NumWritten,
                           NULL))
        {
#if DBG
            ASSERT1("OS2SES(KbdEchoESC): failed on WriteConsoleA", FALSE);
#endif
            //return (1);
        }

#if DBG
        if ( NumChar != NumWritten )
        {
            KdPrint(("OS2SES(KbdEchoESC): partial data WriteConsoleA %u from %u\n",
                    NumWritten, NumChar));
            ASSERT( FALSE );
        }
#endif

        MaxCount--;
    }

    Ow2VioUpdateCurPos(Coord);

    VioLVBFillChar(
#ifdef DBCS
// MSKK Oct.14.1993 V-AkihiS
                "\\",
#else
                '\\',
#endif
                OldCoord,
                1
               );

    VioLVBFillAtt(
               SesGrp->AnsiCellAttr,
               OldCoord,
               1
              );

    OldCoord.X = 0;

    for ( NumChar = 0 ; NumChar < Count ; NumChar++ )
    {
        if ( ++OldCoord.Y >= SesGrp->ScreenRowNum )
        {
            OldCoord.Y--;
            VioLVBScrollBuff(1);
            NumLines--;
        }

        if ( NumChar == ( Count - 1 ))
        {
            Length--;           // don't put the slash at the last line
        }

        VioLVBCopyStr(
                    &KBD_BUFFER_ADDRESS[2],
                    OldCoord,
                    Length
                   );

        VioLVBFillAtt(
                   SesGrp->AnsiCellAttr,
                   OldCoord,
                   Length
                  );
    }

    ASSERT( NumLines == 0 );
    return(NO_ERROR);
}


DWORD
KbdEchoBSAndFillSpaces(
    IN ULONG    BSCount,
    IN ULONG    SpaceCount
    )
/*++

Routine Description:

    This routine write BS ('\b') to console <BSCount> times and fill
    <SpaceCount> times spaces in console and LVB.

Arguments:

    BSCount - number of times to write \b char to console

    SpaceCount - number of times to fill space char to console and LVB

Return Value:


Note:

    ASCII EDIT/CUE string mode.

    Used by ^END, BS (EDIT only), LF (EDIT only), KbdCueEraseAndDisplayLine,
    KbdCueMoveToLeft, KbdCueDeleteCharAndShift and KbdCueHandleChar.

    Updates:

    -   SesGrp->WinCoord (for BSCount only)
    -   LVB (for SpaceCount only)

    Calls:

    -   KbdEchoCharToConsole
    -   Or2WinFillConsoleOutputCharacterA
    -   VioLVBFillChar

--*/
{
    ULONG       NumFilled;
    COORD       OldCoord, Coord;

    if ( !KbdEchoFlag )
    {
        return (0L);
    }

    if (((long) BSCount < 0) || ((long) SpaceCount < 0)) {
#if DBG
        DbgPrint("KbdEchoBSAndFillSpaces: BSCount %d or SpaceCount %d are negative\n",
                (long)BSCount, (long)SpaceCount);
#endif
        return ERROR_INVALID_PARAMETER;
    }

    OldCoord = Coord = GET_CURRENT_COORD;

    Coord.X -= (SHORT)BSCount;
    while ( Coord.X < 0 )
    {
        if ( Coord.Y )
        {
            Coord.Y--;
            Coord.X += SesGrp->ScreenColNum;
        } else
        {
            if ( SpaceCount )
            {
                if ( SpaceCount > (ULONG)abs(Coord.X) )
                {
                    SpaceCount += (ULONG)Coord.X;
                } else
                {
                    SpaceCount = 0;
                }
            }

            BSCount += (ULONG)Coord.X;      // sub the negative value
            Coord.X = 0;
        }
    }

    KbdEchoCharToConsole('\b', BSCount);
    Ow2VioUpdateCurPos(Coord);

    if ( SpaceCount )
    {
        if (!Or2WinFillConsoleOutputCharacterA(
                                #if DBG
                                KbdEchoBSAndFillSpacesStr,
                                #endif
                                hConOut,
                                ' ',
                                SpaceCount,
                                Coord,
                                &NumFilled))
        {
#if DBG
            ASSERT1("OS2SES(KbdEchoBSAndFillSpaces): failed on FillConsoleOutputCharacterA\n", FALSE);
#endif
        }

#if DBG
        if ( NumFilled != SpaceCount )
        {
            KdPrint(("OS2SES(KbdEchoBSAndFillSpaces): partial data %u from %u\n",
                    NumFilled, SpaceCount));
            ASSERT( FALSE );
        }
#endif
        VioLVBFillChar(
#ifdef DBCS
// MSKK Oct.14.1993 V-AkihiS
                    " ",
#else
                    ' ',
#endif
                    Coord,
                    SpaceCount
                   );

        VioLVBFillAtt(
                   SesGrp->AnsiCellAttr,
                   Coord,
                   SpaceCount
                  );
    }
    return(NO_ERROR);
}


DWORD
KbdEchoBeep(
    IN ULONG    Count
    )
/*++

Routine Description:

    This routine send BEPP ('\07') to console <Count> times.

Arguments:

    Count - number of times to write \g char to console

Return Value:


Note:

    ASCII EDIT/CUE string mode.

    Used when no place in the active command line by KbdEchoString,
    Char and KbdCueHandleChar.

    Calls:

    -   KbdEchoCharToConsole

--*/
{
    KbdEchoCharToConsole('\07', Count);
    return(NO_ERROR);
}


DWORD
KbdEchoChar(
    IN UCHAR    Char,
    IN ULONG    Count
    )
/*++

Routine Description:

    This routine echo <Char> to console <Count> times and update LVB.

Arguments:

    Char - char to send to console

    Count - number of times to send char to console

Return Value:


Note:

    ASCII EDIT string mode.

    Updates:

    -   SesGrp->WinCoord
    -   LVB

    Calls:

    -   KbdEchoCharToConsole
    -   VioLVBScrollBuff

--*/
{
    COORD       OldCoord, Coord;
    BOOL        SendByLine = FALSE;
    UCHAR       FillChar;
    ULONG       Offset;

    OldCoord = Coord = GET_CURRENT_COORD;
    if (( Char >= ' ' ) || ( Char == '\t' ))
    {
        KbdEchoCharToConsole(Char, Count);

        if ( Char == '\t' )
        {
            Offset = 8 * Count - (Coord.X & 7);
            FillChar = ' ';
        } else
        {
            FillChar = Char;
            Offset = Count;
        }

        if ((ULONG)( Offset + 2 * SesGrp->ScreenColNum ) > SesGrp->ScreenSize )
        {
            SendByLine = TRUE;
        } else
        {
            Coord.X += (SHORT)Offset;
            while ( Coord.X >= SesGrp->ScreenColNum )
            {
                Coord.Y++;
                Coord.X -= SesGrp->ScreenColNum;
            }

            if ( Coord.Y >= SesGrp->ScreenRowNum )
            {
                VioLVBScrollBuff(Coord.Y - SesGrp->ScreenRowNum + 1);
                OldCoord.Y -= Coord.Y - SesGrp->ScreenRowNum + 1;
                Coord.Y = SesGrp->ScreenRowNum - 1;
            }

            Ow2VioUpdateCurPos(Coord);

            VioLVBFillChar(
#ifdef DBCS
// MSKK Oct.14.1993 V-AkihiS
                        &FillChar,
#else
                        FillChar,
#endif
                        OldCoord,
                        Offset
                       );

            VioLVBFillAtt(
                       SesGrp->AnsiCellAttr,
                       OldCoord,
                       Offset
                      );
        }
    }

    if ( SendByLine || (( Char < ' ' ) && ( Char != '\t' )))
    {
        ULONG   NumChar, NumWritten, MaxCount, Pattern;

        if ( SendByLine )
        {
            Pattern = (ULONG)((FillChar << 24) |
                              (FillChar << 16) |
                              (FillChar << 8) |
                              (FillChar));

            MaxCount = 0;
        } else
        {
            MaxCount = Offset = 2 * Count;
            FillChar = (UCHAR)(Char + '@');

            Pattern = (ULONG)((FillChar << 24) |
                              ('^' << 16) |
                              (FillChar << 8) |
                              ('^'));
        }

        NumChar = ( Offset > KBD_BUFFER_SIZE ) ? KBD_BUFFER_SIZE : Offset;

        RtlFillMemoryUlong(
                KBD_BUFFER_ADDRESS,
                (NumChar + 3) & ~3,
                Pattern
               );

        while ( MaxCount )
        {
            if(!Or2WinWriteConsoleA(
                               #if DBG
                               KbdEchoCharStr,
                               #endif
                               hConOut,
                               (LPSTR)KBD_BUFFER_ADDRESS,
                               NumChar,
                               &NumWritten,
                               NULL))
            {
#if DBG
                ASSERT1("OS2SES(KbdEchoChar): failed on WriteConsoleA", FALSE);
#endif
                //return (1);
            }

#if DBG
            if ( NumChar != NumWritten )
            {
                KdPrint(("OS2SES(KbdEchoChar): partial data WriteConsoleA %u from %u\n",
                        NumWritten, NumChar));
                ASSERT( FALSE );
            }
#endif

            MaxCount -= NumChar;
            NumChar = ( MaxCount > KBD_BUFFER_SIZE ) ? KBD_BUFFER_SIZE : MaxCount;
        }

        if (( NumChar = SesGrp->ScreenColNum - Coord.X ) > Offset )
        {
            NumChar = Offset;
        }

        while ( Offset )
        {
            VioLVBCopyStr(
                        &KBD_BUFFER_ADDRESS[0],
                        Coord,
                        NumChar
                       );


            VioLVBFillAtt(
                       SesGrp->AnsiCellAttr,
                       Coord,
                       NumChar
                      );
            Coord.X += (SHORT)NumChar;
            if ( Coord.X >= SesGrp->ScreenColNum )
            {
                Coord.X -= SesGrp->ScreenColNum;
                if ( ++Coord.Y >= SesGrp->ScreenRowNum )
                {
                    VioLVBScrollBuff(1);
                    Coord.Y--;
                }
            }

            Offset -= NumChar;
            if (( NumChar = SesGrp->ScreenColNum - Coord.X ) > Offset )
            {
                NumChar = Offset;
            }
        }

        Ow2VioUpdateCurPos(Coord);
    }

    return(NO_ERROR);
}


DWORD
KbdEchoAString(
    IN PUCHAR   String,
    IN ULONG    Length
    )
/*++

Routine Description:

    This routine echo <String>, which size is <Lenght> to console and update LVB.

Arguments:

    String - char string to send to console

    Length - string length

Return Value:


Note:

    ASCII EDIT string mode.

    Updates:

    -   SesGrp->WinCoord
    -   LVB

    Calls:

    -   Or2WinWriteConsoleA

--*/
{
    ULONG       NumWritten, NumChar, NumBytes, Num;
    COORD       OldCoord, Coord;
    UCHAR       Char;

    OldCoord = Coord = GET_CURRENT_COORD;

    for ( NumChar = 0, NumBytes = 0 ; NumChar < Length ; NumChar++ )
    {
        Char = String[NumChar];
        if ( Char >= ' ' )
        {
            KBD_BUFFER_ADDRESS[NumBytes++] = Char;
        } else if ( Char = '\t' )
        {
            Num = 8 - ((Coord.X + NumBytes) & 7);
            memset(&KBD_BUFFER_ADDRESS[NumBytes], ' ', Num);
            NumBytes += Num;
        } else
        {
            KBD_BUFFER_ADDRESS[NumBytes++] = '^';
            KBD_BUFFER_ADDRESS[NumBytes++] = (UCHAR)(Char + '@');
        }

        if (((ULONG)( Coord.X + NumBytes ) >= (ULONG)SesGrp->ScreenColNum ) ||
            ( NumChar == ( Length - 1 )))
        {
            if(!Or2WinWriteConsoleA(
                               #if DBG
                               KbdEchoAStringStr,
                               #endif
                               hConOut,
                               (LPSTR)KBD_BUFFER_ADDRESS,
                               NumBytes,
                               &NumWritten,
                               NULL))
            {
#if DBG
                ASSERT1("OS2SES(KbdEchoAString): failed on WriteConsoleA", FALSE);
#endif
            }

#if DBG
            if ( NumBytes != NumWritten )
            {
                KdPrint(("OS2SES(KbdEchoAString): partial data WriteConsoleA %u from %u\n",
                        NumWritten, NumBytes));
                ASSERT( FALSE );
            }
#endif
            OldCoord = Coord;
            Coord.X += (SHORT)NumBytes;
            if ( Coord.X >= SesGrp->ScreenColNum )
            {
                Coord.Y++;
                Coord.X -= SesGrp->ScreenColNum;

                if ( Coord.Y >= SesGrp->ScreenRowNum )
                {
                    Coord.Y = SesGrp->ScreenRowNum - 1;
                    OldCoord.Y--;
                }
            }

            Ow2VioUpdateCurPos(Coord);

            VioLVBCopyStr(
                        &KBD_BUFFER_ADDRESS[0],
                        OldCoord,
                        NumBytes
                       );

            VioLVBFillAtt(
                       SesGrp->AnsiCellAttr,
                       OldCoord,
                       NumBytes
                      );
            NumBytes = 0;
        }
    }
    return(NO_ERROR);
}


BOOL
KbdKeyIsTurnAround(
    IN  UCHAR   Char,
    IN  UCHAR   Scan
    )
{
    if ( KbdTurnAroundCharTwo )
    {
        if ( Scan == (UCHAR)KbdTurnAroundChar )
        {
            if ((( KbdReadMode == 0 ) &&
                 (( Char == 0 ) || ( Char == 0xE0 ))) ||
                (( KbdReadMode == 1 ) && ( Char == HIBYTE(KbdTurnAroundChar) )))
            {
                return(TRUE);
            }
        }
    } else
    {
         if ( Char == (UCHAR)KbdTurnAroundChar )
         {
             return(TRUE);
         }
    }

    return(FALSE);
}