X-Git-Url: https://jasonwoof.com/gitweb/?a=blobdiff_plain;f=spectrwm.c;h=53aaba27ab2b46ab3f43fb6e5807eedec65dec74;hb=59e91c45a7dd7ca913323f8391d8bce0d9f0769d;hp=95f2600ceb0563c28b32247245f057445c39d61c;hpb=c6884e7ede70025416cbf23e0279b58be2af778e;p=spectrwm.git

diff --git a/spectrwm.c b/spectrwm.c
index 95f2600..53aaba2 100644
--- a/spectrwm.c
+++ b/spectrwm.c
@@ -92,6 +92,7 @@
 #include <X11/Xatom.h>
 #include <X11/Xlib-xcb.h>
 #include <xcb/randr.h>
+#include <xcb/xcb_atom.h>
 #include <xcb/xcb_icccm.h>
 #include <xcb/xcb_keysyms.h>
 #include <X11/Xproto.h>
@@ -129,11 +130,13 @@ static const char	*buildstr = SPECTRWM_VERSION;
 #define XCB_ICCCM_WM_STATE_ICONIC		XCB_WM_STATE_ICONIC
 #define XCB_ICCCM_WM_STATE_WITHDRAWN		XCB_WM_STATE_WITHDRAWN
 #define XCB_ICCCM_WM_STATE_NORMAL		XCB_WM_STATE_NORMAL
+#define	xcb_icccm_get_wm_name			xcb_get_wm_name
+#define xcb_icccm_get_wm_name_reply		xcb_get_wm_name_reply
 #define xcb_icccm_get_wm_transient_for		xcb_get_wm_transient_for
 #define xcb_icccm_get_wm_transient_for_reply	xcb_get_wm_transient_for_reply
 #endif
 
-/*#define SWM_DEBUG*/
+#define SWM_DEBUG
 #ifdef SWM_DEBUG
 #define DPRINTF(x...)		do { if (swm_debug) fprintf(stderr, x); } while (0)
 #define DNPRINTF(n,x...)	do { if (swm_debug & n) fprintf(stderr, x); } while (0)
@@ -191,13 +194,13 @@ u_int32_t		swm_debug = 0
 #define BORDER(w)		(w->bordered ? border_width : 0)
 #define MAX_X(r)		((r)->g.x + (r)->g.w)
 #define MAX_Y(r)		((r)->g.y + (r)->g.h)
-#define SH_MIN(w)		(w)->sh_mask & PMinSize
+#define SH_MIN(w)		(w)->sh.flags & XCB_SIZE_HINT_P_MIN_SIZE
 #define SH_MIN_W(w)		(w)->sh.min_width
 #define SH_MIN_H(w)		(w)->sh.min_height
-#define SH_MAX(w)		(w)->sh_mask & PMaxSize
+#define SH_MAX(w)		(w)->sh.flags & XCB_SIZE_HINT_P_MAX_SIZE
 #define SH_MAX_W(w)		(w)->sh.max_width
 #define SH_MAX_H(w)		(w)->sh.max_height
-#define SH_INC(w)		(w)->sh_mask & PResizeInc
+#define SH_INC(w)		(w)->sh.flags & XCB_SIZE_HINT_P_RESIZE_INC
 #define SH_INC_W(w)		(w)->sh.width_inc
 #define SH_INC_H(w)		(w)->sh.height_inc
 #define SWM_MAX_FONT_STEPS	(3)
@@ -256,7 +259,7 @@ struct search_window {
 	TAILQ_ENTRY(search_window)	entry;
 	int				idx;
 	struct ws_win			*win;
-	GC				gc;
+	xcb_gcontext_t			gc;
 	xcb_window_t			indicator;
 };
 TAILQ_HEAD(search_winlist, search_window);
@@ -290,12 +293,6 @@ double			dialog_ratio = 0.6;
 				"-misc-fixed-medium-r-*-*-*-*-*-*-*-*-*-*,"  \
 				"-*-*-*-r-*--*-*-*-*-*-*-*-*"
 
-#ifdef X_HAVE_UTF8_STRING
-#define DRAWSTRING(x...)	Xutf8DrawString(x)
-#else
-#define DRAWSTRING(x...)	XmbDrawString(x)
-#endif
-
 char			*bar_argv[] = { NULL, NULL };
 int			bar_pipe[2];
 unsigned char		bar_ext[SWM_BAR_MAX];
@@ -378,7 +375,7 @@ struct ws_win {
 	int			floatmaxed;	/* whether maxed by max_stack */
 	int			floating;
 	int			manual;
-	int			iconic;
+	int32_t			iconic;
 	int			bordered;
 	unsigned int		ewmh_flags;
 	int			font_size_boundary[SWM_MAX_FONT_STEPS];
@@ -390,11 +387,10 @@ struct ws_win {
 	unsigned long		quirks;
 	struct workspace	*ws;	/* always valid */
 	struct swm_screen	*s;	/* always valid, never changes */
-	XWindowAttributes	wa;
-	XSizeHints		sh;
-	long			sh_mask;
-	XClassHint		ch;
-	XWMHints		*hints;
+	xcb_get_geometry_reply_t	*wa;
+	xcb_size_hints_t	sh;
+	xcb_get_wm_class_reply_t	ch;
+	xcb_wm_hints_t		hints;
 };
 TAILQ_HEAD(ws_win_list, ws_win);
 
@@ -503,7 +499,7 @@ struct swm_screen {
 		char		*name;
 	} c[SWM_S_COLOR_MAX];
 
-	GC			bar_gc;
+	xcb_gcontext_t		bar_gc;
 };
 struct swm_screen	*screens;
 
@@ -637,10 +633,40 @@ int		 floating_toggle_win(struct ws_win *);
 void		 constrain_window(struct ws_win *, struct swm_region *, int);
 void		 update_window(struct ws_win *);
 void		 spawn_select(struct swm_region *, union arg *, char *, int *);
-unsigned char	*get_win_name(xcb_window_t);
+char		*get_win_name(xcb_window_t);
 xcb_atom_t	 get_atom_from_string(const char *);
 void		map_window_raised(xcb_window_t);
 void		do_sync(void);
+xcb_screen_t	*get_screen(int);
+int		parse_rgb(const char *, uint16_t *, uint16_t *, uint16_t *);
+
+int
+parse_rgb(const char *rgb, uint16_t *rr, uint16_t *gg, uint16_t *bb)
+{
+	unsigned int	tmpr, tmpg, tmpb;
+
+	if (sscanf(rgb, "rgb:%x/%x/%x", &tmpr, &tmpg, &tmpb) != 3)
+		return (-1);
+	
+	*rr = tmpr << 8;
+	*gg = tmpg << 8;
+	*bb = tmpb << 8;
+
+	return (0);
+}
+
+xcb_screen_t *
+get_screen(int screen)
+{
+	xcb_screen_iterator_t i;
+
+	i = xcb_setup_roots_iterator(xcb_get_setup(conn));
+	for (; i.rem; --screen, xcb_screen_next(&i))
+		if (screen == 0)
+			return (i.data);
+
+	return (NULL);
+}
 
 void
 do_sync(void)
@@ -687,29 +713,6 @@ get_atom_from_string(const char *str)
 	return (XCB_ATOM_NONE);
 }
 
-int
-get_property(Window id, Atom atom, long count, Atom type, unsigned long *nitems,
-    unsigned long *nbytes, unsigned char **data)
-{
-	int			format, status;
-	unsigned long		*nbytes_ret, *nitems_ret;
-	unsigned long		nbytes_tmp, nitems_tmp;
-	Atom			real;
-
-	nbytes_ret = nbytes != NULL ? nbytes : &nbytes_tmp;
-	nitems_ret = nitems != NULL ? nitems : &nitems_tmp;
-
-	status = XGetWindowProperty(display, id, atom, 0L, count, False, type,
-	    &real, &format, nitems_ret, nbytes_ret, data);
-
-	if (status != Success)
-		return (False);
-	if (real != type)
-		return (False);
-
-	return (True);
-}
-
 void
 update_iconic(struct ws_win *win, int newv)
 {
@@ -729,29 +732,28 @@ update_iconic(struct ws_win *win, int newv)
 		xcb_delete_property(conn, win->id, iprop);
 }
 
-int
+int32_t
 get_iconic(struct ws_win *win)
 {
-	int32_t v = 0, *vtmp;
+	int32_t				v = 0;
 	xcb_atom_t			iprop;
-	xcb_get_property_cookie_t	pc;
 	xcb_get_property_reply_t	*pr = NULL;
 
 	iprop = get_atom_from_string("_SWM_ICONIC");
 	if (iprop == XCB_ATOM_NONE)
 		goto out;
 
-	pc = xcb_get_property(conn, False, win->id, iprop, XCB_ATOM_INTEGER,
-			0, 1);
-	pr = xcb_get_property_reply(conn, pc, NULL);
+	pr = xcb_get_property_reply(conn,
+		xcb_get_property(conn, False, win->id, iprop, XCB_ATOM_INTEGER,
+			0, 1),
+		NULL);
 	if (!pr)
 		goto out;
 	if (pr->type != XCB_ATOM_INTEGER || pr->format != 32)
 		goto out;
-	vtmp = xcb_get_property_value(pr);
-	v = *vtmp;
+	v = *((int32_t *)xcb_get_property_value(pr));
 out:
-	if (pr != NULL)
+	if (pr)	
 		free(pr);
 	return (v);
 }
@@ -1012,10 +1014,10 @@ ewmh_get_win_state(struct ws_win *win)
 	states = xcb_get_property_value(r);
 	n = xcb_get_property_value_length(r);
 
-	free(r);
-
 	for (i = 0; i < n; i++)
 		ewmh_update_win_state(win, states[i], _NET_WM_STATE_ADD);
+
+	free(r);
 }
 
 /* events */
@@ -1308,28 +1310,45 @@ name_to_color(const char *colorname)
 	char				cname[32] = "#";
 	xcb_screen_t			*screen;
 	xcb_colormap_t			cmap;
-	xcb_alloc_named_color_cookie_t	c;
-	xcb_alloc_named_color_reply_t	*r;
+	xcb_alloc_color_reply_t		*cr;
+	xcb_alloc_named_color_reply_t	*nr;
+	uint16_t			rr, gg, bb;
 
-	/* XXX - does not support rgb:/RR/GG/BB
-	 *       will need to use xcb_alloc_color
-	 */
 	screen = xcb_setup_roots_iterator(xcb_get_setup(conn)).data;
 	cmap = screen->default_colormap;
 
-	c = xcb_alloc_named_color(conn, cmap, strlen(colorname), colorname);
-	r = xcb_alloc_named_color_reply(conn, c, NULL);
-	if (!r) {
-		strlcat(cname, colorname + 2, sizeof cname - 1);
-		c = xcb_alloc_named_color(conn, cmap, strlen(cname),
-			cname);
-		r = xcb_alloc_named_color_reply(conn, c, NULL);
+	/* color is in format rgb://rr/gg/bb */
+	if (strncmp(colorname, "rgb:", 4) == 0) {
+		if (parse_rgb(colorname, &rr, &gg, &bb) == -1)
+			warnx("could not parse rgb %s", colorname);
+		else {
+			cr = xcb_alloc_color_reply(conn,
+				xcb_alloc_color(conn, cmap, rr, gg, bb),
+				NULL);
+			if (cr) {
+				result = cr->pixel;
+				free(cr);
+			} else
+				warnx("color '%s' not found", colorname);
+		}
+	} else {
+		nr = xcb_alloc_named_color_reply(conn,
+			xcb_alloc_named_color(conn, cmap, strlen(colorname),
+				colorname),
+			NULL);
+		if (!nr) {
+			strlcat(cname, colorname + 2, sizeof cname - 1);
+			nr = xcb_alloc_named_color_reply(conn,
+				xcb_alloc_named_color(conn, cmap, strlen(cname),
+					cname),
+				NULL);
+		}
+		if (nr) {
+			result = nr->pixel;
+			free(nr);
+		} else
+			warnx("color '%s' not found", colorname);
 	}
-	if (r) {
-		result = r->pixel;
-		free(r);
-	} else
-		warnx("color '%s' not found", colorname);
 
 	return (result);
 }
@@ -1388,6 +1407,7 @@ custom_region(char *val)
 {
 	unsigned int			sidx, x, y, w, h;
 	int				num_screens;
+	xcb_screen_t			*screen;
 
 	num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
 	if (sscanf(val, "screen[%u]:%ux%u+%u+%u", &sidx, &w, &h, &x, &y) != 5)
@@ -1398,16 +1418,17 @@ custom_region(char *val)
 		    sidx, num_screens);
 	sidx--;
 
+	screen = get_screen(sidx);
 	if (w < 1 || h < 1)
 		errx(1, "region %ux%u+%u+%u too small", w, h, x, y);
 
-	if (x > DisplayWidth(display, sidx) ||
-	    y > DisplayHeight(display, sidx) ||
-	    w + x > DisplayWidth(display, sidx) ||
-	    h + y > DisplayHeight(display, sidx)) {
+	if (x > screen->width_in_pixels ||
+	    y > screen->height_in_pixels ||
+	    w + x > screen->width_in_pixels ||
+	    h + y > screen->height_in_pixels) {
 		warnx("ignoring region %ux%u+%u+%u - not within screen "
 		    "boundaries (%ux%u)", w, h, x, y,
-		    DisplayWidth(display, sidx), DisplayHeight(display, sidx));
+		    screen->width_in_pixels, screen->height_in_pixels);
 		return;
 	}
 
@@ -1431,6 +1452,8 @@ bar_print(struct swm_region *r, const char *s)
 {
 	int			x = 0;
 	size_t			len;
+	xcb_rectangle_t		rect;
+	uint32_t		gcv[1];
 	XRectangle		ibox, lbox;
 
 	len = strlen(s);
@@ -1451,21 +1474,27 @@ bar_print(struct swm_region *r, const char *s)
 	if (x < SWM_BAR_OFFSET)
 		x = SWM_BAR_OFFSET;
 
+	rect.x = 0;
+	rect.y = 0;
+	rect.width = WIDTH(r->bar);
+	rect.height = HEIGHT(r->bar);
+
 	/* clear back buffer */
-	XSetForeground(display, r->s->bar_gc, r->s->c[SWM_S_COLOR_BAR].color);
-	XFillRectangle(display, r->bar->buffer, r->s->bar_gc, 0, 0,
-	    WIDTH(r->bar), HEIGHT(r->bar));
+	gcv[0] = r->s->c[SWM_S_COLOR_BAR].color;
+	xcb_change_gc(conn, r->s->bar_gc, XCB_GC_FOREGROUND, gcv);
+	xcb_poly_fill_rectangle(conn, r->bar->buffer, r->s->bar_gc,
+		sizeof(rect), &rect);
 
 	/* draw back buffer */
-	XSetForeground(display, r->s->bar_gc,
-	    r->s->c[SWM_S_COLOR_BAR_FONT].color);
-	DRAWSTRING(display, r->bar->buffer, bar_fs, r->s->bar_gc,
-		x, (bar_fs_extents->max_logical_extent.height - lbox.height) / 2 -
-		lbox.y, s, len);
+	gcv[0] = r->s->c[SWM_S_COLOR_BAR_FONT].color;
+	xcb_change_gc(conn, r->s->bar_gc, XCB_GC_FOREGROUND, gcv);
+	xcb_image_text_8(conn, len, r->bar->buffer, r->s->bar_gc, x,
+		(bar_fs_extents->max_logical_extent.height - lbox.height) / 2 -
+		lbox.y, s);
 
 	/* blt */
-	XCopyArea(display, r->bar->buffer, r->bar->id, r->s->bar_gc, 0, 0,
-	    WIDTH(r->bar), HEIGHT(r->bar), 0, 0);
+	xcb_copy_area(conn, r->bar->buffer, r->bar->id, r->s->bar_gc, 0, 0,
+		0, 0, WIDTH(r->bar), HEIGHT(r->bar));
 }
 
 void
@@ -1488,8 +1517,8 @@ bar_class_name(char *s, size_t sz, struct swm_region *r)
 {
 	if (r == NULL || r->ws == NULL || r->ws->focus == NULL)
 		return;
-	if (r->ws->focus->ch.res_class != NULL)
-		strlcat(s, r->ws->focus->ch.res_class, sz);
+	if (r->ws->focus->ch.class_name != NULL)
+		strlcat(s, r->ws->focus->ch.class_name, sz);
 }
 
 void
@@ -1497,8 +1526,8 @@ bar_title_name(char *s, size_t sz, struct swm_region *r)
 {
 	if (r == NULL || r->ws == NULL || r->ws->focus == NULL)
 		return;
-	if (r->ws->focus->ch.res_name != NULL)
-		strlcat(s, r->ws->focus->ch.res_name, sz);
+	if (r->ws->focus->ch.instance_name != NULL)
+		strlcat(s, r->ws->focus->ch.instance_name, sz);
 }
 
 void
@@ -1524,15 +1553,15 @@ bar_window_float(char *s, size_t sz, struct swm_region *r)
 void
 bar_window_name(char *s, size_t sz, struct swm_region *r)
 {
-	unsigned char		*title;
+	char		*title;
 
 	if (r == NULL || r->ws == NULL || r->ws->focus == NULL)
 		return;
 	if ((title = get_win_name(r->ws->focus->id)) == NULL)
 		return;
 
-	strlcat(s, (char *)title, sz);
-	XFree(title);
+	strlcat(s, title, sz);
+	free(title);
 }
 
 int		urgent[SWM_WS_MAX];
@@ -1925,7 +1954,9 @@ bar_setup(struct swm_region *r)
 	char			**missing_charsets;
 	int			num_missing_charsets = 0;
 	int			i;
-
+	xcb_screen_t		*screen = get_screen(r->s->idx);
+	uint32_t		wa[2];
+	
 	if (bar_fs) {
 		XFreeFontSet(display, bar_fs);
 		bar_fs = NULL;
@@ -1970,13 +2001,18 @@ bar_setup(struct swm_region *r)
 	WIDTH(r->bar) = WIDTH(r) - 2 * bar_border_width;
 	HEIGHT(r->bar) = bar_height - 2 * bar_border_width;
 
-	r->bar->id = XCreateSimpleWindow(display,
-	    r->s->root, X(r->bar), Y(r->bar), WIDTH(r->bar), HEIGHT(r->bar),
-	    bar_border_width, r->s->c[SWM_S_COLOR_BAR_BORDER].color,
-	    r->s->c[SWM_S_COLOR_BAR].color);
+	r->bar->id = xcb_generate_id(conn);
+	wa[0] = r->s->c[SWM_S_COLOR_BAR].color;
+	wa[1] = r->s->c[SWM_S_COLOR_BAR_BORDER].color;
+	xcb_create_window(conn, screen->root_depth, r->bar->id, r->s->root,
+		X(r->bar), Y(r->bar), WIDTH(r->bar), HEIGHT(r->bar),
+		bar_border_width, XCB_WINDOW_CLASS_INPUT_OUTPUT,
+		screen->root_visual, XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL,
+		wa);
 
-	r->bar->buffer = XCreatePixmap(display, r->bar->id, WIDTH(r->bar),
-	    HEIGHT(r->bar), DefaultDepth(display, r->s->idx));
+	r->bar->buffer = xcb_generate_id(conn);
+	xcb_create_pixmap(conn, screen->root_depth, r->bar->buffer, r->bar->id,
+		WIDTH(r->bar), HEIGHT(r->bar)); 
 
 	xcb_randr_select_input(conn, r->bar->id,
 		XCB_RANDR_NOTIFY_MASK_OUTPUT_CHANGE);
@@ -2110,10 +2146,10 @@ config_win(struct ws_win *win, XConfigureRequestEvent  *ev)
 		ce.window = ev->window;
 
 		/* make response appear more WM_SIZE_HINTS-compliant */
-		if (win->sh_mask)
+		if (win->sh.flags)
 			DNPRINTF(SWM_D_MISC, "config_win: hints: window: 0x%x,"
-			    " sh_mask: %ld, min: %d x %d, max: %d x %d, inc: "
-			    "%d x %d\n", win->id, win->sh_mask, SH_MIN_W(win),
+			    " sh.flags: %u, min: %d x %d, max: %d x %d, inc: "
+			    "%d x %d\n", win->id, win->sh.flags, SH_MIN_W(win),
 			    SH_MIN_H(win), SH_MAX_W(win), SH_MAX_H(win),
 			    SH_INC_W(win), SH_INC_H(win));
 
@@ -2244,11 +2280,11 @@ fake_keypress(struct ws_win *win, xcb_keysym_t keysym, uint16_t modifiers)
 	event.state = modifiers;
 
 	event.response_type = XCB_KEY_PRESS;
-	xcb_send_event(conn, win->id, True,
+	xcb_send_event(conn, True, win->id,
 		 XCB_EVENT_MASK_KEY_PRESS, (char *)&event);
 
 	event.response_type = XCB_KEY_RELEASE;
-	xcb_send_event(conn, win->id, True,
+	xcb_send_event(conn, True, win->id,
 		XCB_EVENT_MASK_KEY_RELEASE, (char *)&event);
 	xcb_flush(conn);
 
@@ -2279,7 +2315,6 @@ root_to_region(xcb_window_t root)
 {
 	struct swm_region	*r = NULL;
 	int			i, num_screens;
-	xcb_query_pointer_cookie_t	qpc;
 	xcb_query_pointer_reply_t	*qpr;
 
 	DNPRINTF(SWM_D_MISC, "root_to_region: window: 0x%x\n", root);
@@ -2289,8 +2324,8 @@ root_to_region(xcb_window_t root)
 		if (screens[i].root == root)
 			break;
 
-	qpc = xcb_query_pointer(conn, screens[i].root);
-	qpr = xcb_query_pointer_reply(conn, qpc, NULL);
+	qpr = xcb_query_pointer_reply(conn, xcb_query_pointer(conn,
+		screens[i].root), NULL);
 
 	if (qpr) {
 		DNPRINTF(SWM_D_MISC, "root_to_region: pointer: (%d,%d)\n",
@@ -3733,29 +3768,28 @@ iconify(struct swm_region *r, union arg *args)
 	focus(r, &a);
 }
 
-unsigned char *
+char *
 get_win_name(xcb_window_t win)
 {
-	unsigned char		*prop = NULL;
-	unsigned long		nbytes, nitems;
-
-	/* try _NET_WM_NAME first */
-	if (get_property(win, a_netwmname, 0L, a_utf8_string, NULL, &nbytes,
-	    &prop)) {
-		XFree(prop);
-		if (get_property(win, a_netwmname, nbytes, a_utf8_string,
-		    &nitems, NULL, &prop))
-			return (prop);
+	char				*name = NULL;
+	xcb_get_property_cookie_t	c;
+	xcb_get_text_property_reply_t	r;
+
+	c = xcb_icccm_get_wm_name(conn, win);
+	if (xcb_icccm_get_wm_name_reply(conn, c, &r, NULL)) {
+		if (r.name_len > 0) {
+			name = malloc(r.name_len + 1);
+			if (!name) {
+				xcb_get_text_property_reply_wipe(&r);
+				return (NULL);
+			}
+			memcpy(name, r.name, r.name_len);
+			name[r.name_len] = '\0';
+		}
+		xcb_get_text_property_reply_wipe(&r);
 	}
 
-	/* fallback to WM_NAME */
-	if (!get_property(win, a_wmname, 0L, a_string, NULL, &nbytes, &prop))
-		return (NULL);
-	XFree(prop);
-	if (get_property(win, a_wmname, nbytes, a_string, &nitems, NULL, &prop))
-		return (prop);
-
-	return (NULL);
+	return (name);
 }
 
 void
@@ -3763,7 +3797,7 @@ uniconify(struct swm_region *r, union arg *args)
 {
 	struct ws_win		*win;
 	FILE			*lfile;
-	unsigned char		*name;
+	char			*name;
 	int			count = 0;
 
 	DNPRINTF(SWM_D_MISC, "uniconify\n");
@@ -3800,7 +3834,7 @@ uniconify(struct swm_region *r, union arg *args)
 		if (name == NULL)
 			continue;
 		fprintf(lfile, "%s.%u\n", name, win->id);
-		XFree(name);
+		free(name);
 	}
 
 	fclose(lfile);
@@ -3866,7 +3900,7 @@ search_win_cleanup(void)
 
 	while ((sw = TAILQ_FIRST(&search_wl)) != NULL) {
 		xcb_destroy_window(conn, sw->indicator);
-		XFreeGC(display, sw->gc);
+		xcb_free_gc(conn, sw->gc);
 		TAILQ_REMOVE(&search_wl, sw, entry);
 		free(sw);
 	}
@@ -3878,13 +3912,13 @@ search_win(struct swm_region *r, union arg *args)
 	struct ws_win		*win = NULL;
 	struct search_window	*sw = NULL;
 	xcb_window_t		w;
-	XGCValues               gcv;
+	uint32_t		gcv[1], wa[2];
 	int			i;
 	char			s[8];
 	FILE			*lfile;
 	size_t			len;
 	XRectangle		ibox, lbox;
-
+	xcb_screen_t		*screen; 
 	DNPRINTF(SWM_D_MISC, "search_win\n");
 
 	search_r = r;
@@ -3911,28 +3945,33 @@ search_win(struct swm_region *r, union arg *args)
 		}
 		sw->idx = i;
 		sw->win = win;
+		screen = get_screen(sw->idx);
 
 		snprintf(s, sizeof s, "%d", i);
 		len = strlen(s);
 
 		XmbTextExtents(bar_fs, s, len, &ibox, &lbox);
 
-		w = XCreateSimpleWindow(display,
-		    win->id, 0, 0,lbox.width + 4,
-		    bar_fs_extents->max_logical_extent.height, 1,
-		    r->s->c[SWM_S_COLOR_UNFOCUS].color,
-		    r->s->c[SWM_S_COLOR_FOCUS].color);
-
+		w = xcb_generate_id(conn);
+		wa[0] = r->s->c[SWM_S_COLOR_FOCUS].color;
+		wa[1] = r->s->c[SWM_S_COLOR_UNFOCUS].color;
+		xcb_create_window(conn, screen->root_depth, w, win->id,
+			0, 0, lbox.width + 4,
+			bar_fs_extents->max_logical_extent.height, 1,
+			XCB_WINDOW_CLASS_INPUT_OUTPUT, screen->root_visual,
+			XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL, wa);	
+		
 		sw->indicator = w;
 		TAILQ_INSERT_TAIL(&search_wl, sw, entry);
 
-		sw->gc = XCreateGC(display, w, 0, &gcv);
+		sw->gc = xcb_generate_id(conn);
+		gcv[0] = r->s->c[SWM_S_COLOR_BAR].color;		
+		xcb_create_gc(conn, sw->gc, w, XCB_GC_FOREGROUND, gcv); 
 		map_window_raised(w);
-		XSetForeground(display, sw->gc, r->s->c[SWM_S_COLOR_BAR].color);
 
-		DRAWSTRING(display, w, bar_fs, sw->gc, 2,
+		xcb_image_text_8(conn, len, w, sw->gc, 2,
 		    (bar_fs_extents->max_logical_extent.height -
-		    lbox.height) / 2 - lbox.y, s, len);
+		    lbox.height) / 2 - lbox.y, s);
 
 		fprintf(lfile, "%d\n", i);
 		i++;
@@ -3944,7 +3983,7 @@ search_win(struct swm_region *r, union arg *args)
 void
 search_resp_uniconify(char *resp, unsigned long len)
 {
-	unsigned char		*name;
+	char			*name;
 	struct ws_win		*win;
 	char			*s;
 
@@ -3957,10 +3996,10 @@ search_resp_uniconify(char *resp, unsigned long len)
 		if (name == NULL)
 			continue;
 		if (asprintf(&s, "%s.%u", name, win->id) == -1) {
-			XFree(name);
+			free(name);
 			continue;
 		}
-		XFree(name);
+		free(name);
 		if (strncmp(s, resp, len) == 0) {
 			/* XXX this should be a callback to generalize */
 			update_iconic(win, 0);
@@ -4265,14 +4304,14 @@ resize(struct ws_win *win, union arg *args)
 	Time			time = 0;
 	struct swm_region	*r = NULL;
 	int			resize_step = 0;
-	Window			rr, cr;
-	int			x, y, wx, wy;
-	unsigned int		mask;
 	struct swm_geometry	g;
 	int			top = 0, left = 0;
 	int			dx, dy;
-	Cursor			cursor;
 	unsigned int		shape; /* cursor style */
+	xcb_cursor_t		cursor;
+	xcb_font_t		cursor_font;
+	xcb_grab_pointer_reply_t	*gpr;
+	xcb_query_pointer_reply_t	*xpr;
 
 	if (win == NULL)
 		return;
@@ -4329,15 +4368,17 @@ resize(struct ws_win *win, union arg *args)
 		drain_enter_notify();
 
 	/* get cursor offset from window root */
-	if (!XQueryPointer(display, win->id, &rr, &cr, &x, &y, &wx, &wy, &mask))
-	    return;
-
+	xpr = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, win->id),
+		NULL);
+	if (!xpr)
+		return;
+	
 	g = win->g;
 
-	if (wx < WIDTH(win) / 2)
+	if (xpr->win_x < WIDTH(win) / 2)
 		left = 1;
 
-	if (wy < HEIGHT(win) / 2)
+	if (xpr->win_y < HEIGHT(win) / 2)
 		top = 1;
 
 	if (args->id == SWM_ARG_ID_CENTER)
@@ -4347,11 +4388,22 @@ resize(struct ws_win *win, union arg *args)
 	else
 		shape = (left) ? XC_bottom_left_corner : XC_bottom_right_corner;
 
-	cursor = XCreateFontCursor(display, shape);
-
-	if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync,
-	    GrabModeAsync, None, cursor, CurrentTime) != GrabSuccess) {
-		XFreeCursor(display, cursor);
+	cursor_font = xcb_generate_id(conn);
+	xcb_open_font(conn, cursor_font, strlen("cursor"), "cursor");
+
+	cursor = xcb_generate_id(conn);
+	xcb_create_glyph_cursor(conn, cursor, cursor_font, cursor_font,
+		shape, shape + 1, 0, 0, 0, 0xffff, 0xffff, 0xffff);
+
+	gpr = xcb_grab_pointer_reply(conn,
+		xcb_grab_pointer(conn, False, win->id, MOUSEMASK,
+		XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC, XCB_WINDOW_NONE,
+		cursor, XCB_CURRENT_TIME),
+		NULL);
+	if (!gpr) {
+		xcb_free_cursor(conn, cursor);
+		xcb_close_font(conn, cursor_font);
+		free(xpr);
 		return;
 	}
 
@@ -4366,8 +4418,8 @@ resize(struct ws_win *win, union arg *args)
 			break;
 		case MotionNotify:
 			/* cursor offset/delta from start of the operation */
-			dx = ev.xmotion.x_root - x;
-			dy = ev.xmotion.y_root - y;
+			dx = ev.xmotion.x_root - xpr->root_x;
+			dy = ev.xmotion.y_root - xpr->root_y;
 
 			/* vertical */
 			if (top)
@@ -4427,7 +4479,10 @@ resize(struct ws_win *win, union arg *args)
 	store_float_geom(win,r);
 
 	xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
-	XFreeCursor(display, cursor);
+	xcb_free_cursor(conn, cursor);
+	xcb_close_font(conn, cursor_font);
+	free(gpr);
+	free(xpr);
 
 	/* drain events */
 	drain_enter_notify();
@@ -4455,10 +4510,10 @@ move(struct ws_win *win, union arg *args)
 	Time			time = 0;
 	int			move_step = 0;
 	struct swm_region	*r = NULL;
-
-	Window			rr, cr;
-	int			x, y, wx, wy;
-	unsigned int		mask;
+	xcb_font_t			cursor_font;
+	xcb_cursor_t			cursor;
+	xcb_grab_pointer_reply_t	*gpr;
+	xcb_query_pointer_reply_t	*qpr;
 
 	if (win == NULL)
 		return;
@@ -4513,15 +4568,33 @@ move(struct ws_win *win, union arg *args)
 		return;
 	}
 
-	if (XGrabPointer(display, win->id, False, MOUSEMASK, GrabModeAsync,
-	    GrabModeAsync, None, XCreateFontCursor(display, XC_fleur),
-	    CurrentTime) != GrabSuccess)
+	cursor_font = xcb_generate_id(conn);
+	xcb_open_font(conn, cursor_font, strlen("cursor"), "cursor");
+	
+	cursor = xcb_generate_id(conn);
+	xcb_create_glyph_cursor(conn, cursor, cursor_font, cursor_font,
+		XC_fleur, XC_fleur + 1, 0, 0, 0, 0xffff, 0xffff, 0xffff);
+
+	gpr = xcb_grab_pointer_reply(conn,
+		xcb_grab_pointer(conn, False, win->id, MOUSEMASK,
+			XCB_GRAB_MODE_ASYNC, XCB_GRAB_MODE_ASYNC,
+			XCB_WINDOW_NONE, cursor, XCB_CURRENT_TIME),
+		NULL);
+	if (!gpr) {
+		xcb_free_cursor(conn, cursor);
+		xcb_close_font(conn, cursor_font);
 		return;
+	}
 
 	/* get cursor offset from window root */
-	if (!XQueryPointer(display, win->id, &rr, &cr, &x, &y, &wx, &wy, &mask))
-	    return;
-
+	qpr = xcb_query_pointer_reply(conn, xcb_query_pointer(conn, win->id),
+		NULL);
+	if (!qpr) {
+		xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
+		xcb_free_cursor(conn, cursor);
+		xcb_close_font(conn, cursor_font);
+		return;
+	}
 	do {
 		XMaskEvent(display, MOUSEMASK | ExposureMask |
 		    SubstructureRedirectMask, &ev);
@@ -4532,8 +4605,8 @@ move(struct ws_win *win, union arg *args)
 			handler[ev.type](&ev);
 			break;
 		case MotionNotify:
-			X(win) = ev.xmotion.x_root - wx - border_width;
-			Y(win) = ev.xmotion.y_root - wy - border_width;
+			X(win) = ev.xmotion.x_root - qpr->win_x - border_width;
+			Y(win) = ev.xmotion.y_root - qpr->win_y - border_width;
 
 			constrain_window(win, r, 0);
 
@@ -4551,6 +4624,9 @@ move(struct ws_win *win, union arg *args)
 		update_window(win);
 	}
 	store_float_geom(win, r);
+	free(qpr);
+	xcb_free_cursor(conn, cursor);
+	xcb_close_font(conn, cursor_font);
 	xcb_ungrab_pointer(conn, XCB_CURRENT_TIME);
 
 	/* drain events */
@@ -6230,12 +6306,12 @@ out:
 }
 
 void
-set_child_transient(struct ws_win *win, Window *trans)
+set_child_transient(struct ws_win *win, xcb_window_t *trans)
 {
 	struct ws_win		*parent, *w;
-	XWMHints		*wmh = NULL;
 	struct swm_region	*r;
 	struct workspace	*ws;
+	xcb_wm_hints_t		wmh;
 
 	parent = find_window(win->transient);
 	if (parent)
@@ -6244,37 +6320,28 @@ set_child_transient(struct ws_win *win, Window *trans)
 		DNPRINTF(SWM_D_MISC, "set_child_transient: parent doesn't exist"
 		    " for 0x%x trans 0x%x\n", win->id, win->transient);
 
-		if (win->hints == NULL) {
-			warnx("no hints for 0x%x", win->id);
-			return;
-		}
-
-		r = root_to_region(win->wa.root);
+		r = root_to_region(win->wa->root);
 		ws = r->ws;
 		/* parent doen't exist in our window list */
 		TAILQ_FOREACH(w, &ws->winlist, entry) {
-			if (wmh)
-				XFree(wmh);
-
-			if ((wmh = XGetWMHints(display, w->id)) == NULL) {
+			if (xcb_icccm_get_wm_hints_reply(conn,
+					xcb_icccm_get_wm_hints(conn, w->id),
+					&wmh, NULL) != 1) {
 				warnx("can't get hints for 0x%x", w->id);
 				continue;
 			}
 
-			if (win->hints->window_group != wmh->window_group)
+			if (win->hints.window_group != wmh.window_group)
 				continue;
 
 			w->child_trans = win;
 			win->transient = w->id;
 			*trans = w->id;
-			DNPRINTF(SWM_D_MISC, "set_child_transient: asjusting "
+			DNPRINTF(SWM_D_MISC, "set_child_transient: adjusting "
 			    "transient to 0x%x\n", win->transient);
 			break;
 		}
 	}
-
-	if (wmh)
-		XFree(wmh);
 }
 
 long
@@ -6321,19 +6388,21 @@ tryharder:
 struct ws_win *
 manage_window(xcb_window_t id)
 {
-	Window			trans = 0;
+	xcb_window_t		trans = XCB_WINDOW_NONE;
 	struct workspace	*ws;
 	struct ws_win		*win, *ww;
-	int			format, i, ws_idx, n, border_me = 0;
-	unsigned long		nitems, bytes;
-	Atom			ws_idx_atom = 0, type;
-	Atom			*prot = NULL, *pp;
-	unsigned char		ws_idx_str[SWM_PROPLEN], *prop = NULL;
+	int			i, ws_idx, border_me = 0;
+	xcb_atom_t		ws_idx_atom = XCB_ATOM_NONE;
+	char			ws_idx_str[SWM_PROPLEN], *prop = NULL;
+	size_t			proplen;
 	struct swm_region	*r;
 	const char		*errstr;
 	struct pid_e		*p;
 	struct quirk		*qp;
 	uint32_t		event_mask;
+	xcb_atom_t		prot;
+	xcb_get_property_reply_t	*gpr;
+	xcb_get_wm_protocols_reply_t	wpr;
 
 	if ((win = find_window(id)) != NULL)
 		return (win);	/* already being managed */
@@ -6380,15 +6449,39 @@ manage_window(xcb_window_t id)
 	p = find_pid(window_get_pid(id));
 
 	/* Get all the window data in one shot */
-	ws_idx_atom = XInternAtom(display, "_SWM_WS", False);
+	ws_idx_atom = get_atom_from_string("_SWM_WS");
+	fprintf(stderr, "ws_idx_atom: %d\n", ws_idx_atom);
 	if (ws_idx_atom) {
-		XGetWindowProperty(display, id, ws_idx_atom, 0, SWM_PROPLEN,
-		    False, XA_STRING, &type, &format, &nitems, &bytes, &prop);
+		gpr = xcb_get_property_reply(conn,
+			xcb_get_property(conn, False, id, ws_idx_atom,
+				XCB_ATOM_STRING, 0, SWM_PROPLEN),
+			NULL);
+		if (gpr) {
+			proplen = xcb_get_property_value_length(gpr);
+			if (proplen > 0) {
+				prop = malloc(proplen + 1);
+				if (prop) {
+					memcpy(prop,
+					    xcb_get_property_value(gpr),
+					    proplen);	
+					prop[proplen] = '\0';
+				}
+			}
+			free(gpr);
+		}
 	}
-	XGetWindowAttributes(display, id, &win->wa);
-	XGetWMNormalHints(display, id, &win->sh, &win->sh_mask);
-	win->hints = XGetWMHints(display, id);
-	XGetTransientForHint(display, id, &trans);
+	win->wa = xcb_get_geometry_reply(conn,
+		xcb_get_geometry(conn, id),
+		NULL);	
+	xcb_get_wm_normal_hints_reply(conn,
+		xcb_get_wm_normal_hints(conn, id),
+		&win->sh, NULL);
+	xcb_icccm_get_wm_hints_reply(conn,
+		xcb_icccm_get_wm_hints(conn, id),
+		&win->hints, NULL);
+	xcb_get_wm_transient_for_reply(conn,
+		xcb_get_wm_transient_for(conn, id),
+		&trans, NULL);
 	if (trans) {
 		win->transient = trans;
 		set_child_transient(win, &trans);
@@ -6396,16 +6489,21 @@ manage_window(xcb_window_t id)
 		    "transient: 0x%x\n", win->id, win->transient);
 	}
 
+	prot = xcb_atom_get_fast_reply(conn,
+		xcb_atom_get_fast(conn, False, strlen("WM_PROTOCOLS"),
+			"WM_PROTOCOLS"),
+		NULL);
 	/* get supported protocols */
-	if (XGetWMProtocols(display, id, &prot, &n)) {
-		for (i = 0, pp = prot; i < n; i++, pp++) {
-			if (*pp == takefocus)
+	if (xcb_get_wm_protocols_reply(conn,
+			xcb_get_wm_protocols(conn, id, prot),
+			&wpr, NULL)) {
+		for (i = 0; i < wpr.atoms_len; i++) {
+			if (wpr.atoms[i] == takefocus)
 				win->take_focus = 1;
-			if (*pp == adelete)
+			if (wpr.atoms[i] == adelete)
 				win->can_delete = 1;
 		}
-		if (prot)
-			XFree(prot);
+		xcb_get_wm_protocols_reply_wipe(&wpr);
 	}
 
 	win->iconic = get_iconic(win);
@@ -6415,7 +6513,7 @@ manage_window(xcb_window_t id)
 	 * a workspace (either by spawn() or manually moving), and isn't
 	 * transient, * put it in the same workspace
 	 */
-	r = root_to_region(win->wa.root);
+	r = root_to_region(win->wa->root);
 	if (p) {
 		ws = &r->s->ws[p->ws];
 		TAILQ_REMOVE(&pidlist, p, entry);
@@ -6423,7 +6521,7 @@ manage_window(xcb_window_t id)
 		p = NULL;
 	} else if (prop && win->transient == 0) {
 		DNPRINTF(SWM_D_PROP, "manage_window: get _SWM_WS: %s\n", prop);
-		ws_idx = strtonum((const char *)prop, 0, workspace_limit - 1,
+		ws_idx = strtonum(prop, 0, workspace_limit - 1,
 		    &errstr);
 		if (errstr) {
 			DNPRINTF(SWM_D_EVENT, "manage_window: window: #%s: %s",
@@ -6469,10 +6567,10 @@ manage_window(xcb_window_t id)
 	}
 
 	/* ignore window border if there is one. */
-	WIDTH(win) = win->wa.width;
-	HEIGHT(win) = win->wa.height;
-	X(win) = win->wa.x + win->wa.border_width;
-	Y(win) = win->wa.y + win->wa.border_width;
+	WIDTH(win) = win->wa->width;
+	HEIGHT(win) = win->wa->height;
+	X(win) = win->wa->x + win->wa->border_width;
+	Y(win) = win->wa->y + win->wa->border_width;
 	win->bordered = 0;
 	win->g_floatvalid = 0;
 	win->floatmaxed = 0;
@@ -6486,34 +6584,37 @@ manage_window(xcb_window_t id)
 
 	/* Set window properties so we can remember this after reincarnation */
 	if (ws_idx_atom && prop == NULL &&
-	    snprintf((char *)ws_idx_str, SWM_PROPLEN, "%d", ws->idx) <
+	    snprintf(ws_idx_str, SWM_PROPLEN, "%d", ws->idx) <
 	        SWM_PROPLEN) {
 		DNPRINTF(SWM_D_PROP, "manage_window: set _SWM_WS: %s\n",
 		    ws_idx_str);
-		XChangeProperty(display, win->id, ws_idx_atom, XA_STRING, 8,
-		    PropModeReplace, ws_idx_str, strlen((char *)ws_idx_str));
+		xcb_change_property(conn, XCB_PROP_MODE_REPLACE, win->id,
+			ws_idx_atom, XCB_ATOM_STRING, 8, strlen(ws_idx_str),
+			ws_idx_str);
 	}
 	if (prop)
-		XFree(prop);
+		free(prop);
 
 	ewmh_autoquirk(win);
 
-	if (XGetClassHint(display, win->id, &win->ch)) {
+	if (xcb_get_wm_class_reply(conn,
+			xcb_get_wm_class(conn, win->id),
+			&win->ch, NULL)) {
 		DNPRINTF(SWM_D_CLASS, "manage_window: class: %s, name: %s\n",
-		    win->ch.res_class, win->ch.res_name);
+		    win->ch.class_name, win->ch.instance_name);
 
 		/* java is retarded so treat it special */
-		if (strstr(win->ch.res_name, "sun-awt")) {
+		if (strstr(win->ch.instance_name, "sun-awt")) {
 			win->java = 1;
 			border_me = 1;
 		}
 
 		TAILQ_FOREACH(qp, &quirks, entry) {
-			if (!strcmp(win->ch.res_class, qp->class) &&
-			    !strcmp(win->ch.res_name, qp->name)) {
+			if (!strcmp(win->ch.class_name, qp->class) &&
+			    !strcmp(win->ch.instance_name, qp->name)) {
 				DNPRINTF(SWM_D_CLASS, "manage_window: found: "
-				    "class: %s, name: %s\n", win->ch.res_class,
-				    win->ch.res_name);
+				    "class: %s, name: %s\n", win->ch.class_name,
+				    win->ch.instance_name);
 				if (qp->quirk & SWM_Q_FLOAT) {
 					win->floating = 1;
 					border_me = 1;
@@ -6579,10 +6680,10 @@ free_window(struct ws_win *win)
 
 	TAILQ_REMOVE(&win->ws->unmanagedlist, win, entry);
 
-	if (win->ch.res_class)
-		XFree(win->ch.res_class);
-	if (win->ch.res_name)
-		XFree(win->ch.res_name);
+	if (win->wa)
+		free(win->wa);
+	
+	xcb_get_wm_class_reply_wipe(&win->ch);
 
 	kill_refs(win);
 
@@ -6616,11 +6717,6 @@ unmanage_window(struct ws_win *win)
 
 	focus_prev(win);
 
-	if (win->hints) {
-		XFree(win->hints);
-		win->hints = NULL;
-	}
-
 	TAILQ_REMOVE(&win->ws->winlist, win, entry);
 	TAILQ_INSERT_TAIL(&win->ws->unmanagedlist, win, entry);
 }
@@ -6738,7 +6834,7 @@ configurerequest(XEvent *e)
 
 		XConfigureWindow(display, ev->window, ev->value_mask, &wc);
 	} else if ((!win->manual || win->quirks & SWM_Q_ANYWHERE) &&
-	    !(win->sh_mask & EWMH_F_FULLSCREEN)) {
+	    !(win->ewmh_flags & EWMH_F_FULLSCREEN)) {
 		win->g_float.x = ev->x - X(win->ws->r);
 		win->g_float.y = ev->y - Y(win->ws->r);
 		win->g_float.w = ev->width;
@@ -6768,7 +6864,9 @@ configurenotify(XEvent *e)
 
 	win = find_window(e->xconfigure.window);
 	if (win) {
-		XGetWMNormalHints(display, win->id, &win->sh, &win->sh_mask);
+		xcb_get_wm_normal_hints_reply(conn,
+			xcb_get_wm_normal_hints(conn, win->id),
+			&win->sh, NULL);
 		adjust_font(win);
 		if (font_adjusted)
 			stack();
@@ -7001,25 +7099,32 @@ maprequest(XEvent *e)
 {
 	struct ws_win		*win;
 	struct swm_region	*r;
-	XWindowAttributes	wa;
 	XMapRequestEvent	*ev = &e->xmaprequest;
+	xcb_get_window_attributes_reply_t *war;
 
 	DNPRINTF(SWM_D_EVENT, "maprequest: window: 0x%lx\n",
 	    e->xmaprequest.window);
 
-	if (!XGetWindowAttributes(display, ev->window, &wa))
+	war = xcb_get_window_attributes_reply(conn,
+		xcb_get_window_attributes(conn, ev->window),
+		NULL);
+	if (!war)
 		return;
-	if (wa.override_redirect)
+	if (war->override_redirect) {
+		free(war);
 		return;
+	}	
+	free(war);
 
 	win = manage_window(e->xmaprequest.window);
-	if (win == NULL)
+	if (win == NULL) {
 		return; /* can't happen */
+	}
 
 	stack();
 
 	/* make new win focused */
-	r = root_to_region(win->wa.root);
+	r = root_to_region(win->wa->root);
 	if (win->ws == r->ws)
 		focus_magic(win);
 }
@@ -7030,11 +7135,30 @@ propertynotify(XEvent *e)
 	struct ws_win		*win;
 	XPropertyEvent		*ev = &e->xproperty;
 #ifdef SWM_DEBUG
-	char			*name;
-	name = XGetAtomName(display, ev->atom);
-	DNPRINTF(SWM_D_EVENT, "propertynotify: window: 0x%lx, atom: %s\n",
-	    ev->window, name);
-	XFree(name);
+	char				*name;
+	size_t				len;
+	xcb_get_atom_name_reply_t	*r;
+
+	r = xcb_get_atom_name_reply(conn,
+		xcb_get_atom_name(conn, ev->atom),
+		NULL);
+	if (r) {
+		len = xcb_get_atom_name_name_length(r);
+		if (len > 0) {
+			name = malloc(len + 1);
+			if (name) {
+				memcpy(name, xcb_get_atom_name_name(r), len);
+				name[len] = '\0';
+				
+				DNPRINTF(SWM_D_EVENT,
+				 	"propertynotify: window: 0x%lx, "
+					"atom: %s\n",
+	    				ev->window, name);
+				free(name);
+			}
+		}
+		free(r);
+	}
 #endif
 
 	win = find_window(ev->window);
@@ -7055,7 +7179,7 @@ propertynotify(XEvent *e)
 		long		mask;
 		XGetWMNormalHints(display, win->id, &win->sh, &mask);
 		warnx("normal hints: flag 0x%x", win->sh.flags);
-		if (win->sh.flags & PMinSize) {
+		if (win->sh.flags & XCB_SIZE_HINT_P_MIN_SIZE) {
 			WIDTH(win) = win->sh.min_width;
 			HEIGHT(win) = win->sh.min_height;
 			warnx("min %d %d", WIDTH(win), HEIGHT(win));
@@ -7302,16 +7426,17 @@ void
 scan_xrandr(int i)
 {
 #ifdef SWM_XRR_HAS_CRTC
-	int			c;
-	int			ncrtc = 0;
+	int						c;
+	int						ncrtc = 0;
 #endif /* SWM_XRR_HAS_CRTC */
-	struct swm_region	*r;
-	int			num_screens;
+	struct swm_region				*r;
+	int						num_screens;
 	xcb_randr_get_screen_resources_current_cookie_t	src;
 	xcb_randr_get_screen_resources_current_reply_t	*srr;
-	xcb_randr_get_crtc_info_cookie_t	cic;
-	xcb_randr_get_crtc_info_reply_t		*cir = NULL;
-	xcb_randr_crtc_t	*crtc;
+	xcb_randr_get_crtc_info_cookie_t		cic;
+	xcb_randr_get_crtc_info_reply_t			*cir = NULL;
+	xcb_randr_crtc_t				*crtc;
+	xcb_screen_t					*screen = get_screen(i);
 
 	num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
 	if (i >= num_screens)
@@ -7333,37 +7458,40 @@ scan_xrandr(int i)
 			screens[i].root);
 		srr = xcb_randr_get_screen_resources_current_reply(conn, src,
 			NULL);
-		if (srr == NULL)
+		if (srr == NULL) {
 			new_region(&screens[i], 0, 0,
-			    DisplayWidth(display, i),
-			    DisplayHeight(display, i));
-		else
+			    screen->width_in_pixels,
+			    screen->height_in_pixels);
+			return;
+		} else
 			ncrtc = srr->num_crtcs;
 		for (c = 0; c < ncrtc; c++) {
 			crtc = xcb_randr_get_screen_resources_current_crtcs(srr);
 			cic = xcb_randr_get_crtc_info(conn, crtc[c],
 				XCB_CURRENT_TIME);
 			cir = xcb_randr_get_crtc_info_reply(conn, cic, NULL);
-			if (cir && cir->num_outputs == 0)
+			if (cir == NULL)
+				continue;
+			if (cir->num_outputs == 0) {
+				free(cir);
 				continue;
+			}
 
-			if (cir == NULL || cir->mode == 0)
+			if (cir->mode == 0)
 				new_region(&screens[i], 0, 0,
-				    DisplayWidth(display, i),
-				    DisplayHeight(display, i));
+				    screen->width_in_pixels,
+				    screen->height_in_pixels);
 			else
 				new_region(&screens[i],
 				    cir->x, cir->y, cir->width, cir->height);
-		}
-		if (srr)
-			free(srr);
-		if (cir)
 			free(cir);
+		}
+		free(srr);
 	} else
 #endif /* SWM_XRR_HAS_CRTC */
 	{
-		new_region(&screens[i], 0, 0, DisplayWidth(display, i),
-		    DisplayHeight(display, i));
+		new_region(&screens[i], 0, 0, screen->width_in_pixels,
+		    screen->height_in_pixels);
 	}
 }
 
@@ -7474,8 +7602,10 @@ setup_screens(void)
 {
 	int			i, j, k, num_screens;
 	struct workspace	*ws;
-	XGCValues		gcv;
+	uint32_t		gcv[1], wa[1];
 	const xcb_query_extension_reply_t *qep;
+	xcb_cursor_t				cursor;
+	xcb_font_t				cursor_font;
 	xcb_randr_query_version_cookie_t	c;
 	xcb_randr_query_version_reply_t		*r;
 
@@ -7497,6 +7627,14 @@ setup_screens(void)
 	qep = xcb_get_extension_data(conn, &xcb_randr_id);
 	xrandr_eventbase = qep->first_event;
 
+	cursor_font = xcb_generate_id(conn);
+	xcb_open_font(conn, cursor_font, strlen("cursor"), "cursor");
+
+	cursor = xcb_generate_id(conn);
+	xcb_create_glyph_cursor(conn, cursor, cursor_font, cursor_font,
+		XC_left_ptr, XC_left_ptr + 1, 0, 0, 0, 0xffff, 0xffff, 0xffff);
+	wa[0] = cursor;
+
 	/* map physical screens */
 	for (i = 0; i < num_screens; i++) {
 		DNPRINTF(SWM_D_WS, "setup_screens: init screen: %d\n", i);
@@ -7513,13 +7651,14 @@ setup_screens(void)
 		setscreencolor("rgb:a0/a0/a0", i + 1, SWM_S_COLOR_BAR_FONT);
 
 		/* create graphics context on screen */
-		gcv.graphics_exposures = 0;
-		screens[i].bar_gc = XCreateGC(display, screens[i].root,
-			GCGraphicsExposures, &gcv);
+		screens[i].bar_gc = xcb_generate_id(conn);
+		gcv[0] = 0;
+		xcb_create_gc(conn, screens[i].bar_gc, screens[i].root,
+			XCB_GC_GRAPHICS_EXPOSURES, gcv);
 
 		/* set default cursor */
-		XDefineCursor(display, screens[i].root,
-		    XCreateFontCursor(display, XC_left_ptr));
+		xcb_change_window_attributes(conn, screens[i].root,
+			XCB_CW_CURSOR, wa); 	
 
 		/* init all workspaces */
 		/* XXX these should be dynamically allocated too */
@@ -7547,6 +7686,8 @@ setup_screens(void)
 			xcb_randr_select_input(conn, screens[i].root,
 				XCB_RANDR_NOTIFY_MASK_SCREEN_CHANGE);
 	}
+	xcb_free_cursor(conn, cursor);
+	xcb_close_font(conn, cursor_font);
 }
 
 void
@@ -7565,6 +7706,8 @@ workaround(void)
 	int			i, num_screens;
 	xcb_atom_t		netwmcheck, netwmname, utf8_string;
 	xcb_window_t		root, win;
+	xcb_screen_t		*screen;
+	uint32_t		wa[2];
 
 	/* work around sun jdk bugs, code from wmname */
 	netwmcheck = get_atom_from_string("_NET_SUPPORTING_WM_CHECK");
@@ -7574,9 +7717,15 @@ workaround(void)
 	num_screens = xcb_setup_roots_length(xcb_get_setup(conn));
 	for (i = 0; i < num_screens; i++) {
 		root = screens[i].root;
-		win = XCreateSimpleWindow(display,root, 0, 0, 1, 1, 0,
-		    screens[i].c[SWM_S_COLOR_UNFOCUS].color,
-		    screens[i].c[SWM_S_COLOR_UNFOCUS].color);
+		screen = get_screen(i);
+
+		win = xcb_generate_id(conn);
+		wa[0] = screens[i].c[SWM_S_COLOR_UNFOCUS].color;
+		wa[1] = screens[i].c[SWM_S_COLOR_UNFOCUS].color;
+		xcb_create_window(conn, screen->root_depth, win, 0,
+			0, 0, 1, 1, 0, XCB_WINDOW_CLASS_INPUT_OUTPUT,
+			screen->root_visual,
+			XCB_CW_BACK_PIXEL | XCB_CW_BORDER_PIXEL, wa);
 
 		xcb_change_property(conn, XCB_PROP_MODE_REPLACE, root,
 			netwmcheck, XCB_ATOM_WINDOW, 32, 1, &win);
@@ -7792,8 +7941,8 @@ done:
 	bar_extra_stop();
 
 	for (i = 0; i < num_screens; ++i)
-		if (screens[i].bar_gc != NULL)
-			XFreeGC(display, screens[i].bar_gc);
+		if (screens[i].bar_gc != 0)
+			xcb_free_gc(conn, screens[i].bar_gc);
 	XFreeFontSet(display, bar_fs);
 	xcb_disconnect(conn);
 	XCloseDisplay(display);