6 files changed, 4168 insertions, 0 deletions

diff --git a/sway/tree/container.c b/sway/tree/container.c
new file mode 100644
index 00000000..829fde69
--- /dev/null
+++ b/sway/tree/container.c
@@ -0,0 +1,1016 @@
+#define _XOPEN_SOURCE 500
+#include <ctype.h>
+#include <stdlib.h>
+#include <stdbool.h>
+#include <strings.h>
+#include <string.h>
+#include "sway/config.h"
+#include "sway/container.h"
+#include "sway/workspace.h"
+#include "sway/focus.h"
+#include "sway/border.h"
+#include "sway/layout.h"
+#include "sway/input_state.h"
+#include "sway/ipc-server.h"
+#include "sway/output.h"
+#include "log.h"
+#include "stringop.h"
+
+#define ASSERT_NONNULL(PTR) \
+	sway_assert (PTR, #PTR "must be non-null")
+
+static swayc_t *new_swayc(enum swayc_types type) {
+	// next id starts at 1 because 0 is assigned to root_container in layout.c
+	static size_t next_id = 1;
+	swayc_t *c = calloc(1, sizeof(swayc_t));
+	if (!c) {
+		return NULL;
+	}
+	c->id = next_id++;
+	c->handle = -1;
+	c->gaps = -1;
+	c->layout = L_NONE;
+	c->workspace_layout = L_NONE;
+	c->type = type;
+	c->nb_master = 1;
+	c->nb_slave_groups = 1;
+	if (type != C_VIEW) {
+		c->children = create_list();
+	}
+	return c;
+}
+
+static void free_swayc(swayc_t *cont) {
+	if (!ASSERT_NONNULL(cont)) {
+		return;
+	}
+	if (cont->children) {
+		// remove children until there are no more, free_swayc calls
+		// remove_child, which removes child from this container
+		while (cont->children->length) {
+			free_swayc(cont->children->items[0]);
+		}
+		list_free(cont->children);
+	}
+	if (cont->unmanaged) {
+		list_free(cont->unmanaged);
+	}
+	if (cont->floating) {
+		while (cont->floating->length) {
+			free_swayc(cont->floating->items[0]);
+		}
+		list_free(cont->floating);
+	}
+	if (cont->marks) {
+		list_foreach(cont->marks, free);
+		list_free(cont->marks);
+	}
+	if (cont->parent) {
+		remove_child(cont);
+	}
+	if (cont->name) {
+		free(cont->name);
+	}
+	if (cont->class) {
+		free(cont->class);
+	}
+	if (cont->instance) {
+		free(cont->instance);
+	}
+	if (cont->app_id) {
+		free(cont->app_id);
+	}
+	if (cont->bg_pid != 0) {
+		terminate_swaybg(cont->bg_pid);
+	}
+	if (cont->border) {
+		if (cont->border->buffer) {
+			free(cont->border->buffer);
+		}
+		free(cont->border);
+	}
+	free(cont);
+}
+
+static void update_root_geometry() {
+	int width = 0;
+	int height = 0;
+	swayc_t *child;
+	int child_width;
+	int child_height;
+
+	for (int i = 0; i < root_container.children->length; ++i) {
+		child = root_container.children->items[i];
+		child_width = child->width + child->x;
+		child_height = child->height + child->y;
+		if (child_width > width) {
+			width = child_width;
+		}
+
+		if (child_height > height) {
+			height = child_height;
+		}
+	}
+
+	root_container.width = width;
+	root_container.height = height;
+}
+
+// New containers
+
+swayc_t *new_output(wlc_handle handle) {
+	struct wlc_size size;
+	output_get_scaled_size(handle, &size);
+	const char *name = wlc_output_get_name(handle);
+	// Find current outputs to see if this already exists
+	{
+		int i, len = root_container.children->length;
+		for (i = 0; i < len; ++i) {
+			swayc_t *op = root_container.children->items[i];
+			const char *op_name = op->name;
+			if (op_name && name && strcmp(op_name, name) == 0) {
+				sway_log(L_DEBUG, "restoring output %" PRIuPTR ":%s", handle, op_name);
+				return op;
+			}
+		}
+	}
+
+	sway_log(L_DEBUG, "New output %" PRIuPTR ":%s", handle, name);
+
+	struct output_config *oc = NULL, *all = NULL;
+	int i;
+	for (i = 0; i < config->output_configs->length; ++i) {
+		struct output_config *cur = config->output_configs->items[i];
+		if (strcasecmp(name, cur->name) == 0) {
+			sway_log(L_DEBUG, "Matched output config for %s", name);
+			oc = cur;
+		}
+		if (strcasecmp("*", cur->name) == 0) {
+			sway_log(L_DEBUG, "Matched wildcard output config for %s", name);
+			all = cur;
+		}
+
+		if (oc && all) {
+			break;
+		}
+	}
+
+	if (!oc) {
+		oc = all;
+	}
+
+	if (oc && !oc->enabled) {
+		return NULL;
+	}
+
+	swayc_t *output = new_swayc(C_OUTPUT);
+	output->handle = handle;
+	output->name = name ? strdup(name) : NULL;
+	output->width = size.w;
+	output->height = size.h;
+	output->unmanaged = create_list();
+	output->bg_pid = 0;
+
+	apply_output_config(oc, output);
+	add_child(&root_container, output);
+	load_swaybars();
+
+	// Create workspace
+	char *ws_name = NULL;
+	swayc_t *ws = NULL;
+
+	if (name) {
+		for (i = 0; i < config->workspace_outputs->length; ++i) {
+			struct workspace_output *wso = config->workspace_outputs->items[i];
+			if (strcasecmp(wso->output, name) == 0) {
+				sway_log(L_DEBUG, "Matched workspace to output: %s for %s", wso->workspace, wso->output);
+				// Check if any other workspaces are using this name
+				if ((ws = workspace_by_name(wso->workspace))) {
+					// if yes, move those to this output, because they should be here
+					move_workspace_to(ws, output);
+				} else if (!ws_name) {
+					// set a workspace name in case we need to create a default one
+					ws_name = strdup(wso->workspace);
+				}
+			}
+		}
+	}
+
+	if (output->children->length == 0) {
+		if (!ws_name) {
+			ws_name = workspace_next_name(output->name);
+		}
+		// create and initialize default workspace
+		sway_log(L_DEBUG, "Creating default workspace %s", ws_name);
+		ws = new_workspace(output, ws_name);
+		ws->is_focused = true;
+	} else {
+		sort_workspaces(output);
+		set_focused_container(output->children->items[0]);
+	}
+
+	free(ws_name);
+	update_root_geometry();
+	return output;
+}
+
+swayc_t *new_workspace(swayc_t *output, const char *name) {
+	if (!ASSERT_NONNULL(output)) {
+		return NULL;
+	}
+	sway_log(L_DEBUG, "Added workspace %s for output %u", name, (unsigned int)output->handle);
+	swayc_t *workspace = new_swayc(C_WORKSPACE);
+
+	workspace->prev_layout = L_NONE;
+	workspace->layout = default_layout(output);
+	workspace->workspace_layout = default_layout(output);
+
+	workspace->x = output->x;
+	workspace->y = output->y;
+	workspace->width = output->width;
+	workspace->height = output->height;
+	workspace->name = !name ? NULL : strdup(name);
+	workspace->visible = false;
+	workspace->floating = create_list();
+
+	add_child(output, workspace);
+	sort_workspaces(output);
+
+	return workspace;
+}
+
+swayc_t *new_container(swayc_t *child, enum swayc_layouts layout) {
+	if (!ASSERT_NONNULL(child)
+			&& !sway_assert(!child->is_floating, "cannot create container around floating window")) {
+		return NULL;
+	}
+	swayc_t *cont = new_swayc(C_CONTAINER);
+
+	sway_log(L_DEBUG, "creating container %p around %p", cont, child);
+
+	cont->prev_layout = L_NONE;
+	cont->layout = layout;
+	cont->width = child->width;
+	cont->height = child->height;
+	cont->x = child->x;
+	cont->y = child->y;
+	cont->visible = child->visible;
+	cont->cached_geometry = child->cached_geometry;
+	cont->gaps = child->gaps;
+
+	/* Container inherits all of workspaces children, layout and whatnot */
+	if (child->type == C_WORKSPACE) {
+		swayc_t *workspace = child;
+		// reorder focus
+		cont->focused = workspace->focused;
+		workspace->focused = cont;
+		// set all children focu to container
+		int i;
+		for (i = 0; i < workspace->children->length; ++i) {
+			((swayc_t *)workspace->children->items[i])->parent = cont;
+		}
+		// Swap children
+		list_t  *tmp_list  = workspace->children;
+		workspace->children = cont->children;
+		cont->children = tmp_list;
+		// add container to workspace chidren
+		add_child(workspace, cont);
+		// give them proper layouts
+		cont->layout = workspace->workspace_layout;
+		cont->prev_layout = workspace->prev_layout;
+		/* TODO: might break shit in move_container!!! workspace->layout = layout; */
+		set_focused_container_for(workspace, get_focused_view(workspace));
+	} else { // Or is built around container
+		swayc_t *parent = replace_child(child, cont);
+		if (parent) {
+			add_child(cont, child);
+		}
+	}
+	return cont;
+}
+
+swayc_t *new_view(swayc_t *sibling, wlc_handle handle) {
+	if (!ASSERT_NONNULL(sibling)) {
+		return NULL;
+	}
+	const char *title = wlc_view_get_title(handle);
+	swayc_t *view = new_swayc(C_VIEW);
+	sway_log(L_DEBUG, "Adding new view %" PRIuPTR ":%s to container %p %d",
+		handle, title, sibling, sibling ? sibling->type : 0);
+	// Setup values
+	view->handle = handle;
+	view->name = title ? strdup(title) : NULL;
+	const char *class = wlc_view_get_class(handle);
+	view->class = class ? strdup(class) : NULL;
+	const char *instance = wlc_view_get_instance(handle);
+	view->instance = instance ? strdup(instance) : NULL;
+	const char *app_id = wlc_view_get_app_id(handle);
+	view->app_id = app_id ? strdup(app_id) : NULL;
+	view->visible = true;
+	view->is_focused = true;
+	view->sticky = false;
+	view->width = 0;
+	view->height = 0;
+	view->desired_width = -1;
+	view->desired_height = -1;
+	// setup border
+	view->border_type = config->border;
+	view->border_thickness = config->border_thickness;
+
+	view->is_floating = false;
+
+	if (sibling->type == C_WORKSPACE) {
+		// Case of focused workspace, just create as child of it
+		add_child(sibling, view);
+	} else {
+		// Regular case, create as sibling of current container
+		add_sibling(sibling, view);
+	}
+	return view;
+}
+
+swayc_t *new_floating_view(wlc_handle handle) {
+	if (swayc_active_workspace() == NULL) {
+		return NULL;
+	}
+	const char *title = wlc_view_get_title(handle);
+	swayc_t *view = new_swayc(C_VIEW);
+	sway_log(L_DEBUG, "Adding new view %" PRIuPTR ":%x:%s as a floating view",
+		handle, wlc_view_get_type(handle), title);
+	// Setup values
+	view->handle = handle;
+	view->name = title ? strdup(title) : NULL;
+	const char *class = wlc_view_get_class(handle);
+	view->class = class ? strdup(class) : NULL;
+	const char *instance = wlc_view_get_instance(handle);
+	view->instance = instance ? strdup(instance) : NULL;
+	const char *app_id = wlc_view_get_app_id(handle);
+	view->app_id = app_id ? strdup(app_id) : NULL;
+	view->visible = true;
+	view->sticky = false;
+
+	// Set the geometry of the floating view
+	const struct wlc_geometry *geometry = wlc_view_get_geometry(handle);
+
+	// give it requested geometry, but place in center if possible
+	// in top left otherwise
+	if (geometry->size.w != 0) {
+		view->x = (swayc_active_workspace()->width - geometry->size.w) / 2;
+	} else {
+		view->x = 0;
+	}
+	if (geometry->size.h != 0) {
+		view->y = (swayc_active_workspace()->height - geometry->size.h) / 2;
+	} else {
+		view->y = 0;
+	}
+
+	view->width = geometry->size.w;
+	view->height = geometry->size.h;
+
+	view->desired_width = view->width;
+	view->desired_height = view->height;
+
+	// setup border
+	view->border_type = config->floating_border;
+	view->border_thickness = config->floating_border_thickness;
+
+	view->is_floating = true;
+
+	// Case of focused workspace, just create as child of it
+	list_add(swayc_active_workspace()->floating, view);
+	view->parent = swayc_active_workspace();
+	if (swayc_active_workspace()->focused == NULL) {
+		set_focused_container_for(swayc_active_workspace(), view);
+	}
+	return view;
+}
+
+void floating_view_sane_size(swayc_t *view) {
+	// floating_minimum is used as sane value.
+	// floating_maximum has priority in case of conflict
+	// TODO: implement total_outputs_dimensions()
+	if (config->floating_minimum_height != -1 &&
+		view->desired_height < config->floating_minimum_height) {
+		view->desired_height = config->floating_minimum_height;
+	}
+	if (config->floating_minimum_width != -1 &&
+		view->desired_width < config->floating_minimum_width) {
+		view->desired_width = config->floating_minimum_width;
+	}
+
+	// if 0 do not resize, only enforce max value
+	if (config->floating_maximum_height == 0) {
+		// Missing total_outputs_dimensions() using swayc_active_workspace()
+		config->floating_maximum_height = swayc_active_workspace()->height;
+
+	} else if (config->floating_maximum_height != -1 &&
+			view->desired_height > config->floating_maximum_height) {
+		view->desired_height = config->floating_maximum_height;
+	}
+
+	// if 0 do not resize, only enforce max value
+	if (config->floating_maximum_width == 0) {
+		// Missing total_outputs_dimensions() using swayc_active_workspace()
+		config->floating_maximum_width = swayc_active_workspace()->width;
+
+	} else 	if (config->floating_maximum_width != -1 &&
+		view->desired_width > config->floating_maximum_width) {
+		view->desired_width = config->floating_maximum_width;
+	}
+
+	sway_log(L_DEBUG, "Sane values for view to %d x %d @ %.f, %.f",
+		view->desired_width, view->desired_height, view->x, view->y);
+
+	return;
+}
+
+
+// Destroy container
+
+swayc_t *destroy_output(swayc_t *output) {
+	if (!ASSERT_NONNULL(output)) {
+		return NULL;
+	}
+	if (output->children->length > 0) {
+		// TODO save workspaces when there are no outputs.
+		// TODO also check if there will ever be no outputs except for exiting
+		// program
+		if (root_container.children->length > 1) {
+			int p = root_container.children->items[0] == output;
+			// Move workspace from this output to another output
+			while (output->children->length) {
+				swayc_t *child = output->children->items[0];
+				remove_child(child);
+				add_child(root_container.children->items[p], child);
+			}
+			sort_workspaces(root_container.children->items[p]);
+			update_visibility(root_container.children->items[p]);
+			arrange_windows(root_container.children->items[p], -1, -1);
+		}
+	}
+	sway_log(L_DEBUG, "OUTPUT: Destroying output '%" PRIuPTR "'", output->handle);
+	free_swayc(output);
+	update_root_geometry();
+	return &root_container;
+}
+
+swayc_t *destroy_workspace(swayc_t *workspace) {
+	if (!ASSERT_NONNULL(workspace)) {
+		return NULL;
+	}
+
+	// Do not destroy this if it's the last workspace on this output
+	swayc_t *output = swayc_parent_by_type(workspace, C_OUTPUT);
+	if (output && output->children->length == 1) {
+		return NULL;
+	}
+
+	swayc_t *parent = workspace->parent;
+	// destroy the WS if there are no children
+	if (workspace->children->length == 0 && workspace->floating->length == 0) {
+		sway_log(L_DEBUG, "destroying workspace '%s'", workspace->name);
+		ipc_event_workspace(workspace, NULL, "empty");
+	} else {
+		// Move children to a different workspace on this output
+		swayc_t *new_workspace = NULL;
+		int i;
+		for(i = 0; i < output->children->length; i++) {
+			if(output->children->items[i] != workspace) {
+				break;
+			}
+		}
+		new_workspace = output->children->items[i];
+
+		sway_log(L_DEBUG, "moving children to different workspace '%s' -> '%s'",
+			workspace->name, new_workspace->name);
+
+		for(i = 0; i < workspace->children->length; i++) {
+			move_container_to(workspace->children->items[i], new_workspace);
+		}
+
+		for(i = 0; i < workspace->floating->length; i++) {
+			move_container_to(workspace->floating->items[i], new_workspace);
+		}
+	}
+
+	free_swayc(workspace);
+	return parent;
+}
+
+swayc_t *destroy_container(swayc_t *container) {
+	if (!ASSERT_NONNULL(container)) {
+		return NULL;
+	}
+	while (container->children->length == 0 && container->type == C_CONTAINER) {
+		sway_log(L_DEBUG, "Container: Destroying container '%p'", container);
+		swayc_t *parent = container->parent;
+		free_swayc(container);
+		container = parent;
+	}
+	return container;
+}
+
+swayc_t *destroy_view(swayc_t *view) {
+	if (!ASSERT_NONNULL(view)) {
+		return NULL;
+	}
+	sway_log(L_DEBUG, "Destroying view '%p'", view);
+	swayc_t *parent = view->parent;
+	free_swayc(view);
+
+	// Destroy empty containers
+	if (parent && parent->type == C_CONTAINER) {
+		return destroy_container(parent);
+	}
+	return parent;
+}
+
+// Container lookup
+
+
+swayc_t *swayc_by_test(swayc_t *container, bool (*test)(swayc_t *view, void *data), void *data) {
+	if (!container->children) {
+		return NULL;
+	}
+	// Special case for checking floating stuff
+	int i;
+	if (container->type == C_WORKSPACE) {
+		for (i = 0; i < container->floating->length; ++i) {
+			swayc_t *child = container->floating->items[i];
+			if (test(child, data)) {
+				return child;
+			}
+		}
+	}
+	for (i = 0; i < container->children->length; ++i) {
+		swayc_t *child = container->children->items[i];
+		if (test(child, data)) {
+			return child;
+		} else {
+			swayc_t *res = swayc_by_test(child, test, data);
+			if (res) {
+				return res;
+			}
+		}
+	}
+	return NULL;
+}
+
+static bool test_name(swayc_t *view, void *data) {
+	if (!view || !view->name) {
+		return false;
+	}
+	return strcmp(view->name, data) == 0;
+}
+
+swayc_t *swayc_by_name(const char *name) {
+	return swayc_by_test(&root_container, test_name, (void *)name);
+}
+
+swayc_t *swayc_parent_by_type(swayc_t *container, enum swayc_types type) {
+	if (!ASSERT_NONNULL(container)) {
+		return NULL;
+	}
+	if (!sway_assert(type < C_TYPES && type >= C_ROOT, "invalid type")) {
+		return NULL;
+	}
+	do {
+		container = container->parent;
+	} while (container && container->type != type);
+	return container;
+}
+
+swayc_t *swayc_parent_by_layout(swayc_t *container, enum swayc_layouts layout) {
+	if (!ASSERT_NONNULL(container)) {
+		return NULL;
+	}
+	if (!sway_assert(layout < L_LAYOUTS && layout >= L_NONE, "invalid layout")) {
+		return NULL;
+	}
+	do {
+		container = container->parent;
+	} while (container && container->layout != layout);
+	return container;
+}
+
+swayc_t *swayc_focus_by_type(swayc_t *container, enum swayc_types type) {
+	if (!ASSERT_NONNULL(container)) {
+		return NULL;
+	}
+	if (!sway_assert(type < C_TYPES && type >= C_ROOT, "invalid type")) {
+		return NULL;
+	}
+	do {
+		container = container->focused;
+	} while (container && container->type != type);
+	return container;
+}
+
+swayc_t *swayc_focus_by_layout(swayc_t *container, enum swayc_layouts layout) {
+	if (!ASSERT_NONNULL(container)) {
+		return NULL;
+	}
+	if (!sway_assert(layout < L_LAYOUTS && layout >= L_NONE, "invalid layout")) {
+		return NULL;
+	}
+	do {
+		container = container->focused;
+	} while (container && container->layout != layout);
+	return container;
+}
+
+
+static swayc_t *_swayc_by_handle_helper(wlc_handle handle, swayc_t *parent) {
+	if (!parent || !parent->children) {
+		return NULL;
+	}
+	int i, len;
+	swayc_t **child;
+	if (parent->type == C_WORKSPACE) {
+		len = parent->floating->length;
+		child = (swayc_t **)parent->floating->items;
+		for (i = 0; i < len; ++i, ++child) {
+			if ((*child)->handle == handle) {
+				return *child;
+			}
+		}
+	}
+
+	len = parent->children->length;
+	child = (swayc_t**)parent->children->items;
+	for (i = 0; i < len; ++i, ++child) {
+		if ((*child)->handle == handle) {
+			return *child;
+		} else {
+			swayc_t *res;
+			if ((res = _swayc_by_handle_helper(handle, *child))) {
+				return res;
+			}
+		}
+	}
+	return NULL;
+}
+
+swayc_t *swayc_by_handle(wlc_handle handle) {
+	return _swayc_by_handle_helper(handle, &root_container);
+}
+
+swayc_t *swayc_active_output(void) {
+	return root_container.focused;
+}
+
+swayc_t *swayc_active_workspace(void) {
+	return root_container.focused ? root_container.focused->focused : NULL;
+}
+
+swayc_t *swayc_active_workspace_for(swayc_t *cont) {
+	if (!cont) {
+		return NULL;
+	}
+	switch (cont->type) {
+	case C_ROOT:
+		cont = cont->focused;
+		/* Fallthrough */
+
+	case C_OUTPUT:
+		cont = cont ? cont->focused : NULL;
+		/* Fallthrough */
+
+	case C_WORKSPACE:
+		return cont;
+
+	default:
+		return swayc_parent_by_type(cont, C_WORKSPACE);
+	}
+}
+
+static bool pointer_test(swayc_t *view, void *_origin) {
+	const struct wlc_point *origin = _origin;
+	// Determine the output that the view is under
+	swayc_t *parent = swayc_parent_by_type(view, C_OUTPUT);
+	if (origin->x >= view->x && origin->y >= view->y
+		&& origin->x < view->x + view->width && origin->y < view->y + view->height
+		&& view->visible && parent == root_container.focused) {
+		return true;
+	}
+	return false;
+}
+
+swayc_t *container_under_pointer(void) {
+	// root.output->workspace
+	if (!root_container.focused) {
+		return NULL;
+	}
+	swayc_t *lookup = root_container.focused;
+	// Case of empty workspace
+	if (lookup->children && !lookup->unmanaged) {
+		return NULL;
+	}
+	double x, y;
+	wlc_pointer_get_position_v2(&x, &y);
+	struct wlc_point origin = { .x = x, .y = y };
+
+	while (lookup && lookup->type != C_VIEW) {
+		int i;
+		int len;
+		for (int _i = 0; lookup->unmanaged && _i < lookup->unmanaged->length; ++_i) {
+			wlc_handle *handle = lookup->unmanaged->items[_i];
+			const struct wlc_geometry *geo = wlc_view_get_geometry(*handle);
+			if (origin.x >= geo->origin.x && origin.y >= geo->origin.y
+					&& origin.x < geo->origin.x + (int)geo->size.w
+					&& origin.y < geo->origin.y + (int)geo->size.h) {
+				// Hack: we force focus upon unmanaged views here
+				wlc_view_focus(*handle);
+				return NULL;
+			}
+		}
+		// if tabbed/stacked go directly to focused container, otherwise search
+		// children
+		if (lookup->layout == L_TABBED || lookup->layout == L_STACKED) {
+			lookup = lookup->focused;
+			continue;
+		}
+		// if workspace, search floating
+		if (lookup->type == C_WORKSPACE) {
+			i = len = lookup->floating->length;
+			bool got_floating = false;
+			while (--i > -1) {
+				if (pointer_test(lookup->floating->items[i], &origin)) {
+					lookup = lookup->floating->items[i];
+					got_floating = true;
+					break;
+				}
+			}
+			if (got_floating) {
+				continue;
+			}
+		}
+		// search children
+		len = lookup->children->length;
+		for (i = 0; i < len; ++i) {
+			if (pointer_test(lookup->children->items[i], &origin)) {
+				lookup = lookup->children->items[i];
+				break;
+			}
+		}
+		// when border and titles are done, this could happen
+		if (i == len) {
+			break;
+		}
+	}
+	return lookup;
+}
+
+swayc_t *container_find(swayc_t *container, bool (*f)(swayc_t *, const void *), const void *data) {
+	if (container->children == NULL || container->children->length == 0) {
+		return NULL;
+	}
+
+	swayc_t *con;
+	if (container->type == C_WORKSPACE) {
+		for (int i = 0; i < container->floating->length; ++i) {
+			con = container->floating->items[i];
+			if (f(con, data)) {
+				return con;
+			}
+			con = container_find(con, f, data);
+			if (con != NULL) {
+				return con;
+			}
+		}
+	}
+
+	for (int i = 0; i < container->children->length; ++i) {
+		con = container->children->items[i];
+		if (f(con, data)) {
+			return con;
+		}
+
+		con = container_find(con, f, data);
+		if (con != NULL) {
+			return con;
+		}
+	}
+
+	return NULL;
+}
+
+// Container information
+
+bool swayc_is_fullscreen(swayc_t *view) {
+	return view && view->type == C_VIEW && (wlc_view_get_state(view->handle) & WLC_BIT_FULLSCREEN);
+}
+
+bool swayc_is_active(swayc_t *view) {
+	return view && view->type == C_VIEW && (wlc_view_get_state(view->handle) & WLC_BIT_ACTIVATED);
+}
+
+bool swayc_is_parent_of(swayc_t *parent, swayc_t *child) {
+	while (child != &root_container) {
+		child = child->parent;
+		if (child == parent) {
+			return true;
+		}
+	}
+	return false;
+}
+
+bool swayc_is_child_of(swayc_t *child, swayc_t *parent) {
+	return swayc_is_parent_of(parent, child);
+}
+
+bool swayc_is_empty_workspace(swayc_t *container) {
+	return container->type == C_WORKSPACE && container->children->length == 0;
+}
+
+int swayc_gap(swayc_t *container) {
+	if (container->type == C_VIEW || container->type == C_CONTAINER) {
+		return container->gaps >= 0 ? container->gaps : config->gaps_inner;
+	} else if (container->type == C_WORKSPACE) {
+		int base = container->gaps >= 0 ? container->gaps : config->gaps_outer;
+		if (config->edge_gaps && !(config->smart_gaps && container->children->length == 1)) {
+			// the inner gap is created via a margin around each window which
+			// is half the gap size, so the workspace also needs half a gap
+			// size to make the outermost gap the same size (excluding the
+			// actual "outer gap" size which is handled independently)
+			return base + config->gaps_inner / 2;
+		} else if (config->smart_gaps && container->children->length == 1) {
+			return 0;
+		} else {
+			return base;
+		}
+	} else {
+		return 0;
+	}
+}
+
+// Mapping
+
+void container_map(swayc_t *container, void (*f)(swayc_t *view, void *data), void *data) {
+	if (container) {
+		int i;
+		if (container->children)  {
+			for (i = 0; i < container->children->length; ++i) {
+				swayc_t *child = container->children->items[i];
+				container_map(child, f, data);
+			}
+		}
+		if (container->floating) {
+			for (i = 0; i < container->floating->length; ++i) {
+				swayc_t *child = container->floating->items[i];
+				container_map(child, f, data);
+			}
+		}
+		f(container, data);
+	}
+}
+
+void update_visibility_output(swayc_t *container, wlc_handle output) {
+	// Inherit visibility
+	swayc_t *parent = container->parent;
+	container->visible = parent->visible;
+	// special cases where visibility depends on focus
+	if (parent->type == C_OUTPUT || parent->layout == L_TABBED ||
+			parent->layout == L_STACKED) {
+		container->visible = parent->focused == container && parent->visible;
+	}
+	// Set visibility and output for view
+	if (container->type == C_VIEW) {
+		wlc_view_set_output(container->handle, output);
+		wlc_view_set_mask(container->handle, container->visible ? VISIBLE : 0);
+	}
+	// Update visibility for children
+	else {
+		if (container->children) {
+			int i, len = container->children->length;
+			for (i = 0; i < len; ++i) {
+				update_visibility_output(container->children->items[i], output);
+			}
+		}
+		if (container->floating) {
+			int i, len = container->floating->length;
+			for (i = 0; i < len; ++i) {
+				update_visibility_output(container->floating->items[i], output);
+			}
+		}
+	}
+}
+
+void update_visibility(swayc_t *container) {
+	if (!container) return;
+	switch (container->type) {
+	case C_ROOT:
+		container->visible = true;
+		if (container->children) {
+			int i, len = container->children->length;
+			for (i = 0; i < len; ++i) {
+				update_visibility(container->children->items[i]);
+			}
+		}
+		return;
+
+	case C_OUTPUT:
+		container->visible = true;
+		if (container->children) {
+			int i, len = container->children->length;
+			for (i = 0; i < len; ++i) {
+				update_visibility_output(container->children->items[i], container->handle);
+			}
+		}
+		return;
+
+	default:
+		{
+			swayc_t *op = swayc_parent_by_type(container, C_OUTPUT);
+			update_visibility_output(container, op->handle);
+		}
+	}
+}
+
+void set_gaps(swayc_t *view, void *_data) {
+	int *data = _data;
+	if (!ASSERT_NONNULL(view)) {
+		return;
+	}
+	if (view->type == C_WORKSPACE || view->type == C_VIEW) {
+		view->gaps = *data;
+	}
+}
+
+void add_gaps(swayc_t *view, void *_data) {
+	int *data = _data;
+	if (!ASSERT_NONNULL(view)) {
+		return;
+	}
+	if (view->type == C_WORKSPACE || view->type == C_VIEW) {
+		if ((view->gaps += *data) < 0) {
+			view->gaps = 0;
+		}
+	}
+}
+
+static void close_view(swayc_t *container, void *data) {
+	if (container->type == C_VIEW) {
+		wlc_view_close(container->handle);
+	}
+}
+
+void close_views(swayc_t *container) {
+	container_map(container, close_view, NULL);
+}
+
+swayc_t *swayc_tabbed_stacked_ancestor(swayc_t *view) {
+	swayc_t *parent = NULL;
+	if (!ASSERT_NONNULL(view)) {
+		return NULL;
+	}
+	while (view->type != C_WORKSPACE && view->parent && view->parent->type != C_WORKSPACE) {
+		view = view->parent;
+		if (view->layout == L_TABBED || view->layout == L_STACKED) {
+			parent = view;
+		}
+	}
+
+	return parent;
+}
+
+swayc_t *swayc_tabbed_stacked_parent(swayc_t *con) {
+	if (!ASSERT_NONNULL(con)) {
+		return NULL;
+	}
+	if (con->parent && (con->parent->layout == L_TABBED || con->parent->layout == L_STACKED)) {
+		return con->parent;
+	}
+	return NULL;
+}
+
+swayc_t *swayc_change_layout(swayc_t *container, enum swayc_layouts layout) {
+	// if layout change modifies the auto layout's major axis, swap width and height
+	// to preserve current ratios.
+	if (is_auto_layout(layout) && is_auto_layout(container->layout)) {
+		enum swayc_layouts prev_major =
+			container->layout == L_AUTO_LEFT || container->layout == L_AUTO_RIGHT
+			? L_HORIZ : L_VERT;
+		enum swayc_layouts new_major =
+			layout == L_AUTO_LEFT || layout == L_AUTO_RIGHT
+			? L_HORIZ : L_VERT;
+		if (new_major != prev_major) {
+			for (int i = 0; i < container->children->length; ++i) {
+				swayc_t *child = container->children->items[i];
+				double h = child->height;
+				child->height = child->width;
+				child->width = h;
+			}
+		}
+	}
+	if (container->type == C_WORKSPACE) {
+		container->workspace_layout = layout;
+		if (layout == L_HORIZ || layout == L_VERT || is_auto_layout(layout)) {
+			container->layout = layout;
+		}
+	} else {
+		container->layout = layout;
+	}
+	return container;
+}
diff --git a/sway/tree/criteria.c b/sway/tree/criteria.c
new file mode 100644
index 00000000..e8978ebe
--- /dev/null
+++ b/sway/tree/criteria.c
@@ -0,0 +1,451 @@
+#define _XOPEN_SOURCE 700
+#include <stdlib.h>
+#include <stdio.h>
+#include <stdbool.h>
+#include <pcre.h>
+#include "sway/criteria.h"
+#include "sway/container.h"
+#include "sway/config.h"
+#include "stringop.h"
+#include "list.h"
+#include "log.h"
+
+enum criteria_type { // *must* keep in sync with criteria_strings[]
+	CRIT_CLASS,
+	CRIT_CON_ID,
+	CRIT_CON_MARK,
+	CRIT_FLOATING,
+	CRIT_ID,
+	CRIT_INSTANCE,
+	CRIT_TILING,
+	CRIT_TITLE,
+	CRIT_URGENT,
+	CRIT_WINDOW_ROLE,
+	CRIT_WINDOW_TYPE,
+	CRIT_WORKSPACE,
+	CRIT_LAST
+};
+
+static const char * const criteria_strings[CRIT_LAST] = {
+	[CRIT_CLASS] = "class",
+	[CRIT_CON_ID] = "con_id",
+	[CRIT_CON_MARK] = "con_mark",
+	[CRIT_FLOATING] = "floating",
+	[CRIT_ID] = "id",
+	[CRIT_INSTANCE] = "instance",
+	[CRIT_TILING] = "tiling",
+	[CRIT_TITLE] = "title",
+	[CRIT_URGENT] = "urgent", // either "latest" or "oldest" ...
+	[CRIT_WINDOW_ROLE] = "window_role",
+	[CRIT_WINDOW_TYPE] = "window_type",
+	[CRIT_WORKSPACE] = "workspace"
+};
+
+/**
+ * A single criteria token (ie. value/regex pair),
+ * e.g. 'class="some class regex"'.
+ */
+struct crit_token {
+	enum criteria_type type;
+	pcre *regex;
+	char *raw;
+};
+
+static void free_crit_token(struct crit_token *crit) {
+	pcre_free(crit->regex);
+	free(crit->raw);
+	free(crit);
+}
+
+static void free_crit_tokens(list_t *crit_tokens) {
+	for (int i = 0; i < crit_tokens->length; i++) {
+		free_crit_token(crit_tokens->items[i]);
+	}
+	list_free(crit_tokens);
+}
+
+// Extracts criteria string from its brackets. Returns new (duplicate)
+// substring.
+static char *criteria_from(const char *arg) {
+	char *criteria = NULL;
+	if (*arg == '[') {
+		criteria = strdup(arg + 1);
+	} else {
+		criteria = strdup(arg);
+	}
+
+	int last = strlen(criteria) - 1;
+	if (criteria[last] == ']') {
+		criteria[last] = '\0';
+	}
+	return criteria;
+}
+
+// Return instances of c found in str.
+static int countchr(char *str, char c) {
+	int found = 0;
+	for (int i = 0; str[i]; i++) {
+		if (str[i] == c) {
+			++found;
+		}
+	}
+	return found;
+}
+
+// criteria_str is e.g. '[class="some class regex" instance="instance name"]'.
+//
+// Will create array of pointers in buf, where first is duplicate of given
+// string (must be freed) and the rest are pointers to names and values in the
+// base string (every other, naturally). argc will be populated with the length
+// of buf.
+//
+// Returns error string or NULL if successful.
+static char *crit_tokens(int *argc, char ***buf, const char * const criteria_str) {
+	sway_log(L_DEBUG, "Parsing criteria: '%s'", criteria_str);
+	char *base = criteria_from(criteria_str);
+	char *head = base;
+	char *namep = head; // start of criteria name
+	char *valp = NULL; // start of value
+
+	// We're going to place EOS markers where we need to and fill up an array
+	// of pointers to the start of each token (either name or value).
+	int pairs = countchr(base, '=');
+	int max_tokens = pairs * 2 + 1; // this gives us at least enough slots
+
+	char **argv = *buf = calloc(max_tokens, sizeof(char*));
+	argv[0] = base; // this needs to be freed by caller
+	bool quoted = true;
+
+	*argc = 1; // uneven = name, even = value
+	while (*head && *argc < max_tokens) {
+		if (namep != head && *(head - 1) == '\\') {
+			// escaped character: don't try to parse this
+		} else if (*head == '=' && namep != head) {
+			if (*argc % 2 != 1) {
+				// we're not expecting a name
+				return strdup("Unable to parse criteria: "
+					"Found out of place equal sign");
+			} else {
+				// name ends here
+				char *end = head; // don't want to rewind the head
+				while (*(end - 1) == ' ') {
+					--end;
+				}
+				*end = '\0';
+				if (*(namep) == ' ') {
+					namep = strrchr(namep, ' ') + 1;
+				}
+				argv[*argc] = namep;
+				*argc += 1;
+			}
+		} else if (*head == '"') {
+			if (*argc % 2 != 0) {
+				// we're not expecting a value
+				return strdup("Unable to parse criteria: "
+					"Found quoted value where it was not expected");
+			} else if (!valp) { // value starts here
+				valp = head + 1;
+				quoted = true;
+			} else {
+				// value ends here
+				argv[*argc] = valp;
+				*argc += 1;
+				*head = '\0';
+				valp = NULL;
+				namep = head + 1;
+			}
+		} else if (*argc % 2 == 0 && *head != ' ') {
+			// parse unquoted values
+			if (!valp) {
+				quoted = false;
+				valp = head;  // value starts here
+			}
+		} else if (valp && !quoted && *head == ' ') {
+			// value ends here
+			argv[*argc] = valp;
+			*argc += 1;
+			*head = '\0';
+			valp = NULL;
+			namep = head + 1;
+		}
+		head++;
+	}
+
+	// catch last unquoted value if needed
+	if (valp && !quoted && !*head) {
+		argv[*argc] = valp;
+		*argc += 1;
+	}
+
+	return NULL;
+}
+
+// Returns error string on failure or NULL otherwise.
+static char *parse_criteria_name(enum criteria_type *type, char *name) {
+	*type = CRIT_LAST;
+	for (int i = 0; i < CRIT_LAST; i++) {
+		if (strcmp(criteria_strings[i], name) == 0) {
+			*type = (enum criteria_type) i;
+			break;
+		}
+	}
+	if (*type == CRIT_LAST) {
+		const char *fmt = "Criteria type '%s' is invalid or unsupported.";
+		int len = strlen(name) + strlen(fmt) - 1;
+		char *error = malloc(len);
+		snprintf(error, len, fmt, name);
+		return error;
+	} else if (*type == CRIT_URGENT || *type == CRIT_WINDOW_ROLE ||
+			*type == CRIT_WINDOW_TYPE) {
+		// (we're just being helpful here)
+		const char *fmt = "\"%s\" criteria currently unsupported, "
+			"no window will match this";
+		int len = strlen(fmt) + strlen(name) - 1;
+		char *error = malloc(len);
+		snprintf(error, len, fmt, name);
+		return error;
+	}
+	return NULL;
+}
+
+// Returns error string on failure or NULL otherwise.
+static char *generate_regex(pcre **regex, char *value) {
+	const char *reg_err;
+	int offset;
+
+	*regex = pcre_compile(value, PCRE_UTF8 | PCRE_UCP, &reg_err, &offset, NULL);
+
+	if (!*regex) {
+		const char *fmt = "Regex compilation (for '%s') failed: %s";
+		int len = strlen(fmt) + strlen(value) + strlen(reg_err) - 3;
+		char *error = malloc(len);
+		snprintf(error, len, fmt, value, reg_err);
+		return error;
+	}
+	return NULL;
+}
+
+// Test whether the criterion corresponds to the currently focused window
+static bool crit_is_focused(const char *value) {
+	return !strcmp(value, "focused") || !strcmp(value, "__focused__");
+}
+
+// Populate list with crit_tokens extracted from criteria string, returns error
+// string or NULL if successful.
+char *extract_crit_tokens(list_t *tokens, const char * const criteria) {
+	int argc;
+	char **argv = NULL, *error = NULL;
+	if ((error = crit_tokens(&argc, &argv, criteria))) {
+		goto ect_cleanup;
+	}
+	for (int i = 1; i + 1 < argc; i += 2) {
+		char* name = argv[i], *value = argv[i + 1];
+		struct crit_token *token = calloc(1, sizeof(struct crit_token));
+		token->raw = strdup(value);
+
+		if ((error = parse_criteria_name(&token->type, name))) {
+			free_crit_token(token);
+			goto ect_cleanup;
+		} else if (token->type == CRIT_URGENT || crit_is_focused(value)) {
+			sway_log(L_DEBUG, "%s -> \"%s\"", name, value);
+			list_add(tokens, token);
+		} else if((error = generate_regex(&token->regex, value))) {
+			free_crit_token(token);
+			goto ect_cleanup;
+		} else {
+			sway_log(L_DEBUG, "%s -> /%s/", name, value);
+			list_add(tokens, token);
+		}
+	}
+ect_cleanup:
+	free(argv[0]); // base string
+	free(argv);
+	return error;
+}
+
+static int regex_cmp(const char *item, const pcre *regex) {
+	return pcre_exec(regex, NULL, item, strlen(item), 0, 0, NULL, 0);
+}
+
+// test a single view if it matches list of criteria tokens (all of them).
+static bool criteria_test(swayc_t *cont, list_t *tokens) {
+	if (cont->type != C_VIEW) {
+		return false;
+	}
+	int matches = 0;
+	for (int i = 0; i < tokens->length; i++) {
+		struct crit_token *crit = tokens->items[i];
+		switch (crit->type) {
+		case CRIT_CLASS:
+			if (!cont->class) {
+				// ignore
+			} else if (crit_is_focused(crit->raw)) {
+				swayc_t *focused = get_focused_view(&root_container);
+				if (focused->class && strcmp(cont->class, focused->class) == 0) {
+					matches++;
+				}
+			} else if (crit->regex && regex_cmp(cont->class, crit->regex) == 0) {
+				matches++;
+			}
+			break;
+		case CRIT_CON_ID: {
+			char *endptr;
+			size_t crit_id = strtoul(crit->raw, &endptr, 10);
+
+			if (*endptr == 0 && cont->id == crit_id) {
+				++matches;
+			}
+			break;
+		}
+		case CRIT_CON_MARK:
+			if (crit->regex && cont->marks && (list_seq_find(cont->marks, (int (*)(const void *, const void *))regex_cmp, crit->regex) != -1)) {
+				// Make sure it isn't matching the NUL string
+				if ((strcmp(crit->raw, "") == 0) == (list_seq_find(cont->marks, (int (*)(const void *, const void *))strcmp, "") != -1)) {
+					++matches;
+				}
+			}
+			break;
+		case CRIT_FLOATING:
+			if (cont->is_floating) {
+				matches++;
+			}
+			break;
+		case CRIT_ID:
+			if (!cont->app_id) {
+				// ignore
+			} else if (crit->regex && regex_cmp(cont->app_id, crit->regex) == 0) {
+				matches++;
+			}
+			break;
+		case CRIT_INSTANCE:
+			if (!cont->instance) {
+				// ignore
+			} else if (crit_is_focused(crit->raw)) {
+				swayc_t *focused = get_focused_view(&root_container);
+				if (focused->instance && strcmp(cont->instance, focused->instance) == 0) {
+					matches++;
+				}
+			} else if (crit->regex && regex_cmp(cont->instance, crit->regex) == 0) {
+				matches++;
+			}
+			break;
+		case CRIT_TILING:
+			if (!cont->is_floating) {
+				matches++;
+			}
+			break;
+		case CRIT_TITLE:
+			if (!cont->name) {
+				// ignore
+			} else if (crit_is_focused(crit->raw)) {
+				swayc_t *focused = get_focused_view(&root_container);
+				if (focused->name && strcmp(cont->name, focused->name) == 0) {
+					matches++;
+				}
+			} else if (crit->regex && regex_cmp(cont->name, crit->regex) == 0) {
+				matches++;
+			}
+			break;
+		case CRIT_URGENT: // "latest" or "oldest"
+			break;
+		case CRIT_WINDOW_ROLE:
+			break;
+		case CRIT_WINDOW_TYPE:
+			// TODO wlc indeed exposes this information
+			break;
+		case CRIT_WORKSPACE: ;
+			swayc_t *cont_ws = swayc_parent_by_type(cont, C_WORKSPACE);
+			if (!cont_ws || !cont_ws->name) {
+				// ignore
+			} else if (crit_is_focused(crit->raw)) {
+				swayc_t *focused_ws = swayc_active_workspace();
+				if (focused_ws->name && strcmp(cont_ws->name, focused_ws->name) == 0) {
+					matches++;
+				}
+			} else if (crit->regex && regex_cmp(cont_ws->name, crit->regex) == 0) {
+				matches++;
+			}
+			break;
+		default:
+			sway_abort("Invalid criteria type (%i)", crit->type);
+			break;
+		}
+	}
+	return matches == tokens->length;
+}
+
+int criteria_cmp(const void *a, const void *b) {
+	if (a == b) {
+		return 0;
+	} else if (!a) {
+		return -1;
+	} else if (!b) {
+		return 1;
+	}
+	const struct criteria *crit_a = a, *crit_b = b;
+	int cmp = lenient_strcmp(crit_a->cmdlist, crit_b->cmdlist);
+	if (cmp != 0) {
+		return cmp;
+	}
+	return lenient_strcmp(crit_a->crit_raw, crit_b->crit_raw);
+}
+
+void free_criteria(struct criteria *crit) {
+	if (crit->tokens) {
+		free_crit_tokens(crit->tokens);
+	}
+	if (crit->cmdlist) {
+		free(crit->cmdlist);
+	}
+	if (crit->crit_raw) {
+		free(crit->crit_raw);
+	}
+	free(crit);
+}
+
+bool criteria_any(swayc_t *cont, list_t *criteria) {
+	for (int i = 0; i < criteria->length; i++) {
+		struct criteria *bc = criteria->items[i];
+		if (criteria_test(cont, bc->tokens)) {
+			return true;
+		}
+	}
+	return false;
+}
+
+list_t *criteria_for(swayc_t *cont) {
+	list_t *criteria = config->criteria, *matches = create_list();
+	for (int i = 0; i < criteria->length; i++) {
+		struct criteria *bc = criteria->items[i];
+		if (criteria_test(cont, bc->tokens)) {
+			list_add(matches, bc);
+		}
+	}
+	return matches;
+}
+
+struct list_tokens {
+	list_t *list;
+	list_t *tokens;
+};
+
+static void container_match_add(swayc_t *container, struct list_tokens *list_tokens) {
+	if (criteria_test(container, list_tokens->tokens)) {
+		list_add(list_tokens->list, container);
+	}
+}
+
+list_t *container_for(list_t *tokens) {
+	struct list_tokens list_tokens = (struct list_tokens){create_list(), tokens};
+
+	container_map(&root_container, (void (*)(swayc_t *, void *))container_match_add, &list_tokens);
+	
+	for (int i = 0; i < scratchpad->length; ++i) {
+		swayc_t *c = scratchpad->items[i];
+		if (criteria_test(c, tokens)) {
+			list_add(list_tokens.list, c);
+		}
+	}
+
+	return list_tokens.list;
+}
diff --git a/sway/tree/focus.c b/sway/tree/focus.c
new file mode 100644
index 00000000..66f7ee17
--- /dev/null
+++ b/sway/tree/focus.c
@@ -0,0 +1,278 @@
+#include "stdbool.h"
+#include <wlc/wlc.h>
+#include "sway/focus.h"
+#include "sway/workspace.h"
+#include "sway/layout.h"
+#include "sway/config.h"
+#include "sway/input_state.h"
+#include "sway/ipc-server.h"
+#include "sway/border.h"
+#include "log.h"
+
+bool locked_container_focus = false;
+bool suspend_workspace_cleanup = false;
+
+// switches parent focus to c. will switch it accordingly
+static void update_focus(swayc_t *c) {
+	// Handle if focus switches
+	swayc_t *parent = c->parent;
+	if (!parent) return;
+	if (parent->focused != c) {
+		// Get previous focus
+		swayc_t *prev = parent->focused;
+		// Set new focus
+		parent->focused = c;
+
+		switch (c->type) {
+		// Shouldn't happen
+		case C_ROOT: return;
+
+		// Case where output changes
+		case C_OUTPUT:
+			wlc_output_focus(c->handle);
+			break;
+
+		// Case where workspace changes
+		case C_WORKSPACE:
+			if (prev) {
+				ipc_event_workspace(prev, c, "focus");
+
+				// if the old workspace has no children, destroy it
+				if(prev->children->length == 0 && prev->floating->length == 0 && !suspend_workspace_cleanup) {
+					destroy_workspace(prev);
+				} else {
+					// update visibility of old workspace
+					update_visibility(prev);
+				}
+			}
+			// Update visibility of newly focused workspace
+			update_visibility(c);
+			break;
+
+		default:
+		case C_VIEW:
+		case C_CONTAINER:
+			break;
+		}
+	}
+}
+
+bool move_focus(enum movement_direction direction) {
+	swayc_t *old_view = get_focused_container(&root_container);
+	swayc_t *new_view = get_swayc_in_direction(old_view, direction);
+	if (!new_view) {
+		return false;
+	} else if (new_view->type == C_ROOT) {
+		sway_log(L_DEBUG, "Not setting focus above the workspace level");
+		return false;
+	} else if (new_view->type == C_OUTPUT) {
+		return set_focused_container(swayc_active_workspace_for(new_view));
+	} else if (direction == MOVE_PARENT || direction == MOVE_CHILD) {
+		return set_focused_container(new_view);
+	} else if (config->mouse_warping) {
+		swayc_t *old_op = old_view->type == C_OUTPUT ?
+			old_view : swayc_parent_by_type(old_view, C_OUTPUT);
+		swayc_t *focused = get_focused_view(new_view);
+		if (set_focused_container(focused)) {
+			if (old_op != swayc_active_output() && focused && focused->type == C_VIEW) {
+				center_pointer_on(focused);
+			}
+			return true;
+		}
+	} else {
+		return set_focused_container(get_focused_view(new_view));
+	}
+	return false;
+}
+
+swayc_t *get_focused_container(swayc_t *parent) {
+	if (!parent) {
+		return swayc_active_workspace();
+	}
+	while (!parent->is_focused && parent->focused) {
+		parent = parent->focused;
+	}
+	return parent;
+}
+
+bool set_focused_container(swayc_t *c) {
+	if (locked_container_focus || !c || !c->parent) {
+		return false;
+	}
+
+	// current ("old") workspace for sending workspace change event later
+	swayc_t *old_ws = swayc_active_workspace();
+	// keep track of child count so we can determine if it gets destroyed
+	int old_ws_child_count = 0;
+	if (old_ws) {
+		old_ws_child_count = old_ws->children->length + old_ws->floating->length;
+	}
+
+	// current ("old") focused container
+	swayc_t *old_focus = get_focused_container(&root_container);
+	// if old_focus is a workspace, then it's the same workspace as
+	// old_ws, and we'll need to null its pointer too, since it will
+	// be destroyed in the update_focus() call
+	bool old_focus_was_ws = (old_focus->type == C_WORKSPACE);
+
+	// workspace of new focused container
+	swayc_t *workspace = swayc_active_workspace_for(c);
+
+	if (swayc_is_fullscreen(get_focused_container(workspace))) {
+		// if switching to a workspace with a fullscreen view,
+		// focus on the fullscreen view
+		c = get_focused_container(workspace);
+	}
+
+	swayc_log(L_DEBUG, c, "Setting focus to %p:%" PRIuPTR, c, c->handle);
+
+	if (c->type == C_VIEW) {
+		// dispatch a window event
+		ipc_event_window(c, "focus");
+	}
+
+	// update the global pointer
+	current_focus = c;
+
+	// update container focus from here to root, making necessary changes along
+	// the way
+	swayc_t *p = c;
+	if (p->type != C_OUTPUT && p->type != C_ROOT) {
+		p->is_focused = true;
+	}
+	while (p != &root_container) {
+		update_focus(p);
+		p = p->parent;
+		p->is_focused = false;
+	}
+
+	if (old_focus_was_ws && old_ws_child_count == 0) {
+		// this workspace was destroyed in update_focus(), so null the pointers
+		old_focus = NULL;
+		old_ws = NULL;
+	}
+
+	if (!(wlc_view_get_type(p->handle) & WLC_BIT_POPUP)) {
+		if (old_focus) {
+			if (old_focus->type == C_VIEW) {
+				wlc_view_set_state(old_focus->handle, WLC_BIT_ACTIVATED, false);
+			}
+			update_container_border(old_focus);
+		}
+		if (c->type == C_VIEW) {
+			wlc_view_set_state(c->handle, WLC_BIT_ACTIVATED, true);
+		}
+		/* TODO WLR
+		if (!desktop_shell.is_locked) {
+			// If the system is locked, we do everything _but_ actually setting
+			// focus. This includes making our internals think that this view is
+			// focused.
+			wlc_view_focus(c->handle);
+		}
+		*/
+		if (c->parent->layout != L_TABBED && c->parent->layout != L_STACKED) {
+			update_container_border(c);
+		}
+
+		swayc_t *parent = swayc_tabbed_stacked_ancestor(c);
+		if (parent != NULL) {
+			arrange_backgrounds();
+			arrange_windows(parent, -1, -1);
+		}
+	}
+
+	if (old_ws != workspace) {
+		// old_ws might be NULL here but that's ok
+		ipc_event_workspace(old_ws, workspace, "focus");
+	}
+
+	return true;
+}
+
+bool set_focused_container_for(swayc_t *a, swayc_t *c) {
+	if (locked_container_focus || !c) {
+		return false;
+	}
+	swayc_t *find = c;
+	while (find != a && (find = find->parent)) {
+		if (find == &root_container) {
+			return false;
+		}
+	}
+
+	// Get workspace for c, get that workspaces current focused container.
+	swayc_t *workspace = swayc_active_workspace_for(c);
+	swayc_t *focused = get_focused_view(workspace);
+	// if the workspace we are changing focus to has a fullscreen view return
+	if (swayc_is_fullscreen(focused) && c != focused) {
+		return false;
+	}
+
+	// Check if we are changing a parent container that will see change
+	bool effective = true;
+	while (find != &root_container) {
+		if (find->parent->focused != find) {
+			effective = false;
+		}
+		find = find->parent;
+	}
+	if (effective) {
+		// Go to set_focused_container
+		return set_focused_container(c);
+	}
+
+	sway_log(L_DEBUG, "Setting focus for %p:%" PRIuPTR " to %p:%" PRIuPTR,
+		a, a->handle, c, c->handle);
+
+	c->is_focused = true;
+	swayc_t *p = c;
+	while (p != a) {
+		update_focus(p);
+		p = p->parent;
+		p->is_focused = false;
+	}
+	return true;
+}
+
+swayc_t *get_focused_view(swayc_t *parent) {
+	swayc_t *c = parent;
+	while (c && c->type != C_VIEW) {
+		if (c->type == C_WORKSPACE && c->focused == NULL) {
+			return c;
+		}
+		c = c->focused;
+	}
+	if (c == NULL) {
+		c = swayc_active_workspace_for(parent);
+	}
+	return c;
+}
+
+swayc_t *get_focused_float(swayc_t *ws) {
+	if(!sway_assert(ws->type == C_WORKSPACE, "must be of workspace type")) {
+		ws = swayc_active_workspace();
+	}
+	if (ws->floating->length) {
+		return ws->floating->items[ws->floating->length - 1];
+	}
+	return NULL;
+}
+
+swayc_t *get_focused_view_include_floating(swayc_t *parent) {
+	swayc_t *c = parent;
+	swayc_t *f = NULL;
+
+	while (c && c->type != C_VIEW) {
+		if (c->type == C_WORKSPACE && c->focused == NULL) {
+			return ((f = get_focused_float(c))) ? f : c;
+		}
+
+		c = c->focused;
+	}
+
+	if (c == NULL) {
+		c = swayc_active_workspace_for(parent);
+	}
+
+	return c;
+}
diff --git a/sway/tree/layout.c b/sway/tree/layout.c
new file mode 100644
index 00000000..22f81688
--- /dev/null
+++ b/sway/tree/layout.c
@@ -0,0 +1,1773 @@
+#define _XOPEN_SOURCE 500
+#include <stdlib.h>
+#include <stdbool.h>
+#include <math.h>
+#include <wlc/wlc.h>
+#include "sway/config.h"
+#include "sway/container.h"
+#include "sway/workspace.h"
+#include "sway/focus.h"
+#include "sway/output.h"
+#include "sway/ipc-server.h"
+#include "sway/border.h"
+#include "sway/layout.h"
+#include "list.h"
+#include "log.h"
+
+swayc_t root_container;
+swayc_t *current_focus;
+list_t *scratchpad;
+
+int min_sane_h = 60;
+int min_sane_w = 100;
+
+void init_layout(void) {
+	root_container.id = 0; // normally assigned in new_swayc()
+	root_container.type = C_ROOT;
+	root_container.layout = L_NONE;
+	root_container.name = strdup("root");
+	root_container.children = create_list();
+	root_container.handle = -1;
+	root_container.visible = true;
+	current_focus = &root_container;
+	scratchpad = create_list();
+}
+
+int index_child(const swayc_t *child) {
+	swayc_t *parent = child->parent;
+	int i, len;
+	if (!child->is_floating) {
+		len = parent->children->length;
+		for (i = 0; i < len; ++i) {
+			if (parent->children->items[i] == child) {
+				break;
+			}
+		}
+	} else {
+		len = parent->floating->length;
+		for (i = 0; i < len; ++i) {
+			if (parent->floating->items[i] == child) {
+				break;
+			}
+		}
+	}
+	if (!sway_assert(i < len, "Stray container")) {
+		return -1;
+	}
+	return i;
+}
+
+void add_child(swayc_t *parent, swayc_t *child) {
+	sway_log(L_DEBUG, "Adding %p (%d, %fx%f) to %p (%d, %fx%f)", child, child->type,
+		child->width, child->height, parent, parent->type, parent->width, parent->height);
+	list_add(parent->children, child);
+	child->parent = parent;
+	// set focus for this container
+	if (!parent->focused) {
+		parent->focused = child;
+	}
+	if (parent->type == C_WORKSPACE && child->type == C_VIEW && (parent->workspace_layout == L_TABBED || parent->workspace_layout == L_STACKED)) {
+		child = new_container(child, parent->workspace_layout);
+	}
+}
+
+static double *get_height(swayc_t *cont) {
+	return &cont->height;
+}
+
+static double *get_width(swayc_t *cont) {
+	return &cont->width;
+}
+
+void insert_child(swayc_t *parent, swayc_t *child, int index) {
+	if (index > parent->children->length) {
+		index = parent->children->length;
+	}
+	if (index < 0) {
+		index = 0;
+	}
+	list_insert(parent->children, index, child);
+	child->parent = parent;
+	if (!parent->focused) {
+		parent->focused = child;
+	}
+	if (parent->type == C_WORKSPACE && child->type == C_VIEW && (parent->workspace_layout == L_TABBED || parent->workspace_layout == L_STACKED)) {
+		child = new_container(child, parent->workspace_layout);
+	}
+	if (is_auto_layout(parent->layout)) {
+		/* go through each group, adjust the size of the first child of each group */
+		double *(*get_maj_dim)(swayc_t *cont);
+		double *(*get_min_dim)(swayc_t *cont);
+		if (parent->layout == L_AUTO_LEFT || parent->layout == L_AUTO_RIGHT) {
+			get_maj_dim = get_width;
+			get_min_dim = get_height;
+		} else {
+			get_maj_dim = get_height;
+			get_min_dim = get_width;
+		}
+		for (int i = index; i < parent->children->length;) {
+			int start = auto_group_start_index(parent, i);
+			int end = auto_group_end_index(parent, i);
+			swayc_t *first = parent->children->items[start];
+			if (start + 1 < parent->children->length) {
+				/* preserve the group's dimension along major axis */
+				*get_maj_dim(first) = *get_maj_dim(parent->children->items[start + 1]);
+			} else {
+				/* new group, let the apply_layout handle it */
+				first->height = first->width = 0;
+				break;
+			}
+			double remaining = *get_min_dim(parent);
+			for (int j = end - 1; j > start; --j) {
+				swayc_t *sibling = parent->children->items[j];
+				if (sibling == child) {
+					/* the inserted child won't yet have its minor
+					   dimension set */
+					remaining -= *get_min_dim(parent) / (end - start);
+				} else {
+					remaining -= *get_min_dim(sibling);
+				}
+			}
+			*get_min_dim(first) = remaining;
+			i = end;
+		}
+	}
+}
+
+void add_floating(swayc_t *ws, swayc_t *child) {
+	sway_log(L_DEBUG, "Adding %p (%d, %fx%f) to %p (%d, %fx%f)", child, child->type,
+		child->width, child->height, ws, ws->type, ws->width, ws->height);
+	if (!sway_assert(ws->type == C_WORKSPACE, "Must be of workspace type")) {
+		return;
+	}
+	list_add(ws->floating, child);
+	child->parent = ws;
+	child->is_floating = true;
+	if (!ws->focused) {
+		ws->focused = child;
+	}
+	ipc_event_window(child, "floating");
+}
+
+swayc_t *add_sibling(swayc_t *fixed, swayc_t *active) {
+	swayc_t *parent = fixed->parent;
+	if (fixed->is_floating) {
+		if (active->is_floating) {
+			int i = index_child(fixed);
+			list_insert(parent->floating, i + 1, active);
+		} else {
+			list_add(parent->children, active);
+		}
+	} else {
+		if (active->is_floating) {
+			list_add(parent->floating, active);
+		} else {
+			int i = index_child(fixed);
+			if (is_auto_layout(parent->layout)) {
+				list_add(parent->children, active);
+			} else {
+				list_insert(parent->children, i + 1, active);
+			}
+		}
+	}
+	active->parent = parent;
+	// focus new child
+	parent->focused = active;
+	return active->parent;
+}
+
+swayc_t *replace_child(swayc_t *child, swayc_t *new_child) {
+	swayc_t *parent = child->parent;
+	if (parent == NULL) {
+		return NULL;
+	}
+	int i = index_child(child);
+	if (child->is_floating) {
+		parent->floating->items[i] = new_child;
+	} else {
+		parent->children->items[i] = new_child;
+	}
+	// Set parent and focus for new_child
+	new_child->parent = child->parent;
+	if (child->parent->focused == child) {
+		child->parent->focused = new_child;
+	}
+	child->parent = NULL;
+
+	// Set geometry for new child
+	new_child->x = child->x;
+	new_child->y = child->y;
+	new_child->width = child->width;
+	new_child->height = child->height;
+
+	// reset geometry for child
+	child->width = 0;
+	child->height = 0;
+
+	// deactivate child
+	if (child->type == C_VIEW) {
+		wlc_view_set_state(child->handle, WLC_BIT_ACTIVATED, false);
+	}
+	return parent;
+}
+
+swayc_t *remove_child(swayc_t *child) {
+	int i;
+	swayc_t *parent = child->parent;
+	if (child->is_floating) {
+		// Special case for floating views
+		for (i = 0; i < parent->floating->length; ++i) {
+			if (parent->floating->items[i] == child) {
+				list_del(parent->floating, i);
+				break;
+			}
+		}
+		i = 0;
+	} else {
+		for (i = 0; i < parent->children->length; ++i) {
+			if (parent->children->items[i] == child) {
+				list_del(parent->children, i);
+				break;
+			}
+		}
+		if (is_auto_layout(parent->layout) && parent->children->length) {
+			/* go through each group, adjust the size of the last child of each group */
+			double *(*get_maj_dim)(swayc_t *cont);
+			double *(*get_min_dim)(swayc_t *cont);
+			if (parent->layout == L_AUTO_LEFT || parent->layout == L_AUTO_RIGHT) {
+				get_maj_dim = get_width;
+				get_min_dim = get_height;
+			} else {
+				get_maj_dim = get_height;
+				get_min_dim = get_width;
+			}
+			for (int j = parent->children->length - 1; j >= i;) {
+				int start = auto_group_start_index(parent, j);
+				int end = auto_group_end_index(parent, j);
+				swayc_t *first = parent->children->items[start];
+				if (i == start) {
+					/* removed element was first child in the current group,
+					   use its size along the major axis */
+					*get_maj_dim(first) = *get_maj_dim(child);
+				} else if (start > i) {
+					/* preserve the group's dimension along major axis */
+					*get_maj_dim(first) = *get_maj_dim(parent->children->items[start - 1]);
+				}
+				if (end != parent->children->length) {
+					double remaining = *get_min_dim(parent);
+					for (int k = start; k < end - 1; ++k) {
+						swayc_t *sibling = parent->children->items[k];
+						remaining -= *get_min_dim(sibling);
+					}
+					/* last element of the group gets remaining size, elements
+					   that don't change groups keep their ratio */
+					*get_min_dim((swayc_t *) parent->children->items[end - 1]) = remaining;
+				} /* else last group, let apply_layout handle it */
+				j = start - 1;
+			}
+		}
+	}
+	// Set focused to new container
+	if (parent->focused == child) {
+		if (parent->children->length > 0) {
+			parent->focused = parent->children->items[i ? i-1:0];
+		} else if (parent->floating && parent->floating->length) {
+			parent->focused = parent->floating->items[parent->floating->length - 1];
+		} else {
+			parent->focused = NULL;
+		}
+	}
+	child->parent = NULL;
+	// deactivate view
+	if (child->type == C_VIEW) {
+		wlc_view_set_state(child->handle, WLC_BIT_ACTIVATED, false);
+	}
+	return parent;
+}
+
+void swap_container(swayc_t *a, swayc_t *b) {
+	if (!sway_assert(a&&b, "parameters must be non null") ||
+		!sway_assert(a->parent && b->parent, "containers must have parents")) {
+		return;
+	}
+	size_t a_index = index_child(a);
+	size_t b_index = index_child(b);
+	swayc_t *a_parent = a->parent;
+	swayc_t *b_parent = b->parent;
+	// Swap the pointers
+	if (a->is_floating) {
+		a_parent->floating->items[a_index] = b;
+	} else {
+		a_parent->children->items[a_index] = b;
+	}
+	if (b->is_floating) {
+		b_parent->floating->items[b_index] = a;
+	} else {
+		b_parent->children->items[b_index] = a;
+	}
+	a->parent = b_parent;
+	b->parent = a_parent;
+	if (a_parent->focused == a) {
+		a_parent->focused = b;
+	}
+	// don't want to double switch
+	if (b_parent->focused == b && a_parent != b_parent) {
+		b_parent->focused = a;
+	}
+}
+
+void swap_geometry(swayc_t *a, swayc_t *b) {
+	double x = a->x;
+	double y = a->y;
+	double w = a->width;
+	double h = a->height;
+	a->x = b->x;
+	a->y = b->y;
+	a->width = b->width;
+	a->height = b->height;
+	b->x = x;
+	b->y = y;
+	b->width = w;
+	b->height = h;
+}
+
+static void swap_children(swayc_t *container, int a, int b) {
+	if (a >= 0 && b >= 0 && a < container->children->length
+			&& b < container->children->length
+		&& a != b) {
+		swayc_t *pa = (swayc_t *)container->children->items[a];
+		swayc_t *pb = (swayc_t *)container->children->items[b];
+		container->children->items[a] = container->children->items[b];
+		container->children->items[b] = pa;
+		if (is_auto_layout(container->layout)) {
+			size_t ga = auto_group_index(container, a);
+			size_t gb = auto_group_index(container, b);
+			if (ga != gb) {
+				swap_geometry(pa, pb);
+			}
+		}
+	}
+}
+
+void move_container(swayc_t *container, enum movement_direction dir, int move_amt) {
+	enum swayc_layouts layout = L_NONE;
+	swayc_t *parent = container->parent;
+	if (container->is_floating) {
+		swayc_t *output = swayc_parent_by_type(container, C_OUTPUT);
+		switch(dir) {
+		case MOVE_LEFT:
+			container->x = MAX(0, container->x - move_amt);
+			break;
+		case MOVE_RIGHT:
+			container->x = MIN(output->width - container->width, container->x + move_amt);
+			break;
+		case MOVE_UP:
+			container->y = MAX(0, container->y - move_amt);
+			break;
+		case MOVE_DOWN:
+			container->y = MIN(output->height - container->height, container->y + move_amt);
+			break;
+		default:
+			break;
+		}
+		update_geometry(container);
+		return;
+	}
+	if (container->type != C_VIEW && container->type != C_CONTAINER) {
+		return;
+	}
+	if (dir == MOVE_UP || dir == MOVE_DOWN) {
+		layout = L_VERT;
+	} else if (dir == MOVE_LEFT || dir == MOVE_RIGHT) {
+		layout = L_HORIZ;
+	} else if (dir == MOVE_FIRST) {
+		// swap first child in auto layout with currently focused child
+		if (is_auto_layout(parent->layout)) {
+			int focused_idx = index_child(container);
+			swayc_t *first = parent->children->items[0];
+			if (focused_idx > 0) {
+				list_swap(parent->children, 0, focused_idx);
+				swap_geometry(first, container);
+			}
+			arrange_windows(parent->parent, -1, -1);
+			ipc_event_window(container, "move");
+			set_focused_container_for(parent->parent, container);
+		}
+		return;
+	} else if (! (dir == MOVE_NEXT || dir == MOVE_PREV)) {
+		return;
+	}
+	swayc_t *child = container;
+	bool ascended = false;
+
+	// View is wrapped in intermediate container which is needed for displaying
+	// the titlebar. Moving only the view outside of its parent container would just
+	// wrap it again under worspace. There would effectively be no movement,
+	// just a change of wrapping container.
+	if (child->type == C_VIEW &&
+		parent->type == C_CONTAINER &&
+		parent->children->length == 1 &&
+		parent->parent->type == C_WORKSPACE) {
+		child = parent;
+		parent = parent->parent;
+	}
+
+	while (true) {
+		sway_log(L_DEBUG, "container:%p, parent:%p, child %p,",
+				container,parent,child);
+		if (parent->layout == layout
+			|| (layout == L_NONE && (parent->type == C_CONTAINER || parent->type == C_WORKSPACE)) /* accept any layout for next/prev direction */
+			|| (parent->layout == L_TABBED && layout == L_HORIZ)
+			|| (parent->layout == L_STACKED && layout == L_VERT)
+			|| is_auto_layout(parent->layout)) {
+			int diff;
+			// If it has ascended (parent has moved up), no container is removed
+			// so insert it at index, or index+1.
+			// if it has not, the moved container is removed, so it needs to be
+			// inserted at index-1, or index+1
+			if (ascended) {
+				diff = dir == MOVE_LEFT || dir == MOVE_UP || dir == MOVE_PREV ? 0 : 1;
+			} else {
+				diff = dir == MOVE_LEFT || dir == MOVE_UP || dir == MOVE_PREV ? -1 : 1;
+			}
+			int idx = index_child(child);
+			int desired = idx + diff;
+			if (dir == MOVE_NEXT || dir == MOVE_PREV) {
+				// Next/Prev always wrap.
+				if (desired < 0) {
+					desired += parent->children->length;
+				} else if (desired >= parent->children->length) {
+					desired = 0;
+				}
+			}
+			// when it has ascended, legal insertion position is 0:len
+			// when it has not, legal insertion position is 0:len-1
+			if (desired >= 0 && desired - ascended < parent->children->length) {
+				if (!ascended) {
+					child = parent->children->items[desired];
+					// Move container into sibling container
+					if (child->type == C_CONTAINER) {
+						parent = child;
+						// Insert it in first/last if matching layout, otherwise
+						// insert it next to focused container
+						if (parent->layout == layout
+							|| (parent->layout == L_TABBED && layout == L_HORIZ)
+							|| (parent->layout == L_STACKED && layout == L_VERT)
+							|| is_auto_layout(parent->layout)) {
+							desired = (diff < 0) * parent->children->length;
+						} else {
+							desired = index_child(child->focused) + 1;
+						}
+						//reset geometry
+						container->width = container->height = 0;
+					}
+				}
+				if (container->parent == parent) {
+					swap_children(parent, idx, desired);
+				} else {
+					swayc_t *old_parent = remove_child(container);
+					insert_child(parent, container, desired);
+					destroy_container(old_parent);
+					sway_log(L_DEBUG,"Moving to %p %d", parent, desired);
+				}
+				break;
+			}
+		}
+		// Change parent layout if we need to
+		if (parent->children->length == 1 && parent->layout != layout && layout != L_NONE) {
+			/* swayc_change_layout(parent, layout); */
+			parent->layout = layout;
+			continue;
+		}
+		if (parent->type == C_WORKSPACE) {
+			// If moving to an adjacent output we need a starting position (since this
+			// output might border to multiple outputs).
+			struct wlc_point abs_pos;
+			get_absolute_center_position(container, &abs_pos);
+
+			swayc_t *output = swayc_adjacent_output(parent->parent, dir, &abs_pos, true);
+
+			if (output) {
+				sway_log(L_DEBUG, "Moving between outputs");
+				swayc_t *old_parent = remove_child(container);
+				destroy_container(old_parent);
+
+				swayc_t *dest = output->focused;
+				switch (dir) {
+				case MOVE_LEFT:
+				case MOVE_UP:
+					// reset container geometry
+					container->width = container->height = 0;
+					add_child(dest, container);
+					break;
+				case MOVE_RIGHT:
+				case MOVE_DOWN:
+					// reset container geometry
+					container->width = container->height = 0;
+					insert_child(dest, container, 0);
+					break;
+				default:
+					break;
+				}
+				// arrange new workspace
+				arrange_windows(dest, -1, -1);
+				set_focused_container(container);
+				break;
+			}
+
+			// We simply cannot move any further.
+			if (parent->layout == layout) {
+				break;
+			}
+			// Create container around workspace to insert child into
+			parent = new_container(parent, layout);
+			// Previous line set the resulting container's layout to
+			// workspace_layout. It should have been just layout.
+			parent->layout = parent->parent->layout;
+		}
+		ascended = true;
+		child = parent;
+		parent = child->parent;
+	}
+	arrange_windows(parent->parent, -1, -1);
+	ipc_event_window(container, "move");
+	set_focused_container_for(parent->parent, container);
+}
+
+void move_container_to(swayc_t* container, swayc_t* destination) {
+	if (container == destination || swayc_is_parent_of(container, destination)) {
+		return;
+	}
+	swayc_t *parent = remove_child(container);
+	// Send to new destination
+	if (container->is_floating) {
+		swayc_t *ws = swayc_active_workspace_for(destination);
+		add_floating(ws, container);
+
+		// If the workspace only has one child after adding one, it
+		// means that the workspace was just initialized.
+		if (ws->children->length + ws->floating->length == 1) {
+			ipc_event_workspace(NULL, ws, "init");
+		}
+	} else if (destination->type == C_WORKSPACE) {
+		// reset container geometry
+		container->width = container->height = 0;
+		add_child(destination, container);
+
+		// If the workspace only has one child after adding one, it
+		// means that the workspace was just initialized.
+		if (destination->children->length + destination->floating->length == 1) {
+			ipc_event_workspace(NULL, destination, "init");
+		}
+	} else {
+		// reset container geometry
+		container->width = container->height = 0;
+		add_sibling(destination, container);
+	}
+	// Destroy old container if we need to
+	parent = destroy_container(parent);
+	// Refocus
+	swayc_t *op1 = swayc_parent_by_type(destination, C_OUTPUT);
+	swayc_t *op2 = swayc_parent_by_type(parent, C_OUTPUT);
+	set_focused_container(get_focused_view(op1));
+	arrange_windows(op1, -1, -1);
+	update_visibility(op1);
+	if (op1 != op2) {
+		set_focused_container(get_focused_view(op2));
+		arrange_windows(op2, -1, -1);
+		update_visibility(op2);
+	}
+}
+
+void move_workspace_to(swayc_t* workspace, swayc_t* destination) {
+	if (workspace == destination || swayc_is_parent_of(workspace, destination)) {
+		return;
+	}
+	swayc_t *src_op = remove_child(workspace);
+	// reset container geometry
+	workspace->width = workspace->height = 0;
+	add_child(destination, workspace);
+	sort_workspaces(destination);
+	// Refocus destination (change to new workspace)
+	set_focused_container(get_focused_view(workspace));
+	arrange_windows(destination, -1, -1);
+	update_visibility(destination);
+
+	// make sure source output has a workspace
+	if (src_op->children->length == 0) {
+		char *ws_name = workspace_next_name(src_op->name);
+		swayc_t *ws = new_workspace(src_op, ws_name);
+		ws->is_focused = true;
+		free(ws_name);
+	}
+	set_focused_container(get_focused_view(src_op));
+	update_visibility(src_op);
+}
+
+static void adjust_border_geometry(swayc_t *c, struct wlc_geometry *g,
+	const struct wlc_size *res, int left, int right, int top, int bottom) {
+
+	g->size.w += left + right;
+	if (g->origin.x - left < 0) {
+		g->size.w += g->origin.x - left;
+	} else if (g->origin.x + g->size.w - right > res->w) {
+		g->size.w = res->w - g->origin.x + right;
+	}
+
+	g->size.h += top + bottom;
+	if (g->origin.y - top < 0) {
+		g->size.h += g->origin.y - top;
+	} else if (g->origin.y + g->size.h - top > res->h) {
+		g->size.h = res->h - g->origin.y + top;
+	}
+
+	g->origin.x = MIN((uint32_t)MAX(g->origin.x - left, 0), res->w);
+	g->origin.y = MIN((uint32_t)MAX(g->origin.y - top, 0), res->h);
+
+}
+
+static void update_border_geometry_floating(swayc_t *c, struct wlc_geometry *geometry) {
+	struct wlc_geometry g = *geometry;
+	c->actual_geometry = g;
+
+	swayc_t *output = swayc_parent_by_type(c, C_OUTPUT);
+	struct wlc_size res;
+	output_get_scaled_size(output->handle, &res);
+
+	switch (c->border_type) {
+	case B_NONE:
+		break;
+	case B_PIXEL:
+		adjust_border_geometry(c, &g, &res, c->border_thickness,
+			c->border_thickness, c->border_thickness, c->border_thickness);
+		break;
+	case B_NORMAL:
+	{
+		int title_bar_height = config->font_height + 4; // borders + padding
+
+		adjust_border_geometry(c, &g, &res, c->border_thickness,
+			c->border_thickness, title_bar_height, c->border_thickness);
+
+		struct wlc_geometry title_bar = {
+			.origin = {
+				.x = c->actual_geometry.origin.x - c->border_thickness,
+				.y = c->actual_geometry.origin.y - title_bar_height
+			},
+			.size = {
+				.w = c->actual_geometry.size.w + (2 * c->border_thickness),
+				.h = title_bar_height
+			}
+		};
+		c->title_bar_geometry = title_bar;
+		break;
+	}
+	}
+
+	c->border_geometry = g;
+	*geometry = c->actual_geometry;
+
+	update_container_border(c);
+}
+
+void update_layout_geometry(swayc_t *parent, enum swayc_layouts prev_layout) {
+	switch (parent->layout) {
+	case L_TABBED:
+	case L_STACKED:
+		if (prev_layout != L_TABBED && prev_layout != L_STACKED) {
+			// cache current geometry for all non-float children
+			int i;
+			for (i = 0; i < parent->children->length; ++i) {
+				swayc_t *child = parent->children->items[i];
+				child->cached_geometry.origin.x = child->x;
+				child->cached_geometry.origin.y = child->y;
+				child->cached_geometry.size.w = child->width;
+				child->cached_geometry.size.h = child->height;
+			}
+		}
+		break;
+	default:
+		if (prev_layout == L_TABBED || prev_layout == L_STACKED) {
+			// recover cached geometry for all non-float children
+			int i;
+			for (i = 0; i < parent->children->length; ++i) {
+				swayc_t *child = parent->children->items[i];
+				// only recoverer cached geometry if non-zero
+				if (!wlc_geometry_equals(&child->cached_geometry, &wlc_geometry_zero)) {
+					child->x = child->cached_geometry.origin.x;
+					child->y = child->cached_geometry.origin.y;
+					child->width = child->cached_geometry.size.w;
+					child->height = child->cached_geometry.size.h;
+				}
+			}
+		}
+		break;
+	}
+}
+
+static int update_gap_geometry(swayc_t *container, struct wlc_geometry *g) {
+	swayc_t *ws = swayc_parent_by_type(container, C_WORKSPACE);
+	swayc_t *op = ws->parent;
+	int gap = container->is_floating ? 0 : swayc_gap(container);
+	if (gap % 2 != 0) {
+		// because gaps are implemented as "half sized margins" it's currently
+		// not possible to align views properly with odd sized gaps.
+		gap -= 1;
+	}
+
+	g->origin.x = container->x + gap/2 < op->width  ? container->x + gap/2 : op->width-1;
+	g->origin.y = container->y + gap/2 < op->height ? container->y + gap/2 : op->height-1;
+	g->size.w = container->width > gap ? container->width - gap : 1;
+	g->size.h = container->height > gap ? container->height - gap : 1;
+
+	if ((!config->edge_gaps && gap > 0) || (config->smart_gaps && ws->children->length == 1)) {
+		// Remove gap against the workspace edges. Because a pixel is not
+		// divisable, depending on gap size and the number of siblings our view
+		// might be at the workspace edge without being exactly so (thus test
+		// with gap, and align correctly).
+		if (container->x - gap <= ws->x) {
+			g->origin.x = ws->x;
+			g->size.w = container->width - gap/2;
+		}
+		if (container->y - gap <= ws->y) {
+			g->origin.y = ws->y;
+			g->size.h = container->height - gap/2;
+		}
+		if (container->x + container->width + gap >= ws->x + ws->width) {
+			g->size.w = ws->x + ws->width - g->origin.x;
+		}
+		if (container->y + container->height + gap >= ws->y + ws->height) {
+			g->size.h = ws->y + ws->height - g->origin.y;
+		}
+	}
+
+	return gap;
+}
+
+void update_geometry(swayc_t *container) {
+	if (container->type != C_VIEW && container->type != C_CONTAINER) {
+		return;
+	}
+
+	swayc_t *workspace = swayc_parent_by_type(container, C_WORKSPACE);
+	swayc_t *op = workspace->parent;
+	swayc_t *parent = container->parent;
+
+	struct wlc_geometry geometry = {
+		.origin = {
+			.x = container->x < op->width ? container->x : op->width-1,
+			.y = container->y < op->height ? container->y : op->height-1
+		},
+		.size = {
+			.w = container->width,
+			.h = container->height,
+		}
+	};
+
+	int gap = 0;
+
+	// apply inner gaps to non-tabbed/stacked containers
+	swayc_t *p = swayc_tabbed_stacked_ancestor(container);
+	if (p == NULL) {
+		gap = update_gap_geometry(container, &geometry);
+	}
+
+	swayc_t *output = swayc_parent_by_type(container, C_OUTPUT);
+	struct wlc_size size;
+	output_get_scaled_size(output->handle, &size);
+
+	if (swayc_is_fullscreen(container)) {
+		geometry.origin.x = 0;
+		geometry.origin.y = 0;
+		geometry.size.w = size.w;
+		geometry.size.h = size.h;
+		if (op->focused == workspace) {
+			wlc_view_bring_to_front(container->handle);
+		}
+
+		container->border_geometry = wlc_geometry_zero;
+		container->title_bar_geometry = wlc_geometry_zero;
+		border_clear(container->border);
+	} else if (container->is_floating) { // allocate border for floating window
+		update_border_geometry_floating(container, &geometry);
+	} else if (!container->is_floating) { // allocate border for titled window
+		container->border_geometry = geometry;
+
+		int border_top = container->border_thickness;
+		int border_bottom = container->border_thickness;
+		int border_left = container->border_thickness;
+		int border_right = container->border_thickness;
+
+		// handle hide_edge_borders
+		if (config->hide_edge_borders != E_NONE && (gap <= 0 || (config->smart_gaps && workspace->children->length == 1))) {
+			if (config->hide_edge_borders == E_VERTICAL || config->hide_edge_borders == E_BOTH) {
+				if (geometry.origin.x == workspace->x) {
+					border_left = 0;
+				}
+
+				if (geometry.origin.x + geometry.size.w == workspace->x + workspace->width) {
+					border_right = 0;
+				}
+			}
+
+			if (config->hide_edge_borders == E_HORIZONTAL || config->hide_edge_borders == E_BOTH) {
+				if (geometry.origin.y == workspace->y || should_hide_top_border(container, geometry.origin.y)) {
+					border_top = 0;
+				}
+
+				if (geometry.origin.y + geometry.size.h == workspace->y + workspace->height) {
+					border_bottom = 0;
+				}
+			}
+
+			if (config->hide_edge_borders == E_SMART && workspace->children->length == 1) {
+				border_top = 0;
+				border_bottom = 0;
+				border_left = 0;
+				border_right = 0;
+			}
+		}
+
+		int title_bar_height = config->font_height + 4; //borders + padding
+
+		if (parent->layout == L_TABBED && parent->children->length > 1) {
+			int i, x = 0, w, l, r;
+			l = parent->children->length;
+			w = geometry.size.w / l;
+			r = geometry.size.w % l;
+			for (i = 0; i < parent->children->length; ++i) {
+				swayc_t *view = parent->children->items[i];
+				if (view == container) {
+					x = w * i;
+					if (i == l - 1) {
+						w += r;
+					}
+					break;
+				}
+			}
+
+			struct wlc_geometry title_bar = {
+				.origin = {
+					.x = container->border_geometry.origin.x + x,
+					.y = container->border_geometry.origin.y
+				},
+				.size = {
+					.w = w,
+					.h = title_bar_height
+				}
+			};
+			geometry.origin.x += border_left;
+			geometry.origin.y += title_bar.size.h;
+			geometry.size.w -= (border_left + border_right);
+			geometry.size.h -= (border_bottom + title_bar.size.h);
+			container->title_bar_geometry = title_bar;
+		} else if (parent->layout == L_STACKED && parent->children->length > 1) {
+			int i, y = 0;
+			for (i = 0; i < parent->children->length; ++i) {
+				swayc_t *view = parent->children->items[i];
+				if (view == container) {
+					y = title_bar_height * i;
+				}
+			}
+
+			struct wlc_geometry title_bar = {
+				.origin = {
+					.x = container->border_geometry.origin.x,
+					.y = container->border_geometry.origin.y + y
+				},
+				.size = {
+					.w = container->border_geometry.size.w,
+					.h = title_bar_height
+				}
+			};
+			title_bar_height = title_bar_height * parent->children->length;
+			geometry.origin.x += border_left;
+			geometry.origin.y += title_bar_height;
+			geometry.size.w -= (border_left + border_right);
+			geometry.size.h -= (border_bottom + title_bar_height);
+			container->title_bar_geometry = title_bar;
+		} else {
+			switch (container->border_type) {
+			case B_NONE:
+				break;
+			case B_PIXEL:
+				geometry.origin.x += border_left;
+				geometry.origin.y += border_top;
+				geometry.size.w -= (border_left + border_right);
+				geometry.size.h -= (border_top + border_bottom);
+				break;
+			case B_NORMAL:
+				{
+					struct wlc_geometry title_bar = {
+						.origin = {
+							.x = container->border_geometry.origin.x,
+							.y = container->border_geometry.origin.y
+						},
+						.size = {
+							.w = container->border_geometry.size.w,
+							.h = title_bar_height
+						}
+					};
+					geometry.origin.x += border_left;
+					geometry.origin.y += title_bar.size.h;
+					geometry.size.w -= (border_left + border_right);
+					geometry.size.h -= (border_bottom + title_bar.size.h);
+					container->title_bar_geometry = title_bar;
+					break;
+				}
+			}
+		}
+
+		container->actual_geometry = geometry;
+
+		if (container->type == C_VIEW) {
+			update_container_border(container);
+		}
+	}
+
+	if (container->type == C_VIEW) {
+		wlc_view_set_geometry(container->handle, 0, &geometry);
+	}
+}
+
+/**
+ * Layout application prototypes
+ */
+static void apply_horiz_layout(swayc_t *container, const double x,
+				const double y, const double width,
+				const double height, const int start,
+				const int end);
+static void apply_vert_layout(swayc_t *container, const double x,
+				const double y, const double width,
+				const double height, const int start,
+				const int end);
+static void apply_tabbed_or_stacked_layout(swayc_t *container, double x,
+				double y, double width,
+				double height);
+
+static void apply_auto_layout(swayc_t *container, const double x, const double y,
+				const double width, const double height,
+				enum swayc_layouts group_layout,
+				bool master_first);
+
+static void arrange_windows_r(swayc_t *container, double width, double height) {
+	int i;
+	if (width == -1 || height == -1) {
+		swayc_log(L_DEBUG, container, "Arranging layout for %p", container);
+		width = container->width;
+		height = container->height;
+	}
+	// pixels are indivisible. if we don't round the pixels, then the view
+	// calculations will be off (e.g. 50.5 + 50.5 = 101, but in reality it's
+	// 50 + 50 = 100). doing it here cascades properly to all width/height/x/y.
+	width = floor(width);
+	height = floor(height);
+
+	sway_log(L_DEBUG, "Arranging layout for %p %s %fx%f+%f,%f", container,
+		 container->name, container->width, container->height, container->x,
+		 container->y);
+
+	double x = 0, y = 0;
+	switch (container->type) {
+	case C_ROOT:
+		for (i = 0; i < container->children->length; ++i) {
+			swayc_t *output = container->children->items[i];
+			sway_log(L_DEBUG, "Arranging output '%s' at %f,%f", output->name, output->x, output->y);
+			arrange_windows_r(output, -1, -1);
+		}
+		return;
+	case C_OUTPUT:
+		{
+			struct wlc_size resolution;
+			output_get_scaled_size(container->handle, &resolution);
+			width = resolution.w; height = resolution.h;
+			// output must have correct size due to e.g. seamless mouse,
+			// but a workspace might be smaller depending on panels.
+			container->width = width;
+			container->height = height;
+		}
+		// arrange all workspaces:
+		for (i = 0; i < container->children->length; ++i) {
+			swayc_t *child = container->children->items[i];
+			arrange_windows_r(child, -1, -1);
+		}
+		// Bring all unmanaged views to the front
+		for (i = 0; i < container->unmanaged->length; ++i) {
+			wlc_handle *handle = container->unmanaged->items[i];
+			wlc_view_bring_to_front(*handle);
+		}
+		return;
+	case C_WORKSPACE:
+		{
+			swayc_t *output = swayc_parent_by_type(container, C_OUTPUT);
+			width = output->width, height = output->height;
+			/* TODO WLR
+			for (i = 0; i < desktop_shell.panels->length; ++i) {
+				struct panel_config *config = desktop_shell.panels->items[i];
+				if (config->output == output->handle) {
+					struct wlc_size size = *wlc_surface_get_size(config->surface);
+					sway_log(L_DEBUG, "-> Found panel for this workspace: %ux%u, position: %u", size.w, size.h, config->panel_position);
+					switch (config->panel_position) {
+					case DESKTOP_SHELL_PANEL_POSITION_TOP:
+						y += size.h; height -= size.h;
+						break;
+					case DESKTOP_SHELL_PANEL_POSITION_BOTTOM:
+						height -= size.h;
+						break;
+					case DESKTOP_SHELL_PANEL_POSITION_LEFT:
+						x += size.w; width -= size.w;
+						break;
+					case DESKTOP_SHELL_PANEL_POSITION_RIGHT:
+						width -= size.w;
+						break;
+					}
+				}
+			}
+			*/
+			int gap = swayc_gap(container);
+			x = container->x = x + gap;
+			y = container->y = y + gap;
+			width = container->width = width - gap * 2;
+			height = container->height = height - gap * 2;
+			sway_log(L_DEBUG, "Arranging workspace '%s' at %f, %f", container->name, container->x, container->y);
+		}
+		// children are properly handled below
+		break;
+	case C_VIEW:
+		{
+			container->width = width;
+			container->height = height;
+			update_geometry(container);
+			sway_log(L_DEBUG, "Set view to %.f x %.f @ %.f, %.f", container->width,
+					container->height, container->x, container->y);
+		}
+		return;
+	default:
+		container->width = width;
+		container->height = height;
+		x = container->x;
+		y = container->y;
+
+		// add gaps to top level tapped/stacked container
+		if (container->parent->type == C_WORKSPACE &&
+			(container->layout == L_TABBED || container->layout == L_STACKED)) {
+			update_geometry(container);
+			width = container->border_geometry.size.w;
+			height = container->border_geometry.size.h;
+			x = container->border_geometry.origin.x;
+			y = container->border_geometry.origin.y;
+		}
+
+		// update container size if it's a direct child in a tabbed/stacked layout
+		// if parent is a workspace, its actual_geometry won't be initialized
+		if (swayc_tabbed_stacked_parent(container) != NULL &&
+			container->parent->type != C_WORKSPACE) {
+			// Use parent actual_geometry as a base for calculating
+			// container geometry
+			container->width = container->parent->actual_geometry.size.w;
+			container->height = container->parent->actual_geometry.size.h;
+			container->x = container->parent->actual_geometry.origin.x;
+			container->y = container->parent->actual_geometry.origin.y;
+
+			update_geometry(container);
+			width = container->width = container->actual_geometry.size.w;
+			height = container->height = container->actual_geometry.size.h;
+			x = container->x = container->actual_geometry.origin.x;
+			y = container->y = container->actual_geometry.origin.y;
+		}
+
+		break;
+	}
+
+	switch (container->layout) {
+	case L_HORIZ:
+	default:
+		apply_horiz_layout(container, x, y, width, height, 0,
+			container->children->length);
+		break;
+	case L_VERT:
+		apply_vert_layout(container, x, y, width, height, 0,
+			container->children->length);
+		break;
+	case L_TABBED:
+	case L_STACKED:
+		apply_tabbed_or_stacked_layout(container, x, y, width, height);
+		break;
+	case L_AUTO_LEFT:
+		apply_auto_layout(container, x, y, width, height, L_VERT, true);
+		break;
+	case L_AUTO_RIGHT:
+		apply_auto_layout(container, x, y, width, height, L_VERT, false);
+		break;
+	case L_AUTO_TOP:
+		apply_auto_layout(container, x, y, width, height, L_HORIZ, true);
+		break;
+	case L_AUTO_BOTTOM:
+		apply_auto_layout(container, x, y, width, height, L_HORIZ, false);
+		break;
+	}
+
+	// Arrage floating layouts for workspaces last
+	if (container->type == C_WORKSPACE) {
+		for (int i = 0; i < container->floating->length; ++i) {
+			swayc_t *view = container->floating->items[i];
+			if (view->type == C_VIEW) {
+				update_geometry(view);
+				sway_log(L_DEBUG, "Set floating view to %.f x %.f @ %.f, %.f",
+					 view->width, view->height, view->x, view->y);
+				if (swayc_is_fullscreen(view)) {
+					wlc_view_bring_to_front(view->handle);
+				} else if (!container->focused ||
+						!swayc_is_fullscreen(container->focused)) {
+					wlc_view_bring_to_front(view->handle);
+				}
+			}
+		}
+	}
+}
+
+void apply_horiz_layout(swayc_t *container, const double x, const double y,
+			const double width, const double height,
+			const int start, const int end) {
+	double scale = 0;
+	// Calculate total width
+	for (int i = start; i < end; ++i) {
+		double *old_width = &((swayc_t *)container->children->items[i])->width;
+		if (*old_width <= 0) {
+			if (end - start > 1) {
+				*old_width = width / (end - start - 1);
+			} else {
+				*old_width = width;
+			}
+		}
+		scale += *old_width;
+	}
+	scale = width / scale;
+
+	// Resize windows
+	double child_x = x;
+	if (scale > 0.1) {
+		sway_log(L_DEBUG, "Arranging %p horizontally", container);
+		swayc_t *focused = NULL;
+		for (int i = start; i < end; ++i) {
+			swayc_t *child = container->children->items[i];
+			sway_log(L_DEBUG,
+				 "Calculating arrangement for %p:%d (will scale %f by %f)", child,
+				 child->type, width, scale);
+			child->x = child_x;
+			child->y = y;
+
+			if (child == container->focused) {
+				focused = child;
+			}
+
+			if (i == end - 1) {
+				double remaining_width = x + width - child_x;
+				arrange_windows_r(child, remaining_width, height);
+			} else {
+				arrange_windows_r(child, child->width * scale, height);
+			}
+			child_x += child->width;
+		}
+
+		// update focused view border last because it may
+		// depend on the title bar geometry of its siblings.
+		if (focused && container->children->length > 1) {
+			update_container_border(focused);
+		}
+	}
+}
+
+void apply_vert_layout(swayc_t *container, const double x, const double y,
+			const double width, const double height, const int start,
+			const int end) {
+	int i;
+	double scale = 0;
+	// Calculate total height
+	for (i = start; i < end; ++i) {
+		double *old_height = &((swayc_t *)container->children->items[i])->height;
+		if (*old_height <= 0) {
+			if (end - start > 1) {
+				*old_height = height / (end - start - 1);
+			} else {
+				*old_height = height;
+			}
+		}
+		scale += *old_height;
+	}
+	scale = height / scale;
+
+	// Resize
+	double child_y = y;
+	if (scale > 0.1) {
+		sway_log(L_DEBUG, "Arranging %p vertically", container);
+		swayc_t *focused = NULL;
+		for (i = start; i < end; ++i) {
+			swayc_t *child = container->children->items[i];
+			sway_log(L_DEBUG,
+				 "Calculating arrangement for %p:%d (will scale %f by %f)", child,
+				 child->type, height, scale);
+			child->x = x;
+			child->y = child_y;
+
+			if (child == container->focused) {
+				focused = child;
+			}
+
+			if (i == end - 1) {
+				double remaining_height = y + height - child_y;
+				arrange_windows_r(child, width, remaining_height);
+			} else {
+				arrange_windows_r(child, width, child->height * scale);
+			}
+			child_y += child->height;
+		}
+
+		// update focused view border last because it may
+		// depend on the title bar geometry of its siblings.
+		if (focused && container->children->length > 1) {
+			update_container_border(focused);
+		}
+	}
+}
+
+void apply_tabbed_or_stacked_layout(swayc_t *container, double x, double y,
+					double width, double height) {
+	int i;
+	swayc_t *focused = NULL;
+	for (i = 0; i < container->children->length; ++i) {
+		swayc_t *child = container->children->items[i];
+		child->x = x;
+		child->y = y;
+		if (child == container->focused) {
+			focused = child;
+		} else {
+			arrange_windows_r(child, width, height);
+		}
+	}
+
+	if (focused) {
+		arrange_windows_r(focused, width, height);
+	}
+}
+
+void apply_auto_layout(swayc_t *container, const double x, const double y,
+			const double width, const double height,
+			enum swayc_layouts group_layout,
+			bool master_first) {
+	// Auto layout "container" in width x height @ x, y
+	// using "group_layout" for each of the groups in the container.
+	// There is one "master" group, plus container->nb_slave_groups.
+	// Each group is layed out side by side following the "major" axis.
+	// The direction of the layout used for groups is the "minor" axis.
+	// Example:
+	//
+	//     ---- major axis -->
+	//   +---------+-----------+
+	//   |         |           |   |
+	//   | master  | slave 1   |   |
+	//   |         +-----------+   | minor axis (direction of group_layout)
+	//   |         |           |   |
+	//   |         | slave 2   |   V
+	//   +---------+-----------+
+	//
+	//  container with three children (one master and two slaves) and
+	//  a single slave group (containing slave 1 and 2). The master
+	//  group and slave group are layed out using L_VERT.
+
+	size_t nb_groups = auto_group_count(container);
+
+	// the target dimension of the container along the "major" axis, each
+	// group in the container will be layed out using "group_layout" along
+	// the "minor" axis.
+	double dim_maj;
+	double pos_maj;
+
+	// x and y coords for the next group to be laid out.
+	const double *group_x, *group_y;
+
+	// pos of the next group to layout along the major axis
+	double pos;
+
+	// size of the next group along the major axis.
+	double group_dim;
+
+	// height and width of next group to be laid out.
+	const double *group_h, *group_w;
+
+	switch (group_layout) {
+	default:
+		sway_log(L_DEBUG, "Unknown layout type (%d) used in %s()",
+			 group_layout, __func__);
+		/* fall through */
+	case L_VERT:
+		dim_maj = width;
+		pos_maj = x;
+
+		group_x = &pos;
+		group_y = &y;
+		group_w = &group_dim;
+		group_h = &height;
+		break;
+	case L_HORIZ:
+		dim_maj = height;
+		pos_maj = y;
+
+		group_x = &x;
+		group_y = &pos;
+		group_w = &width;
+		group_h = &group_dim;
+		break;
+	}
+
+	/* Determine the dimension of each of the groups in the layout.
+	 * Dimension will be width for a VERT layout and height for a HORIZ
+	 * layout. */
+	double old_group_dim[nb_groups];
+	double old_dim = 0;
+	for (size_t group = 0; group < nb_groups; ++group) {
+		int idx;
+		if (auto_group_bounds(container, group, &idx, NULL)) {
+			swayc_t *child = container->children->items[idx];
+			double *dim = group_layout == L_HORIZ ? &child->height : &child->width;
+			if (*dim <= 0) {
+				// New child with uninitialized dimension
+				*dim = dim_maj;
+				if (nb_groups > 1) {
+					// child gets a dimension proportional to existing groups,
+					// it will be later scaled based on to the available size
+					// in the major axis.
+					*dim /= (nb_groups - 1);
+				}
+			}
+			old_dim += *dim;
+			old_group_dim[group] = *dim;
+		}
+	}
+	double scale = dim_maj / old_dim;
+
+	/* Apply layout to each group */
+	pos = pos_maj;
+
+	for (size_t group = 0; group < nb_groups; ++group) {
+		int start, end;	// index of first (inclusive) and last (exclusive) child in the group
+		if (auto_group_bounds(container, group, &start, &end)) {
+			// adjusted size of the group
+			group_dim = old_group_dim[group] * scale;
+			if (group == nb_groups - 1) {
+				group_dim = pos_maj + dim_maj - pos; // remaining width
+			}
+			sway_log(L_DEBUG, "Arranging container %p column %zu, children [%d,%d[ (%fx%f+%f,%f)",
+				 container, group, start, end, *group_w, *group_h, *group_x, *group_y);
+			switch (group_layout) {
+			default:
+			case L_VERT:
+				apply_vert_layout(container, *group_x, *group_y, *group_w, *group_h, start, end);
+				break;
+			case L_HORIZ:
+				apply_horiz_layout(container, *group_x, *group_y, *group_w, *group_h, start, end);
+				break;
+			}
+
+			/* update position for next group */
+			pos += group_dim;
+		}
+	}
+}
+
+void arrange_windows(swayc_t *container, double width, double height) {
+	update_visibility(container);
+	arrange_windows_r(container, width, height);
+	layout_log(&root_container, 0);
+}
+
+void arrange_backgrounds(void) {
+	/* TODO WLR
+	struct background_config *bg;
+	for (int i = 0; i < desktop_shell.backgrounds->length; ++i) {
+		bg = desktop_shell.backgrounds->items[i];
+		wlc_view_send_to_back(bg->handle);
+	}
+	*/
+}
+
+/**
+ * Get swayc in the direction of newly entered output.
+ */
+static swayc_t *get_swayc_in_output_direction(swayc_t *output, enum movement_direction dir) {
+	if (!output) {
+		return NULL;
+	}
+
+	swayc_t *ws = swayc_focus_by_type(output, C_WORKSPACE);
+	if (ws && ws->children->length > 0) {
+		switch (dir) {
+		case MOVE_LEFT:
+			// get most right child of new output
+			return ws->children->items[ws->children->length-1];
+		case MOVE_RIGHT:
+			// get most left child of new output
+			return ws->children->items[0];
+		case MOVE_UP:
+		case MOVE_DOWN:
+			{
+				swayc_t *focused_view = swayc_focus_by_type(ws, C_VIEW);
+				if (focused_view && focused_view->parent) {
+					swayc_t *parent = focused_view->parent;
+					if (parent->layout == L_VERT) {
+						if (dir == MOVE_UP) {
+							// get child furthest down on new output
+							return parent->children->items[parent->children->length-1];
+						} else if (dir == MOVE_DOWN) {
+							// get child furthest up on new output
+							return parent->children->items[0];
+						}
+					}
+					return focused_view;
+				}
+				break;
+			}
+		default:
+			break;
+		}
+	}
+
+	return output;
+}
+
+swayc_t *get_swayc_in_direction_under(swayc_t *container, enum movement_direction dir, swayc_t *limit) {
+	if (dir == MOVE_CHILD) {
+		return container->focused;
+	}
+
+	swayc_t *parent = container->parent;
+	if (dir == MOVE_PARENT) {
+		if (parent->type == C_OUTPUT) {
+			return NULL;
+		} else {
+			return parent;
+		}
+	}
+
+	if (dir == MOVE_PREV || dir == MOVE_NEXT) {
+		int focused_idx = index_child(container);
+		if (focused_idx == -1) {
+			return NULL;
+		} else {
+			int desired = (focused_idx + (dir == MOVE_NEXT ? 1 : -1)) %
+				parent->children->length;
+			if (desired < 0) {
+				desired += parent->children->length;
+			}
+			return parent->children->items[desired];
+		}
+	}
+
+	// If moving to an adjacent output we need a starting position (since this
+	// output might border to multiple outputs).
+	struct wlc_point abs_pos;
+	get_absolute_center_position(container, &abs_pos);
+
+	if (container->type == C_VIEW && swayc_is_fullscreen(container)) {
+		sway_log(L_DEBUG, "Moving from fullscreen view, skipping to output");
+		container = swayc_parent_by_type(container, C_OUTPUT);
+		get_absolute_center_position(container, &abs_pos);
+		swayc_t *output = swayc_adjacent_output(container, dir, &abs_pos, true);
+		return get_swayc_in_output_direction(output, dir);
+	}
+
+	if (container->type == C_WORKSPACE && container->fullscreen) {
+		sway_log(L_DEBUG, "Moving to fullscreen view");
+		return container->fullscreen;
+	}
+
+	swayc_t *wrap_candidate = NULL;
+	while (true) {
+		// Test if we can even make a difference here
+		bool can_move = false;
+		int desired;
+		int idx = index_child(container);
+		if (parent->type == C_ROOT) {
+			swayc_t *output = swayc_adjacent_output(container, dir, &abs_pos, true);
+			if (!output || output == container) {
+				return wrap_candidate;
+			}
+			sway_log(L_DEBUG, "Moving between outputs");
+			return get_swayc_in_output_direction(output, dir);
+		} else {
+			if (is_auto_layout(parent->layout)) {
+				bool is_major = parent->layout == L_AUTO_LEFT || parent->layout == L_AUTO_RIGHT
+					? dir == MOVE_LEFT || dir == MOVE_RIGHT
+					: dir == MOVE_DOWN || dir == MOVE_UP;
+				size_t gidx = auto_group_index(parent, idx);
+				if (is_major) {
+					size_t desired_grp = gidx + (dir == MOVE_RIGHT || dir == MOVE_DOWN ? 1 : -1);
+					can_move = auto_group_bounds(parent, desired_grp, &desired, NULL);
+				} else {
+					desired = idx + (dir == MOVE_RIGHT || dir == MOVE_DOWN ? 1 : -1);
+					int start, end;
+					can_move = auto_group_bounds(parent, gidx, &start, &end)
+							&& desired >= start && desired < end;
+				}
+			} else {
+				if (dir == MOVE_LEFT || dir == MOVE_RIGHT) {
+					if (parent->layout == L_HORIZ || parent->layout == L_TABBED) {
+						can_move = true;
+						desired = idx + (dir == MOVE_LEFT ? -1 : 1);
+					}
+				} else {
+					if (parent->layout == L_VERT || parent->layout == L_STACKED) {
+						can_move = true;
+						desired = idx + (dir == MOVE_UP ? -1 : 1);
+					}
+				}
+			}
+		}
+
+		if (can_move) {
+			if (container->is_floating) {
+				if (desired < 0) {
+					wrap_candidate = parent->floating->items[parent->floating->length-1];
+				} else if (desired >= parent->floating->length){
+					wrap_candidate = parent->floating->items[0];
+				} else {
+					wrap_candidate = parent->floating->items[desired];
+				}
+				if (wrap_candidate) {
+					wlc_view_bring_to_front(wrap_candidate->handle);
+				}
+				return wrap_candidate;
+			} else if (desired < 0 || desired >= parent->children->length) {
+				can_move = false;
+				int len = parent->children->length;
+				if (!wrap_candidate && len > 1) {
+					if (desired < 0) {
+						wrap_candidate = parent->children->items[len-1];
+					} else {
+						wrap_candidate = parent->children->items[0];
+					}
+					if (config->force_focus_wrapping) {
+						return wrap_candidate;
+					}
+				}
+			} else {
+				sway_log(L_DEBUG, "%s cont %d-%p dir %i sibling %d: %p", __func__,
+					 idx, container, dir, desired, parent->children->items[desired]);
+				return parent->children->items[desired];
+			}
+		}
+		if (!can_move) {
+			container = parent;
+			parent = parent->parent;
+			if (!parent || container == limit) {
+				// wrapping is the last chance
+				return wrap_candidate;
+			}
+		}
+	}
+}
+
+swayc_t *get_swayc_in_direction(swayc_t *container, enum movement_direction dir) {
+	return get_swayc_in_direction_under(container, dir, NULL);
+}
+
+void recursive_resize(swayc_t *container, double amount, enum wlc_resize_edge edge) {
+	int i;
+	bool layout_match = true;
+	sway_log(L_DEBUG, "Resizing %p with amount: %f", container, amount);
+	if (edge == WLC_RESIZE_EDGE_LEFT || edge == WLC_RESIZE_EDGE_RIGHT) {
+		container->width += amount;
+		layout_match = container->layout == L_HORIZ;
+	} else if (edge == WLC_RESIZE_EDGE_TOP || edge == WLC_RESIZE_EDGE_BOTTOM) {
+		container->height += amount;
+		layout_match = container->layout == L_VERT;
+	}
+	if (container->type == C_VIEW) {
+		update_geometry(container);
+		return;
+	}
+	if (layout_match) {
+		for (i = 0; i < container->children->length; i++) {
+			recursive_resize(container->children->items[i], amount/container->children->length, edge);
+		}
+	} else {
+		for (i = 0; i < container->children->length; i++) {
+			recursive_resize(container->children->items[i], amount, edge);
+		}
+	}
+}
+
+enum swayc_layouts default_layout(swayc_t *output) {
+	if (config->default_layout != L_NONE) {
+		return config->default_layout;
+	} else if (config->default_orientation != L_NONE) {
+		return config->default_orientation;
+	} else if (output->width >= output->height) {
+		return L_HORIZ;
+	} else {
+		return L_VERT;
+	}
+}
+
+bool is_auto_layout(enum swayc_layouts layout) {
+	return (layout >= L_AUTO_FIRST) && (layout <= L_AUTO_LAST);
+}
+
+/**
+ * Return the number of master elements in a container
+ */
+static inline size_t auto_master_count(const swayc_t *container) {
+	sway_assert(container->children->length >= 0, "Container %p has (negative) children %d",
+			container, container->children->length);
+	return MIN(container->nb_master, (size_t)container->children->length);
+}
+
+/**
+ * Return the number of children in the slave groups. This corresponds to the children
+ * that are not members of the master group.
+ */
+static inline size_t auto_slave_count(const swayc_t *container) {
+	return container->children->length - auto_master_count(container);
+}
+
+/**
+ * Return the number of slave groups in the container.
+ */
+size_t auto_slave_group_count(const swayc_t *container) {
+	return MIN(container->nb_slave_groups, auto_slave_count(container));
+}
+
+/**
+ * Return the combined number of master and slave groups in the container.
+ */
+size_t auto_group_count(const swayc_t *container) {
+	return auto_slave_group_count(container)
+		+ (container->children->length && container->nb_master ? 1 : 0);
+}
+
+/**
+ * given the index of a container's child, return the index of the first child of the group
+ * which index is a member of.
+ */
+int auto_group_start_index(const swayc_t *container, int index) {
+	if (index < 0 || ! is_auto_layout(container->layout)
+		|| (size_t)index < container->nb_master) {
+		return 0;
+	} else {
+		size_t nb_slaves = auto_slave_count(container);
+		size_t nb_slave_grp = auto_slave_group_count(container);
+		size_t grp_sz = nb_slaves / nb_slave_grp;
+		size_t remainder = nb_slaves % nb_slave_grp;
+		int idx2 = (nb_slave_grp - remainder) * grp_sz + container->nb_master;
+		int start_idx;
+		if (index < idx2) {
+			start_idx = ((index - container->nb_master) / grp_sz) * grp_sz + container->nb_master;
+		} else {
+			start_idx = idx2 + ((index - idx2) / (grp_sz + 1)) * (grp_sz + 1);
+		}
+		return MIN(start_idx, container->children->length);
+	}
+}
+
+/**
+ * given the index of a container's child, return the index of the first child of the group
+ * that follows the one which index is a member of.
+ * This makes the function usable to walk through the groups in a container.
+ */
+int auto_group_end_index(const swayc_t *container, int index) {
+	if (index < 0 || ! is_auto_layout(container->layout)) {
+		return container->children->length;
+	} else {
+		int nxt_idx;
+		if ((size_t)index < container->nb_master) {
+			nxt_idx = auto_master_count(container);
+		} else {
+			size_t nb_slaves = auto_slave_count(container);
+			size_t nb_slave_grp = auto_slave_group_count(container);
+			size_t grp_sz = nb_slaves / nb_slave_grp;
+			size_t remainder = nb_slaves % nb_slave_grp;
+			int idx2 = (nb_slave_grp - remainder) * grp_sz + container->nb_master;
+			if (index < idx2) {
+				nxt_idx = ((index - container->nb_master) / grp_sz + 1) * grp_sz + container->nb_master;
+			} else {
+				nxt_idx = idx2 + ((index - idx2) / (grp_sz + 1) + 1) * (grp_sz + 1);
+			}
+		}
+		return MIN(nxt_idx, container->children->length);
+	}
+}
+
+/**
+ * return the index of the Group containing <index>th child of <container>.
+ * The index is the order of the group along the container's major axis (starting at 0).
+ */
+size_t auto_group_index(const swayc_t *container, int index) {
+	if (index < 0) {
+		return 0;
+	}
+	bool master_first = (container->layout == L_AUTO_LEFT || container->layout == L_AUTO_TOP);
+	size_t nb_slaves = auto_slave_count(container);
+	if ((size_t)index < container->nb_master) {
+		if (master_first || nb_slaves <= 0) {
+			return 0;
+		} else {
+			return auto_slave_group_count(container);
+		}
+	} else {
+		size_t nb_slave_grp = auto_slave_group_count(container);
+		size_t grp_sz = nb_slaves / nb_slave_grp;
+		size_t remainder = nb_slaves % nb_slave_grp;
+		int idx2 = (nb_slave_grp - remainder) * grp_sz + container->nb_master;
+		size_t grp_idx;
+		if (index < idx2) {
+			grp_idx = (index - container->nb_master) / grp_sz;
+		} else {
+			grp_idx = (nb_slave_grp - remainder) + (index - idx2) / (grp_sz + 1) ;
+		}
+		return grp_idx + (master_first && container-> nb_master ? 1 : 0);
+	}
+}
+
+/**
+ * Return the first index (inclusive) and last index (exclusive) of the elements of a group in
+ * an auto layout.
+ * If the bounds of the given group can be calculated, they are returned in the start/end
+ * parameters (int pointers) and the return value will be true.
+ * The indexes are passed by reference and can be NULL.
+ */
+bool auto_group_bounds(const swayc_t *container, size_t group_index, int *start, int *end) {
+	size_t nb_grp = auto_group_count(container);
+	if (group_index >= nb_grp) {
+		return false;
+	}
+	bool master_first = (container->layout == L_AUTO_LEFT || container->layout == L_AUTO_TOP);
+	size_t nb_master = auto_master_count(container);
+	size_t nb_slave_grp = auto_slave_group_count(container);
+	int g_start, g_end;
+	if (nb_master && (master_first ? group_index == 0 : group_index == nb_grp - 1)) {
+		g_start = 0;
+		g_end = nb_master;
+	} else {
+		size_t nb_slaves = auto_slave_count(container);
+		size_t grp_sz = nb_slaves / nb_slave_grp;
+		size_t remainder = nb_slaves % nb_slave_grp;
+		size_t g0 = master_first && container->nb_master ? 1 : 0;
+		size_t g1 = g0 + nb_slave_grp - remainder;
+		if (group_index < g1) {
+			g_start = container->nb_master + (group_index - g0) * grp_sz;
+			g_end = g_start + grp_sz;
+		} else {
+			size_t g2 = group_index - g1;
+			g_start = container->nb_master
+				+ (nb_slave_grp - remainder) * grp_sz
+				+ g2 * (grp_sz + 1);
+			g_end = g_start + grp_sz + 1;
+		}
+	}
+	if (start) {
+		*start = g_start;
+	}
+	if (end) {
+		*end = g_end;
+	}
+	return true;
+}
diff --git a/sway/tree/output.c b/sway/tree/output.c
new file mode 100644
index 00000000..c0f29c5a
--- /dev/null
+++ b/sway/tree/output.c
@@ -0,0 +1,277 @@
+#include <strings.h>
+#include <ctype.h>
+#include <stdlib.h>
+#include "sway/output.h"
+#include "log.h"
+#include "list.h"
+
+void output_get_scaled_size(wlc_handle handle, struct wlc_size *size) {
+	*size = *wlc_output_get_resolution(handle);
+	uint32_t scale = wlc_output_get_scale(handle);
+	size->w /= scale;
+	size->h /= scale;
+}
+
+swayc_t *output_by_name(const char* name, const struct wlc_point *abs_pos) {
+	swayc_t *output = NULL;
+	// If there is no output directly next to the current one, use
+	// swayc_opposite_output to wrap.
+	if (strcasecmp(name, "left") == 0) {
+		output = swayc_adjacent_output(NULL, MOVE_LEFT, abs_pos, true);
+		if (!output) {
+			output = swayc_opposite_output(MOVE_RIGHT, abs_pos);
+		}
+	} else if (strcasecmp(name, "right") == 0) {
+		output = swayc_adjacent_output(NULL, MOVE_RIGHT, abs_pos, true);
+		if (!output) {
+			output = swayc_opposite_output(MOVE_LEFT, abs_pos);
+		}
+	} else if (strcasecmp(name, "up") == 0) {
+		output = swayc_adjacent_output(NULL, MOVE_UP, abs_pos, true);
+		if (!output) {
+			output = swayc_opposite_output(MOVE_DOWN, abs_pos);
+		}
+	} else if (strcasecmp(name, "down") == 0) {
+		output = swayc_adjacent_output(NULL, MOVE_DOWN, abs_pos, true);
+		if (!output) {
+			output = swayc_opposite_output(MOVE_UP, abs_pos);
+		}
+	} else {
+		for(int i = 0; i < root_container.children->length; ++i) {
+			swayc_t *c = root_container.children->items[i];
+			if (c->type == C_OUTPUT && strcasecmp(c->name, name) == 0) {
+				return c;
+			}
+		}
+	}
+	return output;
+}
+
+swayc_t *swayc_opposite_output(enum movement_direction dir,
+		const struct wlc_point *abs_pos) {
+
+	// Search through all the outputs and pick the output whose edge covers the
+	// given position, and is at leftmost/rightmost/upmost/downmost side of the
+	// screen (decided by the direction given).
+	swayc_t *opposite = NULL;
+	char *dir_text = NULL;
+	switch(dir) {
+		case MOVE_LEFT:
+		case MOVE_RIGHT: ;
+			for (int i = 0; i < root_container.children->length; ++i) {
+				swayc_t *c = root_container.children->items[i];
+				if (abs_pos->y >= c->y && abs_pos->y <= c->y + c->height) {
+					if (!opposite) {
+						opposite = c;
+					} else if ((dir == MOVE_LEFT && c->x < opposite->x)
+							|| (dir == MOVE_RIGHT && c->x > opposite->x)) {
+						opposite = c;
+					}
+				}
+			}
+			dir_text = dir == MOVE_LEFT ? "leftmost" : "rightmost";
+			break;
+		case MOVE_UP:
+		case MOVE_DOWN: ;
+			for (int i = 0; i < root_container.children->length; ++i) {
+				swayc_t *c = root_container.children->items[i];
+				if (abs_pos->x >= c->x && abs_pos->x <= c->x + c->width) {
+					if (!opposite) {
+						opposite = c;
+					} else if ((dir == MOVE_UP && c->y < opposite->y)
+							|| (dir == MOVE_DOWN && c->y > opposite->y)) {
+						opposite = c;
+					}
+				}
+			}
+			dir_text = dir == MOVE_UP ? "upmost" : "downmost";
+			break;
+		default:
+			sway_abort("Function called with invalid argument.");
+			break;
+	}
+	if (opposite) {
+		sway_log(L_DEBUG, "%s (%.0fx%.0f+%.0f+%.0f) is %s from y-position %i",
+				opposite->name, opposite->width, opposite->height, opposite->x, opposite->y,
+				dir_text, abs_pos->y);
+	}
+	return opposite;
+}
+
+// Position is where on the edge (as absolute position) the adjacent output should be searched for.
+swayc_t *swayc_adjacent_output(swayc_t *output, enum movement_direction dir,
+		const struct wlc_point *abs_pos, bool pick_closest) {
+
+	if (!output) {
+		output = swayc_active_output();
+	}
+	// In order to find adjacent outputs we need to test that the outputs are
+	// aligned on one axis (decided by the direction given) and that the given
+	// position is within the edge of the adjacent output. If no such output
+	// exists we pick the adjacent output within the edge that is closest to
+	// the given position, if any.
+	swayc_t *adjacent = NULL;
+	char *dir_text = NULL;
+	switch(dir) {
+		case MOVE_LEFT:
+		case MOVE_RIGHT: ;
+			double delta_y = 0;
+			for(int i = 0; i < root_container.children->length; ++i) {
+				swayc_t *c = root_container.children->items[i];
+				if (c == output || c->type != C_OUTPUT) {
+					continue;
+				}
+				bool x_aligned = dir == MOVE_LEFT ?
+					c->x + c->width == output->x :
+					c->x == output->x + output->width;
+				if (!x_aligned) {
+					continue;
+				}
+				if (abs_pos->y >= c->y && abs_pos->y <= c->y + c->height) {
+					delta_y = 0;
+					adjacent = c;
+					break;
+				} else if (pick_closest) {
+					// track closest adjacent output
+					double top_y = c->y, bottom_y = c->y + c->height;
+					if (top_y >= output->y && top_y <= output->y + output->height) {
+						double delta = top_y - abs_pos->y;
+						if (delta < 0) delta = -delta;
+						if (delta < delta_y || !adjacent) {
+							delta_y = delta;
+							adjacent = c;
+						}
+					}
+					// we check both points and pick the closest
+					if (bottom_y >= output->y && bottom_y <= output->y + output->height) {
+						double delta = bottom_y - abs_pos->y;
+						if (delta < 0) delta = -delta;
+						if (delta < delta_y || !adjacent) {
+							delta_y = delta;
+							adjacent = c;
+						}
+					}
+				}
+			}
+			dir_text = dir == MOVE_LEFT ? "left of" : "right of";
+			if (adjacent && delta_y == 0) {
+				sway_log(L_DEBUG, "%s (%.0fx%.0f+%.0f+%.0f) is %s current output %s (y-position %i)",
+						adjacent->name, adjacent->width, adjacent->height, adjacent->x, adjacent->y,
+						dir_text, output->name, abs_pos->y);
+			} else if (adjacent) {
+				// so we end up picking the closest adjacent output because
+				// there is no directly adjacent to the given position
+				sway_log(L_DEBUG, "%s (%.0fx%.0f+%.0f+%.0f) is %s current output %s (y-position %i, delta: %.0f)",
+					adjacent->name, adjacent->width, adjacent->height, adjacent->x, adjacent->y,
+					dir_text, output->name, abs_pos->y, delta_y);
+			}
+			break;
+		case MOVE_UP:
+		case MOVE_DOWN: ;
+			double delta_x = 0;
+			for(int i = 0; i < root_container.children->length; ++i) {
+				swayc_t *c = root_container.children->items[i];
+				if (c == output || c->type != C_OUTPUT) {
+					continue;
+				}
+				bool y_aligned = dir == MOVE_UP ?
+					c->y + c->height == output->y :
+					c->y == output->y + output->height;
+				if (!y_aligned) {
+					continue;
+				}
+				if (abs_pos->x >= c->x && abs_pos->x <= c->x + c->width) {
+					delta_x = 0;
+					adjacent = c;
+					break;
+				} else if (pick_closest) {
+					// track closest adjacent output
+					double left_x = c->x, right_x = c->x + c->width;
+					if (left_x >= output->x && left_x <= output->x + output->width) {
+						double delta = left_x - abs_pos->x;
+						if (delta < 0) delta = -delta;
+						if (delta < delta_x || !adjacent) {
+							delta_x = delta;
+							adjacent = c;
+						}
+					}
+					// we check both points and pick the closest
+					if (right_x >= output->x && right_x <= output->x + output->width) {
+						double delta = right_x - abs_pos->x;
+						if (delta < 0) delta = -delta;
+						if (delta < delta_x || !adjacent) {
+							delta_x = delta;
+							adjacent = c;
+						}
+					}
+				}
+			}
+			dir_text = dir == MOVE_UP ? "above" : "below";
+			if (adjacent && delta_x == 0) {
+				sway_log(L_DEBUG, "%s (%.0fx%.0f+%.0f+%.0f) is %s current output %s (x-position %i)",
+						adjacent->name, adjacent->width, adjacent->height, adjacent->x, adjacent->y,
+						dir_text, output->name, abs_pos->x);
+			} else if (adjacent) {
+				// so we end up picking the closest adjacent output because
+				// there is no directly adjacent to the given position
+				sway_log(L_DEBUG, "%s (%.0fx%.0f+%.0f+%.0f) is %s current output %s (x-position %i, delta: %.0f)",
+					adjacent->name, adjacent->width, adjacent->height, adjacent->x, adjacent->y,
+					dir_text, output->name, abs_pos->x, delta_x);
+			}
+			break;
+		default:
+			sway_abort("Function called with invalid argument.");
+			break;
+	}
+	return adjacent;
+}
+
+void get_absolute_position(swayc_t *container, struct wlc_point *point) {
+	if (!container || !point)
+		sway_abort("Need container and wlc_point (was %p, %p).", container, point);
+
+	if (container->type == C_OUTPUT) {
+		// Coordinates are already absolute.
+		point->x = container->x;
+		point->y = container->y;
+	} else {
+		swayc_t *output = swayc_parent_by_type(container, C_OUTPUT);
+		if (container->type == C_WORKSPACE) {
+			// Workspace coordinates are actually wrong/arbitrary, but should
+			// be same as output.
+			point->x = output->x;
+			point->y = output->y;
+		} else {
+			point->x = output->x + container->x;
+			point->y = output->y + container->y;
+		}
+	}
+}
+
+void get_absolute_center_position(swayc_t *container, struct wlc_point *point) {
+	get_absolute_position(container, point);
+	point->x += container->width/2;
+	point->y += container->height/2;
+}
+
+static int sort_workspace_cmp_qsort(const void *_a, const void *_b) {
+	swayc_t *a = *(void **)_a;
+	swayc_t *b = *(void **)_b;
+	int retval = 0;
+
+	if (isdigit(a->name[0]) && isdigit(b->name[0])) {
+		int a_num = strtol(a->name, NULL, 10);
+		int b_num = strtol(b->name, NULL, 10);
+		retval = (a_num < b_num) ? -1 : (a_num > b_num);
+	} else if (isdigit(a->name[0])) {
+		retval = -1;
+	} else if (isdigit(b->name[0])) {
+		retval = 1;
+	}
+
+	return retval;
+}
+
+void sort_workspaces(swayc_t *output) {
+	list_stable_sort(output->children, sort_workspace_cmp_qsort);
+}
diff --git a/sway/tree/workspace.c b/sway/tree/workspace.c
new file mode 100644
index 00000000..14cde146
--- /dev/null
+++ b/sway/tree/workspace.c
@@ -0,0 +1,373 @@
+#define _XOPEN_SOURCE 500
+#include <stdlib.h>
+#include <stdbool.h>
+#include <limits.h>
+#include <ctype.h>
+#include <wlc/wlc.h>
+#include <string.h>
+#include <strings.h>
+#include <sys/types.h>
+#include "sway/ipc-server.h"
+#include "sway/workspace.h"
+#include "sway/layout.h"
+#include "sway/container.h"
+#include "sway/handlers.h"
+#include "sway/config.h"
+#include "sway/focus.h"
+#include "stringop.h"
+#include "util.h"
+#include "list.h"
+#include "log.h"
+#include "ipc.h"
+
+char *prev_workspace_name = NULL;
+struct workspace_by_number_data {
+	int len;
+	const char *cset;
+	const char *name;
+};
+
+static bool workspace_valid_on_output(const char *output_name, const char *ws_name) {
+	int i;
+	for (i = 0; i < config->workspace_outputs->length; ++i) {
+		struct workspace_output *wso = config->workspace_outputs->items[i];
+		if (strcasecmp(wso->workspace, ws_name) == 0) {
+			if (strcasecmp(wso->output, output_name) != 0) {
+				return false;
+			}
+		}
+	}
+
+	return true;
+}
+
+char *workspace_next_name(const char *output_name) {
+	sway_log(L_DEBUG, "Workspace: Generating new workspace name for output %s", output_name);
+	int i;
+	int l = 1;
+	// Scan all workspace bindings to find the next available workspace name,
+	// if none are found/available then default to a number
+	struct sway_mode *mode = config->current_mode;
+
+	int order = INT_MAX;
+	char *target = NULL;
+	for (i = 0; i < mode->bindings->length; ++i) {
+		struct sway_binding *binding = mode->bindings->items[i];
+		char *cmdlist = strdup(binding->command);
+		char *dup = cmdlist;
+		char *name = NULL;
+
+		// workspace n
+		char *cmd = argsep(&cmdlist, " ");
+		if (cmdlist) {
+			name = argsep(&cmdlist, ",;");
+		}
+
+		if (strcmp("workspace", cmd) == 0 && name) {
+			sway_log(L_DEBUG, "Got valid workspace command for target: '%s'", name);
+			char *_target = strdup(name);
+			strip_quotes(_target);
+			while (isspace(*_target))
+				_target++;
+
+			// Make sure that the command references an actual workspace
+			// not a command about workspaces
+			if (strcmp(_target, "next") == 0 ||
+				strcmp(_target, "prev") == 0 ||
+				strcmp(_target, "next_on_output") == 0 ||
+				strcmp(_target, "prev_on_output") == 0 ||
+				strcmp(_target, "number") == 0 ||
+				strcmp(_target, "back_and_forth") == 0 ||
+				strcmp(_target, "current") == 0)
+			{
+				free(_target);
+				free(dup);
+				continue;
+			}
+
+			// Make sure that the workspace doesn't already exist
+			if (workspace_by_name(_target)) {
+				free(_target);
+				free(dup);
+				continue;
+			}
+
+			// make sure that the workspace can appear on the given
+			// output
+			if (!workspace_valid_on_output(output_name, _target)) {
+				free(_target);
+				free(dup);
+				continue;
+			}
+
+			if (binding->order < order) {
+				order = binding->order;
+				free(target);
+				target = _target;
+				sway_log(L_DEBUG, "Workspace: Found free name %s", _target);
+			}
+		}
+		free(dup);
+	}
+	if (target != NULL) {
+		return target;
+	}
+	// As a fall back, get the current number of active workspaces
+	// and return that + 1 for the next workspace's name
+	int ws_num = root_container.children->length;
+	if (ws_num >= 10) {
+		l = 2;
+	} else if (ws_num >= 100) {
+		l = 3;
+	}
+	char *name = malloc(l + 1);
+	if (!name) {
+		sway_log(L_ERROR, "Could not allocate workspace name");
+		return NULL;
+	}
+	sprintf(name, "%d", ws_num++);
+	return name;
+}
+
+swayc_t *workspace_create(const char* name) {
+	swayc_t *parent;
+	// Search for workspace<->output pair
+	int i, e = config->workspace_outputs->length;
+	for (i = 0; i < e; ++i) {
+		struct workspace_output *wso = config->workspace_outputs->items[i];
+		if (strcasecmp(wso->workspace, name) == 0)
+		{
+			// Find output to use if it exists
+			e = root_container.children->length;
+			for (i = 0; i < e; ++i) {
+				parent = root_container.children->items[i];
+				if (strcmp(parent->name, wso->output) == 0) {
+					return new_workspace(parent, name);
+				}
+			}
+			break;
+		}
+	}
+	// Otherwise create a new one
+	parent = get_focused_container(&root_container);
+	parent = swayc_parent_by_type(parent, C_OUTPUT);
+	return new_workspace(parent, name);
+}
+
+static bool _workspace_by_name(swayc_t *view, void *data) {
+	return (view->type == C_WORKSPACE) &&
+		   (strcasecmp(view->name, (char *) data) == 0);
+}
+
+swayc_t *workspace_by_name(const char* name) {
+	if (strcmp(name, "prev") == 0) {
+		return workspace_prev();
+	}
+	else if (strcmp(name, "prev_on_output") == 0) {
+		return workspace_output_prev();
+	}
+	else if (strcmp(name, "next") == 0) {
+		return workspace_next();
+	}
+	else if (strcmp(name, "next_on_output") == 0) {
+		return workspace_output_next();
+	}
+	else if (strcmp(name, "current") == 0) {
+		return swayc_active_workspace();
+	}
+	else {
+		return swayc_by_test(&root_container, _workspace_by_name, (void *) name);
+	}
+}
+
+static bool _workspace_by_number(swayc_t *view, void *data) {
+	if (view->type != C_WORKSPACE) {
+		return false;
+	}
+	struct workspace_by_number_data *wbnd = data;
+	int a = strspn(view->name, wbnd->cset);
+	return a == wbnd->len && strncmp(view->name, wbnd->name, a) == 0;
+}
+swayc_t *workspace_by_number(const char* name) {
+	struct workspace_by_number_data wbnd = {0, "1234567890", name};
+	wbnd.len = strspn(name, wbnd.cset);
+	if (wbnd.len <= 0) {
+		return NULL;
+	}
+	return swayc_by_test(&root_container, _workspace_by_number, (void *) &wbnd);
+}
+
+/**
+ * Get the previous or next workspace on the specified output.
+ * Wraps around at the end and beginning.
+ * If next is false, the previous workspace is returned, otherwise the next one is returned.
+ */
+swayc_t *workspace_output_prev_next_impl(swayc_t *output, bool next) {
+	if (!sway_assert(output->type == C_OUTPUT, "Argument must be an output, is %d", output->type)) {
+		return NULL;
+	}
+
+	int i;
+	for (i = 0; i < output->children->length; i++) {
+		if (output->children->items[i] == output->focused) {
+			return output->children->items[wrap(i + (next ? 1 : -1), output->children->length)];
+		}
+	}
+
+	// Doesn't happen, at worst the for loop returns the previously active workspace
+	return NULL;
+}
+
+/**
+ * Get the previous or next workspace. If the first/last workspace on an output is active,
+ * proceed to the previous/next output's previous/next workspace.
+ * If next is false, the previous workspace is returned, otherwise the next one is returned.
+ */
+swayc_t *workspace_prev_next_impl(swayc_t *workspace, bool next) {
+	if (!sway_assert(workspace->type == C_WORKSPACE, "Argument must be a workspace, is %d", workspace->type)) {
+		return NULL;
+	}
+
+	swayc_t *current_output = workspace->parent;
+	int offset = next ? 1 : -1;
+	int start = next ? 0 : 1;
+	int end = next ? (current_output->children->length) - 1 : current_output->children->length;
+	int i;
+	for (i = start; i < end; i++) {
+		if (current_output->children->items[i] == workspace) {
+			return current_output->children->items[i + offset];
+		}
+	}
+
+	// Given workspace is the first/last on the output, jump to the previous/next output
+	int num_outputs = root_container.children->length;
+	for (i = 0; i < num_outputs; i++) {
+		if (root_container.children->items[i] == current_output) {
+			swayc_t *next_output = root_container.children->items[wrap(i + offset, num_outputs)];
+			return workspace_output_prev_next_impl(next_output, next);
+		}
+	}
+
+	// Doesn't happen, at worst the for loop returns the previously active workspace on the active output
+	return NULL;
+}
+
+swayc_t *workspace_output_next() {
+	return workspace_output_prev_next_impl(swayc_active_output(), true);
+}
+
+swayc_t *workspace_next() {
+	return workspace_prev_next_impl(swayc_active_workspace(), true);
+}
+
+swayc_t *workspace_output_prev() {
+	return workspace_output_prev_next_impl(swayc_active_output(), false);
+}
+
+swayc_t *workspace_prev() {
+	return workspace_prev_next_impl(swayc_active_workspace(), false);
+}
+
+bool workspace_switch(swayc_t *workspace) {
+	if (!workspace) {
+		return false;
+	}
+	swayc_t *active_ws = swayc_active_workspace();
+	if (config->auto_back_and_forth && active_ws == workspace && prev_workspace_name) {
+		swayc_t *new_ws = workspace_by_name(prev_workspace_name);
+		workspace = new_ws ? new_ws : workspace_create(prev_workspace_name);
+	}
+
+	if (!prev_workspace_name
+			|| (strcmp(prev_workspace_name, active_ws->name)
+				&& active_ws != workspace)) {
+		free(prev_workspace_name);
+		prev_workspace_name = malloc(strlen(active_ws->name) + 1);
+		if (!prev_workspace_name) {
+			sway_log(L_ERROR, "Unable to allocate previous workspace name");
+			return false;
+		}
+		strcpy(prev_workspace_name, active_ws->name);
+	}
+
+	// move sticky containers
+	if (swayc_parent_by_type(active_ws, C_OUTPUT) == swayc_parent_by_type(workspace, C_OUTPUT)) {
+		// don't change list while traversing it, use intermediate list instead
+		list_t *stickies = create_list();
+		for (int i = 0; i < active_ws->floating->length; i++) {
+			swayc_t *cont = active_ws->floating->items[i];
+			if (cont->sticky) {
+				list_add(stickies, cont);
+			}
+		}
+		for (int i = 0; i < stickies->length; i++) {
+			swayc_t *cont = stickies->items[i];
+			sway_log(L_DEBUG, "Moving sticky container %p to %p:%s",
+					cont, workspace, workspace->name);
+			swayc_t *parent = remove_child(cont);
+			add_floating(workspace, cont);
+			// Destroy old container if we need to
+			destroy_container(parent);
+		}
+		list_free(stickies);
+	}
+	sway_log(L_DEBUG, "Switching to workspace %p:%s", workspace, workspace->name);
+	if (!set_focused_container(get_focused_view(workspace))) {
+		return false;
+	}
+	swayc_t *output = swayc_parent_by_type(workspace, C_OUTPUT);
+	arrange_backgrounds();
+	arrange_windows(output, -1, -1);
+	return true;
+}
+
+swayc_t *workspace_for_pid(pid_t pid) {
+	int i;
+	swayc_t *ws = NULL;
+	struct pid_workspace *pw = NULL;
+
+	sway_log(L_DEBUG, "looking for workspace for pid %d", pid);
+
+	// leaving this here as it's useful for debugging
+	// sway_log(L_DEBUG, "all pid_workspaces");
+	// for (int k = 0; k < config->pid_workspaces->length; k++) {
+	// 	pw = config->pid_workspaces->items[k];
+	// 	sway_log(L_DEBUG, "pid %d workspace %s time_added %li", *pw->pid, pw->workspace, *pw->time_added);
+	// }
+
+	do {
+		for (i = 0; i < config->pid_workspaces->length; i++) {
+			pw = config->pid_workspaces->items[i];
+			pid_t *pw_pid = pw->pid;
+
+			if (pid == *pw_pid) {
+				sway_log(L_DEBUG, "found pid_workspace for pid %d, workspace %s", pid, pw->workspace);
+				break; // out of for loop
+			}
+
+			pw = NULL;
+		}
+
+		if (pw) {
+			break; // out of do-while loop
+		}
+
+		pid = get_parent_pid(pid);
+		// no sense in looking for matches for pid 0.
+		// also, if pid == getpid(), that is the compositor's
+		// pid, which definitely isn't helpful
+	} while (pid > 0 && pid != getpid());
+
+	if (pw) {
+		ws = workspace_by_name(pw->workspace);
+
+		if (!ws) {
+			sway_log(L_DEBUG, "Creating workspace %s for pid %d because it disappeared", pw->workspace, pid);
+			ws = workspace_create(pw->workspace);
+		}
+
+		list_del(config->pid_workspaces, i);
+	}
+
+	return ws;
+}