/*
* tkUnixKey.c --
*
* This file contains routines for dealing with international keyboard
* input.
*
* Copyright (c) 1997 by 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: tkUnixKey.c,v 1.10 2002/06/17 20:09:01 hobbs Exp $
*/
#include "tkInt.h"
/*
* Prototypes for local procedures defined in this file:
*/
/*
*----------------------------------------------------------------------
*
* Tk_SetCaretPos --
*
* This enables correct placement of the XIM caret. This is called
* by widgets to indicate their cursor placement, and the caret
* location is used by TkpGetString to place the XIM caret.
* This is currently only used for over-the-spot XIM.
*
* Results:
* None
*
* Side effects:
* None
*
*----------------------------------------------------------------------
*/
void
Tk_SetCaretPos(tkwin, x, y, height)
Tk_Window tkwin;
int x;
int y;
int height;
{
TkCaret *caretPtr = &(((TkWindow *) tkwin)->dispPtr->caret);
/*
* Use height for best placement of the XIM over-the-spot box.
*/
caretPtr->winPtr = ((TkWindow *) tkwin);
caretPtr->x = x;
caretPtr->y = y;
caretPtr->height = height;
}
/*
*----------------------------------------------------------------------
*
* TkpGetString --
*
* Retrieve the UTF string associated with a keyboard event.
*
* Results:
* Returns the UTF string.
*
* Side effects:
* Stores the input string in the specified Tcl_DString. Modifies
* the internal input state. This routine can only be called
* once for a given event.
*
*----------------------------------------------------------------------
*/
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. */
{
int len;
Tcl_DString buf;
Status status;
#ifdef TK_USE_INPUT_METHODS
TkDisplay *dispPtr = winPtr->dispPtr;
#endif
/*
* Overallocate the dstring to the maximum stack amount.
*/
#ifdef TK_USE_INPUT_METHODS
if ((dispPtr->flags & TK_DISPLAY_USE_IM)
&& (winPtr->inputContext != NULL)
&& (eventPtr->type == KeyPress)) {
#if TK_XIM_SPOT
XVaNestedList preedit_attr;
XPoint spot;
#endif
#ifdef X_HAVE_UTF8_STRING
Tcl_DStringInit(dsPtr);
Tcl_DStringSetLength(dsPtr, TCL_DSTRING_STATIC_SIZE-1);
len = Xutf8LookupString(winPtr->inputContext, &eventPtr->xkey,
Tcl_DStringValue(dsPtr), Tcl_DStringLength(dsPtr),
(KeySym *) NULL, &status);
#else
Tcl_DStringInit(&buf);
Tcl_DStringSetLength(&buf, TCL_DSTRING_STATIC_SIZE-1);
len = XmbLookupString(winPtr->inputContext, &eventPtr->xkey,
Tcl_DStringValue(&buf), Tcl_DStringLength(&buf),
(KeySym *) NULL, &status);
#endif
/*
* If the buffer wasn't big enough, grow the buffer and try again.
*/
if (status == XBufferOverflow) {
#ifdef X_HAVE_UTF8_STRING
Tcl_DStringSetLength(dsPtr, len);
len = Xutf8LookupString(winPtr->inputContext, &eventPtr->xkey,
Tcl_DStringValue(dsPtr), len, (KeySym *) NULL, &status);
#else
Tcl_DStringSetLength(&buf, len);
len = XmbLookupString(winPtr->inputContext, &eventPtr->xkey,
Tcl_DStringValue(&buf), len, (KeySym *) NULL, &status);
#endif
}
if ((status != XLookupChars) && (status != XLookupBoth)) {
len = 0;
}
#if TK_XIM_SPOT
/*
* Adjust the XIM caret position. We might want to check that
* this is the right caret.winPtr as well.
*/
if (dispPtr->flags & TK_DISPLAY_XIM_SPOT) {
spot.x = dispPtr->caret.x;
spot.y = dispPtr->caret.y + dispPtr->caret.height;
preedit_attr = XVaCreateNestedList(0, XNSpotLocation, &spot, NULL);
XSetICValues(winPtr->inputContext,
XNPreeditAttributes, preedit_attr, NULL);
XFree(preedit_attr);
}
#endif
#ifdef X_HAVE_UTF8_STRING
Tcl_DStringSetLength(dsPtr, len);
return Tcl_DStringValue(dsPtr);
#endif
} else {
Tcl_DStringInit(&buf);
Tcl_DStringSetLength(&buf, TCL_DSTRING_STATIC_SIZE-1);
len = XLookupString(&eventPtr->xkey, Tcl_DStringValue(&buf),
Tcl_DStringLength(&buf), (KeySym *) NULL,
(XComposeStatus *) NULL);
}
#else /* TK_USE_INPUT_METHODS */
Tcl_DStringInit(&buf);
Tcl_DStringSetLength(&buf, TCL_DSTRING_STATIC_SIZE-1);
len = XLookupString(&eventPtr->xkey, Tcl_DStringValue(&buf),
Tcl_DStringLength(&buf), (KeySym *) NULL,
(XComposeStatus *) NULL);
#endif /* TK_USE_INPUT_METHODS */
Tcl_DStringSetLength(&buf, len);
Tcl_ExternalToUtfDString(NULL, Tcl_DStringValue(&buf), len, dsPtr);
Tcl_DStringFree(&buf);
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) {
TkpInitKeymapInfo(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;
}
/*
*--------------------------------------------------------------
*
* 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 = 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);
}