windows-server-2003/windows/core/ntuser/kernel/access.c

/****************************** Module Header ******************************\
* Module Name: access.c
*
* Copyright (c) 1985 - 1999, Microsoft Corporation
*
* This module contains the Access Pack functions.
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/

#include "precomp.h"
#pragma hdrstop

CONST ACCESSIBILITYPROC aAccessibilityProc[] = {
    HighContrastHotKey,
    FilterKeys,
    xxxStickyKeys,
    MouseKeys,
    ToggleKeys
#if 0
    ,UtilityManager
#endif
};

typedef struct tagMODBITINFO {
    int BitPosition;
    BYTE ScanCode;
    USHORT Vk;
} MODBITINFO, *PMODBITINFO;

CONST MODBITINFO aModBit[] =
{
    { 0x01, SCANCODE_LSHIFT, VK_LSHIFT },
    { 0x02, SCANCODE_RSHIFT, VK_RSHIFT | KBDEXT },
    { 0x04, SCANCODE_CTRL, VK_LCONTROL },
    { 0x08, SCANCODE_CTRL, VK_RCONTROL | KBDEXT },
    { 0x10, SCANCODE_ALT, VK_LMENU },
    { 0x20, SCANCODE_ALT, VK_RMENU | KBDEXT },
    { 0x40, SCANCODE_LWIN, VK_LWIN },
    { 0x80, SCANCODE_RWIN,    VK_RWIN | KBDEXT}
};

/*
 * The ausMouseVKey array provides a translation from the virtual key
 * value to an index.  The index is used to select the appropriate
 * routine to process the virtual key, as well as to select extra
 * information that is used by this routine during its processing.
 */
CONST USHORT ausMouseVKey[] = {
                       VK_CLEAR,
                       VK_PRIOR,
                       VK_NEXT,
                       VK_END,
                       VK_HOME,
                       VK_LEFT,
                       VK_UP,
                       VK_RIGHT,
                       VK_DOWN,
                       VK_INSERT,
                       VK_DELETE,
                       VK_MULTIPLY,
                       VK_ADD,
                       VK_SUBTRACT,
                       VK_DIVIDE | KBDEXT,
                       VK_NUMLOCK | KBDEXT
                      };

CONST int cMouseVKeys = sizeof(ausMouseVKey) / sizeof(ausMouseVKey[0]);

/*
 * aMouseKeyEvent is an array of function pointers.  The routine to call
 * is selected using the index created by scanning the ausMouseVKey array.
 */
CONST MOUSEPROC aMouseKeyEvent[] = {
    xxxMKButtonClick,      // Numpad 5 (Clear)
    xxxMKMouseMove,        // Numpad 9 (PgUp)
    xxxMKMouseMove,        // Numpad 3 (PgDn)
    xxxMKMouseMove,        // Numpad 1 (End)
    xxxMKMouseMove,        // Numpad 7 (Home)
    xxxMKMouseMove,        // Numpad 4 (Left)
    xxxMKMouseMove,        // Numpad 8 (Up)
    xxxMKMouseMove,        // Numpad 6 (Right)
    xxxMKMouseMove,        // Numpad 2 (Down)
    xxxMKButtonSetState,   // Numpad 0 (Ins)
    xxxMKButtonSetState,   // Numpad . (Del)
    MKButtonSelect,        // Numpad * (Multiply)
    xxxMKButtonDoubleClick,// Numpad + (Add)
    MKButtonSelect,        // Numpad - (Subtract)
    MKButtonSelect,        // Numpad / (Divide)
    xxxMKToggleMouseKeys   // Num Lock
};

/*
 * ausMouseKeyData contains useful data for the routines that process
 * the virtual mousekeys.  This array is indexed using the index created
 * by scanning the ausMouseVKey array.
 */
CONST USHORT ausMouseKeyData[] = {
    0,                     // Numpad 5: Click active button
    MK_UP | MK_RIGHT,      // Numpad 9: Up & Right
    MK_DOWN | MK_RIGHT,    // Numpad 3: Down & Right
    MK_DOWN | MK_LEFT,     // Numpad 1: Down & Left
    MK_UP | MK_LEFT,       // Numpad 7: Up & Left
    MK_LEFT,               // Numpad 4: Left
    MK_UP,                 // Numpad 8: Up
    MK_RIGHT,              // Numpad 6: Right
    MK_DOWN,               // Numpad 2: Down
    FALSE,                 // Numpad 0: Active button down
    TRUE,                  // Numpad .: Active button up
    MOUSE_BUTTON_LEFT | MOUSE_BUTTON_RIGHT,   // Numpad *: Select both buttons
    0,                     // Numpad +: Double click active button
    MOUSE_BUTTON_RIGHT,    // Numpad -: Select right button
    MOUSE_BUTTON_LEFT,     // Numpad /: Select left button
    0
};


__inline void
PostAccessNotification(UINT accessKeyType)
{
    if (gspwndLogonNotify != NULL)
    {
        glinp.ptiLastWoken = GETPTI(gspwndLogonNotify);

        _PostMessage(gspwndLogonNotify, WM_LOGONNOTIFY,
                 LOGON_ACCESSNOTIFY, accessKeyType);
    }
}

void PostRitSound(PTERMINAL pTerm, UINT message) {
    PostEventMessage(
                    pTerm->ptiDesktop,
                    pTerm->ptiDesktop->pq,
                    QEVENT_RITSOUND,
                    NULL,
                    message, 0, 0);
    return;
}

void PostAccessibility( LPARAM lParam )
{
    PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;

    PostEventMessage(
            pTerm->ptiDesktop,
            pTerm->ptiDesktop->pq,
            QEVENT_RITACCESSIBILITY,
            NULL,
            0, HSHELL_ACCESSIBILITYSTATE, lParam);
}

/***************************************************************************\
* AccessProceduresStream
*
* This function controls the order in which the access functions are called.
* All key events pass through this routine.  If an access function returns
* FALSE then none of the other access functions in the stream are called.
* This routine is called initially from KeyboardApcProcedure(), but then
* can be called any number of times by the access functions as they process
* the current key event or add more key events.
*
* Return value:
*   TRUE    All access functions returned TRUE, the key event can be
*           processed.
*   FALSE   An access function returned FALSE, the key event should be
*           discarded.
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
BOOL AccessProceduresStream(PKE pKeyEvent, ULONG ExtraInformation, int dwProcIndex)
{
    int index;

    CheckCritIn();
    for (index = dwProcIndex; index < ARRAY_SIZE(aAccessibilityProc); index++) {
        if (!aAccessibilityProc[index](pKeyEvent, ExtraInformation, index+1)) {
            return FALSE;
        }
    }

    return TRUE;
}


/***************************************************************************\
* FKActivationTimer
*
* If the hot key (right shift key) is held down this routine is called after
* 4, 8, 12 and 16 seconds.  This routine is only called at the 12 and 16
* second time points if we're in the process of enabling FilterKeys.  If at
* 8 seconds FilterKeys is disabled then this routine will not be called again
* until the hot key is released and then pressed.
*
* This routine is called with the critical section already locked.
*
* Return value:
*    0
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
VOID FKActivationTimer(
    PWND pwnd,
    UINT message,
    UINT_PTR nID,
    LPARAM lParam)
{
    UINT TimerDelta;
    PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;

    UNREFERENCED_PARAMETER(pwnd);
    UNREFERENCED_PARAMETER(lParam);
    UNREFERENCED_PARAMETER(message);

    CheckCritIn();

    switch (gFilterKeysState) {

    case FKFIRSTWARNING:
        //
        // The audible feedback cannot be disabled for this warning.
        //
        TimerDelta = FKACTIVATIONDELTA;
        break;

    case FKTOGGLE:
        if (TEST_ACCESSFLAG(FilterKeys, FKF_FILTERKEYSON)) {
            //
            // Disable Filter Keys
            //
            CLEAR_ACCESSFLAG(FilterKeys, FKF_FILTERKEYSON);
            if (TEST_ACCESSFLAG(FilterKeys, FKF_HOTKEYSOUND)) {
                PostRitSound(pTerm, RITSOUND_DOWNSIREN);
            }
            PostAccessibility(ACCESS_FILTERKEYS);
            //
            // Stop all timers that are currently running.
            //
            if (gtmridFKResponse != 0) {
                KILLRITTIMER(NULL, gtmridFKResponse);
                gtmridFKResponse = 0;
            }

            if (gtmridFKAcceptanceDelay != 0) {
                KILLRITTIMER(NULL, gtmridFKAcceptanceDelay);
                gtmridFKAcceptanceDelay = 0;
            }

            //
            // Don't reset activation timer.  Emergency levels are only
            // activated after enabling Filter Keys.
            //
            return;
        } else {
            if (TEST_ACCESSFLAG(FilterKeys, FKF_HOTKEYSOUND)) {
                PostRitSound(pTerm, RITSOUND_UPSIREN);
            }

            PostAccessNotification(ACCESS_FILTERKEYS);

        }
        TimerDelta = FKEMERGENCY1DELTA;
        break;

    case FKFIRSTLEVELEMERGENCY:
        //
        // First level emergency settings:
        //    Repeat Rate OFF
        //    SlowKeys OFF (Acceptance Delay of 0)
        //    BounceKeys Debounce Time of 1 second
        //
        if (TEST_ACCESSFLAG(FilterKeys, FKF_HOTKEYSOUND)) {
            PostEventMessage(pTerm->ptiDesktop,
                             pTerm->ptiDesktop->pq,
                             QEVENT_RITSOUND,
                             NULL,
                             RITSOUND_DOBEEP,
                             RITSOUND_UPSIREN,
                             2);
        }
        gFilterKeys.iRepeatMSec = 0;
        gFilterKeys.iWaitMSec = 0;
        gFilterKeys.iBounceMSec = 1000;
        TimerDelta = FKEMERGENCY2DELTA;
        break;

    case FKSECONDLEVELEMERGENCY:
        //
        // Second level emergency settings:
        //    Repeat Rate OFF
        //    SlowKeys Acceptance Delay of 2 seconds
        //    BounceKeys OFF (Debounce Time of 0)
        //
        gFilterKeys.iRepeatMSec = 0;
        gFilterKeys.iWaitMSec = 2000;
        gFilterKeys.iBounceMSec = 0;
        if (TEST_ACCESSFLAG(FilterKeys, FKF_HOTKEYSOUND)) {
            PostEventMessage(
                    pTerm->ptiDesktop,
                    pTerm->ptiDesktop->pq,
                    QEVENT_RITSOUND,
                    NULL,
                    RITSOUND_DOBEEP, RITSOUND_UPSIREN, 3);
        }
        return;
        break;

    default:
        return;
    }

    gFilterKeysState++;
    gtmridFKActivation = InternalSetTimer(NULL,
                                          nID,
                                          TimerDelta,
                                          FKActivationTimer,
                                          TMRF_RIT | TMRF_ONESHOT);
}

/***************************************************************************\
* FKBounceKeyTimer
*
* If BounceKeys is active this routine is called after the debounce time
* has expired.  Until then, the last key released will not be accepted as
* input if it is pressed again.
*
* Return value:
*    0
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
VOID FKBounceKeyTimer(
    PWND pwnd,
    UINT message,
    UINT_PTR nID,
    LPARAM lParam)
{
    UNREFERENCED_PARAMETER(pwnd);
    UNREFERENCED_PARAMETER(lParam);
    UNREFERENCED_PARAMETER(nID);
    UNREFERENCED_PARAMETER(message);

    CheckCritIn();

    //
    // All we need to do is clear gBounceVk to allow this key as the
    // next keystroke.
    //
    gBounceVk = 0;
}

/***************************************************************************\
* xxxFKRepeatRateTimer
*
* If FilterKeys is active and a repeat rate is set, this routine controls
* the rate at which the last key pressed repeats.  The hardware keyboard
* typematic repeat is ignored in this case.
*
* This routine is called with the critical section already locked.
*
* Return value:
*    0
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
VOID xxxFKRepeatRateTimer(
    PWND pwnd,
    UINT message,
    UINT_PTR nID,
    LPARAM lParam)
{
    UNREFERENCED_PARAMETER(pwnd);
    UNREFERENCED_PARAMETER(lParam);
    UNREFERENCED_PARAMETER(message);

    CheckCritIn();

    if (TEST_ACCESSFLAG(FilterKeys, FKF_CLICKON)) {
        PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;
        PostRitSound(pTerm, RITSOUND_KEYCLICK);
    }

    UserAssert(gtmridFKAcceptanceDelay == 0);

    gtmridFKResponse = InternalSetTimer(NULL,
                                        nID,
                                        gFilterKeys.iRepeatMSec,
                                        xxxFKRepeatRateTimer,
                                        TMRF_RIT | TMRF_ONESHOT);
    if (AccessProceduresStream(gpFKKeyEvent, gFKExtraInformation, gFKNextProcIndex)) {
        xxxProcessKeyEvent(gpFKKeyEvent, gFKExtraInformation, FALSE);
    }
}

/***************************************************************************\
* xxxFKAcceptanceDelayTimer
*
* If FilterKeys is active and an acceptance delay is set, this routine
* is called after the key has been held down for the acceptance delay
* period.
*
* This routine is called with the critical section already locked.
*
* Return value:
*    0
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
VOID xxxFKAcceptanceDelayTimer(
    PWND pwnd,
    UINT message,
    UINT_PTR nID,
    LPARAM lParam)
{
    UNREFERENCED_PARAMETER(lParam);
    UNREFERENCED_PARAMETER(message);
    UNREFERENCED_PARAMETER(pwnd);

    CheckCritIn();

    //
    // The key has been held down long enough. Send it on...
    //
    if (TEST_ACCESSFLAG(FilterKeys, FKF_CLICKON)) {
        PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;
        PostRitSound(pTerm, RITSOUND_KEYCLICK);
    }

    if (AccessProceduresStream(gpFKKeyEvent, gFKExtraInformation, gFKNextProcIndex)) {
        xxxProcessKeyEvent(gpFKKeyEvent, gFKExtraInformation, FALSE);
    }

    if (!gFilterKeys.iRepeatMSec) {
        //
        // gptmrFKAcceptanceDelay needs to be released, but we can't do it while
        // in a RIT timer routine.  Set a global to indicate that the subsequent
        // break of this key should be passed on and the timer freed.
        //
        SET_ACCF(ACCF_FKMAKECODEPROCESSED);
        return;
    }

    UserAssert(gtmridFKResponse == 0);
    if (gFilterKeys.iDelayMSec) {
        gtmridFKResponse = InternalSetTimer(NULL,
                                            nID,
                                            gFilterKeys.iDelayMSec,
                                            xxxFKRepeatRateTimer,
                                            TMRF_RIT | TMRF_ONESHOT);
    } else {
        gtmridFKResponse = InternalSetTimer(NULL,
                                            nID,
                                            gFilterKeys.iRepeatMSec,
                                            xxxFKRepeatRateTimer,
                                            TMRF_RIT | TMRF_ONESHOT);
    }

    //
    // gptmrFKAcceptanceDelay timer structure was reused so set handle to
    // NULL.
    //
    gtmridFKAcceptanceDelay = 0;
}

/***************************************************************************\
* FilterKeys
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
BOOL FilterKeys(
    PKE pKeyEvent,
    ULONG ExtraInformation,
    int NextProcIndex)
{
    int fBreak;
    BYTE Vk;

    CheckCritIn();
    Vk = (BYTE)(pKeyEvent->usFlaggedVk & 0xff);
    fBreak = pKeyEvent->usFlaggedVk & KBDBREAK;

    //
    // Check for Filter Keys hot key (right shift key).
    //
    if (Vk == VK_RSHIFT) {
        if (fBreak) {
            if (gtmridFKActivation != 0) {
                KILLRITTIMER(NULL, gtmridFKActivation);
                gtmridFKActivation = 0;
            }
            gFilterKeysState = FKIDLE;
        } else if (ONLYRIGHTSHIFTDOWN(gPhysModifierState)) {
            //
            // Verify that activation via hotkey is allowed.
            //
            if (TEST_ACCESSFLAG(FilterKeys, FKF_HOTKEYACTIVE)) {
                if ((gtmridFKActivation == 0) && (gFilterKeysState != FKMOUSEMOVE)) {
                    gFilterKeysState = FKFIRSTWARNING;
                    gtmridFKActivation = InternalSetTimer(NULL,
                                                          0,
                                                          FKFIRSTWARNINGTIME,
                                                          FKActivationTimer,
                                                          TMRF_RIT | TMRF_ONESHOT);
                }
            }
        }
    }

    //
    // If another key is pressed while the hot key is down, kill
    // the timer.
    //
    if (Vk != VK_RSHIFT && gtmridFKActivation != 0) {
        gFilterKeysState = FKIDLE;
        KILLRITTIMER(NULL, gtmridFKActivation);
        gtmridFKActivation = 0;
    }

    //
    // If Filter Keys not enabled send the key event on.
    //
    if (!TEST_ACCESSFLAG(FilterKeys, FKF_FILTERKEYSON)) {
        return TRUE;
    }

    if (fBreak) {
        //
        // Kill the current timer and activate bounce key timer (if this is
        // a break of the last key down).
        //
        if (Vk == gLastVkDown) {
            KILLRITTIMER(NULL, gtmridFKResponse);
            gtmridFKResponse = 0;

            gLastVkDown = 0;
            if (gtmridFKAcceptanceDelay != 0) {
                KILLRITTIMER(NULL, gtmridFKAcceptanceDelay);
                gtmridFKAcceptanceDelay = 0;
                if (!TEST_ACCF(ACCF_FKMAKECODEPROCESSED)) {
                    //
                    // This key was released before accepted.  Don't pass on the
                    // break.
                    //
                    return FALSE;
                } else {
                    CLEAR_ACCF(ACCF_FKMAKECODEPROCESSED);
                }
            }

            if (gFilterKeys.iBounceMSec) {
                gBounceVk = Vk;
                gtmridFKResponse = InternalSetTimer(NULL,
                                                    0,
                                                    gFilterKeys.iBounceMSec,
                                                    FKBounceKeyTimer,
                                                    TMRF_RIT | TMRF_ONESHOT);
                if (TEST_ACCF(ACCF_IGNOREBREAKCODE)) {
                    return FALSE;
                }
            }
        }
    } else {
        //
        // Make key processing
        //
        // First check to see if this is a typematic repeat.  If so, we
        // can ignore this key event.  Our timer will handle any repeats.
        // LastVkDown is cleared during processing of the break.
        //
        if (Vk == gLastVkDown) {
            return FALSE;
        }
        //
        // Remember current Virtual Key down for typematic repeat check.
        //
        gLastVkDown = Vk;

        if (gBounceVk) {
            //
            // BounceKeys is active.  If this is a make of the last
            // key pressed we ignore it.  Only when the BounceKey
            // timer expires or another key is pressed will we accept
            // this key.
            //
            if (Vk == gBounceVk) {
                //
                // Ignore this make event and the subsequent break
                // code.  BounceKey timer will be reset on break.
                //
                SET_ACCF(ACCF_IGNOREBREAKCODE);
                return FALSE;
            } else {
                //
                // We have a make of a new key.  Kill the BounceKey
                // timer and clear gBounceVk.
                //
                UserAssert(gtmridFKResponse);
                if (gtmridFKResponse != 0) {
                    KILLRITTIMER(NULL, gtmridFKResponse);
                    gtmridFKResponse = 0;
                }
                gBounceVk = 0;
            }
        }
        CLEAR_ACCF(ACCF_IGNOREBREAKCODE);

        //
        // Give audible feedback that key was pressed.
        //
        if (TEST_ACCESSFLAG(FilterKeys, FKF_CLICKON)) {
            PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;
            PostRitSound(
                    pTerm,
                    RITSOUND_KEYCLICK);
        }

        //
        // If gptmrFKAcceptanceDelay is non-NULL the previous key was
        // not held down long enough to be accepted.  Kill the current
        // timer.  A new timer will be started below for the key we're
        // processing now.
        //
        if (gtmridFKAcceptanceDelay != 0) {
            KILLRITTIMER(NULL, gtmridFKAcceptanceDelay);
            gtmridFKAcceptanceDelay = 0;
        }

        //
        // If gptmrFKResponse is non-NULL a repeat rate timer is active
        // on the previous key.  Kill the timer as we have a new make key.
        //
        if (gtmridFKResponse != 0) {
            KILLRITTIMER(NULL, gtmridFKResponse);
            gtmridFKResponse = 0;
        }

        //
        // Save the current key event for later use if we process an
        // acceptance delay or key repeat.
        //
        *gpFKKeyEvent = *pKeyEvent;
        gFKExtraInformation = ExtraInformation;
        gFKNextProcIndex = NextProcIndex;

        //
        // If there is an acceptance delay, set timer and ignore current
        // key event.  When timer expires, saved key event will be sent.
        //
        if (gFilterKeys.iWaitMSec) {
            gtmridFKAcceptanceDelay = InternalSetTimer(NULL,
                                                       0,
                                                       gFilterKeys.iWaitMSec,
                                                       xxxFKAcceptanceDelayTimer,
                                                       TMRF_RIT | TMRF_ONESHOT);
            CLEAR_ACCF(ACCF_FKMAKECODEPROCESSED);
            return FALSE;
        }
        //
        // No acceptance delay.  Before sending this key event on the
        // timer routine must be set to either the delay until repeat value
        // or the repeat rate value.  If repeat rate is 0 then ignore
        // delay until repeat.
        //
        if (!gFilterKeys.iRepeatMSec) {
            return TRUE;
        }

        UserAssert(gtmridFKResponse == 0);
        if (gFilterKeys.iDelayMSec) {
            gtmridFKResponse = InternalSetTimer(NULL,
                                                0,
                                                gFilterKeys.iDelayMSec,
                                                xxxFKRepeatRateTimer,
                                                TMRF_RIT | TMRF_ONESHOT);
        } else {
            gtmridFKResponse = InternalSetTimer(NULL,
                                                0,
                                                gFilterKeys.iRepeatMSec,
                                                xxxFKRepeatRateTimer,
                                                TMRF_RIT | TMRF_ONESHOT);
        }
    }

    return TRUE;
}

/***************************************************************************\
* StopFilterKeysTimers
*
* Called from SystemParametersInfo on SPI_SETFILTERKEYS if FKF_FILTERKEYSON
* is not set.  Timers must be stopped if user turns FilterKeys off.
*
* History:
*   18 Jul 94 GregoryW   Created.
\***************************************************************************/
VOID StopFilterKeysTimers(VOID)
{

    if (gtmridFKResponse != 0) {
        KILLRITTIMER(NULL, gtmridFKResponse);
        gtmridFKResponse = 0;
    }
    if (gtmridFKAcceptanceDelay) {
        KILLRITTIMER(NULL, gtmridFKAcceptanceDelay);
        gtmridFKAcceptanceDelay = 0;
    }
    gLastVkDown = 0;
    gBounceVk = 0;
}

/***************************************************************************\
* xxxStickyKeys
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
BOOL xxxStickyKeys(PKE pKeyEvent, ULONG ExtraInformation, int NextProcIndex)
{
    int fBreak;
    BYTE NewLockBits, NewLatchBits;
    int BitPositions;
    BOOL bChange;
    PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;


    CheckCritIn();
    fBreak = pKeyEvent->usFlaggedVk & KBDBREAK;

    if (gCurrentModifierBit) {
        //
        // Process modifier key
        //

        //
        // One method of activating StickyKeys is to press either the
        // left shift key or the right shift key five times without
        // pressing any other keys.  We don't want the typematic shift
        // (make code) to enable/disable StickyKeys so we perform a
        // special test for them.
        //
        if (!fBreak) {
            if (gCurrentModifierBit & gPrevModifierState) {
                //
                // This is a typematic make of a modifier key.  Don't do
                // any further processing.  Just pass it along.
                //
                gPrevModifierState = gPhysModifierState;
                return TRUE;
            }
        }

        gPrevModifierState = gPhysModifierState;

        if (LEFTSHIFTKEY(pKeyEvent->usFlaggedVk) &&
            ((gPhysModifierState & ~gCurrentModifierBit) == 0)) {
            gStickyKeysLeftShiftCount++;
        } else {
            gStickyKeysLeftShiftCount = 0;
        }
        if (RIGHTSHIFTKEY(pKeyEvent->usFlaggedVk) &&
            ((gPhysModifierState & ~gCurrentModifierBit) == 0)) {
            gStickyKeysRightShiftCount++;
        } else {
            gStickyKeysRightShiftCount = 0;
        }

        //
        // Check to see if StickyKeys should be toggled on/off
        //
        if ((gStickyKeysLeftShiftCount == (TOGGLE_STICKYKEYS_COUNT * 2)) ||
            (gStickyKeysRightShiftCount == (TOGGLE_STICKYKEYS_COUNT * 2))) {
            if (TEST_ACCESSFLAG(StickyKeys, SKF_HOTKEYACTIVE)) {
                if (TEST_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON)) {
                    xxxTurnOffStickyKeys();
                    if (TEST_ACCESSFLAG(StickyKeys, SKF_HOTKEYSOUND)) {
                        PostRitSound(
                            pTerm,
                            RITSOUND_DOWNSIREN);
                    }
                } else {
                    if (TEST_ACCESSFLAG(StickyKeys, SKF_HOTKEYSOUND)) {
                        PostRitSound(
                            pTerm,
                            RITSOUND_UPSIREN);
                    }
                    // To make the notification window get the focus
                    // The same is done other places where WM_LOGONNOTIFY message is
                    // sent    : a-anilk
                    PostAccessNotification(ACCESS_STICKYKEYS);

                }
            }
            gStickyKeysLeftShiftCount = 0;
            gStickyKeysRightShiftCount = 0;
            return TRUE;
        }

        //
        // If StickyKeys is enabled process the modifier key, otherwise
        // just pass on the modifier key.
        //
        if (TEST_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON)) {
            if (fBreak) {
                //
                // If either locked or latched bit set for this key then
                // don't pass the break on.
                //
                if (UNION(gLatchBits, gLockBits) & gCurrentModifierBit) {
                    return FALSE;
                } else {
                    return TRUE;
                }
            } else{
                if (gPhysModifierState != gCurrentModifierBit) {
                    //
                    // More than one modifier key down at the same time.
                    // This condition may signal sticky keys to turn off.
                    // The routine xxxTwoKeysDown will return the new value
                    // of fStickyKeysOn.  If sticky keys is turned off
                    // (return value 0), the key event should be passed
                    // on without further processing here.
                    //
                    if (!xxxTwoKeysDown(NextProcIndex)) {
                        return TRUE;
                    }

                    //
                    // Modifier states were set to physical state by
                    // xxxTwoKeysDown.  The modifier keys currently in
                    // the down position will be latched by updating
                    // gLatchBits.  No more processing for this key
                    // event is needed.
                    //
                    bChange = gLockBits ||
                              (gLatchBits != gPhysModifierState);
                    gLatchBits = gPhysModifierState;
                    gLockBits = 0;
                    if (bChange) {
                        PostAccessibility( ACCESS_STICKYKEYS );
                    }

                    //
                    // Provide sound feedback, if enabled, before returning.
                    //
                    if (TEST_ACCESSFLAG(StickyKeys, SKF_AUDIBLEFEEDBACK)) {
                        PostRitSound(
                            pTerm,
                            RITSOUND_LOWBEEP);
                        PostRitSound(
                            pTerm,
                            RITSOUND_HIGHBEEP);
                    }
                    return FALSE;
                }
                //
                // Figure out which bits (Shift, Ctrl or Alt key bits) to
                // examine.  Also set up default values for NewLatchBits
                // and NewLockBits in case they're not set later.
                //
                // See the depiction of the bit pattern in KeyboardApcProcedure.
                //
                // Bit 0 -- L SHIFT
                // Bit 1 -- R SHIFT
                // Bit 2 -- L CTL
                // Bit 3 -- R CTL
                // Bit 4 -- L ALT
                // Bit 5 -- R RLT
                // Bit 6 -- L WIN
                // Bit 7 -- R WIN
                switch(pKeyEvent->usFlaggedVk) {
                case VK_LSHIFT:
                case VK_RSHIFT:
                    BitPositions = 0x3;
                    break;
                case VK_LCONTROL:
                case VK_RCONTROL:
                    BitPositions = 0xc;
                    break;
                case VK_LMENU:
                case VK_RMENU:
                    BitPositions = 0x30;
                    break;
                case VK_LWIN:
                case VK_RWIN:
                    BitPositions = 0xc0;
                    break;
                }
                NewLatchBits = gLatchBits;
                NewLockBits = gLockBits;

                //
                // If either left or right modifier is locked clear latched
                // and locked states and send appropriate break/make messages.
                //
                if (gLockBits & BitPositions) {
                    NewLockBits = gLockBits & ~BitPositions;
                    NewLatchBits = gLatchBits & ~BitPositions;
                    xxxUpdateModifierState(
                        NewLockBits | NewLatchBits | gCurrentModifierBit,
                        NextProcIndex
                        );
                } else {
                    //
                    // If specific lock bit (left or right) not
                    // previously set then toggle latch bits.
                    //
                    if (!(gLockBits & gCurrentModifierBit)) {
                        NewLatchBits = gLatchBits ^ gCurrentModifierBit;
                    }
                    //
                    // If locked mode (tri-state) enabled then if latch or lock
                    // bit previously set, toggle lock bit.
                    //
                    if (TEST_ACCESSFLAG(StickyKeys, SKF_TRISTATE)) {
                        if (UNION(gLockBits, gLatchBits) & gCurrentModifierBit) {
                            NewLockBits = gLockBits ^ gCurrentModifierBit;
                        }
                    }
                }

                //
                // Update globals
                //
                bChange = ((gLatchBits != NewLatchBits) ||
                           (gLockBits != NewLockBits));

                gLatchBits = NewLatchBits;
                gLockBits = NewLockBits;

                if (bChange) {
                    PostAccessibility( ACCESS_STICKYKEYS );
                }
                //
                // Now provide sound feedback if enabled.  For the transition
                // to LATCH mode issue a low beep then a high beep.  For the
                // transition to LOCKED mode issue a high beep.  For the
                // transition out of LOCKED mode (or LATCH mode if tri-state
                // not enabled) issue a low beep.
                //
                if (TEST_ACCESSFLAG(StickyKeys, SKF_AUDIBLEFEEDBACK)) {
                    if (!(gLockBits & gCurrentModifierBit)) {
                        PostRitSound(
                            pTerm,
                            RITSOUND_LOWBEEP);
                    }
                    if ((gLatchBits | gLockBits) & gCurrentModifierBit) {
                        PostRitSound(
                            pTerm,
                            RITSOUND_HIGHBEEP);
                    }
                }
                //
                // Pass key on if shift bit is set (e.g., if transitioning
                // from shift to lock mode don't pass on make).
                //
                if (gLatchBits & gCurrentModifierBit) {
                    return TRUE;
                } else {
                    return FALSE;
                }

            }
        }
    } else {
        //
        // Non-shift key processing here...
        //
        gStickyKeysLeftShiftCount = 0;
        gStickyKeysRightShiftCount = 0;
        if (!TEST_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON)) {
            return TRUE;
        }

        //
        // If no modifier keys are down, or this is a break, pass the key event
        // on and clear any latch states.
        //
        if (!gPhysModifierState || fBreak) {
            if (AccessProceduresStream(pKeyEvent, ExtraInformation, NextProcIndex)) {
                xxxProcessKeyEvent(pKeyEvent, ExtraInformation, FALSE);
            }
            xxxUpdateModifierState(gLockBits, NextProcIndex);

            bChange = gLatchBits != 0;
            gLatchBits = 0;
            if (bChange) {

                PostAccessibility( ACCESS_STICKYKEYS );
            }
            return FALSE;
        } else {
            //
            // This is a make of a non-modifier key and there is a modifier key
            // down.  Update the states and pass the key event on.
            //
            xxxTwoKeysDown(NextProcIndex);
            return TRUE;
        }
    }

    return TRUE;
}

/***************************************************************************\
* xxxUpdateModifierState
*
* Starting from the current modifier keys state, send the necessary key
* events (make or break) to end up with the NewModifierState passed in.
*
* Return value:
*    None.
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
VOID xxxUpdateModifierState(int NewModifierState, int NextProcIndex)
{
    KE ke;
    int CurrentModState;
    int CurrentModBit, NewModBit;
    int i;

    CheckCritIn();

    CurrentModState = gLockBits | gLatchBits;

    for (i = 0; i < ARRAY_SIZE(aModBit); i++) {
        CurrentModBit = CurrentModState & aModBit[i].BitPosition;
        NewModBit = NewModifierState & aModBit[i].BitPosition;
        if (CurrentModBit != NewModBit) {
            ke.bScanCode = (BYTE)aModBit[i].ScanCode;
            ke.usFlaggedVk = aModBit[i].Vk;
            if (CurrentModBit) {          // if it's currently on, send break
                ke.usFlaggedVk |= KBDBREAK;
            }
            if (AccessProceduresStream(&ke, 0L, NextProcIndex)) {
                xxxProcessKeyEvent(&ke, 0L, FALSE);
            }
        }
    }
}

/***************************************************************************\
* xxxTurnOffStickyKeys
*
* The user either pressed the appropriate key sequence or used the
* access utility to turn StickyKeys off.  Update modifier states and
* reset globals.
*
* Return value:
*   None.
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
VOID xxxTurnOffStickyKeys(VOID)
{
    INT index;

    CheckCritIn();

    for (index = 0; index < ARRAY_SIZE(aAccessibilityProc); index++) {
        if (aAccessibilityProc[index] == xxxStickyKeys) {

            xxxUpdateModifierState(gPhysModifierState, index+1);
            gLockBits = gLatchBits = 0;
            CLEAR_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON);

            PostAccessibility( ACCESS_STICKYKEYS );
            break;
        }
    }
}

/***************************************************************************\
* xxxUnlatchStickyKeys
*
* This routine releases any sticky keys that are latched.  This routine
* is called during mouse up event processing.
*
* Return value:
*   None.
*
* History:
*   21 Jun 93 GregoryW   Created.
\***************************************************************************/
VOID xxxUnlatchStickyKeys(VOID)
{
    INT index;
    BOOL bChange;

    if (!gLatchBits) {
        return;
    }

    for (index = 0; index < ARRAY_SIZE(aAccessibilityProc); index++) {
        if (aAccessibilityProc[index] == xxxStickyKeys) {
            xxxUpdateModifierState(gLockBits, index+1);
            bChange = gLatchBits != 0;
            gLatchBits = 0;

            if (bChange) {

                PostAccessibility( ACCESS_STICKYKEYS );
            }
            break;
        }
    }
}


/***************************************************************************\
* xxxHardwareMouseKeyUp
*
* This routine is called during a mouse button up event.  If MouseKeys is
* on and the button up event corresponds to a mouse key that's locked down,
* the mouse key must be released.
*
* If StickyKeys is on, all latched keys are released.
*
* Return value:
*   None.
*
* History:
*   17 Jun 94 GregoryW   Created.
\***************************************************************************/

VOID xxxHardwareMouseKeyUp(DWORD dwButton)
{
    CheckCritIn();

    if (TEST_ACCESSFLAG(MouseKeys, MKF_MOUSEKEYSON)) {
        gwMKButtonState &= ~dwButton;
    }

    // Not required to post a setting change
    //PostAccessibility( SPI_SETMOUSEKEYS );

    if (TEST_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON)) {
        xxxUnlatchStickyKeys();
    }
}


/***************************************************************************\
* xxxTwoKeysDown
*
* Two keys are down simultaneously.  Check to see if StickyKeys should be
* turned off.  In all cases update the modifier key state to reflect the
* physical key state and clear latched and locked modes.
*
* Return value:
*    1 if StickyKeys is enabled.
*    0 if StickyKeys is disabled.
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
BOOL xxxTwoKeysDown(int NextProcIndex)
{
    PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;

    if (TEST_ACCESSFLAG(StickyKeys, SKF_TWOKEYSOFF)) {
        CLEAR_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON);
        if (TEST_ACCESSFLAG(StickyKeys, SKF_HOTKEYSOUND)) {
            PostRitSound(
                    pTerm,
                    RITSOUND_DOWNSIREN);
        }
        gStickyKeysLeftShiftCount = 0;
        gStickyKeysRightShiftCount = 0;
    }
    xxxUpdateModifierState(gPhysModifierState, NextProcIndex);
    gLockBits = gLatchBits = 0;

    PostAccessibility( ACCESS_STICKYKEYS );

    return TEST_BOOL_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON);
}

/***************************************************************************\
* SetGlobalCursorLevel
*
* Set the cursor level of all threads running on the visible
* windowstation.
*
* History:
* 04-17-95 JimA         Created.
\***************************************************************************/

VOID SetGlobalCursorLevel(
    INT iCursorLevel)
{

/*
 * LATER
 * We have other code which assumes that the
 * iCursorLevel of a queue is the sum of the iCursorLevel values for the
 * threads attached to the queue.  But this code, if you set iCursorLevel to
 * -1 (to indicate no mouse) will set the queue iCursorLevel to -1, no matter
 * how many threads are attached to the queue.  This needs to be revisited.
 * See the function AttachToQueue.
 *  FritzS
 */


    PDESKTOP pdesk;
    PTHREADINFO pti;
    PLIST_ENTRY pHead, pEntry;

    TAGMSG1(DBGTAG_PNP, "SetGlobalCursorLevel %x", iCursorLevel);

    if (grpdeskRitInput) {
        for (pdesk = grpdeskRitInput->rpwinstaParent->rpdeskList;
                pdesk != NULL; pdesk = pdesk->rpdeskNext) {

            pHead = &pdesk->PtiList;
            for (pEntry = pHead->Flink; pEntry != pHead; pEntry = pEntry->Flink) {
                pti = CONTAINING_RECORD(pEntry, THREADINFO, PtiLink);

                pti->iCursorLevel = iCursorLevel;
                pti->pq->iCursorLevel = iCursorLevel;
            }
        }
    }

    /*
     * CSRSS doesn't seem to be on the list, so fix it up now.
     */
    for (pti = PpiFromProcess(gpepCSRSS)->ptiList;
            pti != NULL; pti = pti->ptiSibling) {
        if (pti->iCursorLevel != iCursorLevel) {
            TAGMSG3(DBGTAG_PNP, "pti %#p has cursorlevel %x, should be %x",
                    pti, pti->iCursorLevel, iCursorLevel);
        }
        if (pti->pq->iCursorLevel != iCursorLevel) {
            TAGMSG4(DBGTAG_PNP, "pti->pq %#p->%#p has cursorlevel %x, should be %x",
                    pti, pti->pq, pti->pq->iCursorLevel, iCursorLevel);
        }
        pti->iCursorLevel = iCursorLevel;
        pti->pq->iCursorLevel = iCursorLevel;
    }
}

/***************************************************************************\
* MKShowMouseCursor
*
* If no hardware mouse is installed and MouseKeys is enabled, we need
* to fix up the system metrics, the oem information and the queue
* information.  The mouse cursor then gets displayed.
*
* Return value:
*    None.
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
VOID MKShowMouseCursor()
{
    TAGMSG1(DBGTAG_PNP, "MKShowMouseCursor (gpDeviceInfoList == %#p)", gpDeviceInfoList);

    //
    // If TEST_GTERMF(GTERMF_MOUSE) is TRUE then we either have a hardware mouse
    // or we're already pretending a mouse is installed.  In either case,
    // there's nothing to do so just return.
    //
    if (TEST_GTERMF(GTERMF_MOUSE)) {
        TAGMSG0(DBGTAG_PNP, "MKShowMouseCursor just returns");
        return;
    }

    SET_GTERMF(GTERMF_MOUSE);
    SET_ACCF(ACCF_MKVIRTUALMOUSE);
    SYSMET(MOUSEPRESENT) = TRUE;
    SYSMET(CMOUSEBUTTONS) = 2;
    /*
     * HACK: CreateQueue() uses oemInfo.fMouse to determine if a mouse is
     * present and thus whether to set the iCursorLevel field in the
     * THREADINFO structure to 0 or -1.  Unfortunately some queues have
     * already been created at this point.  Since oemInfo.fMouse is
     * initialized to FALSE, we need to go back through any queues already
     * around and set their iCursorLevel field to the correct value when
     * mousekeys is enabled.
     */
    SetGlobalCursorLevel(0);
}

/***************************************************************************\
* MKHideMouseCursor
*
* If no hardware mouse is installed and MouseKeys is disabled, we need
* to fix up the system metrics, the oem information and the queue
* information.  The mouse cursor then disappears.
*
* Return value:
*    None.
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
VOID MKHideMouseCursor()
{
    TAGMSG1(DBGTAG_PNP, "MKHideMouseCursor (gpDeviceInfoList == %#p)", gpDeviceInfoList);

    //
    // If a hardware mouse is present we don't need to do anything.
    //
    if (!TEST_ACCF(ACCF_MKVIRTUALMOUSE)) {
        return;
    }

    CLEAR_ACCF(ACCF_MKVIRTUALMOUSE);
    CLEAR_GTERMF(GTERMF_MOUSE);
    SYSMET(MOUSEPRESENT) = FALSE;
    SYSMET(CMOUSEBUTTONS) = 0;

    SetGlobalCursorLevel(-1);
}

/***************************************************************************\
* xxxMKToggleMouseKeys
*
* This routine is called when the NumLock key is pressed and MouseKeys is
* active.  If the left shift key and the left alt key are down then MouseKeys
* is turned off.  If just the NumLock key is pressed then we toggle between
* MouseKeys active and the state of the number pad before MouseKeys was
* activated.
*
* Return value:
*    TRUE  - key should be passed on in the input stream.
*    FALSE - key should not be passed on.
*
* History:
\***************************************************************************/
BOOL xxxMKToggleMouseKeys(
    USHORT NotUsed)
{
    BOOL bRetVal = TRUE;
    BOOL bNewPassThrough;
    PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;

    UNREFERENCED_PARAMETER(NotUsed);

    //
    // If this is a typematic repeat of NumLock we just pass it on.
    //
    if (TEST_ACCF(ACCF_MKREPEATVK)) {
        return bRetVal;
    }
    //
    // This is a make of NumLock.  Check for disable sequence.
    //
    if ((gLockBits | gLatchBits | gPhysModifierState) == MOUSEKEYMODBITS) {
        if (TEST_ACCESSFLAG(MouseKeys, MKF_HOTKEYACTIVE)) {
            if (!gbMKMouseMode) {
               //
               // User wants to turn MouseKeys off.  If we're currently in
               // pass through mode then the NumLock key is in the same state
               // (on or off) as it was when the user invoked MouseKeys.  We
               // want to leave it in that state, so don't pass the NumLock
               // key on.
               //
               bRetVal = FALSE;
            }
            TurnOffMouseKeys();
        }
        return bRetVal;
    }
    /*
     * This is a NumLock with no modifiers.  Toggle current state and
     * provide audible feedback.
     *
     * Note -- this test is the reverse of other ones because it tests the
     * state of VK_NUMLOCK before the keypress flips the state of NUMLOCK.
     * So the code checks for what the state will be.
     */
    bNewPassThrough =
#ifdef FE_SB // MouseKeys()
        (TestAsyncKeyStateToggle(gNumLockVk) != 0) ^
#else  // FE_SB
        (TestAsyncKeyStateToggle(VK_NUMLOCK) != 0) ^
#endif // FE_SB
             (TEST_ACCESSFLAG(MouseKeys, MKF_REPLACENUMBERS) != 0);


    if (!bNewPassThrough) {
        gbMKMouseMode = TRUE;
        PostRitSound(
              pTerm,
              RITSOUND_HIGHBEEP);
    } else {
        WORD SaveCurrentActiveButton;
        //
        // User wants keys to be passed on.  Release all buttons currently
        // down.
        //
        gbMKMouseMode = FALSE;
        PostRitSound(
              pTerm,
              RITSOUND_LOWBEEP);
        SaveCurrentActiveButton = gwMKCurrentButton;
        gwMKCurrentButton = MOUSE_BUTTON_LEFT | MOUSE_BUTTON_RIGHT;
        xxxMKButtonSetState(TRUE);
        gwMKCurrentButton = SaveCurrentActiveButton;
    }

    PostAccessibility( ACCESS_MOUSEKEYS );

    return bRetVal;
}

/***************************************************************************\
* xxxMKButtonClick
*
* Click the active mouse button.
*
* Return value:
*    Always FALSE - key should not be passed on.
*
* History:
\***************************************************************************/
BOOL xxxMKButtonClick(USHORT NotUsed)
{
    UNREFERENCED_PARAMETER(NotUsed);

    //
    // The button click only happens on initial make of key.  If this is a
    // typematic repeat we just ignore it.
    //
    if (TEST_ACCF(ACCF_MKREPEATVK)) {
        return FALSE;
    }

    //
    // Ensure active button is UP before the click
    //
    xxxMKButtonSetState(TRUE);

    //
    // Now push the button DOWN
    //
    xxxMKButtonSetState(FALSE);

    //
    // Now release the button
    //
    xxxMKButtonSetState(TRUE);

    return FALSE;
}


/***************************************************************************\
* xxxMKMoveConstCursorTimer
*
* Timer routine that handles constant speed mouse movement. This routine
* is called 20 times per second and uses information from
* gMouseCursor.bConstantTable[] to determine how many pixels to move the
* mouse cursor on each tick.
*
* Return value:
*    None.
*
* History:
\***************************************************************************/
VOID xxxMKMoveConstCursorTimer(
    PWND pwnd,
    UINT message,
    UINT_PTR nID,
    LPARAM lParam)
{
    LONG  MovePixels;

    UNREFERENCED_PARAMETER(pwnd);
    UNREFERENCED_PARAMETER(lParam);
    UNREFERENCED_PARAMETER(nID);
    UNREFERENCED_PARAMETER(message);

    CheckCritIn();

    if (TEST_ACCESSFLAG(MouseKeys, MKF_MODIFIERS)) {
        if ((gLockBits | gLatchBits | gPhysModifierState) & LRSHIFT) {
            MovePixels = 1;
            goto MoveIt;
        }
        if ((gLockBits | gLatchBits | gPhysModifierState) & LRCONTROL) {
            MovePixels = gMouseCursor.bConstantTable[0] * MK_CONTROL_SPEED;
            goto MoveIt;
        }
    }

    giMouseMoveTable %= gMouseCursor.bConstantTableLen;

    MovePixels = gMouseCursor.bConstantTable[giMouseMoveTable++];

    if (MovePixels == 0) {
        return;
    }

MoveIt:
    //
    // We're inside the critical section - leave before calling MoveEvent.
    // Set gbMouseMoved to TRUE so RawInputThread wakes up the appropriate
    // user thread (if any) to receive this event.
    //
    LeaveCrit();

    xxxMoveEvent(MovePixels * gMKDeltaX, MovePixels * gMKDeltaY, 0, 0,
#ifdef GENERIC_INPUT
                 NULL,
                 NULL,
#endif
                0, FALSE);
    QueueMouseEvent(0, 0, 0, gptCursorAsync, NtGetTickCount(),
#ifdef GENERIC_INPUT
                    /*
                     * There's no real mouse related to this mouse message.
                     */
                    NULL,
                    NULL,
#endif
                    FALSE, TRUE);
    EnterCrit();
}

/***************************************************************************\
* xxxMKMoveAccelCursorTimer
*
* Timer routine that handles mouse acceleration.  It gets called 20 times
* per second and uses information from gMouseCursor.bAccelTable[] to determine
* how many pixels to move the mouse cursor on each tick.
*
* Return value:
*    None.
*
* History:
\***************************************************************************/
VOID xxxMKMoveAccelCursorTimer(
    PWND pwnd,
    UINT message,
    UINT_PTR nID,
    LPARAM lParam)
{
    LONG  MovePixels;

    UNREFERENCED_PARAMETER(pwnd);
    UNREFERENCED_PARAMETER(message);
    UNREFERENCED_PARAMETER(nID);
    UNREFERENCED_PARAMETER(lParam);

    CheckCritIn();

    if (TEST_ACCESSFLAG(MouseKeys, MKF_MODIFIERS)) {
        if ((gLockBits | gLatchBits | gPhysModifierState) & LRSHIFT) {
            MovePixels = 1;
            goto MoveIt;
        }
        if ((gLockBits | gLatchBits | gPhysModifierState) & LRCONTROL) {
            MovePixels = gMouseCursor.bConstantTable[0] * MK_CONTROL_SPEED;
            goto MoveIt;
        }
    }

    if (giMouseMoveTable < gMouseCursor.bAccelTableLen) {
        MovePixels = gMouseCursor.bAccelTable[giMouseMoveTable++];
    } else {
        //
        // We've reached maximum cruising speed.  Switch to constant table.
        //
        MovePixels = gMouseCursor.bConstantTable[0];
        giMouseMoveTable = 1;
        gtmridMKMoveCursor = InternalSetTimer(NULL,
                                              gtmridMKMoveCursor,
                                              MOUSETIMERRATE,
                                              xxxMKMoveConstCursorTimer,
                                              TMRF_RIT);

    }
    if (MovePixels == 0) {
        return;
    }

MoveIt:
    //
    // We're inside the critical section - leave before calling xxxMoveEvent.
    // Set gbMouseMoved to TRUE so RawInputThread wakes up the appropriate
    // user thread (if any) to receive this event.
    //
    LeaveCrit();
    xxxMoveEvent(MovePixels * gMKDeltaX, MovePixels * gMKDeltaY, 0, 0,
#ifdef GENERIC_INPUT
                 NULL,
                 NULL,
#endif
                 0, FALSE);
    QueueMouseEvent(0, 0, 0, gptCursorAsync, NtGetTickCount(),
#ifdef GENERIC_INPUT
                    NULL,
                    NULL,
#endif
                    FALSE, TRUE);

    EnterCrit();
}

/***************************************************************************\
* xxxMKMouseMove
*
* Send a mouse move event.  A timer routine is set to handle the mouse
* cursor acceleration.  The timer will be set on the first make of a
* mouse move key if FilterKeys repeat rate is OFF.  Otherwise, the timer
* is set on the first repeat (typematic make) of the mouse move key.
* Once the timer is set the timer routine handles all mouse movement
* until the key is released or a new key is pressed.
*
* Return value:
*    Always FALSE - key should not be passed on.
*
* History:
\***************************************************************************/
BOOL xxxMKMouseMove(USHORT Data)
{


    /*
     * Let the mouse acceleration timer routine handle repeats.
     */
    if (TEST_ACCF(ACCF_MKREPEATVK) && (gtmridMKMoveCursor != 0)) {
        return FALSE;
    }


    gMKDeltaX = (LONG)((CHAR)LOBYTE(Data));   // Force sign extension
    gMKDeltaY = (LONG)((CHAR)HIBYTE(Data));   // Force sign extension

    LeaveCrit();

    if ((TEST_ACCESSFLAG(MouseKeys, MKF_MODIFIERS) && ((gLockBits | gLatchBits | gPhysModifierState) & LRCONTROL))) {
        xxxMoveEvent(gMKDeltaX * MK_CONTROL_SPEED * gMouseCursor.bConstantTable[0], gMKDeltaY * MK_CONTROL_SPEED * gMouseCursor.bConstantTable[0], 0, 0,
#ifdef GENERIC_INPUT
                     NULL,
                     NULL,
#endif
                     0, FALSE);
    } else {
        xxxMoveEvent(gMKDeltaX, gMKDeltaY, 0, 0,
#ifdef GENERIC_INPUT
                     NULL,
                     NULL,
#endif
                     0, FALSE);
    }

    QueueMouseEvent(0, 0, 0, gptCursorAsync, NtGetTickCount(),
#ifdef GENERIC_INPUT
                    NULL,
                    NULL,
#endif
                    FALSE, TRUE);

    EnterCrit();

    /*
     * If the repeat rate is zero we'll start the mouse acceleration
     * immediately.  Otherwise we wait until after the first repeat
     * of the mouse movement key.
     */
    if (!gFilterKeys.iRepeatMSec || TEST_ACCF(ACCF_MKREPEATVK)) {
        giMouseMoveTable = 0;
        gtmridMKMoveCursor = InternalSetTimer(NULL,
                                              gtmridMKMoveCursor,
                                              MOUSETIMERRATE,
                                              (gMouseCursor.bAccelTableLen) ?
                                                  xxxMKMoveAccelCursorTimer :
                                                  xxxMKMoveConstCursorTimer,
                                              TMRF_RIT);
    }

    return FALSE;
}

/***************************************************************************\
* xxxMKButtonSetState
*
* Set the active mouse button(s) to the state specified by fButtonUp
* (if fButtonUp is TRUE then the button is released, o.w. the button
*  is pressed).
*
* Return value:
*    Always FALSE - key should not be passed on.
*
* History:
\***************************************************************************/
BOOL xxxMKButtonSetState(USHORT fButtonUp)
{
    WORD NewButtonState;

    CheckCritIn();
    if (fButtonUp) {
        NewButtonState = gwMKButtonState & ~gwMKCurrentButton;
    } else {
        NewButtonState = gwMKButtonState | gwMKCurrentButton;
    }

    if ((NewButtonState & MOUSE_BUTTON_LEFT) != (gwMKButtonState & MOUSE_BUTTON_LEFT)) {
        xxxButtonEvent(MOUSE_BUTTON_LEFT,
                       gptCursorAsync,
                       fButtonUp,
                       NtGetTickCount(),
                       0L,
#ifdef GENERIC_INPUT
                       NULL,
                       NULL,
#endif
                       FALSE,
                       FALSE);
    }
    if ((NewButtonState & MOUSE_BUTTON_RIGHT) != (gwMKButtonState & MOUSE_BUTTON_RIGHT)) {
        xxxButtonEvent(MOUSE_BUTTON_RIGHT,
                       gptCursorAsync,
                       fButtonUp,
                       NtGetTickCount(),
                       0L,
#ifdef GENERIC_INPUT
                       NULL,
                       NULL,
#endif
                       FALSE,
                       FALSE);
    }
    gwMKButtonState = NewButtonState;

    PostAccessibility( ACCESS_MOUSEKEYS );

    return FALSE;
}

/***************************************************************************\
* MKButtonSelect
*
* Mark ThisButton as the active mouse button.  It's possible to select both
* the left and right mouse buttons as active simultaneously.
*
* Return value:
*    Always FALSE - key should not be passed on.
*
* History:
\***************************************************************************/
BOOL MKButtonSelect(WORD ThisButton)
{
    gwMKCurrentButton = ThisButton;

    PostAccessibility( ACCESS_MOUSEKEYS );
    return FALSE;
}

/***************************************************************************\
* xxxMKButtonDoubleClick
*
* Double click the active mouse button.
*
* Return value:
*    Always FALSE - key should not be passed on.
*
* History:
\***************************************************************************/
BOOL xxxMKButtonDoubleClick(
    USHORT NotUsed)
{
    UNREFERENCED_PARAMETER(NotUsed);

    xxxMKButtonClick(0);
    xxxMKButtonClick(0);

    return FALSE;
}

BOOL HighContrastHotKey(
    PKE pKeyEvent,
    ULONG ExtraInformation,
    int NotUsed)
{
    int CurrentModState;
    int fBreak;
    BYTE Vk;

    UNREFERENCED_PARAMETER(NotUsed);
    UNREFERENCED_PARAMETER(ExtraInformation);

    CheckCritIn();

    Vk = (BYTE)(pKeyEvent->usFlaggedVk & 0xff);
    fBreak = pKeyEvent->usFlaggedVk & KBDBREAK;
    CurrentModState = gLockBits | gLatchBits | gPhysModifierState;

    if (!TEST_ACCESSFLAG(HighContrast, HCF_HIGHCONTRASTON)) {
        if (TEST_ACCESSFLAG(HighContrast, HCF_HOTKEYACTIVE) && Vk == VK_SNAPSHOT && !fBreak && CurrentModState == MOUSEKEYMODBITS) {

            if (TEST_ACCESSFLAG(HighContrast, MKF_HOTKEYSOUND)) {
                PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;
                PostRitSound(
                    pTerm,
                    RITSOUND_UPSIREN);
            }

            PostAccessNotification(ACCESS_HIGHCONTRAST);

            return FALSE;
        }
    } else {
        if (TEST_ACCESSFLAG(HighContrast, HCF_HOTKEYACTIVE) && Vk == VK_SNAPSHOT && !fBreak && CurrentModState == MOUSEKEYMODBITS) {

            CLEAR_ACCESSFLAG(HighContrast, HCF_HIGHCONTRASTON);

                        if (TEST_ACCESSFLAG(HighContrast, MKF_HOTKEYSOUND)) {
                PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;
                PostRitSound(
                    pTerm,
                    RITSOUND_DOWNSIREN);
            }

            if (gspwndLogonNotify != NULL) {

            _PostMessage(gspwndLogonNotify, WM_LOGONNOTIFY,
                         LOGON_ACCESSNOTIFY, ACCESS_HIGHCONTRASTOFF);
            }
        }
    }

    return TRUE;  // send key event to next accessibility routine.
}


/***************************************************************************\
* MouseKeys
*
* This is the strategy routine that gets called as part of the input stream
* processing.  MouseKeys enabling/disabling is handled here.  All MouseKeys
* helper routines are called from this routine.
*
* Return value:
*    TRUE  - key event should be passed on to the next access routine.
*    FALSE - key event was processed and should not be passed on.
*
* History:
\***************************************************************************/
BOOL MouseKeys(
    PKE pKeyEvent,
    ULONG ExtraInformation,
    int NotUsed)
{
    int CurrentModState;
    int fBreak;
    BYTE Vk;
    USHORT FlaggedVk;
    int i;

    UNREFERENCED_PARAMETER(ExtraInformation);
    UNREFERENCED_PARAMETER(NotUsed);

    CheckCritIn();
    Vk = (BYTE)(pKeyEvent->usFlaggedVk & 0xff);
    fBreak = pKeyEvent->usFlaggedVk & KBDBREAK;
    CurrentModState = gLockBits | gLatchBits | gPhysModifierState;

    if (!TEST_ACCESSFLAG(MouseKeys, MKF_MOUSEKEYSON)) {
        //
        // MouseKeys currently disabled.  Check for enabling sequence:
        //   left Shift + left Alt + Num Lock.
        //
#ifdef FE_SB // MouseKeys()
        if (TEST_ACCESSFLAG(MouseKeys, MKF_HOTKEYACTIVE) && Vk == gNumLockVk && !fBreak && CurrentModState == MOUSEKEYMODBITS) {
#else  // FE_SB
        if (TEST_ACCESSFLAG(MouseKeys, MKF_HOTKEYACTIVE) && Vk == VK_NUMLOCK && !fBreak && CurrentModState == MOUSEKEYMODBITS) {
#endif // FE_SB
            gMKPreviousVk = Vk;
            if (TEST_ACCESSFLAG(MouseKeys, MKF_HOTKEYSOUND)) {
                PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;
                PostRitSound(
                    pTerm,
                    RITSOUND_UPSIREN);
            }
            PostAccessNotification(ACCESS_MOUSEKEYS);

            return FALSE;
        }
    } else {
        //
        // Is this a MouseKey key?
        //
        //
        FlaggedVk = Vk | (pKeyEvent->usFlaggedVk & KBDEXT);
        for (i = 0; i < cMouseVKeys; i++) {
#ifdef FE_SB // MouseKeys()
            if (FlaggedVk == gpusMouseVKey[i]) {
#else  // FE_SB
            if (FlaggedVk == ausMouseVKey[i]) {
#endif // FE_SB
                break;
            }
        }

        if (i == cMouseVKeys) {
            return TRUE;          // not a mousekey
        }
        //
        // Check to see if we should pass on key events until Num Lock is
        // entered.
        //

        if (!gbMKMouseMode) {
#ifdef FE_SB // MouseKeys()
            if (Vk != gNumLockVk) {
#else  // FE_SB
            if (Vk != VK_NUMLOCK) {
#endif // FE_SB
                return TRUE;
            }
        }

        //
        // Check for Ctrl-Alt-Numpad Del.  Pass key event on if sequence
        // detected.
        //
        if (Vk == VK_DELETE && CurrentModState & LRALT && CurrentModState & LRCONTROL) {
            return TRUE;
        }
        if (fBreak) {
            //
            // If this is a break of the key that we're accelerating then
            // kill the timer.
            //
            if (gMKPreviousVk == Vk) {
                if (gtmridMKMoveCursor != 0) {
                    KILLRITTIMER(NULL, gtmridMKMoveCursor);
                    gtmridMKMoveCursor = 0;
                }
                CLEAR_ACCF(ACCF_MKREPEATVK);
                gMKPreviousVk = 0;
            }
            //
            // Pass break of Numlock along.  Other mousekeys stop here.
            //
#ifdef FE_SB // MouseKeys()
            if (Vk == gNumLockVk) {
#else  // FE_SB
            if (Vk == VK_NUMLOCK) {
#endif // FE_SB
                return TRUE;
            } else {
                return FALSE;
            }
        } else {
            SET_OR_CLEAR_ACCF(ACCF_MKREPEATVK,
                              (gMKPreviousVk == Vk));
            //
            // If this is not a typematic repeat, kill the mouse acceleration
            // timer.
            //
            if ((!TEST_ACCF(ACCF_MKREPEATVK)) && (gtmridMKMoveCursor)) {
                KILLRITTIMER(NULL, gtmridMKMoveCursor);
                gtmridMKMoveCursor = 0;
            }
            gMKPreviousVk = Vk;
        }
        return aMouseKeyEvent[i](ausMouseKeyData[i]);
    }

    return TRUE;
}

/***************************************************************************\
* TurnOffMouseKeys
*
* Return value:
*    None.
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
VOID TurnOffMouseKeys(VOID)
{
    CLEAR_ACCESSFLAG(MouseKeys, MKF_MOUSEKEYSON);
//    gMKPassThrough = 0;
    CLEAR_ACCF(ACCF_MKREPEATVK);
    MKHideMouseCursor();
    if (TEST_ACCESSFLAG(MouseKeys, MKF_HOTKEYSOUND)) {
        PostRitSound(
            grpdeskRitInput->rpwinstaParent->pTerm,
            RITSOUND_DOWNSIREN);
    }
    PostAccessibility( ACCESS_MOUSEKEYS );
}


/*
 * Let's assert at the compile time if those values are
 * defined unexpectedly.
 */
#if (MAXSPEED_MIN >= MAXSPEED_MAX) || (MAXSPEED_MIN <= 0) || (TIMETOMAXSPEED_MIN >= TIMETOMAXSPEED_MAX) || (TIMETOMAXSPEED_MIN <= 0)
#error The mousekey min/max values are not as expected.
#endif

/***************************************************************************\
* CalculateMouseTable
*
* Set mouse table based on time to max speed and max speed.  This routine
* is called during user logon (after the registry entries for the access
* features are read).
*
* Return value:
*    None.
*
* History:
*    Taken from access utility.
*
****************************************************************************/

VOID CalculateMouseTable(VOID)
{
    long    Total_Distance;         /* in 1000th of pixel */

    long    Accel_Per_Tick;         /* in 1000th of pixel/tick */
    long    Current_Speed;          /* in 1000th of pixel/tick */
    long    Max_Speed;              /* in 1000th of pixel/tick */
    long    Real_Total_Distance;    /* in pixels */
    long    Real_Delta_Distance;    /* in pixels */
    int     i;
    int     Num_Constant_Table,Num_Accel_Table;

    UserAssert(gMouseKeys.iMaxSpeed >= MAXSPEED_MIN && gMouseKeys.iMaxSpeed <= MAXSPEED_MAX);
    UserAssert(gMouseKeys.iTimeToMaxSpeed >= TIMETOMAXSPEED_MIN && gMouseKeys.iTimeToMaxSpeed <= TIMETOMAXSPEED_MAX);
    UserAssert(gMouseKeys.iTimeToMaxSpeed != 0);

    Max_Speed = gMouseKeys.iMaxSpeed;
    Max_Speed *= 1000 / MOUSETICKS;

    Accel_Per_Tick = Max_Speed * 1000 / (gMouseKeys.iTimeToMaxSpeed * MOUSETICKS);
    Current_Speed = 0;
    Total_Distance = 0;
    Real_Total_Distance = 0;
    Num_Constant_Table = 0;
    Num_Accel_Table = 0;

    for(i=0; i<= 255; i++) {
        Current_Speed = Current_Speed + Accel_Per_Tick;
        if (Current_Speed > Max_Speed) {
            Current_Speed = Max_Speed;
        }
        Total_Distance += Current_Speed;

        //
        // Calculate how many pixels to move on this tick
        //
        Real_Delta_Distance = ((Total_Distance - (Real_Total_Distance * 1000)) + 500) / 1000 ;
        //
        // Calculate total distance moved up to this point
        //
        Real_Total_Distance = Real_Total_Distance + Real_Delta_Distance;

        if ((Current_Speed < Max_Speed) && (Num_Accel_Table < 128)) {
            gMouseCursor.bAccelTable[Num_Accel_Table++] = (BYTE)Real_Delta_Distance;
        }

        if ((Current_Speed == Max_Speed) && (Num_Constant_Table < 128)) {
            gMouseCursor.bConstantTable[Num_Constant_Table++] = (BYTE)Real_Delta_Distance;
        }

    }
    gMouseCursor.bAccelTableLen = (BYTE)Num_Accel_Table;
    gMouseCursor.bConstantTableLen = (BYTE)Num_Constant_Table;
}


/***************************************************************************\
* xxxToggleKeysTimer
*
* Enable ToggleKeys if it is currently disabled.  Disable ToggleKeys if it
* is currently enabled.
*
* This routine is called only when the NumLock key is held down for 5 seconds.
*
* Return value:
*    0
*
* History:
*   11 Feb 93 GregoryW   Created.
\***************************************************************************/
VOID xxxToggleKeysTimer(
    PWND pwnd,
    UINT message,
    UINT_PTR nID,
    LPARAM lParam)
{
    KE ToggleKeyEvent;
    PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;

    UNREFERENCED_PARAMETER(pwnd);
    UNREFERENCED_PARAMETER(message);
    UNREFERENCED_PARAMETER(nID);
    UNREFERENCED_PARAMETER(lParam);

    CheckCritIn();
    //
    // Toggle ToggleKeys and provide audible feedback if appropriate.
    //
    if (TEST_ACCESSFLAG(ToggleKeys, TKF_TOGGLEKEYSON)) {
        CLEAR_ACCESSFLAG(ToggleKeys, TKF_TOGGLEKEYSON);
        if (TEST_ACCESSFLAG(ToggleKeys, TKF_HOTKEYSOUND)) {
            PostRitSound(
                    pTerm,
                    RITSOUND_DOWNSIREN);
        }
    } else {
        if (TEST_ACCESSFLAG(ToggleKeys, TKF_HOTKEYSOUND)) {
            PostRitSound(
                    pTerm,
                    RITSOUND_UPSIREN);
        }

        PostAccessNotification(ACCESS_TOGGLEKEYS);
    }
    //
    // Send a fake break/make combination so state of numlock key remains
    // the same as it was before user pressed it to activate/deactivate
    // ToggleKeys.
    //
    ToggleKeyEvent.bScanCode = gTKScanCode;
#ifdef FE_SB // ToggleKeysTimer()
    ToggleKeyEvent.usFlaggedVk = gNumLockVk | KBDBREAK;
#else
    ToggleKeyEvent.usFlaggedVk = VK_NUMLOCK | KBDBREAK;
#endif // FE_SB
    if (AccessProceduresStream(&ToggleKeyEvent, gTKExtraInformation, gTKNextProcIndex)) {
        xxxProcessKeyEvent(&ToggleKeyEvent, gTKExtraInformation, FALSE);
    }
#ifdef FE_SB // ToggleKeysTimer()
    ToggleKeyEvent.usFlaggedVk = gNumLockVk;
#else
    ToggleKeyEvent.usFlaggedVk = VK_NUMLOCK;
#endif // FE_SB
    if (AccessProceduresStream(&ToggleKeyEvent, gTKExtraInformation, gTKNextProcIndex)) {
        xxxProcessKeyEvent(&ToggleKeyEvent, gTKExtraInformation, FALSE);
    }
}


/***************************************************************************\
* ToggleKeys
*
* This is the strategy routine that gets called as part of the input stream
* processing.  Keys of interest are Num Lock, Scroll Lock and Caps Lock.
*
* Return value:
*    TRUE - key event should be passed on to the next access routine.
*    FALSE - key event was processed and should not be passed on.
*
* History:
\***************************************************************************/
BOOL ToggleKeys(PKE pKeyEvent, ULONG ExtraInformation, int NextProcIndex)
{
    int fBreak;
    BYTE Vk;

    CheckCritIn();
    Vk = (BYTE)pKeyEvent->usFlaggedVk;
    fBreak = pKeyEvent->usFlaggedVk & KBDBREAK;

    //
    // Check for Numlock key.  On the first make set the ToggleKeys timer.
    // The timer is killed on the break of the Numlock key.
    //
    switch (Vk) {
    case VK_NUMLOCK:
#ifdef FE_SB // ToggleKeys()
NumLockProc:
#endif // FE_SB
        /*
         * Don't handle NUMLOCK toggles if the user is doing MouseKey
         * toggling.
         */
        if ((gLockBits | gLatchBits | gPhysModifierState) == MOUSEKEYMODBITS &&
                TEST_ACCESSFLAG(MouseKeys, MKF_HOTKEYACTIVE)) {
            break;
        }
        if (fBreak)
        {
            //
            // Only reset gptmrToggleKeys on the break of NumLock. This
            // prevents cycling the toggle keys state by continually
            // holding down the NumLock key.
            //
            KILLRITTIMER(NULL, gtmridToggleKeys);
            gtmridToggleKeys = 0;
            gTKExtraInformation = 0;
            gTKScanCode = 0;
        }
        else
        {
            if (gtmridToggleKeys == 0 &&
                TEST_ACCESSFLAG(ToggleKeys, TKF_HOTKEYACTIVE))
            {

                //
                // Remember key information to be used by timer routine.
                //
                gTKExtraInformation = ExtraInformation;
                gTKScanCode = pKeyEvent->bScanCode;
                gTKNextProcIndex = NextProcIndex;
                gtmridToggleKeys = InternalSetTimer(NULL,
                                                    0,
                                                    TOGGLEKEYTOGGLETIME,
                                                    xxxToggleKeysTimer,
                                                    TMRF_RIT | TMRF_ONESHOT);
            }
        }

        //
        // If MouseKeys is on, audible feedback has already occurred for this
        // keystroke.  Skip the rest of the processing.
        //
        if (TEST_ACCESSFLAG(MouseKeys, MKF_MOUSEKEYSON)) {
            break;
        }
        // fall through

    case VK_SCROLL:
    case VK_CAPITAL:
#ifdef FE_SB // ToggleKeys()
CapitalProc:
#endif // FE_SB
        if (TEST_ACCESSFLAG(ToggleKeys, TKF_TOGGLEKEYSON) && !fBreak) {
            if (!TestAsyncKeyStateDown(Vk)) {
                PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;
                if (!TestAsyncKeyStateToggle(Vk)) {
                    PostRitSound(
                        pTerm,
                        RITSOUND_HIGHBEEP);
                } else {
                    PostRitSound(
                        pTerm,
                        RITSOUND_LOWBEEP);
                }
            }
        }
        break;

    default:
#ifdef FE_SB // ToggleKeys()
        if (Vk == gNumLockVk) goto NumLockProc;
        if (Vk == gOemScrollVk) goto CapitalProc;
#endif // FE_SB
        if (gtmridToggleKeys != 0) {
            KILLRITTIMER(NULL, gtmridToggleKeys);
        }
    }

    return TRUE;
}


/***************************************************************************\
* AccessTimeOutTimer
*
* This routine is called if no keyboard activity takes place for the
* user configured amount of time.  All access related functions are
* disabled.
*
* This routine is called with the critical section already locked.
*
* Return value:
*    0
*
* History:
\***************************************************************************/
VOID xxxAccessTimeOutTimer(
    PWND pwnd,
    UINT message,
    UINT_PTR nID,
    LPARAM lParam)
{
    UNREFERENCED_PARAMETER(pwnd);
    UNREFERENCED_PARAMETER(message);
    UNREFERENCED_PARAMETER(nID);
    UNREFERENCED_PARAMETER(lParam);

    CheckCritIn();

    /*
     * The timeout timer will remain on (if so configured) as long as
     * TEST_ACCF(ACCF_ACCESSENABLED) is TRUE.  This means we might get timeouts when
     * only hot keys are enabled, but no features are actually on.  Don't
     * provide any audible feedback in this case.
     */
    if (    TEST_ACCESSFLAG(FilterKeys, FKF_FILTERKEYSON)   ||
            TEST_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON)   ||
            TEST_ACCESSFLAG(MouseKeys, MKF_MOUSEKEYSON)     ||
            TEST_ACCESSFLAG(ToggleKeys, TKF_TOGGLEKEYSON)   ||
            TEST_ACCESSFLAG(SoundSentry, SSF_SOUNDSENTRYON) ||
            TEST_ACCESSFLAG(HighContrast, HCF_HIGHCONTRASTON) ||
            TEST_ACCF(ACCF_SHOWSOUNDSON)) {

        PTERMINAL pTerm = grpdeskRitInput->rpwinstaParent->pTerm;
        CLEAR_ACCESSFLAG(FilterKeys, FKF_FILTERKEYSON);
        xxxTurnOffStickyKeys();
        CLEAR_ACCESSFLAG(MouseKeys, MKF_MOUSEKEYSON);
        CLEAR_ACCESSFLAG(ToggleKeys, TKF_TOGGLEKEYSON);
        CLEAR_ACCESSFLAG(SoundSentry, SSF_SOUNDSENTRYON);
        CLEAR_ACCF(ACCF_SHOWSOUNDSON);
        CLEAR_ACCESSFLAG(HighContrast, HCF_HIGHCONTRASTON);

        if (gspwndLogonNotify != NULL) {

        _PostMessage(gspwndLogonNotify, WM_LOGONNOTIFY,
                     LOGON_ACCESSNOTIFY, ACCESS_HIGHCONTRASTOFF);
        }

        if (TEST_ACCESSFLAG(AccessTimeOut, ATF_ONOFFFEEDBACK)) {
            PostRitSound(
                    pTerm,
                    RITSOUND_DOWNSIREN);
        }
        PostAccessibility( ACCESS_MOUSEKEYS );

        PostAccessibility( ACCESS_FILTERKEYS );

        PostAccessibility( ACCESS_STICKYKEYS );

    }
    SetAccessEnabledFlag();
}

/***************************************************************************\
* AccessTimeOutReset
*
* This routine resets the timeout timer.
*
* Return value:
*    0
*
* History:
\***************************************************************************/
VOID AccessTimeOutReset(
    VOID)
{

    if (gtmridAccessTimeOut != 0) {
        KILLRITTIMER(NULL, gtmridAccessTimeOut);
    }

    if (TEST_ACCESSFLAG(AccessTimeOut, ATF_TIMEOUTON)) {
        gtmridAccessTimeOut = InternalSetTimer(NULL,
                                               0,
                                               (UINT)gAccessTimeOut.iTimeOutMSec,
                                               xxxAccessTimeOutTimer,
                                               TMRF_RIT | TMRF_ONESHOT);
    }
}

/***************************************************************************\
* xxxUpdatePerUserAccessPackSettings
*
* Sets the initial access pack features according to the user's profile.
*
* 02-14-93 GregoryW        Created.
\***************************************************************************/
VOID xxxUpdatePerUserAccessPackSettings(
    PUNICODE_STRING pProfileUserName)
{
    LUID luidCaller;
    NTSTATUS Status;
    BOOL fSystem;
    BOOL fRegFilterKeysOn;
    BOOL fRegStickyKeysOn;
    BOOL fRegMouseKeysOn;
    BOOL fRegToggleKeysOn;
    BOOL fRegTimeOutOn;
    BOOL fRegKeyboardPref;
    BOOL fRegScreenReader;
    BOOL fRegHighContrastOn;
    DWORD dwDefFlags;
    WCHAR wcHighContrastScheme[MAX_SCHEME_NAME_SIZE];

    Status = GetProcessLuid(NULL, &luidCaller);
    //
    // If we're called in the system context no one is logged on.
    // We want to read the current .DEFAULT settings for the access
    // features.  Later when we're called in the user context (e.g.,
    // someone has successfully logged on) we check to see if the
    // current access state is the same as the default setting.  If
    // not, the user has enabled/disabled one or more access features
    // from the keyboard.  These changes will be propagated across
    // the logon into the user's intial state (overriding the settings
    // in the user's profile).
    //
    if (NT_SUCCESS(Status) && RtlEqualLuid(&luidCaller, &luidSystem)) {
        fSystem = TRUE;
    } else {
        fSystem = FALSE;
    }

    FastGetProfileIntW(pProfileUserName,
                       PMAP_KEYBOARDRESPONSE,
                       TEXT("Flags"),
                       0,
                       &dwDefFlags,
                       0);

    fRegFilterKeysOn = (dwDefFlags & FKF_FILTERKEYSON) != 0;

    FastGetProfileIntW(pProfileUserName,
                       PMAP_STICKYKEYS,
                       TEXT("Flags"),
                       0,
                       &dwDefFlags,
                       0);
    fRegStickyKeysOn = (dwDefFlags & SKF_STICKYKEYSON) != 0;

    FastGetProfileIntW(pProfileUserName,
                       PMAP_MOUSEKEYS,
                       TEXT("Flags"),
                       0,
                       &dwDefFlags,
                       0);
    fRegMouseKeysOn = (dwDefFlags & MKF_MOUSEKEYSON) != 0;

    FastGetProfileIntW(pProfileUserName,
                       PMAP_TOGGLEKEYS,
                       TEXT("Flags"),
                       0,
                       &dwDefFlags,
                       0);
    fRegToggleKeysOn = (dwDefFlags & TKF_TOGGLEKEYSON) != 0;

    FastGetProfileIntW(pProfileUserName,
                       PMAP_KEYBOARDPREF,
                       TEXT("On"),
                       0,
                       &dwDefFlags,
                       0);
    fRegKeyboardPref = !!dwDefFlags;

    FastGetProfileIntW(pProfileUserName,
                       PMAP_SCREENREADER,
                       TEXT("On"),
                       0,
                       &dwDefFlags,
                       0);
    fRegScreenReader = !!dwDefFlags;

    FastGetProfileIntW(pProfileUserName,
                       PMAP_TIMEOUT,
                       TEXT("Flags"),
                       0,
                       &dwDefFlags,
                       0);
    fRegTimeOutOn = (dwDefFlags & ATF_TIMEOUTON) != 0;

    FastGetProfileIntW(pProfileUserName,
                       PMAP_HIGHCONTRAST,
                       TEXT("Flags"),
                       0,
                       &dwDefFlags,
                       0);
    fRegHighContrastOn = (dwDefFlags & HCF_HIGHCONTRASTON) != 0;

    if (fSystem) {
        //
        // We're in system mode (e.g., no one is logged in).  Remember
        // the .DEFAULT state for comparison during the next user logon
        // and set the current state to the .DEFAULT state.
        //
        if (fRegFilterKeysOn) {
            SET_ACCF(ACCF_DEFAULTFILTERKEYSON);
            SET_ACCESSFLAG(FilterKeys, FKF_FILTERKEYSON);
        } else {
            CLEAR_ACCF(ACCF_DEFAULTFILTERKEYSON);
            CLEAR_ACCESSFLAG(FilterKeys, FKF_FILTERKEYSON);
        }

        //
        // If StickyKeys is currently on and we're about to turn it
        // off we need to make sure the latch keys and lock keys are
        // released.
        //
        if (TEST_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON) && (fRegFilterKeysOn == 0)) {
                xxxTurnOffStickyKeys();
        }

        if (fRegStickyKeysOn) {
            SET_ACCF(ACCF_DEFAULTSTICKYKEYSON);
            SET_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON);
        } else {
            CLEAR_ACCF(ACCF_DEFAULTSTICKYKEYSON);
            CLEAR_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON);
        }

        if (fRegMouseKeysOn) {
            SET_ACCF(ACCF_DEFAULTMOUSEKEYSON);
            SET_ACCESSFLAG(MouseKeys, MKF_MOUSEKEYSON);
        } else {
            CLEAR_ACCF(ACCF_DEFAULTMOUSEKEYSON);
            CLEAR_ACCESSFLAG(MouseKeys, MKF_MOUSEKEYSON);
        }

        if (fRegToggleKeysOn) {
            SET_ACCF(ACCF_DEFAULTTOGGLEKEYSON);
            SET_ACCESSFLAG(ToggleKeys, TKF_TOGGLEKEYSON);
        } else {
            CLEAR_ACCF(ACCF_DEFAULTTOGGLEKEYSON);
            CLEAR_ACCESSFLAG(ToggleKeys, TKF_TOGGLEKEYSON);
        }

        if (fRegTimeOutOn) {
            SET_ACCF(ACCF_DEFAULTTIMEOUTON);
            SET_ACCESSFLAG(AccessTimeOut, ATF_TIMEOUTON);
        } else {
            CLEAR_ACCF(ACCF_DEFAULTTIMEOUTON);
            CLEAR_ACCESSFLAG(AccessTimeOut, ATF_TIMEOUTON);
        }

        if (fRegKeyboardPref) {
            SET_ACCF(ACCF_DEFAULTKEYBOARDPREF);
            SET_ACCF(ACCF_KEYBOARDPREF);
            SET_SRVIF(SRVIF_KEYBOARDPREF);
        } else {
            CLEAR_ACCF(ACCF_DEFAULTKEYBOARDPREF);
            CLEAR_ACCF(ACCF_KEYBOARDPREF);
            CLEAR_SRVIF(SRVIF_KEYBOARDPREF);
        }

        if (fRegScreenReader) {
            SET_ACCF(ACCF_DEFAULTSCREENREADER);
            SET_ACCF(ACCF_SCREENREADER);
        } else {
            CLEAR_ACCF(ACCF_DEFAULTSCREENREADER);
            CLEAR_ACCF(ACCF_SCREENREADER);
        }

        if (fRegHighContrastOn) {
            SET_ACCF(ACCF_DEFAULTHIGHCONTRASTON);
            SET_ACCESSFLAG(HighContrast, HCF_HIGHCONTRASTON);
        } else {
            CLEAR_ACCF(ACCF_DEFAULTHIGHCONTRASTON);
            CLEAR_ACCESSFLAG(HighContrast, HCF_HIGHCONTRASTON);
        }
    } else {
        //
        // A user has successfully logged on.  If the current state is
        // different from the default state stored earlier then we know
        // the user has modified the state via the keyboard (at the logon
        // dialog).  This state will override whatever on/off state the
        // user has set in their profile.  If the current state is the
        // same as the default state then the on/off setting from the
        // user profile is used.
        //

        if (    TEST_BOOL_ACCESSFLAG(FilterKeys, FKF_FILTERKEYSON) ==
                TEST_BOOL_ACCF(ACCF_DEFAULTFILTERKEYSON)) {
            //
            // Current state and default state are the same.  Use the
            // user's profile setting.
            //

            SET_OR_CLEAR_ACCESSFLAG(FilterKeys, FKF_FILTERKEYSON, fRegFilterKeysOn);
        }

        if (    TEST_BOOL_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON) ==
                TEST_BOOL_ACCF(ACCF_DEFAULTSTICKYKEYSON)) {
            //
            // If StickyKeys is currently on and we're about to turn it
            // off we need to make sure the latch keys and lock keys are
            // released.
            //
            if (    TEST_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON) &&
                    (fRegStickyKeysOn == 0)) {

                xxxTurnOffStickyKeys();
            }

            SET_OR_CLEAR_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON, fRegStickyKeysOn);
        }

        if (    TEST_BOOL_ACCESSFLAG(MouseKeys, MKF_MOUSEKEYSON) ==
                TEST_BOOL_ACCF(ACCF_DEFAULTMOUSEKEYSON)) {
            //
            // Current state and default state are the same.  Use the user's
            // profile setting.
            //
            SET_OR_CLEAR_ACCESSFLAG(MouseKeys, MKF_MOUSEKEYSON, fRegMouseKeysOn);
        }

        if (    TEST_BOOL_ACCESSFLAG(ToggleKeys, TKF_TOGGLEKEYSON) ==
                TEST_BOOL_ACCF(ACCF_DEFAULTTOGGLEKEYSON)) {
            //
            // Current state and default state are the same.  Use the user's
            // profile setting.
            //
            SET_OR_CLEAR_ACCESSFLAG(ToggleKeys, TKF_TOGGLEKEYSON, fRegToggleKeysOn);
        }

        if (    TEST_BOOL_ACCESSFLAG(AccessTimeOut, ATF_TIMEOUTON) ==
                TEST_BOOL_ACCF(ACCF_DEFAULTTIMEOUTON)) {
            //
            // Current state and default state are the same.  Use the user's
            // profile setting.
            //
            SET_OR_CLEAR_ACCESSFLAG(AccessTimeOut, ATF_TIMEOUTON, fRegTimeOutOn);
        }

        if (    TEST_BOOL_ACCF(ACCF_KEYBOARDPREF) ==
                TEST_BOOL_ACCF(ACCF_DEFAULTKEYBOARDPREF)) {
            //
            // Current state and default state are the same.  Use the user's
            // profile setting.
            //
            SET_OR_CLEAR_ACCF(ACCF_KEYBOARDPREF, fRegKeyboardPref);
        }

        if (    TEST_BOOL_ACCF(ACCF_SCREENREADER) ==
                TEST_BOOL_ACCF(ACCF_DEFAULTSCREENREADER)) {
            //
            // Current state and default state are the same.  Use the user's
            // profile setting.
            //
            SET_OR_CLEAR_ACCF(ACCF_SCREENREADER, fRegScreenReader);
        }

        if (    TEST_BOOL_ACCESSFLAG(HighContrast, HCF_HIGHCONTRASTON) ==
                TEST_BOOL_ACCF(ACCF_DEFAULTHIGHCONTRASTON)) {
            //
            // Current state and default state are the same.  Use the user's
            // profile setting.
            //
            SET_OR_CLEAR_ACCESSFLAG(HighContrast, HCF_HIGHCONTRASTON, fRegHighContrastOn);
        }
    }

    //
    // Get the default FilterKeys state.
    //
    // -------- flag --------------- value --------- default ------
    // #define FKF_FILTERKEYSON    0x00000001           0
    // #define FKF_AVAILABLE       0x00000002           2
    // #define FKF_HOTKEYACTIVE    0x00000004           0
    // #define FKF_CONFIRMHOTKEY   0x00000008           0
    // #define FKF_HOTKEYSOUND     0x00000010          10
    // #define FKF_INDICATOR       0x00000020           0
    // #define FKF_CLICKON         0x00000040          40
    // ----------------------------------------- total = 0x52 = 82
    //

    FastGetProfileIntW(pProfileUserName,
                       PMAP_KEYBOARDRESPONSE,
                       TEXT("Flags"),
                       82,
                       &dwDefFlags,
                       0);

    SET_OR_CLEAR_FLAG(
            dwDefFlags,
            FKF_FILTERKEYSON,
            TEST_ACCESSFLAG(FilterKeys, FKF_FILTERKEYSON));

    gFilterKeys.dwFlags = dwDefFlags;
    FastGetProfileIntW(pProfileUserName,
                       PMAP_KEYBOARDRESPONSE,
                       TEXT("DelayBeforeAcceptance"),
                       1000,
                       &gFilterKeys.iWaitMSec,
                       0);

    FastGetProfileIntW(pProfileUserName,
                       PMAP_KEYBOARDRESPONSE,
                       TEXT("AutoRepeatRate"),
                       500,
                       &gFilterKeys.iRepeatMSec,
                       0);

    FastGetProfileIntW(pProfileUserName,
                       PMAP_KEYBOARDRESPONSE,
                       TEXT("AutoRepeatDelay"),
                       1000,
                       &gFilterKeys.iDelayMSec,
                       0);

    FastGetProfileIntW(pProfileUserName,
                       PMAP_KEYBOARDRESPONSE,
                       TEXT("BounceTime"),
                       0,
                       &gFilterKeys.iBounceMSec,
                       0);

    //
    // Fill in the SoundSentry state.  This release of the
    // accessibility features only supports iWindowsEffect.
    //
    // -------- flag --------------- value --------- default ------
    // #define SSF_SOUNDSENTRYON   0x00000001           0
    // #define SSF_AVAILABLE       0x00000002           1
    // #define SSF_INDICATOR       0x00000004           0
    // ----------------------------------------- total = 0x2 = 2
    //
    FastGetProfileIntW(pProfileUserName,
                       PMAP_SOUNDSENTRY,
                       TEXT("Flags"),
                       2,
                       &gSoundSentry.dwFlags,
                       0);

    FastGetProfileIntW(pProfileUserName,
                       PMAP_SOUNDSENTRY,
                       TEXT("FSTextEffect"),
                       0,
                       &gSoundSentry.iFSTextEffect,
                       0);

    FastGetProfileIntW(pProfileUserName,
                       PMAP_SOUNDSENTRY,
                       TEXT("WindowsEffect"),
                       0,
                       &gSoundSentry.iWindowsEffect,
                       0);

    /*
     * Set ShowSounds flag.
     */
    FastGetProfileIntW(pProfileUserName,
                       PMAP_SHOWSOUNDS,
                       TEXT("On"),
                       0,
                       &dwDefFlags,
                       0);
    SET_OR_CLEAR_ACCF(ACCF_SHOWSOUNDSON, dwDefFlags);
    /*
    * Bug 17210.  Update the System Metrics Info.
    */
    SYSMET(SHOWSOUNDS) = TEST_BOOL_ACCF(ACCF_SHOWSOUNDSON);

    //
    // Get the default StickyKeys state.
    //
    // -------- flag --------------- value --------- default ------
    // #define SKF_STICKYKEYSON    0x00000001          0
    // #define SKF_AVAILABLE       0x00000002          2
    // #define SKF_HOTKEYACTIVE    0x00000004          0
    // #define SKF_CONFIRMHOTKEY   0x00000008          0
    // #define SKF_HOTKEYSOUND     0x00000010         10
    // #define SKF_INDICATOR       0x00000020          0
    // #define SKF_AUDIBLEFEEDBACK 0x00000040         40
    // #define SKF_TRISTATE        0x00000080         80
    // #define SKF_TWOKEYSOFF      0x00000100        100
    // ----------------------------------------- total = 0x1d2 = 466
    //
    FastGetProfileIntW(pProfileUserName,
                       PMAP_STICKYKEYS,
                       TEXT("Flags"),
                       466,
                       &dwDefFlags,
                       0);

    SET_OR_CLEAR_FLAG(
            dwDefFlags,
            SKF_STICKYKEYSON,
            TEST_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON));

    gStickyKeys.dwFlags = dwDefFlags;

    //
    // Get the default MouseKeys state.
    //
    // -------- flag --------------- value --------- default ------
    // #define MKF_MOUSEKEYSON     0x00000001           0
    // #define MKF_AVAILABLE       0x00000002           2
    // #define MKF_HOTKEYACTIVE    0x00000004           0
    // #define MKF_CONFIRMHOTKEY   0x00000008           0
    // #define MKF_HOTKEYSOUND     0x00000010          10
    // #define MKF_INDICATOR       0x00000020           0
    // #define MKF_MODIFIERS       0x00000040           0
    // #define MKF_REPLACENUMBERS  0x00000080           0
    // ----------------------------------------- total = 0x12 = 18
    //
    FastGetProfileIntW(pProfileUserName,
                       PMAP_MOUSEKEYS,
                       TEXT("Flags"),
                       18,
                       &dwDefFlags,
                       0);

    SET_OR_CLEAR_FLAG(
            dwDefFlags,
            MKF_MOUSEKEYSON,
            TEST_ACCESSFLAG(MouseKeys, MKF_MOUSEKEYSON));

    gMouseKeys.dwFlags = dwDefFlags;
    FastGetProfileIntW(pProfileUserName,
                       PMAP_MOUSEKEYS,
                       TEXT("MaximumSpeed"),
                       MAXSPEED_DEF,
                       &gMouseKeys.iMaxSpeed,
                       0);

    FastGetProfileIntW(pProfileUserName,
                       PMAP_MOUSEKEYS,
                       TEXT("TimeToMaximumSpeed"),
                       TIMETOMAXSPEED_DEF,
                       &gMouseKeys.iTimeToMaxSpeed,
                       0);
 
    /*
     * Avoid unexpected values, like when the migration from previous OS has set bogus values
     * or when the registry is simply broken...
     */
    if (gMouseKeys.iMaxSpeed < MAXSPEED_MIN || gMouseKeys.iMaxSpeed > MAXSPEED_MAX) {
        gMouseKeys.iMaxSpeed = MAXSPEED_DEF;
    }
    if (gMouseKeys.iTimeToMaxSpeed < TIMETOMAXSPEED_MIN || gMouseKeys.iTimeToMaxSpeed > TIMETOMAXSPEED_MAX) {
        gMouseKeys.iTimeToMaxSpeed = TIMETOMAXSPEED_DEF;
    }

    CalculateMouseTable();

    gbMKMouseMode =
#ifdef FE_SB
            (TestAsyncKeyStateToggle(gNumLockVk) != 0) ^
#else  // FE_SB
            (TestAsyncKeyStateToggle(VK_NUMLOCK) != 0) ^
#endif // FE_SB
            (TEST_ACCESSFLAG(MouseKeys, MKF_REPLACENUMBERS) != 0);

    //
    // If the system does not have a hardware mouse:
    //    If MouseKeys is enabled show the mouse cursor,
    //    o.w. hide the mouse cursor.
    //
    if (TEST_ACCESSFLAG(MouseKeys, MKF_MOUSEKEYSON)) {
        MKShowMouseCursor();
    } else {
        MKHideMouseCursor();
    }

    //
    // Get the default ToggleKeys state.
    //
    // -------- flag --------------- value --------- default ------
    // #define TKF_TOGGLEKEYSON    0x00000001           0
    // #define TKF_AVAILABLE       0x00000002           2
    // #define TKF_HOTKEYACTIVE    0x00000004           0
    // #define TKF_CONFIRMHOTKEY   0x00000008           0
    // #define TKF_HOTKEYSOUND     0x00000010          10
    // #define TKF_INDICATOR       0x00000020           0
    // ----------------------------------------- total = 0x12 = 18
    //
    FastGetProfileIntW(pProfileUserName,
                       PMAP_TOGGLEKEYS,
                       TEXT("Flags"),
                       18,
                       &dwDefFlags,
                       0);

    SET_OR_CLEAR_FLAG(
            dwDefFlags,
            TKF_TOGGLEKEYSON,
            TEST_ACCESSFLAG(ToggleKeys, TKF_TOGGLEKEYSON));

    gToggleKeys.dwFlags = dwDefFlags;

    //
    // Get the default Timeout state.
    //
    // -------- flag --------------- value --------- default ------
    // #define ATF_TIMEOUTON       0x00000001           0
    // #define ATF_ONOFFFEEDBACK   0x00000002           2
    // ----------------------------------------- total = 0x2 = 2
    //
    FastGetProfileIntW(pProfileUserName,
                       PMAP_TIMEOUT,
                       TEXT("Flags"),
                       2,
                       &dwDefFlags,
                       0);

    SET_OR_CLEAR_FLAG(
            dwDefFlags,
            ATF_TIMEOUTON,
            TEST_ACCESSFLAG(AccessTimeOut, ATF_TIMEOUTON));

    gAccessTimeOut.dwFlags = dwDefFlags;

#ifdef FE_SB //
    if (gpKbdNlsTbl) {
        //
        // Is there any alternative MouseVKey table in KBDNLSTABLE ?
        //
        if ((gpKbdNlsTbl->NumOfMouseVKey == cMouseVKeys) &&
            (gpKbdNlsTbl->pusMouseVKey   != NULL)) {
            //
            // Overwite the pointer.
            //
            gpusMouseVKey = gpKbdNlsTbl->pusMouseVKey;
        }

        //
        // Is there any remapping flag for VK_NUMLOCK/VK_SCROLL ?
        //
        if (gpKbdNlsTbl->LayoutInformation & NLSKBD_INFO_ACCESSIBILITY_KEYMAP) {
            //
            // Overwrite default.
            //
            gNumLockVk = VK_HOME;
            gOemScrollVk = VK_KANA;
        }
    }
#endif // FE_SB

    FastGetProfileIntW(pProfileUserName,
                       PMAP_TIMEOUT,
                       TEXT("TimeToWait"),
                       300000,
                       &gAccessTimeOut.iTimeOutMSec,
                       0);  // default is 5 minutes

   /*
    * Get High Contrast state
    */

    FastGetProfileIntW(pProfileUserName,
                       PMAP_HIGHCONTRAST,
                       TEXT("Flags"),
                       HCF_AVAILABLE | HCF_HOTKEYSOUND | HCF_HOTKEYAVAILABLE,
                       &dwDefFlags,
                       0);

    SET_OR_CLEAR_FLAG(
            dwDefFlags,
            HCF_HIGHCONTRASTON,
            TEST_ACCESSFLAG(HighContrast, HCF_HIGHCONTRASTON));

    gHighContrast.dwFlags = dwDefFlags;

    /*
     * Get scheme -- set up buffer
     */

    if (FastGetProfileStringW(pProfileUserName,
            PMAP_HIGHCONTRAST,
            TEXT("High Contrast Scheme"),
            NULL,
            wcHighContrastScheme,
            MAX_SCHEME_NAME_SIZE,
            0)) {

        /*
         * copy data
         */

        wcscpy(gHighContrastDefaultScheme, wcHighContrastScheme);
    }


    AccessTimeOutReset();
    SetAccessEnabledFlag();
}


/***************************************************************************\
* SetAccessEnabledFlag
*
* Sets the global flag ACCF_ACCESSENABLED to non-zero if any accessibility
* function is on or hot key activation is enabled.  When TEST_ACCF(ACCF_ACCESSENABLED)
* is zero keyboard input is processed directly.  When TEST_ACCF(ACCF_ACCESSENABLED) is
* non-zero keyboard input is filtered through AccessProceduresStream().
* See KeyboardApcProcedure in ntinput.c.
*
* History:
* 01-19-94 GregoryW         Created.
\***************************************************************************/
VOID SetAccessEnabledFlag(VOID)
{

    SET_OR_CLEAR_ACCF(ACCF_ACCESSENABLED,
                      TEST_ACCESSFLAG(FilterKeys, FKF_FILTERKEYSON)  ||
                      TEST_ACCESSFLAG(FilterKeys, FKF_HOTKEYACTIVE)  ||
                      TEST_ACCESSFLAG(StickyKeys, SKF_STICKYKEYSON)  ||
                      TEST_ACCESSFLAG(StickyKeys, SKF_HOTKEYACTIVE)  ||
                      TEST_ACCESSFLAG(HighContrast, HCF_HOTKEYACTIVE)  ||
                      TEST_ACCESSFLAG(MouseKeys, MKF_MOUSEKEYSON)    ||
                      TEST_ACCESSFLAG(MouseKeys, MKF_HOTKEYACTIVE)   ||
                      TEST_ACCESSFLAG(ToggleKeys, TKF_TOGGLEKEYSON)  ||
                      TEST_ACCESSFLAG(ToggleKeys, TKF_HOTKEYACTIVE)  ||
                      TEST_ACCESSFLAG(SoundSentry, SSF_SOUNDSENTRYON)||
                      TEST_ACCF(ACCF_SHOWSOUNDSON));
}

VOID SoundSentryTimer(
    PWND pwnd,
    UINT message,
    UINT_PTR idTimer,
    LPARAM lParam)
{
    TL tlpwndT;
    PWND pwndSoundSentry;

    UNREFERENCED_PARAMETER(pwnd);
    UNREFERENCED_PARAMETER(message);
    UNREFERENCED_PARAMETER(lParam);

    if (pwndSoundSentry = RevalidateHwnd(ghwndSoundSentry)) {
        ThreadLock(pwndSoundSentry, &tlpwndT);
        xxxFlashWindow(pwndSoundSentry,
                       (TEST_BOOL_ACCF(ACCF_FIRSTTICK) ? FLASHW_ALL : FLASHW_STOP),
                       0);
        ThreadUnlock(&tlpwndT);
    }

    if (TEST_ACCF(ACCF_FIRSTTICK)) {
        gtmridSoundSentry = InternalSetTimer(NULL,
                                             idTimer,
                                             5,
                                             SoundSentryTimer,
                                             TMRF_RIT | TMRF_ONESHOT);
        CLEAR_ACCF(ACCF_FIRSTTICK);
    } else {
        ghwndSoundSentry = NULL;
        gtmridSoundSentry = 0;
        SET_ACCF(ACCF_FIRSTTICK);
    }
}

/***************************************************************************\
* _UserSoundSentryWorker
*
* This is the worker routine that provides the visual feedback requested
* by the user.
*
* History:
* 08-02-93 GregoryW         Created.
\***************************************************************************/
BOOL
_UserSoundSentryWorker(VOID)
{
    PWND pwndActive;
    TL tlpwndT;

    CheckCritIn();
    //
    // Check to see if SoundSentry is on.
    //
    if (!TEST_ACCESSFLAG(SoundSentry, SSF_SOUNDSENTRYON)) {
        return TRUE;
    }

    if ((gpqForeground != NULL) && (gpqForeground->spwndActive != NULL)) {
        pwndActive = gpqForeground->spwndActive;
    } else {
        return TRUE;
    }

    switch (gSoundSentry.iWindowsEffect) {

    case SSWF_NONE:
        break;

    case SSWF_TITLE:
        //
        // Flash the active caption bar.
        //
        if (gtmridSoundSentry) {
            break;
        }
        ThreadLock(pwndActive, &tlpwndT);
        xxxFlashWindow(pwndActive, FLASHW_ALL, 0);
        ThreadUnlock(&tlpwndT);

        ghwndSoundSentry = HWq(pwndActive);
        gtmridSoundSentry = InternalSetTimer(NULL,
                                             0,
                                             gpsi->dtCaretBlink,
                                             SoundSentryTimer,
                                             TMRF_RIT | TMRF_ONESHOT);
        break;

    case SSWF_WINDOW:
    {
        //
        // Flash the active window.
        //
        HDC hdc;
        RECT rc;

        hdc = _GetWindowDC(pwndActive);
        _GetWindowRect(pwndActive, &rc);
        //
        // _GetWindowRect returns screen coordinates.  First adjust them
        // to window (display) coordinates and then map them to logical
        // coordinates before calling InvertRect.
        //
        OffsetRect(&rc, -rc.left, -rc.top);
        GreDPtoLP(hdc, (LPPOINT)&rc, 2);
        InvertRect(hdc, &rc);
        InvertRect(hdc, &rc);
        _ReleaseDC(hdc);
        break;
    }

    case SSWF_DISPLAY:
    {
        //
        // Flash the entire display.
        //
        HDC hdc;
        RECT rc;

        hdc = _GetDCEx(PWNDDESKTOP(pwndActive), NULL, DCX_WINDOW | DCX_CACHE);
        rc.left = rc.top = 0;
        rc.right = SYSMET(CXVIRTUALSCREEN);
        rc.bottom = SYSMET(CYVIRTUALSCREEN);
        InvertRect(hdc, &rc);
        InvertRect(hdc, &rc);
        _ReleaseDC(hdc);
        break;
    }
    }

    return TRUE;
}

/***************************************************************************\
* UtilityManager
*
* This is the strategy routine that gets called as part of the input stream
* processing.  Utility Manager launching happens here.
*
* Return value:
*    TRUE  - key event should be passed on to the next access routine.
*    FALSE - key event was processed and should not be passed on.
*
* History: 10-28-98 a-anilk created
\***************************************************************************/
BOOL UtilityManager(
    PKE pKeyEvent,
    ULONG ExtraInformation,
    int NotUsed)
{
    int CurrentModState;
    int fBreak;
    BYTE Vk;

    UNREFERENCED_PARAMETER(NotUsed);
    UNREFERENCED_PARAMETER(ExtraInformation);

    CheckCritIn();

    Vk = (BYTE)(pKeyEvent->usFlaggedVk & 0xff);
    fBreak = pKeyEvent->usFlaggedVk & KBDBREAK;
    CurrentModState = gLockBits | gLatchBits | gPhysModifierState;

    // the hot key to launch the utility manager is WinKey + U
    if (Vk == VK_U && !fBreak && (CurrentModState & LRWIN)) {
        PostAccessNotification(ACCESS_UTILITYMANAGER);

        return FALSE;
    }

    return TRUE;  // send key event to next accessibility routine.
}