uglpckbd.c

嵌入式开发工具

        if (readCnt == 1)
            {
            /* data was read, so process */
            scanCode = atScanCode;
            if ((scanCode & UGL_PCKBD_EXTENDED_KEY) == UGL_PCKBD_EXTENDED_KEY)
                pKbdData->extendedKey = (scanCode & ~UGL_PCKBD_EXTENDED_KEY) + 1;
            else
                {
                newLedValue = pKbdData->ledValue;
                modifiers = pService->inputModifiers;

                /* Key Up? */
                if (scanCode & UGL_PCKBD_MAKE_FLAG)
                    {
                    keyDown = UGL_FALSE;
                    modifiers &= ~UGL_KEYBOARD_KEYDOWN;
                    scanCode &= ~UGL_PCKBD_MAKE_FLAG;
                    }
                else
                    {
                    keyDown = UGL_TRUE;
                    modifiers |= UGL_KEYBOARD_KEYDOWN;
                    }

                /* processing extended key sequence ? */
                if (pKbdData->extendedKey > 0)
                    {
                    scanCode |= UGL_PCKBD_EXT_FLAG;
                    if (--pKbdData->extendedKey)
                        return (UGL_STATUS_DROP);

                    }

                /* Update modifier states. */
                switch (scanCode)
                    {
                    case UGL_PCKBD_LEFT_ALT:
                        if (keyDown) 
                            modifiers |= UGL_KEYBOARD_LEFT_ALT;
                        else
                            modifiers &= ~UGL_KEYBOARD_LEFT_ALT;
                        scanCode |= UGL_PCKBD_MOD_KEY;
                        break;

                    case UGL_PCKBD_RIGHT_ALT:
                        if (keyDown) 
                            modifiers |= UGL_KEYBOARD_RIGHT_ALT;
                        else
                            modifiers &= ~UGL_KEYBOARD_RIGHT_ALT;
                        scanCode |= UGL_PCKBD_MOD_KEY;
                        break;

                    case UGL_PCKBD_LEFT_CTRL:
                        if (keyDown) 
                            modifiers |= UGL_KEYBOARD_LEFT_CTRL;
                        else
                            modifiers &= ~UGL_KEYBOARD_LEFT_CTRL;
                        scanCode |= UGL_PCKBD_MOD_KEY;
                        break;

                    case UGL_PCKBD_RIGHT_CTRL:
                        if (keyDown) 
                            modifiers |= UGL_KEYBOARD_RIGHT_CTRL;
                        else
                            modifiers &= ~UGL_KEYBOARD_RIGHT_CTRL;
                        scanCode |= UGL_PCKBD_MOD_KEY;
                        break;

                    case UGL_PCKBD_LEFT_SHIFT:
                        if (keyDown) 
                            modifiers |= UGL_KEYBOARD_LEFT_SHIFT;
                        else
                            modifiers &= ~UGL_KEYBOARD_LEFT_SHIFT;
                        scanCode |= UGL_PCKBD_MOD_KEY;
                        break;

                    case UGL_PCKBD_RIGHT_SHIFT:
                        if (keyDown) 
                            modifiers |= UGL_KEYBOARD_RIGHT_SHIFT;
                        else
                            modifiers &= ~UGL_KEYBOARD_RIGHT_SHIFT;
                        scanCode |= UGL_PCKBD_MOD_KEY;
                        break;

                    case UGL_PCKBD_CAPS_LOCK:
                        if (keyDown)
                            {
                            if (modifiers & UGL_KEYBOARD_CAPS_LOCK) 
                                {
                                modifiers &= ~UGL_KEYBOARD_CAPS_LOCK;
                                newLedValue &= ~UGL_KEYBOARD_LED_CAPS_LOCK;
                                }
                            else
                                {
                                modifiers |= UGL_KEYBOARD_CAPS_LOCK;
                                newLedValue |= UGL_KEYBOARD_LED_CAPS_LOCK;
                                }
                            scanCode |= UGL_PCKBD_MOD_KEY;
                            }
                        break;

                    case UGL_PCKBD_NUM_LOCK:
                        if (keyDown)
                            {
                            if (modifiers & UGL_KEYBOARD_NUM_LOCK) 
                                {
                                modifiers &= ~UGL_KEYBOARD_NUM_LOCK;
                                newLedValue &= ~UGL_KEYBOARD_LED_NUM_LOCK;
                                }
                            else
                                {
                                modifiers |= UGL_KEYBOARD_NUM_LOCK;
                                newLedValue |= UGL_KEYBOARD_LED_NUM_LOCK;
                                }
                            scanCode |= UGL_PCKBD_MOD_KEY;
                            }
                        break;

                    case UGL_PCKBD_SCROLL_LOCK:
                        if (keyDown)
                            {
                            if (modifiers & UGL_KEYBOARD_SCROLL_LOCK) 
                                {
                                modifiers &= ~UGL_KEYBOARD_SCROLL_LOCK;
                                newLedValue &= ~UGL_KEYBOARD_LED_SCROLL_LOCK;
                                }
                            else
                                {
                                modifiers |= UGL_KEYBOARD_SCROLL_LOCK;
                                newLedValue |= UGL_KEYBOARD_LED_SCROLL_LOCK;
                                }
                            scanCode |= UGL_PCKBD_MOD_KEY;
                            }
                        break;
                    }

                /* Update the keyboard leds */
                if ((pKbdData->ledValue != newLedValue) && 
                                    (pKbdData->ledControl))
                    ioctl (pDevice->fd, CONIOLEDS, newLedValue);
                pKbdData->ledValue = newLedValue;

                /* build input event */
                pInputEvent->header.type = UGL_EVENT_TYPE_KEYBOARD;
                pInputEvent->header.category = UGL_EVENT_CATEGORY_INPUT;
                pInputEvent->modifiers = modifiers;
                pInputEvent->type.keyboard.scanCode = scanCode;

                /* convert scan code to unicode */
                pInputEvent->type.keyboard.key = MapKeyValue (scanCode, modifiers);

                if (pInputEvent->type.keyboard.key == 0)
                    status = UGL_STATUS_DROP;
                else
                    status = UGL_STATUS_OK;

                return (status);
                }
            }
        }

    return (status);
    }

/******************************************************************************
*
* MapKeyValue - map a scan code to Unicode value
*
* This routien maps a scan code to a unicode value.  The <keyValue> which
* is a PC AT scan code is mapped to the corresonding unicode value, adjusted
* by the current state of the key modifiers (shift, num lock, etc.) which
* is present in <modifiers>.
*
* RETURNS:  mapped unicode value when mapping available, otherwise zero
*
* ERRNO: N/A
*
* SEE ALSO: 
*/

UGL_LOCAL UGL_UINT16 MapKeyValue
    (
    UGL_UINT16   keyValue,       /* scan code */
    UGL_UINT32  modifiers       /* modifier state */ 
    )
    {
    int unshiftedKeyValue;
    int shiftedKeyValue;
    UGL_BOOL numLock = modifiers & UGL_KEYBOARD_NUM_LOCK;
    UGL_BOOL capsLock = modifiers & UGL_KEYBOARD_CAPS_LOCK;
    UGL_BOOL shift = modifiers & UGL_KEYBOARD_SHIFT;
    UGL_BOOL ctrl = modifiers & UGL_KEYBOARD_CTRL;
    UGL_BOOL modChg = keyValue & UGL_PCKBD_MOD_KEY;

/* Select the keyboard mapping */
#ifdef  INCLUDE_KMAP_ENGLISH_US
    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdUsKeyMapTable;
    size_t sizeOfKmap = sizeOfUsKmap;
#endif /* INCLUDE_KMAP_ENGLISH_US */
#ifdef  INCLUDE_KMAP_ENGLISH_UK
    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdUkKeyMapTable;
    size_t sizeOfKmap = sizeOfUkKmap;
#endif /* INCLUDE_KMAP_ENGLISH_UK */
#ifdef  INCLUDE_KMAP_GERMAN
    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdDeKeyMapTable;
    size_t sizeOfKmap = sizeOfDeKmap;
#endif /* INCLUDE_KMAP_GERMAN */
#ifdef  INCLUDE_KMAP_ITALIAN
    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdItKeyMapTable;
    size_t sizeOfKmap = sizeOfItKmap;
#endif /* INCLUDE_KMAP_ITALIAN */
#ifdef  INCLUDE_KMAP_FRENCH
    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdFrKeyMapTable;
    size_t sizeOfKmap = sizeOfFrKmap;
#endif /* INCLUDE_KMAP_FRENCH */
#ifdef  INCLUDE_KMAP_SWEDISH
    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdSwKeyMapTable;
    size_t sizeOfKmap = sizeOfSwKmap;
#endif /* INCLUDE_KMAP_SWEDISH */
#ifdef  INCLUDE_KMAP_NONE
    PC_KBD_KEYMAP * pKbdKeyMapTable = pcKbdNoKeyMapTable;
    size_t sizeOfKmap = sizeOfNoKmap;
#endif /* INCLUDE_KMAP_NONE */


    keyValue &= ~UGL_PCKBD_MOD_KEY;

    if (keyValue & UGL_PCKBD_EXT_FLAG)
        {
        /* turn off extended flag */
        keyValue &= ~UGL_PCKBD_EXT_FLAG;

        /* Don't process the extra 0x2a/0xaa on some extended keys */
        if (keyValue == 0x2a)
            return 0;

        if (keyValue < sizeOfKmap /
               sizeof(struct pckbdKeyMapStruct))
            return ( pKbdKeyMapTable[keyValue].extendedKeyValue);
        else
            return 0;
        }
    else if (keyValue < sizeOfKmap /
             sizeof(struct pckbdKeyMapStruct))
        {
        unshiftedKeyValue = pKbdKeyMapTable[keyValue].unshiftedKeyValue;
        shiftedKeyValue = pKbdKeyMapTable[keyValue].shiftedKeyValue;

        if (modChg) 
            return (unshiftedKeyValue);
        else if (ctrl)
            return (unshiftedKeyValue);
        else if (numLock && shiftedKeyValue >= '0' && shiftedKeyValue <= '9')
            return (shift ? unshiftedKeyValue : shiftedKeyValue);
        else if (capsLock)
            {
            keyValue = (shift ? shiftedKeyValue : unshiftedKeyValue);
            if (shift)
                return (tolower(keyValue));
            else
                return (toupper(keyValue));
            }
        else
            return (shift ? shiftedKeyValue : unshiftedKeyValue);
        }
    else
        return 0;
    }