usim

	 *
	 * Also keep track if we should do an all-up event, and track
	 * the modifiers for later.
	 */
	for (int modifier = 0; modifier < 8; modifier++) {
		int bucky;

		bucky = x11_modifier_map[modifier];
		for (int i = 0; i < modmap->max_keypermod; i++) {
			KeyCode keycode;

			keycode = modmap->modifiermap[modifier * modmap->max_keypermod + i];
			if (keymap[keycode / 8] & (1 << keycode % 8)) {
				keymap[keycode / 8] &= ~(1 << keycode % 8);	/* Clear the key in KEYMAP. */
				printf("cadet_allup_key() - bucky pressed (%d); keycode = %d\n", bucky, keycode);

				case KBD_HYPER:
					mods |= CADET_ALLUP_HYPER;
					break;
				case KBD_SUPER:
					mods |= CADET_ALLUP_SUPER;
					break;
				default:
					printf("kbd (cadet): unknown bucky key: 0%o\n", x11_modifier_map[modifier]);
					break;
				}
			}
		}
	}
	XFreeModifiermap(modmap);
	/*

#elif WITH_SDL2
bool
cadet_allup_key(void)
{
	bool allup;
	int mods;
	int shifts;
	
	int statesize;
	Uint8 *state;
	
	allup = true;
	mods = 0;
	shifts = 0;
	
	state = SDL_GetKeyboardState(&statesize);
	for (int i = 0; allup && i < statesize; i++) {
		int bucky;
		
		if (state[i] != 1)
			continue;
		bucky = sdl2_modifier_map[i];
		printf("cadet_allup_key() - bucky pressed (%d), i = %d\n", bucky, i);
		switch (bucky) {
		case KBD_SHIFT:
			mods |= CADET_ALLUP_SHIFT;
			shifts |= (1 << CADET_IX_SHIFT);
			break;
		case KBD_TOP:

		case KBD_HYPER:
			mods |= CADET_ALLUP_HYPER;
			break;
		case KBD_SUPER:
			mods |= CADET_ALLUP_SUPER;
			break;
		default:
			printf("kbd (cadet): unknown bucky key: 0%o\n", sdl2_modifier_map[i]);
			/* Hack: ignore modifier key which isn't bound */
//			if (i >= SDLK_NUMLOCK && i <= SDLK_COMPOSE)
//				break;
			allup = false;
			break;
		}
	}
	if (allup == true) {
		printf("cadet_allup_key() - all-up event; mods = 0%o, shifts = 0%o\n", mods, shifts);
		cadet_shifts = shifts;	
		cadet_allup_event(mods);
	}
	return allup;
}
#endif

static void

	}
}

void
cadet_process_key(
	int keysym,	  /* keysym, acts as index into kbd_map */
	int bi,		  /* bucky, acts as index into modifier_map */
	int keydown,
	int *kbd_map,
	int *modifier_map
	)
{
	int lmchar;		/* Lisp Machine charachter to insert */
	int scc;		/* Space Cadet scancode. */
	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);

#define X(lmch, scc, wantshift)						\
	cadet_kbd_map[LMCH_##lmch][0] = scc; cadet_kbd_map[LMCH_##lmch][1] = wantshift;
#include "cadet.defs"
	/* Hacks... */
#if 0
	X(LMCH_bracketleft, 0166, CADET_IX_UNSHIFT);
	X(LMCH_bracketright, 0146, CADET_IX_UNSHIFT); 
	X(LMCH_braceleft, 0132, CADET_IX_SHIFT);
	X(LMCH_braceright, 0137, CADET_IX_SHIFT); 
#endif
	
#undef X
}

#pragma once

#if WITH_X11
#include "x11.h"
#elif WITH_SDL1
#include "sdl1.h"
#endif

extern void cadet_init(void);
extern void cadet_process_key(int, int, int, int *, int *);

extern void cadet_queue_all_keys_up(void);

#define KEY_QUEUE_LEN 10

static int key_queue[KEY_QUEUE_LEN];
static int key_queue_optr;
static int key_queue_iptr;
static int key_queue_free = KEY_QUEUE_LEN;









void
kbd_queue_key_event(int ev)
{
	int v;

	v = (1 << 16) | ev;

{
	for (int i = 0; lmchar_map[i].name; i++) {
		if (streq(key, lmchar_map[i].name) == true)
			return lmchar_map[i].lmchar;
	}
	return LMCH_NoSymbol;
}




void








































































































































































kbd_init(void)
{

	if (kbd_type == 0)
		knight_init();
	else
		cadet_init();
}

#define KBD_ALT_LOCK	8
#define KBD_HYPER	9
#define KBD_SUPER	10

extern int kbd_type;
extern uint32_t kbd_scancode;






extern void kbd_init(void);
extern void kbd_event(int, int);

extern void kbd_queue_key_event(int);
extern void kbd_dequeue_key_event(void);

extern void kbd_warm_boot_key(void);

extern int kbd_lmchar(const char *);

	default:
		WARNING(TRACE_KBD, "kbd (knight): unknown bucky key: 0%o\n", k);
		break;
	}
}

void
knight_process_key(int keysym, int bi, int keydown, int *kbd_map, int *modifier_map)
{
	int kc;			/* Knight scancode. */
	int lmchar;		/* Lisp machine character to insert */

	DEBUG(TRACE_KBD, "knight_process_key() - keysym = 0%o, bi = %d\n", keysym, bi);
	if (bi != -1) {
		DEBUG(TRACE_KBD, "knight_process_key() - bucky short-circuit\n");

#pragma once

#if WITH_X11
#include "x11.h"
#elif WITH_SDL1
#include "sdl1.h"
#endif

extern void knight_init(void);
extern void knight_process_key(int, int, int, int *, int *);

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

SDL_Surface *screen;

/*
 * 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;

	u_minh = 0x7fffffff;
	u_maxh = 0;
	u_minv = 0x7fffffff;
	u_maxv = 0;
}

static
void sdl1_cleanup(void) 
{
	SDL_Quit();
}

/*
 * Returns the X11 modifier index of KEYCODE, or -1 if not found.
 */

 * 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();
	kbd_dequeue_key_event();
	while (SDL_PollEvent(ev)) {
		switch (ev->type) {
		case SDL_VIDEOEXPOSE:
			SDL_UpdateRect(screen, 0, 0, screen->w, screen->h);
			break;

		case SDL_MOUSEBUTTONUP: {
			int x;
			int y;
			int dx, dy;
			int buttons;
			int state;

			buttons = 0;			
			state = SDL_GetRelativeMouseState(&dx, &dy);
			if (state & SDL_BUTTON(SDL_BUTTON_LEFT))
				buttons = 1; 	/* Tail */
			if (state & SDL_BUTTON(SDL_BUTTON_MIDDLE))
				buttons = 2;	/* Middle */
			if (state & SDL_BUTTON(SDL_BUTTON_RIGHT))
				buttons = 3;	/* Head */
			state = SDL_GetMouseState(&x, &y);
			mouse_event(x, y, buttons);
			break;
		}
		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;

//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
	
	/* *INDENT-OFF* */
	/*
	 * Initialize keyboard modifiers
	 */

//	sdl1_modifier_map[ShiftMapIndex] = KBD_SHIFT;
//	sdl1_modifier_map[LockMapIndex] = KBD_SHIFT_LOCK;
//	sdl1_modifier_map[ControlMapIndex] = KBD_CONTROL;
//	sdl1_modifier_map[Mod1MapIndex] = KBD_META;
//	sdl1_modifier_map[Mod2MapIndex] = KBD_NoSymbol;
//	sdl1_modifier_map[Mod3MapIndex] = KBD_NoSymbol;
//	sdl1_modifier_map[Mod4MapIndex] = KBD_TOP;
//	sdl1_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 SDL1.
	 */

	/* Function keys */

	/*
	 * LispM "Escape" is actually Terminal, but in Zmacs this is more
	 * useful.
	 */
	sdl1_kbd_map[SDLK_ESCAPE] = LMCH_altmode;

	sdl1_kbd_map[SDLK_F1] = LMCH_system;
	sdl1_kbd_map[SDLK_F2] = LMCH_network;
	sdl1_kbd_map[SDLK_F3] = LMCH_status;
	sdl1_kbd_map[SDLK_F4] = LMCH_terminal;
	sdl1_kbd_map[SDLK_F5] = LMCH_help;
	sdl1_kbd_map[SDLK_F6] = LMCH_clear;
	sdl1_kbd_map[SDLK_F7] = LMCH_break;

	sdl1_kbd_map[SDLK_PAGEUP] = LMCH_abort;
	sdl1_kbd_map[SDLK_PAGEDOWN] = LMCH_resume;
	sdl1_kbd_map[SDLK_HOME] = LMCH_break;	/* This is really handy next to the others */
	sdl1_kbd_map[SDLK_END] = LMCH_end;

	/* This is natural */
	sdl1_kbd_map[SDLK_LEFT] = LMCH_hand_left;
	sdl1_kbd_map[SDLK_RIGHT] = LMCH_hand_right;
	sdl1_kbd_map[SDLK_UP] = LMCH_hand_up;
	sdl1_kbd_map[SDLK_DOWN] = LMCH_hand_down;

	/* 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;

	sdl1_kbd_map[SDLK_TAB] = LMCH_tab;
	sdl1_kbd_map[SDLK_q] = LMCH_q;
	sdl1_kbd_map[SDLK_w] = LMCH_w;
	sdl1_kbd_map[SDLK_e] = LMCH_e;
	sdl1_kbd_map[SDLK_r] = LMCH_r;
	sdl1_kbd_map[SDLK_t] = LMCH_t;
	sdl1_kbd_map[SDLK_y] = LMCH_y;
	sdl1_kbd_map[SDLK_u] = LMCH_u;
	sdl1_kbd_map[SDLK_i] = LMCH_i;
	sdl1_kbd_map[SDLK_o] = LMCH_o;
	sdl1_kbd_map[SDLK_p] = LMCH_p;
	sdl1_kbd_map[SDLK_LEFTBRACKET] = LMCH_bracketleft;
	sdl1_kbd_map[SDLK_RIGHTBRACKET] = LMCH_bracketright;
	sdl1_kbd_map[SDLK_BACKSLASH] = LMCH_backslash;
	sdl1_kbd_map[SDLK_BACKSPACE] = LMCH_rubout;

	sdl1_kbd_map[SDLK_a] = LMCH_a;
	sdl1_kbd_map[SDLK_s] = LMCH_s;
	sdl1_kbd_map[SDLK_d] = LMCH_d;
	sdl1_kbd_map[SDLK_f] = LMCH_f;
	sdl1_kbd_map[SDLK_g] = LMCH_g;
	sdl1_kbd_map[SDLK_h] = LMCH_h;
	sdl1_kbd_map[SDLK_j] = LMCH_j;
	sdl1_kbd_map[SDLK_k] = LMCH_k;
	sdl1_kbd_map[SDLK_l] = LMCH_l;
	sdl1_kbd_map[SDLK_SEMICOLON] = LMCH_semicolon;
	sdl1_kbd_map[SDLK_QUOTE] = LMCH_apostrophe;
	sdl1_kbd_map[SDLK_RETURN] = LMCH_cr;

	sdl1_kbd_map[SDLK_z] = LMCH_z;
	sdl1_kbd_map[SDLK_x] = LMCH_x;
	sdl1_kbd_map[SDLK_c] = LMCH_c;
	sdl1_kbd_map[SDLK_v] = LMCH_v;
	sdl1_kbd_map[SDLK_b] = LMCH_b;
	sdl1_kbd_map[SDLK_n] = LMCH_n;
	sdl1_kbd_map[SDLK_m] = LMCH_m;
	sdl1_kbd_map[SDLK_COMMA] = LMCH_comma;
	sdl1_kbd_map[SDLK_PERIOD] = LMCH_period;
	sdl1_kbd_map[SDLK_SLASH] = LMCH_slash;

	/* Shifted */
//	sdl1_kbd_map[SDLK_asciitilde] = LMCH_asciitilde;
	sdl1_kbd_map[SDLK_EXCLAIM] = LMCH_exclam;
	sdl1_kbd_map[SDLK_AT] = LMCH_at;
//	sdl1_kbd_map[SDLK_numbersign] = LMCH_numbersign;
//	sdl1_kbd_map[SDLK_dollar] = LMCH_dollar;
//	sdl1_kbd_map[SDLK_percent] = LMCH_percent;
//	sdl1_kbd_map[SDLK_asciicircum] = LMCH_asciicircum;
//	sdl1_kbd_map[SDLK_ampersand] = LMCH_ampersand;
//	sdl1_kbd_map[SDLK_asterisk] = LMCH_asterisk;
	sdl1_kbd_map[SDLK_LEFTPAREN] = LMCH_parenleft;
	sdl1_kbd_map[SDLK_RIGHTPAREN] = LMCH_parenright;
	sdl1_kbd_map[SDLK_UNDERSCORE] = LMCH_underscore;
	sdl1_kbd_map[SDLK_PLUS] = LMCH_plus;

//	sdl1_kbd_map[SDLK_Q] = LMCH_Q;
//	sdl1_kbd_map[SDLK_W] = LMCH_W;
//	sdl1_kbd_map[SDLK_E] = LMCH_E;
//	sdl1_kbd_map[SDLK_R] = LMCH_R;
//	sdl1_kbd_map[SDLK_T] = LMCH_T;
//	sdl1_kbd_map[SDLK_Y] = LMCH_Y;
//	sdl1_kbd_map[SDLK_U] = LMCH_U;
//	sdl1_kbd_map[SDLK_I] = LMCH_I;
//	sdl1_kbd_map[SDLK_O] = LMCH_O;
//	sdl1_kbd_map[SDLK_P] = LMCH_P;
//	sdl1_kbd_map[SDLK_braceleft] = LMCH_braceleft;
//	sdl1_kbd_map[SDLK_braceright] = LMCH_braceright;
//	sdl1_kbd_map[SDLK_bar] = LMCH_bar;

//	sdl1_kbd_map[SDLK_A] = LMCH_A;
//	sdl1_kbd_map[SDLK_S] = LMCH_S;
//	sdl1_kbd_map[SDLK_D] = LMCH_D;
//	sdl1_kbd_map[SDLK_F] = LMCH_F;
//	sdl1_kbd_map[SDLK_G] = LMCH_G;
//	sdl1_kbd_map[SDLK_H] = LMCH_H;
//	sdl1_kbd_map[SDLK_J] = LMCH_J;
//	sdl1_kbd_map[SDLK_K] = LMCH_K;
//	sdl1_kbd_map[SDLK_L] = LMCH_L;
//	sdl1_kbd_map[SDLK_colon] = LMCH_colon;
//	sdl1_kbd_map[SDLK_quotedbl] = LMCH_quotedbl;

//	sdl1_kbd_map[SDLK_Z] = LMCH_Z;
//	sdl1_kbd_map[SDLK_X] = LMCH_X;
//	sdl1_kbd_map[SDLK_C] = LMCH_C;
//	sdl1_kbd_map[SDLK_V] = LMCH_V;
//	sdl1_kbd_map[SDLK_B] = LMCH_B;
//	sdl1_kbd_map[SDLK_N] = LMCH_N;
//	sdl1_kbd_map[SDLK_M] = LMCH_M;
//	sdl1_kbd_map[SDLK_less] = LMCH_less;
//	sdl1_kbd_map[SDLK_greater] = LMCH_greater;
//	sdl1_kbd_map[SDLK_question] = LMCH_question;

	sdl1_kbd_map[SDLK_SPACE] = LMCH_space;
	/* *INDENT-ON* */
}

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

	Foreground = 0xff; // White
	Background = 0x00; // Black

	if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_NOPARACHUTE)) { 
		fprintf(stderr, "SDL_Init(): %s", SDL_GetError());
		exit(1);
	}
	/*
	 * We still want Ctrl-C to work - undo the SDL redirections.
	 */
	signal(SIGINT, SIG_DFL);

#pragma once

#include <SDL.h>

extern void sdl1_init(void);
extern void sdl1_default_kbd_map(void);
extern void sdl1_event(void);

extern unsigned long Background;
extern unsigned long Foreground;

extern void accumulate_update(int, int, int, int);

SDL_Surface *screen;

#define XK_greater                       0x003e  /* U+003E GREATER-THAN SIGN */
#define XK_question                      0x003f  /* U+003F QUESTION MARK */


SDL_Window *window;
SDL_Renderer *renderer;
SDL_Texture *texture;

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

unsigned long Background;

}

static void
process_key(SDL_KeyboardEvent e, int keydown)
{
//	KeySym keysym;
//	SDLKey keycode;
	
	int bi;
	int keysym;

	
	idle_keyboard_activity();
	
//	keycode = SDL_KeysymToKeycode(e->keysym.sym);
//if (event->key.code == key) ...
	
//	XLookupString(&e->xkey, (char *)buf, sizeof(buf), &keysym, &status);
//	keycode = sdl2_keysym_to_keycode(keysym);
//	if (keycode == NoSymbol || keysym > NELEM(sdl2_kbd_map)) {
//		NOTICE(TRACE_USIM, "kbd (cadet): unable to translate to sdl2 keycode (keysym = 0%o)\n", keysym);
//		return;
//	}
	
	if (kbd_type == 0) {
		if (!keydown)
			return;
		bi = 0;
//		if (e->xkey.state & ShiftMask)
//			knight_process_bucky(sdl2_modifier_map[ShiftMapIndex], &bi);
//		if (e->xkey.state & LockMask)
//			knight_process_bucky(sdl2_modifier_map[LockMapIndex], &bi);
//		if (e->xkey.state & ControlMask)
//			knight_process_bucky(sdl2_modifier_map[ControlMapIndex], &bi);
//		if (e->xkey.state & Mod1Mask)
//			knight_process_bucky(sdl2_modifier_map[Mod1MapIndex], &bi);
//		if (e->xkey.state & Mod2Mask)
//			knight_process_bucky(sdl2_modifier_map[Mod2MapIndex], &bi);
//		if (e->xkey.state & Mod3Mask)
//			knight_process_bucky(sdl2_modifier_map[Mod3MapIndex], &bi);
//		if (e->xkey.state & Mod4Mask)
//			knight_process_bucky(sdl2_modifier_map[Mod4MapIndex], &bi);
//		if (e->xkey.state & Mod5Mask)
//			knight_process_bucky(sdl2_modifier_map[Mod5MapIndex], &bi);
		knight_process_key(e.keysym.sym, bi, keydown, sdl2_kbd_map, sdl2_modifier_map);
	} else {
		bi = sdl2_bucky(e.keysym.mod);
		keysym = sdl2_keysym_to_xk(e);
		printf("bi = %d, keysym=%c -- 0%o (%c)\n", bi,keysym,keysym,keydown?'d':'u');
		if (keysym == 0xffffff) return;
		cadet_process_key(keysym, bi, keydown, sdl2_kbd_map, sdl2_modifier_map);
	}

}

void
sdl2_event(void)
{
	SDL_Event ev;
	
	send_accumulated_updates();
	kbd_dequeue_key_event();
	SDL_StartTextInput();



	while (SDL_PollEvent(&ev)) {
		switch (ev.type) {
		case SDL_WINDOWEVENT:
			SDL_UpdateTexture(texture, NULL, tv_bitmap, tv_width * sizeof (Uint32));
			// flush
			SDL_RenderClear(renderer);
			SDL_RenderCopy(renderer, texture, NULL, NULL);
			SDL_RenderPresent(renderer);
			break;
		case SDL_KEYDOWN:
			process_key(ev.key, 1);
			break;
		case SDL_KEYUP:
			process_key(ev.key, 0);
			break;
		case SDL_MOUSEMOTION:
		case SDL_MOUSEBUTTONDOWN:
		case SDL_MOUSEBUTTONUP:

			mouse_event(ev.button.x, ev.button.y, ev.button.button);
			break;
		case SDL_QUIT:
			exit(0);
			break;
		}
	}
}

void
sdl2_default_kbd_map(void)
{
	for (int i = 0; i < (int) NELEM(sdl2_kbd_map); i++)
		sdl2_kbd_map[i] = LMCH_NoSymbol;
	for (int i = 0; i < (int) NELEM(sdl2_modifier_map); i++)
		sdl2_modifier_map[i] = KBD_NoSymbol;

	/* *INDENT-OFF* */
	/*
	 * Initialize keyboard modifiers
	 */

	sdl2_modifier_map[ShiftMapIndex] = KBD_SHIFT;
	sdl2_modifier_map[LockMapIndex] = KBD_SHIFT_LOCK;
	sdl2_modifier_map[ControlMapIndex] = KBD_CONTROL;
	sdl2_modifier_map[Mod1MapIndex] = KBD_META;
	sdl2_modifier_map[Mod2MapIndex] = KBD_NoSymbol;
	sdl2_modifier_map[Mod3MapIndex] = KBD_NoSymbol;
	sdl2_modifier_map[Mod4MapIndex] = KBD_TOP;
	sdl2_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.
	 */

	/* Function keys */

	/*
	 * LispM "Escape" is actually Terminal, but in Zmacs this is more
	 * useful.
	 */
	sdl2_kbd_map[XK_Escape] = LMCH_altmode;

	sdl2_kbd_map[XK_F1] = LMCH_system;
	sdl2_kbd_map[XK_F2] = LMCH_network;
	sdl2_kbd_map[XK_F3] = LMCH_status;
	sdl2_kbd_map[XK_F4] = LMCH_terminal;
	sdl2_kbd_map[XK_F5] = LMCH_help;
	sdl2_kbd_map[XK_F6] = LMCH_clear;
	sdl2_kbd_map[XK_F7] = LMCH_break;

	sdl2_kbd_map[XK_Page_Up] = LMCH_abort;
	sdl2_kbd_map[XK_Page_Down] = LMCH_resume;
	sdl2_kbd_map[XK_Home] = LMCH_break;	/* This is really handy next to the others */
	sdl2_kbd_map[XK_End] = LMCH_end;

	/* This is natural */
	sdl2_kbd_map[XK_Left] = LMCH_hand_left;
	sdl2_kbd_map[XK_Right] = LMCH_hand_right;
	sdl2_kbd_map[XK_Up] = LMCH_hand_up;
	sdl2_kbd_map[XK_Down] = LMCH_hand_down;

	/* Unshifted */
	sdl2_kbd_map[XK_grave] = LMCH_grave;
	sdl2_kbd_map[XK_1] = LMCH_1;
	sdl2_kbd_map[XK_2] = LMCH_2;
	sdl2_kbd_map[XK_3] = LMCH_3;
	sdl2_kbd_map[XK_4] = LMCH_4;
	sdl2_kbd_map[XK_5] = LMCH_5;
	sdl2_kbd_map[XK_6] = LMCH_6;
	sdl2_kbd_map[XK_7] = LMCH_7;
	sdl2_kbd_map[XK_8] = LMCH_8;
	sdl2_kbd_map[XK_9] = LMCH_9;
	sdl2_kbd_map[XK_0] = LMCH_0;
	sdl2_kbd_map[XK_minus] = LMCH_minus;
	sdl2_kbd_map[XK_equal] = LMCH_equal;

	sdl2_kbd_map[XK_Tab] = LMCH_tab;
	sdl2_kbd_map[XK_q] = LMCH_q;
	sdl2_kbd_map[XK_w] = LMCH_w;
	sdl2_kbd_map[XK_e] = LMCH_e;
	sdl2_kbd_map[XK_r] = LMCH_r;
	sdl2_kbd_map[XK_t] = LMCH_t;
	sdl2_kbd_map[XK_y] = LMCH_y;
	sdl2_kbd_map[XK_u] = LMCH_u;
	sdl2_kbd_map[XK_i] = LMCH_i;
	sdl2_kbd_map[XK_o] = LMCH_o;
	sdl2_kbd_map[XK_p] = LMCH_p;
	sdl2_kbd_map[XK_bracketleft] = LMCH_bracketleft;
	sdl2_kbd_map[XK_bracketright] = LMCH_bracketright;
	sdl2_kbd_map[XK_backslash] = LMCH_backslash;
	sdl2_kbd_map[XK_BackSpace] = LMCH_rubout;

	sdl2_kbd_map[XK_a] = LMCH_a;
	sdl2_kbd_map[XK_s] = LMCH_s;
	sdl2_kbd_map[XK_d] = LMCH_d;
	sdl2_kbd_map[XK_f] = LMCH_f;
	sdl2_kbd_map[XK_g] = LMCH_g;
	sdl2_kbd_map[XK_h] = LMCH_h;
	sdl2_kbd_map[XK_j] = LMCH_j;
	sdl2_kbd_map[XK_k] = LMCH_k;
	sdl2_kbd_map[XK_l] = LMCH_l;
	sdl2_kbd_map[XK_semicolon] = LMCH_semicolon;
	sdl2_kbd_map[XK_apostrophe] = LMCH_apostrophe;
	sdl2_kbd_map[XK_Return] = LMCH_cr;

	sdl2_kbd_map[XK_z] = LMCH_z;
	sdl2_kbd_map[XK_x] = LMCH_x;
	sdl2_kbd_map[XK_c] = LMCH_c;
	sdl2_kbd_map[XK_v] = LMCH_v;
	sdl2_kbd_map[XK_b] = LMCH_b;
	sdl2_kbd_map[XK_n] = LMCH_n;
	sdl2_kbd_map[XK_m] = LMCH_m;
	sdl2_kbd_map[XK_comma] = LMCH_comma;
	sdl2_kbd_map[XK_period] = LMCH_period;
	sdl2_kbd_map[XK_slash] = LMCH_slash;

	/* Shifted */
	sdl2_kbd_map[XK_asciitilde] = LMCH_asciitilde;
	sdl2_kbd_map[XK_exclam] = LMCH_exclam;
	sdl2_kbd_map[XK_at] = LMCH_at;
	sdl2_kbd_map[XK_numbersign] = LMCH_numbersign;
	sdl2_kbd_map[XK_dollar] = LMCH_dollar;
	sdl2_kbd_map[XK_percent] = LMCH_percent;
	sdl2_kbd_map[XK_asciicircum] = LMCH_asciicircum;
	sdl2_kbd_map[XK_ampersand] = LMCH_ampersand;
	sdl2_kbd_map[XK_asterisk] = LMCH_asterisk;
	sdl2_kbd_map[XK_parenleft] = LMCH_parenleft;
	sdl2_kbd_map[XK_parenright] = LMCH_parenright;
	sdl2_kbd_map[XK_underscore] = LMCH_underscore;
	sdl2_kbd_map[XK_plus] = LMCH_plus;

	sdl2_kbd_map[XK_Q] = LMCH_Q;
	sdl2_kbd_map[XK_W] = LMCH_W;
	sdl2_kbd_map[XK_E] = LMCH_E;
	sdl2_kbd_map[XK_R] = LMCH_R;
	sdl2_kbd_map[XK_T] = LMCH_T;
	sdl2_kbd_map[XK_Y] = LMCH_Y;
	sdl2_kbd_map[XK_U] = LMCH_U;
	sdl2_kbd_map[XK_I] = LMCH_I;
	sdl2_kbd_map[XK_O] = LMCH_O;
	sdl2_kbd_map[XK_P] = LMCH_P;
	sdl2_kbd_map[XK_braceleft] = LMCH_braceleft;
	sdl2_kbd_map[XK_braceright] = LMCH_braceright;
	sdl2_kbd_map[XK_bar] = LMCH_bar;

	sdl2_kbd_map[XK_A] = LMCH_A;
	sdl2_kbd_map[XK_S] = LMCH_S;
	sdl2_kbd_map[XK_D] = LMCH_D;
	sdl2_kbd_map[XK_F] = LMCH_F;
	sdl2_kbd_map[XK_G] = LMCH_G;
	sdl2_kbd_map[XK_H] = LMCH_H;
	sdl2_kbd_map[XK_J] = LMCH_J;
	sdl2_kbd_map[XK_K] = LMCH_K;
	sdl2_kbd_map[XK_L] = LMCH_L;
	sdl2_kbd_map[XK_colon] = LMCH_colon;
	sdl2_kbd_map[XK_quotedbl] = LMCH_quotedbl;

	sdl2_kbd_map[XK_Z] = LMCH_Z;
	sdl2_kbd_map[XK_X] = LMCH_X;
	sdl2_kbd_map[XK_C] = LMCH_C;
	sdl2_kbd_map[XK_V] = LMCH_V;
	sdl2_kbd_map[XK_B] = LMCH_B;
	sdl2_kbd_map[XK_N] = LMCH_N;
	sdl2_kbd_map[XK_M] = LMCH_M;
	sdl2_kbd_map[XK_less] = LMCH_less;
	sdl2_kbd_map[XK_greater] = LMCH_greater;
	sdl2_kbd_map[XK_question] = LMCH_question;

	sdl2_kbd_map[XK_space] = LMCH_space;
	/* *INDENT-ON* */
}

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

	Foreground = 0xffffff; // White
	Background = 0x000000; // Black

	SDL_CreateWindowAndRenderer(tv_width, tv_height, SDL_WINDOW_OPENGL, &window, &renderer);

	SDL_ShowCursor(0);	/* Invisible cursor. */

//	SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
//	SDL_RenderClear(renderer);
//	SDL_RenderPresent(renderer);

	SDL_SetHint(SDL_HINT_RENDER_SCALE_QUALITY, "linear");  // make the scaled rendering look smoother.
	SDL_RenderSetLogicalSize(renderer, tv_width, tv_height);

	texture = SDL_CreateTexture(renderer,
	    SDL_PIXELFORMAT_ARGB8888,
	    SDL_TEXTUREACCESS_STREAMING,
	    tv_width, tv_height);
}

#pragma once

#include <SDL2/SDL.h>

extern void sdl2_init(void);
extern void sdl2_default_kbd_map(void);
extern void sdl2_event(void);

extern unsigned long Background;
extern unsigned long Foreground;

extern void accumulate_update(int, int, int, int);

extern int sdl2_kbd_map[65535];
extern int sdl2_modifier_map[8];

	/*
	 * Change trace defaults; the default in trace.c is to be very
	 * very quiet.
	 */
	trace_level = LOG_NOTICE;
	trace_facilities = TRACE_USIM;
	trace_stream = stdout;	// stderr;

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

		 * ---!!! We don't differentiate between left/right on
		 * ---!!!   the Lisp Machine side.
		 */
		if (streq(value, "")) {
			warnx("value for %s is empty", name);
			return 1;
		}
		     if (streq(name, "Shift"))   x11_modifier_map[ShiftMapIndex]   = lmbucky(value);
		else if (streq(name, "Lock"))    x11_modifier_map[LockMapIndex]    = lmbucky(value);
		else if (streq(name, "Control")) x11_modifier_map[ControlMapIndex] = lmbucky(value);
		else if (streq(name, "Mod1"))    x11_modifier_map[Mod1MapIndex]    = lmbucky(value);
		else if (streq(name, "Mod2"))    x11_modifier_map[Mod2MapIndex]    = lmbucky(value);
		else if (streq(name, "Mod3"))    x11_modifier_map[Mod3MapIndex]    = lmbucky(value);
		else if (streq(name, "Mod4"))    x11_modifier_map[Mod4MapIndex]    = lmbucky(value);
		else if (streq(name, "Mod5"))    x11_modifier_map[Mod5MapIndex]    = lmbucky(value);
		else {
			warnx("unknown x11 modifier: %s", name);
			return 1;
		}
	}
#elif WITH_SDL1
#endif

			return 1;
		}
		lmchar = kbd_lmchar(value);
		if (lmchar == LMCH_NoSymbol) {
			warnx("unknown lisp machine character name: %s", value);
			return 1;
		}
		x11_kbd_map[xk] = lmchar;
	}
#elif WITH_SDL1
#endif

	if (streq(section, "idle") == true) {
		     if (streq(name, "cycles"))  read_integer_value(name, value, &idle_cycles);
		else if (streq(name, "quantum")) read_integer_value(name, value, &idle_quantum);

static GC idle_gc;
static XImage *ximage;
unsigned long Foreground;
unsigned long Background;
static int old_run_state;

bool x11_grab_keyboard;

/*
 * Translation map for the host keyboard to a corresponding Lisp
 * Machine character or modifier.
 */
int x11_kbd_map[65535];
int x11_modifier_map[8];

/* Wrappers and utlity functions for X11.
 */

int
x11_query_keymap(char k[32])
{

process_key(XEvent *e, int keydown)
{
	KeySym keysym;
	KeyCode keycode;
	static XComposeStatus status;
	int bi;
	unsigned char buf[5];
	
	idle_keyboard_activity();
	XLookupString(&e->xkey, (char *)buf, sizeof(buf), &keysym, &status);
	keycode = x11_keysym_to_keycode(keysym);
	if (keycode == NoSymbol || keysym > NELEM(x11_kbd_map)) {
		printf("kbd (cadet): unable to translate to x11 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(keysym, bi, keydown, x11_kbd_map, x11_modifier_map);
	} else {
		bi = x11_bucky(keycode);
		printf("bi = %d, keysym=%c -- 0%o (%c)\n", bi,keysym,keysym,keydown?'d':'u');
		cadet_process_key(keysym, bi, keydown, x11_kbd_map, x11_modifier_map);
	}
}

static int u_minh = 0x7fffffff;
static int u_maxh;
static int u_minv = 0x7fffffff;
static int u_maxv;

			break;
		}
	}
	if (old_run_state != !halted)
		old_run_state = !halted;
}

void
x11_default_kbd_map(void)
{
	for (int i = 0; i < (int) NELEM(x11_kbd_map); i++)
		x11_kbd_map[i] = LMCH_NoSymbol;
	for (int i = 0; i < (int) NELEM(x11_modifier_map); i++)
		x11_modifier_map[i] = KBD_NoSymbol;

	/* *INDENT-OFF* */
	/*
	 * Initialize keyboard modifiers
	 */

	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.
	 */

	/* Function keys */

	/*
	 * LispM "Escape" is actually Terminal, but in Zmacs this is more
	 * useful.
	 */
	x11_kbd_map[XK_Escape] = LMCH_altmode;

	x11_kbd_map[XK_F1] = LMCH_system;
	x11_kbd_map[XK_F2] = LMCH_network;
	x11_kbd_map[XK_F3] = LMCH_status;
	x11_kbd_map[XK_F4] = LMCH_terminal;
	x11_kbd_map[XK_F5] = LMCH_help;
	x11_kbd_map[XK_F6] = LMCH_clear;
	x11_kbd_map[XK_F7] = LMCH_break;

	x11_kbd_map[XK_Page_Up] = LMCH_abort;
	x11_kbd_map[XK_Page_Down] = LMCH_resume;
	x11_kbd_map[XK_Home] = LMCH_break;	/* This is really handy next to the others */
	x11_kbd_map[XK_End] = LMCH_end;

	/* This is natural */
	x11_kbd_map[XK_Left] = LMCH_hand_left;
	x11_kbd_map[XK_Right] = LMCH_hand_right;
	x11_kbd_map[XK_Up] = LMCH_hand_up;
	x11_kbd_map[XK_Down] = LMCH_hand_down;

	/* Unshifted */
	x11_kbd_map[XK_grave] = LMCH_grave;
	x11_kbd_map[XK_1] = LMCH_1;
	x11_kbd_map[XK_2] = LMCH_2;
	x11_kbd_map[XK_3] = LMCH_3;
	x11_kbd_map[XK_4] = LMCH_4;
	x11_kbd_map[XK_5] = LMCH_5;
	x11_kbd_map[XK_6] = LMCH_6;
	x11_kbd_map[XK_7] = LMCH_7;
	x11_kbd_map[XK_8] = LMCH_8;
	x11_kbd_map[XK_9] = LMCH_9;
	x11_kbd_map[XK_0] = LMCH_0;
	x11_kbd_map[XK_minus] = LMCH_minus;
	x11_kbd_map[XK_equal] = LMCH_equal;

	x11_kbd_map[XK_Tab] = LMCH_tab;
	x11_kbd_map[XK_q] = LMCH_q;
	x11_kbd_map[XK_w] = LMCH_w;
	x11_kbd_map[XK_e] = LMCH_e;
	x11_kbd_map[XK_r] = LMCH_r;
	x11_kbd_map[XK_t] = LMCH_t;
	x11_kbd_map[XK_y] = LMCH_y;
	x11_kbd_map[XK_u] = LMCH_u;
	x11_kbd_map[XK_i] = LMCH_i;
	x11_kbd_map[XK_o] = LMCH_o;
	x11_kbd_map[XK_p] = LMCH_p;
	x11_kbd_map[XK_bracketleft] = LMCH_bracketleft;
	x11_kbd_map[XK_bracketright] = LMCH_bracketright;
	x11_kbd_map[XK_backslash] = LMCH_backslash;
	x11_kbd_map[XK_BackSpace] = LMCH_rubout;

	x11_kbd_map[XK_a] = LMCH_a;
	x11_kbd_map[XK_s] = LMCH_s;
	x11_kbd_map[XK_d] = LMCH_d;
	x11_kbd_map[XK_f] = LMCH_f;
	x11_kbd_map[XK_g] = LMCH_g;
	x11_kbd_map[XK_h] = LMCH_h;
	x11_kbd_map[XK_j] = LMCH_j;
	x11_kbd_map[XK_k] = LMCH_k;
	x11_kbd_map[XK_l] = LMCH_l;
	x11_kbd_map[XK_semicolon] = LMCH_semicolon;
	x11_kbd_map[XK_apostrophe] = LMCH_apostrophe;
	x11_kbd_map[XK_Return] = LMCH_cr;

	x11_kbd_map[XK_z] = LMCH_z;
	x11_kbd_map[XK_x] = LMCH_x;
	x11_kbd_map[XK_c] = LMCH_c;
	x11_kbd_map[XK_v] = LMCH_v;
	x11_kbd_map[XK_b] = LMCH_b;
	x11_kbd_map[XK_n] = LMCH_n;
	x11_kbd_map[XK_m] = LMCH_m;
	x11_kbd_map[XK_comma] = LMCH_comma;
	x11_kbd_map[XK_period] = LMCH_period;
	x11_kbd_map[XK_slash] = LMCH_slash;

	/* Shifted */
	x11_kbd_map[XK_asciitilde] = LMCH_asciitilde;
	x11_kbd_map[XK_exclam] = LMCH_exclam;
	x11_kbd_map[XK_at] = LMCH_at;
	x11_kbd_map[XK_numbersign] = LMCH_numbersign;
	x11_kbd_map[XK_dollar] = LMCH_dollar;
	x11_kbd_map[XK_percent] = LMCH_percent;
	x11_kbd_map[XK_asciicircum] = LMCH_asciicircum;
	x11_kbd_map[XK_ampersand] = LMCH_ampersand;
	x11_kbd_map[XK_asterisk] = LMCH_asterisk;
	x11_kbd_map[XK_parenleft] = LMCH_parenleft;
	x11_kbd_map[XK_parenright] = LMCH_parenright;
	x11_kbd_map[XK_underscore] = LMCH_underscore;
	x11_kbd_map[XK_plus] = LMCH_plus;

	x11_kbd_map[XK_Q] = LMCH_Q;
	x11_kbd_map[XK_W] = LMCH_W;
	x11_kbd_map[XK_E] = LMCH_E;
	x11_kbd_map[XK_R] = LMCH_R;
	x11_kbd_map[XK_T] = LMCH_T;
	x11_kbd_map[XK_Y] = LMCH_Y;
	x11_kbd_map[XK_U] = LMCH_U;
	x11_kbd_map[XK_I] = LMCH_I;
	x11_kbd_map[XK_O] = LMCH_O;
	x11_kbd_map[XK_P] = LMCH_P;
	x11_kbd_map[XK_braceleft] = LMCH_braceleft;
	x11_kbd_map[XK_braceright] = LMCH_braceright;
	x11_kbd_map[XK_bar] = LMCH_bar;

	x11_kbd_map[XK_A] = LMCH_A;
	x11_kbd_map[XK_S] = LMCH_S;
	x11_kbd_map[XK_D] = LMCH_D;
	x11_kbd_map[XK_F] = LMCH_F;
	x11_kbd_map[XK_G] = LMCH_G;
	x11_kbd_map[XK_H] = LMCH_H;
	x11_kbd_map[XK_J] = LMCH_J;
	x11_kbd_map[XK_K] = LMCH_K;
	x11_kbd_map[XK_L] = LMCH_L;
	x11_kbd_map[XK_colon] = LMCH_colon;
	x11_kbd_map[XK_quotedbl] = LMCH_quotedbl;

	x11_kbd_map[XK_Z] = LMCH_Z;
	x11_kbd_map[XK_X] = LMCH_X;
	x11_kbd_map[XK_C] = LMCH_C;
	x11_kbd_map[XK_V] = LMCH_V;
	x11_kbd_map[XK_B] = LMCH_B;
	x11_kbd_map[XK_N] = LMCH_N;
	x11_kbd_map[XK_M] = LMCH_M;
	x11_kbd_map[XK_less] = LMCH_less;
	x11_kbd_map[XK_greater] = LMCH_greater;
	x11_kbd_map[XK_question] = LMCH_question;

	x11_kbd_map[XK_space] = LMCH_space;
	/* *INDENT-ON* */
}

void
x11_init(void)
{
	char *displayname;
	unsigned long bg_pixel;
	int xscreen;
	Window root;

#pragma once

#include <stdbool.h>

#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/keysym.h>

extern int x11_kbd_map[65535];
extern int x11_modifier_map[8];
extern bool x11_grab_keyboard;

extern int x11_query_keymap(char[32]);
extern KeyCode x11_keysym_to_keycode(KeySym);
extern XModifierKeymap *x11_get_modifier_mapping(void);
extern int x11_bucky(KeyCode);

extern void x11_init(void);
extern void x11_default_kbd_map(void);
extern void x11_event(void);

extern unsigned long Background;
extern unsigned long Foreground;

extern void accumulate_update(int, int, int, int);