[pcsx_rearmed.git] / frontend / linux / xenv.c

/*
 * (C) Gražvydas "notaz" Ignotas, 2009-2012
 *
 * This work is licensed under the terms of any of these licenses
 * (at your option):
 *  - GNU GPL, version 2 or later.
 *  - GNU LGPL, version 2.1 or later.
 * See the COPYING file in the top-level directory.
 */

#include <stdio.h>
#include <string.h>
#include <pthread.h>

#include <dlfcn.h>
#include <X11/Xlib.h>
#include <X11/Xutil.h>
#include <X11/XKBlib.h>

#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <termios.h>
#include <linux/kd.h>

#define PFX "xenv: "

#define FPTR(f) typeof(f) * p##f
#define FPTR_LINK(xf, dl, f) { \
	xf.p##f = dlsym(dl, #f); \
	if (xf.p##f == NULL) { \
		fprintf(stderr, "missing symbol: %s\n", #f); \
		goto fail; \
	} \
}

struct xstuff {
	Display *display;
	Window window;
	FPTR(XCreateBitmapFromData);
	FPTR(XCreatePixmapCursor);
	FPTR(XFreePixmap);
	FPTR(XOpenDisplay);
	FPTR(XDisplayName);
	FPTR(XCloseDisplay);
	FPTR(XCreateSimpleWindow);
	FPTR(XChangeWindowAttributes);
	FPTR(XSelectInput);
	FPTR(XMapWindow);
	FPTR(XNextEvent);
	FPTR(XCheckTypedEvent);
	FPTR(XWithdrawWindow);
	FPTR(XGrabKeyboard);
	FPTR(XPending);
	FPTR(XLookupKeysym);
	FPTR(XkbSetDetectableAutoRepeat);
	FPTR(XStoreName);
	FPTR(XIconifyWindow);
	FPTR(XMoveResizeWindow);
	FPTR(XInternAtom);
	FPTR(XSetWMHints);
	FPTR(XSync);
};

static struct xstuff g_xstuff;

static Cursor transparent_cursor(struct xstuff *xf, Display *display, Window win)
{
	Cursor cursor;
	Pixmap pix;
	XColor dummy;
	char d = 0;

	memset(&dummy, 0, sizeof(dummy));
	pix = xf->pXCreateBitmapFromData(display, win, &d, 1, 1);
	cursor = xf->pXCreatePixmapCursor(display, pix, pix,
			&dummy, &dummy, 0, 0);
	xf->pXFreePixmap(display, pix);
	return cursor;
}

static int x11h_init(const char *window_title)
{
	unsigned int display_width, display_height;
	Display *display;
	XSetWindowAttributes attributes;
	Window win;
	Visual *visual;
	void *x11lib;
	int screen;

	memset(&g_xstuff, 0, sizeof(g_xstuff));
	x11lib = dlopen("libX11.so.6", RTLD_LAZY);
	if (x11lib == NULL) {
		fprintf(stderr, "libX11.so load failed:\n%s\n", dlerror());
		goto fail;
	}
	FPTR_LINK(g_xstuff, x11lib, XCreateBitmapFromData);
	FPTR_LINK(g_xstuff, x11lib, XCreatePixmapCursor);
	FPTR_LINK(g_xstuff, x11lib, XFreePixmap);
	FPTR_LINK(g_xstuff, x11lib, XOpenDisplay);
	FPTR_LINK(g_xstuff, x11lib, XDisplayName);
	FPTR_LINK(g_xstuff, x11lib, XCloseDisplay);
	FPTR_LINK(g_xstuff, x11lib, XCreateSimpleWindow);
	FPTR_LINK(g_xstuff, x11lib, XChangeWindowAttributes);
	FPTR_LINK(g_xstuff, x11lib, XSelectInput);
	FPTR_LINK(g_xstuff, x11lib, XMapWindow);
	FPTR_LINK(g_xstuff, x11lib, XNextEvent);
	FPTR_LINK(g_xstuff, x11lib, XCheckTypedEvent);
	FPTR_LINK(g_xstuff, x11lib, XWithdrawWindow);
	FPTR_LINK(g_xstuff, x11lib, XGrabKeyboard);
	FPTR_LINK(g_xstuff, x11lib, XPending);
	FPTR_LINK(g_xstuff, x11lib, XLookupKeysym);
	FPTR_LINK(g_xstuff, x11lib, XkbSetDetectableAutoRepeat);
	FPTR_LINK(g_xstuff, x11lib, XStoreName);
	FPTR_LINK(g_xstuff, x11lib, XIconifyWindow);
	FPTR_LINK(g_xstuff, x11lib, XMoveResizeWindow);
	FPTR_LINK(g_xstuff, x11lib, XInternAtom);
	FPTR_LINK(g_xstuff, x11lib, XSetWMHints);
	FPTR_LINK(g_xstuff, x11lib, XSync);

	//XInitThreads();

	g_xstuff.display = display = g_xstuff.pXOpenDisplay(NULL);
	if (display == NULL)
	{
		fprintf(stderr, "cannot connect to X server %s, X handling disabled.\n",
				g_xstuff.pXDisplayName(NULL));
		goto fail2;
	}

	visual = DefaultVisual(display, 0);
	if (visual->class != TrueColor)
		fprintf(stderr, PFX "warning: non true color visual\n");

	printf(PFX "X vendor: %s, rel: %d, display: %s, protocol ver: %d.%d\n", ServerVendor(display),
		VendorRelease(display), DisplayString(display), ProtocolVersion(display),
		ProtocolRevision(display));

	screen = DefaultScreen(display);

	display_width = DisplayWidth(display, screen);
	display_height = DisplayHeight(display, screen);
	printf(PFX "display is %dx%d\n", display_width, display_height);

	g_xstuff.window = win = g_xstuff.pXCreateSimpleWindow(display,
		RootWindow(display, screen), 0, 0, display_width, display_height,
		0, BlackPixel(display, screen), BlackPixel(display, screen));

	attributes.override_redirect = True;
	attributes.cursor = transparent_cursor(&g_xstuff, display, win);
	g_xstuff.pXChangeWindowAttributes(display, win, CWOverrideRedirect | CWCursor, &attributes);

	g_xstuff.pXStoreName(display, win, window_title);
	g_xstuff.pXSelectInput(display, win,
		ExposureMask | FocusChangeMask | KeyPressMask | KeyReleaseMask | PropertyChangeMask);
	g_xstuff.pXMapWindow(display, win);
	g_xstuff.pXGrabKeyboard(display, win, False, GrabModeAsync, GrabModeAsync, CurrentTime);
	g_xstuff.pXkbSetDetectableAutoRepeat(display, 1, NULL);
	// XSetIOErrorHandler

	// we don't know when event dispatch will be called, so sync now
	g_xstuff.pXSync(display, False);

	return 0;
fail2:
	dlclose(x11lib);
fail:
	g_xstuff.display = NULL;
	fprintf(stderr, "x11 handling disabled.\n");
	return -1;
}

static int x11h_update(int *is_down)
{
	XEvent evt;

	while (g_xstuff.pXPending(g_xstuff.display))
	{
		g_xstuff.pXNextEvent(g_xstuff.display, &evt);
		switch (evt.type)
		{
			case Expose:
				while (g_xstuff.pXCheckTypedEvent(g_xstuff.display, Expose, &evt))
					;
			default:
				// printf("event %d\n", evt.type);
				break;

			case KeyPress:
				*is_down = 1;
				return g_xstuff.pXLookupKeysym(&evt.xkey, 0);

			case KeyRelease:
				*is_down = 0;
				return g_xstuff.pXLookupKeysym(&evt.xkey, 0);
				// printf("press %d\n", evt.xkey.keycode);
		}
	}

	return NoSymbol;
}

static void x11h_wait_vmstate(void)
{
	Atom wm_state = g_xstuff.pXInternAtom(g_xstuff.display, "WM_STATE", False);
	XEvent evt;
	int i;

	usleep(20000);

	for (i = 0; i < 20; i++) {
		while (g_xstuff.pXPending(g_xstuff.display)) {
			g_xstuff.pXNextEvent(g_xstuff.display, &evt);
			// printf("w event %d\n", evt.type);
			if (evt.type == PropertyNotify && evt.xproperty.atom == wm_state)
				return;
		}
		usleep(200000);
	}

	printf("timeout waiting for wm_state change\n");
}

static int x11h_minimize(void)
{
	XSetWindowAttributes attributes;
	Display *display = g_xstuff.display;
	Window window = g_xstuff.window;
	int screen = DefaultScreen(g_xstuff.display);
	int display_width, display_height;
	XWMHints wm_hints;
	XEvent evt;

	g_xstuff.pXWithdrawWindow(display, window, screen);

	attributes.override_redirect = False;
	g_xstuff.pXChangeWindowAttributes(display, window,
		CWOverrideRedirect, &attributes);

	wm_hints.flags = StateHint;
	wm_hints.initial_state = IconicState;
	g_xstuff.pXSetWMHints(display, window, &wm_hints);

	g_xstuff.pXMapWindow(display, window);

	while (g_xstuff.pXNextEvent(display, &evt) == 0)
	{
		// printf("m event %d\n", evt.type);
		switch (evt.type)
		{
			case FocusIn:
				goto out;
			default:
				break;
		}
	}

out:
	g_xstuff.pXWithdrawWindow(display, window, screen);

	// must wait for some magic vmstate property change before setting override_redirect
	x11h_wait_vmstate();

	attributes.override_redirect = True;
	g_xstuff.pXChangeWindowAttributes(display, window,
		CWOverrideRedirect, &attributes);

	// fixup window after resize on override_redirect loss
	display_width = DisplayWidth(display, screen);
	display_height = DisplayHeight(display, screen);
	g_xstuff.pXMoveResizeWindow(display, window, 0, 0, display_width, display_height);

	g_xstuff.pXMapWindow(display, window);
	g_xstuff.pXGrabKeyboard(display, window, False, GrabModeAsync, GrabModeAsync, CurrentTime);
	g_xstuff.pXkbSetDetectableAutoRepeat(display, 1, NULL);

	// we don't know when event dispatch will be called, so sync now
	g_xstuff.pXSync(display, False);

	return 0;
}

static struct termios g_kbd_termios_saved;
static int g_kbdfd = -1;

static int tty_init(void)
{
	struct termios kbd_termios;
	int mode;

	g_kbdfd = open("/dev/tty", O_RDWR);
	if (g_kbdfd == -1) {
		perror(PFX "open /dev/tty");
		return -1;
	}

	if (ioctl(g_kbdfd, KDGETMODE, &mode) == -1) {
		perror(PFX "(not hiding FB): KDGETMODE");
		goto fail;
	}

	if (tcgetattr(g_kbdfd, &kbd_termios) == -1) {
		perror(PFX "tcgetattr");
		goto fail;
	}

	g_kbd_termios_saved = kbd_termios;
	kbd_termios.c_lflag &= ~(ICANON | ECHO); // | ISIG);
	kbd_termios.c_iflag &= ~(ISTRIP | IGNCR | ICRNL | INLCR | IXOFF | IXON);
	kbd_termios.c_cc[VMIN] = 0;
	kbd_termios.c_cc[VTIME] = 0;

	if (tcsetattr(g_kbdfd, TCSAFLUSH, &kbd_termios) == -1) {
		perror(PFX "tcsetattr");
		goto fail;
	}

	if (ioctl(g_kbdfd, KDSETMODE, KD_GRAPHICS) == -1) {
		perror(PFX "KDSETMODE KD_GRAPHICS");
		tcsetattr(g_kbdfd, TCSAFLUSH, &g_kbd_termios_saved);
		goto fail;
	}

	return 0;

fail:
	close(g_kbdfd);
	g_kbdfd = -1;
	return -1;
}

static void tty_end(void)
{
	if (g_kbdfd < 0)
		return;

	if (ioctl(g_kbdfd, KDSETMODE, KD_TEXT) == -1)
		perror(PFX "KDSETMODE KD_TEXT");

	if (tcsetattr(g_kbdfd, TCSAFLUSH, &g_kbd_termios_saved) == -1)
		perror(PFX "tcsetattr");

	close(g_kbdfd);
	g_kbdfd = -1;
}

int xenv_init(const char *window_title)
{
	int ret;

	ret = x11h_init(window_title);
	if (ret == 0)
		return 0;

	ret = tty_init();
	if (ret == 0)
		return 0;

	fprintf(stderr, PFX "error: both x11h_init and tty_init failed\n");
	return -1;
}

int xenv_update(int *is_down)
{
	if (g_xstuff.display)
		return x11h_update(is_down);

	// TODO: read tty?
	return -1;
}

/* blocking minimize until user maximazes again */
int xenv_minimize(void)
{
	int ret, dummy;

	if (g_xstuff.display) {
		xenv_update(&dummy);
		ret = x11h_minimize();
		xenv_update(&dummy);
		return ret;
	}

	return -1;
}

void xenv_finish(void)
{
	// TODO: cleanup X?
	tty_end();
}

#if 0
int main()
{
	int i, r, d;

	xenv_init("just a test");

	for (i = 0; i < 5; i++) {
		while ((r = xenv_update(&d)) > 0)
			printf("%d %x %d\n", d, r, r);
		sleep(1);

		if (i == 1)
			xenv_minimize();
		printf("ll %d\n", i);
	}

	printf("xenv_finish..\n");
	xenv_finish();

	return 0;
}
#endif
Commit	Line	Data
698517be	1	/*
a805c855	2	* (C) Gražvydas "notaz" Ignotas, 2009-2012
698517be	3	*
	4	* This work is licensed under the terms of any of these licenses
	5	* (at your option):
	6	* - GNU GPL, version 2 or later.
	7	* - GNU LGPL, version 2.1 or later.
	8	* See the COPYING file in the top-level directory.
	9	*/
	10
	11	#include <stdio.h>
	12	#include <string.h>
	13	#include <pthread.h>
	14
	15	#include <dlfcn.h>
	16	#include <X11/Xlib.h>
	17	#include <X11/Xutil.h>
0b49a8f7	18	#include <X11/XKBlib.h>
698517be	19
	20	#include <sys/types.h>
	21	#include <sys/stat.h>
	22	#include <fcntl.h>
	23	#include <unistd.h>
	24	#include <sys/ioctl.h>
	25	#include <termios.h>
	26	#include <linux/kd.h>
	27
0b49a8f7	28	#define PFX "xenv: "
698517be	29
	30	#define FPTR(f) typeof(f) * p##f
	31	#define FPTR_LINK(xf, dl, f) { \
	32	xf.p##f = dlsym(dl, #f); \
	33	if (xf.p##f == NULL) { \
	34	fprintf(stderr, "missing symbol: %s\n", #f); \
	35	goto fail; \
	36	} \
	37	}
	38
0b49a8f7	39	struct xstuff {
0b49a8f7	40	Display *display;
a805c855	41	Window window;
0b49a8f7	42	FPTR(XCreateBitmapFromData);
	43	FPTR(XCreatePixmapCursor);
	44	FPTR(XFreePixmap);
	45	FPTR(XOpenDisplay);
	46	FPTR(XDisplayName);
	47	FPTR(XCloseDisplay);
	48	FPTR(XCreateSimpleWindow);
	49	FPTR(XChangeWindowAttributes);
	50	FPTR(XSelectInput);
	51	FPTR(XMapWindow);
	52	FPTR(XNextEvent);
	53	FPTR(XCheckTypedEvent);
a805c855	54	FPTR(XWithdrawWindow);
0b49a8f7	55	FPTR(XGrabKeyboard);
	56	FPTR(XPending);
	57	FPTR(XLookupKeysym);
	58	FPTR(XkbSetDetectableAutoRepeat);
a805c855	59	FPTR(XStoreName);
	60	FPTR(XIconifyWindow);
	61	FPTR(XMoveResizeWindow);
	62	FPTR(XInternAtom);
	63	FPTR(XSetWMHints);
	64	FPTR(XSync);
698517be	65	};
698517be	66
0b49a8f7	67	static struct xstuff g_xstuff;
698517be	68
0b49a8f7	69	static Cursor transparent_cursor(struct xstuff xf, Display display, Window win)
698517be	70	{
	71	Cursor cursor;
	72	Pixmap pix;
	73	XColor dummy;
	74	char d = 0;
	75
	76	memset(&dummy, 0, sizeof(dummy));
	77	pix = xf->pXCreateBitmapFromData(display, win, &d, 1, 1);
	78	cursor = xf->pXCreatePixmapCursor(display, pix, pix,
	79	&dummy, &dummy, 0, 0);
	80	xf->pXFreePixmap(display, pix);
	81	return cursor;
	82	}
	83
a805c855	84	static int x11h_init(const char *window_title)
698517be	85	{
698517be	86	unsigned int display_width, display_height;
0b49a8f7	87	Display *display;
698517be	88	XSetWindowAttributes attributes;
698517be	89	Window win;
698517be	90	Visual *visual;
	91	void *x11lib;
	92	int screen;
	93
0b49a8f7	94	memset(&g_xstuff, 0, sizeof(g_xstuff));
698517be	95	x11lib = dlopen("libX11.so.6", RTLD_LAZY);
	96	if (x11lib == NULL) {
	97	fprintf(stderr, "libX11.so load failed:\n%s\n", dlerror());
	98	goto fail;
	99	}
0b49a8f7	100	FPTR_LINK(g_xstuff, x11lib, XCreateBitmapFromData);
	101	FPTR_LINK(g_xstuff, x11lib, XCreatePixmapCursor);
	102	FPTR_LINK(g_xstuff, x11lib, XFreePixmap);
	103	FPTR_LINK(g_xstuff, x11lib, XOpenDisplay);
	104	FPTR_LINK(g_xstuff, x11lib, XDisplayName);
	105	FPTR_LINK(g_xstuff, x11lib, XCloseDisplay);
	106	FPTR_LINK(g_xstuff, x11lib, XCreateSimpleWindow);
	107	FPTR_LINK(g_xstuff, x11lib, XChangeWindowAttributes);
	108	FPTR_LINK(g_xstuff, x11lib, XSelectInput);
	109	FPTR_LINK(g_xstuff, x11lib, XMapWindow);
	110	FPTR_LINK(g_xstuff, x11lib, XNextEvent);
	111	FPTR_LINK(g_xstuff, x11lib, XCheckTypedEvent);
a805c855	112	FPTR_LINK(g_xstuff, x11lib, XWithdrawWindow);
0b49a8f7	113	FPTR_LINK(g_xstuff, x11lib, XGrabKeyboard);
	114	FPTR_LINK(g_xstuff, x11lib, XPending);
	115	FPTR_LINK(g_xstuff, x11lib, XLookupKeysym);
	116	FPTR_LINK(g_xstuff, x11lib, XkbSetDetectableAutoRepeat);
a805c855	117	FPTR_LINK(g_xstuff, x11lib, XStoreName);
	118	FPTR_LINK(g_xstuff, x11lib, XIconifyWindow);
	119	FPTR_LINK(g_xstuff, x11lib, XMoveResizeWindow);
	120	FPTR_LINK(g_xstuff, x11lib, XInternAtom);
	121	FPTR_LINK(g_xstuff, x11lib, XSetWMHints);
	122	FPTR_LINK(g_xstuff, x11lib, XSync);
698517be	123
	124	//XInitThreads();
	125
0b49a8f7	126	g_xstuff.display = display = g_xstuff.pXOpenDisplay(NULL);
698517be	127	if (display == NULL)
	128	{
	129	fprintf(stderr, "cannot connect to X server %s, X handling disabled.\n",
0b49a8f7	130	g_xstuff.pXDisplayName(NULL));
698517be	131	goto fail2;
	132	}
	133
	134	visual = DefaultVisual(display, 0);
	135	if (visual->class != TrueColor)
	136	fprintf(stderr, PFX "warning: non true color visual\n");
	137
	138	printf(PFX "X vendor: %s, rel: %d, display: %s, protocol ver: %d.%d\n", ServerVendor(display),
	139	VendorRelease(display), DisplayString(display), ProtocolVersion(display),
	140	ProtocolRevision(display));
	141
	142	screen = DefaultScreen(display);
	143
	144	display_width = DisplayWidth(display, screen);
	145	display_height = DisplayHeight(display, screen);
	146	printf(PFX "display is %dx%d\n", display_width, display_height);
	147
a805c855	148	g_xstuff.window = win = g_xstuff.pXCreateSimpleWindow(display,
	149	RootWindow(display, screen), 0, 0, display_width, display_height,
	150	0, BlackPixel(display, screen), BlackPixel(display, screen));
698517be	151
698517be	152	attributes.override_redirect = True;
0b49a8f7	153	attributes.cursor = transparent_cursor(&g_xstuff, display, win);
0b49a8f7	154	g_xstuff.pXChangeWindowAttributes(display, win, CWOverrideRedirect \| CWCursor, &attributes);
698517be	155
a805c855	156	g_xstuff.pXStoreName(display, win, window_title);
	157	g_xstuff.pXSelectInput(display, win,
	158	ExposureMask \| FocusChangeMask \| KeyPressMask \| KeyReleaseMask \| PropertyChangeMask);
0b49a8f7	159	g_xstuff.pXMapWindow(display, win);
	160	g_xstuff.pXGrabKeyboard(display, win, False, GrabModeAsync, GrabModeAsync, CurrentTime);
	161	g_xstuff.pXkbSetDetectableAutoRepeat(display, 1, NULL);
698517be	162	// XSetIOErrorHandler
698517be	163
a805c855	164	// we don't know when event dispatch will be called, so sync now
	165	g_xstuff.pXSync(display, False);
	166
0b49a8f7	167	return 0;
	168	fail2:
	169	dlclose(x11lib);
	170	fail:
	171	g_xstuff.display = NULL;
	172	fprintf(stderr, "x11 handling disabled.\n");
	173	return -1;
	174	}
	175
	176	static int x11h_update(int *is_down)
	177	{
	178	XEvent evt;
	179
	180	while (g_xstuff.pXPending(g_xstuff.display))
698517be	181	{
0b49a8f7	182	g_xstuff.pXNextEvent(g_xstuff.display, &evt);
0b49a8f7	183	switch (evt.type)
698517be	184	{
698517be	185	case Expose:
0b49a8f7	186	while (g_xstuff.pXCheckTypedEvent(g_xstuff.display, Expose, &evt))
698517be	187	;
a805c855	188	default:
a805c855	189	// printf("event %d\n", evt.type);
698517be	190	break;
698517be	191
698517be	192	case KeyPress:
0b49a8f7	193	*is_down = 1;
0b49a8f7	194	return g_xstuff.pXLookupKeysym(&evt.xkey, 0);
698517be	195
0b49a8f7	196	case KeyRelease:
	197	*is_down = 0;
	198	return g_xstuff.pXLookupKeysym(&evt.xkey, 0);
	199	// printf("press %d\n", evt.xkey.keycode);
698517be	200	}
	201	}
	202
0b49a8f7	203	return NoSymbol;
698517be	204	}
698517be	205
a805c855	206	static void x11h_wait_vmstate(void)
	207	{
	208	Atom wm_state = g_xstuff.pXInternAtom(g_xstuff.display, "WM_STATE", False);
	209	XEvent evt;
	210	int i;
	211
	212	usleep(20000);
	213
	214	for (i = 0; i < 20; i++) {
	215	while (g_xstuff.pXPending(g_xstuff.display)) {
	216	g_xstuff.pXNextEvent(g_xstuff.display, &evt);
	217	// printf("w event %d\n", evt.type);
	218	if (evt.type == PropertyNotify && evt.xproperty.atom == wm_state)
	219	return;
	220	}
	221	usleep(200000);
	222	}
	223
	224	printf("timeout waiting for wm_state change\n");
	225	}
	226
	227	static int x11h_minimize(void)
	228	{
	229	XSetWindowAttributes attributes;
	230	Display *display = g_xstuff.display;
	231	Window window = g_xstuff.window;
	232	int screen = DefaultScreen(g_xstuff.display);
	233	int display_width, display_height;
	234	XWMHints wm_hints;
	235	XEvent evt;
	236
	237	g_xstuff.pXWithdrawWindow(display, window, screen);
	238
	239	attributes.override_redirect = False;
	240	g_xstuff.pXChangeWindowAttributes(display, window,
	241	CWOverrideRedirect, &attributes);
	242
	243	wm_hints.flags = StateHint;
	244	wm_hints.initial_state = IconicState;
	245	g_xstuff.pXSetWMHints(display, window, &wm_hints);
	246
	247	g_xstuff.pXMapWindow(display, window);
	248
	249	while (g_xstuff.pXNextEvent(display, &evt) == 0)
	250	{
	251	// printf("m event %d\n", evt.type);
	252	switch (evt.type)
	253	{
	254	case FocusIn:
	255	goto out;
	256	default:
	257	break;
	258	}
	259	}
	260
	261	out:
	262	g_xstuff.pXWithdrawWindow(display, window, screen);
	263
	264	// must wait for some magic vmstate property change before setting override_redirect
	265	x11h_wait_vmstate();
	266
	267	attributes.override_redirect = True;
	268	g_xstuff.pXChangeWindowAttributes(display, window,
	269	CWOverrideRedirect, &attributes);
270
271	// fixup window after resize on override_redirect loss
272	display_width = DisplayWidth(display, screen);
273	display_height = DisplayHeight(display, screen);
274	g_xstuff.pXMoveResizeWindow(display, window, 0, 0, display_width, display_height);
275
276	g_xstuff.pXMapWindow(display, window);
277	g_xstuff.pXGrabKeyboard(display, window, False, GrabModeAsync, GrabModeAsync, CurrentTime);
278	g_xstuff.pXkbSetDetectableAutoRepeat(display, 1, NULL);
279
280	// we don't know when event dispatch will be called, so sync now
281	g_xstuff.pXSync(display, False);
282
283	return 0;
284	}
285
698517be	286	static struct termios g_kbd_termios_saved;
0b49a8f7	287	static int g_kbdfd = -1;
698517be	288
0b49a8f7	289	static int tty_init(void)
698517be	290	{
	291	struct termios kbd_termios;
	292	int mode;
	293
	294	g_kbdfd = open("/dev/tty", O_RDWR);
	295	if (g_kbdfd == -1) {
	296	perror(PFX "open /dev/tty");
0b49a8f7	297	return -1;
698517be	298	}
	299
	300	if (ioctl(g_kbdfd, KDGETMODE, &mode) == -1) {
	301	perror(PFX "(not hiding FB): KDGETMODE");
	302	goto fail;
	303	}
	304
	305	if (tcgetattr(g_kbdfd, &kbd_termios) == -1) {
	306	perror(PFX "tcgetattr");
	307	goto fail;
	308	}
	309
	310	g_kbd_termios_saved = kbd_termios;
	311	kbd_termios.c_lflag &= ~(ICANON \| ECHO); // \| ISIG);
	312	kbd_termios.c_iflag &= ~(ISTRIP \| IGNCR \| ICRNL \| INLCR \| IXOFF \| IXON);
	313	kbd_termios.c_cc[VMIN] = 0;
	314	kbd_termios.c_cc[VTIME] = 0;
	315
	316	if (tcsetattr(g_kbdfd, TCSAFLUSH, &kbd_termios) == -1) {
	317	perror(PFX "tcsetattr");
	318	goto fail;
	319	}
	320
	321	if (ioctl(g_kbdfd, KDSETMODE, KD_GRAPHICS) == -1) {
	322	perror(PFX "KDSETMODE KD_GRAPHICS");
	323	tcsetattr(g_kbdfd, TCSAFLUSH, &g_kbd_termios_saved);
	324	goto fail;
	325	}
	326
0b49a8f7	327	return 0;
698517be	328
	329	fail:
	330	close(g_kbdfd);
	331	g_kbdfd = -1;
0b49a8f7	332	return -1;
698517be	333	}
698517be	334
0b49a8f7	335	static void tty_end(void)
698517be	336	{
	337	if (g_kbdfd < 0)
	338	return;
	339
	340	if (ioctl(g_kbdfd, KDSETMODE, KD_TEXT) == -1)
	341	perror(PFX "KDSETMODE KD_TEXT");
	342
	343	if (tcsetattr(g_kbdfd, TCSAFLUSH, &g_kbd_termios_saved) == -1)
	344	perror(PFX "tcsetattr");
	345
	346	close(g_kbdfd);
	347	g_kbdfd = -1;
	348	}
	349
a805c855	350	int xenv_init(const char *window_title)
698517be	351	{
698517be	352	int ret;
698517be	353
a805c855	354	ret = x11h_init(window_title);
0b49a8f7	355	if (ret == 0)
0b49a8f7	356	return 0;
698517be	357
0b49a8f7	358	ret = tty_init();
	359	if (ret == 0)
	360	return 0;
698517be	361
0b49a8f7	362	fprintf(stderr, PFX "error: both x11h_init and tty_init failed\n");
0b49a8f7	363	return -1;
698517be	364	}
698517be	365
0b49a8f7	366	int xenv_update(int *is_down)
698517be	367	{
0b49a8f7	368	if (g_xstuff.display)
0b49a8f7	369	return x11h_update(is_down);
698517be	370
0b49a8f7	371	// TODO: read tty?
0b49a8f7	372	return -1;
698517be	373	}
698517be	374
a805c855	375	/* blocking minimize until user maximazes again */
	376	int xenv_minimize(void)
	377	{
	378	int ret, dummy;
	379
	380	if (g_xstuff.display) {
	381	xenv_update(&dummy);
	382	ret = x11h_minimize();
	383	xenv_update(&dummy);
	384	return ret;
	385	}
	386
	387	return -1;
	388	}
	389
0b49a8f7	390	void xenv_finish(void)
698517be	391	{
0b49a8f7	392	// TODO: cleanup X?
0b49a8f7	393	tty_end();
698517be	394	}
a805c855	395
	396	#if 0
	397	int main()
	398	{
	399	int i, r, d;
	400
	401	xenv_init("just a test");
	402
	403	for (i = 0; i < 5; i++) {
	404	while ((r = xenv_update(&d)) > 0)
	405	printf("%d %x %d\n", d, r, r);
	406	sleep(1);
	407
	408	if (i == 1)
	409	xenv_minimize();
	410	printf("ll %d\n", i);
	411	}
	412
	413	printf("xenv_finish..\n");
	414	xenv_finish();
	415
	416	return 0;
	417	}
	418	#endif