Merge pull request #49 from guidocella/layer-shell

Layer shell

Makefile

@@ -23,15 +23,25 @@ xdg-shell-protocol.c:
 
 xdg-shell-protocol.o: xdg-shell-protocol.h
 
+wlr-layer-shell-unstable-v1-protocol.h:
+	$(WAYLAND_SCANNER) server-header \
+		protocols/wlr-layer-shell-unstable-v1.xml $@
+
+wlr-layer-shell-unstable-v1-protocol.c:
+	$(WAYLAND_SCANNER) private-code \
+		protocols/wlr-layer-shell-unstable-v1.xml $@
+
+wlr-layer-shell-unstable-v1-protocol.o: wlr-layer-shell-unstable-v1-protocol.h
+
 config.h: | config.def.h
 	cp config.def.h $@
 
-dwl.o: config.h xdg-shell-protocol.h
+dwl.o: config.h xdg-shell-protocol.h wlr-layer-shell-unstable-v1-protocol.h
 
-dwl: xdg-shell-protocol.o
+dwl: xdg-shell-protocol.o wlr-layer-shell-unstable-v1-protocol.o
 
 clean:
-	rm -f dwl *.o xdg-shell-protocol.h xdg-shell-protocol.c
+	rm -f dwl *.o *-protocol.h *-protocol.c
 
 install: dwl
 	install -D dwl $(PREFIX)/bin/dwl

README.md

@@ -63,7 +63,6 @@ dwl is a work in progress, and it has not yet reached its feature goals in a num
 - XWayland support is new and could use testing
 - Urgent/attention/focus-request ([not yet supported](https://gitlab.freedesktop.org/wayland/wayland-protocols/-/merge_requests/9) by xdg-shell protocol)
 - Statusbar support (built-in or external)
-- layer-shell
 - Damage tracking
 - Fullscreen/fixed windows (or whatever the Wayland analogues are)
 

dwl.c

@@ -20,6 +20,7 @@
 #include <wlr/types/wlr_export_dmabuf_v1.h>
 #include <wlr/types/wlr_gamma_control_v1.h>
 #include <wlr/types/wlr_input_device.h>
+#include <wlr/types/wlr_layer_shell_v1.h>
 #include <wlr/types/wlr_keyboard.h>
 #include <wlr/types/wlr_matrix.h>
 #include <wlr/types/wlr_output.h>
@@ -130,6 +131,19 @@ typedef struct {
 	struct wl_listener destroy;
 } Keyboard;
 
+typedef struct {
+	struct wlr_layer_surface_v1 *layer_surface;
+	struct wl_list link;
+
+	struct wl_listener destroy;
+	struct wl_listener map;
+	struct wl_listener unmap;
+	struct wl_listener surface_commit;
+
+	struct wlr_box geo;
+	enum zwlr_layer_shell_v1_layer layer;
+} LayerSurface;
+
 typedef struct {
 	const char *symbol;
 	void (*arrange)(Monitor *);
@@ -142,6 +156,7 @@ struct Monitor {
 	struct wl_listener destroy;
 	struct wlr_box m;      /* monitor area, layout-relative */
 	struct wlr_box w;      /* window area, layout-relative */
+	struct wl_list layers[4]; // LayerSurface::link
 	const Layout *lt[2];
 	unsigned int seltags;
 	unsigned int sellt;
@@ -177,21 +192,30 @@ struct render_data {
 
 /* function declarations */
 static void applybounds(Client *c, struct wlr_box *bbox);
+static void applyexclusive(struct wlr_box *usable_area, uint32_t anchor,
+		int32_t exclusive, int32_t margin_top, int32_t margin_right,
+		int32_t margin_bottom, int32_t margin_left);
 static void applyrules(Client *c);
 static void arrange(Monitor *m);
+static void arrangelayer(Monitor *m, struct wl_list *list,
+		struct wlr_box *usable_area, bool exclusive);
+static void arrangelayers(Monitor *m);
 static void axisnotify(struct wl_listener *listener, void *data);
 static void buttonpress(struct wl_listener *listener, void *data);
 static void chvt(const Arg *arg);
 static void cleanup(void);
 static void cleanupkeyboard(struct wl_listener *listener, void *data);
 static void cleanupmon(struct wl_listener *listener, void *data);
+static void commitlayersurfacenotify(struct wl_listener *listener, void *data);
 static void commitnotify(struct wl_listener *listener, void *data);
 static void createkeyboard(struct wlr_input_device *device);
 static void createmon(struct wl_listener *listener, void *data);
 static void createnotify(struct wl_listener *listener, void *data);
+static void createlayersurface(struct wl_listener *listener, void *data);
 static void createpointer(struct wlr_input_device *device);
 static void createxdeco(struct wl_listener *listener, void *data);
 static void cursorframe(struct wl_listener *listener, void *data);
+static void destroylayersurfacenotify(struct wl_listener *listener, void *data);
 static void destroynotify(struct wl_listener *listener, void *data);
 static void destroyxdeco(struct wl_listener *listener, void *data);
 static Monitor *dirtomon(int dir);
@@ -206,6 +230,7 @@ static int keybinding(uint32_t mods, xkb_keysym_t sym);
 static void keypress(struct wl_listener *listener, void *data);
 static void keypressmod(struct wl_listener *listener, void *data);
 static void killclient(const Arg *arg);
+static void maplayersurfacenotify(struct wl_listener *listener, void *data);
 static void maprequest(struct wl_listener *listener, void *data);
 static void monocle(Monitor *m);
 static void motionabsolute(struct wl_listener *listener, void *data);
@@ -217,6 +242,7 @@ static void pointerfocus(Client *c, struct wlr_surface *surface,
 static void quit(const Arg *arg);
 static void render(struct wlr_surface *surface, int sx, int sy, void *data);
 static void renderclients(Monitor *m, struct timespec *now);
+static void renderlayer(struct wl_list *layer_surfaces, struct timespec *now);
 static void rendermon(struct wl_listener *listener, void *data);
 static void resize(Client *c, int x, int y, int w, int h, int interact);
 static void run(char *startup_cmd);
@@ -231,6 +257,7 @@ static void setmfact(const Arg *arg);
 static void setmon(Client *c, Monitor *m, unsigned int newtags);
 static void setup(void);
 static void sigchld(int unused);
+static bool shouldfocusclients();
 static void spawn(const Arg *arg);
 static void tag(const Arg *arg);
 static void tagmon(const Arg *arg);
@@ -238,9 +265,14 @@ static void tile(Monitor *m);
 static void togglefloating(const Arg *arg);
 static void toggletag(const Arg *arg);
 static void toggleview(const Arg *arg);
+static void unmaplayersurface(LayerSurface *layersurface);
+static void unmaplayersurfacenotify(struct wl_listener *listener, void *data);
 static void unmapnotify(struct wl_listener *listener, void *data);
+static void updatemons();
 static void view(const Arg *arg);
 static Client *xytoclient(double x, double y);
+static struct wlr_surface *xytolayersurface(struct wl_list *layer_surfaces,
+		double x, double y, double *sx, double *sy);
 static Monitor *xytomon(double x, double y);
 static void zoom(const Arg *arg);
 
@@ -256,6 +288,7 @@ static struct wl_list clients; /* tiling order */
 static struct wl_list fstack;  /* focus order */
 static struct wl_list stack;   /* stacking z-order */
 static struct wl_list independents;
+static struct wlr_layer_shell_v1 *layer_shell;
 static struct wlr_xdg_decoration_manager_v1 *xdeco_mgr;
 
 static struct wlr_cursor *cursor;
@@ -282,6 +315,7 @@ static struct wl_listener new_input = {.notify = inputdevice};
 static struct wl_listener new_output = {.notify = createmon};
 static struct wl_listener new_xdeco = {.notify = createxdeco};
 static struct wl_listener new_xdg_surface = {.notify = createnotify};
+static struct wl_listener new_layer_shell_surface = {.notify = createlayersurface};
 static struct wl_listener request_cursor = {.notify = setcursor};
 static struct wl_listener request_set_psel = {.notify = setpsel};
 static struct wl_listener request_set_sel = {.notify = setsel};
@@ -324,6 +358,71 @@ applybounds(Client *c, struct wlr_box *bbox)
 		c->geom.y = bbox->y;
 }
 
+void
+applyexclusive(struct wlr_box *usable_area,
+		uint32_t anchor, int32_t exclusive,
+		int32_t margin_top, int32_t margin_right,
+		int32_t margin_bottom, int32_t margin_left) {
+	struct {
+		uint32_t singular_anchor;
+		uint32_t anchor_triplet;
+		int *positive_axis;
+		int *negative_axis;
+		int margin;
+	} edges[4];
+
+	if (exclusive <= 0)
+		return;
+
+	// Top
+	edges[0].singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP;
+	edges[0].anchor_triplet =
+		ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
+		ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
+		ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP;
+	edges[0].positive_axis = &usable_area->y;
+	edges[0].negative_axis = &usable_area->height;
+	edges[0].margin = margin_top;
+	// Bottom
+	edges[1].singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+	edges[1].anchor_triplet =
+		ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
+		ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
+		ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+	edges[1].positive_axis = NULL;
+	edges[1].negative_axis = &usable_area->height;
+	edges[1].margin = margin_bottom;
+	// Left
+	edges[2].singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT;
+	edges[2].anchor_triplet =
+		ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
+		ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
+		ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+	edges[2].positive_axis = &usable_area->x;
+	edges[2].negative_axis = &usable_area->width;
+	edges[2].margin = margin_left;
+	// Right
+	edges[3].singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
+	edges[3].anchor_triplet =
+		ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
+		ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
+		ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+	edges[3].positive_axis = NULL;
+	edges[3].negative_axis = &usable_area->width;
+	edges[3].margin = margin_right;
+
+	for (size_t i = 0; i < LENGTH(edges); ++i) {
+		if ((anchor == edges[i].singular_anchor || anchor == edges[i].anchor_triplet)
+				&& exclusive + edges[i].margin > 0) {
+			if (edges[i].positive_axis)
+				*edges[i].positive_axis += exclusive + edges[i].margin;
+			if (edges[i].negative_axis)
+				*edges[i].negative_axis -= exclusive + edges[i].margin;
+			break;
+		}
+	}
+}
+
 void
 applyrules(Client *c)
 {
@@ -367,14 +466,138 @@ applyrules(Client *c)
 void
 arrange(Monitor *m)
 {
-	/* Get effective monitor geometry to use for window area */
-	m->m = *wlr_output_layout_get_box(output_layout, m->wlr_output);
-	m->w = m->m;
 	if (m->lt[m->sellt]->arrange)
 		m->lt[m->sellt]->arrange(m);
 	/* XXX recheck pointer focus here... or in resize()? */
 }
 
+void
+arrangelayer(Monitor *m, struct wl_list *list, struct wlr_box *usable_area, bool exclusive)
+{
+	LayerSurface *layersurface;
+	struct wlr_box full_area = m->m;
+
+	wl_list_for_each(layersurface, list, link) {
+		struct wlr_layer_surface_v1 *wlr_layer_surface = layersurface->layer_surface;
+		struct wlr_layer_surface_v1_state *state = &wlr_layer_surface->current;
+		struct wlr_box bounds;
+		struct wlr_box box = {
+			.width = state->desired_width,
+			.height = state->desired_height
+		};
+		const uint32_t both_horiz = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT
+			| ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
+		const uint32_t both_vert = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP
+			| ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
+
+		if (exclusive != (state->exclusive_zone > 0))
+			continue;
+
+		bounds = state->exclusive_zone == -1 ? full_area : *usable_area;
+
+		// Horizontal axis
+		if ((state->anchor & both_horiz) && box.width == 0) {
+			box.x = bounds.x;
+			box.width = bounds.width;
+		} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT)) {
+			box.x = bounds.x;
+		} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT)) {
+			box.x = bounds.x + (bounds.width - box.width);
+		} else {
+			box.x = bounds.x + ((bounds.width / 2) - (box.width / 2));
+		}
+		// Vertical axis
+		if ((state->anchor & both_vert) && box.height == 0) {
+			box.y = bounds.y;
+			box.height = bounds.height;
+		} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP)) {
+			box.y = bounds.y;
+		} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM)) {
+			box.y = bounds.y + (bounds.height - box.height);
+		} else {
+			box.y = bounds.y + ((bounds.height / 2) - (box.height / 2));
+		}
+		// Margin
+		if ((state->anchor & both_horiz) == both_horiz) {
+			box.x += state->margin.left;
+			box.width -= state->margin.left + state->margin.right;
+		} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT)) {
+			box.x += state->margin.left;
+		} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT)) {
+			box.x -= state->margin.right;
+		}
+		if ((state->anchor & both_vert) == both_vert) {
+			box.y += state->margin.top;
+			box.height -= state->margin.top + state->margin.bottom;
+		} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP)) {
+			box.y += state->margin.top;
+		} else if ((state->anchor & ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM)) {
+			box.y -= state->margin.bottom;
+		}
+		if (box.width < 0 || box.height < 0) {
+			wlr_layer_surface_v1_close(wlr_layer_surface);
+			continue;
+		}
+		layersurface->geo = box;
+
+		applyexclusive(usable_area, state->anchor, state->exclusive_zone,
+				state->margin.top, state->margin.right,
+				state->margin.bottom, state->margin.left);
+		wlr_layer_surface_v1_configure(wlr_layer_surface, box.width, box.height);
+	}
+}
+
+void
+arrangelayers(Monitor *m)
+{
+	struct wlr_box usable_area = m->m;
+	uint32_t layers_above_shell[] = {
+		ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY,
+		ZWLR_LAYER_SHELL_V1_LAYER_TOP,
+	};
+	size_t nlayers = LENGTH(layers_above_shell);
+	LayerSurface *layersurface;
+	struct wlr_keyboard *kb = wlr_seat_get_keyboard(seat);
+
+	// Arrange exclusive surfaces from top->bottom
+	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
+			&usable_area, true);
+	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
+			&usable_area, true);
+	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
+			&usable_area, true);
+	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
+			&usable_area, true);
+
+	if (memcmp(&usable_area, &m->w, sizeof(struct wlr_box))) {
+		m->w = usable_area;
+		arrange(m);
+	}
+
+	// Arrange non-exlusive surfaces from top->bottom
+	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
+			&usable_area, false);
+	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
+			&usable_area, false);
+	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
+			&usable_area, false);
+	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
+			&usable_area, false);
+
+	// Find topmost keyboard interactive layer, if such a layer exists
+	for (size_t i = 0; i < nlayers; ++i) {
+		wl_list_for_each_reverse(layersurface,
+				&m->layers[layers_above_shell[i]], link) {
+			if (layersurface->layer_surface->current.keyboard_interactive &&
+					layersurface->layer_surface->mapped) {
+				wlr_seat_keyboard_notify_enter(seat, layersurface->layer_surface->surface,
+						kb->keycodes, kb->num_keycodes, &kb->modifiers);
+				return;
+			}
+		}
+	}
+}
+
 void
 axisnotify(struct wl_listener *listener, void *data)
 {
@@ -470,6 +693,30 @@ cleanupmon(struct wl_listener *listener, void *data)
 
 	wl_list_remove(&m->destroy.link);
 	free(m);
+
+	updatemons();
+}
+
+void
+commitlayersurfacenotify(struct wl_listener *listener, void *data)
+{
+	LayerSurface *layersurface = wl_container_of(listener, layersurface, surface_commit);
+	struct wlr_layer_surface_v1 *wlr_layer_surface = layersurface->layer_surface;
+	struct wlr_output *wlr_output = wlr_layer_surface->output;
+	Monitor *m;
+
+	if (!wlr_output)
+		return;
+
+	m = wlr_output->data;
+	arrangelayers(m);
+
+	if (layersurface->layer != wlr_layer_surface->current.layer) {
+		wl_list_remove(&layersurface->link);
+		wl_list_insert(&m->layers[wlr_layer_surface->current.layer],
+			&layersurface->link);
+		layersurface->layer = wlr_layer_surface->current.layer;
+	}
 }
 
 void
@@ -524,6 +771,7 @@ createmon(struct wl_listener *listener, void *data)
 	struct wlr_output *wlr_output = data;
 	Monitor *m;
 	const MonitorRule *r;
+	size_t nlayers = LENGTH(m->layers);
 
 	/* The mode is a tuple of (width, height, refresh rate), and each
 	 * monitor supports only a specific set of modes. We just pick the
@@ -569,6 +817,12 @@ createmon(struct wl_listener *listener, void *data)
 	 */
 	wlr_output_layout_add_auto(output_layout, wlr_output);
 	sgeom = *wlr_output_layout_get_box(output_layout, NULL);
+
+	for (size_t i = 0; i < nlayers; ++i)
+		wl_list_init(&m->layers[i]);
+
+	/* When adding monitors, the geometries of all monitors must be updated */
+	updatemons();
 }
 
 void
@@ -602,6 +856,46 @@ createnotify(struct wl_listener *listener, void *data)
 	wl_signal_add(&xdg_surface->events.destroy, &c->destroy);
 }
 
+void
+createlayersurface(struct wl_listener *listener, void *data)
+{
+	struct wlr_layer_surface_v1 *wlr_layer_surface = data;
+	LayerSurface *layersurface;
+	Monitor *m;
+	struct wlr_layer_surface_v1_state old_state;
+
+	if (!wlr_layer_surface->output) {
+		wlr_layer_surface->output = selmon->wlr_output;
+	}
+
+	layersurface = calloc(1, sizeof(LayerSurface));
+
+	layersurface->surface_commit.notify = commitlayersurfacenotify;
+	wl_signal_add(&wlr_layer_surface->surface->events.commit,
+		&layersurface->surface_commit);
+	layersurface->destroy.notify = destroylayersurfacenotify;
+	wl_signal_add(&wlr_layer_surface->events.destroy, &layersurface->destroy);
+	layersurface->map.notify = maplayersurfacenotify;
+	wl_signal_add(&wlr_layer_surface->events.map, &layersurface->map);
+	layersurface->unmap.notify = unmaplayersurfacenotify;
+	wl_signal_add(&wlr_layer_surface->events.unmap, &layersurface->unmap);
+
+	layersurface->layer_surface = wlr_layer_surface;
+	wlr_layer_surface->data = layersurface;
+
+	m = wlr_layer_surface->output->data;
+
+	wl_list_insert(&m->layers[wlr_layer_surface->client_pending.layer],
+			&layersurface->link);
+
+	// Temporarily set the layer's current state to client_pending
+	// so that we can easily arrange it
+	old_state = wlr_layer_surface->current;
+	wlr_layer_surface->current = wlr_layer_surface->client_pending;
+	arrangelayers(m);
+	wlr_layer_surface->current = old_state;
+}
+
 void
 createpointer(struct wlr_input_device *device)
 {
@@ -647,6 +941,28 @@ cursorframe(struct wl_listener *listener, void *data)
 	wlr_seat_pointer_notify_frame(seat);
 }
 
+void
+destroylayersurfacenotify(struct wl_listener *listener, void *data)
+{
+	LayerSurface *layersurface = wl_container_of(listener, layersurface, destroy);
+	Monitor *m;
+
+	if (layersurface->layer_surface->mapped)
+		unmaplayersurface(layersurface);
+	wl_list_remove(&layersurface->link);
+	wl_list_remove(&layersurface->destroy.link);
+	wl_list_remove(&layersurface->map.link);
+	wl_list_remove(&layersurface->unmap.link);
+	wl_list_remove(&layersurface->surface_commit.link);
+	if (layersurface->layer_surface->output) {
+		m = layersurface->layer_surface->output->data;
+		if (m)
+			arrangelayers(m);
+		layersurface->layer_surface->output = NULL;
+	}
+	free(layersurface);
+}
+
 void
 destroynotify(struct wl_listener *listener, void *data)
 {
@@ -724,8 +1040,9 @@ focusclient(Client *old, Client *c, int lift)
 	}
 
 	/* Have a client, so focus its top-level wlr_surface */
-	wlr_seat_keyboard_notify_enter(seat, WLR_SURFACE(c),
+	if (shouldfocusclients(c->mon))
-			kb->keycodes, kb->num_keycodes, &kb->modifiers);
+		wlr_seat_keyboard_notify_enter(seat, WLR_SURFACE(c),
+				kb->keycodes, kb->num_keycodes, &kb->modifiers);
 
 	/* Put the new client atop the focus stack and select its monitor */
 	wl_list_remove(&c->flink);
@@ -912,6 +1229,14 @@ killclient(const Arg *arg)
 		wlr_xdg_toplevel_send_close(sel->surface.xdg);
 }
 
+void
+maplayersurfacenotify(struct wl_listener *listener, void *data)
+{
+	LayerSurface *layersurface = wl_container_of(listener, layersurface, map);
+	wlr_surface_send_enter(layersurface->layer_surface->surface, layersurface->layer_surface->output);
+	motionnotify(0);
+}
+
 void
 maprequest(struct wl_listener *listener, void *data)
 {
@@ -980,7 +1305,12 @@ motionnotify(uint32_t time)
 {
 	double sx = 0, sy = 0;
 	struct wlr_surface *surface = NULL;
-	Client *c;
+	Client *c = NULL;
+	struct timespec now;
+	if (!time) {
+		clock_gettime(CLOCK_MONOTONIC, &now);
+		time = now.tv_sec * 1000 + now.tv_nsec / 1000000;
+	}
 
 	/* Update selmon (even while dragging a window) */
 	if (sloppyfocus)
@@ -999,17 +1329,23 @@ motionnotify(uint32_t time)
 		return;
 	}
 
+	if ((surface = xytolayersurface(&selmon->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
+					cursor->x, cursor->y, &sx, &sy)))
+		;
+	else if ((surface = xytolayersurface(&selmon->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
+					cursor->x, cursor->y, &sx, &sy)))
+		;
 #ifdef XWAYLAND
 	/* Find an independent under the pointer and send the event along. */
-	if ((c = xytoindependent(cursor->x, cursor->y))) {
+	else if ((c = xytoindependent(cursor->x, cursor->y))) {
 		surface = wlr_surface_surface_at(c->surface.xwayland->surface,
 				cursor->x - c->surface.xwayland->x - c->bw,
 				cursor->y - c->surface.xwayland->y - c->bw, &sx, &sy);
 
 	/* Otherwise, find the client under the pointer and send the event along. */
-	} else
+	}
 #endif
-	if ((c = xytoclient(cursor->x, cursor->y))) {
+	else if ((c = xytoclient(cursor->x, cursor->y))) {
 #ifdef XWAYLAND
 		if (c->type != XDGShell)
 			surface = wlr_surface_surface_at(c->surface.xwayland->surface,
@@ -1021,6 +1357,13 @@ motionnotify(uint32_t time)
 					cursor->x - c->geom.x - c->bw,
 					cursor->y - c->geom.y - c->bw, &sx, &sy);
 	}
+	else if ((surface = xytolayersurface(&selmon->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
+					cursor->x, cursor->y, &sx, &sy)))
+		;
+	else
+		surface = xytolayersurface(&selmon->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
+					cursor->x, cursor->y, &sx, &sy);
+
 	/* If there's no client surface under the cursor, set the cursor image to a
 	 * default. This is what makes the cursor image appear when you move it
 	 * off of a client or over its border. */
@@ -1098,6 +1441,9 @@ pointerfocus(Client *c, struct wlr_surface *surface, double sx, double sy,
 	 * of its surfaces, and make keyboard focus follow if desired. */
 	wlr_seat_pointer_notify_enter(seat, surface, sx, sy);
 
+	if (!c)
+		return;
+
 #if XWAYLAND
 	if (c->type == X11Unmanaged)
 		return;
@@ -1225,6 +1571,22 @@ renderclients(Monitor *m, struct timespec *now)
 	}
 }
 
+void
+renderlayer(struct wl_list *layer_surfaces, struct timespec *now)
+{
+	struct render_data rdata;
+	LayerSurface *layersurface;
+	wl_list_for_each(layersurface, layer_surfaces, link) {
+		rdata.output = layersurface->layer_surface->output;
+		rdata.when = now;
+		rdata.x = layersurface->geo.x;
+		rdata.y = layersurface->geo.y;
+
+		wlr_surface_for_each_surface(layersurface->layer_surface->surface,
+				render, &rdata);
+	}
+}
+
 void
 rendermon(struct wl_listener *listener, void *data)
 {
@@ -1255,10 +1617,14 @@ rendermon(struct wl_listener *listener, void *data)
 		wlr_renderer_begin(drw, m->wlr_output->width, m->wlr_output->height);
 		wlr_renderer_clear(drw, rootcolor);
 
+		renderlayer(&m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND], &now);
+		renderlayer(&m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM], &now);
 		renderclients(m, &now);
 #ifdef XWAYLAND
 		renderindependents(m->wlr_output, &now);
 #endif
+		renderlayer(&m->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP], &now);
+		renderlayer(&m->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &now);
 
 		/* Hardware cursors are rendered by the GPU on a separate plane, and can be
 		 * moved around without re-rendering what's beneath them - which is more
@@ -1532,6 +1898,10 @@ setup(void)
 	wl_list_init(&fstack);
 	wl_list_init(&stack);
 	wl_list_init(&independents);
+
+	layer_shell = wlr_layer_shell_v1_create(dpy);
+	wl_signal_add(&layer_shell->events.new_surface, &new_layer_shell_surface);
+
 	xdg_shell = wlr_xdg_shell_create(dpy);
 	wl_signal_add(&xdg_shell->events.new_surface, &new_xdg_surface);
 
@@ -1613,6 +1983,22 @@ sigchld(int unused)
 		;
 }
 
+bool
+shouldfocusclients(Monitor *m)
+{
+	LayerSurface *layersurface;
+	uint32_t layers_above_shell[] = {
+		ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY,
+		ZWLR_LAYER_SHELL_V1_LAYER_TOP,
+	};
+	for (size_t i = 0; i < LENGTH(layers_above_shell); ++i)
+		wl_list_for_each(layersurface, &m->layers[layers_above_shell[i]], link)
+			if (layersurface->layer_surface->current.keyboard_interactive &&
+					layersurface->layer_surface->mapped)
+				return false;
+	return true;
+}
+
 void
 spawn(const Arg *arg)
 {
@@ -1714,6 +2100,23 @@ toggleview(const Arg *arg)
 	}
 }
 
+void
+unmaplayersurface(LayerSurface *layersurface)
+{
+	layersurface->layer_surface->mapped = false;
+	if (layersurface->layer_surface->surface ==
+			seat->keyboard_state.focused_surface)
+		focusclient(NULL, selclient(), 1);
+	motionnotify(0);
+}
+
+void
+unmaplayersurfacenotify(struct wl_listener *listener, void *data)
+{
+	LayerSurface *layersurface = wl_container_of(listener, layersurface, unmap);
+	unmaplayersurface(layersurface);
+}
+
 void
 unmapnotify(struct wl_listener *listener, void *data)
 {
@@ -1729,6 +2132,20 @@ unmapnotify(struct wl_listener *listener, void *data)
 	wl_list_remove(&c->slink);
 }
 
+void
+updatemons()
+{
+	Monitor *m;
+	wl_list_for_each(m, &mons, link) {
+		/* Get the effective monitor geometry to use for surfaces */
+		m->m = m->w = *wlr_output_layout_get_box(output_layout, m->wlr_output);
+		/* Calculate the effective monitor geometry to use for clients */
+		arrangelayers(m);
+		/* Don't move clients to the left output when plugging monitors */
+		arrange(m);
+	}
+}
+
 void
 view(const Arg *arg)
 {
@@ -1754,6 +2171,27 @@ xytoclient(double x, double y)
 	return NULL;
 }
 
+struct wlr_surface *
+xytolayersurface(struct wl_list *layer_surfaces, double x, double y,
+		double *sx, double *sy)
+{
+	LayerSurface *layersurface;
+	wl_list_for_each_reverse(layersurface, layer_surfaces, link) {
+		struct wlr_surface *sub;
+		if (!layersurface->layer_surface->mapped)
+			continue;
+		sub = wlr_layer_surface_v1_surface_at(
+				layersurface->layer_surface,
+				x - layersurface->geo.x,
+				y - layersurface->geo.y,
+				sx, sy);
+		if (sub)
+			return sub;
+
+	}
+	return NULL;
+}
+
 Monitor *
 xytomon(double x, double y)
 {

protocols/wlr-layer-shell-unstable-v1.xml

@@ -0,0 +1,311 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<protocol name="wlr_layer_shell_unstable_v1">
+  <copyright>
+    Copyright © 2017 Drew DeVault
+
+    Permission to use, copy, modify, distribute, and sell this
+    software and its documentation for any purpose is hereby granted
+    without fee, provided that the above copyright notice appear in
+    all copies and that both that copyright notice and this permission
+    notice appear in supporting documentation, and that the name of
+    the copyright holders not be used in advertising or publicity
+    pertaining to distribution of the software without specific,
+    written prior permission.  The copyright holders make no
+    representations about the suitability of this software for any
+    purpose.  It is provided "as is" without express or implied
+    warranty.
+
+    THE COPYRIGHT HOLDERS DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+    SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+    FITNESS, IN NO EVENT SHALL THE COPYRIGHT HOLDERS BE LIABLE FOR ANY
+    SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+    WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN
+    AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+    ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
+    THIS SOFTWARE.
+  </copyright>
+
+  <interface name="zwlr_layer_shell_v1" version="3">
+    <description summary="create surfaces that are layers of the desktop">
+      Clients can use this interface to assign the surface_layer role to
+      wl_surfaces. Such surfaces are assigned to a "layer" of the output and
+      rendered with a defined z-depth respective to each other. They may also be
+      anchored to the edges and corners of a screen and specify input handling
+      semantics. This interface should be suitable for the implementation of
+      many desktop shell components, and a broad number of other applications
+      that interact with the desktop.
+    </description>
+
+    <request name="get_layer_surface">
+      <description summary="create a layer_surface from a surface">
+        Create a layer surface for an existing surface. This assigns the role of
+        layer_surface, or raises a protocol error if another role is already
+        assigned.
+
+        Creating a layer surface from a wl_surface which has a buffer attached
+        or committed is a client error, and any attempts by a client to attach
+        or manipulate a buffer prior to the first layer_surface.configure call
+        must also be treated as errors.
+
+        You may pass NULL for output to allow the compositor to decide which
+        output to use. Generally this will be the one that the user most
+        recently interacted with.
+
+        Clients can specify a namespace that defines the purpose of the layer
+        surface.
+      </description>
+      <arg name="id" type="new_id" interface="zwlr_layer_surface_v1"/>
+      <arg name="surface" type="object" interface="wl_surface"/>
+      <arg name="output" type="object" interface="wl_output" allow-null="true"/>
+      <arg name="layer" type="uint" enum="layer" summary="layer to add this surface to"/>
+      <arg name="namespace" type="string" summary="namespace for the layer surface"/>
+    </request>
+
+    <enum name="error">
+      <entry name="role" value="0" summary="wl_surface has another role"/>
+      <entry name="invalid_layer" value="1" summary="layer value is invalid"/>
+      <entry name="already_constructed" value="2" summary="wl_surface has a buffer attached or committed"/>
+    </enum>
+
+    <enum name="layer">
+      <description summary="available layers for surfaces">
+        These values indicate which layers a surface can be rendered in. They
+        are ordered by z depth, bottom-most first. Traditional shell surfaces
+        will typically be rendered between the bottom and top layers.
+        Fullscreen shell surfaces are typically rendered at the top layer.
+        Multiple surfaces can share a single layer, and ordering within a
+        single layer is undefined.
+      </description>
+
+      <entry name="background" value="0"/>
+      <entry name="bottom" value="1"/>
+      <entry name="top" value="2"/>
+      <entry name="overlay" value="3"/>
+    </enum>
+
+    <!-- Version 3 additions -->
+
+    <request name="destroy" type="destructor" since="3">
+      <description summary="destroy the layer_shell object">
+        This request indicates that the client will not use the layer_shell
+        object any more. Objects that have been created through this instance
+        are not affected.
+      </description>
+    </request>
+  </interface>
+
+  <interface name="zwlr_layer_surface_v1" version="3">
+    <description summary="layer metadata interface">
+      An interface that may be implemented by a wl_surface, for surfaces that
+      are designed to be rendered as a layer of a stacked desktop-like
+      environment.
+
+      Layer surface state (layer, size, anchor, exclusive zone,
+      margin, interactivity) is double-buffered, and will be applied at the
+      time wl_surface.commit of the corresponding wl_surface is called.
+    </description>
+
+    <request name="set_size">
+      <description summary="sets the size of the surface">
+        Sets the size of the surface in surface-local coordinates. The
+        compositor will display the surface centered with respect to its
+        anchors.
+
+        If you pass 0 for either value, the compositor will assign it and
+        inform you of the assignment in the configure event. You must set your
+        anchor to opposite edges in the dimensions you omit; not doing so is a
+        protocol error. Both values are 0 by default.
+
+        Size is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="width" type="uint"/>
+      <arg name="height" type="uint"/>
+    </request>
+
+    <request name="set_anchor">
+      <description summary="configures the anchor point of the surface">
+        Requests that the compositor anchor the surface to the specified edges
+        and corners. If two orthogonal edges are specified (e.g. 'top' and
+        'left'), then the anchor point will be the intersection of the edges
+        (e.g. the top left corner of the output); otherwise the anchor point
+        will be centered on that edge, or in the center if none is specified.
+
+        Anchor is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="anchor" type="uint" enum="anchor"/>
+    </request>
+
+    <request name="set_exclusive_zone">
+      <description summary="configures the exclusive geometry of this surface">
+        Requests that the compositor avoids occluding an area with other
+        surfaces. The compositor's use of this information is
+        implementation-dependent - do not assume that this region will not
+        actually be occluded.
+
+        A positive value is only meaningful if the surface is anchored to one
+        edge or an edge and both perpendicular edges. If the surface is not
+        anchored, anchored to only two perpendicular edges (a corner), anchored
+        to only two parallel edges or anchored to all edges, a positive value
+        will be treated the same as zero.
+
+        A positive zone is the distance from the edge in surface-local
+        coordinates to consider exclusive.
+
+        Surfaces that do not wish to have an exclusive zone may instead specify
+        how they should interact with surfaces that do. If set to zero, the
+        surface indicates that it would like to be moved to avoid occluding
+        surfaces with a positive exclusive zone. If set to -1, the surface
+        indicates that it would not like to be moved to accommodate for other
+        surfaces, and the compositor should extend it all the way to the edges
+        it is anchored to.
+
+        For example, a panel might set its exclusive zone to 10, so that
+        maximized shell surfaces are not shown on top of it. A notification
+        might set its exclusive zone to 0, so that it is moved to avoid
+        occluding the panel, but shell surfaces are shown underneath it. A
+        wallpaper or lock screen might set their exclusive zone to -1, so that
+        they stretch below or over the panel.
+
+        The default value is 0.
+
+        Exclusive zone is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="zone" type="int"/>
+    </request>
+
+    <request name="set_margin">
+      <description summary="sets a margin from the anchor point">
+        Requests that the surface be placed some distance away from the anchor
+        point on the output, in surface-local coordinates. Setting this value
+        for edges you are not anchored to has no effect.
+
+        The exclusive zone includes the margin.
+
+        Margin is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="top" type="int"/>
+      <arg name="right" type="int"/>
+      <arg name="bottom" type="int"/>
+      <arg name="left" type="int"/>
+    </request>
+
+    <request name="set_keyboard_interactivity">
+      <description summary="requests keyboard events">
+        Set to 1 to request that the seat send keyboard events to this layer
+        surface. For layers below the shell surface layer, the seat will use
+        normal focus semantics. For layers above the shell surface layers, the
+        seat will always give exclusive keyboard focus to the top-most layer
+        which has keyboard interactivity set to true.
+
+        Layer surfaces receive pointer, touch, and tablet events normally. If
+        you do not want to receive them, set the input region on your surface
+        to an empty region.
+
+        Events is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="keyboard_interactivity" type="uint"/>
+    </request>
+
+    <request name="get_popup">
+      <description summary="assign this layer_surface as an xdg_popup parent">
+        This assigns an xdg_popup's parent to this layer_surface.  This popup
+        should have been created via xdg_surface::get_popup with the parent set
+        to NULL, and this request must be invoked before committing the popup's
+        initial state.
+
+        See the documentation of xdg_popup for more details about what an
+        xdg_popup is and how it is used.
+      </description>
+      <arg name="popup" type="object" interface="xdg_popup"/>
+    </request>
+
+    <request name="ack_configure">
+      <description summary="ack a configure event">
+        When a configure event is received, if a client commits the
+        surface in response to the configure event, then the client
+        must make an ack_configure request sometime before the commit
+        request, passing along the serial of the configure event.
+
+        If the client receives multiple configure events before it
+        can respond to one, it only has to ack the last configure event.
+
+        A client is not required to commit immediately after sending
+        an ack_configure request - it may even ack_configure several times
+        before its next surface commit.
+
+        A client may send multiple ack_configure requests before committing, but
+        only the last request sent before a commit indicates which configure
+        event the client really is responding to.
+      </description>
+      <arg name="serial" type="uint" summary="the serial from the configure event"/>
+    </request>
+
+    <request name="destroy" type="destructor">
+      <description summary="destroy the layer_surface">
+        This request destroys the layer surface.
+      </description>
+    </request>
+
+    <event name="configure">
+      <description summary="suggest a surface change">
+        The configure event asks the client to resize its surface.
+
+        Clients should arrange their surface for the new states, and then send
+        an ack_configure request with the serial sent in this configure event at
+        some point before committing the new surface.
+
+        The client is free to dismiss all but the last configure event it
+        received.
+
+        The width and height arguments specify the size of the window in
+        surface-local coordinates.
+
+        The size is a hint, in the sense that the client is free to ignore it if
+        it doesn't resize, pick a smaller size (to satisfy aspect ratio or
+        resize in steps of NxM pixels). If the client picks a smaller size and
+        is anchored to two opposite anchors (e.g. 'top' and 'bottom'), the
+        surface will be centered on this axis.
+
+        If the width or height arguments are zero, it means the client should
+        decide its own window dimension.
+      </description>
+      <arg name="serial" type="uint"/>
+      <arg name="width" type="uint"/>
+      <arg name="height" type="uint"/>
+    </event>
+
+    <event name="closed">
+      <description summary="surface should be closed">
+        The closed event is sent by the compositor when the surface will no
+        longer be shown. The output may have been destroyed or the user may
+        have asked for it to be removed. Further changes to the surface will be
+        ignored. The client should destroy the resource after receiving this
+        event, and create a new surface if they so choose.
+      </description>
+    </event>
+
+    <enum name="error">
+      <entry name="invalid_surface_state" value="0" summary="provided surface state is invalid"/>
+      <entry name="invalid_size" value="1" summary="size is invalid"/>
+      <entry name="invalid_anchor" value="2" summary="anchor bitfield is invalid"/>
+    </enum>
+
+    <enum name="anchor" bitfield="true">
+      <entry name="top" value="1" summary="the top edge of the anchor rectangle"/>
+      <entry name="bottom" value="2" summary="the bottom edge of the anchor rectangle"/>
+      <entry name="left" value="4" summary="the left edge of the anchor rectangle"/>
+      <entry name="right" value="8" summary="the right edge of the anchor rectangle"/>
+    </enum>
+
+    <!-- Version 2 additions -->
+
+    <request name="set_layer" since="2">
+      <description summary="change the layer of the surface">
+        Change the layer that the surface is rendered on.
+
+        Layer is double-buffered, see wl_surface.commit.
+      </description>
+      <arg name="layer" type="uint" enum="zwlr_layer_shell_v1.layer" summary="layer to move this surface to"/>
+    </request>
+  </interface>
+</protocol>