Merge pull request #2540 from RyanDwyer/typesafety

Implement type safe arguments and demote sway_container

1 files changed, 418 insertions, 469 deletions

diff --git a/sway/commands/move.c b/sway/commands/move.c
index 4426f24e..7b503624 100644
--- a/sway/commands/move.c
+++ b/sway/commands/move.c
@@ -40,8 +40,8 @@ enum wlr_direction opposite_direction(enum wlr_direction d) {
 	}
 }
 
-static struct sway_container *output_in_direction(const char *direction_string,
-		struct wlr_output *reference, int ref_lx, int ref_ly) {
+static struct sway_output *output_in_direction(const char *direction_string,
+		struct sway_output *reference, int ref_lx, int ref_ly) {
 	struct {
 		char *name;
 		enum wlr_direction direction;
@@ -61,449 +61,370 @@ static struct sway_container *output_in_direction(const char *direction_string,
 		}
 	}
 
-	if (direction) {
+	if (reference && direction) {
 		struct wlr_output *target = wlr_output_layout_adjacent_output(
-				root_container.sway_root->output_layout,
-				direction, reference, ref_lx, ref_ly);
+				root->output_layout, direction, reference->wlr_output,
+				ref_lx, ref_ly);
 
 		if (!target) {
 			target = wlr_output_layout_farthest_output(
-					root_container.sway_root->output_layout,
-					opposite_direction(direction), reference, ref_lx, ref_ly);
+					root->output_layout, opposite_direction(direction),
+					reference->wlr_output, ref_lx, ref_ly);
 		}
 
 		if (target) {
-			struct sway_output *sway_output = target->data;
-			return sway_output->swayc;
+			return target->data;
 		}
 	}
 
 	return output_by_name(direction_string);
 }
 
-static void container_move_to(struct sway_container *container,
-		struct sway_container *destination) {
-	if (!sway_assert(container->type == C_CONTAINER ||
-				container->type == C_VIEW, "Expected a container or view")) {
-		return;
+static bool is_parallel(enum sway_container_layout layout,
+		enum movement_direction dir) {
+	switch (layout) {
+	case L_TABBED:
+	case L_HORIZ:
+		return dir == MOVE_LEFT || dir == MOVE_RIGHT;
+	case L_STACKED:
+	case L_VERT:
+		return dir == MOVE_UP || dir == MOVE_DOWN;
+	default:
+		return false;
 	}
-	if (container == destination
-			|| container_has_ancestor(container, destination)) {
+}
+
+/**
+ * Ensures all seats focus the fullscreen container if needed.
+ */
+static void workspace_focus_fullscreen(struct sway_workspace *workspace) {
+	if (!workspace->fullscreen) {
 		return;
 	}
-	struct sway_container *old_parent = NULL;
-	struct sway_container *new_parent = NULL;
-	if (container_is_floating(container)) {
-		// Resolve destination into a workspace
-		struct sway_container *new_ws = NULL;
-		if (destination->type == C_OUTPUT) {
-			new_ws = output_get_active_workspace(destination->sway_output);
-		} else if (destination->type == C_WORKSPACE) {
-			new_ws = destination;
-		} else {
-			new_ws = container_parent(destination, C_WORKSPACE);
+	struct sway_seat *seat;
+	struct sway_workspace *focus_ws;
+	wl_list_for_each(seat, &input_manager->seats, link) {
+		focus_ws = seat_get_focused_workspace(seat);
+		if (focus_ws == workspace) {
+			struct sway_node *new_focus =
+				seat_get_focus_inactive(seat, &workspace->fullscreen->node);
+			seat_set_focus(seat, new_focus);
 		}
-		if (!new_ws) {
-			// This can happen if the user has run "move container to mark foo",
-			// where mark foo is on a hidden scratchpad container.
-			return;
+	}
+}
+
+static void container_move_to_container_from_direction(
+		struct sway_container *container, struct sway_container *destination,
+		enum movement_direction move_dir) {
+	if (destination->view) {
+		if (destination->parent == container->parent) {
+			wlr_log(WLR_DEBUG, "Swapping siblings");
+			list_t *siblings = container_get_siblings(container);
+			int container_index = list_find(siblings, container);
+			int destination_index = list_find(siblings, destination);
+			list_swap(siblings, container_index, destination_index);
+		} else {
+			wlr_log(WLR_DEBUG, "Promoting to sibling of cousin");
+			int offset = move_dir == MOVE_LEFT || move_dir == MOVE_UP;
+			int index = container_sibling_index(destination) + offset;
+			if (destination->parent) {
+				container_insert_child(destination->parent, container, index);
+			} else {
+				workspace_insert_tiling(destination->workspace,
+						container, index);
+			}
+			container->width = container->height = 0;
 		}
-		struct sway_container *old_output =
-			container_parent(container, C_OUTPUT);
-		old_parent = container_remove_child(container);
-		workspace_add_floating(new_ws, container);
-		container_handle_fullscreen_reparent(container, old_parent);
+		return;
+	}
+
+	if (is_parallel(destination->layout, move_dir)) {
+		wlr_log(WLR_DEBUG, "Reparenting container (parallel)");
+		int index = move_dir == MOVE_RIGHT || move_dir == MOVE_DOWN ?
+			0 : destination->children->length;
+		container_insert_child(destination, container, index);
+		container->width = container->height = 0;
+		return;
+	}
+
+	wlr_log(WLR_DEBUG, "Reparenting container (perpendicular)");
+	struct sway_node *focus_inactive = seat_get_active_child(
+			config->handler_context.seat, &destination->node);
+	if (!focus_inactive || focus_inactive == &destination->node) {
+		// The container has no children
+		container_add_child(destination, container);
+		return;
+	}
+
+	// Try again but with the child
+	container_move_to_container_from_direction(container,
+			focus_inactive->sway_container, move_dir);
+}
+
+static void container_move_to_workspace_from_direction(
+		struct sway_container *container, struct sway_workspace *workspace,
+		enum movement_direction move_dir) {
+	if (is_parallel(workspace->layout, move_dir)) {
+		wlr_log(WLR_DEBUG, "Reparenting container (parallel)");
+		int index = move_dir == MOVE_RIGHT || move_dir == MOVE_DOWN ?
+			0 : workspace->tiling->length;
+		workspace_insert_tiling(workspace, container, index);
+		return;
+	}
+
+	wlr_log(WLR_DEBUG, "Reparenting container (perpendicular)");
+	struct sway_container *focus_inactive = seat_get_focus_inactive_tiling(
+			config->handler_context.seat, workspace);
+	if (!focus_inactive) {
+		// The workspace has no tiling children
+		workspace_add_tiling(workspace, container);
+		return;
+	}
+	while (focus_inactive->parent) {
+		focus_inactive = focus_inactive->parent;
+	}
+	container_move_to_container_from_direction(container, focus_inactive,
+			move_dir);
+}
+
+static void container_move_to_workspace(struct sway_container *container,
+		struct sway_workspace *workspace) {
+	if (container->workspace == workspace) {
+		return;
+	}
+	struct sway_workspace *old_workspace = container->workspace;
+	if (container_is_floating(container)) {
+		struct sway_output *old_output = container->workspace->output;
+		container_detach(container);
+		workspace_add_floating(workspace, container);
+		container_handle_fullscreen_reparent(container);
 		// If changing output, center it within the workspace
-		if (old_output != new_ws->parent && !container->is_fullscreen) {
+		if (old_output != workspace->output && !container->is_fullscreen) {
 			container_floating_move_to_center(container);
 		}
 	} else {
-		old_parent = container_remove_child(container);
+		container_detach(container);
 		container->width = container->height = 0;
 		container->saved_width = container->saved_height = 0;
-
-		if (destination->type == C_VIEW) {
-			new_parent = container_add_sibling(destination, container);
-		} else {
-			new_parent = destination;
-			container_add_child(destination, container);
-		}
+		workspace_add_tiling(workspace, container);
+		container_update_representation(container);
 	}
-
-	if (container->type == C_VIEW) {
+	if (container->view) {
 		ipc_event_window(container, "move");
 	}
-	container_notify_subtree_changed(old_parent);
-	container_notify_subtree_changed(new_parent);
-
-	// If view was moved to a fullscreen workspace, refocus the fullscreen view
-	struct sway_container *new_workspace = container;
-	if (new_workspace->type != C_WORKSPACE) {
-		new_workspace = container_parent(new_workspace, C_WORKSPACE);
-	}
-	if (new_workspace->sway_workspace->fullscreen) {
-		struct sway_seat *seat;
-		struct sway_container *focus, *focus_ws;
-		wl_list_for_each(seat, &input_manager->seats, link) {
-			focus = seat_get_focus(seat);
-			focus_ws = focus;
-			if (focus_ws->type != C_WORKSPACE) {
-				focus_ws = container_parent(focus_ws, C_WORKSPACE);
-			}
-			if (focus_ws == new_workspace) {
-				struct sway_container *new_focus = seat_get_focus_inactive(seat,
-						new_workspace->sway_workspace->fullscreen);
-				seat_set_focus(seat, new_focus);
-			}
-		}
+	workspace_detect_urgent(old_workspace);
+	workspace_detect_urgent(workspace);
+	workspace_focus_fullscreen(workspace);
+}
+
+static void container_move_to_container(struct sway_container *container,
+		struct sway_container *destination) {
+	if (container == destination
+			|| container_has_ancestor(container, destination)
+			|| container_has_ancestor(destination, container)) {
+		return;
 	}
-	// Update workspace urgent state
-	struct sway_container *old_workspace = old_parent;
-	if (old_workspace->type != C_WORKSPACE) {
-		old_workspace = container_parent(old_workspace, C_WORKSPACE);
-	}
-	if (new_workspace != old_workspace) {
-		workspace_detect_urgent(new_workspace);
-		if (old_workspace) {
-			workspace_detect_urgent(old_workspace);
-		}
+	if (container_is_floating(container)) {
+		return;
 	}
-}
+	struct sway_workspace *old_workspace = container->workspace;
 
-static bool is_parallel(enum sway_container_layout layout,
-		enum movement_direction dir) {
-	switch (layout) {
-	case L_TABBED:
-	case L_HORIZ:
-		return dir == MOVE_LEFT || dir == MOVE_RIGHT;
-	case L_STACKED:
-	case L_VERT:
-		return dir == MOVE_UP || dir == MOVE_DOWN;
-	default:
-		return false;
+	container_detach(container);
+	container->width = container->height = 0;
+	container->saved_width = container->saved_height = 0;
+
+	if (destination->view) {
+		container_add_sibling(destination, container);
+	} else {
+		container_add_child(destination, container);
 	}
-}
 
-static enum movement_direction invert_movement(enum movement_direction dir) {
-	switch (dir) {
-	case MOVE_LEFT:
-		return MOVE_RIGHT;
-	case MOVE_RIGHT:
-		return MOVE_LEFT;
-	case MOVE_UP:
-		return MOVE_DOWN;
-	case MOVE_DOWN:
-		return MOVE_UP;
-	default:
-		sway_assert(0, "This function expects left|right|up|down");
-		return MOVE_LEFT;
+	if (container->view) {
+		ipc_event_window(container, "move");
 	}
-}
 
-static int move_offs(enum movement_direction move_dir) {
-	return move_dir == MOVE_LEFT || move_dir == MOVE_UP ? -1 : 1;
-}
+	workspace_focus_fullscreen(destination->workspace);
 
-/* Gets the index of the most extreme member based on the movement offset */
-static int container_limit(struct sway_container *container,
-		enum movement_direction move_dir) {
-	return move_offs(move_dir) < 0 ? 0 : container->children->length;
+	// Update workspace urgent state
+	workspace_detect_urgent(destination->workspace);
+	if (old_workspace && old_workspace != destination->workspace) {
+		workspace_detect_urgent(old_workspace);
+	}
 }
 
 /* Takes one child, sets it aside, wraps the rest of the children in a new
  * container, switches the layout of the workspace, and drops the child back in.
  * In other words, rejigger it. */
-static void workspace_rejigger(struct sway_container *ws,
+static void workspace_rejigger(struct sway_workspace *ws,
 		struct sway_container *child, enum movement_direction move_dir) {
-	struct sway_container *original_parent = child->parent;
-	struct sway_container *new_parent =
-		container_split(ws, ws->layout);
-
-	container_remove_child(child);
-	for (int i = 0; i < ws->children->length; ++i) {
-		struct sway_container *_child = ws->children->items[i];
-		container_move_to(new_parent, _child);
+	if (!sway_assert(child->parent == NULL, "Expected a root child")) {
+		return;
 	}
+	container_detach(child);
+	workspace_wrap_children(ws);
 
-	int index = move_offs(move_dir);
-	container_insert_child(ws, child, index < 0 ? 0 : 1);
+	int index = move_dir == MOVE_LEFT || move_dir == MOVE_UP ? 0 : 1;
+	workspace_insert_tiling(ws, child, index);
 	ws->layout =
 		move_dir == MOVE_LEFT || move_dir == MOVE_RIGHT ? L_HORIZ : L_VERT;
-
-	container_flatten(ws);
-	container_reap_empty(original_parent);
-	container_create_notify(new_parent);
+	workspace_update_representation(ws);
 }
 
 static void move_out_of_tabs_stacks(struct sway_container *container,
 		struct sway_container *current, enum movement_direction move_dir,
 		int offs) {
-	if (container->parent == current->parent
-			&& current->parent->children->length == 1) {
-		wlr_log(WLR_DEBUG, "Changing layout of %zd", current->parent->id);
-		current->parent->layout = move_dir ==
-			MOVE_LEFT || move_dir == MOVE_RIGHT ? L_HORIZ : L_VERT;
+	enum sway_container_layout layout = move_dir ==
+		MOVE_LEFT || move_dir == MOVE_RIGHT ? L_HORIZ : L_VERT;
+	list_t *siblings = container_get_siblings(container);
+	if (container == current && siblings->length == 1) {
+		wlr_log(WLR_DEBUG, "Changing layout of parent");
+		if (container->parent) {
+			container->parent->layout = layout;
+			container_update_representation(container);
+		} else {
+			container->workspace->layout = layout;
+			workspace_update_representation(container->workspace);
+		}
 		return;
 	}
 
 	wlr_log(WLR_DEBUG, "Moving out of tab/stack into a split");
-	bool is_workspace = current->parent->type == C_WORKSPACE;
-	struct sway_container *new_parent = container_split(current->parent,
-		move_dir == MOVE_LEFT || move_dir == MOVE_RIGHT ? L_HORIZ : L_VERT);
-	if (is_workspace) {
-		container_insert_child(new_parent->parent, container, offs < 0 ? 0 : 1);
-	} else {
+	if (container->parent) {
+		struct sway_container *new_parent =
+			container_split(current->parent, layout);
 		container_insert_child(new_parent, container, offs < 0 ? 0 : 1);
-		container_reap_empty(new_parent->parent);
-		container_flatten(new_parent->parent);
+		container_reap_empty(new_parent);
+		container_flatten(new_parent);
+	} else {
+		// Changing a workspace
+		struct sway_workspace *workspace = container->workspace;
+		workspace_split(workspace, layout);
+		workspace_insert_tiling(workspace, container, offs < 0 ? 0 : 1);
 	}
-	container_create_notify(new_parent);
-	container_notify_subtree_changed(new_parent);
 }
 
-static void container_move(struct sway_container *container,
-		enum movement_direction move_dir, int move_amt) {
-	if (!sway_assert(
-				container->type != C_CONTAINER || container->type != C_VIEW,
-				"Can only move containers and views")) {
-		return;
-	}
-	int offs = move_offs(move_dir);
-
-	struct sway_container *sibling = NULL;
-	struct sway_container *current = container;
-	struct sway_container *parent = current->parent;
-	struct sway_container *top = &root_container;
-
+// Returns true if moved
+static bool container_move_in_direction(struct sway_container *container,
+		enum movement_direction move_dir) {
 	// If moving a fullscreen view, only consider outputs
 	if (container->is_fullscreen) {
-		current = container_parent(container, C_OUTPUT);
-	} else if (container_is_fullscreen_or_child(container) ||
-			container_is_floating_or_child(container)) {
-		// If we've fullscreened a split container, only allow the child to move
-		// around within the fullscreen parent.
-		// Same with floating a split container.
-		struct sway_container *ws = container_parent(container, C_WORKSPACE);
-		top = ws->sway_workspace->fullscreen;
-	}
-
-	struct sway_container *new_parent = container_flatten(parent);
-	if (new_parent != parent) {
-		// Special case: we were the last one in this container, so leave
-		return;
+		struct sway_output *new_output =
+			output_get_in_direction(container->workspace->output, move_dir);
+		if (!new_output) {
+			return false;
+		}
+		struct sway_workspace *ws = output_get_active_workspace(new_output);
+		container_move_to_workspace(container, ws);
+		return true;
 	}
 
-	while (!sibling) {
-		if (current == top) {
-			return;
+	// If container is in a split container by itself, move out of the split
+	if (container->parent) {
+		struct sway_container *new_parent =
+			container_flatten(container->parent);
+		if (new_parent != container->parent) {
+			return true;
 		}
+	}
 
-		parent = current->parent;
-		wlr_log(WLR_DEBUG, "Visiting %p %s '%s'", current,
-				container_type_to_str(current->type), current->name);
-
-		int index = container_sibling_index(current);
-
-		switch (current->type) {
-		case C_OUTPUT: {
-			enum wlr_direction wlr_dir = 0;
-			if (!sway_assert(sway_dir_to_wlr(move_dir, &wlr_dir),
-						"got invalid direction: %d", move_dir)) {
-				return;
-			}
-			double ref_lx = current->x + current->width / 2;
-			double ref_ly = current->y + current->height / 2;
-			struct wlr_output *next = wlr_output_layout_adjacent_output(
-				root_container.sway_root->output_layout, wlr_dir,
-				current->sway_output->wlr_output, ref_lx, ref_ly);
-			if (!next) {
-				wlr_log(WLR_DEBUG, "Hit edge of output, nowhere else to go");
-				return;
-			}
-			struct sway_output *next_output = next->data;
-			current = next_output->swayc;
-			wlr_log(WLR_DEBUG, "Selected next output (%s)", current->name);
-			// Select workspace and get outta here
-			current = seat_get_focus_inactive(
-					config->handler_context.seat, current);
-			if (current->type != C_WORKSPACE) {
-				current = container_parent(current, C_WORKSPACE);
-			}
-			sibling = current;
-			break;
-		}
-		case C_WORKSPACE:
-			if (!is_parallel(current->layout, move_dir)) {
-				if (current->children->length >= 2) {
-					wlr_log(WLR_DEBUG, "Rejiggering the workspace (%d kiddos)",
-							current->children->length);
-					workspace_rejigger(current, container, move_dir);
-					return;
-				} else {
-					wlr_log(WLR_DEBUG, "Selecting output");
-					current = current->parent;
-				}
-			} else if (current->layout == L_TABBED
-					|| current->layout == L_STACKED) {
-				wlr_log(WLR_DEBUG, "Rejiggering out of tabs/stacks");
-				workspace_rejigger(current, container, move_dir);
-			} else {
-				wlr_log(WLR_DEBUG, "Selecting output");
-				current = current->parent;
-			}
-			break;
-		case C_CONTAINER:
-		case C_VIEW:
-			if (is_parallel(parent->layout, move_dir)) {
-				if ((index == parent->children->length - 1 && offs > 0)
-						|| (index == 0 && offs < 0)) {
-					if (current->parent == container->parent) {
-						if (!parent->is_fullscreen &&
-								(parent->layout == L_TABBED ||
-								 parent->layout == L_STACKED)) {
-							move_out_of_tabs_stacks(container, current,
-									move_dir, offs);
-							return;
-						} else {
-							wlr_log(WLR_DEBUG, "Hit limit, selecting parent");
-							current = current->parent;
-						}
+	// Look for a suitable *container* sibling or parent.
+	// The below loop stops once we hit the workspace because current->parent
+	// is NULL for the topmost containers in a workspace.
+	struct sway_container *current = container;
+	int offs = move_dir == MOVE_LEFT || move_dir == MOVE_UP ? -1 : 1;
+
+	while (current) {
+		struct sway_container *parent = current->parent;
+		list_t *siblings = container_get_siblings(current);
+		enum sway_container_layout layout = container_parent_layout(current);
+		int index = list_find(siblings, current);
+		int desired = index + offs;
+
+		if (is_parallel(layout, move_dir)) {
+			if (desired == -1 || desired == siblings->length) {
+				if (current->parent == container->parent) {
+					if (!(parent && parent->is_fullscreen) &&
+							(layout == L_TABBED || layout == L_STACKED)) {
+						move_out_of_tabs_stacks(container, current,
+								move_dir, offs);
+						return true;
 					} else {
-						wlr_log(WLR_DEBUG, "Hit limit, "
-								"promoting descendant to sibling");
-						// Special case
+						current = current->parent;
+						continue;
+					}
+				} else {
+					// Special case
+					if (current->parent) {
 						container_insert_child(current->parent, container,
 								index + (offs < 0 ? 0 : 1));
-						container->width = container->height = 0;
-						return;
+					} else {
+						workspace_insert_tiling(current->workspace, container,
+								index + (offs < 0 ? 0 : 1));
 					}
-				} else {
-					sibling = parent->children->items[index + offs];
-					wlr_log(WLR_DEBUG, "Selecting sibling id:%zd", sibling->id);
+					return true;
 				}
-			} else if (!parent->is_fullscreen && (parent->layout == L_TABBED ||
-						parent->layout == L_STACKED)) {
-				move_out_of_tabs_stacks(container, current, move_dir, offs);
-				return;
 			} else {
-				wlr_log(WLR_DEBUG, "Moving up to find a parallel container");
-				current = current->parent;
+				// Container can move within its siblings
+				container_move_to_container_from_direction(container,
+						siblings->items[desired], move_dir);
+				return true;
 			}
-			break;
-		default:
-			sway_assert(0, "Not expecting to see container of type %s here",
-					container_type_to_str(current->type));
-			return;
+		} else if (!(parent && parent->is_fullscreen) &&
+				(layout == L_TABBED || layout == L_STACKED)) {
+			move_out_of_tabs_stacks(container, current, move_dir, offs);
+			return true;
 		}
-	}
 
-	// Part two: move stuff around
-	int index = container_sibling_index(container);
-	struct sway_container *old_parent = container->parent;
+		current = current->parent;
 
-	while (sibling) {
-		switch (sibling->type) {
-		case C_VIEW:
-			if (sibling->parent == container->parent) {
-				wlr_log(WLR_DEBUG, "Swapping siblings");
-				sibling->parent->children->items[index + offs] = container;
-				sibling->parent->children->items[index] = sibling;
-			} else {
-				wlr_log(WLR_DEBUG, "Promoting to sibling of cousin");
-				container_insert_child(sibling->parent, container,
-						container_sibling_index(sibling) + (offs > 0 ? 0 : 1));
-				container->width = container->height = 0;
-			}
-			sibling = NULL;
-			break;
-		case C_WORKSPACE: // Note: only in the case of moving between outputs
-		case C_CONTAINER:
-			if (is_parallel(sibling->layout, move_dir)) {
-				int limit = container_limit(sibling, invert_movement(move_dir));
-				wlr_log(WLR_DEBUG, "limit: %d", limit);
-				wlr_log(WLR_DEBUG,
-						"Reparenting container (parallel) to index %d "
-						"(move dir: %d)", limit, move_dir);
-				container_insert_child(sibling, container, limit);
-				container->width = container->height = 0;
-				sibling = NULL;
-			} else {
-				wlr_log(WLR_DEBUG, "Reparenting container (perpendicular)");
-				struct sway_container *focus_inactive = seat_get_focus_inactive(
-						config->handler_context.seat, sibling);
-				if (focus_inactive && focus_inactive != sibling) {
-					while (focus_inactive->parent != sibling) {
-						focus_inactive = focus_inactive->parent;
-					}
-					wlr_log(WLR_DEBUG, "Focus inactive: id:%zd",
-							focus_inactive->id);
-					sibling = focus_inactive;
-					continue;
-				} else if (sibling->children->length) {
-					wlr_log(WLR_DEBUG, "No focus-inactive, adding arbitrarily");
-					container_remove_child(container);
-					container_add_sibling(sibling->children->items[0], container);
-				} else {
-					wlr_log(WLR_DEBUG, "No kiddos, adding container alone");
-					container_remove_child(container);
-					container_add_child(sibling, container);
-				}
-				container->width = container->height = 0;
-				sibling = NULL;
-			}
-			break;
-		default:
-			sway_assert(0, "Not expecting to see container of type %s here",
-					container_type_to_str(sibling->type));
-			return;
+		// Don't allow containers to move out of their
+		// fullscreen or floating parent
+		if (current &&
+				(current->is_fullscreen || container_is_floating(current))) {
+			return false;
 		}
 	}
 
-	container_notify_subtree_changed(old_parent);
-	container_notify_subtree_changed(container->parent);
-
-	if (container->type == C_VIEW) {
-		ipc_event_window(container, "move");
-	}
-
-	if (old_parent) {
-		seat_set_focus(config->handler_context.seat, old_parent);
-		seat_set_focus(config->handler_context.seat, container);
+	// Maybe rejigger the workspace
+	struct sway_workspace *ws = container->workspace;
+	if (!is_parallel(ws->layout, move_dir)) {
+		if (ws->tiling->length >= 2) {
+			workspace_rejigger(ws, container, move_dir);
+			return true;
+		}
+	} else if (ws->layout == L_TABBED || ws->layout == L_STACKED) {
+		workspace_rejigger(ws, container, move_dir);
+		return true;
 	}
 
-	struct sway_container *last_ws = old_parent;
-	struct sway_container *next_ws = container->parent;
-	if (last_ws && last_ws->type != C_WORKSPACE) {
-		last_ws = container_parent(last_ws, C_WORKSPACE);
+	// Try adjacent output
+	struct sway_output *output =
+		output_get_in_direction(container->workspace->output, move_dir);
+	if (output) {
+		struct sway_workspace *ws = output_get_active_workspace(output);
+		container_move_to_workspace_from_direction(container, ws, move_dir);
+		return true;
 	}
-	if (next_ws && next_ws->type != C_WORKSPACE) {
-		next_ws = container_parent(next_ws, C_WORKSPACE);
-	}
-	if (last_ws && next_ws && last_ws != next_ws) {
-		ipc_event_workspace(last_ws, next_ws, "focus");
-		workspace_detect_urgent(last_ws);
-		workspace_detect_urgent(next_ws);
-	}
-	container_end_mouse_operation(container);
+	wlr_log(WLR_DEBUG, "Hit edge of output, nowhere else to go");
+	return false;
 }
 
-static struct cmd_results *cmd_move_container(struct sway_container *current,
-		int argc, char **argv) {
+static struct cmd_results *cmd_move_container(int argc, char **argv) {
 	struct cmd_results *error = NULL;
 	if ((error = checkarg(argc, "move container/window",
 				EXPECTED_AT_LEAST, 3))) {
 		return error;
 	}
 
-	if (current->type == C_WORKSPACE) {
-		if (current->children->length == 0) {
+	struct sway_node *node = config->handler_context.node;
+	struct sway_workspace *workspace = config->handler_context.workspace;
+	struct sway_container *container = config->handler_context.container;
+	if (node->type == N_WORKSPACE) {
+		if (workspace->tiling->length == 0) {
 			return cmd_results_new(CMD_FAILURE, "move",
 					"Can't move an empty workspace");
 		}
-		current = workspace_wrap_children(current);
-	} else if (current->type != C_CONTAINER && current->type != C_VIEW) {
-		return cmd_results_new(CMD_FAILURE, "move",
-				"Can only move containers and views.");
+		container = workspace_wrap_children(workspace);
 	}
 
 	bool no_auto_back_and_forth = false;
@@ -530,15 +451,15 @@ static struct cmd_results *cmd_move_container(struct sway_container *current,
 	}
 
 	struct sway_seat *seat = config->handler_context.seat;
-	struct sway_container *old_parent = current->parent;
-	struct sway_container *old_ws = container_parent(current, C_WORKSPACE);
-	struct sway_container *old_output = container_parent(current, C_OUTPUT);
-	struct sway_container *destination = NULL;
+	struct sway_container *old_parent = container->parent;
+	struct sway_workspace *old_ws = container->workspace;
+	struct sway_output *old_output = old_ws ? old_ws->output : NULL;
+	struct sway_node *destination = NULL;
 
 	// determine destination
 	if (strcasecmp(argv[1], "workspace") == 0) {
 		// move container to workspace x
-		struct sway_container *ws = NULL;
+		struct sway_workspace *ws = NULL;
 		char *ws_name = NULL;
 		if (strcasecmp(argv[2], "next") == 0 ||
 				strcasecmp(argv[2], "prev") == 0 ||
@@ -576,7 +497,8 @@ static struct cmd_results *cmd_move_container(struct sway_container *current,
 			if (!no_auto_back_and_forth && config->auto_back_and_forth &&
 					prev_workspace_name) {
 				// auto back and forth move
-				if (old_ws->name && strcmp(old_ws->name, ws_name) == 0) {
+				if (old_ws && old_ws->name &&
+						strcmp(old_ws->name, ws_name) == 0) {
 					// if target workspace is the current one
 					free(ws_name);
 					ws_name = strdup(prev_workspace_name);
@@ -588,8 +510,8 @@ static struct cmd_results *cmd_move_container(struct sway_container *current,
 			// We have to create the workspace, but if the container is
 			// sticky and the workspace is going to be created on the same
 			// output, we'll bail out first.
-			if (current->is_sticky) {
-				struct sway_container *new_output =
+			if (container->is_sticky) {
+				struct sway_output *new_output =
 					workspace_get_initial_output(ws_name);
 				if (old_output == new_output) {
 					free(ws_name);
@@ -601,105 +523,119 @@ static struct cmd_results *cmd_move_container(struct sway_container *current,
 			ws = workspace_create(NULL, ws_name);
 		}
 		free(ws_name);
-		destination = seat_get_focus_inactive(seat, ws);
+		destination = seat_get_focus_inactive(seat, &ws->node);
 	} else if (strcasecmp(argv[1], "output") == 0) {
-		struct sway_container *dest_output = output_in_direction(argv[2],
-				old_output->sway_output->wlr_output, current->x, current->y);
-		if (!dest_output) {
+		struct sway_output *new_output = output_in_direction(argv[2],
+				old_output, container->x, container->y);
+		if (!new_output) {
 			return cmd_results_new(CMD_FAILURE, "move workspace",
 				"Can't find output with name/direction '%s'", argv[2]);
 		}
-		destination = seat_get_focus_inactive(seat, dest_output);
-		if (!destination) {
-			// We've never been to this output before
-			destination = dest_output->children->items[0];
-		}
+		destination = seat_get_focus_inactive(seat, &new_output->node);
 	} else if (strcasecmp(argv[1], "mark") == 0) {
 		struct sway_view *dest_view = view_find_mark(argv[2]);
 		if (dest_view == NULL) {
 			return cmd_results_new(CMD_FAILURE, "move",
 					"Mark '%s' not found", argv[2]);
 		}
-		destination = dest_view->swayc;
+		destination = &dest_view->container->node;
 	} else {
 		return cmd_results_new(CMD_INVALID, "move", expected_syntax);
 	}
 
-	struct sway_container *new_output = destination->type == C_OUTPUT ?
-		destination : container_parent(destination, C_OUTPUT);
-	if (current->is_sticky && old_output == new_output) {
+	if (container->is_sticky && old_output &&
+			node_has_ancestor(destination, &old_output->node)) {
 		return cmd_results_new(CMD_FAILURE, "move", "Can't move sticky "
 				"container to another workspace on the same output");
 	}
 
-	struct sway_container *new_output_last_ws = old_output == new_output ?
-		NULL : seat_get_active_child(seat, new_output);
-	struct sway_container *new_workspace = destination->type == C_WORKSPACE ?
-		destination : container_parent(destination, C_WORKSPACE);
+	struct sway_output *new_output = node_get_output(destination);
+	struct sway_workspace *new_output_last_ws = old_output == new_output ?
+		NULL : output_get_active_workspace(new_output);
 
 	// move container, arrange windows and return focus
-	container_move_to(current, destination);
+	if (container->scratchpad) {
+		root_scratchpad_remove_container(container);
+	}
+	switch (destination->type) {
+	case N_WORKSPACE:
+		container_move_to_workspace(container, destination->sway_workspace);
+		break;
+	case N_OUTPUT: {
+			struct sway_output *output = destination->sway_output;
+			struct sway_workspace *ws = output_get_active_workspace(output);
+			container_move_to_workspace(container, ws);
+		}
+		break;
+	case N_CONTAINER:
+		container_move_to_container(container, destination->sway_container);
+		break;
+	case N_ROOT:
+		break;
+	}
+	struct sway_workspace *new_workspace =
+		output_get_active_workspace(new_output);
 	if (new_output_last_ws && new_output_last_ws != new_workspace) {
 		// change focus on destination output back to its last active workspace
-		struct sway_container *new_output_last_focus =
-			seat_get_focus_inactive(seat, new_output_last_ws);
+		struct sway_node *new_output_last_focus =
+			seat_get_focus_inactive(seat, &new_output_last_ws->node);
 		seat_set_focus_warp(seat, new_output_last_focus, false, false);
 	}
-	struct sway_container *focus = seat_get_focus_inactive(seat, old_parent);
+
+	struct sway_node *focus = NULL;
+	if (old_parent) {
+		focus = seat_get_focus_inactive(seat, &old_parent->node);
+	} else if (old_ws) {
+		focus = seat_get_focus_inactive(seat, &old_ws->node);
+	}
 	seat_set_focus_warp(seat, focus, true, false);
-	container_reap_empty(old_parent);
-	container_reap_empty(destination->parent);
 
-	// TODO: Ideally we would arrange the surviving parent after reaping,
-	// but container_reap_empty does not return it, so we arrange the
-	// workspace instead.
-	arrange_windows(old_ws);
-	arrange_windows(destination->parent);
+	if (old_parent) {
+		container_reap_empty(old_parent);
+	} else if (old_ws) {
+		workspace_consider_destroy(old_ws);
+	}
+
+	if (old_ws) {
+		arrange_workspace(old_ws);
+	}
+	arrange_node(node_get_parent(destination));
 
 	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
 }
 
-static void workspace_move_to_output(struct sway_container *workspace,
-		struct sway_container *output) {
-	if (!sway_assert(workspace->type == C_WORKSPACE, "Expected a workspace")) {
+static void workspace_move_to_output(struct sway_workspace *workspace,
+		struct sway_output *output) {
+	if (workspace->output == output) {
 		return;
 	}
-	if (!sway_assert(output->type == C_OUTPUT, "Expected an output")) {
-		return;
-	}
-	if (workspace->parent == output) {
-		return;
-	}
-	struct sway_container *old_output = container_remove_child(workspace);
-	struct sway_seat *seat = input_manager_get_default_seat(input_manager);
-	struct sway_container *new_output_focus =
-		seat_get_focus_inactive(seat, output);
+	struct sway_output *old_output = workspace->output;
+	workspace_detach(workspace);
+	struct sway_workspace *new_output_old_ws =
+		output_get_active_workspace(output);
 
-	container_add_child(output, workspace);
+	output_add_workspace(output, workspace);
 
 	// If moving the last workspace from the old output, create a new workspace
 	// on the old output
-	if (old_output->children->length == 0) {
-		char *ws_name = workspace_next_name(old_output->name);
-		struct sway_container *ws = workspace_create(old_output, ws_name);
+	struct sway_seat *seat = config->handler_context.seat;
+	if (old_output->workspaces->length == 0) {
+		char *ws_name = workspace_next_name(old_output->wlr_output->name);
+		struct sway_workspace *ws = workspace_create(old_output, ws_name);
 		free(ws_name);
-		seat_set_focus(seat, ws);
+		seat_set_focus(seat, &ws->node);
 	}
 
-	// Try to remove an empty workspace from the destination output.
-	container_reap_empty(new_output_focus);
+	workspace_consider_destroy(new_output_old_ws);
 
 	output_sort_workspaces(output);
-	seat_set_focus(seat, output);
+	struct sway_node *focus = seat_get_focus_inactive(seat, &workspace->node);
+	seat_set_focus(seat, focus);
 	workspace_output_raise_priority(workspace, old_output, output);
 	ipc_event_workspace(NULL, workspace, "move");
-
-	container_notify_subtree_changed(old_output);
-	container_notify_subtree_changed(output);
 }
 
-static struct cmd_results *cmd_move_workspace(struct sway_container *current,
-		int argc, char **argv) {
+static struct cmd_results *cmd_move_workspace(int argc, char **argv) {
 	struct cmd_results *error = NULL;
 	if ((error = checkarg(argc, "move workspace", EXPECTED_AT_LEAST, 2))) {
 		return error;
@@ -716,27 +652,25 @@ static struct cmd_results *cmd_move_workspace(struct sway_container *current,
 		return cmd_results_new(CMD_INVALID, "move", expected_syntax);
 	}
 
-	struct sway_container *source = container_parent(current, C_OUTPUT);
-	int center_x = current->width / 2 + current->x,
-		center_y = current->height / 2 + current->y;
-	struct sway_container *destination = output_in_direction(argv[2],
-			source->sway_output->wlr_output, center_x, center_y);
-	if (!destination) {
+	struct sway_workspace *workspace = config->handler_context.workspace;
+	struct sway_output *old_output = workspace->output;
+	int center_x = workspace->width / 2 + workspace->x,
+		center_y = workspace->height / 2 + workspace->y;
+	struct sway_output *new_output = output_in_direction(argv[2],
+			old_output, center_x, center_y);
+	if (!new_output) {
 		return cmd_results_new(CMD_FAILURE, "move workspace",
 			"Can't find output with name/direction '%s'", argv[2]);
 	}
-	if (current->type != C_WORKSPACE) {
-		current = container_parent(current, C_WORKSPACE);
-	}
-	workspace_move_to_output(current, destination);
+	workspace_move_to_output(workspace, new_output);
 
-	arrange_windows(source);
-	arrange_windows(destination);
+	arrange_output(old_output);
+	arrange_output(new_output);
 
 	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
 }
 
-static struct cmd_results *move_in_direction(struct sway_container *container,
+static struct cmd_results *cmd_move_in_direction(
 		enum movement_direction direction, int argc, char **argv) {
 	int move_amt = 10;
 	if (argc > 1) {
@@ -748,7 +682,8 @@ static struct cmd_results *move_in_direction(struct sway_container *container,
 		}
 	}
 
-	if (container->type == C_WORKSPACE) {
+	struct sway_container *container = config->handler_context.container;
+	if (!container) {
 		return cmd_results_new(CMD_FAILURE, "move",
 				"Cannot move workspaces in a direction");
 	}
@@ -780,20 +715,34 @@ static struct cmd_results *move_in_direction(struct sway_container *container,
 		container_floating_move_to(container, lx, ly);
 		return cmd_results_new(CMD_SUCCESS, NULL, NULL);
 	}
-	// For simplicity, we'll arrange the entire workspace. The reason for this
-	// is moving the container might reap the old parent, and container_move
-	// does not return a surviving parent.
-	// TODO: Make container_move return the surviving parent so we can arrange
-	// just that.
-	struct sway_container *old_ws = container_parent(container, C_WORKSPACE);
-	container_move(container, direction, move_amt);
-	struct sway_container *new_ws = container_parent(container, C_WORKSPACE);
+	struct sway_workspace *old_ws = container->workspace;
 
-	arrange_windows(old_ws);
+	if (!container_move_in_direction(container, direction)) {
+		// Container didn't move
+		return cmd_results_new(CMD_SUCCESS, NULL, NULL);
+	}
+
+	struct sway_workspace *new_ws = container->workspace;
+
+	arrange_workspace(old_ws);
 	if (new_ws != old_ws) {
-		arrange_windows(new_ws);
+		arrange_workspace(new_ws);
+	}
+
+	if (container->view) {
+		ipc_event_window(container, "move");
 	}
 
+	seat_set_focus(config->handler_context.seat, &new_ws->node);
+	seat_set_focus(config->handler_context.seat, &container->node);
+
+	if (old_ws != new_ws) {
+		ipc_event_workspace(old_ws, new_ws, "focus");
+		workspace_detect_urgent(old_ws);
+		workspace_detect_urgent(new_ws);
+	}
+	container_end_mouse_operation(container);
+
 	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
 }
 
@@ -802,9 +751,9 @@ static const char *expected_position_syntax =
 	"'move [absolute] position center' or "
 	"'move position cursor|mouse|pointer'";
 
-static struct cmd_results *move_to_position(struct sway_container *container,
-		int argc, char **argv) {
-	if (!container_is_floating(container)) {
+static struct cmd_results *cmd_move_to_position(int argc, char **argv) {
+	struct sway_container *container = config->handler_context.container;
+	if (!container || !container_is_floating(container)) {
 		return cmd_results_new(CMD_FAILURE, "move",
 				"Only floating containers "
 				"can be moved to an absolute position");
@@ -842,10 +791,10 @@ static struct cmd_results *move_to_position(struct sway_container *container,
 	} else if (strcmp(argv[0], "center") == 0) {
 		double lx, ly;
 		if (absolute) {
-			lx = root_container.x + (root_container.width - container->width) / 2;
-			ly = root_container.y + (root_container.height - container->height) / 2;
+			lx = root->x + (root->width - container->width) / 2;
+			ly = root->y + (root->height - container->height) / 2;
 		} else {
-			struct sway_container *ws = container_parent(container, C_WORKSPACE);
+			struct sway_workspace *ws = container->workspace;
 			lx = ws->x + (ws->width - container->width) / 2;
 			ly = ws->y + (ws->height - container->height) / 2;
 		}
@@ -881,30 +830,31 @@ static struct cmd_results *move_to_position(struct sway_container *container,
 	}
 
 	if (!absolute) {
-		struct sway_container *ws = container_parent(container, C_WORKSPACE);
-		lx += ws->x;
-		ly += ws->y;
+		lx += container->workspace->x;
+		ly += container->workspace->y;
 	}
 	container_floating_move_to(container, lx, ly);
 	return cmd_results_new(CMD_SUCCESS, NULL, NULL);
 }
 
-static struct cmd_results *move_to_scratchpad(struct sway_container *con) {
-	if (con->type == C_WORKSPACE && con->children->length == 0) {
+static struct cmd_results *cmd_move_to_scratchpad(void) {
+	struct sway_node *node = config->handler_context.node;
+	struct sway_container *con = config->handler_context.container;
+	struct sway_workspace *ws = config->handler_context.workspace;
+	if (node->type == N_WORKSPACE && ws->tiling->length == 0) {
 		return cmd_results_new(CMD_INVALID, "move",
 				"Can't move an empty workspace to the scratchpad");
 	}
-	if (con->type == C_WORKSPACE) {
+	if (node->type == N_WORKSPACE) {
 		// Wrap the workspace's children in a container
-		struct sway_container *workspace = con;
-		con = workspace_wrap_children(con);
-		workspace->layout = L_HORIZ;
+		con = workspace_wrap_children(ws);
+		ws->layout = L_HORIZ;
 	}
 
 	// If the container is in a floating split container,
 	// operate on the split container instead of the child.
 	if (container_is_floating_or_child(con)) {
-		while (con->parent->type != C_WORKSPACE) {
+		while (con->parent) {
 			con = con->parent;
 		}
 	}
@@ -922,32 +872,31 @@ struct cmd_results *cmd_move(int argc, char **argv) {
 	if ((error = checkarg(argc, "move", EXPECTED_AT_LEAST, 1))) {
 		return error;
 	}
-	struct sway_container *current = config->handler_context.current_container;
 
 	if (strcasecmp(argv[0], "left") == 0) {
-		return move_in_direction(current, MOVE_LEFT, argc, argv);
+		return cmd_move_in_direction(MOVE_LEFT, argc, argv);
 	} else if (strcasecmp(argv[0], "right") == 0) {
-		return move_in_direction(current, MOVE_RIGHT, argc, argv);
+		return cmd_move_in_direction(MOVE_RIGHT, argc, argv);
 	} else if (strcasecmp(argv[0], "up") == 0) {
-		return move_in_direction(current, MOVE_UP, argc, argv);
+		return cmd_move_in_direction(MOVE_UP, argc, argv);
 	} else if (strcasecmp(argv[0], "down") == 0) {
-		return move_in_direction(current, MOVE_DOWN, argc, argv);
+		return cmd_move_in_direction(MOVE_DOWN, argc, argv);
 	} else if ((strcasecmp(argv[0], "container") == 0
 			|| strcasecmp(argv[0], "window") == 0) ||
-			(strcasecmp(argv[0], "--no-auto-back-and-forth") &&
-			(strcasecmp(argv[0], "container") == 0
-			|| strcasecmp(argv[0], "window") == 0))) {
-		return cmd_move_container(current, argc, argv);
+			(strcasecmp(argv[0], "--no-auto-back-and-forth") && argc >= 2
+			&& (strcasecmp(argv[1], "container") == 0
+			|| strcasecmp(argv[1], "window") == 0))) {
+		return cmd_move_container(argc, argv);
 	} else if (strcasecmp(argv[0], "workspace") == 0) {
-		return cmd_move_workspace(current, argc, argv);
+		return cmd_move_workspace(argc, argv);
 	} else if (strcasecmp(argv[0], "scratchpad") == 0
 			|| (strcasecmp(argv[0], "to") == 0 && argc == 2
 				&& strcasecmp(argv[1], "scratchpad") == 0)) {
-		return move_to_scratchpad(current);
+		return cmd_move_to_scratchpad();
 	} else if (strcasecmp(argv[0], "position") == 0) {
-		return move_to_position(current, argc, argv);
+		return cmd_move_to_position(argc, argv);
 	} else if (strcasecmp(argv[0], "absolute") == 0) {
-		return move_to_position(current, argc, argv);
+		return cmd_move_to_position(argc, argv);
 	} else {
 		return cmd_results_new(CMD_INVALID, "move", expected_syntax);
 	}