* generic/tk.decls:

	* generic/tkBind.c:
	* generic/tkInt.decls:
	* generic/tkIntDecls.h:
	* generic/tkStubInit.c:
	* mac/tkMacKeyboard.c:
	* unix/tkUnixKey.c:
	* win/tkWinKey.c: Fix for keyboard handling of "dead" keys and
	caps lock from Peter Spjuth.
	Split functions into platform specific files:
	Static functions GetKeySym(), SetKeycodeAndState() and InitKeymapInfo()
	from tkBind.c moved into platform files tkWinKey.c tkUnixKey.c and
	tkMacKeyboard.c.  GetKeySym() and SetKeycodeAndState() renamed to
	Tkp* and made public (as private functions) in tkInt.decls.

	Step 2, fixes in tkWinKey.c
	New static function: KeycodeToKeysym(), based on XKeycodeToKeysym()
	but with different arguments, and a lot of improvements.
	TkpGetString() changed to use KeycodeToKeysym() + other fixes.
	TkpGetKeySym() changed to use KeycodeToKeysym() + other fixes.
	InitKeymapInfo() changed to use KeycodeToKeysym().
	TkpSetKeycodeAndState() rewritten, mostly by copying code from
	XKeysymToKeycode().
	XKeycodeToKeysym() rewritten. Preferably it should be removed.

	EXPLANATION: The main problem is ToAscii() which has a lot of side
	effects, and also that XKeycodeToKeysym() is not provided enough
	input to do a proper job.  The changes' main goal is to avoid
	calling ToAscii() if not necessary, and to provide it with as
	correct information as possible when called.  Also some attempts
	to clean up what ToAscii() did are done.  See the code for details.

	BUGS FIXED: Typing shifted (and AltGr) dead keys did not work.
	Keyboard lock lamps did not work on Win98.
	Events regarding AltGr-keys behaved badly.
	Example: On a Swedish keyboard, $ is typed with AltGr-4.
	That keyboard event would get the keysym '4' not 'dollar'.
	Also, doing [event generete . <Key-dollar>] would send keysym '4'.
	Translation to ascii in TkpGetString did not handle return and
	tab correctly. I.e. [event generate . <Key-Return>] gave wrong %A

1 files changed, 376 insertions, 18 deletions

diff --git a/win/tkWinKey.c b/win/tkWinKey.c
index af826d5..d46f601 100644
--- a/win/tkWinKey.c
+++ b/win/tkWinKey.c
@@ -9,7 +9,7 @@
  * 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.6 1999/10/30 09:16:07 hobbs Exp $
+ * RCS: @(#) $Id: tkWinKey.c,v 1.7 2000/02/09 02:13:56 hobbs Exp $
  */
 
 #include "tkWinInt.h"
@@ -85,6 +85,14 @@ static Keys keymap[] = {
     0, NoSymbol
 };
 
+/*
+ * Prototypes for local procedures defined in this file:
+ */
+
+static KeySym		KeycodeToKeysym _ANSI_ARGS_((unsigned int keycode,
+			    int state, int noascii));
+static void		InitKeymapInfo _ANSI_ARGS_((TkDisplay *dispPtr));
+
 
 /*
  *----------------------------------------------------------------------
@@ -110,7 +118,6 @@ TkpGetString(winPtr, eventPtr, dsPtr)
     Tcl_DString *dsPtr;		/* Uninitialized or empty string to hold
 				 * result. */
 {
-    int index;
     KeySym keysym;
     XKeyEvent* keyEv = &eventPtr->xkey;
 
@@ -121,20 +128,13 @@ TkpGetString(winPtr, eventPtr, dsPtr)
 	 * nchars or trans_chars members. 
 	 */
 
-	index = 0;
-	if (eventPtr->xkey.state & ShiftMask) {
-	    index |= 1;
-	}
-	if (eventPtr->xkey.state & Mod1Mask) {
-	    index |= 2;
-	}
-	keysym = XKeycodeToKeysym(eventPtr->xkey.display, 
-		eventPtr->xkey.keycode, index);
+	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, buf);
+	    int len = Tcl_UniCharToUtf((Tcl_UniChar) (keysym & 255), buf);
 	    Tcl_DStringAppend(dsPtr, buf, len);
 	}
     } else if (eventPtr->xkey.nbytes > 0) {
@@ -167,20 +167,132 @@ XKeycodeToKeysym(display, keycode, index)
     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;
+{
     Keys* key;
     BYTE keys[256];
-    int result;
+    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 (index & 0x02) {
+    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 (index & 0x01) {
-	keys[VK_SHIFT] = 0x80;
+    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;
     }
-    result = ToAscii(keycode, scancode, keys, (LPWORD) buf, 0);
 
     /*
      * Keycode mapped to a valid Latin-1 character.  Since the keysyms
@@ -195,6 +307,7 @@ XKeycodeToKeysym(display, keycode, index)
      * Keycode is a non-alphanumeric key, so we have to do the lookup.
      */
 
+    skipToAscii:
     for (key = keymap; key->keycode != 0; key++) {
 	if (key->keycode == keycode) {
 	    return key->keysym;
@@ -204,6 +317,251 @@ XKeycodeToKeysym(display, keycode, index)
     return NoSymbol;
 }
 
+
+/*
+ *----------------------------------------------------------------------
+ *
+ * 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) {
+	InitKeymapInfo(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;
+}
+
+/*
+ *--------------------------------------------------------------
+ *
+ * InitKeymapInfo --
+ *
+ *	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.
+ *
+ *--------------------------------------------------------------
+ */
+
+static void
+InitKeymapInfo(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;
+{
+    Keys* key;
+    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 (key = keymap; key->keycode != 0; key++) {
+        if (key->keysym == keySym) {
+            eventPtr->xkey.keycode = key->keycode;
+            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);
+        }
+    }
+}
+
 /*
  *----------------------------------------------------------------------
  *
@@ -244,7 +602,7 @@ XKeysymToKeycode(display, keysym)
     if (keysym >= 0x20) {
 	result = VkKeyScan((char) keysym);
 	if (result != -1) {
-	    return (KeyCode) (result & 0xfff);
+	    return (KeyCode) (result & 0xff);
 	}
     }