#include "copyright.h"

/* $XConsortium: XKeyBind.c,v 11.44 88/10/09 12:18:19 rws Exp $ */
/* Copyright 1985, 1987, Massachusetts Institute of Technology */

/* Beware, here be monsters (still under construction... - JG */

#define NEED_EVENTS
#include "Xlib.h"
#include "Xlibint.h"
#include "Xutil.h"
#include "keysym.h"
#include <stdio.h>

static ComputeMaskFromKeytrans();

struct XKeytrans {
	struct XKeytrans *next;/* next on list */
	char *string;		/* string to return when the time comes */
	int len;		/* length of string (since NULL is legit)*/
	KeySym key;		/* keysym rebound */
	unsigned int state;	/* modifier state */
	KeySym *modifiers;	/* modifier keysyms you want */
	int mlen;		/* length of modifier list */
};

static KeySym KeyCodetoKeySym(dpy, keycode, col)
     register Display *dpy;
     KeyCode keycode;
     int col;
{
     int ind;
     /*
      * if keycode not defined in set, this should really be impossible.
      * in any case, if sanity check fails, return NoSymbol.
      */
     if (col < 0 || col > dpy->keysyms_per_keycode) return (NoSymbol);
     if (keycode < dpy->min_keycode || keycode > dpy->max_keycode) 
       return(NoSymbol);

     ind = (keycode - dpy->min_keycode) * dpy->keysyms_per_keycode + col;
     return (dpy->keysyms[ind]);
}

KeySym XKeycodeToKeysym(dpy, kc, col)
    Display *dpy;
    KeyCode kc;
    int col;
{
     if (dpy->keysyms == NULL)
         Initialize(dpy);
     return (KeyCodetoKeySym(dpy, kc, col));
}

KeyCode XKeysymToKeycode(dpy, ks)
    Display *dpy;
    KeySym ks;
{
    int         i;

     if (dpy->keysyms == NULL)
         Initialize(dpy);
    for (i = dpy->min_keycode; i <= dpy->max_keycode; i++) {
	int         j;

	for (j = 0; j < dpy->keysyms_per_keycode; j++) {
	    int ind = (i - dpy->min_keycode) * dpy->keysyms_per_keycode + j;

	    if (ks == dpy->keysyms[ind])
		return (i);
	}
    }
    return (0);
}

KeySym XLookupKeysym(event, col)
     register XKeyEvent *event;
     int col;
{
     if (event->display->keysyms == NULL)
         Initialize(event->display);
     return (KeyCodetoKeySym(event->display, event->keycode, col));
}

static
InitModMap(dpy)
    Display *dpy;
{
    register XModifierKeymap *map;
    register int i, j;
    KeySym sym;
    register struct XKeytrans *p;

    dpy->modifiermap = map = XGetModifierMapping(dpy);
    if (dpy->keysyms == NULL)
	Initialize(dpy);
    LockDisplay(dpy);
    /* If any Lock key contains Caps_Lock, then interpret as Caps_Lock,
     * else if any contains Shift_Lock, then interpret as Shift_Lock,
     * else ignore Lock altogether.
     */
    dpy->lock_meaning = NoSymbol;
    /* Lock modifiers are in the second row of the matrix */
    for (i = map->max_keypermod; i < 2*map->max_keypermod; i++) {
        for (j = 0; j < dpy->keysyms_per_keycode; j++) {
	    sym = KeyCodetoKeySym(dpy, map->modifiermap[i], j);
	    if (sym == XK_Caps_Lock) {
		dpy->lock_meaning = XK_Caps_Lock;
		break;
	    } else if (sym == XK_Shift_Lock) {
		dpy->lock_meaning = XK_Shift_Lock;
	    }
	}
    }
    for (p = dpy->key_bindings; p; p = p->next)
        ComputeMaskFromKeytrans(dpy, p);
    UnlockDisplay(dpy);
}

XRefreshKeyboardMapping(event)
     register XMappingEvent *event;
{
     extern void XFreeModifiermap();

     if(event->request == MappingKeyboard) {
	/* XXX should really only refresh what is necessary
	 * for now, make initialize test fail
	 */
	    LockDisplay(event->display);
	    if (event->display->keysyms != NULL) {
	         Xfree ((char *)event->display->keysyms);
	         event->display->keysyms = NULL;
	    }
	    UnlockDisplay(event->display);
     }
     if(event->request == MappingModifier) {
	    LockDisplay(event->display);
	    if (event->display->modifiermap != NULL) {
		XFreeModifiermap(event->display->modifiermap);
		event->display->modifiermap = NULL;
	    }
	    UnlockDisplay(event->display);
	    /* go ahead and get it now, since initialize test may not fail */
	    InitModMap(event->display);
     }
}

/*ARGSUSED*/
static InitTranslationList(dpy)
    Display *dpy;
{
	/* not yet implemented */
	/* should read keymap file and initialize list */
}

/*ARGSUSED*/
int XUseKeymap(filename) 
    char *filename;
{
  /* not yet implemented */
}

static Initialize(dpy)
Display *dpy;
{
    register KeySym *keysyms, *sym, *old, *endp, *temp;
    int per, n;

    /* 
     * lets go get the keysyms from the server.
     */
    if (dpy->keysyms == NULL) {
	n = dpy->max_keycode - dpy->min_keycode + 1;
	keysyms = XGetKeyboardMapping (dpy, (KeyCode) dpy->min_keycode,
				       n, &per);
	/* need at least two per keycode, to have room for case conversion */
	if (per == 1) {
	    temp = (KeySym *) Xmalloc((unsigned)(n * sizeof(KeySym) * 2));
	    for (sym = temp, old = keysyms, endp = keysyms + n; old < endp;) {
		*sym++ = *old++;
	        *sym++ = NoSymbol;
	    }
	    Xfree((char *)keysyms);
	    keysyms = temp;
	    per = 2;
	    n <<= 1;
	}
	/* convert singleton Latin 1 alphabetics */
	for (sym = keysyms, endp = keysyms + n*per; sym < endp; sym += per) {
	  if (*(sym + 1) != NoSymbol) continue;
	  if ((*sym >= XK_A) && (*sym <= XK_Z)) {
	      *(sym + 1) = *sym;
	      *sym += (XK_a - XK_A);
	      }
	  else if ((*sym >= XK_a) && (*sym <= XK_z)) {
	      *(sym + 1) = *sym - (XK_a - XK_A);
	      }
	  else if ((*sym >= XK_Agrave) && (*sym <= XK_Odiaeresis)) {
	      *(sym + 1) = *sym;
	      *sym += (XK_agrave - XK_Agrave);
	      }
	  else if ((*sym >= XK_agrave) && (*sym <= XK_odiaeresis)) {
	      *(sym + 1) = *sym - (XK_agrave - XK_Agrave);
	      }
	  else if ((*sym >= XK_Ooblique) && (*sym <= XK_Thorn)) {
	      *(sym + 1) = *sym;
	      *sym += (XK_oslash - XK_Ooblique);
	      }
	  else if ((*sym >= XK_oslash) && (*sym <= XK_thorn)) {
	      *(sym + 1) = *sym - (XK_oslash - XK_Ooblique);
	      }
 	}
	LockDisplay(dpy);
	dpy->keysyms = keysyms;
	dpy->keysyms_per_keycode = per;
	UnlockDisplay(dpy);
    }
    if (dpy->modifiermap == NULL) {
        InitModMap(dpy);
    }
    if (dpy->key_bindings == NULL) InitTranslationList(dpy);
}

static int KeySymRebound(event, buf, symbol)
    register XKeyEvent *event;
    char *buf;
    KeySym symbol;
{
    register struct XKeytrans *p;

    for (p = event->display->key_bindings; p; p = p->next) {
	if ((event->state == p->state) && (symbol == p->key)) {
		bcopy (p->string, buf, p->len);
		return p->len;
		}
	}
    return -1;
}
  
/*ARGSUSED*/
int XLookupString (event, buffer, nbytes, keysym, status)
     register XKeyEvent *event;
     char *buffer;	/* buffer */
     int nbytes;	/* space in buffer for characters */
     KeySym *keysym;
     XComposeStatus *status;	/* not implemented */
{
     register Display *dpy;
     register KeySym symbol, usymbol;
     int length = 0;
     char buf[BUFSIZ];
     unsigned char c;
     unsigned long hiBytes;

     dpy = event->display;
     if (dpy->keysyms == NULL)
         Initialize(dpy);

     symbol = KeyCodetoKeySym(dpy, event->keycode, 0);

     /* apply Shift first */
     if ((event->state & ShiftMask) ||
	 ((event->state & LockMask) && (dpy->lock_meaning == XK_Shift_Lock))) {
	     usymbol = KeyCodetoKeySym(dpy, event->keycode, 1);
	     if (usymbol != NoSymbol)
	          symbol = usymbol;
     }
     /* then apply Caps, as protocol suggests*/
     /* XXX this should really work for all character sets */
     if ((event->state & LockMask) && (dpy->lock_meaning == XK_Caps_Lock)) {
	    if (symbol >= XK_a && symbol <= XK_z)
	          symbol -= (XK_a - XK_A);
	    else if (symbol >= XK_agrave && symbol <= XK_odiaeresis)
	          symbol -= (XK_agrave - XK_Agrave);
	    else if (symbol >= XK_oslash && symbol <= XK_thorn)
	          symbol -= (XK_oslash - XK_Ooblique);
     }

     if (keysym != NULL) *keysym = symbol;

     /*
      * see if symbol rebound, if so, return that string.
      * if special Keyboard, convert to ascii.  handle control.
      */
     if ((length = KeySymRebound(event, buf, symbol)) == -1) {
	    c = symbol & 0xFF;
	    hiBytes = symbol >> 8;
            if ( ((hiBytes != 0) && (hiBytes != 0xFF))
		|| IsModifierKey(symbol)   || IsCursorKey(symbol)
		|| IsPFKey (symbol)      || IsFunctionKey(symbol)
		|| IsMiscFunctionKey(symbol)
		|| (symbol == XK_Multi_key) || (symbol == XK_Kanji)) {
		return 0;
	    } else {
		if (symbol == XK_KP_Space)
		   c = XK_space & 0xFF; /* patch encoding botch */
		/* if X keysym, convert to ascii by grabbing low 7 bits */
		if (hiBytes == 0xFF) c &= 0x7F;
		/* only apply Control key if it makes sense, else ignore it */
		if (event->state & ControlMask) {
		    if ((c >= '@' && c <= '\177') || c == ' ') c &= 0x1F;
		    else if (c == '2') c = '\000';
		    else if (c >= '3' && c <= '7') c -= ('3' - '\033');
		    else if (c == '8') c = '\177';
		    else if (c == '/') c = '_' & 0x1F;
		}
	    }
	    buf[0] = c;
     	    length = 1;
      }
      if (length > nbytes) length = nbytes;
      bcopy (buf, buffer, length);
      return (length);
}

XRebindKeysym (dpy, keysym, mlist, nm, str, nbytes)
    Display *dpy;
    KeySym keysym;
    KeySym *mlist;
    int nm;		/* number of modifiers in mlist */
    unsigned char *str;
    int nbytes;
{
    register struct XKeytrans *tmp, *p;
    int nb;

    if (dpy->keysyms == NULL)
    	Initialize(dpy);
    LockDisplay(dpy);
    tmp = dpy->key_bindings;
    dpy->key_bindings = p = (struct XKeytrans *)Xmalloc(sizeof(struct XKeytrans));
    p->next = tmp;	/* chain onto list */
    p->string = (char *) Xmalloc(nbytes);
    bcopy (str, p->string, nbytes);
    p->len = nbytes;
    nb = sizeof (KeySym) * nm;
    p->modifiers = (KeySym *) Xmalloc(nb);
    bcopy (mlist, p->modifiers, nb);
    p->key = keysym;
    p->mlen = nm;
    ComputeMaskFromKeytrans(dpy, p);
    UnlockDisplay(dpy);
    return;
}

_XFreeKeyBindings (dpy)
    Display *dpy;
{
    register struct XKeytrans *p, *np;

    for (p = dpy->key_bindings; p; p = np) {
        np = p->next;
	Xfree(p->string);
	Xfree((char *)p->modifiers);
	Xfree((char *)p);
    }   
}

/*
 * given a KeySym, returns the first keycode containing it, if any.
 */
static CARD8 FindKeyCode(dpy, code)
    register Display *dpy;
    register KeySym code;
{

    register KeySym *kmax = dpy->keysyms + 
	(dpy->max_keycode - dpy->min_keycode + 1) * dpy->keysyms_per_keycode;
    register KeySym *k = dpy->keysyms;
    while (k < kmax) {
	if (*k == code)
	    return(((k - dpy->keysyms)
		/ dpy->keysyms_per_keycode) + dpy->min_keycode);
	k += 1;
	}
    return 0;
}

	
/*
 * given a list of modifiers, computes the mask necessary for later matching.
 * This routine must lookup the key in the Keymap and then search to see
 * what modifier it is bound to, if any.
 */
static ComputeMaskFromKeytrans(dpy, p)
    Display *dpy;
    register struct XKeytrans *p;
{
    register int i;
    register CARD8 code;
    register XModifierKeymap *m = dpy->modifiermap;

    p->state = 0;
    for (i = 0; i < p->mlen; i++) {
	/* if not found, then not on current keyboard */
	if ((code = FindKeyCode(dpy, p->modifiers[i])) == 0)
		continue;
	/* code is now the keycode for the modifier you want */
	{
	    register int j;

	    for (j = 0; j < (m->max_keypermod<<3); j++) {
		if (code == m->modifiermap[j])
		    p->state |= (1<<(j/m->max_keypermod));
	    }
	}
    }
    return;
}