usim

	int wantshift;		/* Index into second column in cadet_kbd_map. */
	int shkey;		/* Shift key being pressed. */
	int oshift;
	
	if (!keydown && cadet_allup_key() == true)
		return;
	oshift = cadet_shifts;
	printf("kbd (cadet): keysym = 0%o, bi = %d\n", keysym, bi);
	if (bi != -1) {
		int bucky;
		
		bucky = modifier_map[bi];
		if (bucky == KBD_NoSymbol) {
			printf("kbd (cadet): unbound modifier (keysym = 0%o)\n", keysym);
			return;
		}
		scc = cadet_modifier_map[bucky];
		cadet_process_shift(scc, keydown);
		printf("kbd (cadet): bucky pressed; scc = 0%o, shifts = 0%o (previous: 0%o)\n", scc, cadet_shifts, oshift);
		kbd_event(scc, keydown);
		return;
	}
	lmchar = kbd_map[keysym];
	printf("kbd (cadet): kbd_map[%d] (lmchar) = 0%o\n", keysym, kbd_map[keysym]);
	if (lmchar > LMCH_CODE_LIMIT || lmchar == LMCH_NoSymbol) {
		NOTICE(TRACE_USIM, "kbd (cadet): unable to translate to lispm key (keysym = 0%o)\n", keysym);
		return;
	}
	scc = cadet_kbd_map[lmchar][0];
	wantshift = cadet_kbd_map[lmchar][1];
	printf("kbd (cadet): non bucky pressed; scc = 0%o, wantshift = %d\n", scc, wantshift);
	/*
	 * If modifiers correct, just post the event, else
	 * queue the event and post the appropriate shifts.
	 */
	if (((wantshift == CADET_IX_UNSHIFT) && ((cadet_shifts & (1 << CADET_IX_SHIFT)) == 0)) || (cadet_shifts & (1 << wantshift))) {
		kbd_event(scc, keydown);
		return;

/* sdl1.c --- SDL1 routines used by the TV and KBD interfaces
 */

#include <signal.h>

#include <SDL.h>

#include "tv.h"
#include "kbd.h"
#include "mouse.h"
#include "utrace.h"
#include "idle.h"

SDL_Surface *screen;

struct DisplayState {
	unsigned char *data;
	int linesize;
	int depth;
	int width;
	int height;
};
static struct DisplayState display_state;
static struct DisplayState *ds = &display_state;

/*
 * Translation map for the host keyboard to a corresponding Lisp
 * Machine character or modifier.
 */
int sdl1_kbd_map[65535];
int sdl1_modifier_map[8];

/*
 * This is shared between x11.c, and sdl1.c ... the only difference is
 * the hook in send_accumulated_updates.
 */

unsigned long Background;


static
void sdl1_cleanup(void) 
{
	SDL_Quit();
}

/*
 * Returns the X11 modifier index of KEYCODE, or -1 if not found.
 */
int
sdl1_bucky(SDLKey keycode)
{
//	XModifierKeymap *modmap;
//
//	modmap = XGetModifierMapping(display);
//	for (int modifier = 0; modifier < 8; modifier++) {
//		for (int i = 0; i < modmap->max_keypermod; i++) {
//			if (keycode == modmap->modifiermap[modifier * modmap->max_keypermod + i]) {
//				XFreeModifiermap(modmap);
//				return modifier;
//			}
//		}
//	}
//	XFreeModifiermap(modmap);
	return -1;
}

/*
 * Takes E, converts it into a LM (hardware) keycode and sends it to
 * the IOB KBD.
 */
static void
process_key(SDL_KeyboardEvent *e, int keydown)
{
//	KeySym keysym;
//	SDLKey keycode;
	

	int bi;
	unsigned char buf[5];
	
	idle_keyboard_activity();
	
//	keycode = SDL_KeysymToKeycode(e->keysym.sym);
//if (event->key.code == key) ...
	
//	XLookupString(&e->xkey, (char *)buf, sizeof(buf), &keysym, &status);
//	keycode = x11_keysym_to_keycode(keysym);
//	if (keycode == NoSymbol || keysym > NELEM(x11_kbd_map)) {
//		NOTICE(TRACE_USIM, "kbd (cadet): unable to translate to sdl1 keycode (keysym = 0%o)\n", keysym);
//		return;
//	}

	

	if (kbd_type == 0) {
		if (!keydown)
			return;
		bi = 0;
//		if (e->xkey.state & ShiftMask)
//			knight_process_bucky(x11_modifier_map[ShiftMapIndex], &bi);
//		if (e->xkey.state & LockMask)
//			knight_process_bucky(x11_modifier_map[LockMapIndex], &bi);
//		if (e->xkey.state & ControlMask)
//			knight_process_bucky(x11_modifier_map[ControlMapIndex], &bi);
//		if (e->xkey.state & Mod1Mask)
//			knight_process_bucky(x11_modifier_map[Mod1MapIndex], &bi);
//		if (e->xkey.state & Mod2Mask)
//			knight_process_bucky(x11_modifier_map[Mod2MapIndex], &bi);
//		if (e->xkey.state & Mod3Mask)
//			knight_process_bucky(x11_modifier_map[Mod3MapIndex], &bi);
//		if (e->xkey.state & Mod4Mask)
//			knight_process_bucky(x11_modifier_map[Mod4MapIndex], &bi);
//		if (e->xkey.state & Mod5Mask)
//			knight_process_bucky(x11_modifier_map[Mod5MapIndex], &bi);
		knight_process_key(e->keysym.sym, bi, keydown, sdl1_kbd_map, sdl1_modifier_map);
	} else {


		bi = sdl1_bucky(e->keysym.sym);
		cadet_process_key(e->keysym.sym, bi, keydown, sdl1_kbd_map, sdl1_modifier_map);

	}
}

void
sdl1_event(void)
{
	SDL_Event ev1, *ev = &ev1;
	
	send_accumulated_updates();

		}
		case SDL_QUIT:
			exit(0);
			break;
		}
	}
}

void
sdl1_default_kbd_map(void)
{
	for (int i = 0; i < (int) NELEM(sdl1_kbd_map); i++)
		sdl1_kbd_map[i] = LMCH_NoSymbol;
	for (int i = 0; i < (int) NELEM(sdl1_modifier_map); i++)
		sdl1_modifier_map[i] = KBD_NoSymbol;

	/* *INDENT-OFF* */
	/*
	 * Initialize keyboard modifiers
	 */
//SDL Modifier	Meaning
//KMOD_NONE	No modifiers applicable
//KMOD_NUM	Numlock is down
//KMOD_CAPS	Capslock is down
//KMOD_LCTRL	Left Control is down
//KMOD_RCTRL	Right Control is down
//KMOD_RSHIFT	Right Shift is down
//KMOD_LSHIFT	Left Shift is down
//KMOD_RALT	Right Alt is down
//KMOD_LALT	Left Alt is down
//KMOD_CTRL	A Control key is down
//KMOD_SHIFT	A Shift key is down
//KMOD_ALT	An Alt key is down
	
//	x11_modifier_map[ShiftMapIndex] = KBD_SHIFT;
//	x11_modifier_map[LockMapIndex] = KBD_SHIFT_LOCK;
//	x11_modifier_map[ControlMapIndex] = KBD_CONTROL;
//	x11_modifier_map[Mod1MapIndex] = KBD_META;
//	x11_modifier_map[Mod2MapIndex] = KBD_NoSymbol;
//	x11_modifier_map[Mod3MapIndex] = KBD_NoSymbol;
//	x11_modifier_map[Mod4MapIndex] = KBD_TOP;
//	x11_modifier_map[Mod5MapIndex] = KBD_NoSymbol;

	/*
	 * Initialize keyboard mapping.
	 *
	 * We cann't reuse lmch.defs here because the Lisp Machine
	 * charachter set has names and charachters that do not have a
	 * corresponding mapping in X11.
	 */

	/* Unshifted */
	sdl1_kbd_map[SDLK_BACKQUOTE] = LMCH_grave;
	sdl1_kbd_map[SDLK_1] = LMCH_1;
	sdl1_kbd_map[SDLK_2] = LMCH_2;
	sdl1_kbd_map[SDLK_3] = LMCH_3;
	sdl1_kbd_map[SDLK_4] = LMCH_4;
	sdl1_kbd_map[SDLK_5] = LMCH_5;
	sdl1_kbd_map[SDLK_6] = LMCH_6;
	sdl1_kbd_map[SDLK_7] = LMCH_7;
	sdl1_kbd_map[SDLK_8] = LMCH_8;
	sdl1_kbd_map[SDLK_9] = LMCH_9;
	sdl1_kbd_map[SDLK_0] = LMCH_0;
	sdl1_kbd_map[SDLK_MINUS] = LMCH_minus;
	sdl1_kbd_map[SDLK_EQUALS] = LMCH_equal;
	/* *INDENT-ON* */
}

void
sdl1_init(void)
{
	NOTICE(TRACE_USIM, "tv: using SDL backend for monitor and keyboard\n"); 

	Foreground = 0xff; // White

#ifdef WITH_X11
	/*
	 * Initialize default X11 keybaord translation map.
	 */
	x11_default_kbd_map();
	x11_grab_keyboard = true;
#elif WITH_SDL1
	sdl1_default_kbd_map();
#endif
	/*
	 * Initialize default idle values.
	 */
	idle_cycles = 0x0ffff * 10;
	idle_quantum = 0x0ffff;
	idle_timeout = 1000;