vkchjpn1.cpp

来自「WinCE 3.0 BSP, 包含Inter SA1110, Intel_815」· C++ 代码 · 共 1,819 行 · 第 1/5 页

/* -*-C-*-
 *
 * $Revision: 1.1 $
 *   $Author: kwelton $
 *     $Date: 2000/04/12 03:33:14 $
 *
 * Copyright (c) 1995-1998  Microsoft Corporation
 * Copyright (c) 2000 ARM Limited
 * All Rights Reserved
 */

#include <windows.h>
#include <nkintr.h>
#include <keybd.h>
#include <keybddr.h>
#include <keybdpdd.h>

//      Languages besides English may return more than one character.
//      It is usually a dead char and another character.
#define MAX_TO_UNICODE_CHARACTERS       2


#define VK_A    0x41
#define VK_F    0x46

#define VK_6    0x36
#define VK_X    0x58



#define C_ALT_NUM_VK    5

struct TO_UNICODE_STATE
        {
        BOOL                    bAltNumAltDownTransition;
        BOOL                    bAltNumInProgress;
        BOOL                    bAltNumHex;
        int                             cAltNumVk;
        unsigned int    vkAltNum[C_ALT_NUM_VK];
        };


void
VKeyToUnicodeInfo(
        KBDI_VKEY_TO_UNICODE_INFO *pInfo
        )
{
        pInfo -> cbToUnicodeState = sizeof(TO_UNICODE_STATE);
        pInfo -> cMaxToUnicodeCharacters = MAX_TO_UNICODE_CHARACTERS;
        return;
}



static
BOOL
AltNumOkToStart(
        KEY_STATE_FLAGS ShiftFlags
        )
{
        if ( ShiftFlags & ( KeyShiftAnyCtrlFlag         |
                                                KeyShiftLeftWinFlag             |
                                                KeyShiftRightWinFlag    |
                                                KeyShiftAnyShiftFlag ) )
                return FALSE;
        return TRUE;
}





static
BOOL
AltNumKeyEvent(
        UINT32                          VirtualKey,
        KEY_STATE_FLAGS         KeyEvent,
        TO_UNICODE_STATE    *pToUnicodeState,
        KEY_STATE_FLAGS         *pShiftFlags,
        UINT32                          *pCharacterBuffer
        )
{
        KEY_STATE_FLAGS ShiftFlags = *pShiftFlags;
        BOOL                    bGeneratedCharacter = FALSE;
        UINT32                  chGenerated;
        unsigned int    uiBase;
        int                             i;
        UINT32                  vk;



        if ( VirtualKey == VK_MENU )
                {
                if ( KeyEvent & KeyStateDownFlag )
                        {
                        //      Down transition with no other keys?
                        if ( !( KeyEvent & KeyStatePrevDownFlag ) &&
                                  ( AltNumOkToStart(ShiftFlags) ) )
                                {
                                //      Now armed to looked for number keys.
                                pToUnicodeState -> bAltNumAltDownTransition = TRUE;
                                pToUnicodeState -> bAltNumInProgress = FALSE;
                                pToUnicodeState -> bAltNumHex = FALSE;
                                pToUnicodeState -> cAltNumVk = 0;
                                }
                        }
                else    //      Alt key up
                        {
                        pToUnicodeState -> bAltNumAltDownTransition = FALSE;
                        if ( pToUnicodeState -> bAltNumInProgress )
                                {
                                pToUnicodeState -> bAltNumInProgress = FALSE;
                                if ( pToUnicodeState -> cAltNumVk > 1 )
                                        {
                                        chGenerated = 0;
                                        if ( pToUnicodeState -> bAltNumHex )
                                                {
                                                uiBase = 16;
                                                }
                                        else
                                                {
                                                uiBase = 10;
                                                }

                                        for ( i = 0;
                                                        i < pToUnicodeState -> cAltNumVk;
                                                                i++ )
                                                {
                                                vk = pToUnicodeState -> vkAltNum[i];
                                                if ( ( vk >= VK_NUMPAD0 ) && ( vk <= VK_NUMPAD9 ) )
                                                        {
                                                        vk -= VK_NUMPAD0;
                                                        }
                                                else if ( pToUnicodeState -> bAltNumHex &&
                                                                  ( ( vk >= VK_A ) && ( vk <= VK_F ) ) )
                                                        {
                                                        vk -= VK_A;
                                                        vk += 10;
                                                        }
                                                else
                                                        {
                                                        break;  //      bad character
                                                        }
                                                chGenerated *= uiBase;
                                                chGenerated += vk;
                                                }
                                        bGeneratedCharacter = TRUE;
                                        *pCharacterBuffer = chGenerated;
                                        }
                                else
                                        {
                                        //      Alt+N app startup here.
                                        }
                                }
                        }
                }
        else if ( ( pToUnicodeState -> bAltNumAltDownTransition ) &&
                          ( KeyEvent & KeyStateDownFlag ) )
                {
                if ( ( VirtualKey >= VK_NUMPAD0 ) && ( VirtualKey <= VK_NUMPAD9 ) )
                        {
                        //      We were armed to look for number keys and we found one, so now we
                        //      are actually in progress.
                        pToUnicodeState -> bAltNumInProgress = TRUE;
                        if ( pToUnicodeState -> cAltNumVk < C_ALT_NUM_VK )
                                {
                                pToUnicodeState -> vkAltNum[pToUnicodeState -> cAltNumVk++] = VirtualKey;
                                }
                        }
                else if ( ( pToUnicodeState -> bAltNumHex ) &&
                                  ( ( VirtualKey >= VK_A ) && ( VirtualKey <= VK_F ) ) )
                        {
                        //      Hex characters are split out separately for convenience in case the design changes.
                        pToUnicodeState -> bAltNumInProgress = TRUE;
                        if ( pToUnicodeState -> cAltNumVk < C_ALT_NUM_VK )
                                {
                                pToUnicodeState -> vkAltNum[pToUnicodeState -> cAltNumVk++] = VirtualKey;
                                }
                        }
                else if ( ( pToUnicodeState -> bAltNumInProgress ) &&
                                  ( VirtualKey == VK_X ) )
                        {
                        pToUnicodeState -> bAltNumHex = TRUE;
                        }
                else if ( pToUnicodeState -> bAltNumInProgress )
                        {
                        //      If we are in progress, ignore unknown keys.
                        }
                else
                        {
                        //      If we see a key we can't handle when not in progress, disarm
                        pToUnicodeState -> bAltNumAltDownTransition = FALSE;
                        }
                }


        if ( pToUnicodeState -> bAltNumInProgress )
                {
                ShiftFlags |= KeyShiftUseVKNullFlag | KeyShiftNoCharacterFlag;
                }

        *pShiftFlags = ShiftFlags;
        return pToUnicodeState -> bAltNumInProgress || bGeneratedCharacter;

}




static
UINT32
MapCommonVKeyToLVKey(
        UINT32  vkey
        )
{
        if ( vkey == VK_SHIFT )
                vkey = VK_LSHIFT;
        else if ( vkey == VK_CONTROL )
                vkey = VK_LCONTROL;
        else if ( vkey == VK_MENU )
                vkey = VK_LMENU;
        return vkey;
}





/*++

MapLRVKeyToCommonVKey:

Map left and right virtual keys to their common vkey.

Return Value:

The common vkey.

--*/
static
UINT32
MapLRVKeyToCommonVKey(
        UINT32  vkey
        )
{
        if ( ( vkey == VK_LCONTROL ) ||
                 ( vkey == VK_RCONTROL ) )
                return VK_CONTROL;

        if ( ( vkey == VK_LMENU ) ||
                 ( vkey == VK_RMENU ) )
                return VK_MENU;

        if ( ( vkey == VK_LSHIFT ) ||
                 ( vkey == VK_RSHIFT ) )
                return VK_SHIFT;

//      VK_LWIN and VK_RWIN do not have a merged key.

        return vkey;
}




/*++

NewKeyStateFlags:

Figure out the new key state flags based on the current state and the
event.

Return Value:

The new flag settings.

--*/
static
UINT32
NewKeyStateFlags(
        KEY_STATE_FLAGS CurrentState,
        KEY_STATE_FLAGS KeyEventFlags
        )
{
//      Just interested in down/up flag.
        KeyEventFlags &= KeyStateDownFlag;

//      First update the key state for the specific key.
//      Remember the previous state.
        if ( KeyStateIsDown(CurrentState) )
                CurrentState |= KeyStatePrevDownFlag;
        else
                CurrentState &= ~KeyStatePrevDownFlag;

//      Set the new state.
        if ( KeyEventFlags )
                CurrentState |= KeyStateDownFlag | KeyStateGetAsyncDownFlag;
        else
                CurrentState &= ~KeyStateDownFlag;

//      Toggle flag only changes on down transition, not auto repeat.
        if ( KeyStateIsDownTransition(CurrentState) )
                CurrentState ^= KeyStateToggledFlag;

        return CurrentState;
}




/*++

KeybdDriverKeyStateToShiftFlags:

Collapse the shift state from a given key state array into a single
element.

Notes:

For the given virtual key, the current flags from the key state array are
put into the low bits of the output flags.


--*/
static
void
KeybdDriverKeyStateToShiftFlags(
        KEY_STATE       KeyState,           // Key state array.
        UINT32          VKey,               // Virtual key.
        KEY_STATE_FLAGS *pShiftStateFlags   // Location to put collapsed shift state.
        )
{
        KEY_STATE_FLAGS ShiftFlags = 0;

//  Add the standard keys.
        if ( KeyStateIsDown(KeyState[VK_CONTROL]) )
                {
                ShiftFlags |= KeyShiftAnyCtrlFlag;
                }

        if ( KeyStateIsDown(KeyState[VK_LCONTROL]) )
                {
                ShiftFlags |= KeyShiftLeftCtrlFlag;
                }

        if ( KeyStateIsDown(KeyState[VK_RCONTROL]) )
                {
                ShiftFlags |= KeyShiftRightCtrlFlag;
                }


        if ( KeyStateIsDown(KeyState[VK_SHIFT]) )
                {
                ShiftFlags |= KeyShiftAnyShiftFlag;
                }

        if ( KeyStateIsDown(KeyState[VK_LSHIFT]) )
                {
                ShiftFlags |= KeyShiftLeftShiftFlag;
                }

        if ( KeyStateIsDown(KeyState[VK_RSHIFT]) )
                {
                ShiftFlags |= KeyShiftRightShiftFlag;