[sdl_omap.git] / src / video / omapdss / 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>

#include "xenv.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(XkbKeycodeToKeysym);
	FPTR(XStoreName);
	FPTR(XIconifyWindow);
	FPTR(XMoveResizeWindow);
	FPTR(XInternAtom);
	FPTR(XAllocWMHints);
	FPTR(XGetWMHints);
	FPTR(XSetWMHints);
	FPTR(XSync);
	FPTR(XFree);
};

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(int *xenv_flags, const char *window_title)
{
	unsigned int display_width, display_height;
	Display *display;
	XSetWindowAttributes attributes;
	Window win;
	Visual *visual;
	long evt_mask;
	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, XkbKeycodeToKeysym);
	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, XAllocWMHints);
	FPTR_LINK(g_xstuff, x11lib, XGetWMHints);
	FPTR_LINK(g_xstuff, x11lib, XSetWMHints);
	FPTR_LINK(g_xstuff, x11lib, XSync);
	FPTR_LINK(g_xstuff, x11lib, XFree);

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

	if (window_title != NULL)
		g_xstuff.pXStoreName(display, win, window_title);
	evt_mask = ExposureMask | FocusChangeMask | PropertyChangeMask;
	if (xenv_flags && (*xenv_flags & XENV_CAP_KEYS))
		evt_mask |= KeyPressMask | KeyReleaseMask;
	if (xenv_flags && (*xenv_flags & XENV_CAP_MOUSE))
		evt_mask |= ButtonPressMask | ButtonReleaseMask | PointerMotionMask;
	g_xstuff.pXSelectInput(display, win, evt_mask);
	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 void x11h_update(int (*key_cb)(void *cb_arg, int kc, int is_pressed),
			int (*mouseb_cb)(void *cb_arg, int x, int y, int button, int is_pressed),
			int (*mousem_cb)(void *cb_arg, int x, int y),
			void *cb_arg)
{
	XEvent evt;
	int keysym;

	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))
				;
			break;

		case KeyPress:
			keysym = g_xstuff.pXLookupKeysym(&evt.xkey, 0);
			if (key_cb != NULL)
				key_cb(cb_arg, keysym, 1);
			break;

		case KeyRelease:
			keysym = g_xstuff.pXLookupKeysym(&evt.xkey, 0);
			if (key_cb != NULL)
				key_cb(cb_arg, keysym, 0);
			break;

		case ButtonPress:
			if (mouseb_cb != NULL)
				mouseb_cb(cb_arg, evt.xbutton.x, evt.xbutton.y,
					  evt.xbutton.button, 1);
			break;

		case ButtonRelease:
			if (mouseb_cb != NULL)
				mouseb_cb(cb_arg, evt.xbutton.x, evt.xbutton.y,
					  evt.xbutton.button, 0);
			break;

		case MotionNotify:
			if (mousem_cb != NULL)
				mousem_cb(cb_arg, evt.xmotion.x, evt.xmotion.y);
			break;
		}
	}
}

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);
	}

	fprintf(stderr, PFX "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 = g_xstuff.pXGetWMHints(display, window);
	if (wm_hints == NULL) {
		wm_hints = XAllocWMHints();
		wm_hints->flags = 0;
	}
	wm_hints->flags |= StateHint;
	wm_hints->initial_state = IconicState;
	g_xstuff.pXSetWMHints(display, window, wm_hints);
	g_xstuff.pXFree(wm_hints);
	wm_hints = NULL;

	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(int *xenv_flags, const char *window_title)
{
	int ret;

	ret = x11h_init(xenv_flags, window_title);
	if (ret == 0)
		goto out;

	if (xenv_flags != NULL)
		*xenv_flags &= ~(XENV_CAP_KEYS | XENV_CAP_MOUSE); /* TODO? */
	ret = tty_init();
	if (ret == 0)
		goto out;

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

int xenv_update(int (*key_cb)(void *cb_arg, int kc, int is_pressed),
		int (*mouseb_cb)(void *cb_arg, int x, int y, int button, int is_pressed),
		int (*mousem_cb)(void *cb_arg, int x, int y),
		void *cb_arg)
{
	if (g_xstuff.display) {
		x11h_update(key_cb, mouseb_cb, mousem_cb, cb_arg);
		return 0;
	}

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

/* blocking minimize until user maximizes again */
int xenv_minimize(void)
{
	int ret;

	if (g_xstuff.display) {
		xenv_update(NULL, NULL, NULL, NULL);
		ret = x11h_minimize();
		xenv_update(NULL, NULL, NULL, NULL);
		return ret;
	}

	return -1;
}

int xenv_keycode_to_keysym(int kc, int shift)
{
	if (g_xstuff.display)
		return g_xstuff.pXkbKeycodeToKeysym(g_xstuff.display,
			kc, 0, shift);

	return -1;
}

int xenv_get_window(void **display, int *screen, void **window)
{
	*display = *window = NULL;
	*screen = 0;
	if (g_xstuff.display && g_xstuff.window) {
		*display = g_xstuff.display;
		*screen = DefaultScreen(g_xstuff.display);
		*window = (void *)g_xstuff.window;
		return 0;
	}

	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
83b5751b	1	/*
e1837b2c	2	* (C) Gražvydas "notaz" Ignotas, 2009-2012
83b5751b	3	*
f9b3f440	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.
83b5751b	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>
f9b3f440	18	#include <X11/XKBlib.h>
83b5751b	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
090bcb85	28	#include "xenv.h"
090bcb85	29
f9b3f440	30	#define PFX "xenv: "
83b5751b	31
	32	#define FPTR(f) typeof(f) * p##f
	33	#define FPTR_LINK(xf, dl, f) { \
	34	xf.p##f = dlsym(dl, #f); \
	35	if (xf.p##f == NULL) { \
	36	fprintf(stderr, "missing symbol: %s\n", #f); \
	37	goto fail; \
	38	} \
	39	}
	40
f9b3f440	41	struct xstuff {
f9b3f440	42	Display *display;
090bcb85	43	Window window;
f9b3f440	44	FPTR(XCreateBitmapFromData);
	45	FPTR(XCreatePixmapCursor);
	46	FPTR(XFreePixmap);
	47	FPTR(XOpenDisplay);
	48	FPTR(XDisplayName);
	49	FPTR(XCloseDisplay);
	50	FPTR(XCreateSimpleWindow);
	51	FPTR(XChangeWindowAttributes);
	52	FPTR(XSelectInput);
	53	FPTR(XMapWindow);
	54	FPTR(XNextEvent);
	55	FPTR(XCheckTypedEvent);
090bcb85	56	FPTR(XWithdrawWindow);
f9b3f440	57	FPTR(XGrabKeyboard);
	58	FPTR(XPending);
	59	FPTR(XLookupKeysym);
	60	FPTR(XkbSetDetectableAutoRepeat);
89df2746	61	FPTR(XkbKeycodeToKeysym);
090bcb85	62	FPTR(XStoreName);
	63	FPTR(XIconifyWindow);
	64	FPTR(XMoveResizeWindow);
	65	FPTR(XInternAtom);
7eac0547	66	FPTR(XAllocWMHints);
7eac0547	67	FPTR(XGetWMHints);
090bcb85	68	FPTR(XSetWMHints);
090bcb85	69	FPTR(XSync);
7eac0547	70	FPTR(XFree);
83b5751b	71	};
83b5751b	72
f9b3f440	73	static struct xstuff g_xstuff;
83b5751b	74
f9b3f440	75	static Cursor transparent_cursor(struct xstuff xf, Display display, Window win)
83b5751b	76	{
	77	Cursor cursor;
	78	Pixmap pix;
	79	XColor dummy;
	80	char d = 0;
	81
	82	memset(&dummy, 0, sizeof(dummy));
	83	pix = xf->pXCreateBitmapFromData(display, win, &d, 1, 1);
	84	cursor = xf->pXCreatePixmapCursor(display, pix, pix,
	85	&dummy, &dummy, 0, 0);
	86	xf->pXFreePixmap(display, pix);
	87	return cursor;
	88	}
	89
090bcb85	90	static int x11h_init(int xenv_flags, const char window_title)
83b5751b	91	{
83b5751b	92	unsigned int display_width, display_height;
f9b3f440	93	Display *display;
83b5751b	94	XSetWindowAttributes attributes;
83b5751b	95	Window win;
83b5751b	96	Visual *visual;
090bcb85	97	long evt_mask;
83b5751b	98	void *x11lib;
	99	int screen;
	100
f9b3f440	101	memset(&g_xstuff, 0, sizeof(g_xstuff));
83b5751b	102	x11lib = dlopen("libX11.so.6", RTLD_LAZY);
	103	if (x11lib == NULL) {
	104	fprintf(stderr, "libX11.so load failed:\n%s\n", dlerror());
	105	goto fail;
	106	}
f9b3f440	107	FPTR_LINK(g_xstuff, x11lib, XCreateBitmapFromData);
	108	FPTR_LINK(g_xstuff, x11lib, XCreatePixmapCursor);
	109	FPTR_LINK(g_xstuff, x11lib, XFreePixmap);
	110	FPTR_LINK(g_xstuff, x11lib, XOpenDisplay);
	111	FPTR_LINK(g_xstuff, x11lib, XDisplayName);
	112	FPTR_LINK(g_xstuff, x11lib, XCloseDisplay);
	113	FPTR_LINK(g_xstuff, x11lib, XCreateSimpleWindow);
	114	FPTR_LINK(g_xstuff, x11lib, XChangeWindowAttributes);
	115	FPTR_LINK(g_xstuff, x11lib, XSelectInput);
	116	FPTR_LINK(g_xstuff, x11lib, XMapWindow);
	117	FPTR_LINK(g_xstuff, x11lib, XNextEvent);
	118	FPTR_LINK(g_xstuff, x11lib, XCheckTypedEvent);
090bcb85	119	FPTR_LINK(g_xstuff, x11lib, XWithdrawWindow);
f9b3f440	120	FPTR_LINK(g_xstuff, x11lib, XGrabKeyboard);
	121	FPTR_LINK(g_xstuff, x11lib, XPending);
	122	FPTR_LINK(g_xstuff, x11lib, XLookupKeysym);
	123	FPTR_LINK(g_xstuff, x11lib, XkbSetDetectableAutoRepeat);
89df2746	124	FPTR_LINK(g_xstuff, x11lib, XkbKeycodeToKeysym);
090bcb85	125	FPTR_LINK(g_xstuff, x11lib, XStoreName);
	126	FPTR_LINK(g_xstuff, x11lib, XIconifyWindow);
	127	FPTR_LINK(g_xstuff, x11lib, XMoveResizeWindow);
	128	FPTR_LINK(g_xstuff, x11lib, XInternAtom);
7eac0547	129	FPTR_LINK(g_xstuff, x11lib, XAllocWMHints);
7eac0547	130	FPTR_LINK(g_xstuff, x11lib, XGetWMHints);
090bcb85	131	FPTR_LINK(g_xstuff, x11lib, XSetWMHints);
090bcb85	132	FPTR_LINK(g_xstuff, x11lib, XSync);
7eac0547	133	FPTR_LINK(g_xstuff, x11lib, XFree);
83b5751b	134
	135	//XInitThreads();
	136
f9b3f440	137	g_xstuff.display = display = g_xstuff.pXOpenDisplay(NULL);
83b5751b	138	if (display == NULL)
	139	{
	140	fprintf(stderr, "cannot connect to X server %s, X handling disabled.\n",
f9b3f440	141	g_xstuff.pXDisplayName(NULL));
83b5751b	142	goto fail2;
	143	}
	144
	145	visual = DefaultVisual(display, 0);
	146	if (visual->class != TrueColor)
	147	fprintf(stderr, PFX "warning: non true color visual\n");
	148
	149	printf(PFX "X vendor: %s, rel: %d, display: %s, protocol ver: %d.%d\n", ServerVendor(display),
	150	VendorRelease(display), DisplayString(display), ProtocolVersion(display),
	151	ProtocolRevision(display));
	152
	153	screen = DefaultScreen(display);
	154
	155	display_width = DisplayWidth(display, screen);
	156	display_height = DisplayHeight(display, screen);
	157	printf(PFX "display is %dx%d\n", display_width, display_height);
	158
090bcb85	159	g_xstuff.window = win = g_xstuff.pXCreateSimpleWindow(display,
	160	RootWindow(display, screen), 0, 0, display_width, display_height,
	161	0, BlackPixel(display, screen), BlackPixel(display, screen));
83b5751b	162
83b5751b	163	attributes.override_redirect = True;
f9b3f440	164	attributes.cursor = transparent_cursor(&g_xstuff, display, win);
f9b3f440	165	g_xstuff.pXChangeWindowAttributes(display, win, CWOverrideRedirect \| CWCursor, &attributes);
83b5751b	166
090bcb85	167	if (window_title != NULL)
	168	g_xstuff.pXStoreName(display, win, window_title);
	169	evt_mask = ExposureMask \| FocusChangeMask \| PropertyChangeMask;
	170	if (xenv_flags && (*xenv_flags & XENV_CAP_KEYS))
	171	evt_mask \|= KeyPressMask \| KeyReleaseMask;
	172	if (xenv_flags && (*xenv_flags & XENV_CAP_MOUSE))
	173	evt_mask \|= ButtonPressMask \| ButtonReleaseMask \| PointerMotionMask;
	174	g_xstuff.pXSelectInput(display, win, evt_mask);
f9b3f440	175	g_xstuff.pXMapWindow(display, win);
	176	g_xstuff.pXGrabKeyboard(display, win, False, GrabModeAsync, GrabModeAsync, CurrentTime);
	177	g_xstuff.pXkbSetDetectableAutoRepeat(display, 1, NULL);
83b5751b	178	// XSetIOErrorHandler
83b5751b	179
090bcb85	180	// we don't know when event dispatch will be called, so sync now
	181	g_xstuff.pXSync(display, False);
	182
f9b3f440	183	return 0;
	184	fail2:
	185	dlclose(x11lib);
	186	fail:
	187	g_xstuff.display = NULL;
	188	fprintf(stderr, "x11 handling disabled.\n");
	189	return -1;
	190	}
	191
e1837b2c	192	static void x11h_update(int (key_cb)(void cb_arg, int kc, int is_pressed),
	193	int (mouseb_cb)(void cb_arg, int x, int y, int button, int is_pressed),
	194	int (mousem_cb)(void cb_arg, int x, int y),
	195	void *cb_arg)
f9b3f440	196	{
f9b3f440	197	XEvent evt;
e1837b2c	198	int keysym;
f9b3f440	199
f9b3f440	200	while (g_xstuff.pXPending(g_xstuff.display))
83b5751b	201	{
f9b3f440	202	g_xstuff.pXNextEvent(g_xstuff.display, &evt);
f9b3f440	203	switch (evt.type)
83b5751b	204	{
e1837b2c	205	case Expose:
	206	while (g_xstuff.pXCheckTypedEvent(g_xstuff.display, Expose, &evt))
	207	;
	208	break;
	209
	210	case KeyPress:
	211	keysym = g_xstuff.pXLookupKeysym(&evt.xkey, 0);
	212	if (key_cb != NULL)
	213	key_cb(cb_arg, keysym, 1);
	214	break;
	215
	216	case KeyRelease:
	217	keysym = g_xstuff.pXLookupKeysym(&evt.xkey, 0);
	218	if (key_cb != NULL)
	219	key_cb(cb_arg, keysym, 0);
	220	break;
	221
	222	case ButtonPress:
	223	if (mouseb_cb != NULL)
	224	mouseb_cb(cb_arg, evt.xbutton.x, evt.xbutton.y,
	225	evt.xbutton.button, 1);
	226	break;
	227
	228	case ButtonRelease:
	229	if (mouseb_cb != NULL)
	230	mouseb_cb(cb_arg, evt.xbutton.x, evt.xbutton.y,
	231	evt.xbutton.button, 0);
	232	break;
	233
	234	case MotionNotify:
	235	if (mousem_cb != NULL)
	236	mousem_cb(cb_arg, evt.xmotion.x, evt.xmotion.y);
	237	break;
83b5751b	238	}
83b5751b	239	}
83b5751b	240	}
83b5751b	241
090bcb85	242	static void x11h_wait_vmstate(void)
	243	{
	244	Atom wm_state = g_xstuff.pXInternAtom(g_xstuff.display, "WM_STATE", False);
	245	XEvent evt;
	246	int i;
	247
	248	usleep(20000);
	249
	250	for (i = 0; i < 20; i++) {
	251	while (g_xstuff.pXPending(g_xstuff.display)) {
	252	g_xstuff.pXNextEvent(g_xstuff.display, &evt);
	253	// printf("w event %d\n", evt.type);
	254	if (evt.type == PropertyNotify && evt.xproperty.atom == wm_state)
	255	return;
	256	}
	257	usleep(200000);
	258	}
	259
	260	fprintf(stderr, PFX "timeout waiting for wm_state change\n");
	261	}
	262
	263	static int x11h_minimize(void)
	264	{
	265	XSetWindowAttributes attributes;
	266	Display *display = g_xstuff.display;
	267	Window window = g_xstuff.window;
	268	int screen = DefaultScreen(g_xstuff.display);
	269	int display_width, display_height;
7eac0547	270	XWMHints *wm_hints;
090bcb85	271	XEvent evt;
	272
	273	g_xstuff.pXWithdrawWindow(display, window, screen);
	274
	275	attributes.override_redirect = False;
	276	g_xstuff.pXChangeWindowAttributes(display, window,
	277	CWOverrideRedirect, &attributes);
	278
7eac0547	279	wm_hints = g_xstuff.pXGetWMHints(display, window);
	280	if (wm_hints == NULL) {
	281	wm_hints = XAllocWMHints();
	282	wm_hints->flags = 0;
	283	}
	284	wm_hints->flags \|= StateHint;
	285	wm_hints->initial_state = IconicState;
	286	g_xstuff.pXSetWMHints(display, window, wm_hints);
	287	g_xstuff.pXFree(wm_hints);
	288	wm_hints = NULL;
090bcb85	289
	290	g_xstuff.pXMapWindow(display, window);
	291
	292	while (g_xstuff.pXNextEvent(display, &evt) == 0)
	293	{
	294	// printf("m event %d\n", evt.type);
	295	switch (evt.type)
	296	{
	297	case FocusIn:
	298	goto out;
	299	default:
	300	break;
	301	}
	302	}
	303
	304	out:
	305	g_xstuff.pXWithdrawWindow(display, window, screen);
	306
	307	// must wait for some magic vmstate property change before setting override_redirect
	308	x11h_wait_vmstate();
	309
	310	attributes.override_redirect = True;
	311	g_xstuff.pXChangeWindowAttributes(display, window,
	312	CWOverrideRedirect, &attributes);
	313
	314	// fixup window after resize on override_redirect loss
	315	display_width = DisplayWidth(display, screen);
	316	display_height = DisplayHeight(display, screen);
	317	g_xstuff.pXMoveResizeWindow(display, window, 0, 0, display_width, display_height);
	318
	319	g_xstuff.pXMapWindow(display, window);
	320	g_xstuff.pXGrabKeyboard(display, window, False, GrabModeAsync, GrabModeAsync, CurrentTime);
	321	g_xstuff.pXkbSetDetectableAutoRepeat(display, 1, NULL);
	322
	323	// we don't know when event dispatch will be called, so sync now
	324	g_xstuff.pXSync(display, False);
	325
	326	return 0;
	327	}
	328
83b5751b	329	static struct termios g_kbd_termios_saved;
f9b3f440	330	static int g_kbdfd = -1;
83b5751b	331
f9b3f440	332	static int tty_init(void)
83b5751b	333	{
	334	struct termios kbd_termios;
	335	int mode;
	336
	337	g_kbdfd = open("/dev/tty", O_RDWR);
	338	if (g_kbdfd == -1) {
	339	perror(PFX "open /dev/tty");
f9b3f440	340	return -1;
83b5751b	341	}
	342
	343	if (ioctl(g_kbdfd, KDGETMODE, &mode) == -1) {
	344	perror(PFX "(not hiding FB): KDGETMODE");
	345	goto fail;
	346	}
	347
	348	if (tcgetattr(g_kbdfd, &kbd_termios) == -1) {
	349	perror(PFX "tcgetattr");
	350	goto fail;
	351	}
	352
	353	g_kbd_termios_saved = kbd_termios;
	354	kbd_termios.c_lflag &= ~(ICANON \| ECHO); // \| ISIG);
	355	kbd_termios.c_iflag &= ~(ISTRIP \| IGNCR \| ICRNL \| INLCR \| IXOFF \| IXON);
	356	kbd_termios.c_cc[VMIN] = 0;
	357	kbd_termios.c_cc[VTIME] = 0;
	358
	359	if (tcsetattr(g_kbdfd, TCSAFLUSH, &kbd_termios) == -1) {
	360	perror(PFX "tcsetattr");
	361	goto fail;
	362	}
	363
	364	if (ioctl(g_kbdfd, KDSETMODE, KD_GRAPHICS) == -1) {
	365	perror(PFX "KDSETMODE KD_GRAPHICS");
	366	tcsetattr(g_kbdfd, TCSAFLUSH, &g_kbd_termios_saved);
	367	goto fail;
	368	}
	369
f9b3f440	370	return 0;
83b5751b	371
	372	fail:
	373	close(g_kbdfd);
	374	g_kbdfd = -1;
f9b3f440	375	return -1;
83b5751b	376	}
83b5751b	377
f9b3f440	378	static void tty_end(void)
83b5751b	379	{
	380	if (g_kbdfd < 0)
	381	return;
	382
	383	if (ioctl(g_kbdfd, KDSETMODE, KD_TEXT) == -1)
	384	perror(PFX "KDSETMODE KD_TEXT");
	385
	386	if (tcsetattr(g_kbdfd, TCSAFLUSH, &g_kbd_termios_saved) == -1)
	387	perror(PFX "tcsetattr");
	388
	389	close(g_kbdfd);
	390	g_kbdfd = -1;
	391	}
	392
090bcb85	393	int xenv_init(int xenv_flags, const char window_title)
83b5751b	394	{
83b5751b	395	int ret;
83b5751b	396
090bcb85	397	ret = x11h_init(xenv_flags, window_title);
090bcb85	398	if (ret == 0)
e1837b2c	399	goto out;
83b5751b	400
090bcb85	401	if (xenv_flags != NULL)
090bcb85	402	xenv_flags &= ~(XENV_CAP_KEYS \| XENV_CAP_MOUSE); / TODO? */
f9b3f440	403	ret = tty_init();
f9b3f440	404	if (ret == 0)
e1837b2c	405	goto out;
83b5751b	406
f9b3f440	407	fprintf(stderr, PFX "error: both x11h_init and tty_init failed\n");
e1837b2c	408	ret = -1;
e1837b2c	409	out:
e1837b2c	410	return ret;
83b5751b	411	}
83b5751b	412
e1837b2c	413	int xenv_update(int (key_cb)(void cb_arg, int kc, int is_pressed),
	414	int (mouseb_cb)(void cb_arg, int x, int y, int button, int is_pressed),
	415	int (mousem_cb)(void cb_arg, int x, int y),
	416	void *cb_arg)
83b5751b	417	{
e1837b2c	418	if (g_xstuff.display) {
	419	x11h_update(key_cb, mouseb_cb, mousem_cb, cb_arg);
	420	return 0;
	421	}
83b5751b	422
f9b3f440	423	// TODO: read tty?
f9b3f440	424	return -1;
83b5751b	425	}
83b5751b	426
090bcb85	427	/* blocking minimize until user maximizes again */
	428	int xenv_minimize(void)
	429	{
	430	int ret;
	431
	432	if (g_xstuff.display) {
	433	xenv_update(NULL, NULL, NULL, NULL);
	434	ret = x11h_minimize();
	435	xenv_update(NULL, NULL, NULL, NULL);
	436	return ret;
	437	}
	438
	439	return -1;
	440	}
	441
89df2746	442	int xenv_keycode_to_keysym(int kc, int shift)
	443	{
	444	if (g_xstuff.display)
	445	return g_xstuff.pXkbKeycodeToKeysym(g_xstuff.display,
	446	kc, 0, shift);
	447
	448	return -1;
	449	}
	450
ee7e6b2d	451	int xenv_get_window(void *display, int screen, void **window)
	452	{
	453	display = window = NULL;
	454	*screen = 0;
	455	if (g_xstuff.display && g_xstuff.window) {
	456	*display = g_xstuff.display;
	457	*screen = DefaultScreen(g_xstuff.display);
	458	window = (void )g_xstuff.window;
	459	return 0;
	460	}
	461
	462	return -1;
	463	}
	464
f9b3f440	465	void xenv_finish(void)
83b5751b	466	{
f9b3f440	467	// TODO: cleanup X?
f9b3f440	468	tty_end();
83b5751b	469	}
090bcb85	470
	471	#if 0
	472	int main()
	473	{
	474	int i, r, d;
	475
	476	xenv_init("just a test");
	477
	478	for (i = 0; i < 5; i++) {
	479	while ((r = xenv_update(&d)) > 0)
	480	printf("%d %x %d\n", d, r, r);
	481	sleep(1);
	482
	483	if (i == 1)
	484	xenv_minimize();
	485	printf("ll %d\n", i);
	486	}
	487
	488	printf("xenv_finish..\n");
	489	xenv_finish();
	490
	491	return 0;
	492	}
	493	#endif