unsigned
_XKeysymToModifiers(
Display *dpy,
KeySym ks)
{
CARD8 code,mods;
register KeySym *kmax;
register KeySym *k;
register XModifierKeymap *m;
if ((! dpy->keysyms) && (! _XKeyInitialize(dpy)))
return 0;
kmax = dpy->keysyms +
(dpy->max_keycode - dpy->min_keycode + 1) * dpy->keysyms_per_keycode;
k = dpy->keysyms;
m = dpy->modifiermap;
mods= 0;
while (k<kmax) {
if (*k == ks ) {
register int j = m->max_keypermod<<3;
code=(((k-dpy->keysyms)/dpy->keysyms_per_keycode)+dpy->min_keycode);
while (--j >= 0) {
if (code == m->modifiermap[j])
mods|= (1<<(j/m->max_keypermod));
}
}
k++;
}
return mods;
}
int
_XTranslateKey( register Display *dpy,
KeyCode keycode,
register unsigned int modifiers,
unsigned int *modifiers_return,
KeySym *keysym_return)
{
int per;
register KeySym *syms;
KeySym sym, lsym, usym;
if ((! dpy->keysyms) && (! _XKeyInitialize(dpy)))
return 0;
*modifiers_return = ((ShiftMask|LockMask)
| dpy->mode_switch | dpy->num_lock);
if (((int)keycode < dpy->min_keycode) || ((int)keycode > dpy->max_keycode))
{
*keysym_return = NoSymbol;
return 1;
}
per = dpy->keysyms_per_keycode;
syms = &dpy->keysyms[(keycode - dpy->min_keycode) * per];
while ((per > 2) && (syms[per - 1] == NoSymbol))
per--;
if ((per > 2) && (modifiers & dpy->mode_switch)) {
syms += 2;
per -= 2;
}
if ((modifiers & dpy->num_lock) &&
(per > 1 && (IsKeypadKey(syms[1]) || IsPrivateKeypadKey(syms[1])))) {
if ((modifiers & ShiftMask) ||
((modifiers & LockMask) && (dpy->lock_meaning == XK_Shift_Lock)))
*keysym_return = syms[0];
else
*keysym_return = syms[1];
} else if (!(modifiers & ShiftMask) &&
(!(modifiers & LockMask) || (dpy->lock_meaning == NoSymbol))) {
if ((per == 1) || (syms[1] == NoSymbol))
XConvertCase(syms[0], keysym_return, &usym);
else
*keysym_return = syms[0];
} else if (!(modifiers & LockMask) ||
(dpy->lock_meaning != XK_Caps_Lock)) {
if ((per == 1) || ((usym = syms[1]) == NoSymbol))
XConvertCase(syms[0], &lsym, &usym);
*keysym_return = usym;
} else {
if ((per == 1) || ((sym = syms[1]) == NoSymbol))
sym = syms[0];
XConvertCase(sym, &lsym, &usym);
if (!(modifiers & ShiftMask) && (sym != syms[0]) &&
((sym != usym) || (lsym == usym)))
XConvertCase(syms[0], &lsym, &usym);
*keysym_return = usym;
}
if (*keysym_return == XK_VoidSymbol)
*keysym_return = NoSymbol;
return 1;
}
KeySym
XLookupKeysym(
register XKeyEvent *event,
int col)
{
if ((! event->display->keysyms) && (! _XKeyInitialize(event->display)))
return NoSymbol;
return KeyCodetoKeySym(event->display, event->keycode, col);
}
KeySym XKeycodeToKeysym(Display *dpy,
#if NeedWidePrototypes
unsigned int kc,
#else
KeyCode kc,
#endif
int col)
{
if ((!dpy->keysyms) && (!_XKeyInitialize(dpy)))
return NoSymbol;
return KeyCodetoKeySym(dpy, kc, col);
}
KeyCode
XKeysymToKeycode(
Display *dpy,
KeySym ks)
{
register int i, j;
if ((! dpy->keysyms) && (! _XKeyInitialize(dpy)))
return (KeyCode) 0;
for (j = 0; j < dpy->keysyms_per_keycode; j++) {
for (i = dpy->min_keycode; i <= dpy->max_keycode; i++) {
if (KeyCodetoKeySym(dpy, (KeyCode) i, j) == ks)
return i;
}
}
return 0;
}
int
XRebindKeysym (
Display *dpy,
KeySym keysym,
KeySym *mlist,
int nm, /* number of modifiers in mlist */
_Xconst unsigned char *str,
int nbytes)
{
register struct _XKeytrans *tmp, *p;
int nb;
if ((! dpy->keysyms) && (! _XKeyInitialize(dpy)))
return 0;
LockDisplay(dpy);
tmp = dpy->key_bindings;
nb = sizeof(KeySym) * nm;
if ((! (p = Xcalloc( 1, sizeof(struct _XKeytrans)))) ||
((! (p->string = Xmalloc(nbytes))) && (nbytes > 0)) ||
((! (p->modifiers = Xmalloc(nb))) && (nb > 0))) {
if (p) {
if (p->string) Xfree(p->string);
if (p->modifiers) Xfree(p->modifiers);
Xfree(p);
}
UnlockDisplay(dpy);
return 0;
}
dpy->key_bindings = p;
dpy->free_funcs->key_bindings = _XFreeKeyBindings;
p->next = tmp; /* chain onto list */
memcpy (p->string, str, nbytes);
p->len = nbytes;
memcpy ((char *) p->modifiers, (char *) mlist, nb);
p->key = keysym;
p->mlen = nm;
ComputeMaskFromKeytrans(dpy, p);
UnlockDisplay(dpy);
return 0;
}
