From a3f27546681a6a92e1e37ed7692428c36b486a8e Mon Sep 17 00:00:00 2001
From: Tony Crisci <tony@dubstepdish.com>
Date: Tue, 24 Oct 2017 12:00:43 -0400
Subject: xwm: add surface to rootston on surface commit

---
 include/wlr/xwayland.h | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

(limited to 'include/wlr/xwayland.h')

diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h
index c25d0eb0..0398ff28 100644
--- a/include/wlr/xwayland.h
+++ b/include/wlr/xwayland.h
@@ -66,14 +66,16 @@ struct wlr_xwayland_surface_size_hints {
 
 struct wlr_xwayland_surface {
 	xcb_window_t window_id;
+	struct wlr_xwm *xwm;
 	uint32_t surface_id;
 	struct wl_list link;
 
 	struct wlr_surface *surface;
-	struct wl_listener surface_destroy_listener;
 	int16_t x, y;
 	uint16_t width, height;
 	bool override_redirect;
+	bool mapped;
+	bool added;
 
 	char *title;
 	char *class;
@@ -95,9 +97,7 @@ struct wlr_xwayland_surface {
 
 	struct {
 		struct wl_signal destroy;
-
 		struct wl_signal request_configure;
-
 		struct wl_signal set_title;
 		struct wl_signal set_class;
 		struct wl_signal set_parent;
@@ -106,6 +106,9 @@ struct wlr_xwayland_surface {
 		struct wl_signal set_window_type;
 	} events;
 
+	struct wl_listener surface_destroy;
+	struct wl_listener surface_commit;
+
 	void *data;
 };
 
-- 
cgit v1.2.3


From 79e14f65e0a005b1ab47b294dd2368cb3d55cb33 Mon Sep 17 00:00:00 2001
From: Tony Crisci <tony@dubstepdish.com>
Date: Tue, 24 Oct 2017 14:37:18 -0400
Subject: xwm: fix lists

---
 include/wlr/xwayland.h | 11 ++++++--
 xwayland/xwm.c         | 73 +++++++++++++++++++++++++++++++++++++-------------
 xwayland/xwm.h         |  4 +--
 3 files changed, 66 insertions(+), 22 deletions(-)

(limited to 'include/wlr/xwayland.h')

diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h
index 0398ff28..2cd1db92 100644
--- a/include/wlr/xwayland.h
+++ b/include/wlr/xwayland.h
@@ -25,7 +25,7 @@ struct wlr_xwayland {
 	struct wl_event_source *sigusr1_source;
 	struct wl_listener destroy_listener;
 	struct wlr_xwm *xwm;
-	struct wl_list displayable_surfaces;
+	struct wl_list displayable_surfaces; // wlr_xwayland_surface::displayable_link
 
 	struct {
 		struct wl_signal new_surface;
@@ -68,7 +68,14 @@ struct wlr_xwayland_surface {
 	xcb_window_t window_id;
 	struct wlr_xwm *xwm;
 	uint32_t surface_id;
-	struct wl_list link;
+
+	struct wl_list displayable_link;
+	// XXX: I think this is just a list of all the surfaces
+	struct wl_list new_link;
+	struct wl_list unpaired_link;
+	bool displayable;
+	bool unpaired;
+
 
 	struct wlr_surface *surface;
 	int16_t x, y;
diff --git a/xwayland/xwm.c b/xwayland/xwm.c
index f72f58b2..0839ae20 100644
--- a/xwayland/xwm.c
+++ b/xwayland/xwm.c
@@ -36,10 +36,32 @@ const char *atom_map[ATOM_LAST] = {
 
 /* General helpers */
 // TODO: replace this with hash table?
-static struct wlr_xwayland_surface *lookup_surface(struct wl_list *list,
+static struct wlr_xwayland_surface *lookup_surface(struct wlr_xwm *xwm,
 		xcb_window_t window_id) {
 	struct wlr_xwayland_surface *surface;
-	wl_list_for_each(surface, list, link) {
+	wl_list_for_each(surface, &xwm->new_surfaces, new_link) {
+		if (surface->window_id == window_id) {
+			return surface;
+		}
+	}
+	return NULL;
+}
+
+static struct wlr_xwayland_surface *lookup_displayable_surface(struct wlr_xwm *xwm,
+		xcb_window_t window_id) {
+	struct wlr_xwayland_surface *surface;
+	wl_list_for_each(surface, &xwm->xwayland->displayable_surfaces, displayable_link) {
+		if (surface->window_id == window_id) {
+			return surface;
+		}
+	}
+	return NULL;
+}
+
+static struct wlr_xwayland_surface *lookup_unpaired_surface(struct wlr_xwm *xwm,
+		xcb_window_t window_id) {
+	struct wlr_xwayland_surface *surface;
+	wl_list_for_each(surface, &xwm->unpaired_surfaces, unpaired_link) {
 		if (surface->window_id == window_id) {
 			return surface;
 		}
@@ -50,9 +72,9 @@ static struct wlr_xwayland_surface *lookup_surface(struct wl_list *list,
 static struct wlr_xwayland_surface *lookup_surface_any(struct wlr_xwm *xwm,
 		xcb_window_t window_id) {
 	struct wlr_xwayland_surface *surface;
-	if ((surface = lookup_surface(&xwm->xwayland->displayable_surfaces, window_id)) ||
-			(surface = lookup_surface(&xwm->unpaired_surfaces, window_id)) ||
-			(surface = lookup_surface(&xwm->new_surfaces, window_id))) {
+	if ((surface = lookup_displayable_surface(xwm, window_id)) ||
+			(surface = lookup_unpaired_surface(xwm, window_id)) ||
+			(surface = lookup_surface(xwm, window_id))) {
 		return surface;
 	}
 	return NULL;
@@ -82,7 +104,7 @@ static struct wlr_xwayland_surface *wlr_xwayland_surface_create(
 	surface->width = width;
 	surface->height = height;
 	surface->override_redirect = override_redirect;
-	wl_list_insert(&xwm->new_surfaces, &surface->link);
+	wl_list_insert(&xwm->new_surfaces, &surface->new_link);
 	surface->state = wlr_list_create();
 	wl_signal_init(&surface->events.destroy);
 	wl_signal_init(&surface->events.request_configure);
@@ -97,7 +119,19 @@ static struct wlr_xwayland_surface *wlr_xwayland_surface_create(
 
 static void wlr_xwayland_surface_destroy(struct wlr_xwayland_surface *surface) {
 	wl_signal_emit(&surface->events.destroy, surface);
-	wl_list_remove(&surface->link);
+
+	wl_list_remove(&surface->new_link);
+
+	if (surface->unpaired) {
+		wl_list_remove(&surface->unpaired_link);
+		surface->unpaired = false;
+	}
+
+	if (surface->displayable) {
+		wl_list_remove(&surface->displayable_link);
+		surface->displayable = false;
+	}
+
 	for (size_t i = 0; i < surface->state->length; i++) {
 		free(surface->state->items[i]);
 	}
@@ -470,9 +504,11 @@ static void map_shell_surface(struct wlr_xwm *xwm,
 		read_surface_property(xwm, xsurface, props[i]);
 	}
 
-	wl_list_remove(&xsurface->link);
-	wl_list_insert(&xwm->xwayland->displayable_surfaces,
-		&xsurface->link);
+	if (!xsurface->displayable) {
+		wl_list_insert(&xwm->xwayland->displayable_surfaces,
+			&xsurface->displayable_link);
+		xsurface->displayable = true;
+	}
 
 	xsurface->surface_commit.notify = handle_surface_commit;
 	wl_signal_add(&surface->events.commit, &xsurface->surface_commit);
@@ -594,8 +630,7 @@ static void handle_client_message(struct wlr_xwm *xwm,
 	wlr_log(L_DEBUG, "XCB_CLIENT_MESSAGE (%u)", ev->window);
 
 	if (ev->type == xwm->atoms[WL_SURFACE_ID]) {
-		struct wlr_xwayland_surface *surface = lookup_surface(
-			&xwm->new_surfaces, ev->window);
+		struct wlr_xwayland_surface *surface = lookup_surface(xwm, ev->window);
 		if (surface == NULL) {
 			wlr_log(L_DEBUG, "client message WL_SURFACE_ID but no new window %u ?",
 				ev->window);
@@ -608,8 +643,10 @@ static void handle_client_message(struct wlr_xwm *xwm,
 		if (resource) {
 			map_shell_surface(xwm, surface, wl_resource_get_user_data(resource));
 		} else {
-			wl_list_remove(&surface->link);
-			wl_list_insert(&xwm->unpaired_surfaces, &surface->link);
+			if (!surface->unpaired) {
+				wl_list_insert(&xwm->unpaired_surfaces, &surface->unpaired_link);
+				surface->unpaired = true;
+			}
 		}
 	} else if (ev->type == xwm->atoms[NET_WM_STATE]) {
 		struct wlr_xwayland_surface *surface = lookup_surface_any(xwm,
@@ -687,7 +724,7 @@ static void handle_compositor_surface_create(struct wl_listener *listener, void
 
 	uint32_t surface_id = wl_resource_get_id(surface->resource);
 	struct wlr_xwayland_surface *xwayland_surface;
-	wl_list_for_each(xwayland_surface, &xwm->unpaired_surfaces, link) {
+	wl_list_for_each(xwayland_surface, &xwm->unpaired_surfaces, unpaired_link) {
 		if (xwayland_surface->surface_id == surface_id) {
 			map_shell_surface(xwm, xwayland_surface, surface);
 			xcb_flush(xwm->xcb_conn);
@@ -803,13 +840,13 @@ void xwm_destroy(struct wlr_xwm *xwm) {
 	}
 	struct wlr_xwayland_surface *surface, *tmp;
 	wl_list_for_each_safe(surface, tmp, &xwm->xwayland->displayable_surfaces,
-			link) {
+			displayable_link) {
 		wlr_xwayland_surface_destroy(surface);
 	}
-	wl_list_for_each_safe(surface, tmp, &xwm->new_surfaces, link) {
+	wl_list_for_each_safe(surface, tmp, &xwm->new_surfaces, new_link) {
 		wlr_xwayland_surface_destroy(surface);
 	}
-	wl_list_for_each_safe(surface, tmp, &xwm->unpaired_surfaces, link) {
+	wl_list_for_each_safe(surface, tmp, &xwm->unpaired_surfaces, unpaired_link) {
 		wlr_xwayland_surface_destroy(surface);
 	}
 	wl_list_remove(&xwm->compositor_surface_create.link);
diff --git a/xwayland/xwm.h b/xwayland/xwm.h
index b557a331..9ae084d2 100644
--- a/xwayland/xwm.h
+++ b/xwayland/xwm.h
@@ -44,8 +44,8 @@ struct wlr_xwm {
 
 	struct wlr_xwayland_surface *focus_surface;
 
-	struct wl_list new_surfaces;
-	struct wl_list unpaired_surfaces;
+	struct wl_list new_surfaces; // wlr_xwayland_surface::new_link
+	struct wl_list unpaired_surfaces; // wlr_xwayland_surface::unpaired_link
 
 	const xcb_query_extension_reply_t *xfixes;
 
-- 
cgit v1.2.3


From 2ff94d0036833b85f54c8be0ffb98c49be168be2 Mon Sep 17 00:00:00 2001
From: Tony Crisci <tony@dubstepdish.com>
Date: Tue, 24 Oct 2017 18:57:20 -0400
Subject: xwm: get rid of displayable surfaces list

---
 include/wlr/xwayland.h |   8 +---
 xwayland/xwayland.c    |   1 -
 xwayland/xwm.c         | 107 ++++++++++++++++++-------------------------------
 xwayland/xwm.h         |   2 +-
 4 files changed, 42 insertions(+), 76 deletions(-)

(limited to 'include/wlr/xwayland.h')

diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h
index 2cd1db92..3d5a204c 100644
--- a/include/wlr/xwayland.h
+++ b/include/wlr/xwayland.h
@@ -25,7 +25,6 @@ struct wlr_xwayland {
 	struct wl_event_source *sigusr1_source;
 	struct wl_listener destroy_listener;
 	struct wlr_xwm *xwm;
-	struct wl_list displayable_surfaces; // wlr_xwayland_surface::displayable_link
 
 	struct {
 		struct wl_signal new_surface;
@@ -69,13 +68,8 @@ struct wlr_xwayland_surface {
 	struct wlr_xwm *xwm;
 	uint32_t surface_id;
 
-	struct wl_list displayable_link;
-	// XXX: I think this is just a list of all the surfaces
-	struct wl_list new_link;
+	struct wl_list link;
 	struct wl_list unpaired_link;
-	bool displayable;
-	bool unpaired;
-
 
 	struct wlr_surface *surface;
 	int16_t x, y;
diff --git a/xwayland/xwayland.c b/xwayland/xwayland.c
index f1599911..81bac2ce 100644
--- a/xwayland/xwayland.c
+++ b/xwayland/xwayland.c
@@ -205,7 +205,6 @@ static bool wlr_xwayland_init(struct wlr_xwayland *wlr_xwayland,
 	wlr_xwayland->x_fd[0] = wlr_xwayland->x_fd[1] = -1;
 	wlr_xwayland->wl_fd[0] = wlr_xwayland->wl_fd[1] = -1;
 	wlr_xwayland->wm_fd[0] = wlr_xwayland->wm_fd[1] = -1;
-	wl_list_init(&wlr_xwayland->displayable_surfaces);
 	wl_signal_init(&wlr_xwayland->events.new_surface);
 
 	wlr_xwayland->display = open_display_sockets(wlr_xwayland->x_fd);
diff --git a/xwayland/xwm.c b/xwayland/xwm.c
index 0839ae20..87498fe2 100644
--- a/xwayland/xwm.c
+++ b/xwayland/xwm.c
@@ -39,18 +39,7 @@ const char *atom_map[ATOM_LAST] = {
 static struct wlr_xwayland_surface *lookup_surface(struct wlr_xwm *xwm,
 		xcb_window_t window_id) {
 	struct wlr_xwayland_surface *surface;
-	wl_list_for_each(surface, &xwm->new_surfaces, new_link) {
-		if (surface->window_id == window_id) {
-			return surface;
-		}
-	}
-	return NULL;
-}
-
-static struct wlr_xwayland_surface *lookup_displayable_surface(struct wlr_xwm *xwm,
-		xcb_window_t window_id) {
-	struct wlr_xwayland_surface *surface;
-	wl_list_for_each(surface, &xwm->xwayland->displayable_surfaces, displayable_link) {
+	wl_list_for_each(surface, &xwm->surfaces, link) {
 		if (surface->window_id == window_id) {
 			return surface;
 		}
@@ -69,17 +58,6 @@ static struct wlr_xwayland_surface *lookup_unpaired_surface(struct wlr_xwm *xwm,
 	return NULL;
 }
 
-static struct wlr_xwayland_surface *lookup_surface_any(struct wlr_xwm *xwm,
-		xcb_window_t window_id) {
-	struct wlr_xwayland_surface *surface;
-	if ((surface = lookup_displayable_surface(xwm, window_id)) ||
-			(surface = lookup_unpaired_surface(xwm, window_id)) ||
-			(surface = lookup_surface(xwm, window_id))) {
-		return surface;
-	}
-	return NULL;
-}
-
 static struct wlr_xwayland_surface *wlr_xwayland_surface_create(
 		struct wlr_xwm *xwm, xcb_window_t window_id, int16_t x, int16_t y,
 		uint16_t width, uint16_t height, bool override_redirect) {
@@ -104,7 +82,7 @@ static struct wlr_xwayland_surface *wlr_xwayland_surface_create(
 	surface->width = width;
 	surface->height = height;
 	surface->override_redirect = override_redirect;
-	wl_list_insert(&xwm->new_surfaces, &surface->new_link);
+	wl_list_insert(&xwm->surfaces, &surface->link);
 	surface->state = wlr_list_create();
 	wl_signal_init(&surface->events.destroy);
 	wl_signal_init(&surface->events.request_configure);
@@ -120,16 +98,10 @@ static struct wlr_xwayland_surface *wlr_xwayland_surface_create(
 static void wlr_xwayland_surface_destroy(struct wlr_xwayland_surface *surface) {
 	wl_signal_emit(&surface->events.destroy, surface);
 
-	wl_list_remove(&surface->new_link);
+	wl_list_remove(&surface->link);
 
-	if (surface->unpaired) {
+	if (surface->surface_id) {
 		wl_list_remove(&surface->unpaired_link);
-		surface->unpaired = false;
-	}
-
-	if (surface->displayable) {
-		wl_list_remove(&surface->displayable_link);
-		surface->displayable = false;
 	}
 
 	for (size_t i = 0; i < surface->state->length; i++) {
@@ -229,7 +201,7 @@ static void read_surface_parent(struct wlr_xwm *xwm,
 
 	xcb_window_t *xid = xcb_get_property_value(reply);
 	if (xid != NULL) {
-		surface->parent = lookup_surface_any(xwm, *xid);
+		surface->parent = lookup_surface(xwm, *xid);
 	} else {
 		surface->parent = NULL;
 	}
@@ -477,6 +449,7 @@ static void handle_surface_destroy(struct wl_listener *listener, void *data) {
 	struct wlr_xwayland_surface *xsurface =
 		wl_container_of(listener, xsurface, surface_destroy);
 
+	xsurface->surface = NULL;
 	// TODO destroy xwayland surface?
 }
 
@@ -504,12 +477,6 @@ static void map_shell_surface(struct wlr_xwm *xwm,
 		read_surface_property(xwm, xsurface, props[i]);
 	}
 
-	if (!xsurface->displayable) {
-		wl_list_insert(&xwm->xwayland->displayable_surfaces,
-			&xsurface->displayable_link);
-		xsurface->displayable = true;
-	}
-
 	xsurface->surface_commit.notify = handle_surface_commit;
 	wl_signal_add(&surface->events.commit, &xsurface->surface_commit);
 
@@ -530,7 +497,7 @@ static void handle_create_notify(struct wlr_xwm *xwm,
 static void handle_destroy_notify(struct wlr_xwm *xwm,
 		xcb_destroy_notify_event_t *ev) {
 	wlr_log(L_DEBUG, "XCB_DESTROY_NOTIFY (%u)", ev->window);
-	struct wlr_xwayland_surface *surface = lookup_surface_any(xwm, ev->window);
+	struct wlr_xwayland_surface *surface = lookup_surface(xwm, ev->window);
 	if (surface == NULL) {
 		return;
 	}
@@ -541,7 +508,7 @@ static void handle_configure_request(struct wlr_xwm *xwm,
 		xcb_configure_request_event_t *ev) {
 	wlr_log(L_DEBUG, "XCB_CONFIGURE_REQUEST (%u) [%ux%u+%d,%d]", ev->window,
 		ev->width, ev->height, ev->x, ev->y);
-	struct wlr_xwayland_surface *surface = lookup_surface_any(xwm, ev->window);
+	struct wlr_xwayland_surface *surface = lookup_surface(xwm, ev->window);
 	if (surface == NULL) {
 		return;
 	}
@@ -574,7 +541,7 @@ static void handle_configure_request(struct wlr_xwm *xwm,
 static void handle_configure_notify(struct wlr_xwm *xwm,
 		xcb_configure_notify_event_t *ev) {
 	struct wlr_xwayland_surface *xsurface =
-		lookup_surface_any(xwm, ev->window);
+		lookup_surface(xwm, ev->window);
 
 	if (!xsurface) {
 		return;
@@ -594,7 +561,7 @@ static void handle_map_request(struct wlr_xwm *xwm,
 
 static void handle_map_notify(struct wlr_xwm *xwm, xcb_map_notify_event_t *ev) {
 	wlr_log(L_DEBUG, "XCB_MAP_NOTIFY (%u)", ev->window);
-	struct wlr_xwayland_surface *surface = lookup_surface_any(xwm, ev->window);
+	struct wlr_xwayland_surface *surface = lookup_surface(xwm, ev->window);
 	if (surface != NULL) {
 		surface->override_redirect = ev->override_redirect;
 	} else {
@@ -606,18 +573,32 @@ static void handle_map_notify(struct wlr_xwm *xwm, xcb_map_notify_event_t *ev) {
 static void handle_unmap_notify(struct wlr_xwm *xwm,
 		xcb_unmap_notify_event_t *ev) {
 	wlr_log(L_DEBUG, "XCB_UNMAP_NOTIFY (%u)", ev->window);
-	struct wlr_xwayland_surface *surface = lookup_surface_any(xwm, ev->window);
-	if (surface == NULL) {
+	struct wlr_xwayland_surface *xsurface = lookup_surface(xwm, ev->window);
+	if (xsurface == NULL) {
 		return;
 	}
-	// TODO: remove pointer to surface only?
-	wlr_xwayland_surface_destroy(surface);
+
+	if (xsurface->surface_id) {
+		// Make sure we're not on the unpaired surface list or we
+		// could be assigned a surface during surface creation that
+		// was mapped before this unmap request.
+		wl_list_remove(&xsurface->unpaired_link);
+		xsurface->surface_id = 0;
+	}
+
+	if (xsurface->surface) {
+		wl_list_remove(&xsurface->surface_commit.link);
+		wl_list_remove(&xsurface->surface_destroy.link);
+		xsurface->surface = NULL;
+	}
+
+	wlr_xwayland_surface_destroy(xsurface);
 }
 
 static void handle_property_notify(struct wlr_xwm *xwm,
 		xcb_property_notify_event_t *ev) {
 	wlr_log(L_DEBUG, "XCB_PROPERTY_NOTIFY (%u)", ev->window);
-	struct wlr_xwayland_surface *surface = lookup_surface_any(xwm, ev->window);
+	struct wlr_xwayland_surface *surface = lookup_surface(xwm, ev->window);
 	if (surface == NULL) {
 		return;
 	}
@@ -636,21 +617,20 @@ static void handle_client_message(struct wlr_xwm *xwm,
 				ev->window);
 			return;
 		}
-		surface->surface_id = ev->data.data32[0];
 		/* Check if we got notified after wayland surface create event */
-		struct wl_resource *resource = wl_client_get_object(
-			xwm->xwayland->client, surface->surface_id);
+		uint32_t id = ev->data.data32[0];
+		struct wl_resource *resource =
+			wl_client_get_object(xwm->xwayland->client, id);
 		if (resource) {
-			map_shell_surface(xwm, surface, wl_resource_get_user_data(resource));
+			surface->surface_id = 0;
+			map_shell_surface(xwm,
+				surface, wl_resource_get_user_data(resource));
 		} else {
-			if (!surface->unpaired) {
-				wl_list_insert(&xwm->unpaired_surfaces, &surface->unpaired_link);
-				surface->unpaired = true;
-			}
+			surface->surface_id = id;
+			wl_list_insert(&xwm->unpaired_surfaces, &surface->unpaired_link);
 		}
 	} else if (ev->type == xwm->atoms[NET_WM_STATE]) {
-		struct wlr_xwayland_surface *surface = lookup_surface_any(xwm,
-			ev->window);
+		struct wlr_xwayland_surface *surface = lookup_surface(xwm, ev->window);
 		if (surface == NULL) {
 			return;
 		}
@@ -839,14 +819,7 @@ void xwm_destroy(struct wlr_xwm *xwm) {
 		wl_event_source_remove(xwm->event_source);
 	}
 	struct wlr_xwayland_surface *surface, *tmp;
-	wl_list_for_each_safe(surface, tmp, &xwm->xwayland->displayable_surfaces,
-			displayable_link) {
-		wlr_xwayland_surface_destroy(surface);
-	}
-	wl_list_for_each_safe(surface, tmp, &xwm->new_surfaces, new_link) {
-		wlr_xwayland_surface_destroy(surface);
-	}
-	wl_list_for_each_safe(surface, tmp, &xwm->unpaired_surfaces, unpaired_link) {
+	wl_list_for_each_safe(surface, tmp, &xwm->surfaces, link) {
 		wlr_xwayland_surface_destroy(surface);
 	}
 	wl_list_remove(&xwm->compositor_surface_create.link);
@@ -891,7 +864,7 @@ struct wlr_xwm *xwm_create(struct wlr_xwayland *wlr_xwayland) {
 	}
 
 	xwm->xwayland = wlr_xwayland;
-	wl_list_init(&xwm->new_surfaces);
+	wl_list_init(&xwm->surfaces);
 	wl_list_init(&xwm->unpaired_surfaces);
 
 	xwm->xcb_conn = xcb_connect_to_fd(wlr_xwayland->wm_fd[0], NULL);
diff --git a/xwayland/xwm.h b/xwayland/xwm.h
index 9ae084d2..2bb1ff0b 100644
--- a/xwayland/xwm.h
+++ b/xwayland/xwm.h
@@ -44,7 +44,7 @@ struct wlr_xwm {
 
 	struct wlr_xwayland_surface *focus_surface;
 
-	struct wl_list new_surfaces; // wlr_xwayland_surface::new_link
+	struct wl_list surfaces; // wlr_xwayland_surface::link
 	struct wl_list unpaired_surfaces; // wlr_xwayland_surface::unpaired_link
 
 	const xcb_query_extension_reply_t *xfixes;
-- 
cgit v1.2.3


From e5ee01254b442ae2f742a7044c56753fef13de76 Mon Sep 17 00:00:00 2001
From: Tony Crisci <tony@dubstepdish.com>
Date: Tue, 24 Oct 2017 21:07:46 -0400
Subject: xwm: map and unmap notify

---
 include/rootston/view.h |  2 ++
 include/wlr/xwayland.h  |  2 ++
 rootston/xwayland.c     | 37 +++++++++++++++++++++++++++++++++++++
 xwayland/xwm.c          | 27 ++++++++++++---------------
 4 files changed, 53 insertions(+), 15 deletions(-)

(limited to 'include/wlr/xwayland.h')

diff --git a/include/rootston/view.h b/include/rootston/view.h
index 7d297329..1a0de6de 100644
--- a/include/rootston/view.h
+++ b/include/rootston/view.h
@@ -34,6 +34,8 @@ struct roots_xwayland_surface {
 	// TODO: Maybe destroy listener should go in roots_view
 	struct wl_listener destroy;
 	struct wl_listener request_configure;
+	struct wl_listener map_notify;
+	struct wl_listener unmap_notify;
 };
 
 enum roots_view_type {
diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h
index 3d5a204c..efee3d9f 100644
--- a/include/wlr/xwayland.h
+++ b/include/wlr/xwayland.h
@@ -99,6 +99,8 @@ struct wlr_xwayland_surface {
 	struct {
 		struct wl_signal destroy;
 		struct wl_signal request_configure;
+		struct wl_signal map_notify;
+		struct wl_signal unmap_notify;
 		struct wl_signal set_title;
 		struct wl_signal set_class;
 		struct wl_signal set_parent;
diff --git a/rootston/xwayland.c b/rootston/xwayland.c
index 1149b966..d43618c3 100644
--- a/rootston/xwayland.c
+++ b/rootston/xwayland.c
@@ -44,6 +44,8 @@ static void handle_destroy(struct wl_listener *listener, void *data) {
 	struct roots_xwayland_surface *roots_surface =
 		wl_container_of(listener, roots_surface, destroy);
 	wl_list_remove(&roots_surface->destroy.link);
+	wl_list_remove(&roots_surface->map_notify.link);
+	wl_list_remove(&roots_surface->unmap_notify.link);
 	view_destroy(roots_surface->view);
 	free(roots_surface);
 }
@@ -62,6 +64,34 @@ static void handle_request_configure(struct wl_listener *listener, void *data) {
 		xwayland_surface, event->x, event->y, event->width, event->height);
 }
 
+static void handle_map_notify(struct wl_listener *listener, void *data) {
+	struct roots_xwayland_surface *roots_surface =
+		wl_container_of(listener, roots_surface, map_notify);
+	struct roots_view *view = roots_surface->view;
+	struct wlr_xwayland_surface *xsurface = view->xwayland_surface;
+	struct roots_desktop *desktop = view->desktop;
+
+	view->wlr_surface = xsurface->surface;
+	view->x = (double)xsurface->x;
+	view->y = (double)xsurface->y;
+
+	wlr_list_push(desktop->views, roots_surface->view);
+}
+
+static void handle_unmap_notify(struct wl_listener *listener, void *data) {
+	struct roots_xwayland_surface *roots_surface =
+		wl_container_of(listener, roots_surface, unmap_notify);
+	struct roots_desktop *desktop = roots_surface->view->desktop;
+	roots_surface->view->wlr_surface = NULL;
+
+	for (size_t i = 0; i < desktop->views->length; i++) {
+		if (desktop->views->items[i] == roots_surface->view) {
+			wlr_list_del(desktop->views, i);
+			break;
+		}
+	}
+}
+
 void handle_xwayland_surface(struct wl_listener *listener, void *data) {
 	struct roots_desktop *desktop =
 		wl_container_of(listener, desktop, xwayland_surface);
@@ -77,10 +107,17 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
 	}
 	roots_surface->destroy.notify = handle_destroy;
 	wl_signal_add(&surface->events.destroy, &roots_surface->destroy);
+
 	roots_surface->request_configure.notify = handle_request_configure;
 	wl_signal_add(&surface->events.request_configure,
 		&roots_surface->request_configure);
 
+	roots_surface->map_notify.notify = handle_map_notify;
+	wl_signal_add(&surface->events.map_notify, &roots_surface->map_notify);
+
+	roots_surface->unmap_notify.notify = handle_unmap_notify;
+	wl_signal_add(&surface->events.unmap_notify, &roots_surface->unmap_notify);
+
 	struct roots_view *view = calloc(1, sizeof(struct roots_view));
 	if (view == NULL) {
 		free(roots_surface);
diff --git a/xwayland/xwm.c b/xwayland/xwm.c
index 7d676987..6850f56b 100644
--- a/xwayland/xwm.c
+++ b/xwayland/xwm.c
@@ -75,6 +75,8 @@ static struct wlr_xwayland_surface *wlr_xwayland_surface_create(
 	surface->state = wlr_list_create();
 	wl_signal_init(&surface->events.destroy);
 	wl_signal_init(&surface->events.request_configure);
+	wl_signal_init(&surface->events.map_notify);
+	wl_signal_init(&surface->events.unmap_notify);
 	wl_signal_init(&surface->events.set_class);
 	wl_signal_init(&surface->events.set_title);
 	wl_signal_init(&surface->events.set_parent);
@@ -474,6 +476,7 @@ static void map_shell_surface(struct wlr_xwm *xwm,
 	wl_signal_add(&surface->events.destroy, &xsurface->surface_destroy);
 
 	xsurface->mapped = true;
+	wl_signal_emit(&xsurface->events.map_notify, xsurface);
 }
 
 /* xcb event handlers */
@@ -551,13 +554,6 @@ static void handle_map_request(struct wlr_xwm *xwm,
 
 static void handle_map_notify(struct wlr_xwm *xwm, xcb_map_notify_event_t *ev) {
 	wlr_log(L_DEBUG, "XCB_MAP_NOTIFY (%u)", ev->window);
-	struct wlr_xwayland_surface *surface = lookup_surface(xwm, ev->window);
-	if (surface != NULL) {
-		surface->override_redirect = ev->override_redirect;
-	} else {
-		wlr_xwayland_surface_create(xwm, ev->window, 0, 0, 1, 1,
-			ev->override_redirect);
-	}
 }
 
 static void handle_unmap_notify(struct wlr_xwm *xwm,
@@ -579,10 +575,11 @@ static void handle_unmap_notify(struct wlr_xwm *xwm,
 	if (xsurface->surface) {
 		wl_list_remove(&xsurface->surface_commit.link);
 		wl_list_remove(&xsurface->surface_destroy.link);
-		xsurface->surface = NULL;
 	}
+	xsurface->surface = NULL;
 
-	wlr_xwayland_surface_destroy(xsurface);
+	xsurface->mapped = false;
+	wl_signal_emit(&xsurface->events.unmap_notify, xsurface);
 }
 
 static void handle_property_notify(struct wlr_xwm *xwm,
@@ -696,12 +693,12 @@ static void handle_compositor_surface_create(struct wl_listener *listener,
 	wlr_log(L_DEBUG, "New xwayland surface: %p", surface);
 
 	uint32_t surface_id = wl_resource_get_id(surface->resource);
-	struct wlr_xwayland_surface *xwayland_surface;
-	wl_list_for_each(xwayland_surface, &xwm->unpaired_surfaces, unpaired_link) {
-		if (xwayland_surface->surface_id == surface_id) {
-			map_shell_surface(xwm, xwayland_surface, surface);
-			xwayland_surface->surface_id = 0;
-			wl_list_remove(&xwayland_surface->unpaired_link);
+	struct wlr_xwayland_surface *xsurface;
+	wl_list_for_each(xsurface, &xwm->unpaired_surfaces, unpaired_link) {
+		if (xsurface->surface_id == surface_id) {
+			map_shell_surface(xwm, xsurface, surface);
+			xsurface->surface_id = 0;
+			wl_list_remove(&xsurface->unpaired_link);
 			xcb_flush(xwm->xcb_conn);
 			return;
 		}
-- 
cgit v1.2.3


From 0d1dd84a48cbfec848866cfbe4e62652765d7c98 Mon Sep 17 00:00:00 2001
From: Tony Crisci <tony@dubstepdish.com>
Date: Wed, 25 Oct 2017 08:39:28 -0400
Subject: xwm: improve activation and dont send focus twice

---
 include/wlr/xwayland.h |   2 +-
 rootston/xwayland.c    |   8 +---
 xwayland/xwm.c         | 114 ++++++++++++++++++++++++++++---------------------
 3 files changed, 69 insertions(+), 55 deletions(-)

(limited to 'include/wlr/xwayland.h')

diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h
index efee3d9f..e7598d4c 100644
--- a/include/wlr/xwayland.h
+++ b/include/wlr/xwayland.h
@@ -125,7 +125,7 @@ void wlr_xwayland_destroy(struct wlr_xwayland *wlr_xwayland);
 struct wlr_xwayland *wlr_xwayland_create(struct wl_display *wl_display,
 	struct wlr_compositor *compositor);
 void wlr_xwayland_surface_activate(struct wlr_xwayland *wlr_xwayland,
-	struct wlr_xwayland_surface *surface);
+	struct wlr_xwayland_surface *surface, bool activated);
 void wlr_xwayland_surface_configure(struct wlr_xwayland *wlr_xwayland,
 	struct wlr_xwayland_surface *surface, int16_t x, int16_t y,
 	uint16_t width, uint16_t height);
diff --git a/rootston/xwayland.c b/rootston/xwayland.c
index d43618c3..221c659d 100644
--- a/rootston/xwayland.c
+++ b/rootston/xwayland.c
@@ -11,12 +11,8 @@
 
 static void activate(struct roots_view *view, bool active) {
 	assert(view->type == ROOTS_XWAYLAND_VIEW);
-	if (active) {
-		wlr_xwayland_surface_activate(view->desktop->xwayland,
-			view->xwayland_surface);
-	} else {
-		wlr_xwayland_surface_activate(view->desktop->xwayland, NULL);
-	}
+	struct wlr_xwayland *xwayland = view->desktop->xwayland;
+	wlr_xwayland_surface_activate(xwayland, view->xwayland_surface, active);
 }
 
 static void resize(struct roots_view *view, uint32_t width, uint32_t height) {
diff --git a/xwayland/xwm.c b/xwayland/xwm.c
index 7827295e..f39f8391 100644
--- a/xwayland/xwm.c
+++ b/xwayland/xwm.c
@@ -86,9 +86,69 @@ static struct wlr_xwayland_surface *wlr_xwayland_surface_create(
 	return surface;
 }
 
+static void xwm_set_net_active_window(struct wlr_xwm *xwm,
+		xcb_window_t window) {
+	xcb_change_property(xwm->xcb_conn, XCB_PROP_MODE_REPLACE,
+			xwm->screen->root, xwm->atoms[_NET_ACTIVE_WINDOW],
+			xwm->atoms[WINDOW], 32, 1, &window);
+}
+
+static void xwm_send_focus_window(struct wlr_xwm *xwm,
+		struct wlr_xwayland_surface *surface) {
+	if (surface) {
+		xcb_client_message_event_t client_message;
+		client_message.response_type = XCB_CLIENT_MESSAGE;
+		client_message.format = 32;
+		client_message.window = surface->window_id;
+		client_message.type = xwm->atoms[WM_PROTOCOLS];
+		client_message.data.data32[0] = xwm->atoms[WM_TAKE_FOCUS];
+		client_message.data.data32[1] = XCB_TIME_CURRENT_TIME;
+
+		xcb_send_event(xwm->xcb_conn, 0, surface->window_id,
+			XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (char*)&client_message);
+
+		xcb_set_input_focus(xwm->xcb_conn, XCB_INPUT_FOCUS_POINTER_ROOT,
+			surface->window_id, XCB_CURRENT_TIME);
+
+		uint32_t values[1];
+		values[0] = XCB_STACK_MODE_ABOVE;
+		xcb_configure_window_checked(xwm->xcb_conn, surface->window_id,
+			XCB_CONFIG_WINDOW_STACK_MODE, values);
+	} else {
+		xcb_set_input_focus_checked(xwm->xcb_conn,
+			XCB_INPUT_FOCUS_POINTER_ROOT,
+			XCB_NONE, XCB_CURRENT_TIME);
+	}
+}
+
+
+void xwm_surface_activate(struct wlr_xwm *xwm,
+		struct wlr_xwayland_surface *xsurface) {
+	if (xwm->focus_surface == xsurface) {
+		return;
+	}
+
+	if (xsurface) {
+		xwm_set_net_active_window(xwm, xsurface->window_id);
+	} else {
+		xwm_set_net_active_window(xwm, XCB_WINDOW_NONE);
+	}
+
+	xwm_send_focus_window(xwm, xsurface);
+
+	xwm->focus_surface = xsurface;
+
+	xcb_flush(xwm->xcb_conn);
+}
+
+
 static void wlr_xwayland_surface_destroy(struct wlr_xwayland_surface *surface) {
 	wl_signal_emit(&surface->events.destroy, surface);
 
+	if (surface == surface->xwm->focus_surface) {
+		xwm_surface_activate(surface->xwm, NULL);
+	}
+
 	wl_list_remove(&surface->link);
 
 	if (surface->surface_id) {
@@ -707,56 +767,14 @@ static void handle_compositor_surface_create(struct wl_listener *listener,
 	}
 }
 
-static void xwm_set_net_active_window(struct wlr_xwm *xwm,
-		xcb_window_t window) {
-	xcb_change_property(xwm->xcb_conn, XCB_PROP_MODE_REPLACE,
-			xwm->screen->root, xwm->atoms[_NET_ACTIVE_WINDOW],
-			xwm->atoms[WINDOW], 32, 1, &window);
-}
-
-static void xwm_send_focus_window(struct wlr_xwm *xwm,
-		struct wlr_xwayland_surface *surface) {
-	if (surface) {
-		xcb_client_message_event_t client_message;
-		client_message.response_type = XCB_CLIENT_MESSAGE;
-		client_message.format = 32;
-		client_message.window = surface->window_id;
-		client_message.type = xwm->atoms[WM_PROTOCOLS];
-		client_message.data.data32[0] = xwm->atoms[WM_TAKE_FOCUS];
-		client_message.data.data32[1] = XCB_TIME_CURRENT_TIME;
-
-		xcb_send_event(xwm->xcb_conn, 0, surface->window_id,
-			XCB_EVENT_MASK_SUBSTRUCTURE_REDIRECT, (char*)&client_message);
-
-		xcb_set_input_focus(xwm->xcb_conn, XCB_INPUT_FOCUS_POINTER_ROOT,
-			surface->window_id, XCB_CURRENT_TIME);
-
-		uint32_t values[1];
-		values[0] = XCB_STACK_MODE_ABOVE;
-		xcb_configure_window_checked(xwm->xcb_conn, surface->window_id,
-			XCB_CONFIG_WINDOW_STACK_MODE, values);
-	} else {
-		xcb_set_input_focus_checked(xwm->xcb_conn,
-			XCB_INPUT_FOCUS_POINTER_ROOT,
-			XCB_NONE, XCB_CURRENT_TIME);
-	}
-}
-
 void wlr_xwayland_surface_activate(struct wlr_xwayland *wlr_xwayland,
-		struct wlr_xwayland_surface *surface) {
-	struct wlr_xwm *xwm = wlr_xwayland->xwm;
-
-	if (surface) {
-		xwm_set_net_active_window(xwm, surface->window_id);
-	} else {
-		xwm_set_net_active_window(xwm, XCB_WINDOW_NONE);
+		struct wlr_xwayland_surface *surface, bool activated) {
+	struct wlr_xwayland_surface *focused = wlr_xwayland->xwm->focus_surface;
+	if (activated) {
+		xwm_surface_activate(wlr_xwayland->xwm, surface);
+	} else if (focused == surface) {
+		xwm_surface_activate(wlr_xwayland->xwm, NULL);
 	}
-
-	xwm_send_focus_window(xwm, surface);
-
-	xwm->focus_surface = surface;
-
-	xcb_flush(xwm->xcb_conn);
 }
 
 void wlr_xwayland_surface_configure(struct wlr_xwayland *wlr_xwayland,
-- 
cgit v1.2.3


From 4a106648c4455793560d8ca3e60082a6f1d5f791 Mon Sep 17 00:00:00 2001
From: Tony Crisci <tony@dubstepdish.com>
Date: Thu, 26 Oct 2017 15:58:18 -0400
Subject: xwm: remove incorrect implementation of net wm state

---
 include/wlr/xwayland.h |  5 +++
 xwayland/xwm.c         | 82 ++++++++++++++++++++------------------------------
 xwayland/xwm.h         |  3 ++
 3 files changed, 40 insertions(+), 50 deletions(-)

(limited to 'include/wlr/xwayland.h')

diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h
index e7598d4c..6198ff22 100644
--- a/include/wlr/xwayland.h
+++ b/include/wlr/xwayland.h
@@ -96,6 +96,11 @@ struct wlr_xwayland_surface {
 	uint32_t hints_urgency;
 	struct wlr_xwayland_surface_size_hints *size_hints;
 
+	// _NET_WM_STATE
+	bool fullscreen;
+	bool maximized_vert;
+	bool maximized_horz;
+
 	struct {
 		struct wl_signal destroy;
 		struct wl_signal request_configure;
diff --git a/xwayland/xwm.c b/xwayland/xwm.c
index 01d09768..b52dfcf7 100644
--- a/xwayland/xwm.c
+++ b/xwayland/xwm.c
@@ -36,6 +36,9 @@ const char *atom_map[ATOM_LAST] = {
 	"_NET_WM_MOVERESIZE",
 	"_NET_WM_NAME",
 	"_NET_SUPPORTING_WM_CHECK",
+	"_NET_WM_STATE_FULLSCREEN",
+	"_NET_WM_STATE_MAXIMIZED_VERT",
+	"_NET_WM_STATE_MAXIMIZED_HORZ",
 };
 
 /* General helpers */
@@ -150,6 +153,30 @@ void xwm_surface_activate(struct wlr_xwm *xwm,
 	xcb_flush(xwm->xcb_conn);
 }
 
+static void xsurface_set_net_wm_state(struct wlr_xwayland_surface *xsurface) {
+	struct wlr_xwm *xwm = xsurface->xwm;
+	uint32_t property[3];
+	int i;
+
+	i = 0;
+	if (xsurface->fullscreen) {
+		property[i++] = xwm->atoms[_NET_WM_STATE_FULLSCREEN];
+	}
+	if (xsurface->maximized_vert) {
+		property[i++] = xwm->atoms[_NET_WM_STATE_MAXIMIZED_VERT];
+	}
+	if (xsurface->maximized_horz) {
+		property[i++] = xwm->atoms[_NET_WM_STATE_MAXIMIZED_HORZ];
+	}
+
+	xcb_change_property(xwm->xcb_conn,
+		XCB_PROP_MODE_REPLACE,
+		xsurface->window_id,
+		xwm->atoms[NET_WM_STATE],
+		XCB_ATOM_ATOM,
+		32, // format
+		i, property);
+}
 
 static void wlr_xwayland_surface_destroy(struct wlr_xwayland_surface *surface) {
 	wl_signal_emit(&surface->events.destroy, surface);
@@ -271,44 +298,6 @@ static void read_surface_parent(struct wlr_xwm *xwm,
 	wl_signal_emit(&surface->events.set_parent, surface);
 }
 
-static void handle_surface_state(struct wlr_xwm *xwm,
-		struct wlr_xwayland_surface *surface, xcb_atom_t *state,
-		size_t state_len, enum net_wm_state_action action) {
-	for (size_t i = 0; i < state_len; i++) {
-		xcb_atom_t atom = state[i];
-		bool found = false;
-		for (size_t j = 0; j < surface->state->length; j++) {
-			xcb_atom_t *cur = surface->state->items[j];
-			if (atom == *cur) {
-				found = true;
-				if (action == NET_WM_STATE_REMOVE ||
-						action == NET_WM_STATE_TOGGLE) {
-					free(surface->state->items[j]);
-					wlr_list_del(surface->state, j);
-				}
-				break;
-			}
-		}
-
-		if (!found && (action == NET_WM_STATE_ADD ||
-				action == NET_WM_STATE_TOGGLE)) {
-			xcb_atom_t *atom_ptr = malloc(sizeof(xcb_atom_t));
-			*atom_ptr = atom;
-			wlr_list_add(surface->state, atom_ptr);
-		}
-	}
-
-	wlr_log(L_DEBUG, "NET_WM_STATE (%zu)", state_len);
-	wl_signal_emit(&surface->events.set_state, surface);
-}
-
-static void read_surface_state(struct wlr_xwm *xwm,
-		struct wlr_xwayland_surface *surface, xcb_get_property_reply_t *reply) {
-	// reply->type == XCB_ATOM_ANY
-	handle_surface_state(xwm, surface, xcb_get_property_value(reply),
-		reply->value_len, NET_WM_STATE_ADD);
-}
-
 static void read_surface_pid(struct wlr_xwm *xwm,
 		struct wlr_xwayland_surface *surface, xcb_get_property_reply_t *reply) {
 	if (reply->type != XCB_ATOM_CARDINAL) {
@@ -480,7 +469,7 @@ static void read_surface_property(struct wlr_xwm *xwm,
 	} else if (property == xwm->atoms[WM_PROTOCOLS]) {
 		read_surface_protocols(xwm, surface, reply);
 	} else if (property == xwm->atoms[NET_WM_STATE]) {
-		read_surface_state(xwm, surface, reply);
+		wlr_log(L_DEBUG, "TODO: read _NET_WM_STATE property");
 	} else if (property == xwm->atoms[WM_HINTS]) {
 		read_surface_hints(xwm, surface, reply);
 	} else if (property == xwm->atoms[WM_NORMAL_HINTS]) {
@@ -645,6 +634,7 @@ static void handle_map_request(struct wlr_xwm *xwm,
 	}
 
 	xsurface_set_wm_state(xsurface, ICCCM_NORMAL_STATE);
+	xsurface_set_net_wm_state(xsurface);
 	xcb_map_window(xwm->xcb_conn, ev->window);
 }
 
@@ -716,16 +706,6 @@ static void handle_surface_id_message(struct wlr_xwm *xwm,
 	}
 }
 
-static void handle_net_wm_state_message(struct wlr_xwm *xwm,
-		xcb_client_message_event_t *ev) {
-	struct wlr_xwayland_surface *xsurface = lookup_surface(xwm, ev->window);
-	if (xsurface == NULL) {
-		return;
-	}
-	handle_surface_state(xwm, xsurface, &ev->data.data32[1], 2,
-		ev->data.data32[0]);
-}
-
 static void handle_net_wm_moveresize_message(struct wlr_xwm *xwm,
 		xcb_client_message_event_t *ev) {
 	wlr_log(L_DEBUG, "TODO: handle moveresize");
@@ -738,7 +718,7 @@ static void handle_client_message(struct wlr_xwm *xwm,
 	if (ev->type == xwm->atoms[WL_SURFACE_ID]) {
 		handle_surface_id_message(xwm, ev);
 	} else if (ev->type == xwm->atoms[NET_WM_STATE]) {
-		handle_net_wm_state_message(xwm, ev);
+		wlr_log(L_DEBUG, "TODO: handle _NET_WM_STATE client message");
 	} else if (ev->type == xwm->atoms[_NET_WM_MOVERESIZE]) {
 		handle_net_wm_moveresize_message(xwm, ev);
 	} else {
@@ -1075,6 +1055,8 @@ struct wlr_xwm *xwm_create(struct wlr_xwayland *wlr_xwayland) {
 		sizeof(supported)/sizeof(*supported),
 		supported);
 
+	xcb_flush(xwm->xcb_conn);
+
 	xwm_set_net_active_window(xwm, XCB_WINDOW_NONE);
 
 	xwm->compositor_surface_create.notify = handle_compositor_surface_create;
diff --git a/xwayland/xwm.h b/xwayland/xwm.h
index 05fcfa7e..4f8c20a2 100644
--- a/xwayland/xwm.h
+++ b/xwayland/xwm.h
@@ -25,6 +25,9 @@ enum atom_name {
 	_NET_WM_MOVERESIZE,
 	_NET_WM_NAME,
 	_NET_SUPPORTING_WM_CHECK,
+	_NET_WM_STATE_FULLSCREEN,
+	_NET_WM_STATE_MAXIMIZED_VERT,
+	_NET_WM_STATE_MAXIMIZED_HORZ,
 	ATOM_LAST,
 };
 
-- 
cgit v1.2.3


From 6a4290b86ac282a899221834465df81bdd9d6bc9 Mon Sep 17 00:00:00 2001
From: Tony Crisci <tony@dubstepdish.com>
Date: Fri, 27 Oct 2017 10:48:09 -0400
Subject: xwm: moveresize events

---
 include/rootston/view.h |  2 ++
 include/wlr/xwayland.h  | 12 ++++++++++
 rootston/xwayland.c     | 57 +++++++++++++++++++++++++++++++++++++++++++++
 xwayland/xwm.c          | 61 ++++++++++++++++++++++++++++++++++++++++++++++++-
 4 files changed, 131 insertions(+), 1 deletion(-)

(limited to 'include/wlr/xwayland.h')

diff --git a/include/rootston/view.h b/include/rootston/view.h
index 1a0de6de..53a2e133 100644
--- a/include/rootston/view.h
+++ b/include/rootston/view.h
@@ -34,6 +34,8 @@ struct roots_xwayland_surface {
 	// TODO: Maybe destroy listener should go in roots_view
 	struct wl_listener destroy;
 	struct wl_listener request_configure;
+	struct wl_listener request_move;
+	struct wl_listener request_resize;
 	struct wl_listener map_notify;
 	struct wl_listener unmap_notify;
 };
diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h
index 6198ff22..b108028f 100644
--- a/include/wlr/xwayland.h
+++ b/include/wlr/xwayland.h
@@ -104,6 +104,8 @@ struct wlr_xwayland_surface {
 	struct {
 		struct wl_signal destroy;
 		struct wl_signal request_configure;
+		struct wl_signal request_move;
+		struct wl_signal request_resize;
 		struct wl_signal map_notify;
 		struct wl_signal unmap_notify;
 		struct wl_signal set_title;
@@ -126,6 +128,16 @@ struct wlr_xwayland_surface_configure_event {
 	uint16_t width, height;
 };
 
+// TODO: maybe add a seat to these
+struct wlr_xwayland_move_event {
+	struct wlr_xwayland_surface *surface;
+};
+
+struct wlr_xwayland_resize_event {
+	struct wlr_xwayland_surface *surface;
+	uint32_t edges;
+};
+
 void wlr_xwayland_destroy(struct wlr_xwayland *wlr_xwayland);
 struct wlr_xwayland *wlr_xwayland_create(struct wl_display *wl_display,
 	struct wlr_compositor *compositor);
diff --git a/rootston/xwayland.c b/rootston/xwayland.c
index 221c659d..9a6e33fd 100644
--- a/rootston/xwayland.c
+++ b/rootston/xwayland.c
@@ -60,6 +60,57 @@ static void handle_request_configure(struct wl_listener *listener, void *data) {
 		xwayland_surface, event->x, event->y, event->width, event->height);
 }
 
+// XXX Needs deep refactoring to get this better. We need to select the correct
+// seat based on seat pointer focus, but interactive moving and resizing is not
+// yet seat aware. Even then, we can only guess because X11 events don't give us
+// enough wayland info to know for sure.
+static struct wlr_cursor *guess_cursor_for_view(struct roots_view *view) {
+	struct roots_input *input = view->desktop->server->input;
+	size_t len = sizeof(input->input_events) / sizeof(*input->input_events);
+	for (size_t i = 0; i < len; i++) {
+		struct wlr_cursor *cursor = input->input_events[i].cursor;
+		if (cursor) {
+			int width = view->xwayland_surface->surface->current->width;
+			int height = view->xwayland_surface->surface->current->height;
+			if (cursor->x > view->x && cursor->y > view->y &&
+					cursor->x < view->x + width &&
+					cursor->y < view->y + height) {
+				return cursor;
+			}
+		}
+	}
+
+	return NULL;
+}
+
+static void handle_request_move(struct wl_listener *listener, void *data) {
+	struct roots_xwayland_surface *roots_surface =
+		wl_container_of(listener, roots_surface, request_move);
+	struct roots_view *view = roots_surface->view;
+	struct roots_input *input = view->desktop->server->input;
+	struct wlr_cursor *cursor = guess_cursor_for_view(view);
+
+	if (!cursor || input->mode != ROOTS_CURSOR_PASSTHROUGH) {
+		return;
+	}
+
+	view_begin_move(input, cursor, view);
+}
+
+static void handle_request_resize(struct wl_listener *listener, void *data) {
+	struct roots_xwayland_surface *roots_surface =
+		wl_container_of(listener, roots_surface, request_resize);
+	struct roots_view *view = roots_surface->view;
+	struct roots_input *input = view->desktop->server->input;
+	struct wlr_cursor *cursor = guess_cursor_for_view(view);
+	struct wlr_xwayland_resize_event *e = data;
+
+	if (!cursor || input->mode != ROOTS_CURSOR_PASSTHROUGH) {
+		return;
+	}
+	view_begin_resize(input, cursor, view, e->edges);
+}
+
 static void handle_map_notify(struct wl_listener *listener, void *data) {
 	struct roots_xwayland_surface *roots_surface =
 		wl_container_of(listener, roots_surface, map_notify);
@@ -114,6 +165,12 @@ void handle_xwayland_surface(struct wl_listener *listener, void *data) {
 	roots_surface->unmap_notify.notify = handle_unmap_notify;
 	wl_signal_add(&surface->events.unmap_notify, &roots_surface->unmap_notify);
 
+	roots_surface->request_move.notify = handle_request_move;
+	wl_signal_add(&surface->events.request_move, &roots_surface->request_move);
+
+	roots_surface->request_resize.notify = handle_request_resize;
+	wl_signal_add(&surface->events.request_resize, &roots_surface->request_resize);
+
 	struct roots_view *view = calloc(1, sizeof(struct roots_view));
 	if (view == NULL) {
 		free(roots_surface);
diff --git a/xwayland/xwm.c b/xwayland/xwm.c
index b52dfcf7..2caae3a7 100644
--- a/xwayland/xwm.c
+++ b/xwayland/xwm.c
@@ -82,6 +82,8 @@ static struct wlr_xwayland_surface *wlr_xwayland_surface_create(
 	surface->state = wlr_list_create();
 	wl_signal_init(&surface->events.destroy);
 	wl_signal_init(&surface->events.request_configure);
+	wl_signal_init(&surface->events.request_move);
+	wl_signal_init(&surface->events.request_resize);
 	wl_signal_init(&surface->events.map_notify);
 	wl_signal_init(&surface->events.unmap_notify);
 	wl_signal_init(&surface->events.set_class);
@@ -706,9 +708,58 @@ static void handle_surface_id_message(struct wlr_xwm *xwm,
 	}
 }
 
+#define _NET_WM_MOVERESIZE_SIZE_TOPLEFT      0
+#define _NET_WM_MOVERESIZE_SIZE_TOP          1
+#define _NET_WM_MOVERESIZE_SIZE_TOPRIGHT     2
+#define _NET_WM_MOVERESIZE_SIZE_RIGHT        3
+#define _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT  4
+#define _NET_WM_MOVERESIZE_SIZE_BOTTOM       5
+#define _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT   6
+#define _NET_WM_MOVERESIZE_SIZE_LEFT         7
+#define _NET_WM_MOVERESIZE_MOVE              8  // movement only
+#define _NET_WM_MOVERESIZE_SIZE_KEYBOARD     9  // size via keyboard
+#define _NET_WM_MOVERESIZE_MOVE_KEYBOARD    10  // move via keyboard
+#define _NET_WM_MOVERESIZE_CANCEL           11  // cancel operation
+
 static void handle_net_wm_moveresize_message(struct wlr_xwm *xwm,
 		xcb_client_message_event_t *ev) {
-	wlr_log(L_DEBUG, "TODO: handle moveresize");
+	// same as xdg-toplevel-v6
+	// TODO need a common enum for this
+	static const int map[] = {
+		5, 1, 9, 8, 10, 2, 6, 4
+	};
+
+	struct wlr_xwayland_surface *xsurface = lookup_surface(xwm, ev->window);
+	if (!xsurface) {
+		return;
+	}
+
+	// TODO: we should probably add input or seat info to this but we would just
+	// be guessing
+	struct wlr_xwayland_resize_event resize_event;
+	struct wlr_xwayland_move_event move_event;
+
+	int detail = ev->data.data32[2];
+	switch (detail) {
+	case _NET_WM_MOVERESIZE_MOVE:
+		move_event.surface = xsurface;
+		wl_signal_emit(&xsurface->events.request_move, &move_event);
+		break;
+	case _NET_WM_MOVERESIZE_SIZE_TOPLEFT:
+	case _NET_WM_MOVERESIZE_SIZE_TOP:
+	case _NET_WM_MOVERESIZE_SIZE_TOPRIGHT:
+	case _NET_WM_MOVERESIZE_SIZE_RIGHT:
+	case _NET_WM_MOVERESIZE_SIZE_BOTTOMRIGHT:
+	case _NET_WM_MOVERESIZE_SIZE_BOTTOM:
+	case _NET_WM_MOVERESIZE_SIZE_BOTTOMLEFT:
+	case _NET_WM_MOVERESIZE_SIZE_LEFT:
+		resize_event.surface = xsurface;
+		resize_event.edges = map[detail];
+		wl_signal_emit(&xsurface->events.request_resize, &resize_event);
+		break;
+	case _NET_WM_MOVERESIZE_CANCEL:
+		break;
+	}
 }
 
 static void handle_client_message(struct wlr_xwm *xwm,
@@ -980,6 +1031,14 @@ static void xwm_create_wm_window(struct wlr_xwm *xwm) {
 		32, // format
 		1, &xwm->window);
 
+	xcb_change_property(xwm->xcb_conn,
+		XCB_PROP_MODE_REPLACE,
+		xwm->window,
+		xwm->atoms[_NET_SUPPORTING_WM_CHECK],
+		XCB_ATOM_WINDOW,
+		32, // format
+		1, &xwm->window);
+
 	xcb_set_selection_owner(xwm->xcb_conn,
 		xwm->window,
 		xwm->atoms[WM_S0],
-- 
cgit v1.2.3


From be297d9d144739e39e9264bc91fa95990873ced0 Mon Sep 17 00:00:00 2001
From: Tony Crisci <tony@dubstepdish.com>
Date: Fri, 27 Oct 2017 13:05:14 -0400
Subject: xwm: net wm state

---
 include/wlr/xwayland.h |  17 ++++++-
 xwayland/xwm.c         | 118 +++++++++++++++++++++++++++++++++++++++++++++++--
 2 files changed, 129 insertions(+), 6 deletions(-)

(limited to 'include/wlr/xwayland.h')

diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h
index b108028f..cc5d06cb 100644
--- a/include/wlr/xwayland.h
+++ b/include/wlr/xwayland.h
@@ -74,6 +74,7 @@ struct wlr_xwayland_surface {
 	struct wlr_surface *surface;
 	int16_t x, y;
 	uint16_t width, height;
+	uint16_t saved_width, saved_height;
 	bool override_redirect;
 	bool mapped;
 	bool added;
@@ -106,12 +107,14 @@ struct wlr_xwayland_surface {
 		struct wl_signal request_configure;
 		struct wl_signal request_move;
 		struct wl_signal request_resize;
+		struct wl_signal request_maximize;
+		struct wl_signal request_fullscreen;
+
 		struct wl_signal map_notify;
 		struct wl_signal unmap_notify;
 		struct wl_signal set_title;
 		struct wl_signal set_class;
 		struct wl_signal set_parent;
-		struct wl_signal set_state;
 		struct wl_signal set_pid;
 		struct wl_signal set_window_type;
 	} events;
@@ -138,15 +141,25 @@ struct wlr_xwayland_resize_event {
 	uint32_t edges;
 };
 
-void wlr_xwayland_destroy(struct wlr_xwayland *wlr_xwayland);
 struct wlr_xwayland *wlr_xwayland_create(struct wl_display *wl_display,
 	struct wlr_compositor *compositor);
+
+void wlr_xwayland_destroy(struct wlr_xwayland *wlr_xwayland);
+
 void wlr_xwayland_surface_activate(struct wlr_xwayland *wlr_xwayland,
 	struct wlr_xwayland_surface *surface, bool activated);
+
 void wlr_xwayland_surface_configure(struct wlr_xwayland *wlr_xwayland,
 	struct wlr_xwayland_surface *surface, int16_t x, int16_t y,
 	uint16_t width, uint16_t height);
+
 void wlr_xwayland_surface_close(struct wlr_xwayland *wlr_xwayland,
 	struct wlr_xwayland_surface *surface);
 
+void wlr_xwayland_surface_set_maximized(struct wlr_xwayland *wlr_xwayland,
+	struct wlr_xwayland_surface *surface, bool maximized);
+
+void wlr_xwayland_surface_set_fullscreen(struct wlr_xwayland *wlr_xwayland,
+	struct wlr_xwayland_surface *surface, bool fullscreen);
+
 #endif
diff --git a/xwayland/xwm.c b/xwayland/xwm.c
index 2caae3a7..5ba91370 100644
--- a/xwayland/xwm.c
+++ b/xwayland/xwm.c
@@ -79,17 +79,17 @@ static struct wlr_xwayland_surface *wlr_xwayland_surface_create(
 	surface->height = height;
 	surface->override_redirect = override_redirect;
 	wl_list_insert(&xwm->surfaces, &surface->link);
-	surface->state = wlr_list_create();
 	wl_signal_init(&surface->events.destroy);
 	wl_signal_init(&surface->events.request_configure);
 	wl_signal_init(&surface->events.request_move);
 	wl_signal_init(&surface->events.request_resize);
+	wl_signal_init(&surface->events.request_maximize);
+	wl_signal_init(&surface->events.request_fullscreen);
 	wl_signal_init(&surface->events.map_notify);
 	wl_signal_init(&surface->events.unmap_notify);
 	wl_signal_init(&surface->events.set_class);
 	wl_signal_init(&surface->events.set_title);
 	wl_signal_init(&surface->events.set_parent);
-	wl_signal_init(&surface->events.set_state);
 	wl_signal_init(&surface->events.set_pid);
 	wl_signal_init(&surface->events.set_window_type);
 	return surface;
@@ -447,6 +447,21 @@ static void read_surface_motif_hints(struct wlr_xwm *xwm,
 	wlr_log(L_DEBUG, "MOTIF_WM_HINTS (%d)", reply->value_len);
 }
 
+static void read_surface_net_wm_state(struct wlr_xwm *xwm,
+		struct wlr_xwayland_surface *xsurface, xcb_get_property_reply_t *reply) {
+	xsurface->fullscreen = 0;
+	xcb_atom_t *atom = xcb_get_property_value(reply);
+	atom = xcb_get_property_value(reply);
+	for (uint32_t i = 0; i < reply->value_len; i++) {
+		if (atom[i] == xwm->atoms[_NET_WM_STATE_FULLSCREEN])
+			xsurface->fullscreen = true;
+		if (atom[i] == xwm->atoms[_NET_WM_STATE_MAXIMIZED_VERT])
+			xsurface->maximized_vert = true;
+		if (atom[i] == xwm->atoms[_NET_WM_STATE_MAXIMIZED_HORZ])
+			xsurface->maximized_horz = true;
+	}
+}
+
 static void read_surface_property(struct wlr_xwm *xwm,
 		struct wlr_xwayland_surface *surface, xcb_atom_t property) {
 	xcb_get_property_cookie_t cookie = xcb_get_property(xwm->xcb_conn, 0,
@@ -471,7 +486,7 @@ static void read_surface_property(struct wlr_xwm *xwm,
 	} else if (property == xwm->atoms[WM_PROTOCOLS]) {
 		read_surface_protocols(xwm, surface, reply);
 	} else if (property == xwm->atoms[NET_WM_STATE]) {
-		wlr_log(L_DEBUG, "TODO: read _NET_WM_STATE property");
+		read_surface_net_wm_state(xwm, surface, reply);
 	} else if (property == xwm->atoms[WM_HINTS]) {
 		read_surface_hints(xwm, surface, reply);
 	} else if (property == xwm->atoms[WM_NORMAL_HINTS]) {
@@ -762,6 +777,81 @@ static void handle_net_wm_moveresize_message(struct wlr_xwm *xwm,
 	}
 }
 
+#define _NET_WM_STATE_REMOVE	0
+#define _NET_WM_STATE_ADD	1
+#define _NET_WM_STATE_TOGGLE	2
+
+static bool update_state(int action, bool *state) {
+	int new_state, changed;
+
+	switch (action) {
+		case _NET_WM_STATE_REMOVE:
+			new_state = false;
+			break;
+		case _NET_WM_STATE_ADD:
+			new_state = true;
+			break;
+		case _NET_WM_STATE_TOGGLE:
+			new_state = !*state;
+			break;
+		default:
+			return false;
+	}
+
+	changed = (*state != new_state);
+	*state = new_state;
+
+	return changed;
+}
+
+static inline bool xsurface_is_maximized(struct wlr_xwayland_surface *xsurface) {
+	return xsurface->maximized_horz && xsurface->maximized_vert;
+}
+
+static void handle_net_wm_state_message(struct wlr_xwm *xwm,
+		xcb_client_message_event_t *client_message) {
+	struct wlr_xwayland_surface *xsurface = lookup_surface(xwm, client_message->window);
+	if (!xsurface) {
+		return;
+	}
+
+	int maximized = xsurface_is_maximized(xsurface);
+
+	uint32_t action = client_message->data.data32[0];
+	uint32_t property = client_message->data.data32[1];
+
+	if (property == xwm->atoms[_NET_WM_STATE_FULLSCREEN] &&
+			update_state(action, &xsurface->fullscreen)) {
+		xsurface_set_net_wm_state(xsurface);
+
+		if (xsurface->fullscreen) {
+			xsurface->saved_width = xsurface->width;
+			xsurface->saved_height = xsurface->height;
+		}
+
+		wl_signal_emit(&xsurface->events.request_fullscreen, xsurface);
+	} else {
+		if (property == xwm->atoms[_NET_WM_STATE_MAXIMIZED_VERT] &&
+				update_state(action, &xsurface->maximized_vert)) {
+			xsurface_set_net_wm_state(xsurface);
+		}
+
+		if (property == xwm->atoms[_NET_WM_STATE_MAXIMIZED_HORZ] &&
+				update_state(action, &xsurface->maximized_horz)) {
+			xsurface_set_net_wm_state(xsurface);
+		}
+
+		if (maximized != xsurface_is_maximized(xsurface)) {
+			if (xsurface_is_maximized(xsurface)) {
+				xsurface->saved_width = xsurface->width;
+				xsurface->saved_height = xsurface->height;
+			}
+
+			wl_signal_emit(&xsurface->events.request_maximize, xsurface);
+		}
+	}
+}
+
 static void handle_client_message(struct wlr_xwm *xwm,
 		xcb_client_message_event_t *ev) {
 	wlr_log(L_DEBUG, "XCB_CLIENT_MESSAGE (%u)", ev->window);
@@ -769,7 +859,7 @@ static void handle_client_message(struct wlr_xwm *xwm,
 	if (ev->type == xwm->atoms[WL_SURFACE_ID]) {
 		handle_surface_id_message(xwm, ev);
 	} else if (ev->type == xwm->atoms[NET_WM_STATE]) {
-		wlr_log(L_DEBUG, "TODO: handle _NET_WM_STATE client message");
+		handle_net_wm_state_message(xwm, ev);
 	} else if (ev->type == xwm->atoms[_NET_WM_MOVERESIZE]) {
 		handle_net_wm_moveresize_message(xwm, ev);
 	} else {
@@ -1104,6 +1194,9 @@ struct wlr_xwm *xwm_create(struct wlr_xwayland *wlr_xwayland) {
 		xwm->atoms[NET_WM_STATE],
 		xwm->atoms[_NET_ACTIVE_WINDOW],
 		xwm->atoms[_NET_WM_MOVERESIZE],
+		xwm->atoms[_NET_WM_STATE_FULLSCREEN],
+		xwm->atoms[_NET_WM_STATE_MAXIMIZED_HORZ],
+		xwm->atoms[_NET_WM_STATE_MAXIMIZED_VERT],
 	};
 	xcb_change_property(xwm->xcb_conn,
 		XCB_PROP_MODE_REPLACE,
@@ -1128,3 +1221,20 @@ struct wlr_xwm *xwm_create(struct wlr_xwayland *wlr_xwayland) {
 
 	return xwm;
 }
+
+void wlr_xwayland_surface_set_maximized(struct wlr_xwayland *wlr_xwayland,
+	struct wlr_xwayland_surface *surface, bool maximized) {
+	if (xsurface_is_maximized(surface) != maximized) {
+		surface->maximized_horz = maximized;
+		surface->maximized_vert = maximized;
+		xsurface_set_net_wm_state(surface);
+	}
+}
+
+void wlr_xwayland_surface_set_fullscreen(struct wlr_xwayland *wlr_xwayland,
+	struct wlr_xwayland_surface *surface, bool fullscreen) {
+	if (surface->fullscreen != fullscreen) {
+		surface->fullscreen = fullscreen;
+		xsurface_set_net_wm_state(surface);
+	}
+}
-- 
cgit v1.2.3


From 325def38418f5caefd6dc23749dd2ca6bae0a36c Mon Sep 17 00:00:00 2001
From: Tony Crisci <tony@dubstepdish.com>
Date: Fri, 27 Oct 2017 15:20:50 -0400
Subject: xwm: create colormap and visual depth detection

---
 include/wlr/xwayland.h |  2 ++
 xwayland/xwm.c         | 47 +++++++++++++++++++++++++++++++++++++++++++----
 xwayland/xwm.h         |  2 ++
 3 files changed, 47 insertions(+), 4 deletions(-)

(limited to 'include/wlr/xwayland.h')

diff --git a/include/wlr/xwayland.h b/include/wlr/xwayland.h
index cc5d06cb..2d968133 100644
--- a/include/wlr/xwayland.h
+++ b/include/wlr/xwayland.h
@@ -102,6 +102,8 @@ struct wlr_xwayland_surface {
 	bool maximized_vert;
 	bool maximized_horz;
 
+	bool has_alpha;
+
 	struct {
 		struct wl_signal destroy;
 		struct wl_signal request_configure;
diff --git a/xwayland/xwm.c b/xwayland/xwm.c
index 5ba91370..9ddf59df 100644
--- a/xwayland/xwm.c
+++ b/xwayland/xwm.c
@@ -64,6 +64,9 @@ static struct wlr_xwayland_surface *wlr_xwayland_surface_create(
 		return NULL;
 	}
 
+	xcb_get_geometry_cookie_t geometry_cookie =
+		xcb_get_geometry(xwm->xcb_conn, window_id);
+
 	uint32_t values[1];
 	values[0] =
 		XCB_EVENT_MASK_FOCUS_CHANGE |
@@ -92,6 +95,16 @@ static struct wlr_xwayland_surface *wlr_xwayland_surface_create(
 	wl_signal_init(&surface->events.set_parent);
 	wl_signal_init(&surface->events.set_pid);
 	wl_signal_init(&surface->events.set_window_type);
+
+	xcb_get_geometry_reply_t *geometry_reply =
+		xcb_get_geometry_reply(xwm->xcb_conn, geometry_cookie, NULL);
+
+	if (geometry_reply != NULL) {
+		surface->has_alpha = geometry_reply->depth == 32;
+	}
+
+	free(geometry_reply);
+
 	return surface;
 }
 
@@ -193,10 +206,6 @@ static void wlr_xwayland_surface_destroy(struct wlr_xwayland_surface *surface) {
 		wl_list_remove(&surface->unpaired_link);
 	}
 
-	for (size_t i = 0; i < surface->state->length; i++) {
-		free(surface->state->items[i]);
-	}
-
 	if (surface->surface) {
 		wl_list_remove(&surface->surface_destroy.link);
 		wl_list_remove(&surface->surface_commit.link);
@@ -1140,6 +1149,35 @@ static void xwm_create_wm_window(struct wlr_xwm *xwm) {
 		XCB_CURRENT_TIME);
 }
 
+// TODO use me to support 32 bit color somehow
+static void xwm_get_visual_and_colormap(struct wlr_xwm *xwm) {
+	xcb_depth_iterator_t d_iter;
+	xcb_visualtype_iterator_t vt_iter;
+	xcb_visualtype_t *visualtype;
+
+	d_iter = xcb_screen_allowed_depths_iterator(xwm->screen);
+	visualtype = NULL;
+	while (d_iter.rem > 0) {
+		if (d_iter.data->depth == 32) {
+			vt_iter = xcb_depth_visuals_iterator(d_iter.data);
+			visualtype = vt_iter.data;
+			break;
+		}
+
+		xcb_depth_next(&d_iter);
+	}
+
+	if (visualtype == NULL) {
+		wlr_log(L_DEBUG, "no 32 bit visualtype\n");
+		return;
+	}
+
+	xwm->visual_id = visualtype->visual_id;
+	xwm->colormap = xcb_generate_id(xwm->xcb_conn);
+	xcb_create_colormap_checked(xwm->xcb_conn, XCB_COLORMAP_ALLOC_NONE,
+		xwm->colormap, xwm->screen->root, xwm->visual_id);
+}
+
 struct wlr_xwm *xwm_create(struct wlr_xwayland *wlr_xwayland) {
 	struct wlr_xwm *xwm = calloc(1, sizeof(struct wlr_xwm));
 	if (xwm == NULL) {
@@ -1175,6 +1213,7 @@ struct wlr_xwm *xwm_create(struct wlr_xwayland *wlr_xwayland) {
 	wl_event_source_check(xwm->event_source);
 
 	xwm_get_resources(xwm);
+	xwm_get_visual_and_colormap(xwm);
 
 	uint32_t values[1];
 	values[0] =
diff --git a/xwayland/xwm.h b/xwayland/xwm.h
index 4f8c20a2..7d30d278 100644
--- a/xwayland/xwm.h
+++ b/xwayland/xwm.h
@@ -47,6 +47,8 @@ struct wlr_xwm {
 	xcb_connection_t *xcb_conn;
 	xcb_screen_t *screen;
 	xcb_window_t window;
+	xcb_visualid_t visual_id;
+	xcb_colormap_t colormap;
 
 	struct wlr_xwayland_surface *focus_surface;
 
-- 
cgit v1.2.3