Flesh out Display structure, send events

8 files changed, 479 insertions, 92 deletions

diff --git a/src/Makefile.am b/src/Makefile.am
index 100ed0c..13baef9 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -7,7 +7,10 @@ libX11_wayland_la_CPPFLAGS = $(CSX_CFLAGS)
 libX11_wayland_la_SOURCES = \
 	display.c resource.c window.c pixmap.c event.c private.h
 
-noinst_PROGRAMS = xlib-wayland-test
+noinst_PROGRAMS = csx-test xlib-test
 
-xlib_wayland_test_SOURCES = xlib-wayland-test.c
-xlib_wayland_test_LDADD = libX11-wayland.la
+csx_test_SOURCES = test.c
+csx_test_LDADD = libX11-wayland.la
+
+xlib_test_SOURCES = test.c
+xlib_test_LDADD = -lX11
diff --git a/src/Xlib-wayland.h b/src/Xlib-wayland.h
index 3b87373..d2ca6c6 100644
--- a/src/Xlib-wayland.h
+++ b/src/Xlib-wayland.h
@@ -1,53 +1,162 @@
 #include <stdint.h>
 
+#include "X.h"
+
+typedef char *XPointer;
+
 #define Bool int
 #define Status int
 #define True 1
 #define False 0
 
-typedef uint32_t XID;
-typedef uint32_t Mask;
-typedef uint32_t Atom;
-typedef uint32_t VisualID;
-typedef uint32_t Time;
-
-typedef XID Window;
-typedef XID Drawable;
-typedef XID Font;
-typedef XID Pixmap;
-typedef XID Cursor;
-typedef XID Colormap;
-typedef XID GContext;
-typedef XID KeySym;
-
-typedef unsigned char KeyCode;
-typedef char *XPointer;
+#define QueuedAlready 0
+#define QueuedAfterReading 1
+#define QueuedAfterFlush 2
+
+#define ConnectionNumber(dpy) 	(((_XPrivDisplay)dpy)->fd)
+#define RootWindow(dpy, scr) 	(ScreenOfDisplay(dpy,scr)->root)
+#define DefaultScreen(dpy) 	(((_XPrivDisplay)dpy)->default_screen)
+#define DefaultRootWindow(dpy) 	(ScreenOfDisplay(dpy,DefaultScreen(dpy))->root)
+#define DefaultVisual(dpy, scr) (ScreenOfDisplay(dpy,scr)->root_visual)
+#define DefaultGC(dpy, scr) 	(ScreenOfDisplay(dpy,scr)->default_gc)
+#define BlackPixel(dpy, scr) 	(ScreenOfDisplay(dpy,scr)->black_pixel)
+#define WhitePixel(dpy, scr) 	(ScreenOfDisplay(dpy,scr)->white_pixel)
+#define AllPlanes 		((unsigned long)~0L)
+#define QLength(dpy) 		(((_XPrivDisplay)dpy)->qlen)
+#define DisplayWidth(dpy, scr) 	(ScreenOfDisplay(dpy,scr)->width)
+#define DisplayHeight(dpy, scr) (ScreenOfDisplay(dpy,scr)->height)
+#define DisplayWidthMM(dpy, scr)(ScreenOfDisplay(dpy,scr)->mwidth)
+#define DisplayHeightMM(dpy, scr)(ScreenOfDisplay(dpy,scr)->mheight)
+#define DisplayPlanes(dpy, scr) (ScreenOfDisplay(dpy,scr)->root_depth)
+#define DisplayCells(dpy, scr) 	(DefaultVisual(dpy,scr)->map_entries)
+#define ScreenCount(dpy) 	(((_XPrivDisplay)dpy)->nscreens)
+#define ServerVendor(dpy) 	(((_XPrivDisplay)dpy)->vendor)
+#define ProtocolVersion(dpy) 	(((_XPrivDisplay)dpy)->proto_major_version)
+#define ProtocolRevision(dpy) 	(((_XPrivDisplay)dpy)->proto_minor_version)
+#define VendorRelease(dpy) 	(((_XPrivDisplay)dpy)->release)
+#define DisplayString(dpy) 	(((_XPrivDisplay)dpy)->display_name)
+#define DefaultDepth(dpy, scr) 	(ScreenOfDisplay(dpy,scr)->root_depth)
+#define DefaultColormap(dpy, scr)(ScreenOfDisplay(dpy,scr)->cmap)
+#define BitmapUnit(dpy) 	(((_XPrivDisplay)dpy)->bitmap_unit)
+#define BitmapBitOrder(dpy) 	(((_XPrivDisplay)dpy)->bitmap_bit_order)
+#define BitmapPad(dpy) 		(((_XPrivDisplay)dpy)->bitmap_pad)
+#define ImageByteOrder(dpy) 	(((_XPrivDisplay)dpy)->byte_order)
+#ifdef CRAY /* unable to get WORD64 without pulling in other symbols */
+#define NextRequest(dpy)	XNextRequest(dpy)
+#else
+#define NextRequest(dpy)	(((_XPrivDisplay)dpy)->request + 1)
+#endif
+#define LastKnownRequestProcessed(dpy)	(((_XPrivDisplay)dpy)->last_request_read)
+
+/* macros for screen oriented applications (toolkit) */
+#define ScreenOfDisplay(dpy, scr)(&((_XPrivDisplay)dpy)->screens[scr])
+#define DefaultScreenOfDisplay(dpy) ScreenOfDisplay(dpy,DefaultScreen(dpy))
+#define DisplayOfScreen(s)	((s)->display)
+#define RootWindowOfScreen(s)	((s)->root)
+#define BlackPixelOfScreen(s)	((s)->black_pixel)
+#define WhitePixelOfScreen(s)	((s)->white_pixel)
+#define DefaultColormapOfScreen(s)((s)->cmap)
+#define DefaultDepthOfScreen(s)	((s)->root_depth)
+#define DefaultGCOfScreen(s)	((s)->default_gc)
+#define DefaultVisualOfScreen(s)((s)->root_visual)
+#define WidthOfScreen(s)	((s)->width)
+#define HeightOfScreen(s)	((s)->height)
+#define WidthMMOfScreen(s)	((s)->mwidth)
+#define HeightMMOfScreen(s)	((s)->mheight)
+#define PlanesOfScreen(s)	((s)->root_depth)
+#define CellsOfScreen(s)	(DefaultVisualOfScreen((s))->map_entries)
+#define MinCmapsOfScreen(s)	((s)->min_maps)
+#define MaxCmapsOfScreen(s)	((s)->max_maps)
+#define DoesSaveUnders(s)	((s)->save_unders)
+#define DoesBackingStore(s)	((s)->backing_store)
+#define EventMaskOfScreen(s)	((s)->root_input_mask)
 
-#define None                 0L	/* universal null resource or null atom */
+/*
+ * Extensions need a way to hang private data on some structures.
+ */
+typedef struct _XExtData {
+	int number;		/* number returned by XRegisterExtension */
+	struct _XExtData *next;	/* next item on list of data for structure */
+	int (*free_private)(	/* called to free private storage */
+	struct _XExtData *extension
+	);
+	XPointer private_data;	/* data private to this extension. */
+} XExtData;
 
-/* Window classes used by CreateWindow */
-/* Note that CopyFromParent is already defined as 0 above */
+/*
+ * Graphics context.  The contents of this structure are implementation
+ * dependent.  A GC should be treated as opaque by application code.
+ */
 
-#define InputOutput		1
-#define InputOnly		2
+typedef struct _XGC
+#ifdef XLIB_ILLEGAL_ACCESS
+{
+    XExtData *ext_data;	/* hook for extension to hang data */
+    GContext gid;	/* protocol ID for graphics context */
+    /* there is more to this structure, but it is private to Xlib */
+}
+#endif
+*GC;
 
-/* Window attributes for CreateWindow and ChangeWindowAttributes */
+typedef struct {
+	XExtData *ext_data;	/* hook for extension to hang data */
+	VisualID visualid;	/* visual id of this visual */
+#if defined(__cplusplus) || defined(c_plusplus)
+	int c_class;		/* C++ class of screen (monochrome, etc.) */
+#else
+	int class;		/* class of screen (monochrome, etc.) */
+#endif
+	unsigned long red_mask, green_mask, blue_mask;	/* mask values */
+	int bits_per_rgb;	/* log base 2 of distinct color values */
+	int map_entries;	/* color map entries */
+} Visual;
 
-#define CWBackPixmap		(1L<<0)
-#define CWBackPixel		(1L<<1)
-#define CWBorderPixmap		(1L<<2)
-#define CWBorderPixel           (1L<<3)
-#define CWBitGravity		(1L<<4)
-#define CWWinGravity		(1L<<5)
-#define CWBackingStore          (1L<<6)
-#define CWBackingPlanes	        (1L<<7)
-#define CWBackingPixel	        (1L<<8)
-#define CWOverrideRedirect	(1L<<9)
-#define CWSaveUnder		(1L<<10)
-#define CWEventMask		(1L<<11)
-#define CWDontPropagate	        (1L<<12)
-#define CWColormap		(1L<<13)
-#define CWCursor	        (1L<<14)
+/*
+ * Depth structure; contains information for each possible depth.
+ */
+typedef struct {
+	int depth;		/* this depth (Z) of the depth */
+	int nvisuals;		/* number of Visual types at this depth */
+	Visual *visuals;	/* list of visuals possible at this depth */
+} Depth;
+
+/*
+ * Information about the screen.  The contents of this structure are
+ * implementation dependent.  A Screen should be treated as opaque
+ * by application code.
+ */
+
+struct _XDisplay;		/* Forward declare before use for C++ */
+
+typedef struct {
+	XExtData *ext_data;	/* hook for extension to hang data */
+	struct _XDisplay *display;/* back pointer to display structure */
+	Window root;		/* Root window id. */
+	int width, height;	/* width and height of screen */
+	int mwidth, mheight;	/* width and height of  in millimeters */
+	int ndepths;		/* number of depths possible */
+	Depth *depths;		/* list of allowable depths on the screen */
+	int root_depth;		/* bits per pixel */
+	Visual *root_visual;	/* root visual */
+	GC default_gc;		/* GC for the root root visual */
+	Colormap cmap;		/* default color map */
+	unsigned long white_pixel;
+	unsigned long black_pixel;	/* White and Black pixel values */
+	int max_maps, min_maps;	/* max and min color maps */
+	int backing_store;	/* Never, WhenMapped, Always */
+	Bool save_unders;
+	long root_input_mask;	/* initial root input mask */
+} Screen;
+
+/*
+ * Format structure; describes ZFormat data the screen will understand.
+ */
+typedef struct {
+	XExtData *ext_data;	/* hook for extension to hang data */
+	int depth;		/* depth of this image format */
+	int bits_per_pixel;	/* bits/pixel at this depth */
+	int scanline_pad;	/* scanline must padded to this multiple */
+} ScreenFormat;
 
 /*
  * Data structure for setting window attributes.
@@ -71,35 +180,75 @@ typedef struct {
 } XSetWindowAttributes;
 
 /*
- * Extensions need a way to hang private data on some structures.
+ * Display datatype maintaining display specific data.
+ * The contents of this structure are implementation dependent.
+ * A Display should be treated as opaque by application code.
  */
-typedef struct _XExtData {
-	int number;		/* number returned by XRegisterExtension */
-	struct _XExtData *next;	/* next item on list of data for structure */
-	int (*free_private)(	/* called to free private storage */
-	struct _XExtData *extension
-	);
-	XPointer private_data;	/* data private to this extension. */
-} XExtData;
-
-typedef struct {
-	XExtData *ext_data;	/* hook for extension to hang data */
-	VisualID visualid;	/* visual id of this visual */
-#if defined(__cplusplus) || defined(c_plusplus)
-	int c_class;		/* C++ class of screen (monochrome, etc.) */
-#else
-	int class;		/* class of screen (monochrome, etc.) */
+#ifndef XLIB_ILLEGAL_ACCESS
+typedef struct _XDisplay Display;
 #endif
-	unsigned long red_mask, green_mask, blue_mask;	/* mask values */
-	int bits_per_rgb;	/* log base 2 of distinct color values */
-	int map_entries;	/* color map entries */
-} Visual;
 
-typedef struct _XDisplay Display;
+struct _XPrivate;		/* Forward declare before use for C++ */
+struct _XrmHashBucketRec;
 
-struct _XDisplay {
-	struct csx_display *csx_display;
-};
+typedef struct
+#ifdef XLIB_ILLEGAL_ACCESS
+_XDisplay
+#endif
+{
+	XExtData *ext_data;	/* hook for extension to hang data */
+	struct _XPrivate *private1;
+	int fd;			/* Network socket. */
+	int private2;
+	int proto_major_version;/* major version of server's X protocol */
+	int proto_minor_version;/* minor version of servers X protocol */
+	char *vendor;		/* vendor of the server hardware */
+        XID private3;
+	XID private4;
+	XID private5;
+	int private6;
+	XID (*resource_alloc)(	/* allocator function */
+		struct _XDisplay*
+	);
+	int byte_order;		/* screen byte order, LSBFirst, MSBFirst */
+	int bitmap_unit;	/* padding and data requirements */
+	int bitmap_pad;		/* padding requirements on bitmaps */
+	int bitmap_bit_order;	/* LeastSignificant or MostSignificant */
+	int nformats;		/* number of pixmap formats in list */
+	ScreenFormat *pixmap_format;	/* pixmap format list */
+	int private8;
+	int release;		/* release of the server */
+	struct _XPrivate *private9, *private10;
+	int qlen;		/* Length of input event queue */
+	unsigned long last_request_read; /* seq number of last event read */
+	unsigned long request;	/* sequence number of last request. */
+	XPointer private11;
+	XPointer private12;
+	XPointer private13;
+	XPointer private14;
+	unsigned max_request_size; /* maximum number 32 bit words in request*/
+	struct _XrmHashBucketRec *db;
+	int (*private15)(
+		struct _XDisplay*
+		);
+	char *display_name;	/* "host:display" string used on this connect*/
+	int default_screen;	/* default screen for operations */
+	int nscreens;		/* number of screens on this server*/
+	Screen *screens;	/* pointer to list of screens */
+	unsigned long motion_buffer;	/* size of motion buffer */
+	unsigned long private16;
+	int min_keycode;	/* minimum defined keycode */
+	int max_keycode;	/* maximum defined keycode */
+	XPointer private17;
+	XPointer private18;
+	int private19;
+	char *xdefaults;	/* contents of defaults from server */
+	/* there is more to this structure, but it is private to Xlib */
+}
+#ifdef XLIB_ILLEGAL_ACCESS
+Display,
+#endif
+*_XPrivDisplay;
 
 /* Event names.  Used in "type" field in XEvent structures.  Not to be
 confused with event masks above.  They start from 2 because 0 and 1
@@ -614,3 +763,7 @@ Window XCreateWindow(Display *display, Window parent, int x, int y,
 		     unsigned int CLASS, Visual *visual,
 		     unsigned long valuemask,
 		     XSetWindowAttributes *attributes);
+Window XCreateSimpleWindow(Display *xdisplay, Window parent, int x, int y,
+			   unsigned int width, unsigned int height,
+			   unsigned int border_width, unsigned long border,
+			   unsigned long background);
diff --git a/src/display.c b/src/display.c
index 9010c31..ce9a7dc 100644
--- a/src/display.c
+++ b/src/display.c
@@ -59,18 +59,29 @@ static const struct wl_registry_listener registry_listener = {
 	registry_handle_global_remove
 };
 
+static XID
+resource_alloc(struct _XDisplay *xdisplay)
+{
+	struct csx_display *display = csx_display(xdisplay);
+
+	return csx_display_add_resource(display, NULL);
+}
+
 WL_EXPORT Display *
 XOpenDisplay(const char *display_name)
 {
-	Display *xdisplay;
+	_XPrivDisplay xdisplay;
 	struct csx_display *display;
+	int size;
 
-	xdisplay = malloc(sizeof *xdisplay + sizeof *display);
+	size = sizeof *xdisplay + sizeof *display;
+	xdisplay = malloc(size);
 	if (!xdisplay)
 		return NULL;
 
-	memset(xdisplay, 0, sizeof *xdisplay);
-	display = xdisplay->csx_display = (void *) (xdisplay + 1);
+	memset(xdisplay, 0, size);
+	display = csx_display((Display *) xdisplay);
+	display->xdisplay = (Display *) xdisplay;
 	display->display = wl_display_connect(display_name);
 	if (!display->display) {
 		free(display);
@@ -94,23 +105,90 @@ XOpenDisplay(const char *display_name)
 	}
 
 	csx_display_add_resource(display, NULL); /* None resource */
+
+	display->depth24_visuals[0].visualid =
+		csx_display_add_resource(display,
+					 &display->depth24_visuals[0]);
+	display->depth24_visuals[0].class = DirectColor;
+	display->depth24_visuals[0].red_mask = 0x00ff0000;
+	display->depth24_visuals[0].green_mask = 0x0000ff00;
+	display->depth24_visuals[0].blue_mask = 0x000000ff;
+	display->depth24_visuals[0].bits_per_rgb = 8;
+	display->depth24_visuals[0].map_entries = 2^24;
+
+	display->depth24_visuals[0].visualid =
+		csx_display_add_resource(display,
+					 &display->depth32_visuals[0]);
+	display->depth24_visuals[0].class = DirectColor;
+	display->depth24_visuals[0].red_mask = 0x00ff0000;
+	display->depth24_visuals[0].green_mask = 0x0000ff00;
+	display->depth24_visuals[0].blue_mask = 0x000000ff;
+	display->depth24_visuals[0].bits_per_rgb = 8;
+	display->depth24_visuals[0].map_entries = 2^32;
+
+	display->depths[0].depth = 24;
+	display->depths[0].nvisuals = 1;
+	display->depths[0].visuals = display->depth24_visuals;
+
+	display->depths[1].depth = 32;
+	display->depths[1].nvisuals = 1;
+	display->depths[1].visuals = display->depth32_visuals;
+
 	display->root = csx_window_create(display, NULL);
+	display->screens[0].display = (Display *) xdisplay;
+	display->screens[0].root = display->root->id;
+	display->screens[0].width = 800;
+	display->screens[0].height = 600;
+	display->screens[0].mwidth = 290;
+	display->screens[0].mheight = 180;
+	display->screens[0].ndepths = 2;
+	display->screens[0].depths = display->depths;
+	display->screens[0].default_gc = None;
+	display->screens[0].cmap = None;
+	display->screens[0].white_pixel = 0xffffffff;
+	display->screens[0].black_pixel = 0xff000000;
+
+#if 0
+	int max_maps, min_maps;	/* max and min color maps */
+	int backing_store;	/* Never, WhenMapped, Always */
+	Bool save_unders;
+	long root_input_mask;	/* initial root input mask */
+#endif
+	wl_list_init(&display->event_list);
+
+	xdisplay->fd = wl_display_get_fd(display->display);
+	xdisplay->proto_major_version = 11;
+	xdisplay->proto_minor_version = 0;
+	xdisplay->vendor = "Wayland Client Side X Server";
+	xdisplay->resource_alloc = resource_alloc;
+
+	xdisplay->default_screen = 0;
+	xdisplay->screens = display->screens;
+
+	return (Display *) xdisplay;
+}
 
-	fprintf(stderr, "root window is id %d\n", display->root->id);
+WL_EXPORT int
+XConnectionNumber(Display *xdisplay)
+{
+	struct csx_display *display = csx_display(xdisplay);
 
-	return xdisplay;
+	return wl_display_get_fd(display->display);
 }
 
 WL_EXPORT int
-XConnectionNumber(Display *display)
+XFlush(Display *xdisplay)
 {
-	return wl_display_get_fd(display->csx_display->display);
+	struct csx_display *display = csx_display(xdisplay);
+
+	return wl_display_flush(display->display);
 }
 
+
 WL_EXPORT int
 XCloseDisplay(Display *xdisplay)
 {
-	struct csx_display *display = xdisplay->csx_display;
+	struct csx_display *display = csx_display(xdisplay);
 
 	if (display->shm)
 		wl_shm_destroy(display->shm);
@@ -126,3 +204,76 @@ XCloseDisplay(Display *xdisplay)
 	wl_display_disconnect(display->display);
 	free(xdisplay);
 }
+
+
+WL_EXPORT Window
+XRootWindow(Display *xdisplay, int screen_number)
+{
+	return RootWindow(xdisplay, screen_number);
+}
+
+WL_EXPORT Window
+XDefaultRootWindow(Display *xdisplay)
+{
+	return DefaultRootWindow(xdisplay);
+}
+
+WL_EXPORT Window
+XRootWindowOfScreen(Screen *screen)
+{
+	return RootWindowOfScreen(screen);
+}
+
+WL_EXPORT Visual *
+XDefaultVisual(Display *xdisplay, int screen_number)
+{
+	return DefaultVisual(xdisplay, screen_number);
+}
+
+WL_EXPORT Visual *
+XDefaultVisualOfScreen(Screen *screen)
+{
+	return DefaultVisualOfScreen(screen);
+}
+
+WL_EXPORT GC
+XDefaultGC(Display *xdisplay, int screen_number)
+{
+	return DefaultGC(xdisplay, screen_number);
+}
+
+WL_EXPORT GC
+XDefaultGCOfScreen(Screen *screen)
+{
+	return DefaultGCOfScreen(screen);
+}
+
+WL_EXPORT unsigned long
+XBlackPixel(Display *xdisplay, int screen_number)
+{
+	return BlackPixel(xdisplay, screen_number);
+}
+
+WL_EXPORT unsigned long
+XWhitePixel(Display *xdisplay, int screen_number)
+{
+	return WhitePixel(xdisplay, screen_number);
+}
+
+WL_EXPORT unsigned long
+XAllPlanes(void)
+{
+	return AllPlanes;
+}
+
+WL_EXPORT unsigned long
+XBlackPixelOfScreen(Screen *screen)
+{
+	return BlackPixelOfScreen(screen);
+}
+
+WL_EXPORT unsigned long
+XWhitePixelOfScreen(Screen *screen)
+{
+	return WhitePixelOfScreen(screen);
+}
diff --git a/src/event.c b/src/event.c
index 5344956..586c0cc 100644
--- a/src/event.c
+++ b/src/event.c
@@ -5,9 +5,16 @@
 WL_EXPORT int
 XNextEvent(Display *xdisplay, XEvent *xevent)
 {
-	struct csx_display *display = xdisplay->csx_display;
+	struct csx_display *display = csx_display(xdisplay);
+	struct csx_event *event;
 
-	wl_display_dispatch(display->display);
+	while (wl_list_empty(&display->event_list))
+		wl_display_dispatch(display->display);
+
+	event = container_of(display->event_list.next, struct csx_event, link);
+	wl_list_remove(&event->link);
+	*xevent = event->xevent;
+	free(event);
 
 	return 0;
 }
diff --git a/src/pixmap.c b/src/pixmap.c
index 820c023..50941ea 100644
--- a/src/pixmap.c
+++ b/src/pixmap.c
@@ -25,10 +25,11 @@ static int
 create_shm_buffer(struct csx_display *display, struct csx_pixmap *pixmap)
 {
 	struct wl_shm_pool *pool;
-	int fd, size, stride;
+	int fd, size, stride, i;
 	void *data;
 	const char *path;
 	char name[PATH_MAX];
+	uint32_t *p;
 
 	stride = pixmap->width * 4;
 	size = stride * pixmap->height;
@@ -68,7 +69,9 @@ create_shm_buffer(struct csx_display *display, struct csx_pixmap *pixmap)
 	wl_shm_pool_destroy(pool);
 	close(fd);
 
-	memset(pixmap->data, 55, size);
+	p = pixmap->data;
+	for (i = 0; i < size / 4; i++)
+		p[i] = 0xff000000 | (0x00010004 * i);
 
 	return 0;
 }
@@ -89,6 +92,8 @@ csx_pixmap_create(struct csx_display *display,
 	pixmap->depth = depth;
 	pixmap->refcount = 1;
 
+	/* Only create this for window backing pixmaps, just use
+	 * malloc for "normal" pixmaps. */
 	create_shm_buffer(display, pixmap);
 
 	return pixmap;
@@ -116,7 +121,7 @@ WL_EXPORT Pixmap
 XCreatePixmap(Display *xdisplay, Drawable drawable,
 	      unsigned int width, unsigned int height, unsigned int depth)
 {
-	struct csx_display *display = xdisplay->csx_display;
+	struct csx_display *display = csx_display(xdisplay);
 	struct csx_pixmap *pixmap;
 	void *resource;
 	Pixmap id;
@@ -136,7 +141,7 @@ XCreatePixmap(Display *xdisplay, Drawable drawable,
 WL_EXPORT int
 XFreePixmap(Display *xdisplay, Pixmap xpixmap)
 {
-	struct csx_display *display = xdisplay->csx_display;
+	struct csx_display *display = csx_display(xdisplay);
 	struct csx_pixmap *pixmap;
 
 	pixmap = csx_display_lookup_resource(display, xpixmap);
diff --git a/src/private.h b/src/private.h
index b3abf87..942931b 100644
--- a/src/private.h
+++ b/src/private.h
@@ -1,8 +1,12 @@
 #include <pixman.h>
 #include <wayland-client.h>
 
+#define container_of(ptr, type, member) ({				\
+	const __typeof__( ((type *)0)->member ) *__mptr = (ptr);	\
+	(type *)( (char *)__mptr - offsetof(type,member) );})
+
 struct csx_event {
-	XEvent event;
+	XEvent xevent;
 	struct wl_list link;
 };
 
@@ -21,8 +25,22 @@ struct csx_display {
 	struct wl_list event_list;
 
 	struct csx_window *root;
+
+	Display *xdisplay;
+	Screen screens[1];
+	Depth depths[2];
+
+	Visual depth24_visuals[1];
+	Visual depth32_visuals[1];
+	unsigned long serial;
 };
 
+static inline struct csx_display *
+csx_display(Display *display)
+{
+	return (struct csx_display *) ((_XPrivDisplay) display + 1);
+}
+
 XID cxs_display_add_resource(struct csx_display *display, void *p);
 void csx_display_remove_resource(struct csx_display *display, XID id);
 void *csx_display_lookup_resource(struct csx_display *display, XID id);
@@ -39,7 +57,7 @@ struct csx_window {
 	int depth;
 	unsigned int class;
 	Visual *visual;
-	unsigned long valuemask;
+	unsigned long event_mask;
 
 	struct csx_display *display;
 	int mapped;
diff --git a/src/window.c b/src/window.c
index 1f5df1b..d5b7d8a 100644
--- a/src/window.c
+++ b/src/window.c
@@ -37,7 +37,7 @@ XCreateWindow(Display *xdisplay, Window xparent, int x, int y,
 	      unsigned long valuemask,
 	      XSetWindowAttributes *attributes)
 {
-	struct csx_display *display = xdisplay->csx_display;
+	struct csx_display *display = csx_display(xdisplay);
 	struct csx_window *window, *parent;
 	int i;
 
@@ -73,7 +73,10 @@ XCreateWindow(Display *xdisplay, Window xparent, int x, int y,
 		case CWBackingPixel:
 		case CWOverrideRedirect:
 		case CWSaveUnder:
+			break;
 		case CWEventMask:
+			window->event_mask = attributes->event_mask;
+			break;
 		case CWDontPropagate:
 		case CWColormap:
 		case CWCursor:
@@ -84,10 +87,43 @@ XCreateWindow(Display *xdisplay, Window xparent, int x, int y,
 	return window->id;
 }
 
+WL_EXPORT Window
+XCreateSimpleWindow(Display *xdisplay, Window parent, int x, int y,
+		    unsigned int width, unsigned int height,
+		    unsigned int border_width, unsigned long border,
+		    unsigned long background)
+{
+	unsigned long valuemask;
+	XSetWindowAttributes attributes;
+
+	attributes.background_pixel = background;
+	attributes.border_pixel = border;
+	return XCreateWindow(xdisplay, parent, x, y, width, height,
+			     border_width, 0, CopyFromParent, CopyFromParent,
+			     CWBackPixel | CWBorderPixel, &attributes);
+}
+
 void
 csx_display_send_map_notify(struct csx_display *display,
 			    struct csx_window *window)
 {
+	struct csx_event *event;
+
+	if (!(window->event_mask & StructureNotifyMask))
+		return;
+
+	event = malloc(sizeof *event);
+	event->xevent.type = MapNotify;
+
+	event->xevent.xmap.type = MapNotify;
+	event->xevent.xmap.serial = display->serial;
+	event->xevent.xmap.send_event = False;
+	event->xevent.xmap.display = display->xdisplay;
+	event->xevent.xmap.event = window->id;
+	event->xevent.xmap.window = window->id;
+	event->xevent.xmap.override_redirect = False;
+
+	wl_list_insert(display->event_list.prev, &event->link);
 }
 
 void
@@ -99,6 +135,7 @@ csx_window_map_tree(struct csx_window *window, struct csx_pixmap *pixmap)
 		csx_window_map_tree(child, pixmap);
 
 	window->pixmap = pixmap;
+	csx_display_send_map_notify(window->display, window);
 }
 
 void
@@ -122,7 +159,7 @@ csx_window_map_toplevel(struct csx_window *window)
 WL_EXPORT int
 XMapWindow(Display *xdisplay, Window xwindow)
 {
-	struct csx_display *display = xdisplay->csx_display;
+	struct csx_display *display = csx_display(xdisplay);
 	struct csx_window *window;
 	struct csx_pixmap *pixmap;
 
@@ -168,7 +205,7 @@ csx_window_destroy(struct csx_window *window)
 WL_EXPORT int
 XDestroyWindow(Display *xdisplay, Window xwindow)
 {
-	struct csx_display *display = xdisplay->csx_display;
+	struct csx_display *display = csx_display(xdisplay);
 	struct csx_window *window;
 
 	window = csx_display_lookup_resource(display, xwindow);
@@ -185,7 +222,7 @@ XDestroyWindow(Display *xdisplay, Window xwindow)
 WL_EXPORT int
 XDestroySubwindows(Display *xdisplay, Window xwindow)
 {
-	struct csx_display *display = xdisplay->csx_display;
+	struct csx_display *display = csx_display(xdisplay);
 	struct csx_window *window, *child, *next;
 
 	window = csx_display_lookup_resource(display, xwindow);
diff --git a/src/xlib-wayland-test.c b/src/xlib-wayland-test.c
index 0eb0452..e2c7c93 100644
--- a/src/xlib-wayland-test.c
+++ b/src/xlib-wayland-test.c
@@ -7,10 +7,12 @@ int main(int argc, char *argv[])
 {
 	Display *display;
 	Window win;
-	XID root = 1; /* FIXME */
+	XID root;
+	XEvent e;
 
 	display = XOpenDisplay(NULL);
-	printf("opened display %p\n", display);
+	root = XRootWindow(display, 0);
+	printf("opened display %p, root window is %d\n", display, root);
 	win = XCreateWindow(display, root,
 			    100, 100, 200, 200, 0, 24,
 			    InputOutput, NULL, 0, NULL);
@@ -18,9 +20,20 @@ int main(int argc, char *argv[])
 	printf("created window %d\n", win);
 
 	XMapWindow(display, win);
-
-	while (1)
-		XNextEvent(display, NULL);
+	XFlush(display);
+
+	while (1) {
+		XNextEvent(display, &e);
+		switch (e.type) {
+		case MapNotify:
+			printf("got MapNotify event: window %d\n",
+			       e.xmap.window);
+			break;
+		default:
+			printf("got event type %d\n", e.type);
+			break;
+		}
+	}
 
 	XCloseDisplay(display);