* 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, 265 insertions, 1 deletions

diff --git a/unix/tkUnixKey.c b/unix/tkUnixKey.c
index effce2f..efba728 100644
--- a/unix/tkUnixKey.c
+++ b/unix/tkUnixKey.c
@@ -9,11 +9,17 @@
  * See the file "license.terms" for information on usage and redistribution
  * of this file, and for a DISCLAIMER OF ALL WARRANTIES.
  *
- * RCS: @(#) $Id: tkUnixKey.c,v 1.3 1999/12/16 21:59:13 hobbs Exp $
+ * RCS: @(#) $Id: tkUnixKey.c,v 1.4 2000/02/09 02:13:54 hobbs Exp $
  */
 
 #include "tkInt.h"
 
+/*
+ * Prototypes for local procedures defined in this file:
+ */
+
+static void		InitKeymapInfo _ANSI_ARGS_((TkDisplay *dispPtr));
+
 
 /*
  *----------------------------------------------------------------------
@@ -88,3 +94,261 @@ TkpGetString(winPtr, eventPtr, dsPtr)
 
     return Tcl_DStringValue(dsPtr);
 }
+
+/*
+ * 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;
+{
+    Display *display;
+    int state;
+    KeyCode keycode;
+    
+    display = Tk_Display(tkwin);
+    
+    if (keySym == NoSymbol) {
+	keycode = 0;
+    } else {
+	keycode = XKeysymToKeycode(display, keySym);
+    }
+    if (keycode != 0) {
+	for (state = 0; state < 4; state++) {
+	    if (XKeycodeToKeysym(display, keycode, state) == keySym) {
+		if (state & 1) {
+		    eventPtr->xkey.state |= ShiftMask;
+		}
+		if (state & 2) {
+		    TkDisplay *dispPtr;
+
+		    dispPtr = ((TkWindow *) tkwin)->dispPtr; 
+		    eventPtr->xkey.state |= dispPtr->modeModMask;
+		}
+		break;
+	    }
+	}
+    }
+    eventPtr->xkey.keycode = 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 index;
+
+    /*
+     * Refresh the mapping information if it's stale
+     */
+
+    if (dispPtr->bindInfoStale) {
+	InitKeymapInfo(dispPtr);
+    }
+
+    /*
+     * Figure out which of the four slots in the keymap vector to
+     * use for this key.  Refer to Xlib documentation for more info
+     * on how this computation works.
+     */
+
+    index = 0;
+    if (eventPtr->xkey.state & dispPtr->modeModMask) {
+	index = 2;
+    }
+    if ((eventPtr->xkey.state & ShiftMask)
+	    || ((dispPtr->lockUsage != LU_IGNORE)
+	    && (eventPtr->xkey.state & LockMask))) {
+	index += 1;
+    }
+    sym = XKeycodeToKeysym(dispPtr->display, eventPtr->xkey.keycode, index);
+
+    /*
+     * Special handling:  if the key was shifted because of Lock, but
+     * lock is only caps lock, not shift lock, and the shifted keysym
+     * isn't upper-case alphabetic, then switch back to the unshifted
+     * keysym.
+     */
+
+    if ((index & 1) && !(eventPtr->xkey.state & ShiftMask)
+	    && (dispPtr->lockUsage == LU_CAPS)) {
+	if (!(((sym >= XK_A) && (sym <= XK_Z))
+		|| ((sym >= XK_Agrave) && (sym <= XK_Odiaeresis))
+		|| ((sym >= XK_Ooblique) && (sym <= XK_Thorn)))) {
+	    index &= ~1;
+	    sym = XKeycodeToKeysym(dispPtr->display, eventPtr->xkey.keycode,
+		    index);
+	}
+    }
+
+    /*
+     * Another bit of special handling:  if this is a shifted key and there
+     * is no keysym defined, then use the keysym for the unshifted key.
+     */
+
+    if ((index & 1) && (sym == NoSymbol)) {
+	sym = XKeycodeToKeysym(dispPtr->display, eventPtr->xkey.keycode,
+		index & ~1);
+    }
+    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 = XKeycodeToKeysym(dispPtr->display, *codePtr, 0);
+	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 = XKeycodeToKeysym(dispPtr->display, *codePtr, 0);
+	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);
+}