Implement atomic layout updates for tree operations

This implements atomic layout updates for when views map, reparent or
unmap.

include/sway/desktop/transaction.h

@@ -1,5 +1,6 @@
 #ifndef _SWAY_TRANSACTION_H
 #define _SWAY_TRANSACTION_H
+#include <wlr/render/wlr_texture.h>
 #include "sway/tree/container.h"
 
 /**
@@ -48,4 +49,12 @@ void transaction_commit(struct sway_transaction *transaction);
  */
 void transaction_notify_view_ready(struct sway_view *view, uint32_t serial);
 
+/**
+ * Get the texture that should be rendered for a view.
+ *
+ * In most cases this will return the normal live texture for a view, but if the
+ * view is in a transaction then it'll return a saved texture.
+ */
+struct wlr_texture *transaction_get_texture(struct sway_view *view);
+
 #endif

include/sway/server.h

@@ -12,6 +12,7 @@
 #include <wlr/render/wlr_renderer.h>
 // TODO WLR: make Xwayland optional
 #include <wlr/xwayland.h>
+#include "list.h"
 
 struct sway_server {
 	struct wl_display *wl_display;
@@ -43,6 +44,12 @@ struct sway_server {
 
 	struct wlr_wl_shell *wl_shell;
 	struct wl_listener wl_shell_surface;
+
+	bool terminating;
+
+	// When a view is being destroyed and is waiting for a transaction to
+	// complete it will be stored here.
+	list_t *destroying_containers;
 };
 
 struct sway_server server;

include/sway/tree/container.h

@@ -65,8 +65,8 @@ struct sway_container_state {
 	double gaps_inner;
 	double gaps_outer;
 
-	//struct sway_container *parent;
-	//list_t *children;
+	struct sway_container *parent;
+	list_t *children;
 
 	// View properties
 	double view_x, view_y;
@@ -79,6 +79,10 @@ struct sway_container_state {
 	bool border_bottom;
 	bool border_left;
 	bool border_right;
+
+	// Workspace properties
+	struct sway_view *ws_fullscreen;
+	struct sway_container *ws_floating;
 };
 
 struct sway_container {
@@ -128,8 +132,6 @@ struct sway_container {
 
 	struct sway_container *parent;
 
-	list_t *marks; // list of char*
-
 	float alpha;
 
 	struct wlr_texture *title_focused;
@@ -138,6 +140,10 @@ struct sway_container {
 	struct wlr_texture *title_urgent;
 	size_t title_height;
 
+	list_t *instructions; // struct sway_transaction_instruction *
+
+	bool destroying;
+
 	struct {
 		struct wl_signal destroy;
 		// Raised after the tree updates, but before arrange_windows
@@ -181,6 +187,8 @@ struct sway_container *workspace_create(struct sway_container *output,
 struct sway_container *container_view_create(
 		struct sway_container *sibling, struct sway_view *sway_view);
 
+void container_free(struct sway_container *cont);
+
 struct sway_container *container_destroy(struct sway_container *container);
 
 struct sway_container *container_close(struct sway_container *container);

include/sway/tree/view.h

@@ -37,7 +37,7 @@ struct sway_view_impl {
 	void (*for_each_surface)(struct sway_view *view,
 		wlr_surface_iterator_func_t iterator, void *user_data);
 	void (*close)(struct sway_view *view);
-	void (*destroy)(struct sway_view *view);
+	void (*free)(struct sway_view *view);
 };
 
 struct sway_view {
@@ -68,15 +68,10 @@ struct sway_view {
 	bool border_left;
 	bool border_right;
 
+	bool destroying;
+
 	list_t *executed_criteria; // struct criteria *
 	list_t *marks;             // char *
-	list_t *instructions;      // struct sway_transaction_instruction *
-
-	// If saved_buffer is set, the main surface of the view will render this
-	// buffer/texture instead of its own. This is used while waiting for
-	// transactions to complete.
-	struct wlr_buffer *saved_buffer;
-	int saved_surface_width, saved_surface_height;
 
 	struct wlr_texture *marks_focused;
 	struct wlr_texture *marks_focused_inactive;
@@ -244,11 +239,16 @@ void view_for_each_surface(struct sway_view *view,
 void view_init(struct sway_view *view, enum sway_view_type type,
 	const struct sway_view_impl *impl);
 
+void view_free(struct sway_view *view);
+
 void view_destroy(struct sway_view *view);
 
 void view_map(struct sway_view *view, struct wlr_surface *wlr_surface);
 
-void view_unmap(struct sway_view *view);
+/**
+ * Unmap the view and return the surviving parent (after reaping).
+ */
+struct sway_container *view_unmap(struct sway_view *view);
 
 void view_update_position(struct sway_view *view, double lx, double ly);
 

sway/commands/split.c

@@ -16,7 +16,7 @@ static struct cmd_results *do_split(int layout) {
 	}
 	struct sway_container *parent = container_split(con, layout);
 	container_create_notify(parent);
-	arrange_and_commit(parent);
+	arrange_and_commit(parent->parent);
 
 	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
 }

sway/desktop/output.c

@@ -102,40 +102,8 @@ static bool get_surface_box(struct root_geometry *geo,
 	wlr_box_rotated_bounds(&box, geo->rotation, &rotated_box);
 
 	struct wlr_box output_box = {
-		.width = output->swayc->width,
-		.height = output->swayc->height,
-	};
-
-	struct wlr_box intersection;
-	return wlr_box_intersection(&output_box, &rotated_box, &intersection);
-}
-
-static bool get_view_box(struct root_geometry *geo,
-		struct sway_output *output, struct sway_view *view, int sx, int sy,
-		struct wlr_box *surface_box) {
-	int sw = view->saved_surface_width;
-	int sh = view->saved_surface_height;
-
-	double _sx = sx, _sy = sy;
-	rotate_child_position(&_sx, &_sy, sw, sh, geo->width, geo->height,
-		geo->rotation);
-
-	struct wlr_box box = {
-		.x = geo->x + _sx,
-		.y = geo->y + _sy,
-		.width = sw,
-		.height = sh,
-	};
-	if (surface_box != NULL) {
-		memcpy(surface_box, &box, sizeof(struct wlr_box));
-	}
-
-	struct wlr_box rotated_box;
-	wlr_box_rotated_bounds(&box, geo->rotation, &rotated_box);
-
-	struct wlr_box output_box = {
-		.width = output->swayc->width,
-		.height = output->swayc->height,
+		.width = output->swayc->current.swayc_width,
+		.height = output->swayc->current.swayc_height,
 	};
 
 	struct wlr_box intersection;
@@ -158,8 +126,8 @@ static void output_view_for_each_surface(struct sway_view *view,
 		struct root_geometry *geo, wlr_surface_iterator_func_t iterator,
 		void *user_data) {
 	struct render_data *data = user_data;
-	geo->x = view->swayc->current.view_x - data->output->swayc->x;
-	geo->y = view->swayc->current.view_y - data->output->swayc->y;
+	geo->x = view->swayc->current.view_x - data->output->swayc->current.swayc_x;
+	geo->y = view->swayc->current.view_y - data->output->swayc->current.swayc_y;
 	geo->width = view->swayc->current.view_width;
 	geo->height = view->swayc->current.view_height;
 	geo->rotation = 0; // TODO
@@ -187,8 +155,8 @@ static void unmanaged_for_each_surface(struct wl_list *unmanaged,
 	wl_list_for_each(unmanaged_surface, unmanaged, link) {
 		struct wlr_xwayland_surface *xsurface =
 			unmanaged_surface->wlr_xwayland_surface;
-		double ox = unmanaged_surface->lx - output->swayc->x;
-		double oy = unmanaged_surface->ly - output->swayc->y;
+		double ox = unmanaged_surface->lx - output->swayc->current.swayc_x;
+		double oy = unmanaged_surface->ly - output->swayc->current.swayc_y;
 
 		surface_for_each_surface(xsurface->surface, ox, oy, geo,
 			iterator, user_data);
@@ -274,26 +242,14 @@ static void render_surface_iterator(struct wlr_surface *surface, int sx, int sy,
 	pixman_region32_t *output_damage = data->damage;
 	float alpha = data->alpha;
 
-	struct wlr_texture *texture = NULL;
-	struct wlr_box box;
-	bool intersects;
-
-	// If this is the main surface of a view, render the saved_buffer instead
-	// if it exists. It exists when we are mid-transaction.
-	if (data->view && data->view->saved_buffer &&
-			data->view->surface == surface) {
-		texture = data->view->saved_buffer->texture;
-		intersects = get_view_box(&data->root_geo, data->output, data->view,
-				sx, sy, &box);
-	} else {
-		texture = wlr_surface_get_texture(surface);
-		if (texture == NULL) {
+	struct wlr_texture *texture = wlr_surface_get_texture(surface);
+	if (!texture) {
 		return;
 	}
-		intersects = get_surface_box(&data->root_geo, data->output, surface,
-				sx, sy, &box);
-	}
 
+	struct wlr_box box;
+	bool intersects = get_surface_box(&data->root_geo, data->output, surface,
+			sx, sy, &box);
 	if (!intersects) {
 		return;
 	}
@@ -394,58 +350,98 @@ static void render_view_surfaces(struct sway_view *view,
 			view, &data.root_geo, render_surface_iterator, &data);
 }
 
+static void render_saved_view(struct sway_view *view,
+		struct sway_output *output, pixman_region32_t *damage, float alpha) {
+	struct wlr_output *wlr_output = output->wlr_output;
+
+	struct wlr_texture *texture = transaction_get_texture(view);
+	if (!texture) {
+		return;
+	}
+	struct wlr_box box = {
+		.x = view->swayc->current.view_x - output->swayc->current.swayc_x,
+		.y = view->swayc->current.view_y - output->swayc->current.swayc_y,
+		.width = view->swayc->current.view_width,
+		.height = view->swayc->current.view_height,
+	};
+
+	struct wlr_box output_box = {
+		.width = output->swayc->current.swayc_width,
+		.height = output->swayc->current.swayc_height,
+	};
+
+	struct wlr_box intersection;
+	bool intersects = wlr_box_intersection(&output_box, &box, &intersection);
+	if (!intersects) {
+		return;
+	}
+
+	scale_box(&box, wlr_output->scale);
+
+	float matrix[9];
+	wlr_matrix_project_box(matrix, &box, WL_OUTPUT_TRANSFORM_NORMAL, 0,
+		wlr_output->transform_matrix);
+
+	render_texture(wlr_output, damage, texture, &box, matrix, alpha);
+}
+
 /**
  * Render a view's surface and left/bottom/right borders.
  */
 static void render_view(struct sway_output *output, pixman_region32_t *damage,
 		struct sway_container *con, struct border_colors *colors) {
 	struct sway_view *view = con->sway_view;
+	if (view->swayc->instructions->length) {
+		render_saved_view(view, output, damage, view->swayc->alpha);
+	} else {
 		render_view_surfaces(view, output, damage, view->swayc->alpha);
+	}
 
 	struct wlr_box box;
 	float output_scale = output->wlr_output->scale;
 	float color[4];
+	struct sway_container_state *state = &con->current;
 
-	if (con->current.border != B_NONE) {
-		if (con->current.border_left) {
+	if (state->border != B_NONE) {
+		if (state->border_left) {
 			memcpy(&color, colors->child_border, sizeof(float) * 4);
 			premultiply_alpha(color, con->alpha);
-			box.x = con->current.swayc_x;
-			box.y = con->current.view_y;
-			box.width = con->current.border_thickness;
-			box.height = con->current.view_height;
+			box.x = state->swayc_x;
+			box.y = state->view_y;
+			box.width = state->border_thickness;
+			box.height = state->view_height;
 			scale_box(&box, output_scale);
 			render_rect(output->wlr_output, damage, &box, color);
 		}
 
-		if (con->current.border_right) {
-			if (con->parent->children->length == 1
-					&& con->parent->current.layout == L_HORIZ) {
+		if (state->border_right) {
+			if (state->parent->current.children->length == 1
+					&& state->parent->current.layout == L_HORIZ) {
 				memcpy(&color, colors->indicator, sizeof(float) * 4);
 			} else {
 				memcpy(&color, colors->child_border, sizeof(float) * 4);
 			}
 			premultiply_alpha(color, con->alpha);
-			box.x = con->current.view_x + con->current.view_width;
-			box.y = con->current.view_y;
-			box.width = con->current.border_thickness;
-			box.height = con->current.view_height;
+			box.x = state->view_x + state->view_width;
+			box.y = state->view_y;
+			box.width = state->border_thickness;
+			box.height = state->view_height;
 			scale_box(&box, output_scale);
 			render_rect(output->wlr_output, damage, &box, color);
 		}
 
-		if (con->current.border_bottom) {
-			if (con->parent->children->length == 1
-					&& con->parent->current.layout == L_VERT) {
+		if (state->border_bottom) {
+			if (state->parent->current.children->length == 1
+					&& con->current.parent->current.layout == L_VERT) {
 				memcpy(&color, colors->indicator, sizeof(float) * 4);
 			} else {
 				memcpy(&color, colors->child_border, sizeof(float) * 4);
 			}
 			premultiply_alpha(color, con->alpha);
-			box.x = con->current.swayc_x;
-			box.y = con->current.view_y + con->current.view_height;
-			box.width = con->current.swayc_width;
-			box.height = con->current.border_thickness;
+			box.x = state->swayc_x;
+			box.y = state->view_y + state->view_height;
+			box.width = state->swayc_width;
+			box.height = state->border_thickness;
 			scale_box(&box, output_scale);
 			render_rect(output->wlr_output, damage, &box, color);
 		}
@@ -469,10 +465,13 @@ static void render_titlebar(struct sway_output *output,
 		struct wlr_texture *marks_texture) {
 	struct wlr_box box;
 	float color[4];
+	struct sway_container_state *state = &con->current;
 	float output_scale = output->wlr_output->scale;
-	enum sway_container_layout layout = con->parent->current.layout;
-	bool is_last_child =
-		con->parent->children->items[con->parent->children->length - 1] == con;
+	enum sway_container_layout layout = state->parent->current.layout;
+	list_t *children = state->parent->current.children;
+	bool is_last_child = children->items[children->length - 1] == con;
+	double output_x = output->swayc->current.swayc_x;
+	double output_y = output->swayc->current.swayc_y;
 
 	// Single pixel bar above title
 	memcpy(&color, colors->border, sizeof(float) * 4);
@@ -490,10 +489,8 @@ static void render_titlebar(struct sway_output *output,
 	if (layout == L_HORIZ || layout == L_VERT ||
 			(layout == L_STACKED && is_last_child)) {
 		if (con->type == C_VIEW) {
-			left_offset =
-				con->current.border_left * con->current.border_thickness;
-			right_offset =
-				con->current.border_right * con->current.border_thickness;
+			left_offset = state->border_left * state->border_thickness;
+			right_offset = state->border_right * state->border_thickness;
 			connects_sides = true;
 		}
 	}
@@ -527,10 +524,9 @@ static void render_titlebar(struct sway_output *output,
 		struct wlr_box texture_box;
 		wlr_texture_get_size(marks_texture,
 			&texture_box.width, &texture_box.height);
-		texture_box.x = (x - output->swayc->x + width - TITLEBAR_H_PADDING)
+		texture_box.x = (x - output_x + width - TITLEBAR_H_PADDING)
 			* output_scale - texture_box.width;
-		texture_box.y = (y - output->swayc->y + TITLEBAR_V_PADDING)
-			* output_scale;
+		texture_box.y = (y - output_y + TITLEBAR_V_PADDING) * output_scale;
 
 		float matrix[9];
 		wlr_matrix_project_box(matrix, &texture_box,
@@ -551,10 +547,8 @@ static void render_titlebar(struct sway_output *output,
 		struct wlr_box texture_box;
 		wlr_texture_get_size(title_texture,
 			&texture_box.width, &texture_box.height);
-		texture_box.x = (x - output->swayc->x + TITLEBAR_H_PADDING)
-			* output_scale;
-		texture_box.y = (y - output->swayc->y + TITLEBAR_V_PADDING)
-			* output_scale;
+		texture_box.x = (x - output_x + TITLEBAR_H_PADDING) * output_scale;
+		texture_box.y = (y - output_y + TITLEBAR_V_PADDING) * output_scale;
 
 		float matrix[9];
 		wlr_matrix_project_box(matrix, &texture_box,
@@ -614,16 +608,15 @@ static void render_titlebar(struct sway_output *output,
 		// Left pixel in line with bottom bar
 		box.x = x;
 		box.y = y + container_titlebar_height() - TITLEBAR_BORDER_THICKNESS;
-		box.width = con->current.border_thickness * con->current.border_left;
+		box.width = state->border_thickness * state->border_left;
 		box.height = TITLEBAR_BORDER_THICKNESS;
 		scale_box(&box, output_scale);
 		render_rect(output->wlr_output, output_damage, &box, color);
 
 		// Right pixel in line with bottom bar
-		box.x = x + width -
-			con->current.border_thickness * con->current.border_right;
+		box.x = x + width - state->border_thickness * state->border_right;
 		box.y = y + container_titlebar_height() - TITLEBAR_BORDER_THICKNESS;
-		box.width = con->current.border_thickness * con->current.border_right;
+		box.width = state->border_thickness * state->border_right;
 		box.height = TITLEBAR_BORDER_THICKNESS;
 		scale_box(&box, output_scale);
 		render_rect(output->wlr_output, output_damage, &box, color);
@@ -636,7 +629,8 @@ static void render_titlebar(struct sway_output *output,
 static void render_top_border(struct sway_output *output,
 		pixman_region32_t *output_damage, struct sway_container *con,
 		struct border_colors *colors) {
-	if (!con->current.border_top) {
+	struct sway_container_state *state = &con->current;
+	if (!state->border_top) {
 		return;
 	}
 	struct wlr_box box;
@@ -646,10 +640,10 @@ static void render_top_border(struct sway_output *output,
 	// Child border - top edge
 	memcpy(&color, colors->child_border, sizeof(float) * 4);
 	premultiply_alpha(color, con->alpha);
-	box.x = con->current.swayc_x;
-	box.y = con->current.swayc_y;
-	box.width = con->current.swayc_width;
-	box.height = con->current.border_thickness;
+	box.x = state->swayc_x;
+	box.y = state->swayc_y;
+	box.width = state->swayc_width;
+	box.height = state->border_thickness;
 	scale_box(&box, output_scale);
 	render_rect(output->wlr_output, output_damage, &box, color);
 }
@@ -669,31 +663,34 @@ static void render_container_simple(struct sway_output *output,
 	struct sway_seat *seat = input_manager_current_seat(input_manager);
 	struct sway_container *focus = seat_get_focus(seat);
 
-	for (int i = 0; i < con->children->length; ++i) {
-		struct sway_container *child = con->children->items[i];
+	for (int i = 0; i < con->current.children->length; ++i) {
+		struct sway_container *child = con->current.children->items[i];
 
 		if (child->type == C_VIEW) {
+			struct sway_view *view = child->sway_view;
 			struct border_colors *colors;
 			struct wlr_texture *title_texture;
 			struct wlr_texture *marks_texture;
+			struct sway_container_state *state = &child->current;
+
 			if (focus == child || parent_focused) {
 				colors = &config->border_colors.focused;
 				title_texture = child->title_focused;
-				marks_texture = child->sway_view->marks_focused;
+				marks_texture = view->marks_focused;
 			} else if (seat_get_focus_inactive(seat, con) == child) {
 				colors = &config->border_colors.focused_inactive;
 				title_texture = child->title_focused_inactive;
-				marks_texture = child->sway_view->marks_focused_inactive;
+				marks_texture = view->marks_focused_inactive;
 			} else {
 				colors = &config->border_colors.unfocused;
 				title_texture = child->title_unfocused;
-				marks_texture = child->sway_view->marks_unfocused;
+				marks_texture = view->marks_unfocused;
 			}
 
-			if (child->current.border == B_NORMAL) {
-				render_titlebar(output, damage, child, child->current.swayc_x,
-						child->current.swayc_y, child->current.swayc_width,
-						colors, title_texture, marks_texture);
+			if (state->border == B_NORMAL) {
+				render_titlebar(output, damage, child, state->swayc_x,
+						state->swayc_y, state->swayc_width, colors,
+						title_texture, marks_texture);
 			} else {
 				render_top_border(output, damage, child, colors);
 			}
@@ -711,22 +708,23 @@ static void render_container_simple(struct sway_output *output,
 static void render_container_tabbed(struct sway_output *output,
 		pixman_region32_t *damage, struct sway_container *con,
 		bool parent_focused) {
-	if (!con->children->length) {
+	if (!con->current.children->length) {
 		return;
 	}
 	struct sway_seat *seat = input_manager_current_seat(input_manager);
 	struct sway_container *focus = seat_get_focus(seat);
 	struct sway_container *current = seat_get_active_child(seat, con);
 	struct border_colors *current_colors = NULL;
+	struct sway_container_state *pstate = &con->current;
 
 	// Render tabs
-	for (int i = 0; i < con->children->length; ++i) {
-		struct sway_container *child = con->children->items[i];
+	for (int i = 0; i < con->current.children->length; ++i) {
+		struct sway_container *child = con->current.children->items[i];
+		struct sway_view *view = child->type == C_VIEW ? child->sway_view : NULL;
+		struct sway_container_state *cstate = &child->current;
 		struct border_colors *colors;
 		struct wlr_texture *title_texture;
 		struct wlr_texture *marks_texture;
-		struct sway_view *view =
-			child->type == C_VIEW ? child->sway_view : NULL;
 
 		if (focus == child || parent_focused) {
 			colors = &config->border_colors.focused;
@@ -735,22 +733,22 @@ static void render_container_tabbed(struct sway_output *output,
 		} else if (child == current) {
 			colors = &config->border_colors.focused_inactive;
 			title_texture = child->title_focused_inactive;
-			marks_texture = view ? view->marks_focused : NULL;
+			marks_texture = view ? view->marks_focused_inactive : NULL;
 		} else {
 			colors = &config->border_colors.unfocused;
 			title_texture = child->title_unfocused;
 			marks_texture = view ? view->marks_unfocused : NULL;
 		}
 
-		int tab_width = con->current.swayc_width / con->children->length;
-		int x = con->current.swayc_x + tab_width * i;
+		int tab_width = pstate->swayc_width / pstate->children->length;
+		int x = pstate->swayc_x + tab_width * i;
 		// Make last tab use the remaining width of the parent
-		if (i == con->children->length - 1) {
-			tab_width = con->current.swayc_width - tab_width * i;
+		if (i == pstate->children->length - 1) {
+			tab_width = pstate->swayc_width - tab_width * i;
 		}
 
-		render_titlebar(output, damage, child, x, child->current.swayc_y,
-				tab_width, colors, title_texture, marks_texture);
+		render_titlebar(output, damage, child, x, cstate->swayc_y, tab_width,
+				colors, title_texture, marks_texture);
 
 		if (child == current) {
 			current_colors = colors;
@@ -772,22 +770,23 @@ static void render_container_tabbed(struct sway_output *output,
 static void render_container_stacked(struct sway_output *output,
 		pixman_region32_t *damage, struct sway_container *con,
 		bool parent_focused) {
-	if (!con->children->length) {
+	if (!con->current.children->length) {
 		return;
 	}
 	struct sway_seat *seat = input_manager_current_seat(input_manager);
 	struct sway_container *focus = seat_get_focus(seat);
 	struct sway_container *current = seat_get_active_child(seat, con);
 	struct border_colors *current_colors = NULL;
+	struct sway_container_state *pstate = &con->current;
 
 	// Render titles
-	for (int i = 0; i < con->children->length; ++i) {
-		struct sway_container *child = con->children->items[i];
+	for (int i = 0; i < con->current.children->length; ++i) {
+		struct sway_container *child = con->current.children->items[i];
+		struct sway_view *view = child->type == C_VIEW ? child->sway_view : NULL;
+		struct sway_container_state *cstate = &child->current;
 		struct border_colors *colors;
 		struct wlr_texture *title_texture;
 		struct wlr_texture *marks_texture;
-		struct sway_view *view =
-			child->type == C_VIEW ? child->sway_view : NULL;
 
 		if (focus == child || parent_focused) {
 			colors = &config->border_colors.focused;
@@ -803,10 +802,9 @@ static void render_container_stacked(struct sway_output *output,
 			marks_texture = view ? view->marks_unfocused : NULL;
 		}
 
-		int y = con->current.swayc_y + container_titlebar_height() * i;
-		render_titlebar(output, damage, child, child->current.swayc_x, y,
-				child->current.swayc_width, colors,
-				title_texture, marks_texture);
+		int y = pstate->swayc_y + container_titlebar_height() * i;
+		render_titlebar(output, damage, child, cstate->swayc_x, y,
+				cstate->swayc_width, colors, title_texture, marks_texture);
 
 		if (child == current) {
 			current_colors = colors;
@@ -877,17 +875,18 @@ static void render_floating_container(struct sway_output *soutput,
 
 static void render_floating(struct sway_output *soutput,
 		pixman_region32_t *damage) {
-	for (int i = 0; i < root_container.children->length; ++i) {
-		struct sway_container *output = root_container.children->items[i];
-		for (int j = 0; j < output->children->length; ++j) {
-			struct sway_container *workspace = output->children->items[j];
-			struct sway_workspace *ws = workspace->sway_workspace;
-			if (!workspace_is_visible(workspace)) {
+	for (int i = 0; i < root_container.current.children->length; ++i) {
+		struct sway_container *output =
+			root_container.current.children->items[i];
+		for (int j = 0; j < output->current.children->length; ++j) {
+			struct sway_container *ws = output->current.children->items[j];
+			if (!workspace_is_visible(ws)) {
 				continue;
 			}
-			for (int k = 0; k < ws->floating->children->length; ++k) {
-				struct sway_container *floater =
-					ws->floating->children->items[k];
+			list_t *floating =
+				ws->current.ws_floating->current.children;
+			for (int k = 0; k < floating->length; ++k) {
+				struct sway_container *floater = floating->items[k];
 				render_floating_container(soutput, damage, floater);
 			}
 		}
@@ -901,7 +900,7 @@ static struct sway_container *output_get_active_workspace(
 		seat_get_focus_inactive(seat, output->swayc);
 	if (!focus) {
 		// We've never been to this output before
-		focus = output->swayc->children->items[0];
+		focus = output->swayc->current.children->items[0];
 	}
 	struct sway_container *workspace = focus;
 	if (workspace->type != C_WORKSPACE) {
@@ -942,8 +941,9 @@ static void render_output(struct sway_output *output, struct timespec *when,
 	}
 
 	struct sway_container *workspace = output_get_active_workspace(output);
+	struct sway_view *fullscreen_view = workspace->current.ws_fullscreen;
 
-	if (workspace->sway_workspace->fullscreen) {
+	if (fullscreen_view) {
 		float clear_color[] = {0.0f, 0.0f, 0.0f, 1.0f};
 
 		int nrects;
@@ -954,10 +954,9 @@ static void render_output(struct sway_output *output, struct timespec *when,
 		}
 
 		// TODO: handle views smaller than the output
-		render_view_surfaces(
-				workspace->sway_workspace->fullscreen, output, damage, 1.0f);
+		render_view_surfaces(fullscreen_view, output, damage, 1.0f);
 
-		if (workspace->sway_workspace->fullscreen->type == SWAY_VIEW_XWAYLAND) {
+		if (fullscreen_view->type == SWAY_VIEW_XWAYLAND) {
 			render_unmanaged(output, damage,
 				&root_container.sway_root->xwayland_unmanaged);
 		}
@@ -1073,11 +1072,11 @@ static void send_frame_done(struct sway_output *output, struct timespec *when) {
 	};
 
 	struct sway_container *workspace = output_get_active_workspace(output);
-	if (workspace->sway_workspace->fullscreen) {
+	if (workspace->current.ws_fullscreen) {
 		send_frame_done_container_iterator(
-			workspace->sway_workspace->fullscreen->swayc, &data);
+			workspace->current.ws_fullscreen->swayc, &data);
 
-		if (workspace->sway_workspace->fullscreen->type == SWAY_VIEW_XWAYLAND) {
+		if (workspace->current.ws_fullscreen->type == SWAY_VIEW_XWAYLAND) {
 			send_frame_done_unmanaged(&data,
 				&root_container.sway_root->xwayland_unmanaged);
 		}

sway/desktop/transaction.c

@@ -9,6 +9,7 @@
 #include "sway/output.h"
 #include "sway/tree/container.h"
 #include "sway/tree/view.h"
+#include "sway/tree/workspace.h"
 #include "list.h"
 #include "log.h"
 
@@ -18,6 +19,13 @@
  */
 #define TIMEOUT_MS 200
 
+/**
+ * If enabled, sway will always wait for the transaction timeout before
+ * applying it, rather than applying it when the views are ready. This allows us
+ * to observe the rendered state while a transaction is in progress.
+ */
+#define TRANSACTION_DEBUG false
+
 struct sway_transaction {
 	struct wl_event_source *timer;
 	list_t *instructions;   // struct sway_transaction_instruction *
@@ -29,7 +37,9 @@ struct sway_transaction_instruction {
 	struct sway_transaction *transaction;
 	struct sway_container *container;
 	struct sway_container_state state;
+	struct wlr_buffer *saved_buffer;
 	uint32_t serial;
+	bool ready;
 };
 
 struct sway_transaction *transaction_create() {
@@ -40,44 +50,55 @@ struct sway_transaction *transaction_create() {
 	return transaction;
 }
 
+static void remove_saved_view_buffer(
+		struct sway_transaction_instruction *instruction) {
+	if (instruction->saved_buffer) {
+		wlr_buffer_unref(instruction->saved_buffer);
+		instruction->saved_buffer = NULL;
+	}
+}
+
+static void save_view_buffer(struct sway_view *view,
+		struct sway_transaction_instruction *instruction) {
+	if (!sway_assert(instruction->saved_buffer == NULL,
+				"Didn't expect instruction to have a saved buffer already")) {
+		remove_saved_view_buffer(instruction);
+	}
+	if (view->surface && wlr_surface_has_buffer(view->surface)) {
+		wlr_buffer_ref(view->surface->buffer);
+		instruction->saved_buffer = view->surface->buffer;
+	}
+}
+
 static void transaction_destroy(struct sway_transaction *transaction) {
-	int i;
 	// Free instructions
-	for (i = 0; i < transaction->instructions->length; ++i) {
+	for (int i = 0; i < transaction->instructions->length; ++i) {
 		struct sway_transaction_instruction *instruction =
 			transaction->instructions->items[i];
-		if (instruction->container->type == C_VIEW) {
-			struct sway_view *view = instruction->container->sway_view;
-			for (int j = 0; j < view->instructions->length; ++j) {
-				if (view->instructions->items[j] == instruction) {
-					list_del(view->instructions, j);
+		struct sway_container *con = instruction->container;
+		for (int j = 0; j < con->instructions->length; ++j) {
+			if (con->instructions->items[j] == instruction) {
+				list_del(con->instructions, j);
 				break;
 			}
 		}
+		if (con->destroying && !con->instructions->length) {
+			container_free(con);
 		}
+		remove_saved_view_buffer(instruction);
 		free(instruction);
 	}
 	list_free(transaction->instructions);
 
 	// Free damage
-	for (i = 0; i < transaction->damage->length; ++i) {
-		struct wlr_box *box = transaction->damage->items[i];
-		free(box);
-	}
+	list_foreach(transaction->damage, free);
 	list_free(transaction->damage);
 
 	free(transaction);
 }
 
-void transaction_add_container(struct sway_transaction *transaction,
-		struct sway_container *container) {
-	struct sway_transaction_instruction *instruction =
-		calloc(1, sizeof(struct sway_transaction_instruction));
-	instruction->transaction = transaction;
-	instruction->container = container;
-
-	// Copy the container's main (pending) properties into the instruction state
-	struct sway_container_state *state = &instruction->state;
+static void copy_pending_state(struct sway_container *container,
+		struct sway_container_state *state) {
 	state->layout = container->layout;
 	state->swayc_x = container->x;
 	state->swayc_y = container->y;
@@ -87,6 +108,7 @@ void transaction_add_container(struct sway_transaction *transaction,
 	state->current_gaps = container->current_gaps;
 	state->gaps_inner = container->gaps_inner;
 	state->gaps_outer = container->gaps_outer;
+	state->parent = container->parent;
 
 	if (container->type == C_VIEW) {
 		struct sway_view *view = container->sway_view;
@@ -101,8 +123,44 @@ void transaction_add_container(struct sway_transaction *transaction,
 		state->border_left = view->border_left;
 		state->border_right = view->border_right;
 		state->border_bottom = view->border_bottom;
+	} else if (container->type == C_WORKSPACE) {
+		state->ws_fullscreen = container->sway_workspace->fullscreen;
+		state->ws_floating = container->sway_workspace->floating;
+		state->children = create_list();
+		list_cat(state->children, container->children);
+	} else {
+		state->children = create_list();
+		list_cat(state->children, container->children);
+	}
+}
+
+static bool transaction_has_container(struct sway_transaction *transaction,
+		struct sway_container *container) {
+	for (int i = 0; i < transaction->instructions->length; ++i) {
+		struct sway_transaction_instruction *instruction =
+			transaction->instructions->items[i];
+		if (instruction->container == container) {
+			return true;
+		}
+	}
+	return false;
 }
 
+void transaction_add_container(struct sway_transaction *transaction,
+		struct sway_container *container) {
+	if (transaction_has_container(transaction, container)) {
+		return;
+	}
+	struct sway_transaction_instruction *instruction =
+		calloc(1, sizeof(struct sway_transaction_instruction));
+	instruction->transaction = transaction;
+	instruction->container = container;
+
+	copy_pending_state(container, &instruction->state);
+
+	if (container->type == C_VIEW) {
+		save_view_buffer(container->sway_view, instruction);
+	}
 	list_add(transaction->instructions, instruction);
 }
 
@@ -113,47 +171,29 @@ void transaction_add_damage(struct sway_transaction *transaction,
 	list_add(transaction->damage, box);
 }
 
-static void save_view_buffer(struct sway_view *view) {
-	if (view->saved_buffer) {
-		wlr_buffer_unref(view->saved_buffer);
-	}
-	wlr_buffer_ref(view->surface->buffer);
-	view->saved_buffer = view->surface->buffer;
-	view->saved_surface_width = view->surface->current->width;
-	view->saved_surface_height = view->surface->current->height;
-}
-
-static void remove_saved_view_buffer(struct sway_view *view) {
-	if (view->saved_buffer) {
-		wlr_buffer_unref(view->saved_buffer);
-		view->saved_buffer = NULL;
-		view->saved_surface_width = 0;
-		view->saved_surface_height = 0;
-	}
-}
-
 /**
  * Apply a transaction to the "current" state of the tree.
- *
- * This is mostly copying stuff from the pending state into the main swayc
- * properties, but also includes reparenting and deleting containers.
  */
 static void transaction_apply(struct sway_transaction *transaction) {
 	int i;
+	// Apply the instruction state to the container's current state
 	for (i = 0; i < transaction->instructions->length; ++i) {
 		struct sway_transaction_instruction *instruction =
 			transaction->instructions->items[i];
 		struct sway_container *container = instruction->container;
 
-		memcpy(&instruction->container->current, &instruction->state,
-				sizeof(struct sway_container_state));
+		// There are separate children lists for each instruction state, the
+		// container's current state and the container's pending state
+		// (ie. con->children). The list itself needs to be freed here.
+		// Any child containers which are being deleted will be cleaned up in
+		// transaction_destroy().
+		list_free(container->current.children);
 
-		if (container->type == C_VIEW) {
-			remove_saved_view_buffer(container->sway_view);
-		}
+		memcpy(&container->current, &instruction->state,
+				sizeof(struct sway_container_state));
 	}
 
-	// Damage
+	// Apply damage
 	for (i = 0; i < transaction->damage->length; ++i) {
 		struct wlr_box *box = transaction->damage->items[i];
 		for (int j = 0; j < root_container.children->length; ++j) {
@@ -161,8 +201,6 @@ static void transaction_apply(struct sway_transaction *transaction) {
 			output_damage_box(output->sway_output, box);
 		}
 	}
-
-	update_debug_tree();
 }
 
 static int handle_timeout(void *data) {
@@ -182,7 +220,7 @@ void transaction_commit(struct sway_transaction *transaction) {
 		struct sway_transaction_instruction *instruction =
 			transaction->instructions->items[i];
 		struct sway_container *con = instruction->container;
-		if (con->type == C_VIEW &&
+		if (con->type == C_VIEW && !con->destroying &&
 				(con->current.view_width != instruction->state.view_width ||
 				 con->current.view_height != instruction->state.view_height)) {
 			instruction->serial = view_configure(con->sway_view,
@@ -191,14 +229,12 @@ void transaction_commit(struct sway_transaction *transaction) {
 					instruction->state.view_width,
 					instruction->state.view_height);
 			if (instruction->serial) {
-				save_view_buffer(con->sway_view);
-				list_add(con->sway_view->instructions, instruction);
 				++transaction->num_waiting;
 			}
 		}
+		list_add(con->instructions, instruction);
 	}
 	if (!transaction->num_waiting) {
-		// This can happen if the transaction only contains xwayland views
 		wlr_log(L_DEBUG, "Transaction %p has nothing to wait for, applying",
 				transaction);
 		transaction_apply(transaction);
@@ -210,31 +246,47 @@ void transaction_commit(struct sway_transaction *transaction) {
 	transaction->timer = wl_event_loop_add_timer(server.wl_event_loop,
 			handle_timeout, transaction);
 	wl_event_source_timer_update(transaction->timer, TIMEOUT_MS);
+
+	// The debug tree shows the pending/live tree. Here is a good place to
+	// update it, because we make a transaction every time we change the pending
+	// tree.
+	update_debug_tree();
 }
 
 void transaction_notify_view_ready(struct sway_view *view, uint32_t serial) {
 	// Find the instruction
 	struct sway_transaction_instruction *instruction = NULL;
-	for (int i = 0; i < view->instructions->length; ++i) {
+	for (int i = 0; i < view->swayc->instructions->length; ++i) {
 		struct sway_transaction_instruction *tmp_instruction =
-			view->instructions->items[i];
-		if (tmp_instruction->serial == serial) {
+			view->swayc->instructions->items[i];
+		if (tmp_instruction->serial == serial && !tmp_instruction->ready) {
 			instruction = tmp_instruction;
-			list_del(view->instructions, i);
 			break;
 		}
 	}
 	if (!instruction) {
-		// This can happen if the view acknowledges the configure after the
-		// transaction has timed out and applied.
 		return;
 	}
+	instruction->ready = true;
+
 	// If all views are ready, apply the transaction
 	struct sway_transaction *transaction = instruction->transaction;
 	if (--transaction->num_waiting == 0) {
+#if !TRANSACTION_DEBUG
 		wlr_log(L_DEBUG, "Transaction %p is ready, applying", transaction);
 		wl_event_source_timer_update(transaction->timer, 0);
 		transaction_apply(transaction);
 		transaction_destroy(transaction);
+#endif
 	}
 }
+
+struct wlr_texture *transaction_get_texture(struct sway_view *view) {
+	if (!view->swayc || !view->swayc->instructions->length) {
+		return view->surface->buffer->texture;
+	}
+	struct sway_transaction_instruction *instruction =
+		view->swayc->instructions->items[0];
+	return instruction->saved_buffer ?
+		instruction->saved_buffer->texture : NULL;
+}

sway/desktop/xdg_shell.c

@@ -143,16 +143,12 @@ static void _close(struct sway_view *view) {
 	}
 }
 
-static void destroy(struct sway_view *view) {
+static void _free(struct sway_view *view) {
 	struct sway_xdg_shell_view *xdg_shell_view =
 		xdg_shell_view_from_view(view);
 	if (xdg_shell_view == NULL) {
 		return;
 	}
-	wl_list_remove(&xdg_shell_view->destroy.link);
-	wl_list_remove(&xdg_shell_view->map.link);
-	wl_list_remove(&xdg_shell_view->unmap.link);
-	wl_list_remove(&xdg_shell_view->request_fullscreen.link);
 	free(xdg_shell_view);
 }
 
@@ -164,7 +160,7 @@ static const struct sway_view_impl view_impl = {
 	.wants_floating = wants_floating,
 	.for_each_surface = for_each_surface,
 	.close = _close,
-	.destroy = destroy,
+	.free = _free,
 };
 
 static void handle_commit(struct wl_listener *listener, void *data) {
@@ -173,7 +169,11 @@ static void handle_commit(struct wl_listener *listener, void *data) {
 	struct sway_view *view = &xdg_shell_view->view;
 	struct wlr_xdg_surface *xdg_surface = view->wlr_xdg_surface;
 
-	if (view->instructions->length) {
+	if (!view->swayc) {
+		return;
+	}
+
+	if (view->swayc->instructions->length) {
 		transaction_notify_view_ready(view, xdg_surface->configure_serial);
 	}
 
@@ -191,11 +191,18 @@ static void handle_new_popup(struct wl_listener *listener, void *data) {
 static void handle_unmap(struct wl_listener *listener, void *data) {
 	struct sway_xdg_shell_view *xdg_shell_view =
 		wl_container_of(listener, xdg_shell_view, unmap);
+	struct sway_view *view = &xdg_shell_view->view;
+
+	if (!sway_assert(view->surface, "Cannot unmap unmapped view")) {
+		return;
+	}
 
-	view_unmap(&xdg_shell_view->view);
+	struct sway_container *parent = view_unmap(view);
+	arrange_and_commit(parent);
 
 	wl_list_remove(&xdg_shell_view->commit.link);
 	wl_list_remove(&xdg_shell_view->new_popup.link);
+	view->surface = NULL;
 }
 
 static void handle_map(struct wl_listener *listener, void *data) {
@@ -230,7 +237,17 @@ static void handle_map(struct wl_listener *listener, void *data) {
 static void handle_destroy(struct wl_listener *listener, void *data) {
 	struct sway_xdg_shell_view *xdg_shell_view =
 		wl_container_of(listener, xdg_shell_view, destroy);
-	view_destroy(&xdg_shell_view->view);
+	struct sway_view *view = &xdg_shell_view->view;
+	if (!sway_assert(view->swayc == NULL || view->swayc->destroying,
+				"Tried to destroy a mapped view")) {
+		return;
+	}
+	wl_list_remove(&xdg_shell_view->destroy.link);
+	wl_list_remove(&xdg_shell_view->map.link);
+	wl_list_remove(&xdg_shell_view->unmap.link);
+	wl_list_remove(&xdg_shell_view->request_fullscreen.link);
+	view->wlr_xdg_surface = NULL;
+	view_destroy(view);
 }
 
 static void handle_request_fullscreen(struct wl_listener *listener, void *data) {

sway/desktop/xdg_shell_v6.c

@@ -143,16 +143,12 @@ static void _close(struct sway_view *view) {
 	}
 }
 
-static void destroy(struct sway_view *view) {
+static void _free(struct sway_view *view) {
 	struct sway_xdg_shell_v6_view *xdg_shell_v6_view =
 		xdg_shell_v6_view_from_view(view);
 	if (xdg_shell_v6_view == NULL) {
 		return;
 	}
-	wl_list_remove(&xdg_shell_v6_view->destroy.link);
-	wl_list_remove(&xdg_shell_v6_view->map.link);
-	wl_list_remove(&xdg_shell_v6_view->unmap.link);
-	wl_list_remove(&xdg_shell_v6_view->request_fullscreen.link);
 	free(xdg_shell_v6_view);
 }
 
@@ -164,7 +160,7 @@ static const struct sway_view_impl view_impl = {
 	.wants_floating = wants_floating,
 	.for_each_surface = for_each_surface,
 	.close = _close,
-	.destroy = destroy,
+	.free = _free,
 };
 
 static void handle_commit(struct wl_listener *listener, void *data) {
@@ -173,7 +169,10 @@ static void handle_commit(struct wl_listener *listener, void *data) {
 	struct sway_view *view = &xdg_shell_v6_view->view;
 	struct wlr_xdg_surface_v6 *xdg_surface_v6 = view->wlr_xdg_surface_v6;
 
-	if (view->instructions->length) {
+	if (!view->swayc) {
+		return;
+	}
+	if (view->swayc->instructions->length) {
 		transaction_notify_view_ready(view, xdg_surface_v6->configure_serial);
 	}
 
@@ -191,11 +190,18 @@ static void handle_new_popup(struct wl_listener *listener, void *data) {
 static void handle_unmap(struct wl_listener *listener, void *data) {
 	struct sway_xdg_shell_v6_view *xdg_shell_v6_view =
 		wl_container_of(listener, xdg_shell_v6_view, unmap);
+	struct sway_view *view = &xdg_shell_v6_view->view;
 
-	view_unmap(&xdg_shell_v6_view->view);
+	if (!sway_assert(view->surface, "Cannot unmap unmapped view")) {
+		return;
+	}
+
+	struct sway_container *parent = view_unmap(view);
+	arrange_and_commit(parent);
 
 	wl_list_remove(&xdg_shell_v6_view->commit.link);
 	wl_list_remove(&xdg_shell_v6_view->new_popup.link);
+	view->surface = NULL;
 }
 
 static void handle_map(struct wl_listener *listener, void *data) {
@@ -230,7 +236,13 @@ static void handle_map(struct wl_listener *listener, void *data) {
 static void handle_destroy(struct wl_listener *listener, void *data) {
 	struct sway_xdg_shell_v6_view *xdg_shell_v6_view =
 		wl_container_of(listener, xdg_shell_v6_view, destroy);
-	view_destroy(&xdg_shell_v6_view->view);
+	struct sway_view *view = &xdg_shell_v6_view->view;
+	wl_list_remove(&xdg_shell_v6_view->destroy.link);
+	wl_list_remove(&xdg_shell_v6_view->map.link);
+	wl_list_remove(&xdg_shell_v6_view->unmap.link);
+	wl_list_remove(&xdg_shell_v6_view->request_fullscreen.link);
+	view->wlr_xdg_surface_v6 = NULL;
+	view_destroy(view);
 }
 
 static void handle_request_fullscreen(struct wl_listener *listener, void *data) {

sway/desktop/xwayland.c

@@ -218,19 +218,11 @@ static void _close(struct sway_view *view) {
 	wlr_xwayland_surface_close(view->wlr_xwayland_surface);
 }
 
-static void destroy(struct sway_view *view) {
+static void _free(struct sway_view *view) {
 	struct sway_xwayland_view *xwayland_view = xwayland_view_from_view(view);
 	if (xwayland_view == NULL) {
 		return;
 	}
-	wl_list_remove(&xwayland_view->destroy.link);
-	wl_list_remove(&xwayland_view->request_configure.link);
-	wl_list_remove(&xwayland_view->request_fullscreen.link);
-	wl_list_remove(&xwayland_view->set_title.link);
-	wl_list_remove(&xwayland_view->set_class.link);
-	wl_list_remove(&xwayland_view->set_window_type.link);
-	wl_list_remove(&xwayland_view->map.link);
-	wl_list_remove(&xwayland_view->unmap.link);
 	free(xwayland_view);
 }
 
@@ -242,7 +234,7 @@ static const struct sway_view_impl view_impl = {
 	.set_fullscreen = set_fullscreen,
 	.wants_floating = wants_floating,
 	.close = _close,
-	.destroy = destroy,
+	.free = _free,
 };
 
 static void handle_commit(struct wl_listener *listener, void *data) {
@@ -254,7 +246,7 @@ static void handle_commit(struct wl_listener *listener, void *data) {
 	// Don't allow xwayland views to do resize or reposition themselves if
 	// they're involved in a transaction. Once the transaction has finished
 	// they'll apply the next time a commit happens.
-	if (view->instructions->length) {
+	if (view->swayc && view->swayc->instructions->length) {
 		if (view->swayc && container_is_floating(view->swayc)) {
 			view_update_size(view, xsurface->width, xsurface->height);
 		} else {
@@ -268,8 +260,17 @@ static void handle_commit(struct wl_listener *listener, void *data) {
 static void handle_unmap(struct wl_listener *listener, void *data) {
 	struct sway_xwayland_view *xwayland_view =
 		wl_container_of(listener, xwayland_view, unmap);
+	struct sway_view *view = &xwayland_view->view;
+
+	if (!sway_assert(view->surface, "Cannot unmap unmapped view")) {
+		return;
+	}
+
+	struct sway_container *parent = view_unmap(view);
+	arrange_and_commit(parent);
+
 	wl_list_remove(&xwayland_view->commit.link);
-	view_unmap(&xwayland_view->view);
+	view->surface = NULL;
 }
 
 static void handle_map(struct wl_listener *listener, void *data) {
@@ -293,12 +294,30 @@ static void handle_map(struct wl_listener *listener, void *data) {
 	if (xsurface->fullscreen) {
 		view_set_fullscreen(view, true);
 	}
-	arrange_and_commit(view->swayc);
+	arrange_and_commit(view->swayc->parent);
 }
 
 static void handle_destroy(struct wl_listener *listener, void *data) {
 	struct sway_xwayland_view *xwayland_view =
 		wl_container_of(listener, xwayland_view, destroy);
+	struct sway_view *view = &xwayland_view->view;
+
+	if (view->surface) {
+		struct sway_container *parent = view_unmap(view);
+		arrange_and_commit(parent);
+
+		wl_list_remove(&xwayland_view->commit.link);
+		view->surface = NULL;
+	}
+
+	wl_list_remove(&xwayland_view->destroy.link);
+	wl_list_remove(&xwayland_view->request_configure.link);
+	wl_list_remove(&xwayland_view->request_fullscreen.link);
+	wl_list_remove(&xwayland_view->set_title.link);
+	wl_list_remove(&xwayland_view->set_class.link);
+	wl_list_remove(&xwayland_view->set_window_type.link);
+	wl_list_remove(&xwayland_view->map.link);
+	wl_list_remove(&xwayland_view->unmap.link);
 	view_destroy(&xwayland_view->view);
 }
 

sway/main.c

@@ -34,6 +34,7 @@ struct sway_server server;
 void sway_terminate(int exit_code) {
 	terminate_request = true;
 	exit_value = exit_code;
+	server.terminating = true;
 	wl_display_terminate(server.wl_display);
 }
 

sway/server.c

@@ -19,6 +19,7 @@
 #include <wlr/util/log.h>
 // TODO WLR: make Xwayland optional
 #include <wlr/xwayland.h>
+#include "list.h"
 #include "sway/config.h"
 #include "sway/input/input-manager.h"
 #include "sway/server.h"
@@ -105,6 +106,8 @@ bool server_init(struct sway_server *server) {
 		return false;
 	}
 
+	server->destroying_containers = create_list();
+
 	input_manager = input_manager_create(server);
 	return true;
 }
@@ -112,6 +115,7 @@ bool server_init(struct sway_server *server) {
 void server_fini(struct sway_server *server) {
 	// TODO: free sway-specific resources
 	wl_display_destroy(server->wl_display);
+	list_free(server->destroying_containers);
 }
 
 void server_run(struct sway_server *server) {

sway/tree/arrange.c

@@ -144,6 +144,19 @@ static void apply_tabbed_or_stacked_layout(struct sway_container *parent) {
 	}
 }
 
+/**
+ * If a container has been deleted from the pending tree state, we must add it
+ * to the transaction so it can be freed afterwards. To do this, we iterate the
+ * server's destroying_containers list and add all of them. We may add more than
+ * what we need to, but this is easy and has no negative consequences.
+ */
+static void add_deleted_containers(struct sway_transaction *transaction) {
+	for (int i = 0; i < server.destroying_containers->length; ++i) {
+		struct sway_container *child = server.destroying_containers->items[i];
+		transaction_add_container(transaction, child);
+	}
+}
+
 static void arrange_children_of(struct sway_container *parent,
 		struct sway_transaction *transaction);
 
@@ -158,6 +171,7 @@ static void arrange_floating(struct sway_container *floating,
 		}
 		transaction_add_container(transaction, floater);
 	}
+	transaction_add_container(transaction, floating);
 }
 
 static void arrange_children_of(struct sway_container *parent,
@@ -290,8 +304,17 @@ void arrange_windows(struct sway_container *container,
 	case C_TYPES:
 		break;
 	}
+	// Add damage for whatever container arrange_windows() was called with,
+	// unless it was called with the special floating container, in which case
+	// we'll damage the entire output.
+	if (container->type == C_CONTAINER && container->layout == L_FLOATING) {
+		struct sway_container *output = container_parent(container, C_OUTPUT);
+		transaction_add_damage(transaction, container_get_box(output));
+	} else {
 		transaction_add_damage(transaction, container_get_box(container));
 	}
+	add_deleted_containers(transaction);
+}
 
 void arrange_and_commit(struct sway_container *container) {
 	struct sway_transaction *transaction = transaction_create();

sway/tree/container.c

@@ -16,7 +16,6 @@
 #include "sway/ipc-server.h"
 #include "sway/output.h"
 #include "sway/server.h"
-#include "sway/tree/arrange.h"
 #include "sway/tree/layout.h"
 #include "sway/tree/view.h"
 #include "sway/tree/workspace.h"
@@ -113,10 +112,11 @@ struct sway_container *container_create(enum sway_container_type type) {
 	c->layout = L_NONE;
 	c->type = type;
 	c->alpha = 1.0f;
+	c->instructions = create_list();
 
 	if (type != C_VIEW) {
 		c->children = create_list();
-		//c->pending.children = create_list();
+		c->current.children = create_list();
 	}
 
 	wl_signal_init(&c->events.destroy);
@@ -133,43 +133,68 @@ struct sway_container *container_create(enum sway_container_type type) {
 	return c;
 }
 
-static void _container_destroy(struct sway_container *cont) {
-	if (cont == NULL) {
-		return;
+static void container_workspace_free(struct sway_workspace *ws) {
+	list_foreach(ws->output_priority, free);
+	list_free(ws->output_priority);
+	ws->floating->destroying = true;
+	container_free(ws->floating);
+	free(ws);
 }
 
-	wl_signal_emit(&cont->events.destroy, cont);
-
-	struct sway_container *parent = cont->parent;
-	if (cont->children != NULL && cont->children->length) {
-		// remove children until there are no more, container_destroy calls
-		// container_remove_child, which removes child from this container
-		while (cont->children != NULL && cont->children->length > 0) {
-			struct sway_container *child = cont->children->items[0];
-			ipc_event_window(child, "close");
-			container_remove_child(child);
-			_container_destroy(child);
-		}
-	}
-	if (cont->marks) {
-		list_foreach(cont->marks, free);
-		list_free(cont->marks);
+void container_free(struct sway_container *cont) {
+	if (!sway_assert(cont->destroying,
+				"Tried to free container which wasn't marked as destroying")) {
+		return;
 	}
-	if (parent) {
-		parent = container_remove_child(cont);
+	if (!sway_assert(cont->instructions->length == 0,
+				"Tried to free container with pending instructions")) {
+		return;
 	}
-	if (cont->name) {
 	free(cont->name);
-	}
-
 	wlr_texture_destroy(cont->title_focused);
 	wlr_texture_destroy(cont->title_focused_inactive);
 	wlr_texture_destroy(cont->title_unfocused);
 	wlr_texture_destroy(cont->title_urgent);
 
+	for (int i = 0; i < server.destroying_containers->length; ++i) {
+		if (server.destroying_containers->items[i] == cont) {
+			list_del(server.destroying_containers, i);
+			break;
+		}
+	}
+
+	list_free(cont->instructions);
 	list_free(cont->children);
-	//list_free(cont->pending.children);
-	cont->children = NULL;
+	list_free(cont->current.children);
+
+	switch (cont->type) {
+	case C_ROOT:
+		break;
+	case C_OUTPUT:
+		cont->sway_output->swayc = NULL;
+		break;
+	case C_WORKSPACE:
+		container_workspace_free(cont->sway_workspace);
+		break;
+	case C_CONTAINER:
+		break;
+	case C_VIEW:
+		{
+			struct sway_view *view = cont->sway_view;
+			view->swayc = NULL;
+			free(view->title_format);
+			view->title_format = NULL;
+
+			if (view->destroying) {
+				view_free(view);
+			}
+		}
+		break;
+	case C_TYPES:
+		sway_assert(false, "Didn't expect to see C_TYPES here");
+		break;
+	}
+
 	free(cont);
 }
 
@@ -186,7 +211,6 @@ static struct sway_container *container_workspace_destroy(
 	}
 
 	wlr_log(L_DEBUG, "destroying workspace '%s'", workspace->name);
-	ipc_event_window(workspace, "close");
 
 	struct sway_container *parent = workspace->parent;
 	if (!workspace_is_empty(workspace) && output) {
@@ -209,25 +233,6 @@ static struct sway_container *container_workspace_destroy(
 			container_move_to(floating->children->items[i],
 					new_workspace->sway_workspace->floating);
 		}
-		arrange_and_commit(new_workspace);
-	}
-
-	struct sway_workspace *sway_workspace = workspace->sway_workspace;
-
-	// This emits the destroy event and also destroys the swayc.
-	_container_destroy(workspace);
-
-	// Clean up the floating container
-	sway_workspace->floating->parent = NULL;
-	_container_destroy(sway_workspace->floating);
-
-	list_foreach(sway_workspace->output_priority, free);
-	list_free(sway_workspace->output_priority);
-
-	free(sway_workspace);
-
-	if (output) {
-		output_damage_whole(output->sway_output);
 	}
 
 	return parent;
@@ -266,14 +271,13 @@ static struct sway_container *container_output_destroy(
 					container_add_child(new_output, workspace);
 					ipc_event_workspace(workspace, NULL, "move");
 				} else {
-					container_workspace_destroy(workspace);
+					container_destroy(workspace);
 				}
 
 				container_sort_workspaces(new_output);
 			}
 		}
 	}
-	arrange_and_commit(&root_container);
 
 	wl_list_remove(&output->sway_output->mode.link);
 	wl_list_remove(&output->sway_output->transform.link);
@@ -285,12 +289,8 @@ static struct sway_container *container_output_destroy(
 	output->sway_output->swayc = NULL;
 
 	wlr_log(L_DEBUG, "OUTPUT: Destroying output '%s'", output->name);
-	_container_destroy(output);
-	return &root_container;
-}
 
-static void container_root_finish(struct sway_container *con) {
-	wlr_log(L_ERROR, "TODO: destroy the root container");
+	return &root_container;
 }
 
 bool container_reap_empty(struct sway_container *con) {
@@ -306,13 +306,13 @@ bool container_reap_empty(struct sway_container *con) {
 	case C_WORKSPACE:
 		if (!workspace_is_visible(con) && workspace_is_empty(con)) {
 			wlr_log(L_DEBUG, "Destroying workspace via reaper");
-			container_workspace_destroy(con);
+			container_destroy(con);
 			return true;
 		}
 		break;
 	case C_CONTAINER:
 		if (con->children->length == 0) {
-			_container_destroy(con);
+			container_destroy(con);
 			return true;
 		}
 	case C_VIEW:
@@ -349,46 +349,48 @@ struct sway_container *container_flatten(struct sway_container *container) {
 	return container;
 }
 
+/**
+ * container_destroy() is the first step in destroying a container. We'll emit
+ * events, detach it from the tree and mark it as destroying. The container will
+ * remain in memory until it's no longer used by a transaction, then it will be
+ * freed via container_free().
+ */
 struct sway_container *container_destroy(struct sway_container *con) {
 	if (con == NULL) {
 		return NULL;
 	}
+	if (con->destroying) {
+		return NULL;
+	}
 
-	struct sway_container *parent = con->parent;
-
-	switch (con->type) {
-		case C_ROOT:
-			container_root_finish(con);
-			break;
-		case C_OUTPUT:
-			// dont try to reap the root after this
+	// The below functions move their children to somewhere else.
+	if (con->type == C_OUTPUT) {
 		container_output_destroy(con);
-			break;
-		case C_WORKSPACE:
-			// dont try to reap the output after this
-			container_workspace_destroy(con);
-			break;
-		case C_CONTAINER:
-			if (con->children->length) {
-				for (int i = 0; i < con->children->length; ++i) {
-					struct sway_container *child = con->children->items[0];
-					ipc_event_window(child, "close");
-					container_remove_child(child);
-					container_add_child(parent, child);
+	} else if (con->type == C_WORKSPACE) {
+		// Workspaces will refuse to be destroyed if they're the last workspace
+		// on their output.
+		if (!container_workspace_destroy(con)) {
+			return NULL;
 		}
 	}
-			ipc_event_window(con, "close");
-			_container_destroy(con);
-			break;
-		case C_VIEW:
-			_container_destroy(con);
-			break;
-		case C_TYPES:
-			wlr_log(L_ERROR, "container_destroy called on an invalid "
-				"container");
-			break;
+
+	// At this point the container being destroyed shouldn't have any children
+	// unless sway is terminating.
+	if (!server.terminating) {
+		if (!sway_assert(!con->children || con->children->length == 0,
+					"Didn't expect to see children here")) {
+			return NULL;
+		}
 	}
 
+	wl_signal_emit(&con->events.destroy, con);
+	ipc_event_window(con, "close");
+
+	struct sway_container *parent = container_remove_child(con);
+
+	con->destroying = true;
+	list_add(server.destroying_containers, con);
+
 	return container_reap_empty_recursive(parent);
 }
 

sway/tree/layout.c

@@ -30,7 +30,9 @@ void layout_init(void) {
 	root_container.type = C_ROOT;
 	root_container.layout = L_NONE;
 	root_container.name = strdup("root");
+	root_container.instructions = create_list();
 	root_container.children = create_list();
+	root_container.current.children = create_list();
 	wl_signal_init(&root_container.events.destroy);
 
 	root_container.sway_root = calloc(1, sizeof(*root_container.sway_root));

sway/tree/output.c

@@ -29,7 +29,6 @@ static void restore_workspaces(struct sway_container *output) {
 	}
 
 	container_sort_workspaces(output);
-	arrange_and_commit(&root_container);
 }
 
 struct sway_container *output_create(
@@ -66,7 +65,6 @@ struct sway_container *output_create(
 
 	struct sway_container *output = container_create(C_OUTPUT);
 	output->sway_output = sway_output;
-	sway_output->swayc = output;
 	output->name = strdup(name);
 	if (output->name == NULL) {
 		container_destroy(output);

sway/tree/view.c

@@ -25,47 +25,60 @@ void view_init(struct sway_view *view, enum sway_view_type type,
 	view->impl = impl;
 	view->executed_criteria = create_list();
 	view->marks = create_list();
-	view->instructions = create_list();
 	wl_signal_init(&view->events.unmap);
 }
 
-void view_destroy(struct sway_view *view) {
-	if (view == NULL) {
+void view_free(struct sway_view *view) {
+	if (!sway_assert(view->surface == NULL, "Tried to free mapped view")) {
 		return;
 	}
-
-	if (view->surface != NULL) {
-		view_unmap(view);
+	if (!sway_assert(view->destroying,
+				"Tried to free view which wasn't marked as destroying")) {
+		return;
 	}
-
-	if (!sway_assert(view->instructions->length == 0,
-				"Tried to destroy view with pending instructions")) {
+	if (!sway_assert(view->swayc == NULL,
+				"Tried to free view which still has a swayc "
+				"(might have a pending transaction?)")) {
 		return;
 	}
-
 	list_free(view->executed_criteria);
 
-	for (int i = 0; i < view->marks->length; ++i) {
-		free(view->marks->items[i]);
-	}
+	list_foreach(view->marks, free);
 	list_free(view->marks);
 
-	list_free(view->instructions);
-
 	wlr_texture_destroy(view->marks_focused);
 	wlr_texture_destroy(view->marks_focused_inactive);
 	wlr_texture_destroy(view->marks_unfocused);
 	wlr_texture_destroy(view->marks_urgent);
 
-	container_destroy(view->swayc);
-
-	if (view->impl->destroy) {
-		view->impl->destroy(view);
+	if (view->impl->free) {
+		view->impl->free(view);
 	} else {
 		free(view);
 	}
 }
 
+/**
+ * The view may or may not be involved in a transaction. For example, a view may
+ * unmap then attempt to destroy itself before we've applied the new layout. If
+ * an unmapping view is still involved in a transaction then it'll still have a
+ * swayc.
+ *
+ * If there's no transaction we can simply free the view. Otherwise the
+ * destroying flag will make the view get freed when the transaction is
+ * finished.
+ */
+void view_destroy(struct sway_view *view) {
+	if (!sway_assert(view->surface == NULL, "Tried to destroy a mapped view")) {
+		return;
+	}
+	view->destroying = true;
+
+	if (!view->swayc) {
+		view_free(view);
+	}
+}
+
 const char *view_get_title(struct sway_view *view) {
 	if (view->impl->get_string_prop) {
 		return view->impl->get_string_prop(view, VIEW_PROP_TITLE);
@@ -356,6 +369,9 @@ static void view_get_layout_box(struct sway_view *view, struct wlr_box *box) {
 
 void view_for_each_surface(struct sway_view *view,
 		wlr_surface_iterator_func_t iterator, void *user_data) {
+	if (!view->surface) {
+		return;
+	}
 	if (view->impl->for_each_surface) {
 		view->impl->for_each_surface(view, iterator, user_data);
 	} else {
@@ -523,11 +539,7 @@ void view_map(struct sway_view *view, struct wlr_surface *wlr_surface) {
 	view_handle_container_reparent(&view->container_reparent, NULL);
 }
 
-void view_unmap(struct sway_view *view) {
-	if (!sway_assert(view->surface != NULL, "cannot unmap unmapped view")) {
-		return;
-	}
-
+struct sway_container *view_unmap(struct sway_view *view) {
 	wl_signal_emit(&view->events.unmap, view);
 
 	if (view->is_fullscreen) {
@@ -535,22 +547,10 @@ void view_unmap(struct sway_view *view) {
 		ws->sway_workspace->fullscreen = NULL;
 	}
 
-	container_damage_whole(view->swayc);
-
 	wl_list_remove(&view->surface_new_subsurface.link);
 	wl_list_remove(&view->container_reparent.link);
 
-	struct sway_container *parent = container_destroy(view->swayc);
-
-	view->swayc = NULL;
-	view->surface = NULL;
-
-	if (view->title_format) {
-		free(view->title_format);
-		view->title_format = NULL;
-	}
-
-	arrange_and_commit(parent);
+	return container_destroy(view->swayc);
 }
 
 void view_update_position(struct sway_view *view, double lx, double ly) {
@@ -924,7 +924,7 @@ void view_update_marks_textures(struct sway_view *view) {
 }
 
 bool view_is_visible(struct sway_view *view) {
-	if (!view->swayc) {
+	if (!view->swayc || view->swayc->destroying) {
 		return false;
 	}
 	struct sway_container *workspace =

sway/tree/workspace.c

@@ -430,6 +430,9 @@ bool workspace_switch(struct sway_container *workspace) {
 }
 
 bool workspace_is_visible(struct sway_container *ws) {
+	if (ws->destroying) {
+		return false;
+	}
 	struct sway_container *output = container_parent(ws, C_OUTPUT);
 	struct sway_seat *seat = input_manager_current_seat(input_manager);
 	struct sway_container *focus = seat_get_focus_inactive(seat, output);