Merge updates from guidocella

Thanks so much for helping to keep the project running while life was
crazy!

1 files changed, 435 insertions, 240 deletions

diff --git a/dwl.c b/dwl.c
index 1ffae9c..336c939 100644
--- a/dwl.c
+++ b/dwl.c
@@ -16,21 +16,25 @@
 #include <wlr/render/wlr_renderer.h>
 #include <wlr/types/wlr_compositor.h>
 #include <wlr/types/wlr_cursor.h>
+#include <wlr/types/wlr_data_control_v1.h>
 #include <wlr/types/wlr_data_device.h>
 #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_idle.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>
 #include <wlr/types/wlr_output_layout.h>
+#include <wlr/types/wlr_output_management_v1.h>
 #include <wlr/types/wlr_pointer.h>
 #include <wlr/types/wlr_primary_selection.h>
 #include <wlr/types/wlr_primary_selection_v1.h>
 #include <wlr/types/wlr_screencopy_v1.h>
 #include <wlr/types/wlr_seat.h>
 #include <wlr/types/wlr_viewporter.h>
+#include <wlr/types/wlr_virtual_keyboard_v1.h>
 #include <wlr/types/wlr_xcursor_manager.h>
 #include <wlr/types/wlr_xdg_decoration_v1.h>
 #include <wlr/types/wlr_xdg_output_v1.h>
@@ -95,6 +99,7 @@ typedef struct {
 	} surface;
 #ifdef XWAYLAND
 	struct wl_listener activate;
+	struct wl_listener configure;
 #endif
 	struct wl_listener commit;
 	struct wl_listener map;
@@ -171,6 +176,7 @@ struct Monitor {
 	double mfact;
 	int nmaster;
 	Client *fullscreenclient;
+	int position;
 };
 
 typedef struct {
@@ -206,7 +212,7 @@ static void applyexclusive(struct wlr_box *usable_area, uint32_t anchor,
 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);
+		struct wlr_box *usable_area, int exclusive);
 static void arrangelayers(Monitor *m);
 static void axisnotify(struct wl_listener *listener, void *data);
 static void buttonpress(struct wl_listener *listener, void *data);
@@ -214,6 +220,7 @@ 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 closemon(Monitor *m);
 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);
@@ -227,7 +234,7 @@ 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);
-static void focusclient(Client *old, Client *c, int lift);
+static void focusclient(Client *c, int lift);
 static void focusmon(const Arg *arg);
 static void focusstack(const Arg *arg);
 static void fullscreennotify(struct wl_listener *listener, void *data);
@@ -240,13 +247,16 @@ 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 mapnotify(struct wl_listener *listener, void *data);
 static void maximizeclient(Client *c);
 static void monocle(Monitor *m);
 static void motionabsolute(struct wl_listener *listener, void *data);
 static void motionnotify(uint32_t time);
 static void motionrelative(struct wl_listener *listener, void *data);
 static void moveresize(const Arg *arg);
+static void outputmgrapply(struct wl_listener *listener, void *data);
+static void outputmgrapplyortest(struct wlr_output_configuration_v1 *config, int test);
+static void outputmgrtest(struct wl_listener *listener, void *data);
 static void pointerfocus(Client *c, struct wlr_surface *surface,
 		double sx, double sy, uint32_t time);
 static void quit(const Arg *arg);
@@ -268,7 +278,6 @@ 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);
@@ -282,6 +291,7 @@ 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 void virtualkeyboard(struct wl_listener *listener, void *data);
 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);
@@ -300,8 +310,11 @@ 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_idle *idle;
 static struct wlr_layer_shell_v1 *layer_shell;
 static struct wlr_xdg_decoration_manager_v1 *xdeco_mgr;
+static struct wlr_output_manager_v1 *output_mgr;
+static struct wlr_virtual_keyboard_manager_v1 *virtual_keyboard_mgr;
 
 static struct wlr_cursor *cursor;
 static struct wlr_xcursor_manager *cursor_mgr;
@@ -328,16 +341,20 @@ static struct wl_listener cursor_frame = {.notify = cursorframe};
 static struct wl_listener cursor_motion = {.notify = motionrelative};
 static struct wl_listener cursor_motion_absolute = {.notify = motionabsolute};
 static struct wl_listener new_input = {.notify = inputdevice};
+static struct wl_listener new_virtual_keyboard = {.notify = virtualkeyboard};
 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 output_mgr_apply = {.notify = outputmgrapply};
+static struct wl_listener output_mgr_test = {.notify = outputmgrtest};
 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};
 
 #ifdef XWAYLAND
 static void activatex11(struct wl_listener *listener, void *data);
+static void configurex11(struct wl_listener *listener, void *data);
 static void createnotifyx11(struct wl_listener *listener, void *data);
 static Atom getatom(xcb_connection_t *xc, const char *name);
 static void renderindependents(struct wlr_output *output, struct timespec *now);
@@ -379,53 +396,61 @@ 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) {
+	if (exclusive <= 0)
+		return;
+
 	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;
+	} edges[] = {
+		// Top
+		{
+			.singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP,
+			.anchor_triplet =
+				ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
+				ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
+				ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP,
+			.positive_axis = &usable_area->y,
+			.negative_axis = &usable_area->height,
+			.margin = margin_top,
+		},
+		// Bottom
+		{
+			.singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
+			.anchor_triplet =
+				ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
+				ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
+				ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
+			.positive_axis = NULL,
+			.negative_axis = &usable_area->height,
+			.margin = margin_bottom,
+		},
+		// Left
+		{
+			.singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT,
+			.anchor_triplet =
+				ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT |
+				ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
+				ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
+			.positive_axis = &usable_area->x,
+			.negative_axis = &usable_area->width,
+			.margin = margin_left,
+		},
+		// Right
+		{
+			.singular_anchor = ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT,
+			.anchor_triplet =
+				ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT |
+				ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP |
+				ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM,
+			.positive_axis = NULL,
+			.negative_axis = &usable_area->width,
+			.margin = margin_right,
+		},
+	};
 
 	for (size_t i = 0; i < LENGTH(edges); ++i) {
 		if ((anchor == edges[i].singular_anchor || anchor == edges[i].anchor_triplet)
@@ -442,13 +467,8 @@ applyexclusive(struct wlr_box *usable_area,
 void
 applyrules(Client *c)
 {
-	const char *appid, *title;
-	unsigned int i, newtags = 0;
-	const Rule *r;
-	Monitor *mon = selmon, *m;
-
 	/* rule matching */
-	c->isfloating = 0;
+	const char *appid, *title;
 #ifdef XWAYLAND
 	if (c->type != XDGShell) {
 		updatewindowtype(c);
@@ -465,6 +485,9 @@ applyrules(Client *c)
 	if (!title)
 		title = broken;
 
+	unsigned int i, newtags = 0;
+	const Rule *r;
+	Monitor *mon = selmon, *m;
 	for (r = rules; r < END(rules); r++) {
 		if ((!r->title || strstr(title, r->title))
 				&& (!r->id || strstr(appid, r->id))) {
@@ -486,11 +509,11 @@ arrange(Monitor *m)
 		m->lt[m->sellt]->arrange(m);
 	else if (m->fullscreenclient)
 		maximizeclient(m->fullscreenclient);
-	/* XXX recheck pointer focus here... or in resize()? */
+	/* TODO recheck pointer focus here... or in resize()? */
 }
 
 void
-arrangelayer(Monitor *m, struct wl_list *list, struct wlr_box *usable_area, bool exclusive)
+arrangelayer(Monitor *m, struct wl_list *list, struct wlr_box *usable_area, int exclusive)
 {
 	LayerSurface *layersurface;
 	struct wlr_box full_area = m->m;
@@ -498,22 +521,20 @@ arrangelayer(Monitor *m, struct wl_list *list, struct wlr_box *usable_area, bool
 	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;
+		struct wlr_box bounds = state->exclusive_zone == -1 ?
+			full_area : *usable_area;
 
 		// Horizontal axis
+		const uint32_t both_horiz = ZWLR_LAYER_SURFACE_V1_ANCHOR_LEFT
+			| ZWLR_LAYER_SURFACE_V1_ANCHOR_RIGHT;
 		if ((state->anchor & both_horiz) && box.width == 0) {
 			box.x = bounds.x;
 			box.width = bounds.width;
@@ -525,6 +546,8 @@ arrangelayer(Monitor *m, struct wl_list *list, struct wlr_box *usable_area, bool
 			box.x = bounds.x + ((bounds.width / 2) - (box.width / 2));
 		}
 		// Vertical axis
+		const uint32_t both_vert = ZWLR_LAYER_SURFACE_V1_ANCHOR_TOP
+			| ZWLR_LAYER_SURFACE_V1_ANCHOR_BOTTOM;
 		if ((state->anchor & both_vert) && box.height == 0) {
 			box.y = bounds.y;
 			box.height = bounds.height;
@@ -569,23 +592,16 @@ 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);
+			&usable_area, 1);
 	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
-			&usable_area, true);
+			&usable_area, 1);
 	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
-			&usable_area, true);
+			&usable_area, 1);
 	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
-			&usable_area, true);
+			&usable_area, 1);
 
 	if (memcmp(&usable_area, &m->w, sizeof(struct wlr_box))) {
 		m->w = usable_area;
@@ -594,20 +610,29 @@ arrangelayers(Monitor *m)
 
 	// Arrange non-exlusive surfaces from top->bottom
 	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
-			&usable_area, false);
+			&usable_area, 0);
 	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_TOP],
-			&usable_area, false);
+			&usable_area, 0);
 	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BOTTOM],
-			&usable_area, false);
+			&usable_area, 0);
 	arrangelayer(m, &m->layers[ZWLR_LAYER_SHELL_V1_LAYER_BACKGROUND],
-			&usable_area, false);
+			&usable_area, 0);
 
 	// Find topmost keyboard interactive layer, if such a layer exists
+	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);
 	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) {
+				// Deactivate the focused client.
+				focusclient(NULL, 0);
 				wlr_seat_keyboard_notify_enter(seat, layersurface->layer_surface->surface,
 						kb->keycodes, kb->num_keycodes, &kb->modifiers);
 				return;
@@ -622,6 +647,7 @@ axisnotify(struct wl_listener *listener, void *data)
 	/* This event is forwarded by the cursor when a pointer emits an axis event,
 	 * for example when you move the scroll wheel. */
 	struct wlr_event_pointer_axis *event = data;
+	wlr_idle_notify_activity(idle, seat);
 	/* Notify the client with pointer focus of the axis event. */
 	wlr_seat_pointer_notify_axis(seat,
 			event->time_msec, event->orientation, event->delta,
@@ -632,19 +658,19 @@ void
 buttonpress(struct wl_listener *listener, void *data)
 {
 	struct wlr_event_pointer_button *event = data;
-	struct wlr_keyboard *keyboard;
-	uint32_t mods;
-	Client *c;
-	const Button *b;
+
+	wlr_idle_notify_activity(idle, seat);
 
 	switch (event->state) {
 	case WLR_BUTTON_PRESSED:;
 		/* Change focus if the button was _pressed_ over a client */
+		Client *c;
 		if ((c = xytoclient(cursor->x, cursor->y)))
-			focusclient(selclient(), c, 1);
+			focusclient(c, 1);
 
-		keyboard = wlr_seat_get_keyboard(seat);
-		mods = wlr_keyboard_get_modifiers(keyboard);
+		struct wlr_keyboard* keyboard = wlr_seat_get_keyboard(seat);
+		uint32_t mods = wlr_keyboard_get_modifiers(keyboard);
+		const Button *b;
 		for (b = buttons; b < END(buttons); b++) {
 			if (CLEANMASK(mods) == CLEANMASK(b->mod) &&
 					event->button == b->button && b->func) {
@@ -655,7 +681,7 @@ buttonpress(struct wl_listener *listener, void *data)
 		break;
 	case WLR_BUTTON_RELEASED:
 		/* If you released any buttons, we exit interactive move/resize mode. */
-		/* XXX should reset to the pointer focus's current setcursor */
+		/* TODO should reset to the pointer focus's current setcursor */
 		if (cursor_mode != CurNormal) {
 			wlr_xcursor_manager_set_cursor_image(cursor_mgr,
 					"left_ptr", cursor);
@@ -699,6 +725,9 @@ cleanupkeyboard(struct wl_listener *listener, void *data)
 	struct wlr_input_device *device = data;
 	Keyboard *kb = device->data;
 
+	wl_list_remove(&kb->link);
+	wl_list_remove(&kb->modifiers.link);
+	wl_list_remove(&kb->key.link);
 	wl_list_remove(&kb->destroy.link);
 	free(kb);
 }
@@ -710,9 +739,33 @@ cleanupmon(struct wl_listener *listener, void *data)
 	Monitor *m = wlr_output->data;
 
 	wl_list_remove(&m->destroy.link);
+	wl_list_remove(&m->frame.link);
+	wl_list_remove(&m->link);
+	wlr_output_layout_remove(output_layout, m->wlr_output);
+	updatemons();
+
+	int nmons = wl_list_length(&mons), i = 0;
+	do // don't switch to disabled mons
+		selmon = wl_container_of(mons.prev, selmon, link);
+	while (!selmon->wlr_output->enabled && i++ < nmons);
+	focusclient(focustop(selmon), 1);
+	closemon(m);
 	free(m);
+}
 
-	updatemons();
+void
+closemon(Monitor *m)
+{
+	// move closed monitor's clients to the focused one
+	Client *c;
+
+	wl_list_for_each(c, &clients, link) {
+		if (c->isfloating && c->geom.x > m->m.width)
+			resize(c, c->geom.x - m->w.width, c->geom.y,
+				c->geom.width, c->geom.height, 0);
+		if (c->mon == m)
+			setmon(c, selmon, c->tags);
+	}
 }
 
 void
@@ -721,12 +774,11 @@ 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;
+	Monitor *m = wlr_output->data;
 	arrangelayers(m);
 
 	if (layersurface->layer != wlr_layer_surface->current.layer) {
@@ -750,16 +802,12 @@ commitnotify(struct wl_listener *listener, void *data)
 void
 createkeyboard(struct wlr_input_device *device)
 {
-	struct xkb_context *context;
-	struct xkb_keymap *keymap;
-	Keyboard *kb;
-
-	kb = device->data = calloc(1, sizeof(*kb));
+	Keyboard *kb = device->data = calloc(1, sizeof(*kb));
 	kb->device = device;
 
 	/* Prepare an XKB keymap and assign it to the keyboard. */
-	context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
-	keymap = xkb_map_new_from_names(context, &xkb_rules,
+	struct xkb_context *context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
+	struct xkb_keymap *keymap = xkb_map_new_from_names(context, &xkb_rules,
 		XKB_KEYMAP_COMPILE_NO_FLAGS);
 
 	wlr_keyboard_set_keymap(device->keyboard, keymap);
@@ -787,9 +835,6 @@ createmon(struct wl_listener *listener, void *data)
 	/* This event is raised by the backend when a new output (aka a display or
 	 * monitor) becomes available. */
 	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
@@ -798,49 +843,77 @@ createmon(struct wl_listener *listener, void *data)
 	wlr_output_set_mode(wlr_output, wlr_output_preferred_mode(wlr_output));
 
 	/* Allocates and configures monitor state using configured rules */
-	m = wlr_output->data = calloc(1, sizeof(*m));
+	Monitor *m = wlr_output->data = calloc(1, sizeof(*m));
 	m->wlr_output = wlr_output;
 	m->tagset[0] = m->tagset[1] = 1;
-	for (r = monrules; r < END(monrules); r++) {
+	m->position = -1;
+	for (const MonitorRule *r = monrules; r < END(monrules); r++) {
 		if (!r->name || strstr(wlr_output->name, r->name)) {
 			m->mfact = r->mfact;
 			m->nmaster = r->nmaster;
 			wlr_output_set_scale(wlr_output, r->scale);
 			wlr_xcursor_manager_load(cursor_mgr, r->scale);
-			m->lt[0] = m->lt[1] = r->lt;
+			m->lt[0] = r->lt;
+			m->lt[1] = &layouts[LENGTH(layouts) > 1 && r->lt != &layouts[1]];
 			wlr_output_set_transform(wlr_output, r->rr);
+			m->position = r - monrules;
 			break;
 		}
 	}
+	wlr_output_enable_adaptive_sync(wlr_output, 1);
 	/* Set up event listeners */
 	m->frame.notify = rendermon;
 	wl_signal_add(&wlr_output->events.frame, &m->frame);
 	m->destroy.notify = cleanupmon;
 	wl_signal_add(&wlr_output->events.destroy, &m->destroy);
 
-	wl_list_insert(&mons, &m->link);
+	Monitor *moni, *insertmon = NULL;
+	int x = 0;
+	wl_list_for_each(moni, &mons, link)
+		if (m->position > moni->position)
+			insertmon = moni;
+	if (insertmon) {
+		x = insertmon->w.x + insertmon->w.width;
+		wl_list_insert(&insertmon->link, &m->link);
+	} else {
+		wl_list_insert(&mons, &m->link);
+	}
 
 	wlr_output_enable(wlr_output, 1);
 	if (!wlr_output_commit(wlr_output))
 		return;
 
-	/* Adds this to the output layout. The add_auto function arranges outputs
-	 * from left-to-right in the order they appear. A more sophisticated
-	 * compositor would let the user configure the arrangement of outputs in the
-	 * layout.
+	/* Adds this to the output layout in the order it was configured in.
 	 *
 	 * The output layout utility automatically adds a wl_output global to the
 	 * display, which Wayland clients can see to find out information about the
 	 * output (such as DPI, scale factor, manufacturer, etc).
 	 */
-	wlr_output_layout_add_auto(output_layout, wlr_output);
+	wlr_output_layout_add(output_layout, wlr_output, x, 0);
+	wl_list_for_each_reverse(moni, &mons, link) {
+		/* All monitors to the right of the new one must be moved */
+		if (moni == m)
+			break;
+		wlr_output_layout_move(output_layout, moni->wlr_output, moni->w.x + m->wlr_output->width, 0);
+	}
 	sgeom = *wlr_output_layout_get_box(output_layout, NULL);
 
+	size_t nlayers = LENGTH(m->layers);
 	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();
+	wl_list_for_each(m, &mons, link) {
+		/* The first monitor in the list is the most recently added */
+		Client *c;
+		wl_list_for_each(c, &clients, link) {
+			if (c->isfloating)
+				resize(c, c->geom.x + m->w.width, c->geom.y,
+						c->geom.width, c->geom.height, 0);
+		}
+		return;
+	}
 }
 
 void
@@ -853,6 +926,9 @@ createnotify(struct wl_listener *listener, void *data)
 
 	if (xdg_surface->role != WLR_XDG_SURFACE_ROLE_TOPLEVEL)
 		return;
+	wl_list_for_each(c, &clients, link)
+		if (c->isfullscreen && VISIBLEON(c, c->mon))
+			setfullscreen(c, 0);
 
 	/* Allocate a Client for this surface */
 	c = xdg_surface->data = calloc(1, sizeof(*c));
@@ -866,7 +942,7 @@ createnotify(struct wl_listener *listener, void *data)
 	/* Listen to the various events it can emit */
 	c->commit.notify = commitnotify;
 	wl_signal_add(&xdg_surface->surface->events.commit, &c->commit);
-	c->map.notify = maprequest;
+	c->map.notify = mapnotify;
 	wl_signal_add(&xdg_surface->events.map, &c->map);
 	c->unmap.notify = unmapnotify;
 	wl_signal_add(&xdg_surface->events.unmap, &c->unmap);
@@ -882,15 +958,12 @@ 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 *layersurface = calloc(1, sizeof(LayerSurface));
 
 	layersurface->surface_commit.notify = commitlayersurfacenotify;
 	wl_signal_add(&wlr_layer_surface->surface->events.commit,
@@ -905,14 +978,14 @@ createlayersurface(struct wl_listener *listener, void *data)
 	layersurface->layer_surface = wlr_layer_surface;
 	wlr_layer_surface->data = layersurface;
 
-	m = wlr_layer_surface->output->data;
+	Monitor *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;
+	struct wlr_layer_surface_v1_state old_state = wlr_layer_surface->current;
 	wlr_layer_surface->current = wlr_layer_surface->client_pending;
 	arrangelayers(m);
 	wlr_layer_surface->current = old_state;
@@ -968,7 +1041,6 @@ 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);
@@ -978,7 +1050,7 @@ destroylayersurfacenotify(struct wl_listener *listener, void *data)
 	wl_list_remove(&layersurface->unmap.link);
 	wl_list_remove(&layersurface->surface_commit.link);
 	if (layersurface->layer_surface->output) {
-		m = layersurface->layer_surface->output->data;
+		Monitor *m = layersurface->layer_surface->output->data;
 		if (m)
 			arrangelayers(m);
 		layersurface->layer_surface->output = NULL;
@@ -1082,31 +1154,53 @@ dirtomon(int dir)
 }
 
 void
-focusclient(Client *old, Client *c, int lift)
+focusclient(Client *c, int lift)
 {
-	struct wlr_keyboard *kb = wlr_seat_get_keyboard(seat);
-
 	/* Raise client in stacking order if requested */
 	if (c && lift) {
 		wl_list_remove(&c->slink);
 		wl_list_insert(&stack, &c->slink);
 	}
 
-	/* Nothing else to do? */
-	if (c == old)
+	struct wlr_surface *old = seat->keyboard_state.focused_surface;
+
+	if (c && WLR_SURFACE(c) == old)
 		return;
 
+	/* Put the new client atop the focus stack and select its monitor */
+	if (c) {
+		wl_list_remove(&c->flink);
+		wl_list_insert(&fstack, &c->flink);
+		selmon = c->mon;
+	}
+
 	/* Deactivate old client if focus is changing */
-	if (c != old && old) {
+	if (old && (!c || WLR_SURFACE(c) != old)) {
+		if (wlr_surface_is_xdg_surface(old))
+			wlr_xdg_toplevel_set_activated(
+					wlr_xdg_surface_from_wlr_surface(old), 0);
 #ifdef XWAYLAND
-		if (old->type != XDGShell)
-			wlr_xwayland_surface_activate(old->surface.xwayland, 0);
-		else
+		else if (wlr_surface_is_xwayland_surface(old))
+			wlr_xwayland_surface_activate(
+					wlr_xwayland_surface_from_wlr_surface(old), 0);
 #endif
-			wlr_xdg_toplevel_set_activated(old->surface.xdg, 0);
+		/* If an overlay is focused, don't focus or activate the client,
+		 * but only update its position in fstack to render its border with focuscolor
+		 * and focus it after the overlay is closed.
+		 * It's probably pointless to check if old is a layer surface
+		 * since it can't be anything else at this point. */
+		else if (wlr_surface_is_layer_surface(old)) {
+			struct wlr_layer_surface_v1 *wlr_layer_surface =
+				wlr_layer_surface_v1_from_wlr_surface(old);
+
+			if (wlr_layer_surface->mapped && (
+						wlr_layer_surface->current.layer == ZWLR_LAYER_SHELL_V1_LAYER_TOP ||
+						wlr_layer_surface->current.layer == ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY
+						))
+				return;
+		}
 	}
 
-	/* Update wlroots' keyboard focus */
 	if (!c) {
 		/* With no client, all we have left is to clear focus */
 		wlr_seat_keyboard_notify_clear_focus(seat);
@@ -1114,14 +1208,9 @@ focusclient(Client *old, Client *c, int lift)
 	}
 
 	/* Have a client, so focus its top-level wlr_surface */
-	if (shouldfocusclients(c->mon))
-		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);
-	wl_list_insert(&fstack, &c->flink);
-	selmon = c->mon;
+	struct wlr_keyboard *kb = wlr_seat_get_keyboard(seat);
+	wlr_seat_keyboard_notify_enter(seat, WLR_SURFACE(c),
+			kb->keycodes, kb->num_keycodes, &kb->modifiers);
 
 	/* Activate the new client */
 #ifdef XWAYLAND
@@ -1135,10 +1224,10 @@ focusclient(Client *old, Client *c, int lift)
 void
 focusmon(const Arg *arg)
 {
-	Client *sel = selclient();
-
-	selmon = dirtomon(arg->i);
-	focusclient(sel, focustop(selmon), 1);
+	do
+		selmon = dirtomon(arg->i);
+	while (!selmon->wlr_output->enabled);
+	focusclient(focustop(selmon), 1);
 }
 
 void
@@ -1164,7 +1253,7 @@ focusstack(const Arg *arg)
 		}
 	}
 	/* If only one client is visible on selmon, then c == sel */
-	focusclient(sel, c, 1);
+	focusclient(c, 1);
 }
 
 Client *
@@ -1198,7 +1287,6 @@ inputdevice(struct wl_listener *listener, void *data)
 	/* This event is raised by the backend when a new input device becomes
 	 * available. */
 	struct wlr_input_device *device = data;
-	uint32_t caps;
 	switch (device->type) {
 	case WLR_INPUT_DEVICE_KEYBOARD:
 		createkeyboard(device);
@@ -1207,14 +1295,14 @@ inputdevice(struct wl_listener *listener, void *data)
 		createpointer(device);
 		break;
 	default:
-		/* XXX handle other input device types */
+		/* TODO handle other input device types */
 		break;
 	}
 	/* We need to let the wlr_seat know what our capabilities are, which is
 	 * communiciated to the client. In dwl we always have a cursor, even if
 	 * there are no pointer devices, so we always include that capability. */
-	/* XXX do we actually require a cursor? */
-	caps = WL_SEAT_CAPABILITY_POINTER;
+	/* TODO do we actually require a cursor? */
+	uint32_t caps = WL_SEAT_CAPABILITY_POINTER;
 	if (!wl_list_empty(&keyboards))
 		caps |= WL_SEAT_CAPABILITY_KEYBOARD;
 	wlr_seat_set_capabilities(seat, caps);
@@ -1243,10 +1331,10 @@ keybinding(uint32_t mods, xkb_keysym_t sym)
 void
 keypress(struct wl_listener *listener, void *data)
 {
+	int i;
 	/* This event is raised when a key is pressed or released. */
 	Keyboard *kb = wl_container_of(listener, kb, key);
 	struct wlr_event_keyboard_key *event = data;
-	int i;
 
 	/* Translate libinput keycode -> xkbcommon */
 	uint32_t keycode = event->keycode + 8;
@@ -1257,6 +1345,9 @@ keypress(struct wl_listener *listener, void *data)
 
 	int handled = 0;
 	uint32_t mods = wlr_keyboard_get_modifiers(kb->device->keyboard);
+
+	wlr_idle_notify_activity(idle, seat);
+
 	/* On _press_, attempt to process a compositor keybinding. */
 	if (event->state == WL_KEYBOARD_KEY_STATE_PRESSED)
 		for (i = 0; i < nsyms; i++)
@@ -1312,7 +1403,7 @@ maplayersurfacenotify(struct wl_listener *listener, void *data)
 }
 
 void
-maprequest(struct wl_listener *listener, void *data)
+mapnotify(struct wl_listener *listener, void *data)
 {
 	/* Called when the surface is mapped, or ready to display on-screen. */
 	Client *c = wl_container_of(listener, c, map), *oldfocus = selclient();
@@ -1350,7 +1441,7 @@ maprequest(struct wl_listener *listener, void *data)
 	if (c->mon->fullscreenclient && c->mon->fullscreenclient == oldfocus
 			&& !c->isfloating && c->mon->lt[c->mon->sellt]->arrange) {
 		maximizeclient(c->mon->fullscreenclient);
-		focusclient(c, c->mon->fullscreenclient, 1);
+		focusclient(c->mon->fullscreenclient, 1);
 		/* give the focus back the fullscreen client on that monitor if exists,
 		 * is focused and the new client isn't floating */
 	}
@@ -1388,18 +1479,14 @@ motionabsolute(struct wl_listener *listener, void *data)
 void
 motionnotify(uint32_t time)
 {
-	double sx = 0, sy = 0;
-	struct wlr_surface *surface = NULL;
-	Client *c = NULL;
-	struct timespec now;
-	if (!time) {
-		clock_gettime(CLOCK_MONOTONIC, &now);
-		time = now.tv_sec * 1000 + now.tv_nsec / 1000000;
-	}
+	// time is 0 in internal calls meant to restore pointer focus.
+	if (time) {
+		wlr_idle_notify_activity(idle, seat);
 
-	/* Update selmon (even while dragging a window) */
-	if (sloppyfocus)
-		selmon = xytomon(cursor->x, cursor->y);
+		/* Update selmon (even while dragging a window) */
+		if (sloppyfocus)
+			selmon = xytomon(cursor->x, cursor->y);
+	}
 
 	/* If we are currently grabbing the mouse, handle and return */
 	if (cursor_mode == CurMove) {
@@ -1414,6 +1501,9 @@ motionnotify(uint32_t time)
 		return;
 	}
 
+	struct wlr_surface *surface = NULL;
+	double sx = 0, sy = 0;
+	Client *c = NULL;
 	if ((surface = xytolayersurface(&selmon->layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],
 					cursor->x, cursor->y, &sx, &sy)))
 		;
@@ -1452,7 +1542,7 @@ motionnotify(uint32_t time)
 	/* 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. */
-	if (!surface)
+	if (!surface && time)
 		wlr_xcursor_manager_set_cursor_image(cursor_mgr,
 				"left_ptr", cursor);
 
@@ -1503,6 +1593,72 @@ moveresize(const Arg *arg)
 }
 
 void
+outputmgrapply(struct wl_listener *listener, void *data)
+{
+	struct wlr_output_configuration_v1 *config = data;
+	outputmgrapplyortest(config, 0);
+}
+
+void
+outputmgrapplyortest(struct wlr_output_configuration_v1 *config, int test)
+{
+	struct wlr_output_configuration_head_v1 *config_head;
+	int ok = 1;
+
+	wl_list_for_each(config_head, &config->heads, link) {
+		struct wlr_output *wlr_output = config_head->state.output;
+
+		wlr_output_enable(wlr_output, config_head->state.enabled);
+		if (config_head->state.enabled) {
+			if (config_head->state.mode)
+				wlr_output_set_mode(wlr_output, config_head->state.mode);
+			else
+				wlr_output_set_custom_mode(wlr_output,
+						config_head->state.custom_mode.width,
+						config_head->state.custom_mode.height,
+						config_head->state.custom_mode.refresh);
+
+			wlr_output_layout_move(output_layout, wlr_output,
+					config_head->state.x, config_head->state.y);
+			wlr_output_set_transform(wlr_output, config_head->state.transform);
+			wlr_output_set_scale(wlr_output, config_head->state.scale);
+		} else if (wl_list_length(&mons) > 1) {
+			Monitor *m;
+			wl_list_for_each(m, &mons, link) {
+				if (m->wlr_output->name == wlr_output->name) {
+					// focus the left monitor (relative to the current focus)
+					m->wlr_output->enabled = !m->wlr_output->enabled;
+					Arg ar = {.i = -1};
+					focusmon(&ar);
+					closemon(m);
+					m->wlr_output->enabled = !m->wlr_output->enabled;
+				}
+			}
+		}
+
+		if (test) {
+			ok &= wlr_output_test(wlr_output);
+			wlr_output_rollback(wlr_output);
+		} else
+			ok &= wlr_output_commit(wlr_output);
+	}
+	if (ok) {
+		wlr_output_configuration_v1_send_succeeded(config);
+		if (!test)
+			updatemons();
+	} else
+		wlr_output_configuration_v1_send_failed(config);
+	wlr_output_configuration_v1_destroy(config);
+}
+
+void
+outputmgrtest(struct wl_listener *listener, void *data)
+{
+	struct wlr_output_configuration_v1 *config = data;
+	outputmgrapplyortest(config, 1);
+}
+
+void
 pointerfocus(Client *c, struct wlr_surface *surface, double sx, double sy,
 		uint32_t time)
 {
@@ -1516,6 +1672,13 @@ pointerfocus(Client *c, struct wlr_surface *surface, double sx, double sy,
 		return;
 	}
 
+	int internal_call = !time;
+	if (!time) {
+		struct timespec now;
+		clock_gettime(CLOCK_MONOTONIC, &now);
+		time = now.tv_sec * 1000 + now.tv_nsec / 1000000;
+	}
+
 	/* If surface is already focused, only notify of motion */
 	if (surface == seat->pointer_state.focused_surface) {
 		wlr_seat_pointer_notify_motion(seat, time, sx, sy);
@@ -1534,8 +1697,8 @@ pointerfocus(Client *c, struct wlr_surface *surface, double sx, double sy,
 		return;
 #endif
 
-	if (sloppyfocus)
-		focusclient(selclient(), c, 0);
+	if (sloppyfocus && !internal_call)
+		focusclient(c, 0);
 }
 
 void
@@ -1550,10 +1713,6 @@ render(struct wlr_surface *surface, int sx, int sy, void *data)
 	/* This function is called for every surface that needs to be rendered. */
 	struct render_data *rdata = data;
 	struct wlr_output *output = rdata->output;
-	double ox = 0, oy = 0;
-	struct wlr_box obox;
-	float matrix[9];
-	enum wl_output_transform transform;
 
 	/* We first obtain a wlr_texture, which is a GPU resource. wlroots
 	 * automatically handles negotiating these with the client. The underlying
@@ -1568,14 +1727,17 @@ render(struct wlr_surface *surface, int sx, int sy, void *data)
 	 * one next to the other, both 1080p, a client on the rightmost display might
 	 * have layout coordinates of 2000,100. We need to translate that to
 	 * output-local coordinates, or (2000 - 1920). */
+	double ox = 0, oy = 0;
 	wlr_output_layout_output_coords(output_layout, output, &ox, &oy);
 
 	/* We also have to apply the scale factor for HiDPI outputs. This is only
 	 * part of the puzzle, dwl does not fully support HiDPI. */
-	obox.x = ox + rdata->x + sx;
-	obox.y = oy + rdata->y + sy;
-	obox.width = surface->current.width;
-	obox.height = surface->current.height;
+	struct wlr_box obox = {
+		.x = ox + rdata->x + sx,
+		.y = oy + rdata->y + sy,
+		.width = surface->current.width,
+		.height = surface->current.height,
+	};
 	scalebox(&obox, output->scale);
 
 	/*
@@ -1589,7 +1751,9 @@ render(struct wlr_surface *surface, int sx, int sy, void *data)
 	 * Naturally you can do this any way you like, for example to make a 3D
 	 * compositor.
 	 */
-	transform = wlr_output_transform_invert(surface->current.transform);
+	float matrix[9];
+	enum wl_output_transform transform = wlr_output_transform_invert(
+			surface->current.transform);
 	wlr_matrix_project_box(matrix, &obox, transform, 0,
 		output->transform_matrix);
 
@@ -1662,13 +1826,14 @@ 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;
+		struct render_data rdata = {
+			.output = layersurface->layer_surface->output,
+			.when = now,
+			.x = layersurface->geo.x,
+			.y = layersurface->geo.y,
+		};
 
 		wlr_surface_for_each_surface(layersurface->layer_surface->surface,
 				render, &rdata);
@@ -1678,9 +1843,6 @@ renderlayer(struct wl_list *layer_surfaces, struct timespec *now)
 void
 rendermon(struct wl_listener *listener, void *data)
 {
-	Client *c;
-	int render = 1;
-
 	/* This function is called every time an output is ready to display a frame,
 	 * generally at the output's refresh rate (e.g. 60Hz). */
 	Monitor *m = wl_container_of(listener, m, frame);
@@ -1689,6 +1851,8 @@ rendermon(struct wl_listener *listener, void *data)
 	clock_gettime(CLOCK_MONOTONIC, &now);
 
 	/* Do not render if any XDG clients have an outstanding resize. */
+	Client *c;
+	int render = 1;
 	wl_list_for_each(c, &stack, slink) {
 		if (c->resize) {
 			wlr_surface_send_frame_done(WLR_SURFACE(c), &now);
@@ -1738,11 +1902,11 @@ resize(Client *c, int x, int y, int w, int h, int interact)
 	 * compositor, you'd wait for the client to prepare a buffer at
 	 * the new size, then commit any movement that was prepared.
 	 */
-	struct wlr_box *bbox = interact ? &sgeom : &c->mon->w;
 	c->geom.x = x;
 	c->geom.y = y;
 	c->geom.width = w;
 	c->geom.height = h;
+	struct wlr_box *bbox = interact ? &sgeom : &c->mon->w;
 	applybounds(c, bbox);
 	/* wlroots makes this a no-op if size hasn't changed */
 #ifdef XWAYLAND
@@ -1759,8 +1923,6 @@ resize(Client *c, int x, int y, int w, int h, int interact)
 void
 run(char *startup_cmd)
 {
-	pid_t startup_pid = -1;
-
 	/* Add a Unix socket to the Wayland display. */
 	const char *socket = wl_display_add_socket_auto(dpy);
 	if (!socket)
@@ -1775,7 +1937,7 @@ run(char *startup_cmd)
 	 * cursor position, and set default cursor image */
 	selmon = xytomon(cursor->x, cursor->y);
 
-	/* XXX hack to get cursor to display in its initial location (100, 100)
+	/* TODO hack to get cursor to display in its initial location (100, 100)
 	 * instead of (0, 0) and then jumping.  still may not be fully
 	 * initialized, as the image/coordinates are not transformed for the
 	 * monitor when displayed here */
@@ -1785,8 +1947,10 @@ run(char *startup_cmd)
 	/* Set the WAYLAND_DISPLAY environment variable to our socket and run the
 	 * startup command if requested. */
 	setenv("WAYLAND_DISPLAY", socket, 1);
+
+	pid_t startup_pid = -1;
 	if (startup_cmd) {
-		startup_pid = fork();
+		pid_t startup_pid = fork();
 		if (startup_pid < 0)
 			EBARF("startup: fork");
 		if (startup_pid == 0) {
@@ -1794,6 +1958,7 @@ run(char *startup_cmd)
 			EBARF("startup: execl");
 		}
 	}
+
 	/* Run the Wayland event loop. This does not return until you exit the
 	 * compositor. Starting the backend rigged up all of the necessary event
 	 * loop configuration to listen to libinput events, DRM events, generate
@@ -1830,7 +1995,7 @@ setcursor(struct wl_listener *listener, void *data)
 	/* This event is raised by the seat when a client provides a cursor image */
 	struct wlr_seat_pointer_request_set_cursor_event *event = data;
 	/* If we're "grabbing" the cursor, don't use the client's image */
-	/* XXX still need to save the provided surface to restore later */
+	/* TODO still need to save the provided surface to restore later */
 	if (cursor_mode != CurNormal)
 		return;
 	/* This can be sent by any client, so we check to make sure this one is
@@ -1857,7 +2022,7 @@ setlayout(const Arg *arg)
 		selmon->sellt ^= 1;
 	if (arg && arg->v)
 		selmon->lt[selmon->sellt] = (Layout *)arg->v;
-	/* XXX change layout symbol? */
+	/* TODO change layout symbol? */
 	arrange(selmon);
 }
 
@@ -1865,11 +2030,9 @@ setlayout(const Arg *arg)
 void
 setmfact(const Arg *arg)
 {
-	float f;
-
 	if (!arg || !selmon->lt[selmon->sellt]->arrange)
 		return;
-	f = arg->f < 1.0 ? arg->f + selmon->mfact : arg->f - 1.0;
+	float f = arg->f < 1.0 ? arg->f + selmon->mfact : arg->f - 1.0;
 	if (f < 0.1 || f > 0.9)
 		return;
 	selmon->mfact = f;
@@ -1880,13 +2043,12 @@ void
 setmon(Client *c, Monitor *m, unsigned int newtags)
 {
 	Monitor *oldmon = c->mon;
-	Client *oldsel = selclient();
 
 	if (oldmon == m)
 		return;
 	c->mon = m;
 
-	/* XXX leave/enter is not optimal but works */
+	/* TODO leave/enter is not optimal but works */
 	if (oldmon) {
 		wlr_surface_send_leave(WLR_SURFACE(c), oldmon->wlr_output);
 		arrange(oldmon);
@@ -1898,7 +2060,7 @@ setmon(Client *c, Monitor *m, unsigned int newtags)
 		c->tags = newtags ? newtags : m->tagset[m->seltags]; /* assign tags of target monitor */
 		arrange(m);
 	}
-	focusclient(oldsel, focustop(selmon), 1);
+	focusclient(focustop(selmon), 1);
 }
 
 void
@@ -1959,6 +2121,7 @@ setup(void)
 	compositor = wlr_compositor_create(dpy, drw);
 	wlr_export_dmabuf_manager_v1_create(dpy);
 	wlr_screencopy_manager_v1_create(dpy);
+	wlr_data_control_manager_v1_create(dpy);
 	wlr_data_device_manager_create(dpy);
 	wlr_gamma_control_manager_v1_create(dpy);
 	wlr_primary_selection_v1_device_manager_create(dpy);
@@ -1985,6 +2148,8 @@ setup(void)
 	wl_list_init(&stack);
 	wl_list_init(&independents);
 
+	idle = wlr_idle_create(dpy);
+
 	layer_shell = wlr_layer_shell_v1_create(dpy);
 	wl_signal_add(&layer_shell->events.new_surface, &new_layer_shell_surface);
 
@@ -2035,6 +2200,9 @@ setup(void)
 	 */
 	wl_list_init(&keyboards);
 	wl_signal_add(&backend->events.new_input, &new_input);
+	virtual_keyboard_mgr = wlr_virtual_keyboard_manager_v1_create(dpy);
+	wl_signal_add(&virtual_keyboard_mgr->events.new_virtual_keyboard,
+			&new_virtual_keyboard);
 	seat = wlr_seat_create(dpy, "seat0");
 	wl_signal_add(&seat->events.request_set_cursor,
 			&request_cursor);
@@ -2043,12 +2211,16 @@ setup(void)
 	wl_signal_add(&seat->events.request_set_primary_selection,
 			&request_set_psel);
 
+	output_mgr = wlr_output_manager_v1_create(dpy);
+	wl_signal_add(&output_mgr->events.apply, &output_mgr_apply);
+	wl_signal_add(&output_mgr->events.test, &output_mgr_test);
+
 #ifdef XWAYLAND
 	/*
 	 * Initialise the XWayland X server.
 	 * It will be started when the first X client is started.
 	 */
-	xwayland = wlr_xwayland_create(dpy, compositor, true);
+	xwayland = wlr_xwayland_create(dpy, compositor, 1);
 	if (xwayland) {
 		wl_signal_add(&xwayland->events.ready, &xwayland_ready);
 		wl_signal_add(&xwayland->events.new_surface, &new_xwayland_surface);
@@ -2067,7 +2239,7 @@ setup(void)
 					xcursor->images[0]->hotspot_x, xcursor->images[0]->hotspot_y);
 		}
 
-		setenv("DISPLAY", xwayland->display_name, true);
+		setenv("DISPLAY", xwayland->display_name, 1);
 	} else {
 		fprintf(stderr, "failed to setup XWayland X server, continuing without it\n");
 	}
@@ -2083,22 +2255,6 @@ 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)
 {
@@ -2115,7 +2271,7 @@ tag(const Arg *arg)
 	Client *sel = selclient();
 	if (sel && arg->ui & TAGMASK) {
 		sel->tags = arg->ui & TAGMASK;
-		focusclient(sel, focustop(selmon), 1);
+		focusclient(focustop(selmon), 1);
 		arrange(selmon);
 	}
 }
@@ -2177,14 +2333,13 @@ togglefloating(const Arg *arg)
 void
 toggletag(const Arg *arg)
 {
-	unsigned int newtags;
 	Client *sel = selclient();
 	if (!sel)
 		return;
-	newtags = sel->tags ^ (arg->ui & TAGMASK);
+	unsigned int newtags = sel->tags ^ (arg->ui & TAGMASK);
 	if (newtags) {
 		sel->tags = newtags;
-		focusclient(sel, focustop(selmon), 1);
+		focusclient(focustop(selmon), 1);
 		arrange(selmon);
 	}
 }
@@ -2192,12 +2347,11 @@ toggletag(const Arg *arg)
 void
 toggleview(const Arg *arg)
 {
-	Client *sel = selclient();
 	unsigned int newtagset = selmon->tagset[selmon->seltags] ^ (arg->ui & TAGMASK);
 
 	if (newtagset) {
 		selmon->tagset[selmon->seltags] = newtagset;
-		focusclient(sel, focustop(selmon), 1);
+		focusclient(focustop(selmon), 1);
 		arrange(selmon);
 	}
 }
@@ -2205,10 +2359,10 @@ toggleview(const Arg *arg)
 void
 unmaplayersurface(LayerSurface *layersurface)
 {
-	layersurface->layer_surface->mapped = false;
+	layersurface->layer_surface->mapped = 0;
 	if (layersurface->layer_surface->surface ==
 			seat->keyboard_state.focused_surface)
-		focusclient(NULL, selclient(), 1);
+		focusclient(selclient(), 1);
 	motionnotify(0);
 }
 
@@ -2237,30 +2391,50 @@ unmapnotify(struct wl_listener *listener, void *data)
 void
 updatemons()
 {
+	struct wlr_output_configuration_v1 *config =
+		wlr_output_configuration_v1_create();
 	Monitor *m;
+	sgeom = *wlr_output_layout_get_box(output_layout, NULL);
 	wl_list_for_each(m, &mons, link) {
+		struct wlr_output_configuration_head_v1 *config_head =
+			wlr_output_configuration_head_v1_create(config, m->wlr_output);
+
 		/* 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);
+
+		config_head->state.enabled = m->wlr_output->enabled;
+		config_head->state.mode = m->wlr_output->current_mode;
+		config_head->state.x = m->m.x;
+		config_head->state.y = m->m.y;
 	}
+
+	wlr_output_manager_v1_set_configuration(output_mgr, config);
 }
 
 void
 view(const Arg *arg)
 {
-	Client *sel = selclient();
 	if ((arg->ui & TAGMASK) == selmon->tagset[selmon->seltags])
 		return;
 	selmon->seltags ^= 1; /* toggle sel tagset */
 	if (arg->ui & TAGMASK)
 		selmon->tagset[selmon->seltags] = arg->ui & TAGMASK;
-	focusclient(sel, focustop(selmon), 1);
+	focusclient(focustop(selmon), 1);
 	arrange(selmon);
 }
 
+void
+virtualkeyboard(struct wl_listener *listener, void *data)
+{
+	struct wlr_virtual_keyboard_v1 *keyboard = data;
+	struct wlr_input_device *device = &keyboard->input_device;
+	createkeyboard(device);
+}
+
 Client *
 xytoclient(double x, double y)
 {
@@ -2304,7 +2478,7 @@ xytomon(double x, double y)
 void
 zoom(const Arg *arg)
 {
-	Client *c, *sel = selclient(), *oldsel = sel;
+	Client *c, *sel = selclient();
 
 	if (!sel || !selmon->lt[selmon->sellt]->arrange || sel->isfloating)
 		return;
@@ -2329,7 +2503,7 @@ zoom(const Arg *arg)
 	wl_list_remove(&sel->link);
 	wl_list_insert(&clients, &sel->link);
 
-	focusclient(oldsel, sel, 1);
+	focusclient(sel, 1);
 	arrange(selmon);
 }
 
@@ -2345,24 +2519,38 @@ activatex11(struct wl_listener *listener, void *data)
 }
 
 void
+configurex11(struct wl_listener *listener, void *data)
+{
+	Client *c = wl_container_of(listener, c, configure);
+	struct wlr_xwayland_surface_configure_event *event = data;
+	wlr_xwayland_surface_configure(c->surface.xwayland,
+			event->x, event->y, event->width, event->height);
+}
+
+void
 createnotifyx11(struct wl_listener *listener, void *data)
 {
-	struct wlr_xwayland_surface *xwayland_surface = data;
 	Client *c;
+	wl_list_for_each(c, &clients, link)
+		if (c->isfullscreen && VISIBLEON(c, c->mon))
+			setfullscreen(c, 0);
 
 	/* Allocate a Client for this surface */
+	struct wlr_xwayland_surface *xwayland_surface = data;
 	c = xwayland_surface->data = calloc(1, sizeof(*c));
 	c->surface.xwayland = xwayland_surface;
 	c->type = xwayland_surface->override_redirect ? X11Unmanaged : X11Managed;
 	c->bw = borderpx;
 
 	/* Listen to the various events it can emit */
-	c->map.notify = maprequest;
+	c->map.notify = mapnotify;
 	wl_signal_add(&xwayland_surface->events.map, &c->map);
 	c->unmap.notify = unmapnotify;
 	wl_signal_add(&xwayland_surface->events.unmap, &c->unmap);
 	c->activate.notify = activatex11;
 	wl_signal_add(&xwayland_surface->events.request_activate, &c->activate);
+	c->configure.notify = configurex11;
+	wl_signal_add(&xwayland_surface->events.request_configure, &c->configure);
 	c->destroy.notify = destroynotify;
 	wl_signal_add(&xwayland_surface->events.destroy, &c->destroy);
 
@@ -2375,10 +2563,8 @@ Atom
 getatom(xcb_connection_t *xc, const char *name)
 {
 	Atom atom = 0;
-	xcb_intern_atom_cookie_t cookie;
 	xcb_intern_atom_reply_t *reply;
-
-	cookie = xcb_intern_atom(xc, 0, strlen(name), name);
+	xcb_intern_atom_cookie_t cookie = xcb_intern_atom(xc, 0, strlen(name), name);
 	if ((reply = xcb_intern_atom_reply(xc, cookie, NULL)))
 		atom = reply->atom;
 	free(reply);
@@ -2390,23 +2576,25 @@ void
 renderindependents(struct wlr_output *output, struct timespec *now)
 {
 	Client *c;
-	struct render_data rdata;
-	struct wlr_box geom;
 
 	wl_list_for_each_reverse(c, &independents, link) {
-		geom.x = c->surface.xwayland->x;
-		geom.y = c->surface.xwayland->y;
-		geom.width = c->surface.xwayland->width;
-		geom.height = c->surface.xwayland->height;
+		struct wlr_box geom = {
+			.x = c->surface.xwayland->x,
+			.y = c->surface.xwayland->y,
+			.width = c->surface.xwayland->width,
+			.height = c->surface.xwayland->height,
+		};
 
 		/* Only render visible clients which show on this output */
 		if (!wlr_output_layout_intersects(output_layout, output, &geom))
 			continue;
 
-		rdata.output = output;
-		rdata.when = now;
-		rdata.x = c->surface.xwayland->x;
-		rdata.y = c->surface.xwayland->y;
+		struct render_data rdata = {
+			.output = output,
+			.when = now,
+			.x = c->surface.xwayland->x,
+			.y = c->surface.xwayland->y,
+		};
 
 		wlr_surface_for_each_surface(c->surface.xwayland->surface, render, &rdata);
 	}
@@ -2415,8 +2603,7 @@ renderindependents(struct wlr_output *output, struct timespec *now)
 void
 updatewindowtype(Client *c)
 {
-	size_t i;
-	for (i = 0; i < c->surface.xwayland->window_type_len; i++)
+	for (size_t i = 0; i < c->surface.xwayland->window_type_len; i++)
 		if (c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeDialog] ||
 				c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeSplash] ||
 				c->surface.xwayland->window_type[i] == netatom[NetWMWindowTypeToolbar] ||
@@ -2444,6 +2631,13 @@ xwaylandready(struct wl_listener *listener, void *data)
 	/* assign the one and only seat */
 	wlr_xwayland_set_seat(xwayland, seat);
 
+	/* Set the default XWayland cursor to match the rest of dwl. */
+	struct wlr_xcursor *xcursor = wlr_xcursor_manager_get_xcursor(cursor_mgr, "left_ptr", 1);
+	wlr_xwayland_set_cursor(xwayland,
+			xcursor->images[0]->buffer, xcursor->images[0]->width * 4,
+			xcursor->images[0]->width, xcursor->images[0]->height,
+			xcursor->images[0]->hotspot_x, xcursor->images[0]->hotspot_y);
+
 	xcb_disconnect(xc);
 }
 
@@ -2456,12 +2650,13 @@ xytoindependent(double x, double y)
 	 * client loses focus, which ensures that unmanaged are only visible on
 	 * the current tag. */
 	Client *c;
-	struct wlr_box geom;
 	wl_list_for_each_reverse(c, &independents, link) {
-		geom.x = c->surface.xwayland->x;
-		geom.y = c->surface.xwayland->y;
-		geom.width = c->surface.xwayland->width;
-		geom.height = c->surface.xwayland->height;
+		struct wlr_box geom = {
+			.x = c->surface.xwayland->x,
+			.y = c->surface.xwayland->y,
+			.width = c->surface.xwayland->width,
+			.height = c->surface.xwayland->height,
+		};
 		if (wlr_box_contains_point(&geom, x, y))
 			return c;
 	}