src/c_tk_base_7_5_w_mods/tkwinkey.c

/* $Header$ */

/*
 * tkWinKey.c --
 *
 *      This file contains X emulation routines for keyboard related
 *      functions.
 *
 * Copyright (c) 1995 Sun Microsystems, Inc.
 *
 * See the file "license.terms" for information on usage and redistribution
 * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
 *
 * RCS: @(#) $Id: tkwinkey.c,v 1.1.1.1 2001/06/13 05:13:42 dtashley Exp $
 */

#include "tkWinInt.h"
/*
 * The keymap table holds mappings of Windows keycodes to X keysyms.
 * If Windows ever comes along and changes the value of their keycodes,
 * this will break all kinds of things.  However, this table lookup is much
 * faster than the alternative, in which we walked a list of keycodes looking
 * for a match.  Since this lookup is performed for every Windows keypress
 * event, it seems like a worthwhile improvement to use the table.
 */
#define MAX_KEYCODE 145 /* VK_SCROLL is the last entry in our table below */
static KeySym keymap[] = {
    NoSymbol, NoSymbol, NoSymbol, XK_Cancel, NoSymbol,
        NoSymbol, NoSymbol, NoSymbol, XK_BackSpace, XK_Tab,
        NoSymbol, NoSymbol, XK_Clear, XK_Return, NoSymbol,
        NoSymbol, XK_Shift_L, XK_Control_L, XK_Alt_L, XK_Pause,
        XK_Caps_Lock, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, XK_Escape, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, XK_space, XK_Prior, XK_Next,
        XK_End, XK_Home, XK_Left, XK_Up, XK_Right,
        XK_Down, XK_Select, XK_Print, XK_Execute, NoSymbol,
        XK_Insert, XK_Delete, XK_Help, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
        NoSymbol, XK_Win_L, XK_Win_R, XK_App, NoSymbol,
        NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, XK_F1, XK_F2, XK_F3,
        XK_F4, XK_F5, XK_F6, XK_F7, XK_F8,
        XK_F9, XK_F10, XK_F11, XK_F12, XK_F13,
        XK_F14, XK_F15, XK_F16, XK_F17, XK_F18,
        XK_F19, XK_F20, XK_F21, XK_F22, XK_F23,
        XK_F24, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
        NoSymbol, NoSymbol, NoSymbol, NoSymbol, XK_Num_Lock,
        XK_Scroll_Lock
};

/*
 * Prototypes for local procedures defined in this file:
 */

static KeySym           KeycodeToKeysym _ANSI_ARGS_((unsigned int keycode,
                            int state, int noascii));

/*
 *----------------------------------------------------------------------
 *
 * TkpGetString --
 *
 *      Retrieve the UTF string equivalent for the given keyboard event.
 *
 * Results:
 *      Returns the UTF string.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

char *
TkpGetString(winPtr, eventPtr, dsPtr)
    TkWindow *winPtr;           /* Window where event occurred:  needed to
                                 * get input context. */
    XEvent *eventPtr;           /* X keyboard event. */
    Tcl_DString *dsPtr;         /* Uninitialized or empty string to hold
                                 * result. */
{
    KeySym keysym;
    XKeyEvent* keyEv = &eventPtr->xkey;

    Tcl_DStringInit(dsPtr);
    if (eventPtr->xkey.send_event != -1) {
        /*
         * This is an event generated from generic code.  It has no
         * nchars or trans_chars members. 
         */

        keysym = KeycodeToKeysym(eventPtr->xkey.keycode,
                eventPtr->xkey.state, 0);
        if (((keysym != NoSymbol) && (keysym > 0) && (keysym < 256)) 
                || (keysym == XK_Return)
                || (keysym == XK_Tab)) {
            char buf[TCL_UTF_MAX];
            int len = Tcl_UniCharToUtf((Tcl_UniChar) (keysym & 255), buf);
            Tcl_DStringAppend(dsPtr, buf, len);
        }
    } else if (eventPtr->xkey.nbytes > 0) {
        Tcl_ExternalToUtfDString(NULL, eventPtr->xkey.trans_chars,
                eventPtr->xkey.nbytes, dsPtr);
    }
    return Tcl_DStringValue(dsPtr);
}

/*
 *----------------------------------------------------------------------
 *
 * XKeycodeToKeysym --
 *
 *      Translate from a system-dependent keycode to a
 *      system-independent keysym.
 *
 * Results:
 *      Returns the translated keysym, or NoSymbol on failure.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

KeySym
XKeycodeToKeysym(display, keycode, index)
    Display* display;
    unsigned int keycode;
    int index;
{
    int state = 0;

    if (index & 0x01) {
        state |= ShiftMask;
    }
    return KeycodeToKeysym(keycode, state, 0);
}


/*
 *----------------------------------------------------------------------
 *
 * KeycodeToKeysym --
 *
 *      Translate from a system-dependent keycode to a
 *      system-independent keysym.
 *
 * Results:
 *      Returns the translated keysym, or NoSymbol on failure.
 *
 * Side effects:
 *      It may affect the internal state of the keyboard, such as
 *      remembered dead key or lock indicator lamps.
 *
 *----------------------------------------------------------------------
 */

static KeySym
KeycodeToKeysym(keycode, state, noascii)
    unsigned int keycode;
    int state;
    int noascii;
{
    BYTE keys[256];
    int result, deadkey, shift;
    char buf[4];
    unsigned int scancode = MapVirtualKey(keycode, 0);

    /*
     * Do not run keycodes of lock keys through ToAscii().
     * One of ToAscii()'s side effects is to handle the lights
     * on the keyboard, and we don't want to mess that up.
     */

    if (noascii || keycode == VK_CAPITAL || keycode == VK_SCROLL ||
            keycode == VK_NUMLOCK)
        goto skipToAscii;

    /*
     * Use MapVirtualKey() to detect some dead keys.
     */

    if (MapVirtualKey(keycode, 2) > 0x7fffUL)
        return XK_Multi_key;

    /*
     * Set up a keyboard with correct modifiers
     */

    memset(keys, 0, 256);
    if (state & ShiftMask)
        keys[VK_SHIFT] = 0x80;
    if (state & ControlMask)
        keys[VK_CONTROL] = 0x80;
    if (state & Mod2Mask)
        keys[VK_MENU] = 0x80;

    /* 
     * Make sure all lock button info is correct so we don't mess up the
     * lights
     */

    if (state & LockMask)
        keys[VK_CAPITAL] = 1;
    if (state & Mod3Mask)
        keys[VK_SCROLL] = 1;
    if (state & Mod1Mask)
        keys[VK_NUMLOCK] = 1;

    result = ToAscii(keycode, scancode, keys, (LPWORD) buf, 0);

    if (result < 0) {
        /*
         * Win95/98:
         * This was a dead char, which is now remembered by the keyboard.
         * Call ToAscii() again to forget it.
         * WinNT:
         * This was a dead char, overwriting any previously remembered
         * key. Calling ToAscii() again does not affect anything.
         */

        ToAscii(keycode, scancode, keys, (LPWORD) buf, 0);
        return XK_Multi_key;
    }
    if (result == 2) {
        /*
         * This was a dead char, and there were one previously remembered
         * by the keyboard.
         * Call ToAscii() again with proper parameters to restore it.
         */

        /* 
         * Get information about the old char
         */

        deadkey = VkKeyScan(buf[0]);
        shift = deadkey >> 8;
        deadkey &= 255;
        scancode = MapVirtualKey(deadkey, 0);

        /*
         * Set up a keyboard with proper modifier keys
         */

        memset(keys, 0, 256);
        if (shift & 1)
            keys[VK_SHIFT] = 0x80;
        if (shift & 2)
            keys[VK_CONTROL] = 0x80;
        if (shift & 4)
            keys[VK_MENU] = 0x80;
        ToAscii(deadkey, scancode, keys, (LPWORD) buf, 0);
        return XK_Multi_key;
    }

    /*
     * Keycode mapped to a valid Latin-1 character.  Since the keysyms
     * for alphanumeric characters map onto Latin-1, we just return it.
     *
     * We treat 0x7F as a special case mostly for backwards compatibility.
     * In versions of Tk<=8.2, Control-Backspace returned "XK_BackSpace"
     * as the X Keysym.  This was due to the fact that we did not
     * initialize the keys array properly when we passed it to ToAscii, above.
     * We had previously not been setting the state bit for the Control key.
     * When we fixed that, we found that Control-Backspace on Windows is
     * interpreted as ASCII-127 (0x7F), which corresponds to the Delete key.
     *
     * Upon discovering this, we realized we had two choices:  return XK_Delete
     * or return XK_BackSpace.  If we returned XK_Delete, that could be
     * considered "more correct" (although the correctness would be dependant
     * on whether you believe that ToAscii is doing the right thing in that
     * case); however, this would break backwards compatibility, and worse,
     * it would limit application programmers -- they would effectively be
     * unable to bind to <Control-Backspace> on Windows.  We therefore chose
     * instead to return XK_BackSpace (handled here by letting the code
     * "fall-through" to the return statement below, which works because the
     * keycode for this event is VK_BACKSPACE, and the keymap table maps that
     * keycode to XK_BackSpace).
     */

    if (result == 1 && UCHAR(buf[0]) >= 0x20 && UCHAR(buf[0]) != 0x7F) {
        return (KeySym) UCHAR(buf[0]);
    }

    /*
     * Keycode is a non-alphanumeric key, so we have to do the lookup.
     */

    skipToAscii:
    if (keycode < 0 || keycode > MAX_KEYCODE) {
        return NoSymbol;
    }
    switch (keycode) {
        /*
         * Windows only gives us an undifferentiated VK_CONTROL
         * code (for example) when either Control key is pressed.
         * To distinguish between left and right, we have to query the
         * state of one of the two to determine which was actually
         * pressed.  So if the keycode indicates Control, Shift, or Menu
         * (the key that everybody else calls Alt), do this extra test.
         * If the right-side key was pressed, return the appropriate
         * keycode.  Otherwise, we fall through and rely on the
         * keymap table to hold the correct keysym value.
         */
        case VK_CONTROL: {
            if (GetKeyState(VK_RCONTROL) & 0x80) {
                return XK_Control_R;
            }
            break;
        }
        case VK_SHIFT: {
            if (GetKeyState(VK_RSHIFT) & 0x80) {
                return XK_Shift_R;
            }
            break;
        }
        case VK_MENU: {
            if (GetKeyState(VK_RMENU) & 0x80) {
                return XK_Alt_R;
            }
            break;
        }
    }
    return keymap[keycode];
}


/*
 *----------------------------------------------------------------------
 *
 * TkpGetKeySym --
 *
 *      Given an X KeyPress or KeyRelease event, map the
 *      keycode in the event into a KeySym.
 *
 * Results:
 *      The return value is the KeySym corresponding to
 *      eventPtr, or NoSymbol if no matching Keysym could be
 *      found.
 *
 * Side effects:
 *      In the first call for a given display, keycode-to-
 *      KeySym maps get loaded.
 *
 *----------------------------------------------------------------------
 */

KeySym
TkpGetKeySym(dispPtr, eventPtr)
    TkDisplay *dispPtr;         /* Display in which to map keycode. */
    XEvent *eventPtr;           /* Description of X event. */
{
    KeySym sym;
    int state = eventPtr->xkey.state;

    /*
     * Refresh the mapping information if it's stale
     */

    if (dispPtr->bindInfoStale) {
        TkpInitKeymapInfo(dispPtr);
    }

    sym = KeycodeToKeysym(eventPtr->xkey.keycode, state, 0);

    /*
     * Special handling: if this is a ctrl-alt or shifted key, and there
     * is no keysym defined, try without the modifiers.
     */

    if ((sym == NoSymbol) && ((state & ControlMask) || (state & Mod2Mask))) {
        state &=  ~(ControlMask | Mod2Mask);
        sym = KeycodeToKeysym(eventPtr->xkey.keycode, state, 0);
    }
    if ((sym == NoSymbol) && (state & ShiftMask)) {
        state &=  ~ShiftMask;
        sym = KeycodeToKeysym(eventPtr->xkey.keycode, state, 0);
    }
    return sym;
}

/*
 *--------------------------------------------------------------
 *
 * TkpInitKeymapInfo --
 *
 *      This procedure is invoked to scan keymap information
 *      to recompute stuff that's important for binding, such
 *      as the modifier key (if any) that corresponds to "mode
 *      switch".
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Keymap-related information in dispPtr is updated.
 *
 *--------------------------------------------------------------
 */

void
TkpInitKeymapInfo(dispPtr)
    TkDisplay *dispPtr;         /* Display for which to recompute keymap
                                 * information. */
{
    XModifierKeymap *modMapPtr;
    KeyCode *codePtr;
    KeySym keysym;
    int count, i, j, max, arraySize;
#define KEYCODE_ARRAY_SIZE 20

    dispPtr->bindInfoStale = 0;
    modMapPtr = XGetModifierMapping(dispPtr->display);

    /*
     * Check the keycodes associated with the Lock modifier.  If
     * any of them is associated with the XK_Shift_Lock modifier,
     * then Lock has to be interpreted as Shift Lock, not Caps Lock.
     */

    dispPtr->lockUsage = LU_IGNORE;
    codePtr = modMapPtr->modifiermap + modMapPtr->max_keypermod*LockMapIndex;
    for (count = modMapPtr->max_keypermod; count > 0; count--, codePtr++) {
        if (*codePtr == 0) {
            continue;
        }
        keysym = KeycodeToKeysym(*codePtr, 0, 1);
        if (keysym == XK_Shift_Lock) {
            dispPtr->lockUsage = LU_SHIFT;
            break;
        }
        if (keysym == XK_Caps_Lock) {
            dispPtr->lockUsage = LU_CAPS;
            break;
        }
    }

    /*
     * Look through the keycodes associated with modifiers to see if
     * the the "mode switch", "meta", or "alt" keysyms are associated
     * with any modifiers.  If so, remember their modifier mask bits.
     */

    dispPtr->modeModMask = 0;
    dispPtr->metaModMask = 0;
    dispPtr->altModMask = 0;
    codePtr = modMapPtr->modifiermap;
    max = 8*modMapPtr->max_keypermod;
    for (i = 0; i < max; i++, codePtr++) {
        if (*codePtr == 0) {
            continue;
        }
        keysym = KeycodeToKeysym(*codePtr, 0, 1);
        if (keysym == XK_Mode_switch) {
            dispPtr->modeModMask |= ShiftMask << (i/modMapPtr->max_keypermod);
        }
        if ((keysym == XK_Meta_L) || (keysym == XK_Meta_R)) {
            dispPtr->metaModMask |= ShiftMask << (i/modMapPtr->max_keypermod);
        }
        if ((keysym == XK_Alt_L) || (keysym == XK_Alt_R)) {
            dispPtr->altModMask |= ShiftMask << (i/modMapPtr->max_keypermod);
        }
    }

    /*
     * Create an array of the keycodes for all modifier keys.
     */

    if (dispPtr->modKeyCodes != NULL) {
        ckfree((char *) dispPtr->modKeyCodes);
    }
    dispPtr->numModKeyCodes = 0;
    arraySize = KEYCODE_ARRAY_SIZE;
    dispPtr->modKeyCodes = (KeyCode *) ckalloc((unsigned)
            (KEYCODE_ARRAY_SIZE * sizeof(KeyCode)));
    for (i = 0, codePtr = modMapPtr->modifiermap; i < max; i++, codePtr++) {
        if (*codePtr == 0) {
            continue;
        }

        /*
         * Make sure that the keycode isn't already in the array.
         */

        for (j = 0; j < dispPtr->numModKeyCodes; j++) {
            if (dispPtr->modKeyCodes[j] == *codePtr) {
                goto nextModCode;
            }
        }
        if (dispPtr->numModKeyCodes >= arraySize) {
            KeyCode *new;

            /*
             * Ran out of space in the array;  grow it.
             */

            arraySize *= 2;
            new = (KeyCode *) ckalloc((unsigned)
                    (arraySize * sizeof(KeyCode)));
            memcpy((VOID *) new, (VOID *) dispPtr->modKeyCodes,
                    (dispPtr->numModKeyCodes * sizeof(KeyCode)));
            ckfree((char *) dispPtr->modKeyCodes);
            dispPtr->modKeyCodes = new;
        }
        dispPtr->modKeyCodes[dispPtr->numModKeyCodes] = *codePtr;
        dispPtr->numModKeyCodes++;
        nextModCode: continue;
    }
    XFreeModifiermap(modMapPtr);
}

/*
 * When mapping from a keysym to a keycode, need
 * information about the modifier state that should be used
 * so that when they call XKeycodeToKeysym taking into
 * account the xkey.state, they will get back the original
 * keysym.
 */

void
TkpSetKeycodeAndState(tkwin, keySym, eventPtr)
    Tk_Window tkwin;
    KeySym keySym;
    XEvent *eventPtr;
{
    int i;
    SHORT result;
    int shift;
    
    eventPtr->xkey.keycode = 0;
    if (keySym == NoSymbol) {
        return;
    }

    /*
     * We check our private map first for a virtual keycode,
     * as VkKeyScan will return values that don't map to X
     * for the "extended" Syms.  This may be due to just casting
     * problems below, but this works.
     */
    for (i = 0; i <= MAX_KEYCODE; i++) {
        if (keymap[i] == keySym) {
            eventPtr->xkey.keycode = i;
            return;
        }
    }
    if (keySym >= 0x20) {
        result = VkKeyScan((char) keySym);
        if (result != -1) {
            shift = result >> 8;
            if (shift & 1)
                eventPtr->xkey.state |= ShiftMask;
            if (shift & 2)
                eventPtr->xkey.state |= ControlMask;
            if (shift & 4)
                eventPtr->xkey.state |= Mod2Mask;
            eventPtr->xkey.keycode = (KeyCode) (result & 0xff);
        }
    }
    {
        /* Debug log */
        FILE *fp = fopen("c:\\temp\\tklog.txt", "a");
        if (fp != NULL) {
            fprintf(fp, "TkpSetKeycode. Keycode %d State %d Keysym %d\n", eventPtr->xkey.keycode, eventPtr->xkey.state, keySym);
            fclose(fp);
        }
    }
}

/*
 *----------------------------------------------------------------------
 *
 * XKeysymToKeycode --
 *
 *      Translate a keysym back into a keycode.
 *
 * Results:
 *      Returns the keycode that would generate the specified keysym.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

KeyCode
XKeysymToKeycode(display, keysym)
    Display* display;
    KeySym keysym;
{
    int i;
    SHORT result;

    /*
     * We check our private map first for a virtual keycode,
     * as VkKeyScan will return values that don't map to X
     * for the "extended" Syms.  This may be due to just casting
     * problems below, but this works.
     */
    if (keysym == NoSymbol) {
        return 0;
    }
    for (i = 0; i <= MAX_KEYCODE; i++) {
        if (keymap[i] == keysym) {
            return ((KeyCode) i);
        }
    }
    if (keysym >= 0x20) {
        result = VkKeyScan((char) keysym);
        if (result != -1) {
            return (KeyCode) (result & 0xff);
        }
    }

    return 0;
}

/*
 *----------------------------------------------------------------------
 *
 * XGetModifierMapping --
 *
 *      Fetch the current keycodes used as modifiers.
 *
 * Results:
 *      Returns a new modifier map.
 *
 * Side effects:
 *      Allocates a new modifier map data structure.
 *
 *----------------------------------------------------------------------
 */

XModifierKeymap *
XGetModifierMapping(display)
    Display* display;
{
    XModifierKeymap *map = (XModifierKeymap *)ckalloc(sizeof(XModifierKeymap));

    map->max_keypermod = 1;
    map->modifiermap = (KeyCode *) ckalloc(sizeof(KeyCode)*8);
    map->modifiermap[ShiftMapIndex] = VK_SHIFT;
    map->modifiermap[LockMapIndex] = VK_CAPITAL;
    map->modifiermap[ControlMapIndex] = VK_CONTROL;
    map->modifiermap[Mod1MapIndex] = VK_NUMLOCK;
    map->modifiermap[Mod2MapIndex] = VK_MENU;
    map->modifiermap[Mod3MapIndex] = VK_SCROLL;
    map->modifiermap[Mod4MapIndex] = 0;
    map->modifiermap[Mod5MapIndex] = 0;
    return map;
}

/*
 *----------------------------------------------------------------------
 *
 * XFreeModifiermap --
 *
 *      Deallocate a modifier map that was created by
 *      XGetModifierMapping.
 *
 * Results:
 *      None.
 *
 * Side effects:
 *      Frees the datastructure referenced by modmap.
 *
 *----------------------------------------------------------------------
 */

void
XFreeModifiermap(modmap)
    XModifierKeymap* modmap;
{
    ckfree((char *) modmap->modifiermap);
    ckfree((char *) modmap);
}

/*
 *----------------------------------------------------------------------
 *
 * XStringToKeysym --
 *
 *      Translate a keysym name to the matching keysym. 
 *
 * Results:
 *      Returns the keysym.  Since this is already handled by
 *      Tk's StringToKeysym function, we just return NoSymbol.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

KeySym
XStringToKeysym(string)
    _Xconst char *string;
{
    return NoSymbol;
}

/*
 *----------------------------------------------------------------------
 *
 * XKeysymToString --
 *
 *      Convert a keysym to character form.
 *
 * Results:
 *      Returns NULL, since Tk will have handled this already.
 *
 * Side effects:
 *      None.
 *
 *----------------------------------------------------------------------
 */

char *
XKeysymToString(keysym)
    KeySym keysym;
{
    return NULL;
}

/* End of tkwinkey.c */
1	dashley	71	/* $Header$ */
2
3			/*
4			* tkWinKey.c --
5			*
6			* This file contains X emulation routines for keyboard related
7			* functions.
8			*
9			* Copyright (c) 1995 Sun Microsystems, Inc.
10			*
11			* See the file "license.terms" for information on usage and redistribution
12			* of this file, and for a DISCLAIMER OF ALL WARRANTIES.
13			*
14			* RCS: @(#) $Id: tkwinkey.c,v 1.1.1.1 2001/06/13 05:13:42 dtashley Exp $
15			*/
16
17			#include "tkWinInt.h"
18			/*
19			* The keymap table holds mappings of Windows keycodes to X keysyms.
20			* If Windows ever comes along and changes the value of their keycodes,
21			* this will break all kinds of things. However, this table lookup is much
22			* faster than the alternative, in which we walked a list of keycodes looking
23			* for a match. Since this lookup is performed for every Windows keypress
24			* event, it seems like a worthwhile improvement to use the table.
25			*/
26			#define MAX_KEYCODE 145 /* VK_SCROLL is the last entry in our table below */
27			static KeySym keymap[] = {
28			NoSymbol, NoSymbol, NoSymbol, XK_Cancel, NoSymbol,
29			NoSymbol, NoSymbol, NoSymbol, XK_BackSpace, XK_Tab,
30			NoSymbol, NoSymbol, XK_Clear, XK_Return, NoSymbol,
31			NoSymbol, XK_Shift_L, XK_Control_L, XK_Alt_L, XK_Pause,
32			XK_Caps_Lock, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
33			NoSymbol, NoSymbol, XK_Escape, NoSymbol, NoSymbol,
34			NoSymbol, NoSymbol, XK_space, XK_Prior, XK_Next,
35			XK_End, XK_Home, XK_Left, XK_Up, XK_Right,
36			XK_Down, XK_Select, XK_Print, XK_Execute, NoSymbol,
37			XK_Insert, XK_Delete, XK_Help, NoSymbol, NoSymbol,
38			NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
39			NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
40			NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
41			NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
42			NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
43			NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
44			NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
45			NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
46			NoSymbol, XK_Win_L, XK_Win_R, XK_App, NoSymbol,
47			NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
48			NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
49			NoSymbol, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
50			NoSymbol, NoSymbol, XK_F1, XK_F2, XK_F3,
51			XK_F4, XK_F5, XK_F6, XK_F7, XK_F8,
52			XK_F9, XK_F10, XK_F11, XK_F12, XK_F13,
53			XK_F14, XK_F15, XK_F16, XK_F17, XK_F18,
54			XK_F19, XK_F20, XK_F21, XK_F22, XK_F23,
55			XK_F24, NoSymbol, NoSymbol, NoSymbol, NoSymbol,
56			NoSymbol, NoSymbol, NoSymbol, NoSymbol, XK_Num_Lock,
57			XK_Scroll_Lock
58			};
59
60			/*
61			* Prototypes for local procedures defined in this file:
62			*/
63
64			static KeySym KeycodeToKeysym _ANSI_ARGS_((unsigned int keycode,
65			int state, int noascii));
66
67			/*
68			*----------------------------------------------------------------------
69			*
70			* TkpGetString --
71			*
72			* Retrieve the UTF string equivalent for the given keyboard event.
73			*
74			* Results:
75			* Returns the UTF string.
76			*
77			* Side effects:
78			* None.
79			*
80			*----------------------------------------------------------------------
81			*/
82
83			char *
84			TkpGetString(winPtr, eventPtr, dsPtr)
85			TkWindow winPtr; / Window where event occurred: needed to
86			* get input context. */
87			XEvent eventPtr; / X keyboard event. */
88			Tcl_DString dsPtr; / Uninitialized or empty string to hold
89			* result. */
90			{
91			KeySym keysym;
92			XKeyEvent* keyEv = &eventPtr->xkey;
93
94			Tcl_DStringInit(dsPtr);
95			if (eventPtr->xkey.send_event != -1) {
96			/*
97			* This is an event generated from generic code. It has no
98			* nchars or trans_chars members.
99			*/
100
101			keysym = KeycodeToKeysym(eventPtr->xkey.keycode,
102			eventPtr->xkey.state, 0);
103			if (((keysym != NoSymbol) && (keysym > 0) && (keysym < 256))
104			\|\| (keysym == XK_Return)
105			\|\| (keysym == XK_Tab)) {
106			char buf[TCL_UTF_MAX];
107			int len = Tcl_UniCharToUtf((Tcl_UniChar) (keysym & 255), buf);
108			Tcl_DStringAppend(dsPtr, buf, len);
109			}
110			} else if (eventPtr->xkey.nbytes > 0) {
111			Tcl_ExternalToUtfDString(NULL, eventPtr->xkey.trans_chars,
112			eventPtr->xkey.nbytes, dsPtr);
113			}
114			return Tcl_DStringValue(dsPtr);
115			}
116
117			/*
118			*----------------------------------------------------------------------
119			*
120			* XKeycodeToKeysym --
121			*
122			* Translate from a system-dependent keycode to a
123			* system-independent keysym.
124			*
125			* Results:
126			* Returns the translated keysym, or NoSymbol on failure.
127			*
128			* Side effects:
129			* None.
130			*
131			*----------------------------------------------------------------------
132			*/
133
134			KeySym
135			XKeycodeToKeysym(display, keycode, index)
136			Display* display;
137			unsigned int keycode;
138			int index;
139			{
140			int state = 0;
141
142			if (index & 0x01) {
143			state \|= ShiftMask;
144			}
145			return KeycodeToKeysym(keycode, state, 0);
146			}
147
148
149
150			/*
151			*----------------------------------------------------------------------
152			*
153			* KeycodeToKeysym --
154			*
155			* Translate from a system-dependent keycode to a
156			* system-independent keysym.
157			*
158			* Results:
159			* Returns the translated keysym, or NoSymbol on failure.
160			*
161			* Side effects:
162			* It may affect the internal state of the keyboard, such as
163			* remembered dead key or lock indicator lamps.
164			*
165			*----------------------------------------------------------------------
166			*/
167
168			static KeySym
169			KeycodeToKeysym(keycode, state, noascii)
170			unsigned int keycode;
171			int state;
172			int noascii;
173			{
174			BYTE keys[256];
175			int result, deadkey, shift;
176			char buf[4];
177			unsigned int scancode = MapVirtualKey(keycode, 0);
178
179			/*
180			* Do not run keycodes of lock keys through ToAscii().
181			* One of ToAscii()'s side effects is to handle the lights
182			* on the keyboard, and we don't want to mess that up.
183			*/
184
185			if (noascii \|\| keycode == VK_CAPITAL \|\| keycode == VK_SCROLL \|\|
186			keycode == VK_NUMLOCK)
187			goto skipToAscii;
188
189			/*
190			* Use MapVirtualKey() to detect some dead keys.
191			*/
192
193			if (MapVirtualKey(keycode, 2) > 0x7fffUL)
194			return XK_Multi_key;
195
196			/*
197			* Set up a keyboard with correct modifiers
198			*/
199
200			memset(keys, 0, 256);
201			if (state & ShiftMask)
202			keys[VK_SHIFT] = 0x80;
203			if (state & ControlMask)
204			keys[VK_CONTROL] = 0x80;
205			if (state & Mod2Mask)
206			keys[VK_MENU] = 0x80;
207
208			/*
209			* Make sure all lock button info is correct so we don't mess up the
210			* lights
211			*/
212
213			if (state & LockMask)
214			keys[VK_CAPITAL] = 1;
215			if (state & Mod3Mask)
216			keys[VK_SCROLL] = 1;
217			if (state & Mod1Mask)
218			keys[VK_NUMLOCK] = 1;
219
220			result = ToAscii(keycode, scancode, keys, (LPWORD) buf, 0);
221
222			if (result < 0) {
223			/*
224			* Win95/98:
225			* This was a dead char, which is now remembered by the keyboard.
226			* Call ToAscii() again to forget it.
227			* WinNT:
228			* This was a dead char, overwriting any previously remembered
229			* key. Calling ToAscii() again does not affect anything.
230			*/
231
232			ToAscii(keycode, scancode, keys, (LPWORD) buf, 0);
233			return XK_Multi_key;
234			}
235			if (result == 2) {
236			/*
237			* This was a dead char, and there were one previously remembered
238			* by the keyboard.
239			* Call ToAscii() again with proper parameters to restore it.
240			*/
241
242			/*
243			* Get information about the old char
244			*/
245
246			deadkey = VkKeyScan(buf[0]);
247			shift = deadkey >> 8;
248			deadkey &= 255;
249			scancode = MapVirtualKey(deadkey, 0);
250
251			/*
252			* Set up a keyboard with proper modifier keys
253			*/
254
255			memset(keys, 0, 256);
256			if (shift & 1)
257			keys[VK_SHIFT] = 0x80;
258			if (shift & 2)
259			keys[VK_CONTROL] = 0x80;
260			if (shift & 4)
261			keys[VK_MENU] = 0x80;
262			ToAscii(deadkey, scancode, keys, (LPWORD) buf, 0);
263			return XK_Multi_key;
264			}
265
266			/*
267			* Keycode mapped to a valid Latin-1 character. Since the keysyms
268			* for alphanumeric characters map onto Latin-1, we just return it.
269			*
270			* We treat 0x7F as a special case mostly for backwards compatibility.
271			* In versions of Tk<=8.2, Control-Backspace returned "XK_BackSpace"
272			* as the X Keysym. This was due to the fact that we did not
273			* initialize the keys array properly when we passed it to ToAscii, above.
274			* We had previously not been setting the state bit for the Control key.
275			* When we fixed that, we found that Control-Backspace on Windows is
276			* interpreted as ASCII-127 (0x7F), which corresponds to the Delete key.
277			*
278			* Upon discovering this, we realized we had two choices: return XK_Delete
279			* or return XK_BackSpace. If we returned XK_Delete, that could be
280			* considered "more correct" (although the correctness would be dependant
281			* on whether you believe that ToAscii is doing the right thing in that
282			* case); however, this would break backwards compatibility, and worse,
283			* it would limit application programmers -- they would effectively be
284			* unable to bind to <Control-Backspace> on Windows. We therefore chose
285			* instead to return XK_BackSpace (handled here by letting the code
286			* "fall-through" to the return statement below, which works because the
287			* keycode for this event is VK_BACKSPACE, and the keymap table maps that
288			* keycode to XK_BackSpace).
289			*/
290
291			if (result == 1 && UCHAR(buf[0]) >= 0x20 && UCHAR(buf[0]) != 0x7F) {
292			return (KeySym) UCHAR(buf[0]);
293			}
294
295			/*
296			* Keycode is a non-alphanumeric key, so we have to do the lookup.
297			*/
298
299			skipToAscii:
300			if (keycode < 0 \|\| keycode > MAX_KEYCODE) {
301			return NoSymbol;
302			}
303			switch (keycode) {
304			/*
305			* Windows only gives us an undifferentiated VK_CONTROL
306			* code (for example) when either Control key is pressed.
307			* To distinguish between left and right, we have to query the
308			* state of one of the two to determine which was actually
309			* pressed. So if the keycode indicates Control, Shift, or Menu
310			* (the key that everybody else calls Alt), do this extra test.
311			* If the right-side key was pressed, return the appropriate
312			* keycode. Otherwise, we fall through and rely on the
313			* keymap table to hold the correct keysym value.
314			*/
315			case VK_CONTROL: {
316			if (GetKeyState(VK_RCONTROL) & 0x80) {
317			return XK_Control_R;
318			}
319			break;
320			}
321			case VK_SHIFT: {
322			if (GetKeyState(VK_RSHIFT) & 0x80) {
323			return XK_Shift_R;
324			}
325			break;
326			}
327			case VK_MENU: {
328			if (GetKeyState(VK_RMENU) & 0x80) {
329			return XK_Alt_R;
330			}
331			break;
332			}
333			}
334			return keymap[keycode];
335			}
336
337
338			/*
339			*----------------------------------------------------------------------
340			*
341			* TkpGetKeySym --
342			*
343			* Given an X KeyPress or KeyRelease event, map the
344			* keycode in the event into a KeySym.
345			*
346			* Results:
347			* The return value is the KeySym corresponding to
348			* eventPtr, or NoSymbol if no matching Keysym could be
349			* found.
350			*
351			* Side effects:
352			* In the first call for a given display, keycode-to-
353			* KeySym maps get loaded.
354			*
355			*----------------------------------------------------------------------
356			*/
357
358			KeySym
359			TkpGetKeySym(dispPtr, eventPtr)
360			TkDisplay dispPtr; / Display in which to map keycode. */
361			XEvent eventPtr; / Description of X event. */
362			{
363			KeySym sym;
364			int state = eventPtr->xkey.state;
365
366			/*
367			* Refresh the mapping information if it's stale
368			*/
369
370			if (dispPtr->bindInfoStale) {
371			TkpInitKeymapInfo(dispPtr);
372			}
373
374			sym = KeycodeToKeysym(eventPtr->xkey.keycode, state, 0);
375
376			/*
377			* Special handling: if this is a ctrl-alt or shifted key, and there
378			* is no keysym defined, try without the modifiers.
379			*/
380
381			if ((sym == NoSymbol) && ((state & ControlMask) \|\| (state & Mod2Mask))) {
382			state &= ~(ControlMask \| Mod2Mask);
383			sym = KeycodeToKeysym(eventPtr->xkey.keycode, state, 0);
384			}
385			if ((sym == NoSymbol) && (state & ShiftMask)) {
386			state &= ~ShiftMask;
387			sym = KeycodeToKeysym(eventPtr->xkey.keycode, state, 0);
388			}
389			return sym;
390			}
391
392			/*
393			*--------------------------------------------------------------
394			*
395			* TkpInitKeymapInfo --
396			*
397			* This procedure is invoked to scan keymap information
398			* to recompute stuff that's important for binding, such
399			* as the modifier key (if any) that corresponds to "mode
400			* switch".
401			*
402			* Results:
403			* None.
404			*
405			* Side effects:
406			* Keymap-related information in dispPtr is updated.
407			*
408			*--------------------------------------------------------------
409			*/
410
411			void
412			TkpInitKeymapInfo(dispPtr)
413			TkDisplay dispPtr; / Display for which to recompute keymap
414			* information. */
415			{
416			XModifierKeymap *modMapPtr;
417			KeyCode *codePtr;
418			KeySym keysym;
419			int count, i, j, max, arraySize;
420			#define KEYCODE_ARRAY_SIZE 20
421
422			dispPtr->bindInfoStale = 0;
423			modMapPtr = XGetModifierMapping(dispPtr->display);
424
425			/*
426			* Check the keycodes associated with the Lock modifier. If
427			* any of them is associated with the XK_Shift_Lock modifier,
428			* then Lock has to be interpreted as Shift Lock, not Caps Lock.
429			*/
430
431			dispPtr->lockUsage = LU_IGNORE;
432			codePtr = modMapPtr->modifiermap + modMapPtr->max_keypermod*LockMapIndex;
433			for (count = modMapPtr->max_keypermod; count > 0; count--, codePtr++) {
434			if (*codePtr == 0) {
435			continue;
436			}
437			keysym = KeycodeToKeysym(*codePtr, 0, 1);
438			if (keysym == XK_Shift_Lock) {
439			dispPtr->lockUsage = LU_SHIFT;
440			break;
441			}
442			if (keysym == XK_Caps_Lock) {
443			dispPtr->lockUsage = LU_CAPS;
444			break;
445			}
446			}
447
448			/*
449			* Look through the keycodes associated with modifiers to see if
450			* the the "mode switch", "meta", or "alt" keysyms are associated
451			* with any modifiers. If so, remember their modifier mask bits.
452			*/
453
454			dispPtr->modeModMask = 0;
455			dispPtr->metaModMask = 0;
456			dispPtr->altModMask = 0;
457			codePtr = modMapPtr->modifiermap;
458			max = 8*modMapPtr->max_keypermod;
459			for (i = 0; i < max; i++, codePtr++) {
460			if (*codePtr == 0) {
461			continue;
462			}
463			keysym = KeycodeToKeysym(*codePtr, 0, 1);
464			if (keysym == XK_Mode_switch) {
465			dispPtr->modeModMask \|= ShiftMask << (i/modMapPtr->max_keypermod);
466			}
467			if ((keysym == XK_Meta_L) \|\| (keysym == XK_Meta_R)) {
468			dispPtr->metaModMask \|= ShiftMask << (i/modMapPtr->max_keypermod);
469			}
470			if ((keysym == XK_Alt_L) \|\| (keysym == XK_Alt_R)) {
471			dispPtr->altModMask \|= ShiftMask << (i/modMapPtr->max_keypermod);
472			}
473			}
474
475			/*
476			* Create an array of the keycodes for all modifier keys.
477			*/
478
479			if (dispPtr->modKeyCodes != NULL) {
480			ckfree((char *) dispPtr->modKeyCodes);
481			}
482			dispPtr->numModKeyCodes = 0;
483			arraySize = KEYCODE_ARRAY_SIZE;
484			dispPtr->modKeyCodes = (KeyCode *) ckalloc((unsigned)
485			(KEYCODE_ARRAY_SIZE * sizeof(KeyCode)));
486			for (i = 0, codePtr = modMapPtr->modifiermap; i < max; i++, codePtr++) {
487			if (*codePtr == 0) {
488			continue;
489			}
490
491			/*
492			* Make sure that the keycode isn't already in the array.
493			*/
494
495			for (j = 0; j < dispPtr->numModKeyCodes; j++) {
496			if (dispPtr->modKeyCodes[j] == *codePtr) {
497			goto nextModCode;
498			}
499			}
500			if (dispPtr->numModKeyCodes >= arraySize) {
501			KeyCode *new;
502
503			/*
504			* Ran out of space in the array; grow it.
505			*/
506
507			arraySize *= 2;
508			new = (KeyCode *) ckalloc((unsigned)
509			(arraySize * sizeof(KeyCode)));
510			memcpy((VOID ) new, (VOID ) dispPtr->modKeyCodes,
511			(dispPtr->numModKeyCodes * sizeof(KeyCode)));
512			ckfree((char *) dispPtr->modKeyCodes);
513			dispPtr->modKeyCodes = new;
514			}
515			dispPtr->modKeyCodes[dispPtr->numModKeyCodes] = *codePtr;
516			dispPtr->numModKeyCodes++;
517			nextModCode: continue;
518			}
519			XFreeModifiermap(modMapPtr);
520			}
521
522			/*
523			* When mapping from a keysym to a keycode, need
524			* information about the modifier state that should be used
525			* so that when they call XKeycodeToKeysym taking into
526			* account the xkey.state, they will get back the original
527			* keysym.
528			*/
529
530			void
531			TkpSetKeycodeAndState(tkwin, keySym, eventPtr)
532			Tk_Window tkwin;
533			KeySym keySym;
534			XEvent *eventPtr;
535			{
536			int i;
537			SHORT result;
538			int shift;
539
540			eventPtr->xkey.keycode = 0;
541			if (keySym == NoSymbol) {
542			return;
543			}
544
545			/*
546			* We check our private map first for a virtual keycode,
547			* as VkKeyScan will return values that don't map to X
548			* for the "extended" Syms. This may be due to just casting
549			* problems below, but this works.
550			*/
551			for (i = 0; i <= MAX_KEYCODE; i++) {
552			if (keymap[i] == keySym) {
553			eventPtr->xkey.keycode = i;
554			return;
555			}
556			}
557			if (keySym >= 0x20) {
558			result = VkKeyScan((char) keySym);
559			if (result != -1) {
560			shift = result >> 8;
561			if (shift & 1)
562			eventPtr->xkey.state \|= ShiftMask;
563			if (shift & 2)
564			eventPtr->xkey.state \|= ControlMask;
565			if (shift & 4)
566			eventPtr->xkey.state \|= Mod2Mask;
567			eventPtr->xkey.keycode = (KeyCode) (result & 0xff);
568			}
569			}
570			{
571			/* Debug log */
572			FILE *fp = fopen("c:\\temp\\tklog.txt", "a");
573			if (fp != NULL) {
574			fprintf(fp, "TkpSetKeycode. Keycode %d State %d Keysym %d\n", eventPtr->xkey.keycode, eventPtr->xkey.state, keySym);
575			fclose(fp);
576			}
577			}
578			}
579
580			/*
581			*----------------------------------------------------------------------
582			*
583			* XKeysymToKeycode --
584			*
585			* Translate a keysym back into a keycode.
586			*
587			* Results:
588			* Returns the keycode that would generate the specified keysym.
589			*
590			* Side effects:
591			* None.
592			*
593			*----------------------------------------------------------------------
594			*/
595
596			KeyCode
597			XKeysymToKeycode(display, keysym)
598			Display* display;
599			KeySym keysym;
600			{
601			int i;
602			SHORT result;
603
604			/*
605			* We check our private map first for a virtual keycode,
606			* as VkKeyScan will return values that don't map to X
607			* for the "extended" Syms. This may be due to just casting
608			* problems below, but this works.
609			*/
610			if (keysym == NoSymbol) {
611			return 0;
612			}
613			for (i = 0; i <= MAX_KEYCODE; i++) {
614			if (keymap[i] == keysym) {
615			return ((KeyCode) i);
616			}
617			}
618			if (keysym >= 0x20) {
619			result = VkKeyScan((char) keysym);
620			if (result != -1) {
621			return (KeyCode) (result & 0xff);
622			}
623			}
624
625			return 0;
626			}
627
628			/*
629			*----------------------------------------------------------------------
630			*
631			* XGetModifierMapping --
632			*
633			* Fetch the current keycodes used as modifiers.
634			*
635			* Results:
636			* Returns a new modifier map.
637			*
638			* Side effects:
639			* Allocates a new modifier map data structure.
640			*
641			*----------------------------------------------------------------------
642			*/
643
644			XModifierKeymap *
645			XGetModifierMapping(display)
646			Display* display;
647			{
648			XModifierKeymap map = (XModifierKeymap )ckalloc(sizeof(XModifierKeymap));
649
650			map->max_keypermod = 1;
651			map->modifiermap = (KeyCode ) ckalloc(sizeof(KeyCode)8);
652			map->modifiermap[ShiftMapIndex] = VK_SHIFT;
653			map->modifiermap[LockMapIndex] = VK_CAPITAL;
654			map->modifiermap[ControlMapIndex] = VK_CONTROL;
655			map->modifiermap[Mod1MapIndex] = VK_NUMLOCK;
656			map->modifiermap[Mod2MapIndex] = VK_MENU;
657			map->modifiermap[Mod3MapIndex] = VK_SCROLL;
658			map->modifiermap[Mod4MapIndex] = 0;
659			map->modifiermap[Mod5MapIndex] = 0;
660			return map;
661			}
662
663			/*
664			*----------------------------------------------------------------------
665			*
666			* XFreeModifiermap --
667			*
668			* Deallocate a modifier map that was created by
669			* XGetModifierMapping.
670			*
671			* Results:
672			* None.
673			*
674			* Side effects:
675			* Frees the datastructure referenced by modmap.
676			*
677			*----------------------------------------------------------------------
678			*/
679
680			void
681			XFreeModifiermap(modmap)
682			XModifierKeymap* modmap;
683			{
684			ckfree((char *) modmap->modifiermap);
685			ckfree((char *) modmap);
686			}
687
688			/*
689			*----------------------------------------------------------------------
690			*
691			* XStringToKeysym --
692			*
693			* Translate a keysym name to the matching keysym.
694			*
695			* Results:
696			* Returns the keysym. Since this is already handled by
697			* Tk's StringToKeysym function, we just return NoSymbol.
698			*
699			* Side effects:
700			* None.
701			*
702			*----------------------------------------------------------------------
703			*/
704
705			KeySym
706			XStringToKeysym(string)
707			_Xconst char *string;
708			{
709			return NoSymbol;
710			}
711
712			/*
713			*----------------------------------------------------------------------
714			*
715			* XKeysymToString --
716			*
717			* Convert a keysym to character form.
718			*
719			* Results:
720			* Returns NULL, since Tk will have handled this already.
721			*
722			* Side effects:
723			* None.
724			*
725			*----------------------------------------------------------------------
726			*/
727
728			char *
729			XKeysymToString(keysym)
730			KeySym keysym;
731			{
732			return NULL;
733			}
734
735			/* End of tkwinkey.c */