1 files changed, 314 insertions, 557 deletions

diff --git a/sway/tree/container.c b/sway/tree/container.c
index 520b4566..0cb8d0a5 100644
--- a/sway/tree/container.c
+++ b/sway/tree/container.c
@@ -24,97 +24,39 @@
 #include "log.h"
 #include "stringop.h"
 
-const char *container_type_to_str(enum sway_container_type type) {
-        switch (type) {
-        case C_ROOT:
-                return "C_ROOT";
-        case C_OUTPUT:
-                return "C_OUTPUT";
-        case C_WORKSPACE:
-                return "C_WORKSPACE";
-        case C_CONTAINER:
-                return "C_CONTAINER";
-        case C_VIEW:
-                return "C_VIEW";
-        default:
-                return "C_UNKNOWN";
-        }
-}
-
-void container_create_notify(struct sway_container *container) {
-        if (container->type == C_VIEW) {
-                ipc_event_window(container, "new");
-        } else if (container->type == C_WORKSPACE) {
-                ipc_event_workspace(NULL, container, "init");
-        }
-        wl_signal_emit(&root_container.sway_root->events.new_container, container);
-}
-
-void container_update_textures_recursive(struct sway_container *con) {
-        if (con->type == C_CONTAINER || con->type == C_VIEW) {
-                container_update_title_textures(con);
-        }
-
-        if (con->type == C_VIEW) {
-                view_update_marks_textures(con->sway_view);
-        } else {
-                for (int i = 0; i < con->children->length; ++i) {
-                        struct sway_container *child = con->children->items[i];
-                        container_update_textures_recursive(child);
-                }
-
-                if (con->type == C_WORKSPACE) {
-                        for (int i = 0; i < con->sway_workspace->floating->length; ++i) {
-                                struct sway_container *floater =
-                                        con->sway_workspace->floating->items[i];
-                                container_update_textures_recursive(floater);
-                        }
-                }
-        }
-}
-
-struct sway_container *container_create(enum sway_container_type type) {
-        // next id starts at 1 because 0 is assigned to root_container in layout.c
-        static size_t next_id = 1;
+struct sway_container *container_create(struct sway_view *view) {
         struct sway_container *c = calloc(1, sizeof(struct sway_container));
         if (!c) {
+                wlr_log(WLR_ERROR, "Unable to allocate sway_container");
                 return NULL;
         }
-        c->id = next_id++;
+        node_init(&c->node, N_CONTAINER, c);
         c->layout = L_NONE;
-        c->type = type;
+        c->view = view;
         c->alpha = 1.0f;
 
-        if (type != C_VIEW) {
+        if (!view) {
                 c->children = create_list();
                 c->current.children = create_list();
         }
         c->outputs = create_list();
 
         wl_signal_init(&c->events.destroy);
-
-        c->has_gaps = false;
-        c->gaps_inner = 0;
-        c->gaps_outer = 0;
-        c->current_gaps = 0;
+        wl_signal_emit(&root->events.new_node, &c->node);
 
         return c;
 }
 
 void container_destroy(struct sway_container *con) {
-        if (!sway_assert(con->type == C_CONTAINER || con->type == C_VIEW,
-                                "Expected a container or view")) {
-                return;
-        }
-        if (!sway_assert(con->destroying,
+        if (!sway_assert(con->node.destroying,
                                 "Tried to free container which wasn't marked as destroying")) {
                 return;
         }
-        if (!sway_assert(con->ntxnrefs == 0, "Tried to free container "
+        if (!sway_assert(con->node.ntxnrefs == 0, "Tried to free container "
                                 "which is still referenced by transactions")) {
                 return;
         }
-        free(con->name);
+        free(con->title);
         free(con->formatted_title);
         wlr_texture_destroy(con->title_focused);
         wlr_texture_destroy(con->title_focused_inactive);
@@ -124,14 +66,14 @@ void container_destroy(struct sway_container *con) {
         list_free(con->current.children);
         list_free(con->outputs);
 
-        if (con->type == C_VIEW) {
-                struct sway_view *view = con->sway_view;
-                view->swayc = NULL;
+        if (con->view) {
+                struct sway_view *view = con->view;
+                view->container = NULL;
                 free(view->title_format);
                 view->title_format = NULL;
 
                 if (view->destroying) {
-                        view_destroy(view);
+                        view_destroy(con->view);
                 }
         }
 
@@ -139,115 +81,57 @@ void container_destroy(struct sway_container *con) {
 }
 
 void container_begin_destroy(struct sway_container *con) {
-        if (!sway_assert(con->type == C_CONTAINER || con->type == C_VIEW,
-                                "Expected a container or view")) {
-                return;
-        }
-
-        if (con->type == C_VIEW) {
+        if (con->view) {
                 ipc_event_window(con, "close");
         }
-        wl_signal_emit(&con->events.destroy, con);
+        wl_signal_emit(&con->node.events.destroy, &con->node);
 
         container_end_mouse_operation(con);
 
-        con->destroying = true;
-        container_set_dirty(con);
+        con->node.destroying = true;
+        node_set_dirty(&con->node);
 
         if (con->scratchpad) {
                 root_scratchpad_remove_container(con);
         }
 
-        if (con->parent) {
-                container_remove_child(con);
+        if (con->parent || con->workspace) {
+                container_detach(con);
         }
 }
 
-struct sway_container *container_reap_empty(struct sway_container *con) {
-        while (con && con->type == C_CONTAINER) {
-                struct sway_container *next = con->parent;
-                if (con->children->length == 0) {
-                        container_begin_destroy(con);
-                }
-                con = next;
+void container_reap_empty(struct sway_container *con) {
+        if (con->view) {
+                return;
         }
-        if (con && con->type == C_WORKSPACE) {
-                workspace_consider_destroy(con);
-                if (con->destroying) {
-                        con = con->parent;
+        struct sway_workspace *ws = con->workspace;
+        while (con) {
+                if (con->children->length) {
+                        return;
                 }
+                struct sway_container *parent = con->parent;
+                container_begin_destroy(con);
+                con = parent;
         }
-        return con;
+        workspace_consider_destroy(ws);
 }
 
 struct sway_container *container_flatten(struct sway_container *container) {
-        while (container->type == C_CONTAINER && container->children->length == 1) {
+        if (container->view) {
+                return NULL;
+        }
+        while (container && container->children->length == 1) {
                 struct sway_container *child = container->children->items[0];
                 struct sway_container *parent = container->parent;
-                container_replace_child(container, child);
+                container_replace(container, child);
                 container_begin_destroy(container);
                 container = parent;
         }
         return container;
 }
 
-static void container_close_func(struct sway_container *container, void *data) {
-        if (container->type == C_VIEW) {
-                view_close(container->sway_view);
-        }
-}
-
-struct sway_container *container_close(struct sway_container *con) {
-        if (!sway_assert(con != NULL,
-                        "container_close called with a NULL container")) {
-                return NULL;
-        }
-
-        struct sway_container *parent = con->parent;
-
-        if (con->type == C_VIEW) {
-                view_close(con->sway_view);
-        } else if (con->type == C_CONTAINER) {
-                container_for_each_child(con, container_close_func, NULL);
-        } else if (con->type == C_WORKSPACE) {
-                workspace_for_each_container(con, container_close_func, NULL);
-        }
-
-        return parent;
-}
-
-struct sway_container *container_view_create(struct sway_container *sibling,
-                struct sway_view *sway_view) {
-        if (!sway_assert(sibling,
-                        "container_view_create called with NULL sibling/parent")) {
-                return NULL;
-        }
-        const char *title = view_get_title(sway_view);
-        struct sway_container *swayc = container_create(C_VIEW);
-        wlr_log(WLR_DEBUG, "Adding new view %p:%s to container %p %d %s",
-                swayc, title, sibling, sibling ? sibling->type : 0, sibling->name);
-        // Setup values
-        swayc->sway_view = sway_view;
-        swayc->width = 0;
-        swayc->height = 0;
-
-        if (sibling->type == C_WORKSPACE) {
-                // Case of focused workspace, just create as child of it
-                container_add_child(sibling, swayc);
-        } else {
-                // Regular case, create as sibling of current container
-                container_add_sibling(sibling, swayc);
-        }
-        container_create_notify(swayc);
-        return swayc;
-}
-
 struct sway_container *container_find_child(struct sway_container *container,
-                bool (*test)(struct sway_container *view, void *data), void *data) {
-        if (!sway_assert(container->type == C_CONTAINER ||
-                                container->type == C_VIEW, "Expected a container or view")) {
-                return NULL;
-        }
+                bool (*test)(struct sway_container *con, void *data), void *data) {
         if (!container->children) {
                 return NULL;
         }
@@ -264,46 +148,32 @@ struct sway_container *container_find_child(struct sway_container *container,
         return NULL;
 }
 
-struct sway_container *container_parent(struct sway_container *container,
-                enum sway_container_type type) {
-        if (!sway_assert(container, "container is NULL")) {
-                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;
-}
-
-static void surface_at_view(struct sway_container *swayc, double lx, double ly,
+static void surface_at_view(struct sway_container *con, double lx, double ly,
                 struct wlr_surface **surface, double *sx, double *sy) {
-        if (!sway_assert(swayc->type == C_VIEW, "Expected a view")) {
+        if (!sway_assert(con->view, "Expected a view")) {
                 return;
         }
-        struct sway_view *sview = swayc->sway_view;
-        double view_sx = lx - sview->x + sview->geometry.x;
-        double view_sy = ly - sview->y + sview->geometry.y;
+        struct sway_view *view = con->view;
+        double view_sx = lx - view->x + view->geometry.x;
+        double view_sy = ly - view->y + view->geometry.y;
 
         double _sx, _sy;
         struct wlr_surface *_surface = NULL;
-        switch (sview->type) {
+        switch (view->type) {
 #ifdef HAVE_XWAYLAND
         case SWAY_VIEW_XWAYLAND:
-                _surface = wlr_surface_surface_at(sview->surface,
+                _surface = wlr_surface_surface_at(view->surface,
                                 view_sx, view_sy, &_sx, &_sy);
                 break;
 #endif
         case SWAY_VIEW_XDG_SHELL_V6:
                 _surface = wlr_xdg_surface_v6_surface_at(
-                                sview->wlr_xdg_surface_v6,
+                                view->wlr_xdg_surface_v6,
                                 view_sx, view_sy, &_sx, &_sy);
                 break;
         case SWAY_VIEW_XDG_SHELL:
                 _surface = wlr_xdg_surface_surface_at(
-                                sview->wlr_xdg_surface,
+                                view->wlr_xdg_surface,
                                 view_sx, view_sy, &_sx, &_sy);
                 break;
         }
@@ -317,65 +187,72 @@ static void surface_at_view(struct sway_container *swayc, double lx, double ly,
 /**
  * container_at for a container with layout L_TABBED.
  */
-static struct sway_container *container_at_tabbed(struct sway_container *parent,
+static struct sway_container *container_at_tabbed(struct sway_node *parent,
                 double lx, double ly,
                 struct wlr_surface **surface, double *sx, double *sy) {
-        if (ly < parent->y || ly > parent->y + parent->height) {
+        struct wlr_box box;
+        node_get_box(parent, &box);
+        if (ly < box.y || ly > box.y + box.height) {
                 return NULL;
         }
         struct sway_seat *seat = input_manager_current_seat(input_manager);
+        list_t *children = node_get_children(parent);
 
         // Tab titles
         int title_height = container_titlebar_height();
-        if (ly < parent->y + title_height) {
-                int tab_width = parent->width / parent->children->length;
-                int child_index = (lx - parent->x) / tab_width;
-                if (child_index >= parent->children->length) {
-                        child_index = parent->children->length - 1;
+        if (ly < box.y + title_height) {
+                int tab_width = box.width / children->length;
+                int child_index = (lx - box.x) / tab_width;
+                if (child_index >= children->length) {
+                        child_index = children->length - 1;
                 }
-                struct sway_container *child = parent->children->items[child_index];
-                return seat_get_focus_inactive(seat, child);
+                struct sway_container *child = children->items[child_index];
+                struct sway_node *node = seat_get_focus_inactive(seat, &child->node);
+                return node->sway_container;
         }
 
         // Surfaces
-        struct sway_container *current = seat_get_active_child(seat, parent);
-
+        struct sway_node *current = seat_get_active_child(seat, parent);
         return tiling_container_at(current, lx, ly, surface, sx, sy);
 }
 
 /**
  * container_at for a container with layout L_STACKED.
  */
-static struct sway_container *container_at_stacked(
-                struct sway_container *parent, double lx, double ly,
+static struct sway_container *container_at_stacked(struct sway_node *parent,
+                double lx, double ly,
                 struct wlr_surface **surface, double *sx, double *sy) {
-        if (ly < parent->y || ly > parent->y + parent->height) {
+        struct wlr_box box;
+        node_get_box(parent, &box);
+        if (ly < box.y || ly > box.y + box.height) {
                 return NULL;
         }
         struct sway_seat *seat = input_manager_current_seat(input_manager);
+        list_t *children = node_get_children(parent);
 
         // Title bars
         int title_height = container_titlebar_height();
-        int child_index = (ly - parent->y) / title_height;
-        if (child_index < parent->children->length) {
-                struct sway_container *child = parent->children->items[child_index];
-                return seat_get_focus_inactive(seat, child);
+        int child_index = (ly - box.y) / title_height;
+        if (child_index < children->length) {
+                struct sway_container *child = children->items[child_index];
+                struct sway_node *node = seat_get_focus_inactive(seat, &child->node);
+                return node->sway_container;
         }
 
         // Surfaces
-        struct sway_container *current = seat_get_active_child(seat, parent);
-
+        struct sway_node *current = seat_get_active_child(seat, parent);
         return tiling_container_at(current, lx, ly, surface, sx, sy);
 }
 
 /**
  * container_at for a container with layout L_HORIZ or L_VERT.
  */
-static struct sway_container *container_at_linear(struct sway_container *parent,
+static struct sway_container *container_at_linear(struct sway_node *parent,
                 double lx, double ly,
                 struct wlr_surface **surface, double *sx, double *sy) {
-        for (int i = 0; i < parent->children->length; ++i) {
-                struct sway_container *child = parent->children->items[i];
+        list_t *children = node_get_children(parent);
+        for (int i = 0; i < children->length; ++i) {
+                struct sway_container *child = children->items[i];
                 struct wlr_box box = {
                         .x = child->x,
                         .y = child->y,
@@ -383,7 +260,7 @@ static struct sway_container *container_at_linear(struct sway_container *parent,
                         .height = child->height,
                 };
                 if (wlr_box_contains_point(&box, lx, ly)) {
-                        return tiling_container_at(child, lx, ly, surface, sx, sy);
+                        return tiling_container_at(&child->node, lx, ly, surface, sx, sy);
                 }
         }
         return NULL;
@@ -391,12 +268,11 @@ static struct sway_container *container_at_linear(struct sway_container *parent,
 
 static struct sway_container *floating_container_at(double lx, double ly,
                 struct wlr_surface **surface, double *sx, double *sy) {
-        for (int i = 0; i < root_container.children->length; ++i) {
-                struct sway_container *output = root_container.children->items[i];
-                for (int j = 0; j < output->children->length; ++j) {
-                        struct sway_container *workspace = output->children->items[j];
-                        struct sway_workspace *ws = workspace->sway_workspace;
-                        if (!workspace_is_visible(workspace)) {
+        for (int i = 0; i < root->outputs->length; ++i) {
+                struct sway_output *output = root->outputs->items[i];
+                for (int j = 0; j < output->workspaces->length; ++j) {
+                        struct sway_workspace *ws = output->workspaces->items[j];
+                        if (!workspace_is_visible(ws)) {
                                 continue;
                         }
                         // Items at the end of the list are on top, so iterate the list in
@@ -410,7 +286,7 @@ static struct sway_container *floating_container_at(double lx, double ly,
                                         .height = floater->height,
                                 };
                                 if (wlr_box_contains_point(&box, lx, ly)) {
-                                        return tiling_container_at(floater, lx, ly,
+                                        return tiling_container_at(&floater->node, lx, ly,
                                                         surface, sx, sy);
                                 }
                         }
@@ -419,25 +295,24 @@ static struct sway_container *floating_container_at(double lx, double ly,
         return NULL;
 }
 
-struct sway_container *tiling_container_at(
-                struct sway_container *con, double lx, double ly,
+struct sway_container *tiling_container_at(struct sway_node *parent,
+                double lx, double ly,
                 struct wlr_surface **surface, double *sx, double *sy) {
-        if (con->type == C_VIEW) {
-                surface_at_view(con, lx, ly, surface, sx, sy);
-                return con;
+        if (node_is_view(parent)) {
+                surface_at_view(parent->sway_container, lx, ly, surface, sx, sy);
+                return parent->sway_container;
         }
-        if (!con->children->length) {
+        if (!node_get_children(parent)) {
                 return NULL;
         }
-
-        switch (con->layout) {
+        switch (node_get_layout(parent)) {
         case L_HORIZ:
         case L_VERT:
-                return container_at_linear(con, lx, ly, surface, sx, sy);
+                return container_at_linear(parent, lx, ly, surface, sx, sy);
         case L_TABBED:
-                return container_at_tabbed(con, lx, ly, surface, sx, sy);
+                return container_at_tabbed(parent, lx, ly, surface, sx, sy);
         case L_STACKED:
-                return container_at_stacked(con, lx, ly, surface, sx, sy);
+                return container_at_stacked(parent, lx, ly, surface, sx, sy);
         case L_NONE:
                 return NULL;
         }
@@ -472,19 +347,16 @@ static bool surface_is_popup(struct wlr_surface *surface) {
         return false;
 }
 
-struct sway_container *container_at(struct sway_container *workspace,
+struct sway_container *container_at(struct sway_workspace *workspace,
                 double lx, double ly,
                 struct wlr_surface **surface, double *sx, double *sy) {
-        if (!sway_assert(workspace->type == C_WORKSPACE, "Expected a workspace")) {
-                return NULL;
-        }
         struct sway_container *c;
+        // Focused view's popups
         struct sway_seat *seat = input_manager_current_seat(input_manager);
-        struct sway_container *focus =
-                seat_get_focus_inactive(seat, &root_container);
+        struct sway_container *focus = seat_get_focused_container(seat);
         bool is_floating = focus && container_is_floating_or_child(focus);
         // Focused view's popups
-        if (focus && focus->type == C_VIEW) {
+        if (focus && focus->view) {
                 surface_at_view(focus, lx, ly, surface, sx, sy);
                 if (*surface && surface_is_popup(*surface)) {
                         return focus;
@@ -492,7 +364,7 @@ struct sway_container *container_at(struct sway_container *workspace,
                 *surface = NULL;
         }
         // If focused is floating, focused view's non-popups
-        if (focus && focus->type == C_VIEW && is_floating) {
+        if (focus && focus->view && is_floating) {
                 surface_at_view(focus, lx, ly, surface, sx, sy);
                 if (*surface) {
                         return focus;
@@ -504,7 +376,7 @@ struct sway_container *container_at(struct sway_container *workspace,
                 return c;
         }
         // If focused is tiling, focused view's non-popups
-        if (focus && focus->type == C_VIEW && !is_floating) {
+        if (focus && focus->view && !is_floating) {
                 surface_at_view(focus, lx, ly, surface, sx, sy);
                 if (*surface) {
                         return focus;
@@ -512,7 +384,7 @@ struct sway_container *container_at(struct sway_container *workspace,
                 *surface = NULL;
         }
         // Tiling (non-focused)
-        if ((c = tiling_container_at(workspace, lx, ly, surface, sx, sy))) {
+        if ((c = tiling_container_at(&workspace->node, lx, ly, surface, sx, sy))) {
                 return c;
         }
         return NULL;
@@ -521,10 +393,6 @@ struct sway_container *container_at(struct sway_container *workspace,
 void container_for_each_child(struct sway_container *container,
                 void (*f)(struct sway_container *container, void *data),
                 void *data) {
-        if (!sway_assert(container->type == C_CONTAINER ||
-                                container->type == C_VIEW, "Expected a container or view")) {
-                return;
-        }
         if (container->children)  {
                 for (int i = 0; i < container->children->length; ++i) {
                         struct sway_container *child = container->children->items[i];
@@ -536,7 +404,7 @@ void container_for_each_child(struct sway_container *container,
 
 bool container_has_ancestor(struct sway_container *descendant,
                 struct sway_container *ancestor) {
-        while (descendant && descendant->type != C_ROOT) {
+        while (descendant) {
                 descendant = descendant->parent;
                 if (descendant == ancestor) {
                         return true;
@@ -545,27 +413,10 @@ bool container_has_ancestor(struct sway_container *descendant,
         return false;
 }
 
-int container_count_descendants_of_type(struct sway_container *con,
-                enum sway_container_type type) {
-        int children = 0;
-        if (con->type == type) {
-                children++;
-        }
-        if (con->children) {
-                for (int i = 0; i < con->children->length; i++) {
-                        struct sway_container *child = con->children->items[i];
-                        children += container_count_descendants_of_type(child, type);
-                }
-        }
-        return children;
-}
-
 void container_damage_whole(struct sway_container *container) {
-        for (int i = 0; i < root_container.children->length; ++i) {
-                struct sway_container *cont = root_container.children->items[i];
-                if (cont->type == C_OUTPUT) {
-                        output_damage_whole_container(cont->sway_output, container);
-                }
+        for (int i = 0; i < root->outputs->length; ++i) {
+                struct sway_output *output = root->outputs->items[i];
+                output_damage_whole_container(output, container);
         }
 }
 
@@ -582,10 +433,6 @@ struct sway_output *container_get_effective_output(struct sway_container *con) {
 
 static void update_title_texture(struct sway_container *con,
                 struct wlr_texture **texture, struct border_colors *class) {
-        if (!sway_assert(con->type == C_CONTAINER || con->type == C_VIEW,
-                        "Unexpected type %s", container_type_to_str(con->type))) {
-                return;
-        }
         struct sway_output *output = container_get_effective_output(con);
         if (!output) {
                 return;
@@ -664,9 +511,10 @@ void container_calculate_title_height(struct sway_container *container) {
  * An example tree representation is: V[Terminal, Firefox]
  * If buffer is not NULL, also populate the buffer with the representation.
  */
-static size_t get_tree_representation(struct sway_container *parent, char *buffer) {
+size_t container_build_representation(enum sway_container_layout layout,
+                list_t *children, char *buffer) {
         size_t len = 2;
-        switch (parent->layout) {
+        switch (layout) {
         case L_VERT:
                 lenient_strcat(buffer, "V[");
                 break;
@@ -683,17 +531,17 @@ static size_t get_tree_representation(struct sway_container *parent, char *buffe
                 lenient_strcat(buffer, "D[");
                 break;
         }
-        for (int i = 0; i < parent->children->length; ++i) {
+        for (int i = 0; i < children->length; ++i) {
                 if (i != 0) {
                         ++len;
                         lenient_strcat(buffer, " ");
                 }
-                struct sway_container *child = parent->children->items[i];
+                struct sway_container *child = children->items[i];
                 const char *identifier = NULL;
-                if (child->type == C_VIEW) {
-                        identifier = view_get_class(child->sway_view);
+                if (child->view) {
+                        identifier = view_get_class(child->view);
                         if (!identifier) {
-                                identifier = view_get_app_id(child->sway_view);
+                                identifier = view_get_app_id(child->view);
                         }
                 } else {
                         identifier = child->formatted_title;
@@ -711,25 +559,25 @@ static size_t get_tree_representation(struct sway_container *parent, char *buffe
         return len;
 }
 
-void container_notify_subtree_changed(struct sway_container *container) {
-        if (!container || container->type < C_WORKSPACE) {
-                return;
-        }
-        free(container->formatted_title);
-        container->formatted_title = NULL;
-
-        size_t len = get_tree_representation(container, NULL);
-        char *buffer = calloc(len + 1, sizeof(char));
-        if (!sway_assert(buffer, "Unable to allocate title string")) {
-                return;
+void container_update_representation(struct sway_container *con) {
+        if (!con->view) {
+                size_t len = container_build_representation(con->layout,
+                                con->children, NULL);
+                free(con->formatted_title);
+                con->formatted_title = calloc(len + 1, sizeof(char));
+                if (!sway_assert(con->formatted_title,
+                                        "Unable to allocate title string")) {
+                        return;
+                }
+                container_build_representation(con->layout, con->children,
+                                con->formatted_title);
+                container_calculate_title_height(con);
+                container_update_title_textures(con);
         }
-        get_tree_representation(container, buffer);
-
-        container->formatted_title = buffer;
-        if (container->type != C_WORKSPACE) {
-                container_calculate_title_height(container);
-                container_update_title_textures(container);
-                container_notify_subtree_changed(container->parent);
+        if (con->parent) {
+                container_update_representation(con->parent);
+        } else if (con->workspace) {
+                workspace_update_representation(con->workspace);
         }
 }
 
@@ -738,11 +586,7 @@ size_t container_titlebar_height() {
 }
 
 void container_init_floating(struct sway_container *con) {
-        if (!sway_assert(con->type == C_VIEW || con->type == C_CONTAINER,
-                        "Expected a view or container")) {
-                return;
-        }
-        struct sway_container *ws = container_parent(con, C_WORKSPACE);
+        struct sway_workspace *ws = con->workspace;
         int min_width, min_height;
         int max_width, max_height;
 
@@ -778,13 +622,13 @@ void container_init_floating(struct sway_container *con) {
                 max_height = config->floating_maximum_height;
         }
 
-        if (con->type == C_CONTAINER) {
+        if (!con->view) {
                 con->width = max_width;
                 con->height = max_height;
                 con->x = ws->x + (ws->width - con->width) / 2;
                 con->y = ws->y + (ws->height - con->height) / 2;
         } else {
-                struct sway_view *view = con->sway_view;
+                struct sway_view *view = con->view;
                 view->width = fmax(min_width, fmin(view->natural_width, max_width));
                 view->height = fmax(min_height, fmin(view->natural_height, max_height));
                 view->x = ws->x + (ws->width - view->width) / 2;
@@ -794,7 +638,7 @@ void container_init_floating(struct sway_container *con) {
                 view->border_top = view->border_bottom = true;
                 view->border_left = view->border_right = true;
 
-                container_set_geometry_from_floating_view(view->swayc);
+                container_set_geometry_from_floating_view(con);
         }
 }
 
@@ -804,32 +648,41 @@ void container_set_floating(struct sway_container *container, bool enable) {
         }
 
         struct sway_seat *seat = input_manager_current_seat(input_manager);
-        struct sway_container *workspace = container_parent(container, C_WORKSPACE);
+        struct sway_workspace *workspace = container->workspace;
 
         if (enable) {
-                struct sway_container *old_parent = container_remove_child(container);
+                struct sway_container *old_parent = container->parent;
+                container_detach(container);
                 workspace_add_floating(workspace, container);
                 container_init_floating(container);
-                if (container->type == C_VIEW) {
-                        view_set_tiled(container->sway_view, false);
+                if (container->view) {
+                        view_set_tiled(container->view, false);
+                }
+                if (old_parent) {
+                        container_reap_empty(old_parent);
                 }
-                container_reap_empty(old_parent);
         } else {
                 // Returning to tiled
                 if (container->scratchpad) {
                         root_scratchpad_remove_container(container);
                 }
-                container_remove_child(container);
+                container_detach(container);
                 struct sway_container *reference =
                         seat_get_focus_inactive_tiling(seat, workspace);
-                if (reference->type == C_VIEW) {
+                if (reference && reference->view) {
                         reference = reference->parent;
                 }
-                container_add_child(reference, container);
-                container->width = container->parent->width;
-                container->height = container->parent->height;
-                if (container->type == C_VIEW) {
-                        view_set_tiled(container->sway_view, true);
+                if (reference) {
+                        container_add_child(reference, container);
+                        container->width = reference->width;
+                        container->height = reference->height;
+                } else {
+                        workspace_add_tiling(workspace, container);
+                        container->width = workspace->width;
+                        container->height = workspace->height;
+                }
+                if (container->view) {
+                        view_set_tiled(container->view, true);
                 }
                 container->is_sticky = false;
         }
@@ -840,14 +693,13 @@ void container_set_floating(struct sway_container *container, bool enable) {
 }
 
 void container_set_geometry_from_floating_view(struct sway_container *con) {
-        if (!sway_assert(con->type == C_VIEW, "Expected a view")) {
+        if (!sway_assert(con->view, "Expected a view")) {
                 return;
         }
-        if (!sway_assert(container_is_floating(con),
-                                "Expected a floating view")) {
+        if (!sway_assert(container_is_floating(con), "Expected a floating view")) {
                 return;
         }
-        struct sway_view *view = con->sway_view;
+        struct sway_view *view = con->view;
         size_t border_width = 0;
         size_t top = 0;
 
@@ -861,12 +713,12 @@ void container_set_geometry_from_floating_view(struct sway_container *con) {
         con->y = view->y - top;
         con->width = view->width + border_width * 2;
         con->height = top + view->height + border_width;
-        container_set_dirty(con);
+        node_set_dirty(&con->node);
 }
 
 bool container_is_floating(struct sway_container *container) {
-        return container->parent && container->parent->type == C_WORKSPACE &&
-                list_find(container->parent->sway_workspace->floating, container) != -1;
+        return !container->parent && container->workspace &&
+                list_find(container->workspace->floating, container) != -1;
 }
 
 void container_get_box(struct sway_container *container, struct wlr_box *box) {
@@ -883,16 +735,16 @@ void container_floating_translate(struct sway_container *con,
                 double x_amount, double y_amount) {
         con->x += x_amount;
         con->y += y_amount;
-        if (con->type == C_VIEW) {
-                con->sway_view->x += x_amount;
-                con->sway_view->y += y_amount;
+        if (con->view) {
+                con->view->x += x_amount;
+                con->view->y += y_amount;
         } else {
                 for (int i = 0; i < con->children->length; ++i) {
                         struct sway_container *child = con->children->items[i];
                         container_floating_translate(child, x_amount, y_amount);
                 }
         }
-        container_set_dirty(con);
+        node_set_dirty(&con->node);
 }
 
 /**
@@ -902,17 +754,16 @@ void container_floating_translate(struct sway_container *con,
  * one, otherwise we'll choose whichever output is closest to the container's
  * center.
  */
-struct sway_container *container_floating_find_output(
-                struct sway_container *con) {
+struct sway_output *container_floating_find_output(struct sway_container *con) {
         double center_x = con->x + con->width / 2;
         double center_y = con->y + con->height / 2;
-        struct sway_container *closest_output = NULL;
+        struct sway_output *closest_output = NULL;
         double closest_distance = DBL_MAX;
-        for (int i = 0; i < root_container.children->length; ++i) {
-                struct sway_container *output = root_container.children->items[i];
+        for (int i = 0; i < root->outputs->length; ++i) {
+                struct sway_output *output = root->outputs->items[i];
                 struct wlr_box output_box;
                 double closest_x, closest_y;
-                container_get_box(output, &output_box);
+                output_get_box(output, &output_box);
                 wlr_box_closest_point(&output_box, center_x, center_y,
                                 &closest_x, &closest_y);
                 if (center_x == closest_x && center_y == closest_y) {
@@ -937,18 +788,18 @@ void container_floating_move_to(struct sway_container *con,
                 return;
         }
         container_floating_translate(con, lx - con->x, ly - con->y);
-        struct sway_container *old_workspace = container_parent(con, C_WORKSPACE);
-        struct sway_container *new_output = container_floating_find_output(con);
+        struct sway_workspace *old_workspace = con->workspace;
+        struct sway_output *new_output = container_floating_find_output(con);
         if (!sway_assert(new_output, "Unable to find any output")) {
                 return;
         }
-        struct sway_container *new_workspace =
-                output_get_active_workspace(new_output->sway_output);
+        struct sway_workspace *new_workspace =
+                output_get_active_workspace(new_output);
         if (old_workspace != new_workspace) {
-                container_remove_child(con);
+                container_detach(con);
                 workspace_add_floating(new_workspace, con);
-                arrange_windows(old_workspace);
-                arrange_windows(new_workspace);
+                arrange_workspace(old_workspace);
+                arrange_workspace(new_workspace);
                 workspace_detect_urgent(old_workspace);
                 workspace_detect_urgent(new_workspace);
         }
@@ -959,22 +810,14 @@ void container_floating_move_to_center(struct sway_container *con) {
                         "Expected a floating container")) {
                 return;
         }
-        struct sway_container *ws = container_parent(con, C_WORKSPACE);
+        struct sway_workspace *ws = con->workspace;
         double new_lx = ws->x + (ws->width - con->width) / 2;
         double new_ly = ws->y + (ws->height - con->height) / 2;
         container_floating_translate(con, new_lx - con->x, new_ly - con->y);
 }
 
-void container_set_dirty(struct sway_container *container) {
-        if (container->dirty) {
-                return;
-        }
-        container->dirty = true;
-        list_add(server.dirty_containers, container);
-}
-
 static bool find_urgent_iterator(struct sway_container *con, void *data) {
-        return con->type == C_VIEW && view_is_urgent(con->sway_view);
+        return con->view && view_is_urgent(con->view);
 }
 
 bool container_has_urgent_child(struct sway_container *container) {
@@ -991,12 +834,12 @@ void container_end_mouse_operation(struct sway_container *container) {
 }
 
 static void set_fullscreen_iterator(struct sway_container *con, void *data) {
-        if (con->type != C_VIEW) {
+        if (!con->view) {
                 return;
         }
-        if (con->sway_view->impl->set_fullscreen) {
+        if (con->view->impl->set_fullscreen) {
                 bool *enable = data;
-                con->sway_view->impl->set_fullscreen(con->sway_view, *enable);
+                con->view->impl->set_fullscreen(con->view, *enable);
         }
 }
 
@@ -1005,9 +848,9 @@ void container_set_fullscreen(struct sway_container *container, bool enable) {
                 return;
         }
 
-        struct sway_container *workspace = container_parent(container, C_WORKSPACE);
-        if (enable && workspace->sway_workspace->fullscreen) {
-                container_set_fullscreen(workspace->sway_workspace->fullscreen, false);
+        struct sway_workspace *workspace = container->workspace;
+        if (enable && workspace->fullscreen) {
+                container_set_fullscreen(workspace->fullscreen, false);
         }
 
         set_fullscreen_iterator(container, &enable);
@@ -1016,36 +859,32 @@ void container_set_fullscreen(struct sway_container *container, bool enable) {
         container->is_fullscreen = enable;
 
         if (enable) {
-                workspace->sway_workspace->fullscreen = container;
+                workspace->fullscreen = container;
                 container->saved_x = container->x;
                 container->saved_y = container->y;
                 container->saved_width = container->width;
                 container->saved_height = container->height;
 
                 struct sway_seat *seat;
-                struct sway_container *focus, *focus_ws;
+                struct sway_workspace *focus_ws;
                 wl_list_for_each(seat, &input_manager->seats, link) {
-                        focus = seat_get_focus(seat);
-                        if (focus) {
-                                focus_ws = focus;
-                                if (focus_ws->type != C_WORKSPACE) {
-                                        focus_ws = container_parent(focus_ws, C_WORKSPACE);
-                                }
+                        focus_ws = seat_get_focused_workspace(seat);
+                        if (focus_ws) {
                                 if (focus_ws == workspace) {
-                                        seat_set_focus(seat, container);
+                                        seat_set_focus(seat, &container->node);
                                 }
                         }
                 }
         } else {
-                workspace->sway_workspace->fullscreen = NULL;
+                workspace->fullscreen = NULL;
                 if (container_is_floating(container)) {
                         container->x = container->saved_x;
                         container->y = container->saved_y;
                         container->width = container->saved_width;
                         container->height = container->saved_height;
-                        struct sway_container *output =
+                        struct sway_output *output =
                                 container_floating_find_output(container);
-                        if (!container_has_ancestor(container, output)) {
+                        if (workspace->output != output) {
                                 container_floating_move_to_center(container);
                         }
                 } else {
@@ -1060,7 +899,7 @@ void container_set_fullscreen(struct sway_container *container, bool enable) {
 }
 
 bool container_is_floating_or_child(struct sway_container *container) {
-        while (container->parent && container->parent->type != C_WORKSPACE) {
+        while (container->parent) {
                 container = container->parent;
         }
         return container_is_floating(container);
@@ -1072,7 +911,7 @@ bool container_is_fullscreen_or_child(struct sway_container *container) {
                         return true;
                 }
                 container = container->parent;
-        } while (container && container->type != C_WORKSPACE);
+        } while (container);
 
         return false;
 }
@@ -1090,42 +929,37 @@ static void surface_send_leave_iterator(struct wlr_surface *surface,
 }
 
 void container_discover_outputs(struct sway_container *con) {
-        if (!sway_assert(con->type == C_CONTAINER || con->type == C_VIEW,
-                                "Expected a container or view")) {
-                return;
-        }
         struct wlr_box con_box = {
-                .x = con->current.swayc_x,
-                .y = con->current.swayc_y,
-                .width = con->current.swayc_width,
-                .height = con->current.swayc_height,
+                .x = con->current.con_x,
+                .y = con->current.con_y,
+                .width = con->current.con_width,
+                .height = con->current.con_height,
         };
         struct sway_output *old_output = container_get_effective_output(con);
 
-        for (int i = 0; i < root_container.children->length; ++i) {
-                struct sway_container *output = root_container.children->items[i];
-                struct sway_output *sway_output = output->sway_output;
+        for (int i = 0; i < root->outputs->length; ++i) {
+                struct sway_output *output = root->outputs->items[i];
                 struct wlr_box output_box;
-                container_get_box(output, &output_box);
+                output_get_box(output, &output_box);
                 struct wlr_box intersection;
                 bool intersects =
                         wlr_box_intersection(&con_box, &output_box, &intersection);
-                int index = list_find(con->outputs, sway_output);
+                int index = list_find(con->outputs, output);
 
                 if (intersects && index == -1) {
                         // Send enter
-                        wlr_log(WLR_DEBUG, "Con %p entered output %p", con, sway_output);
-                        if (con->type == C_VIEW) {
-                                view_for_each_surface(con->sway_view,
-                                                surface_send_enter_iterator, sway_output->wlr_output);
+                        wlr_log(WLR_DEBUG, "Container %p entered output %p", con, output);
+                        if (con->view) {
+                                view_for_each_surface(con->view,
+                                                surface_send_enter_iterator, output->wlr_output);
                         }
-                        list_add(con->outputs, sway_output);
+                        list_add(con->outputs, output);
                 } else if (!intersects && index != -1) {
                         // Send leave
-                        wlr_log(WLR_DEBUG, "Con %p left output %p", con, sway_output);
-                        if (con->type == C_VIEW) {
-                                view_for_each_surface(con->sway_view,
-                                        surface_send_leave_iterator, sway_output->wlr_output);
+                        wlr_log(WLR_DEBUG, "Container %p left output %p", con, output);
+                        if (con->view) {
+                                view_for_each_surface(con->view,
+                                        surface_send_leave_iterator, output->wlr_output);
                         }
                         list_del(con->outputs, index);
                 }
@@ -1135,17 +969,13 @@ void container_discover_outputs(struct sway_container *con) {
         double new_scale = new_output ? new_output->wlr_output->scale : -1;
         if (old_scale != new_scale) {
                 container_update_title_textures(con);
-                if (con->type == C_VIEW) {
-                        view_update_marks_textures(con->sway_view);
+                if (con->view) {
+                        view_update_marks_textures(con->view);
                 }
         }
 }
 
 void container_remove_gaps(struct sway_container *c) {
-        if (!sway_assert(c->type == C_CONTAINER || c->type == C_VIEW,
-                                "Expected a container or view")) {
-                return;
-        }
         if (c->current_gaps == 0) {
                 return;
         }
@@ -1158,25 +988,20 @@ void container_remove_gaps(struct sway_container *c) {
 }
 
 void container_add_gaps(struct sway_container *c) {
-        if (!sway_assert(c->type == C_CONTAINER || c->type == C_VIEW,
-                                "Expected a container or view")) {
-                return;
-        }
         if (c->current_gaps > 0) {
                 return;
         }
         // Linear containers don't have gaps because it'd create double gaps
-        if (c->type == C_CONTAINER &&
-                        c->layout != L_TABBED && c->layout != L_STACKED) {
+        if (!c->view && c->layout != L_TABBED && c->layout != L_STACKED) {
                 return;
         }
         // Children of tabbed/stacked containers re-use the gaps of the container
-        enum sway_container_layout layout = c->parent->layout;
+        enum sway_container_layout layout = container_parent_layout(c);
         if (layout == L_TABBED || layout == L_STACKED) {
                 return;
         }
 
-        struct sway_container *ws = container_parent(c, C_WORKSPACE);
+        struct sway_workspace *ws = c->workspace;
 
         c->current_gaps = ws->has_gaps ? ws->gaps_inner : config->gaps_inner;
         c->x += c->current_gaps;
@@ -1185,222 +1010,154 @@ void container_add_gaps(struct sway_container *c) {
         c->height -= 2 * c->current_gaps;
 }
 
-int container_sibling_index(const struct sway_container *child) {
-        return list_find(child->parent->children, child);
+enum sway_container_layout container_parent_layout(struct sway_container *con) {
+        if (con->parent) {
+                return con->parent->layout;
+        }
+        return con->workspace->layout;
 }
 
-void container_handle_fullscreen_reparent(struct sway_container *con,
-                struct sway_container *old_parent) {
-        if (!con->is_fullscreen) {
-                return;
+enum sway_container_layout container_current_parent_layout(
+                struct sway_container *con) {
+        if (con->current.parent) {
+                return con->current.parent->current.layout;
         }
-        struct sway_container *old_workspace = old_parent;
-        if (old_workspace && old_workspace->type != C_WORKSPACE) {
-                old_workspace = container_parent(old_workspace, C_WORKSPACE);
+        return con->current.workspace->current.layout;
+}
+
+list_t *container_get_siblings(const struct sway_container *container) {
+        if (container->parent) {
+                return container->parent->children;
         }
-        struct sway_container *new_workspace = container_parent(con, C_WORKSPACE);
-        if (old_workspace == new_workspace) {
-                return;
+        if (!container->workspace) {
+                return NULL;
         }
-        // Unmark the old workspace as fullscreen
-        if (old_workspace) {
-                old_workspace->sway_workspace->fullscreen = NULL;
+        if (list_find(container->workspace->tiling, container) != -1) {
+                return container->workspace->tiling;
         }
+        return container->workspace->floating;
+}
 
-        // Mark the new workspace as fullscreen
-        if (new_workspace->sway_workspace->fullscreen) {
-                container_set_fullscreen(
-                                new_workspace->sway_workspace->fullscreen, false);
-        }
-        new_workspace->sway_workspace->fullscreen = con;
+int container_sibling_index(const struct sway_container *child) {
+        return list_find(container_get_siblings(child), child);
+}
 
-        // Resize container to new output dimensions
-        struct sway_container *output = new_workspace->parent;
-        con->x = output->x;
-        con->y = output->y;
-        con->width = output->width;
-        con->height = output->height;
+list_t *container_get_current_siblings(struct sway_container *container) {
+        if (container->current.parent) {
+                return container->current.parent->current.children;
+        }
+        return container->current.workspace->current.tiling;
+}
 
-        if (con->type == C_VIEW) {
-                struct sway_view *view = con->sway_view;
-                view->x = output->x;
-                view->y = output->y;
-                view->width = output->width;
-                view->height = output->height;
-        } else {
-                arrange_windows(new_workspace);
+void container_handle_fullscreen_reparent(struct sway_container *con) {
+        if (!con->is_fullscreen || con->workspace->fullscreen == con) {
+                return;
         }
+        if (con->workspace->fullscreen) {
+                container_set_fullscreen(con->workspace->fullscreen, false);
+        }
+        con->workspace->fullscreen = con;
+
+        arrange_workspace(con->workspace);
+}
+
+static void set_workspace(struct sway_container *container, void *data) {
+        container->workspace = container->parent->workspace;
 }
 
 void container_insert_child(struct sway_container *parent,
                 struct sway_container *child, int i) {
-        struct sway_container *old_parent = child->parent;
-        if (old_parent) {
-                container_remove_child(child);
+        if (child->workspace) {
+                container_detach(child);
         }
-        wlr_log(WLR_DEBUG, "Inserting id:%zd at index %d", child->id, i);
         list_insert(parent->children, i, child);
         child->parent = parent;
-        container_handle_fullscreen_reparent(child, old_parent);
+        child->workspace = parent->workspace;
+        container_for_each_child(child, set_workspace, NULL);
+        container_handle_fullscreen_reparent(child);
+        container_update_representation(parent);
 }
 
-struct sway_container *container_add_sibling(struct sway_container *fixed,
-                struct sway_container *active) {
-        // TODO handle floating
-        struct sway_container *old_parent = NULL;
-        if (active->parent) {
-                old_parent = active->parent;
-                container_remove_child(active);
-        }
-        struct sway_container *parent = fixed->parent;
-        int i = container_sibling_index(fixed);
-        list_insert(parent->children, i + 1, active);
-        active->parent = parent;
-        container_handle_fullscreen_reparent(active, old_parent);
-        return active->parent;
+void container_add_sibling(struct sway_container *fixed,
+                struct sway_container *active, int offset) {
+        if (active->workspace) {
+                container_detach(active);
+        }
+        list_t *siblings = container_get_siblings(fixed);
+        int index = list_find(siblings, fixed);
+        list_insert(siblings, index + offset, active);
+        active->parent = fixed->parent;
+        active->workspace = fixed->workspace;
+        container_for_each_child(active, set_workspace, NULL);
+        container_handle_fullscreen_reparent(active);
+        container_update_representation(active);
 }
 
 void container_add_child(struct sway_container *parent,
                 struct sway_container *child) {
-        wlr_log(WLR_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);
-        struct sway_container *old_parent = child->parent;
+        if (child->workspace) {
+                container_detach(child);
+        }
         list_add(parent->children, child);
         child->parent = parent;
-        container_handle_fullscreen_reparent(child, old_parent);
-        if (old_parent) {
-                container_set_dirty(old_parent);
-        }
-        container_set_dirty(child);
+        child->workspace = parent->workspace;
+        container_for_each_child(child, set_workspace, NULL);
+        container_handle_fullscreen_reparent(child);
+        container_update_representation(parent);
+        node_set_dirty(&child->node);
+        node_set_dirty(&parent->node);
 }
 
-struct sway_container *container_remove_child(struct sway_container *child) {
+void container_detach(struct sway_container *child) {
         if (child->is_fullscreen) {
-                struct sway_container *workspace = container_parent(child, C_WORKSPACE);
-                workspace->sway_workspace->fullscreen = NULL;
+                child->workspace->fullscreen = NULL;
         }
 
-        struct sway_container *parent = child->parent;
-        list_t *list = container_is_floating(child) ?
-                parent->sway_workspace->floating : parent->children;
-        int index = list_find(list, child);
+        struct sway_container *old_parent = child->parent;
+        struct sway_workspace *old_workspace = child->workspace;
+        list_t *siblings = container_get_siblings(child);
+        int index = list_find(siblings, child);
         if (index != -1) {
-                list_del(list, index);
+                list_del(siblings, index);
         }
         child->parent = NULL;
-        container_notify_subtree_changed(parent);
-
-        container_set_dirty(parent);
-        container_set_dirty(child);
-
-        return parent;
-}
-
-enum sway_container_layout container_get_default_layout(
-                struct sway_container *con) {
-        if (con->type != C_OUTPUT) {
-                con = container_parent(con, C_OUTPUT);
-        }
+        child->workspace = NULL;
+        container_for_each_child(child, set_workspace, NULL);
 
-        if (!sway_assert(con != NULL,
-                        "container_get_default_layout must be called on an attached"
-                        " container below the root container")) {
-                return 0;
-        }
-
-        if (config->default_layout != L_NONE) {
-                return config->default_layout;
-        } else if (config->default_orientation != L_NONE) {
-                return config->default_orientation;
-        } else if (con->width >= con->height) {
-                return L_HORIZ;
+        if (old_parent) {
+                container_update_representation(old_parent);
+                node_set_dirty(&old_parent->node);
         } else {
-                return L_VERT;
+                workspace_update_representation(old_workspace);
+                node_set_dirty(&old_workspace->node);
         }
+        node_set_dirty(&child->node);
 }
 
-struct sway_container *container_replace_child(struct sway_container *child,
-                struct sway_container *new_child) {
-        struct sway_container *parent = child->parent;
-        if (parent == NULL) {
-                return NULL;
-        }
-
-        list_t *list = container_is_floating(child) ?
-                parent->sway_workspace->floating : parent->children;
-        int i = list_find(list, child);
-
-        if (new_child->parent) {
-                container_remove_child(new_child);
-        }
-        list->items[i] = new_child;
-        new_child->parent = parent;
-        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;
-
-        return parent;
+void container_replace(struct sway_container *container,
+                struct sway_container *replacement) {
+        container_add_sibling(container, replacement, 1);
+        container_detach(container);
 }
 
 struct sway_container *container_split(struct sway_container *child,
                 enum sway_container_layout layout) {
-        // TODO floating: cannot split a floating container
-        if (!sway_assert(child, "child cannot be null")) {
-                return NULL;
-        }
-        if (child->type == C_WORKSPACE && child->children->length == 0) {
-                // Special case: this just behaves like splitt
-                child->prev_split_layout = child->layout;
-                child->layout = layout;
-                return child;
-        }
-
-        struct sway_container *cont = container_create(C_CONTAINER);
-
-        wlr_log(WLR_DEBUG, "creating container %p around %p", cont, child);
+        struct sway_seat *seat = input_manager_get_default_seat(input_manager);
+        bool set_focus = (seat_get_focus(seat) == &child->node);
 
-        cont->prev_split_layout = L_NONE;
+        struct sway_container *cont = container_create(NULL);
         cont->width = child->width;
         cont->height = child->height;
-        cont->x = child->x;
-        cont->y = child->y;
         cont->current_gaps = child->current_gaps;
+        cont->layout = layout;
 
-        struct sway_seat *seat = input_manager_get_default_seat(input_manager);
-        bool set_focus = (seat_get_focus(seat) == child);
-
-        if (child->type == C_WORKSPACE) {
-                struct sway_container *workspace = child;
-                while (workspace->children->length) {
-                        struct sway_container *ws_child = workspace->children->items[0];
-                        container_remove_child(ws_child);
-                        container_add_child(cont, ws_child);
-                }
-
-                container_add_child(workspace, cont);
-                enum sway_container_layout old_layout = workspace->layout;
-                workspace->layout = layout;
-                cont->layout = old_layout;
-        } else {
-                cont->layout = layout;
-                container_replace_child(child, cont);
-                container_add_child(cont, child);
-        }
+        container_replace(child, cont);
+        container_add_child(cont, child);
 
         if (set_focus) {
-                seat_set_focus(seat, cont);
-                seat_set_focus(seat, child);
+                seat_set_focus(seat, &cont->node);
+                seat_set_focus(seat, &child->node);
         }
 
-        container_notify_subtree_changed(cont);
         return cont;
 }