1 files changed, 661 insertions, 645 deletions

diff --git a/sway/tree/container.c b/sway/tree/container.c
index 04ef965f..9224b4fb 100644
--- a/sway/tree/container.c
+++ b/sway/tree/container.c
@@ -1,25 +1,20 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
 #include <drm_fourcc.h>
 #include <stdint.h>
 #include <stdlib.h>
-#include <string.h>
-#include <strings.h>
-#include <sys/stat.h>
 #include <wayland-server-core.h>
+#include <wlr/types/wlr_foreign_toplevel_management_v1.h>
 #include <wlr/types/wlr_linux_dmabuf_v1.h>
 #include <wlr/types/wlr_output_layout.h>
 #include <wlr/types/wlr_subcompositor.h>
-#include <wlr/render/drm_format_set.h>
 #include "linux-dmabuf-unstable-v1-protocol.h"
-#include "cairo_util.h"
-#include "pango.h"
 #include "sway/config.h"
-#include "sway/desktop.h"
 #include "sway/desktop/transaction.h"
 #include "sway/input/input-manager.h"
 #include "sway/input/seat.h"
 #include "sway/ipc-server.h"
+#include "sway/scene_descriptor.h"
+#include "sway/sway_text_node.h"
 #include "sway/output.h"
 #include "sway/server.h"
 #include "sway/tree/arrange.h"
@@ -30,6 +25,53 @@
 #include "log.h"
 #include "stringop.h"
 
+static void handle_output_enter(
+                struct wl_listener *listener, void *data) {
+        struct sway_container *con = wl_container_of(
+                        listener, con, output_enter);
+        struct wlr_scene_output *output = data;
+
+        if (con->view->foreign_toplevel) {
+                wlr_foreign_toplevel_handle_v1_output_enter(
+                        con->view->foreign_toplevel, output->output);
+        }
+}
+
+static void handle_output_leave(
+                struct wl_listener *listener, void *data) {
+        struct sway_container *con = wl_container_of(
+                        listener, con, output_leave);
+        struct wlr_scene_output *output = data;
+
+        if (con->view->foreign_toplevel) {
+                wlr_foreign_toplevel_handle_v1_output_leave(
+                        con->view->foreign_toplevel, output->output);
+        }
+}
+
+static bool handle_point_accepts_input(
+                struct wlr_scene_buffer *buffer, double *x, double *y) {
+        return false;
+}
+
+static struct wlr_scene_rect *alloc_rect_node(struct wlr_scene_tree *parent,
+                bool *failed) {
+        if (*failed) {
+                return NULL;
+        }
+
+        // just pass in random values. These will be overwritten when
+        // they need to be used.
+        struct wlr_scene_rect *rect = wlr_scene_rect_create(
+                parent, 0, 0, (float[4]){0.f, 0.f, 0.f, 1.f});
+        if (!rect) {
+                sway_log(SWAY_ERROR, "Failed to allocate a wlr_scene_rect");
+                *failed = true;
+        }
+
+        return rect;
+}
+
 struct sway_container *container_create(struct sway_view *view) {
         struct sway_container *c = calloc(1, sizeof(struct sway_container));
         if (!c) {
@@ -37,23 +79,411 @@ struct sway_container *container_create(struct sway_view *view) {
                 return NULL;
         }
         node_init(&c->node, N_CONTAINER, c);
-        c->pending.layout = L_NONE;
-        c->view = view;
-        c->alpha = 1.0f;
+
+        // Container tree structure
+        // - scene tree
+        //   - title bar
+        //     - border
+        //     - background
+        //     - title text
+        //     - marks text
+        //   - border
+        //     - border top/bottom/left/right
+        //     - content_tree (we put the content node here so when we disable the
+        //       border everything gets disabled. We only render the content iff there
+        //       is a border as well)
+        //     - buffer used for output enter/leave events for foreign_toplevel
+        bool failed = false;
+        c->scene_tree = alloc_scene_tree(root->staging, &failed);
+
+        c->title_bar.tree = alloc_scene_tree(c->scene_tree, &failed);
+        c->title_bar.border = alloc_scene_tree(c->title_bar.tree, &failed);
+        c->title_bar.background = alloc_scene_tree(c->title_bar.tree, &failed);
+
+        // for opacity purposes we need to carfully create the scene such that
+        // none of our rect nodes as well as text buffers don't overlap. To do
+        // this we have to create rects such that they go around text buffers
+        for (int i = 0; i < 4; i++) {
+                alloc_rect_node(c->title_bar.border, &failed);
+        }
+
+        for (int i = 0; i < 5; i++) {
+                alloc_rect_node(c->title_bar.background, &failed);
+        }
+
+        c->border.tree = alloc_scene_tree(c->scene_tree, &failed);
+        c->content_tree = alloc_scene_tree(c->border.tree, &failed);
+
+        if (view) {
+                // only containers with views can have borders
+                c->border.top = alloc_rect_node(c->border.tree, &failed);
+                c->border.bottom = alloc_rect_node(c->border.tree, &failed);
+                c->border.left = alloc_rect_node(c->border.tree, &failed);
+                c->border.right = alloc_rect_node(c->border.tree, &failed);
+
+                c->output_handler = wlr_scene_buffer_create(c->border.tree, NULL);
+                if (!c->output_handler) {
+                        sway_log(SWAY_ERROR, "Failed to allocate a scene node");
+                        failed = true;
+                }
+
+                if (!failed) {
+                        c->output_enter.notify = handle_output_enter;
+                        wl_signal_add(&c->output_handler->events.output_enter,
+                                        &c->output_enter);
+                        c->output_leave.notify = handle_output_leave;
+                        wl_signal_add(&c->output_handler->events.output_leave,
+                                        &c->output_leave);
+                        c->output_handler->point_accepts_input = handle_point_accepts_input;
+                }
+        }
+
+        if (!failed && !scene_descriptor_assign(&c->scene_tree->node,
+                        SWAY_SCENE_DESC_CONTAINER, c)) {
+                failed = true;
+        }
+
+        if (failed) {
+                wlr_scene_node_destroy(&c->scene_tree->node);
+                free(c);
+                return NULL;
+        }
 
         if (!view) {
                 c->pending.children = create_list();
                 c->current.children = create_list();
         }
+
+        c->pending.layout = L_NONE;
+        c->view = view;
+        c->alpha = 1.0f;
         c->marks = create_list();
-        c->outputs = create_list();
 
         wl_signal_init(&c->events.destroy);
-        wl_signal_emit(&root->events.new_node, &c->node);
+        wl_signal_emit_mutable(&root->events.new_node, &c->node);
+
+        container_update(c);
 
         return c;
 }
 
+static bool container_is_focused(struct sway_container *con, void *data) {
+        return con->current.focused;
+}
+
+static bool container_has_focused_child(struct sway_container *con) {
+        return container_find_child(con, container_is_focused, NULL);
+}
+
+static bool container_is_current_parent_focused(struct sway_container *con) {
+        if (con->current.parent) {
+                struct sway_container *parent = con->current.parent;
+                return parent->current.focused || container_is_current_parent_focused(parent);
+        } else if (con->current.workspace) {
+                struct sway_workspace *ws = con->current.workspace;
+                return ws->current.focused;
+        }
+
+        return false;
+}
+
+static struct border_colors *container_get_current_colors(
+                struct sway_container *con) {
+        struct border_colors *colors;
+
+        bool urgent = con->view ?
+                view_is_urgent(con->view) : container_has_urgent_child(con);
+        struct sway_container *active_child;
+
+        if (con->current.parent) {
+                active_child = con->current.parent->current.focused_inactive_child;
+        } else if (con->current.workspace) {
+                active_child = con->current.workspace->current.focused_inactive_child;
+        } else {
+                active_child = NULL;
+        }
+
+        if (urgent) {
+                colors = &config->border_colors.urgent;
+        } else if (con->current.focused || container_is_current_parent_focused(con)) {
+                colors = &config->border_colors.focused;
+        } else if (config->has_focused_tab_title && container_has_focused_child(con)) {
+                colors = &config->border_colors.focused_tab_title;
+        } else if (con == active_child) {
+                colors = &config->border_colors.focused_inactive;
+        } else {
+                colors = &config->border_colors.unfocused;
+        }
+
+        return colors;
+}
+
+static bool container_is_current_floating(struct sway_container *container) {
+        if (!container->current.parent && container->current.workspace &&
+                        list_find(container->current.workspace->floating, container) != -1) {
+                return true;
+        }
+        if (container->scratchpad) {
+                return true;
+        }
+        return false;
+}
+
+// scene rect wants premultiplied colors
+static void scene_rect_set_color(struct wlr_scene_rect *rect,
+                const float color[4], float opacity) {
+        const float premultiplied[] = {
+                color[0] * color[3] * opacity,
+                color[1] * color[3] * opacity,
+                color[2] * color[3] * opacity,
+                color[3] * opacity,
+        };
+
+        wlr_scene_rect_set_color(rect, premultiplied);
+}
+
+void container_update(struct sway_container *con) {
+        struct border_colors *colors = container_get_current_colors(con);
+        list_t *siblings = NULL;
+        enum sway_container_layout layout = L_NONE;
+        float alpha = con->alpha;
+
+        if (con->current.parent) {
+                siblings = con->current.parent->current.children;
+                layout = con->current.parent->current.layout;
+        } else if (con->current.workspace) {
+                siblings = con->current.workspace->current.tiling;
+                layout = con->current.workspace->current.layout;
+        }
+
+        float bottom[4], right[4];
+        memcpy(bottom, colors->child_border, sizeof(bottom));
+        memcpy(right, colors->child_border, sizeof(right));
+
+        if (!container_is_current_floating(con) && siblings && siblings->length == 1) {
+                if (layout == L_HORIZ) {
+                        memcpy(right, colors->indicator, sizeof(right));
+                } else if (layout == L_VERT) {
+                        memcpy(bottom, colors->indicator, sizeof(bottom));
+                }
+        }
+
+        struct wlr_scene_node *node;
+        wl_list_for_each(node, &con->title_bar.border->children, link) {
+                struct wlr_scene_rect *rect = wlr_scene_rect_from_node(node);
+                scene_rect_set_color(rect, colors->border, alpha);
+        }
+
+        wl_list_for_each(node, &con->title_bar.background->children, link) {
+                struct wlr_scene_rect *rect = wlr_scene_rect_from_node(node);
+                scene_rect_set_color(rect, colors->background, alpha);
+        }
+
+        if (con->view) {
+                scene_rect_set_color(con->border.top, colors->child_border, alpha);
+                scene_rect_set_color(con->border.bottom, bottom, alpha);
+                scene_rect_set_color(con->border.left, colors->child_border, alpha);
+                scene_rect_set_color(con->border.right, right, alpha);
+        }
+
+        if (con->title_bar.title_text) {
+                sway_text_node_set_color(con->title_bar.title_text, colors->text);
+                sway_text_node_set_background(con->title_bar.title_text, colors->background);
+        }
+
+        if (con->title_bar.marks_text) {
+                sway_text_node_set_color(con->title_bar.marks_text, colors->text);
+                sway_text_node_set_background(con->title_bar.marks_text, colors->background);
+        }
+}
+
+void container_update_itself_and_parents(struct sway_container *con) {
+        container_update(con);
+
+        if (con->current.parent) {
+                container_update_itself_and_parents(con->current.parent);
+        }
+}
+
+static void update_rect_list(struct wlr_scene_tree *tree, pixman_region32_t *region) {
+        int len;
+        const pixman_box32_t *rects = pixman_region32_rectangles(region, &len);
+
+        wlr_scene_node_set_enabled(&tree->node, len > 0);
+        if (len == 0) {
+                return;
+        }
+
+        int i = 0;
+        struct wlr_scene_node *node;
+        wl_list_for_each(node, &tree->children, link) {
+                struct wlr_scene_rect *rect = wlr_scene_rect_from_node(node);
+                wlr_scene_node_set_enabled(&rect->node, i < len);
+
+                if (i < len) {
+                        const pixman_box32_t *box = &rects[i++];
+                        wlr_scene_node_set_position(&rect->node, box->x1, box->y1);
+                        wlr_scene_rect_set_size(rect, box->x2 - box->x1, box->y2 - box->y1);
+                }
+        }
+}
+
+void container_arrange_title_bar(struct sway_container *con) {
+        enum alignment title_align = config->title_align;
+        int marks_buffer_width = 0;
+        int width = con->title_width;
+        int height = container_titlebar_height();
+
+        pixman_region32_t text_area;
+        pixman_region32_init(&text_area);
+
+        if (con->title_bar.marks_text) {
+                struct sway_text_node *node = con->title_bar.marks_text;
+                marks_buffer_width = node->width;
+
+                int h_padding;
+                if (title_align == ALIGN_RIGHT) {
+                        h_padding = config->titlebar_h_padding;
+                } else {
+                        h_padding = width - config->titlebar_h_padding - marks_buffer_width;
+                }
+
+                h_padding = MAX(h_padding, 0);
+
+                int alloc_width = MIN((int)node->width,
+                        width - h_padding - config->titlebar_h_padding);
+                sway_text_node_set_max_width(node, alloc_width);
+                wlr_scene_node_set_position(node->node,
+                        h_padding, (height - node->height) >> 1);
+
+                pixman_region32_union_rect(&text_area, &text_area,
+                        node->node->x, node->node->y, alloc_width, node->height);
+        }
+
+        if (con->title_bar.title_text) {
+                struct sway_text_node *node = con->title_bar.title_text;
+
+                int h_padding;
+                if (title_align == ALIGN_RIGHT) {
+                        h_padding = width - config->titlebar_h_padding - node->width;
+                } else if (title_align == ALIGN_CENTER) {
+                        h_padding = ((int)width - marks_buffer_width - node->width) >> 1;
+                } else {
+                        h_padding = config->titlebar_h_padding;
+                }
+
+                h_padding = MAX(h_padding, 0);
+
+                int alloc_width = MIN((int) node->width,
+                        width - h_padding - config->titlebar_h_padding);
+                sway_text_node_set_max_width(node, alloc_width);
+                wlr_scene_node_set_position(node->node,
+                        h_padding, (height - node->height) >> 1);
+
+                pixman_region32_union_rect(&text_area, &text_area,
+                        node->node->x, node->node->y, alloc_width, node->height);
+        }
+
+        // silence pixman errors
+        if (width <= 0 || height <= 0) {
+                pixman_region32_fini(&text_area);
+                return;
+        }
+
+        pixman_region32_t background, border;
+
+        int thickness = config->titlebar_border_thickness;
+        pixman_region32_init_rect(&background,
+                thickness, thickness,
+                width - thickness * 2, height - thickness * 2);
+        pixman_region32_init_rect(&border, 0, 0, width, height);
+        pixman_region32_subtract(&border, &border, &background);
+
+        pixman_region32_subtract(&background, &background, &text_area);
+        pixman_region32_fini(&text_area);
+
+        update_rect_list(con->title_bar.background, &background);
+        pixman_region32_fini(&background);
+
+        update_rect_list(con->title_bar.border, &border);
+        pixman_region32_fini(&border);
+
+        container_update(con);
+}
+
+void container_update_marks(struct sway_container *con) {
+        char *buffer = NULL;
+
+        if (config->show_marks && con->marks->length) {
+                size_t len = 0;
+                for (int i = 0; i < con->marks->length; ++i) {
+                        char *mark = con->marks->items[i];
+                        if (mark[0] != '_') {
+                                len += strlen(mark) + 2;
+                        }
+                }
+                buffer = calloc(len + 1, 1);
+                char *part = malloc(len + 1);
+
+                if (!sway_assert(buffer && part, "Unable to allocate memory")) {
+                        free(buffer);
+                        return;
+                }
+
+                for (int i = 0; i < con->marks->length; ++i) {
+                        char *mark = con->marks->items[i];
+                        if (mark[0] != '_') {
+                                snprintf(part, len + 1, "[%s]", mark);
+                                strcat(buffer, part);
+                        }
+                }
+                free(part);
+        }
+
+        if (!buffer) {
+                if (con->title_bar.marks_text) {
+                        wlr_scene_node_destroy(con->title_bar.marks_text->node);
+                        con->title_bar.marks_text = NULL;
+                }
+        } else if (!con->title_bar.marks_text) {
+                struct border_colors *colors = container_get_current_colors(con);
+
+                con->title_bar.marks_text = sway_text_node_create(con->title_bar.tree,
+                        buffer, colors->text, false);
+        } else {
+                sway_text_node_set_text(con->title_bar.marks_text, buffer);
+        }
+
+        container_arrange_title_bar(con);
+        free(buffer);
+}
+
+void container_update_title_bar(struct sway_container *con) {
+        if (!con->formatted_title) {
+                return;
+        }
+
+        struct border_colors *colors = container_get_current_colors(con);
+
+        if (con->title_bar.title_text) {
+                wlr_scene_node_destroy(con->title_bar.title_text->node);
+                con->title_bar.title_text = NULL;
+        }
+
+        con->title_bar.title_text = sway_text_node_create(con->title_bar.tree,
+                con->formatted_title, colors->text, config->pango_markup);
+
+        // we always have to remake these text buffers completely for text font
+        // changes etc...
+        if (con->title_bar.marks_text) {
+                wlr_scene_node_destroy(con->title_bar.marks_text->node);
+                con->title_bar.marks_text = NULL;
+        }
+
+        container_update_marks(con);
+        container_arrange_title_bar(con);
+}
+
 void container_destroy(struct sway_container *con) {
         if (!sway_assert(con->node.destroying,
                                 "Tried to free container which wasn't marked as destroying")) {
@@ -65,29 +495,21 @@ void container_destroy(struct sway_container *con) {
         }
         free(con->title);
         free(con->formatted_title);
-        wlr_texture_destroy(con->title_focused);
-        wlr_texture_destroy(con->title_focused_inactive);
-        wlr_texture_destroy(con->title_unfocused);
-        wlr_texture_destroy(con->title_urgent);
-        wlr_texture_destroy(con->title_focused_tab_title);
         list_free(con->pending.children);
         list_free(con->current.children);
-        list_free(con->outputs);
 
         list_free_items_and_destroy(con->marks);
-        wlr_texture_destroy(con->marks_focused);
-        wlr_texture_destroy(con->marks_focused_inactive);
-        wlr_texture_destroy(con->marks_unfocused);
-        wlr_texture_destroy(con->marks_urgent);
-        wlr_texture_destroy(con->marks_focused_tab_title);
 
         if (con->view && con->view->container == con) {
                 con->view->container = NULL;
+                wlr_scene_node_destroy(&con->output_handler->node);
                 if (con->view->destroying) {
                         view_destroy(con->view);
                 }
         }
 
+        scene_node_disown_children(con->content_tree);
+        wlr_scene_node_destroy(&con->scene_tree->node);
         free(con);
 }
 
@@ -104,7 +526,7 @@ void container_begin_destroy(struct sway_container *con) {
                 container_fullscreen_disable(con);
         }
 
-        wl_signal_emit(&con->node.events.destroy, &con->node);
+        wl_signal_emit_mutable(&con->node.events.destroy, &con->node);
 
         container_end_mouse_operation(con);
 
@@ -174,265 +596,6 @@ struct sway_container *container_find_child(struct sway_container *container,
         return NULL;
 }
 
-static struct sway_container *surface_at_view(struct sway_container *con, double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        if (!sway_assert(con->view, "Expected a view")) {
-                return NULL;
-        }
-        struct sway_view *view = con->view;
-        double view_sx = lx - con->surface_x + view->geometry.x;
-        double view_sy = ly - con->surface_y + view->geometry.y;
-
-        double _sx, _sy;
-        struct wlr_surface *_surface = NULL;
-        switch (view->type) {
-#if HAVE_XWAYLAND
-        case SWAY_VIEW_XWAYLAND:
-                _surface = wlr_surface_surface_at(view->surface,
-                                view_sx, view_sy, &_sx, &_sy);
-                break;
-#endif
-        case SWAY_VIEW_XDG_SHELL:
-                _surface = wlr_xdg_surface_surface_at(
-                                view->wlr_xdg_toplevel->base,
-                                view_sx, view_sy, &_sx, &_sy);
-                break;
-        }
-        if (_surface) {
-                *sx = _sx;
-                *sy = _sy;
-                *surface = _surface;
-                return con;
-        }
-        return NULL;
-}
-
-/**
- * container_at for a container with layout L_TABBED.
- */
-static struct sway_container *container_at_tabbed(struct sway_node *parent,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        struct wlr_box box;
-        node_get_box(parent, &box);
-        if (lx < box.x || lx > box.x + box.width ||
-                        ly < box.y || ly > box.y + box.height) {
-                return NULL;
-        }
-        struct sway_seat *seat = input_manager_current_seat();
-        list_t *children = node_get_children(parent);
-        if (!children->length) {
-                return NULL;
-        }
-
-        // Tab titles
-        int title_height = container_titlebar_height();
-        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 = children->items[child_index];
-                return child;
-        }
-
-        // Surfaces
-        struct sway_node *current = seat_get_active_tiling_child(seat, parent);
-        return current ? tiling_container_at(current, lx, ly, surface, sx, sy) : NULL;
-}
-
-/**
- * container_at for a container with layout L_STACKED.
- */
-static struct sway_container *container_at_stacked(struct sway_node *parent,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        struct wlr_box box;
-        node_get_box(parent, &box);
-        if (lx < box.x || lx > box.x + box.width ||
-                        ly < box.y || ly > box.y + box.height) {
-                return NULL;
-        }
-        struct sway_seat *seat = input_manager_current_seat();
-        list_t *children = node_get_children(parent);
-
-        // Title bars
-        int title_height = container_titlebar_height();
-        if (title_height > 0) {
-                int child_index = (ly - box.y) / title_height;
-                if (child_index < children->length) {
-                        struct sway_container *child = children->items[child_index];
-                        return child;
-                }
-        }
-
-        // Surfaces
-        struct sway_node *current = seat_get_active_tiling_child(seat, parent);
-        return current ? tiling_container_at(current, lx, ly, surface, sx, sy) : NULL;
-}
-
-/**
- * container_at for a container with layout L_HORIZ or L_VERT.
- */
-static struct sway_container *container_at_linear(struct sway_node *parent,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        list_t *children = node_get_children(parent);
-        for (int i = 0; i < children->length; ++i) {
-                struct sway_container *child = children->items[i];
-                struct sway_container *container =
-                        tiling_container_at(&child->node, lx, ly, surface, sx, sy);
-                if (container) {
-                        return container;
-                }
-        }
-        return NULL;
-}
-
-static struct sway_container *floating_container_at(double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        // For outputs with floating containers that overhang the output bounds,
-        // those at the end of the output list appear on top of floating
-        // containers from other outputs, so iterate the list in reverse.
-        for (int i = root->outputs->length - 1; i >= 0; --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
-                        // reverse.
-                        for (int k = ws->floating->length - 1; k >= 0; --k) {
-                                struct sway_container *floater = ws->floating->items[k];
-                                struct sway_container *container =
-                                        tiling_container_at(&floater->node, lx, ly, surface, sx, sy);
-                                if (container) {
-                                        return container;
-                                }
-                        }
-                }
-        }
-        return NULL;
-}
-
-static struct sway_container *view_container_content_at(struct sway_node *parent,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        if (!sway_assert(node_is_view(parent), "Expected a view")) {
-                return NULL;
-        }
-
-        struct sway_container *container = parent->sway_container;
-        struct wlr_box box = {
-                .x = container->pending.content_x,
-                .y = container->pending.content_y,
-                .width = container->pending.content_width,
-                .height = container->pending.content_height,
-        };
-
-        if (wlr_box_contains_point(&box, lx, ly)) {
-                surface_at_view(parent->sway_container, lx, ly, surface, sx, sy);
-                return container;
-        }
-
-        return NULL;
-}
-
-static struct sway_container *view_container_at(struct sway_node *parent,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        if (!sway_assert(node_is_view(parent), "Expected a view")) {
-                return NULL;
-        }
-
-        struct sway_container *container = parent->sway_container;
-        struct wlr_box box = {
-                .x = container->pending.x,
-                .y = container->pending.y,
-                .width = container->pending.width,
-                .height = container->pending.height,
-        };
-
-        if (wlr_box_contains_point(&box, lx, ly)) {
-                surface_at_view(parent->sway_container, lx, ly, surface, sx, sy);
-                return container;
-        }
-
-        return NULL;
-}
-
-struct sway_container *tiling_container_at(struct sway_node *parent,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        if (node_is_view(parent)) {
-                return view_container_at(parent, lx, ly, surface, sx, sy);
-        }
-        if (!node_get_children(parent)) {
-                return NULL;
-        }
-        switch (node_get_layout(parent)) {
-        case L_HORIZ:
-        case L_VERT:
-                return container_at_linear(parent, lx, ly, surface, sx, sy);
-        case L_TABBED:
-                return container_at_tabbed(parent, lx, ly, surface, sx, sy);
-        case L_STACKED:
-                return container_at_stacked(parent, lx, ly, surface, sx, sy);
-        case L_NONE:
-                return NULL;
-        }
-        return NULL;
-}
-
-static bool surface_is_popup(struct wlr_surface *surface) {
-        while (!wlr_surface_is_xdg_surface(surface)) {
-                if (!wlr_surface_is_subsurface(surface)) {
-                        return false;
-                }
-                struct wlr_subsurface *subsurface =
-                        wlr_subsurface_from_wlr_surface(surface);
-                surface = subsurface->parent;
-        }
-        struct wlr_xdg_surface *xdg_surface =
-                wlr_xdg_surface_from_wlr_surface(surface);
-        return xdg_surface->role == WLR_XDG_SURFACE_ROLE_POPUP;
-}
-
-struct sway_container *container_at(struct sway_workspace *workspace,
-                double lx, double ly,
-                struct wlr_surface **surface, double *sx, double *sy) {
-        struct sway_container *c;
-
-        struct sway_seat *seat = input_manager_current_seat();
-        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->view) {
-                c = surface_at_view(focus, lx, ly, surface, sx, sy);
-                if (c && surface_is_popup(*surface)) {
-                        return c;
-                }
-                *surface = NULL;
-        }
-        // Floating
-        if ((c = floating_container_at(lx, ly, surface ,sx ,sy))) {
-                return c;
-        }
-        // Tiling (focused)
-        if (focus && focus->view && !is_floating) {
-                if ((c = view_container_content_at(&focus->node, lx, ly, surface, sx, sy))) {
-                        return c;
-                }
-        }
-        // Tiling (non-focused)
-        if ((c = tiling_container_at(&workspace->node, lx, ly, surface, sx, sy))) {
-                return c;
-        }
-        return NULL;
-}
-
 void container_for_each_child(struct sway_container *container,
                 void (*f)(struct sway_container *container, void *data),
                 void *data) {
@@ -478,127 +641,6 @@ bool container_has_ancestor(struct sway_container *descendant,
         return false;
 }
 
-void container_damage_whole(struct sway_container *container) {
-        for (int i = 0; i < root->outputs->length; ++i) {
-                struct sway_output *output = root->outputs->items[i];
-                output_damage_whole_container(output, container);
-        }
-}
-
-/**
- * Return the output which will be used for scale purposes.
- * This is the most recently entered output.
- */
-struct sway_output *container_get_effective_output(struct sway_container *con) {
-        if (con->outputs->length == 0) {
-                return NULL;
-        }
-        return con->outputs->items[con->outputs->length - 1];
-}
-
-static void render_titlebar_text_texture(struct sway_output *output,
-                struct sway_container *con, struct wlr_texture **texture,
-                struct border_colors *class, bool pango_markup, char *text) {
-        double scale = output->wlr_output->scale;
-        int width = 0;
-        int height = config->font_height * scale;
-        int baseline;
-
-        // We must use a non-nil cairo_t for cairo_set_font_options to work.
-        // Therefore, we cannot use cairo_create(NULL).
-        cairo_surface_t *dummy_surface = cairo_image_surface_create(
-                        CAIRO_FORMAT_ARGB32, 0, 0);
-        cairo_t *c = cairo_create(dummy_surface);
-        cairo_set_antialias(c, CAIRO_ANTIALIAS_BEST);
-        cairo_font_options_t *fo = cairo_font_options_create();
-        cairo_font_options_set_hint_style(fo, CAIRO_HINT_STYLE_FULL);
-        if (output->wlr_output->subpixel == WL_OUTPUT_SUBPIXEL_NONE) {
-                cairo_font_options_set_antialias(fo, CAIRO_ANTIALIAS_GRAY);
-        } else {
-                cairo_font_options_set_antialias(fo, CAIRO_ANTIALIAS_SUBPIXEL);
-                cairo_font_options_set_subpixel_order(fo,
-                        to_cairo_subpixel_order(output->wlr_output->subpixel));
-        }
-        cairo_set_font_options(c, fo);
-        get_text_size(c, config->font_description, &width, NULL, &baseline, scale,
-                        config->pango_markup, "%s", text);
-        cairo_surface_destroy(dummy_surface);
-        cairo_destroy(c);
-
-        if (width == 0 || height == 0) {
-                return;
-        }
-
-        if (height > config->font_height * scale) {
-                height = config->font_height * scale;
-        }
-
-        cairo_surface_t *surface = cairo_image_surface_create(
-                        CAIRO_FORMAT_ARGB32, width, height);
-        cairo_status_t status = cairo_surface_status(surface);
-        if (status != CAIRO_STATUS_SUCCESS) {
-                sway_log(SWAY_ERROR, "cairo_image_surface_create failed: %s",
-                        cairo_status_to_string(status));
-                return;
-        }
-
-        cairo_t *cairo = cairo_create(surface);
-        cairo_set_antialias(cairo, CAIRO_ANTIALIAS_BEST);
-        cairo_set_font_options(cairo, fo);
-        cairo_font_options_destroy(fo);
-        cairo_set_source_rgba(cairo, class->background[0], class->background[1],
-                        class->background[2], class->background[3]);
-        cairo_paint(cairo);
-        PangoContext *pango = pango_cairo_create_context(cairo);
-        cairo_set_source_rgba(cairo, class->text[0], class->text[1],
-                        class->text[2], class->text[3]);
-        cairo_move_to(cairo, 0, config->font_baseline * scale - baseline);
-
-        render_text(cairo, config->font_description, scale, pango_markup, "%s", text);
-
-        cairo_surface_flush(surface);
-        unsigned char *data = cairo_image_surface_get_data(surface);
-        int stride = cairo_image_surface_get_stride(surface);
-        struct wlr_renderer *renderer = output->wlr_output->renderer;
-        *texture = wlr_texture_from_pixels(
-                        renderer, DRM_FORMAT_ARGB8888, stride, width, height, data);
-        cairo_surface_destroy(surface);
-        g_object_unref(pango);
-        cairo_destroy(cairo);
-}
-
-static void update_title_texture(struct sway_container *con,
-                struct wlr_texture **texture, struct border_colors *class) {
-        struct sway_output *output = container_get_effective_output(con);
-        if (!output) {
-                return;
-        }
-        if (*texture) {
-                wlr_texture_destroy(*texture);
-                *texture = NULL;
-        }
-        if (!con->formatted_title) {
-                return;
-        }
-
-        render_titlebar_text_texture(output, con, texture, class,
-                config->pango_markup, con->formatted_title);
-}
-
-void container_update_title_textures(struct sway_container *container) {
-        update_title_texture(container, &container->title_focused,
-                        &config->border_colors.focused);
-        update_title_texture(container, &container->title_focused_inactive,
-                        &config->border_colors.focused_inactive);
-        update_title_texture(container, &container->title_unfocused,
-                        &config->border_colors.unfocused);
-        update_title_texture(container, &container->title_urgent,
-                        &config->border_colors.urgent);
-        update_title_texture(container, &container->title_focused_tab_title,
-                        &config->border_colors.focused_tab_title);
-        container_damage_whole(container);
-}
-
 /**
  * Calculate and return the length of the tree representation.
  * An example tree representation is: V[Terminal, Firefox]
@@ -664,7 +706,13 @@ void container_update_representation(struct sway_container *con) {
                 }
                 container_build_representation(con->pending.layout, con->pending.children,
                                 con->formatted_title);
-                container_update_title_textures(con);
+
+                if (con->title_bar.title_text) {
+                        sway_text_node_set_text(con->title_bar.title_text, con->formatted_title);
+                        container_arrange_title_bar(con);
+                } else {
+                        container_update_title_bar(con);
+                }
         }
         if (con->pending.parent) {
                 container_update_representation(con->pending.parent);
@@ -716,6 +764,21 @@ void floating_calculate_constraints(int *min_width, int *max_width,
 
 }
 
+void floating_fix_coordinates(struct sway_container *con, struct wlr_box *old, struct wlr_box *new) {
+        if (!old->width || !old->height) {
+                // Fall back to centering on the workspace.
+                container_floating_move_to_center(con);
+        } else {
+                int rel_x = con->pending.x - old->x + (con->pending.width / 2);
+                int rel_y = con->pending.y - old->y + (con->pending.height / 2);
+
+                con->pending.x = new->x + (double)(rel_x * new->width) / old->width - (con->pending.width / 2);
+                con->pending.y = new->y + (double)(rel_y * new->height) / old->height - (con->pending.height / 2);
+
+                sway_log(SWAY_DEBUG, "Transformed container %p to coords (%f, %f)", con, con->pending.x, con->pending.y);
+        }
+}
+
 static void floating_natural_resize(struct sway_container *con) {
         int min_width, max_width, min_height, max_height;
         floating_calculate_constraints(&min_width, &max_width,
@@ -787,11 +850,11 @@ void container_floating_set_default_size(struct sway_container *con) {
         int min_width, max_width, min_height, max_height;
         floating_calculate_constraints(&min_width, &max_width,
                         &min_height, &max_height);
-        struct wlr_box *box = calloc(1, sizeof(struct wlr_box));
-        workspace_get_box(con->pending.workspace, box);
+        struct wlr_box box;
+        workspace_get_box(con->pending.workspace, &box);
 
-        double width = fmax(min_width, fmin(box->width * 0.5, max_width));
-        double height = fmax(min_height, fmin(box->height * 0.75, max_height));
+        double width = fmax(min_width, fmin(box.width * 0.5, max_width));
+        double height = fmax(min_height, fmin(box.height * 0.75, max_height));
         if (!con->view) {
                 con->pending.width = width;
                 con->pending.height = height;
@@ -800,8 +863,6 @@ void container_floating_set_default_size(struct sway_container *con) {
                 con->pending.content_height = height;
                 container_set_geometry_from_content(con);
         }
-
-        free(box);
 }
 
 
@@ -937,17 +998,6 @@ bool container_is_floating(struct sway_container *container) {
         return false;
 }
 
-bool container_is_current_floating(struct sway_container *container) {
-        if (!container->current.parent && container->current.workspace &&
-                        list_find(container->current.workspace->floating, container) != -1) {
-                return true;
-        }
-        if (container->scratchpad) {
-                return true;
-        }
-        return false;
-}
-
 void container_get_box(struct sway_container *container, struct wlr_box *box) {
         box->x = container->pending.x;
         box->y = container->pending.y;
@@ -1031,6 +1081,13 @@ void container_floating_move_to(struct sway_container *con,
                 workspace_add_floating(new_workspace, con);
                 arrange_workspace(old_workspace);
                 arrange_workspace(new_workspace);
+                // If the moved container was a visible scratchpad container, then
+                // update its transform.
+                if (con->scratchpad) {
+                        struct wlr_box output_box;
+                        output_get_box(new_output, &output_box);
+                        con->transform = output_box;
+                }
                 workspace_detect_urgent(old_workspace);
                 workspace_detect_urgent(new_workspace);
         }
@@ -1062,16 +1119,6 @@ void container_end_mouse_operation(struct sway_container *container) {
         }
 }
 
-static bool devid_from_fd(int fd, dev_t *devid) {
-        struct stat stat;
-        if (fstat(fd, &stat) != 0) {
-                sway_log_errno(SWAY_ERROR, "fstat failed");
-                return false;
-        }
-        *devid = stat.st_rdev;
-        return true;
-}
-
 static void set_fullscreen(struct sway_container *con, bool enable) {
         if (!con->view) {
                 return;
@@ -1083,75 +1130,6 @@ static void set_fullscreen(struct sway_container *con, bool enable) {
                                 con->view->foreign_toplevel, enable);
                 }
         }
-
-        if (!server.linux_dmabuf_v1 || !con->view->surface) {
-                return;
-        }
-        if (!enable) {
-                wlr_linux_dmabuf_v1_set_surface_feedback(server.linux_dmabuf_v1,
-                        con->view->surface, NULL);
-                return;
-        }
-
-        if (!con->pending.workspace || !con->pending.workspace->output) {
-                return;
-        }
-
-        struct sway_output *output = con->pending.workspace->output;
-        struct wlr_output *wlr_output = output->wlr_output;
-
-        // TODO: add wlroots helpers for all of this stuff
-
-        const struct wlr_drm_format_set *renderer_formats =
-                wlr_renderer_get_dmabuf_texture_formats(server.renderer);
-        assert(renderer_formats);
-
-        int renderer_drm_fd = wlr_renderer_get_drm_fd(server.renderer);
-        int backend_drm_fd = wlr_backend_get_drm_fd(wlr_output->backend);
-        if (renderer_drm_fd < 0 || backend_drm_fd < 0) {
-                return;
-        }
-
-        dev_t render_dev, scanout_dev;
-        if (!devid_from_fd(renderer_drm_fd, &render_dev) ||
-                        !devid_from_fd(backend_drm_fd, &scanout_dev)) {
-                return;
-        }
-
-        const struct wlr_drm_format_set *output_formats =
-                wlr_output_get_primary_formats(output->wlr_output,
-                WLR_BUFFER_CAP_DMABUF);
-        if (!output_formats) {
-                return;
-        }
-
-        struct wlr_drm_format_set scanout_formats = {0};
-        if (!wlr_drm_format_set_intersect(&scanout_formats,
-                        output_formats, renderer_formats)) {
-                return;
-        }
-
-        struct wlr_linux_dmabuf_feedback_v1_tranche tranches[] = {
-                {
-                        .target_device = scanout_dev,
-                        .flags = ZWP_LINUX_DMABUF_FEEDBACK_V1_TRANCHE_FLAGS_SCANOUT,
-                        .formats = &scanout_formats,
-                },
-                {
-                        .target_device = render_dev,
-                        .formats = renderer_formats,
-                },
-        };
-
-        const struct wlr_linux_dmabuf_feedback_v1 feedback = {
-                .main_device = render_dev,
-                .tranches = tranches,
-                .tranches_len = sizeof(tranches) / sizeof(tranches[0]),
-        };
-        wlr_linux_dmabuf_v1_set_surface_feedback(server.linux_dmabuf_v1,
-                con->view->surface, &feedback);
-
-        wlr_drm_format_set_finish(&scanout_formats);
 }
 
 static void container_fullscreen_workspace(struct sway_container *con) {
@@ -1321,72 +1299,6 @@ bool container_is_fullscreen_or_child(struct sway_container *container) {
         return false;
 }
 
-static void surface_send_enter_iterator(struct wlr_surface *surface,
-                int x, int y, void *data) {
-        struct wlr_output *wlr_output = data;
-        wlr_surface_send_enter(surface, wlr_output);
-}
-
-static void surface_send_leave_iterator(struct wlr_surface *surface,
-                int x, int y, void *data) {
-        struct wlr_output *wlr_output = data;
-        wlr_surface_send_leave(surface, wlr_output);
-}
-
-void container_discover_outputs(struct sway_container *con) {
-        struct wlr_box con_box = {
-                .x = con->current.x,
-                .y = con->current.y,
-                .width = con->current.width,
-                .height = con->current.height,
-        };
-        struct sway_output *old_output = container_get_effective_output(con);
-
-        for (int i = 0; i < root->outputs->length; ++i) {
-                struct sway_output *output = root->outputs->items[i];
-                struct wlr_box output_box;
-                output_get_box(output, &output_box);
-                struct wlr_box intersection;
-                bool intersects =
-                        wlr_box_intersection(&intersection, &con_box, &output_box);
-                int index = list_find(con->outputs, output);
-
-                if (intersects && index == -1) {
-                        // Send enter
-                        sway_log(SWAY_DEBUG, "Container %p entered output %p", con, output);
-                        if (con->view) {
-                                view_for_each_surface(con->view,
-                                                surface_send_enter_iterator, output->wlr_output);
-                                if (con->view->foreign_toplevel) {
-                                        wlr_foreign_toplevel_handle_v1_output_enter(
-                                                        con->view->foreign_toplevel, output->wlr_output);
-                                }
-                        }
-                        list_add(con->outputs, output);
-                } else if (!intersects && index != -1) {
-                        // Send leave
-                        sway_log(SWAY_DEBUG, "Container %p left output %p", con, output);
-                        if (con->view) {
-                                view_for_each_surface(con->view,
-                                        surface_send_leave_iterator, output->wlr_output);
-                                if (con->view->foreign_toplevel) {
-                                        wlr_foreign_toplevel_handle_v1_output_leave(
-                                                        con->view->foreign_toplevel, output->wlr_output);
-                                }
-                        }
-                        list_del(con->outputs, index);
-                }
-        }
-        struct sway_output *new_output = container_get_effective_output(con);
-        double old_scale = old_output && old_output->enabled ?
-                old_output->wlr_output->scale : -1;
-        double new_scale = new_output ? new_output->wlr_output->scale : -1;
-        if (old_scale != new_scale) {
-                container_update_title_textures(con);
-                container_update_marks_textures(con);
-        }
-}
-
 enum sway_container_layout container_parent_layout(struct sway_container *con) {
         if (con->pending.parent) {
                 return con->pending.parent->pending.layout;
@@ -1397,19 +1309,11 @@ enum sway_container_layout container_parent_layout(struct sway_container *con) {
         return L_NONE;
 }
 
-enum sway_container_layout container_current_parent_layout(
-                struct sway_container *con) {
-        if (con->current.parent) {
-                return con->current.parent->current.layout;
-        }
-        return con->current.workspace->current.layout;
-}
-
 list_t *container_get_siblings(struct sway_container *container) {
         if (container->pending.parent) {
                 return container->pending.parent->pending.children;
         }
-        if (container_is_scratchpad_hidden(container)) {
+        if (!container->pending.workspace) {
                 return NULL;
         }
         if (list_find(container->pending.workspace->tiling, container) != -1) {
@@ -1422,13 +1326,6 @@ int container_sibling_index(struct sway_container *child) {
         return list_find(container_get_siblings(child), child);
 }
 
-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;
-}
-
 void container_handle_fullscreen_reparent(struct sway_container *con) {
         if (con->pending.fullscreen_mode != FULLSCREEN_WORKSPACE || !con->pending.workspace ||
                         con->pending.workspace->fullscreen == con) {
@@ -1643,7 +1540,7 @@ bool container_find_and_unmark(char *mark) {
                 if (strcmp(con_mark, mark) == 0) {
                         free(con_mark);
                         list_del(con->marks, i);
-                        container_update_marks_textures(con);
+                        container_update_marks(con);
                         ipc_event_window(con, "mark");
                         return true;
                 }
@@ -1674,70 +1571,15 @@ void container_add_mark(struct sway_container *con, char *mark) {
         ipc_event_window(con, "mark");
 }
 
-static void update_marks_texture(struct sway_container *con,
-                struct wlr_texture **texture, struct border_colors *class) {
-        struct sway_output *output = container_get_effective_output(con);
-        if (!output) {
-                return;
-        }
-        if (*texture) {
-                wlr_texture_destroy(*texture);
-                *texture = NULL;
-        }
-        if (!con->marks->length) {
-                return;
-        }
-
-        size_t len = 0;
-        for (int i = 0; i < con->marks->length; ++i) {
-                char *mark = con->marks->items[i];
-                if (mark[0] != '_') {
-                        len += strlen(mark) + 2;
-                }
-        }
-        char *buffer = calloc(len + 1, 1);
-        char *part = malloc(len + 1);
-
-        if (!sway_assert(buffer && part, "Unable to allocate memory")) {
-                free(buffer);
-                return;
-        }
-
-        for (int i = 0; i < con->marks->length; ++i) {
-                char *mark = con->marks->items[i];
-                if (mark[0] != '_') {
-                        snprintf(part, len + 1, "[%s]", mark);
-                        strcat(buffer, part);
-                }
-        }
-        free(part);
-
-        render_titlebar_text_texture(output, con, texture, class, false, buffer);
-
-        free(buffer);
-}
-
-void container_update_marks_textures(struct sway_container *con) {
-        if (!config->show_marks) {
-                return;
-        }
-        update_marks_texture(con, &con->marks_focused,
-                        &config->border_colors.focused);
-        update_marks_texture(con, &con->marks_focused_inactive,
-                        &config->border_colors.focused_inactive);
-        update_marks_texture(con, &con->marks_unfocused,
-                        &config->border_colors.unfocused);
-        update_marks_texture(con, &con->marks_urgent,
-                        &config->border_colors.urgent);
-        update_marks_texture(con, &con->marks_focused_tab_title,
-                        &config->border_colors.focused_tab_title);
-        container_damage_whole(con);
-}
-
 void container_raise_floating(struct sway_container *con) {
         // Bring container to front by putting it at the end of the floating list.
         struct sway_container *floater = container_toplevel_ancestor(con);
         if (container_is_floating(floater) && floater->pending.workspace) {
+                // it's okay to just raise the scene directly instead of waiting
+                // for the transaction to go through. We won't be reconfiguring
+                // surfaces
+                wlr_scene_node_raise_to_top(&floater->scene_tree->node);
+
                 list_move_to_end(floater->pending.workspace->floating, floater);
                 node_set_dirty(&floater->pending.workspace->node);
         }
@@ -1821,3 +1663,177 @@ int container_squash(struct sway_container *con) {
         }
         return change;
 }
+
+static void swap_places(struct sway_container *con1,
+                struct sway_container *con2) {
+        struct sway_container *temp = malloc(sizeof(struct sway_container));
+        temp->pending.x = con1->pending.x;
+        temp->pending.y = con1->pending.y;
+        temp->pending.width = con1->pending.width;
+        temp->pending.height = con1->pending.height;
+        temp->width_fraction = con1->width_fraction;
+        temp->height_fraction = con1->height_fraction;
+        temp->pending.parent = con1->pending.parent;
+        temp->pending.workspace = con1->pending.workspace;
+        bool temp_floating = container_is_floating(con1);
+
+        con1->pending.x = con2->pending.x;
+        con1->pending.y = con2->pending.y;
+        con1->pending.width = con2->pending.width;
+        con1->pending.height = con2->pending.height;
+        con1->width_fraction = con2->width_fraction;
+        con1->height_fraction = con2->height_fraction;
+
+        con2->pending.x = temp->pending.x;
+        con2->pending.y = temp->pending.y;
+        con2->pending.width = temp->pending.width;
+        con2->pending.height = temp->pending.height;
+        con2->width_fraction = temp->width_fraction;
+        con2->height_fraction = temp->height_fraction;
+
+        int temp_index = container_sibling_index(con1);
+        if (con2->pending.parent) {
+                container_insert_child(con2->pending.parent, con1,
+                                container_sibling_index(con2));
+        } else if (container_is_floating(con2)) {
+                workspace_add_floating(con2->pending.workspace, con1);
+        } else {
+                workspace_insert_tiling(con2->pending.workspace, con1,
+                                container_sibling_index(con2));
+        }
+        if (temp->pending.parent) {
+                container_insert_child(temp->pending.parent, con2, temp_index);
+        } else if (temp_floating) {
+                workspace_add_floating(temp->pending.workspace, con2);
+        } else {
+                workspace_insert_tiling(temp->pending.workspace, con2, temp_index);
+        }
+
+        free(temp);
+}
+
+static void swap_focus(struct sway_container *con1,
+                struct sway_container *con2, struct sway_seat *seat,
+                struct sway_container *focus) {
+        if (focus == con1 || focus == con2) {
+                struct sway_workspace *ws1 = con1->pending.workspace;
+                struct sway_workspace *ws2 = con2->pending.workspace;
+                enum sway_container_layout layout1 = container_parent_layout(con1);
+                enum sway_container_layout layout2 = container_parent_layout(con2);
+                if (focus == con1 && (layout2 == L_TABBED || layout2 == L_STACKED)) {
+                        if (workspace_is_visible(ws2)) {
+                                seat_set_focus(seat, &con2->node);
+                        }
+                        seat_set_focus_container(seat, ws1 != ws2 ? con2 : con1);
+                } else if (focus == con2 && (layout1 == L_TABBED
+                                        || layout1 == L_STACKED)) {
+                        if (workspace_is_visible(ws1)) {
+                                seat_set_focus(seat, &con1->node);
+                        }
+                        seat_set_focus_container(seat, ws1 != ws2 ? con1 : con2);
+                } else if (ws1 != ws2) {
+                        seat_set_focus_container(seat, focus == con1 ? con2 : con1);
+                } else {
+                        seat_set_focus_container(seat, focus);
+                }
+        } else {
+                seat_set_focus_container(seat, focus);
+        }
+
+        if (root->fullscreen_global) {
+                seat_set_focus(seat,
+                                seat_get_focus_inactive(seat, &root->fullscreen_global->node));
+        }
+}
+
+void container_swap(struct sway_container *con1, struct sway_container *con2) {
+        if (!sway_assert(con1 && con2, "Cannot swap with nothing")) {
+                return;
+        }
+        if (!sway_assert(!container_has_ancestor(con1, con2)
+                                && !container_has_ancestor(con2, con1),
+                                "Cannot swap ancestor and descendant")) {
+                return;
+        }
+
+        sway_log(SWAY_DEBUG, "Swapping containers %zu and %zu",
+                        con1->node.id, con2->node.id);
+
+        bool scratch1 = con1->scratchpad;
+        bool hidden1 = container_is_scratchpad_hidden(con1);
+        bool scratch2 = con2->scratchpad;
+        bool hidden2 = container_is_scratchpad_hidden(con2);
+        if (scratch1) {
+                if (hidden1) {
+                        root_scratchpad_show(con1);
+                }
+                root_scratchpad_remove_container(con1);
+        }
+        if (scratch2) {
+                if (hidden2) {
+                        root_scratchpad_show(con2);
+                }
+                root_scratchpad_remove_container(con2);
+        }
+
+        enum sway_fullscreen_mode fs1 = con1->pending.fullscreen_mode;
+        if (fs1) {
+                container_fullscreen_disable(con1);
+        }
+        enum sway_fullscreen_mode fs2 = con2->pending.fullscreen_mode;
+        if (fs2) {
+                container_fullscreen_disable(con2);
+        }
+
+        struct sway_seat *seat = input_manager_current_seat();
+        struct sway_container *focus = seat_get_focused_container(seat);
+        struct sway_workspace *vis1 =
+                output_get_active_workspace(con1->pending.workspace->output);
+        struct sway_workspace *vis2 =
+                output_get_active_workspace(con2->pending.workspace->output);
+        if (!sway_assert(vis1 && vis2, "con1 or con2 are on an output without a"
+                                "workspace. This should not happen")) {
+                return;
+        }
+
+        char *stored_prev_name = NULL;
+        if (seat->prev_workspace_name) {
+                stored_prev_name = strdup(seat->prev_workspace_name);
+        }
+
+        swap_places(con1, con2);
+
+        if (!workspace_is_visible(vis1)) {
+                seat_set_focus(seat, seat_get_focus_inactive(seat, &vis1->node));
+        }
+        if (!workspace_is_visible(vis2)) {
+                seat_set_focus(seat, seat_get_focus_inactive(seat, &vis2->node));
+        }
+
+        swap_focus(con1, con2, seat, focus);
+
+        if (stored_prev_name) {
+                free(seat->prev_workspace_name);
+                seat->prev_workspace_name = stored_prev_name;
+        }
+
+        if (scratch1) {
+                root_scratchpad_add_container(con2, NULL);
+                if (!hidden1) {
+                        root_scratchpad_show(con2);
+                }
+        }
+        if (scratch2) {
+                root_scratchpad_add_container(con1, NULL);
+                if (!hidden2) {
+                        root_scratchpad_show(con1);
+                }
+        }
+
+        if (fs1) {
+                container_set_fullscreen(con2, fs1);
+        }
+        if (fs2) {
+                container_set_fullscreen(con1, fs2);
+        }
+}