ui/x11/sysx11.cc

/* 
 *      PearPC
 *      sysx11.cc
 *
 *      Copyright (C) 1999-2002 Stefan Weyergraf
 *      Copyright (C) 1999-2004 Sebastian Biallas (sb@biallas.net)
 *
 *      This program is free software; you can redistribute it and/or modify
 *      it under the terms of the GNU General Public License version 2 as
 *      published by the Free Software Foundation.
 *
 *      This program is distributed in the hope that it will be useful,
 *      but WITHOUT ANY WARRANTY; without even the implied warranty of
 *      MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *      GNU General Public License for more details.
 *
 *      You should have received a copy of the GNU General Public License
 *      along with this program; if not, write to the Free Software
 *      Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include <X11/Xutil.h>
#include <X11/keysym.h>
#include <sys/time.h>

#include <csignal>
#include <cstdlib>
#include <cstdio>
#include <unistd.h>
#include <cstring>

#include "system/sysclk.h"
#include "system/display.h"
#include "system/keyboard.h"
#include "system/mouse.h"

#include "tools/snprintf.h"

#include "sysx11.h"

sys_mutex       gX11Mutex;
Display *       gX11Display = NULL;
Window          gX11Window;

static uint8 x11_key_to_adb_key[256] = {
        // 0    1    2    3    4    5    6    7    8    9   10   11   12   13   14   15
        0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x35,0x12,0x13,0x14,0x15,0x17,0x16,
        0x1a,0x1c,0x19,0x1d,0x1b,0x18,0x33,0x30,0x0c,0x0d,0x0e,0x0f,0x11,0x10,0x20,0x22,
        0x1f,0x23,0x21,0x1e,0x24,0x36,0x00,0x01,0x02,0x03,0x05,0x04,0x26,0x28,0x25,0x29,
        0x27,0x32,0x38,0x2a,0x06,0x07,0x08,0x09,0x0b,0x2d,0x2e,0x2b,0x2f,0x2c,0x38,0x43,
        0x37,0x31,0xff,0x7a,0x78,0x63,0x76,0x60,0x61,0x62,0x64,0x65,0x6d,0x47,0xff,0x59,
        0x5b,0x5c,0x4e,0x56,0x57,0x58,0x45,0x53,0x54,0x55,0x52,0x41,0xff,0xff,0x0a,0x67,
        0x6f,0x73,0x3e,0x74,0x3b,0xff,0x3c,0x77,0x3d,0x79,0x72,0x75,0x4c,0x36,0xff,0xff,
        0x4b,0x3a,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
        0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
        0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
        0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
        0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
        0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
        0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
        0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
        0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
};

static void handleX11Event(const XEvent &event)
{
        static bool visible = true;
        static bool mapped = true;
        static bool mouseButton[3] = {false, false, false};
        bool tmpMouseButton[3];

        switch (event.type) {
        case GraphicsExpose:
        case Expose:
                damageFrameBufferAll();
                gDisplay->displayShow();
                break;
        case KeyRelease: {
                char buffer[4];
                SystemEvent ev;
                XComposeStatus compose;
                KeySym keysym;

                ev.key.keycode = x11_key_to_adb_key[event.xkey.keycode];
                if ((ev.key.keycode & 0xff) == 0xff) break;
                ev.type = sysevKey;
                ev.key.pressed = false;

                sys_lock_mutex(gX11Mutex);
                XLookupString((XKeyEvent*)&event, buffer, sizeof buffer, &keysym, &compose);
                sys_unlock_mutex(gX11Mutex);
                ev.key.chr = buffer[0];

                gKeyboard->handleEvent(ev);
                break;
        }
        case KeyPress: {
                char buffer[4];
                XComposeStatus compose;
                KeySym keysym;

                SystemEvent ev;
                ev.key.keycode = x11_key_to_adb_key[event.xkey.keycode];
                if ((ev.key.keycode & 0xff) == 0xff) break;
                ev.type = sysevKey;
                ev.key.pressed = true;
                ev.key.keycode = x11_key_to_adb_key[event.xkey.keycode];

                sys_lock_mutex(gX11Mutex);
                XLookupString((XKeyEvent*)&event, buffer, sizeof buffer, &keysym, &compose);
                sys_unlock_mutex(gX11Mutex);
                ev.key.chr = buffer[0];

                gKeyboard->handleEvent(ev);
                break;
        }
        case ButtonPress: {
                SystemEvent ev;
                ev.type = sysevMouse;
                memcpy(tmpMouseButton, mouseButton, sizeof (tmpMouseButton));
                switch (((XButtonEvent *)&event)->button) {
                case Button1:
                        mouseButton[0] = true;
                        break;
                case Button2:
                        mouseButton[2] = true;
                        break;
                case Button3:
                        mouseButton[1] = true;
                        break;
                }
                ev.mouse.type = sme_buttonPressed;
                ev.mouse.button1 = mouseButton[0];
                ev.mouse.button2 = mouseButton[1];
                ev.mouse.button3 = mouseButton[2];
                if (mouseButton[0] != tmpMouseButton[0]) {
                        ev.mouse.dbutton = 1;
                } else if (mouseButton[1] != tmpMouseButton[1]) {
                        ev.mouse.dbutton = 2;
                } else if (mouseButton[2] != tmpMouseButton[2]) {
                        ev.mouse.dbutton = 3;
                } else {
                        ev.mouse.dbutton = 0;
                }
                ev.mouse.x = gDisplay->mCurMouseX;
                ev.mouse.y = gDisplay->mCurMouseY;
                ev.mouse.relx = 0;
                ev.mouse.rely = 0;

                gMouse->handleEvent(ev);
                break;
        }
        case ButtonRelease: {
                SystemEvent ev; 
                ev.type = sysevMouse;
                memcpy(tmpMouseButton, mouseButton, sizeof (tmpMouseButton));
                switch (((XButtonEvent *)&event)->button) {
                case Button1:
                        mouseButton[0] = false;
                        break;
                case Button2:
                        mouseButton[2] = false;
                        break;
                case Button3:
                        mouseButton[1] = false;
                        break;
                }
                ev.mouse.type = sme_buttonReleased;
                ev.mouse.button1 = mouseButton[0];
                ev.mouse.button2 = mouseButton[1];
                ev.mouse.button3 = mouseButton[2];
                if (mouseButton[0] != tmpMouseButton[0]) {
                        ev.mouse.dbutton = 1;
                } else if (mouseButton[1] != tmpMouseButton[1]) {
                        ev.mouse.dbutton = 2;
                } else if (mouseButton[2] != tmpMouseButton[2]) {
                        ev.mouse.dbutton = 3;
                } else {
                        ev.mouse.dbutton = 0;
                }
                ev.mouse.x = gDisplay->mCurMouseX;
                ev.mouse.y = gDisplay->mCurMouseY;
                ev.mouse.relx = 0;
                ev.mouse.rely = 0;

                gMouse->handleEvent(ev);
                break;
        }
        case MotionNotify: {
                SystemEvent ev; 
                gDisplay->mCurMouseX = ev.mouse.x = ((XPointerMovedEvent *)&event)->x;
                gDisplay->mCurMouseY = ev.mouse.y = ((XPointerMovedEvent *)&event)->y;
                if (gDisplay->mCurMouseX == gDisplay->mHomeMouseX && gDisplay->mCurMouseY == gDisplay->mHomeMouseY) break;
                if (gDisplay->mCurMouseX == -1) break;
                ev.type = sysevMouse;
                ev.mouse.type = sme_motionNotify;
                ev.mouse.button1 = mouseButton[0];
                ev.mouse.button2 = mouseButton[1];
                ev.mouse.button3 = mouseButton[2];
                ev.mouse.dbutton = 0;
                ev.mouse.relx = gDisplay->mCurMouseX - gDisplay->mHomeMouseX;
                ev.mouse.rely = gDisplay->mCurMouseY - gDisplay->mHomeMouseY;
                if (gDisplay->isMouseGrabbed()) {
                        sys_lock_mutex(gX11Mutex);
                        XWarpPointer(gX11Display, gX11Window, gX11Window, 0, 0, 0, 0, gDisplay->mHomeMouseX, gDisplay->mHomeMouseY);
                        sys_unlock_mutex(gX11Mutex);
                }

                gMouse->handleEvent(ev);
                break;
        }
        case EnterNotify:
                gDisplay->mCurMouseX = ((XEnterWindowEvent *)&event)->x;
                gDisplay->mCurMouseY = ((XEnterWindowEvent *)&event)->y;
                break;
        case LeaveNotify:
                gDisplay->mCurMouseX = gDisplay->mCurMouseY = -1;
                break;
        case FocusOut:
                if (gDisplay->isMouseGrabbed()) gDisplay->setMouseGrab(false);
                break;
        case MapNotify:
                mapped = true;
                gDisplay->setExposed(visible);
                break;
        case UnmapNotify:
                mapped = false;
                gDisplay->setExposed(false);
                break;
        case VisibilityNotify:
                visible = (event.xvisibility.state != VisibilityFullyObscured);
                gDisplay->setExposed(mapped && visible);
                break;
        }
}

static inline bool checkHandleX11Event()
{
        XEvent event;
        uint xevmask = KeyPressMask | KeyReleaseMask | ExposureMask
                | ButtonPressMask | ButtonReleaseMask | PointerMotionMask
                | EnterWindowMask | LeaveWindowMask | StructureNotifyMask
                | VisibilityChangeMask;

        sys_lock_mutex(gX11Mutex);
        if (!XCheckWindowEvent(gX11Display, gX11Window,
        xevmask, &event)) {
                sys_unlock_mutex(gX11Mutex);
                return false;
        }
        sys_unlock_mutex(gX11Mutex);

        handleX11Event(event);
        return true;
}

static void *X11eventLoop(void *p)
{
        int fd = ConnectionNumber(gX11Display);

        int redraw_interval_msec = gDisplay->mRedraw_ms;
        uint64 redraw_interval_clk = redraw_interval_msec*sys_get_hiresclk_ticks_per_second()/1000;
        uint64 clk_per_sec = sys_get_hiresclk_ticks_per_second();
        uint64 next_redraw_clk = sys_get_hiresclk_ticks();

        while (1) {
                while (1) {
                        uint64 clk = sys_get_hiresclk_ticks();

                        if (clk >= next_redraw_clk) {
                                uint64 d = clk - next_redraw_clk;
                                // We may have missed some scheduled display
                                // redraws. We'll just ignore this and
                                // keep drawing every 'redraw_interval_msec' msecs
                                d %= redraw_interval_clk;
                                next_redraw_clk = clk + redraw_interval_clk - d;
                                gDisplay->displayShow();
                        }
                        struct timeval tm;
                        fd_set zerofds;
                        fd_set xfds;

                        FD_ZERO(&zerofds);
                        FD_ZERO(&xfds);
                        FD_SET(fd, &xfds);

                        uint64 x = (next_redraw_clk - clk) * 1000000 / clk_per_sec;
                        tm.tv_sec = 0;
                        tm.tv_usec = x;

                        if (checkHandleX11Event()) break;
                        if (select(fd+1, &xfds, &zerofds, &zerofds, &tm)) break;
                }

                // kind of limit the number of X events we handle to give the above
                // code a chance
                for (int i=0; i<500; i++) {
                        if (!checkHandleX11Event()) break;
                }
        }
        return NULL;
}

extern SystemDisplay *allocSystemDisplay(const char *title, const DisplayCharacteristics &chr, int redraw_ms, bool fullscreen);
extern SystemMouse *allocSystemMouse();
extern SystemKeyboard *allocSystemKeyboard();

void initUI(const char *title, const DisplayCharacteristics &aCharacteristics, int redraw_ms, const KeyboardCharacteristics &keyConfig, bool fullscreen)
{
        // connect to X server
        char *display = getenv("DISPLAY");
        if (display == NULL) {
                display = ":0.0";
        }
        gX11Display = XOpenDisplay(display);
        if (!gX11Display) {
                ht_printf("can't open X11 display (%s)!\n", display);
                exit(1);
        }

        sys_create_mutex(&gX11Mutex);

        gDisplay = allocSystemDisplay(title, aCharacteristics, redraw_ms, fullscreen);
        gMouse = allocSystemMouse();
        gKeyboard = allocSystemKeyboard();
        if(!gKeyboard->setKeyConfig(keyConfig)) {
                ht_printf("no keyConfig, or is empty");
                exit(1);
        }
        gDisplay->updateTitle();

        sys_thread X11eventLoopThread;

        if (sys_create_thread(&X11eventLoopThread, 0, X11eventLoop, NULL)) {
                ht_printf("can't create x11 event thread!\n");
                exit(1);
        }
}

void doneUI()
{
        XCloseDisplay(gX11Display);
}
1	/*
2	* PearPC
3	* sysx11.cc
4	*
5	* Copyright (C) 1999-2002 Stefan Weyergraf
6	* Copyright (C) 1999-2004 Sebastian Biallas (sb@biallas.net)
7	*
8	* This program is free software; you can redistribute it and/or modify
9	* it under the terms of the GNU General Public License version 2 as
10	* published by the Free Software Foundation.
11	*
12	* This program is distributed in the hope that it will be useful,
13	* but WITHOUT ANY WARRANTY; without even the implied warranty of
14	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15	* GNU General Public License for more details.
16	*
17	* You should have received a copy of the GNU General Public License
18	* along with this program; if not, write to the Free Software
19	* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20	*/
21
22	#include <X11/Xutil.h>
23	#include <X11/keysym.h>
24	#include <sys/time.h>
25
26	#include <csignal>
27	#include <cstdlib>
28	#include <cstdio>
29	#include <unistd.h>
30	#include <cstring>
31
32	#include "system/sysclk.h"
33	#include "system/display.h"
34	#include "system/keyboard.h"
35	#include "system/mouse.h"
36
37	#include "tools/snprintf.h"
38
39	#include "sysx11.h"
40
41	sys_mutex gX11Mutex;
42	Display * gX11Display = NULL;
43	Window gX11Window;
44
45	static uint8 x11_key_to_adb_key[256] = {
46	// 0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
47	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0x35,0x12,0x13,0x14,0x15,0x17,0x16,
48	0x1a,0x1c,0x19,0x1d,0x1b,0x18,0x33,0x30,0x0c,0x0d,0x0e,0x0f,0x11,0x10,0x20,0x22,
49	0x1f,0x23,0x21,0x1e,0x24,0x36,0x00,0x01,0x02,0x03,0x05,0x04,0x26,0x28,0x25,0x29,
50	0x27,0x32,0x38,0x2a,0x06,0x07,0x08,0x09,0x0b,0x2d,0x2e,0x2b,0x2f,0x2c,0x38,0x43,
51	0x37,0x31,0xff,0x7a,0x78,0x63,0x76,0x60,0x61,0x62,0x64,0x65,0x6d,0x47,0xff,0x59,
52	0x5b,0x5c,0x4e,0x56,0x57,0x58,0x45,0x53,0x54,0x55,0x52,0x41,0xff,0xff,0x0a,0x67,
53	0x6f,0x73,0x3e,0x74,0x3b,0xff,0x3c,0x77,0x3d,0x79,0x72,0x75,0x4c,0x36,0xff,0xff,
54	0x4b,0x3a,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
55	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
56	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
57	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
58	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
59	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
60	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
61	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
62	0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,0xff,
63	};
64
65	static void handleX11Event(const XEvent &event)
66	{
67	static bool visible = true;
68	static bool mapped = true;
69	static bool mouseButton[3] = {false, false, false};
70	bool tmpMouseButton[3];
71
72	switch (event.type) {
73	case GraphicsExpose:
74	case Expose:
75	damageFrameBufferAll();
76	gDisplay->displayShow();
77	break;
78	case KeyRelease: {
79	char buffer[4];
80	SystemEvent ev;
81	XComposeStatus compose;
82	KeySym keysym;
83
84	ev.key.keycode = x11_key_to_adb_key[event.xkey.keycode];
85	if ((ev.key.keycode & 0xff) == 0xff) break;
86	ev.type = sysevKey;
87	ev.key.pressed = false;
88
89	sys_lock_mutex(gX11Mutex);
90	XLookupString((XKeyEvent*)&event, buffer, sizeof buffer, &keysym, &compose);
91	sys_unlock_mutex(gX11Mutex);
92	ev.key.chr = buffer[0];
93
94	gKeyboard->handleEvent(ev);
95	break;
96	}
97	case KeyPress: {
98	char buffer[4];
99	XComposeStatus compose;
100	KeySym keysym;
101
102	SystemEvent ev;
103	ev.key.keycode = x11_key_to_adb_key[event.xkey.keycode];
104	if ((ev.key.keycode & 0xff) == 0xff) break;
105	ev.type = sysevKey;
106	ev.key.pressed = true;
107	ev.key.keycode = x11_key_to_adb_key[event.xkey.keycode];
108
109	sys_lock_mutex(gX11Mutex);
110	XLookupString((XKeyEvent*)&event, buffer, sizeof buffer, &keysym, &compose);
111	sys_unlock_mutex(gX11Mutex);
112	ev.key.chr = buffer[0];
113
114	gKeyboard->handleEvent(ev);
115	break;
116	}
117	case ButtonPress: {
118	SystemEvent ev;
119	ev.type = sysevMouse;
120	memcpy(tmpMouseButton, mouseButton, sizeof (tmpMouseButton));
121	switch (((XButtonEvent *)&event)->button) {
122	case Button1:
123	mouseButton[0] = true;
124	break;
125	case Button2:
126	mouseButton[2] = true;
127	break;
128	case Button3:
129	mouseButton[1] = true;
130	break;
131	}
132	ev.mouse.type = sme_buttonPressed;
133	ev.mouse.button1 = mouseButton[0];
134	ev.mouse.button2 = mouseButton[1];
135	ev.mouse.button3 = mouseButton[2];
136	if (mouseButton[0] != tmpMouseButton[0]) {
137	ev.mouse.dbutton = 1;
138	} else if (mouseButton[1] != tmpMouseButton[1]) {
139	ev.mouse.dbutton = 2;
140	} else if (mouseButton[2] != tmpMouseButton[2]) {
141	ev.mouse.dbutton = 3;
142	} else {
143	ev.mouse.dbutton = 0;
144	}
145	ev.mouse.x = gDisplay->mCurMouseX;
146	ev.mouse.y = gDisplay->mCurMouseY;
147	ev.mouse.relx = 0;
148	ev.mouse.rely = 0;
149
150	gMouse->handleEvent(ev);
151	break;
152	}
153	case ButtonRelease: {
154	SystemEvent ev;
155	ev.type = sysevMouse;
156	memcpy(tmpMouseButton, mouseButton, sizeof (tmpMouseButton));
157	switch (((XButtonEvent *)&event)->button) {
158	case Button1:
159	mouseButton[0] = false;
160	break;
161	case Button2:
162	mouseButton[2] = false;
163	break;
164	case Button3:
165	mouseButton[1] = false;
166	break;
167	}
168	ev.mouse.type = sme_buttonReleased;
169	ev.mouse.button1 = mouseButton[0];
170	ev.mouse.button2 = mouseButton[1];
171	ev.mouse.button3 = mouseButton[2];
172	if (mouseButton[0] != tmpMouseButton[0]) {
173	ev.mouse.dbutton = 1;
174	} else if (mouseButton[1] != tmpMouseButton[1]) {
175	ev.mouse.dbutton = 2;
176	} else if (mouseButton[2] != tmpMouseButton[2]) {
177	ev.mouse.dbutton = 3;
178	} else {
179	ev.mouse.dbutton = 0;
180	}
181	ev.mouse.x = gDisplay->mCurMouseX;
182	ev.mouse.y = gDisplay->mCurMouseY;
183	ev.mouse.relx = 0;
184	ev.mouse.rely = 0;
185
186	gMouse->handleEvent(ev);
187	break;
188	}
189	case MotionNotify: {
190	SystemEvent ev;
191	gDisplay->mCurMouseX = ev.mouse.x = ((XPointerMovedEvent *)&event)->x;
192	gDisplay->mCurMouseY = ev.mouse.y = ((XPointerMovedEvent *)&event)->y;
193	if (gDisplay->mCurMouseX == gDisplay->mHomeMouseX && gDisplay->mCurMouseY == gDisplay->mHomeMouseY) break;
194	if (gDisplay->mCurMouseX == -1) break;
195	ev.type = sysevMouse;
196	ev.mouse.type = sme_motionNotify;
197	ev.mouse.button1 = mouseButton[0];
198	ev.mouse.button2 = mouseButton[1];
199	ev.mouse.button3 = mouseButton[2];
200	ev.mouse.dbutton = 0;
201	ev.mouse.relx = gDisplay->mCurMouseX - gDisplay->mHomeMouseX;
202	ev.mouse.rely = gDisplay->mCurMouseY - gDisplay->mHomeMouseY;
203	if (gDisplay->isMouseGrabbed()) {
204	sys_lock_mutex(gX11Mutex);
205	XWarpPointer(gX11Display, gX11Window, gX11Window, 0, 0, 0, 0, gDisplay->mHomeMouseX, gDisplay->mHomeMouseY);
206	sys_unlock_mutex(gX11Mutex);
207	}
208
209	gMouse->handleEvent(ev);
210	break;
211	}
212	case EnterNotify:
213	gDisplay->mCurMouseX = ((XEnterWindowEvent *)&event)->x;
214	gDisplay->mCurMouseY = ((XEnterWindowEvent *)&event)->y;
215	break;
216	case LeaveNotify:
217	gDisplay->mCurMouseX = gDisplay->mCurMouseY = -1;
218	break;
219	case FocusOut:
220	if (gDisplay->isMouseGrabbed()) gDisplay->setMouseGrab(false);
221	break;
222	case MapNotify:
223	mapped = true;
224	gDisplay->setExposed(visible);
225	break;
226	case UnmapNotify:
227	mapped = false;
228	gDisplay->setExposed(false);
229	break;
230	case VisibilityNotify:
231	visible = (event.xvisibility.state != VisibilityFullyObscured);
232	gDisplay->setExposed(mapped && visible);
233	break;
234	}
235	}
236
237	static inline bool checkHandleX11Event()
238	{
239	XEvent event;
240	uint xevmask = KeyPressMask \| KeyReleaseMask \| ExposureMask
241	\| ButtonPressMask \| ButtonReleaseMask \| PointerMotionMask
242	\| EnterWindowMask \| LeaveWindowMask \| StructureNotifyMask
243	\| VisibilityChangeMask;
244
245	sys_lock_mutex(gX11Mutex);
246	if (!XCheckWindowEvent(gX11Display, gX11Window,
247	xevmask, &event)) {
248	sys_unlock_mutex(gX11Mutex);
249	return false;
250	}
251	sys_unlock_mutex(gX11Mutex);
252
253	handleX11Event(event);
254	return true;
255	}
256
257	static void X11eventLoop(void p)
258	{
259	int fd = ConnectionNumber(gX11Display);
260
261	int redraw_interval_msec = gDisplay->mRedraw_ms;
262	uint64 redraw_interval_clk = redraw_interval_msec*sys_get_hiresclk_ticks_per_second()/1000;
263	uint64 clk_per_sec = sys_get_hiresclk_ticks_per_second();
264	uint64 next_redraw_clk = sys_get_hiresclk_ticks();
265
266	while (1) {
267	while (1) {
268	uint64 clk = sys_get_hiresclk_ticks();
269
270	if (clk >= next_redraw_clk) {
271	uint64 d = clk - next_redraw_clk;
272	// We may have missed some scheduled display
273	// redraws. We'll just ignore this and
274	// keep drawing every 'redraw_interval_msec' msecs
275	d %= redraw_interval_clk;
276	next_redraw_clk = clk + redraw_interval_clk - d;
277	gDisplay->displayShow();
278	}
279	struct timeval tm;
280	fd_set zerofds;
281	fd_set xfds;
282
283	FD_ZERO(&zerofds);
284	FD_ZERO(&xfds);
285	FD_SET(fd, &xfds);
286
287	uint64 x = (next_redraw_clk - clk) * 1000000 / clk_per_sec;
288	tm.tv_sec = 0;
289	tm.tv_usec = x;
290
291	if (checkHandleX11Event()) break;
292	if (select(fd+1, &xfds, &zerofds, &zerofds, &tm)) break;
293	}
294
295	// kind of limit the number of X events we handle to give the above
296	// code a chance
297	for (int i=0; i<500; i++) {
298	if (!checkHandleX11Event()) break;
299	}
300	}
301	return NULL;
302	}
303
304	extern SystemDisplay allocSystemDisplay(const char title, const DisplayCharacteristics &chr, int redraw_ms, bool fullscreen);
305	extern SystemMouse *allocSystemMouse();
306	extern SystemKeyboard *allocSystemKeyboard();
307
308	void initUI(const char *title, const DisplayCharacteristics &aCharacteristics, int redraw_ms, const KeyboardCharacteristics &keyConfig, bool fullscreen)
309	{
310	// connect to X server
311	char *display = getenv("DISPLAY");
312	if (display == NULL) {
313	display = ":0.0";
314	}
315	gX11Display = XOpenDisplay(display);
316	if (!gX11Display) {
317	ht_printf("can't open X11 display (%s)!\n", display);
318	exit(1);
319	}
320
321	sys_create_mutex(&gX11Mutex);
322
323	gDisplay = allocSystemDisplay(title, aCharacteristics, redraw_ms, fullscreen);
324	gMouse = allocSystemMouse();
325	gKeyboard = allocSystemKeyboard();
326	if(!gKeyboard->setKeyConfig(keyConfig)) {
327	ht_printf("no keyConfig, or is empty");
328	exit(1);
329	}
330	gDisplay->updateTitle();
331
332	sys_thread X11eventLoopThread;
333
334	if (sys_create_thread(&X11eventLoopThread, 0, X11eventLoop, NULL)) {
335	ht_printf("can't create x11 event thread!\n");
336	exit(1);
337	}
338	}
339
340	void doneUI()
341	{
342	XCloseDisplay(gX11Display);
343	}