1 files changed, 554 insertions, 180 deletions

diff --git a/sway/desktop/transaction.c b/sway/desktop/transaction.c
index eac38991..acc3e3f9 100644
--- a/sway/desktop/transaction.c
+++ b/sway/desktop/transaction.c
@@ -5,7 +5,7 @@
 #include <time.h>
 #include <wlr/types/wlr_buffer.h>
 #include "sway/config.h"
-#include "sway/desktop.h"
+#include "sway/scene_descriptor.h"
 #include "sway/desktop/idle_inhibit_v1.h"
 #include "sway/desktop/transaction.h"
 #include "sway/input/cursor.h"
@@ -35,6 +35,8 @@ struct sway_transaction_instruction {
                 struct sway_container_state container_state;
         };
         uint32_t serial;
+        bool server_request;
+        bool waiting;
 };
 
 static struct sway_transaction *transaction_create(void) {
@@ -86,7 +88,11 @@ static void transaction_destroy(struct sway_transaction *transaction) {
 static void copy_output_state(struct sway_output *output,
                 struct sway_transaction_instruction *instruction) {
         struct sway_output_state *state = &instruction->output_state;
-        state->workspaces = create_list();
+        if (state->workspaces) {
+                state->workspaces->length = 0;
+        } else {
+                state->workspaces = create_list();
+        }
         list_cat(state->workspaces, output->workspaces);
 
         state->active_workspace = output_get_active_workspace(output);
@@ -104,8 +110,16 @@ static void copy_workspace_state(struct sway_workspace *ws,
         state->layout = ws->layout;
 
         state->output = ws->output;
-        state->floating = create_list();
-        state->tiling = create_list();
+        if (state->floating) {
+                state->floating->length = 0;
+        } else {
+                state->floating = create_list();
+        }
+        if (state->tiling) {
+                state->tiling->length = 0;
+        } else {
+                state->tiling = create_list();
+        }
         list_cat(state->floating, ws->floating);
         list_cat(state->tiling, ws->tiling);
 
@@ -115,8 +129,8 @@ static void copy_workspace_state(struct sway_workspace *ws,
         // Set focused_inactive_child to the direct tiling child
         struct sway_container *focus = seat_get_focus_inactive_tiling(seat, ws);
         if (focus) {
-                while (focus->parent) {
-                        focus = focus->parent;
+                while (focus->pending.parent) {
+                        focus = focus->pending.parent;
                 }
         }
         state->focused_inactive_child = focus;
@@ -126,28 +140,19 @@ static void copy_container_state(struct sway_container *container,
                 struct sway_transaction_instruction *instruction) {
         struct sway_container_state *state = &instruction->container_state;
 
-        state->layout = container->layout;
-        state->x = container->x;
-        state->y = container->y;
-        state->width = container->width;
-        state->height = container->height;
-        state->fullscreen_mode = container->fullscreen_mode;
-        state->parent = container->parent;
-        state->workspace = container->workspace;
-        state->border = container->border;
-        state->border_thickness = container->border_thickness;
-        state->border_top = container->border_top;
-        state->border_left = container->border_left;
-        state->border_right = container->border_right;
-        state->border_bottom = container->border_bottom;
-        state->content_x = container->content_x;
-        state->content_y = container->content_y;
-        state->content_width = container->content_width;
-        state->content_height = container->content_height;
+        if (state->children) {
+                list_free(state->children);
+        }
+
+        memcpy(state, &container->pending, sizeof(struct sway_container_state));
 
         if (!container->view) {
+                // We store a copy of the child list to avoid having it mutated after
+                // we copy the state.
                 state->children = create_list();
-                list_cat(state->children, container->children);
+                list_cat(state->children, container->pending.children);
+        } else {
+                state->children = NULL;
         }
 
         struct sway_seat *seat = input_manager_current_seat();
@@ -161,14 +166,36 @@ static void copy_container_state(struct sway_container *container,
 }
 
 static void transaction_add_node(struct sway_transaction *transaction,
-                struct sway_node *node) {
-        struct sway_transaction_instruction *instruction =
-                calloc(1, sizeof(struct sway_transaction_instruction));
-        if (!sway_assert(instruction, "Unable to allocate instruction")) {
-                return;
+                struct sway_node *node, bool server_request) {
+        struct sway_transaction_instruction *instruction = NULL;
+
+        // Check if we have an instruction for this node already, in which case we
+        // update that instead of creating a new one.
+        if (node->ntxnrefs > 0) {
+                for (int idx = 0; idx < transaction->instructions->length; idx++) {
+                        struct sway_transaction_instruction *other =
+                                transaction->instructions->items[idx];
+                        if (other->node == node) {
+                                instruction = other;
+                                break;
+                        }
+                }
+        }
+
+        if (!instruction) {
+                instruction = calloc(1, sizeof(struct sway_transaction_instruction));
+                if (!sway_assert(instruction, "Unable to allocate instruction")) {
+                        return;
+                }
+                instruction->transaction = transaction;
+                instruction->node = node;
+                instruction->server_request = server_request;
+
+                list_add(transaction->instructions, instruction);
+                node->ntxnrefs++;
+        } else if (server_request) {
+                instruction->server_request = true;
         }
-        instruction->transaction = transaction;
-        instruction->node = node;
 
         switch (node->type) {
         case N_ROOT:
@@ -183,46 +210,24 @@ static void transaction_add_node(struct sway_transaction *transaction,
                 copy_container_state(node->sway_container, instruction);
                 break;
         }
-
-        list_add(transaction->instructions, instruction);
-        node->ntxnrefs++;
 }
 
 static void apply_output_state(struct sway_output *output,
                 struct sway_output_state *state) {
-        output_damage_whole(output);
         list_free(output->current.workspaces);
         memcpy(&output->current, state, sizeof(struct sway_output_state));
-        output_damage_whole(output);
 }
 
 static void apply_workspace_state(struct sway_workspace *ws,
                 struct sway_workspace_state *state) {
-        output_damage_whole(ws->current.output);
         list_free(ws->current.floating);
         list_free(ws->current.tiling);
         memcpy(&ws->current, state, sizeof(struct sway_workspace_state));
-        output_damage_whole(ws->current.output);
 }
 
 static void apply_container_state(struct sway_container *container,
                 struct sway_container_state *state) {
         struct sway_view *view = container->view;
-        // Damage the old location
-        desktop_damage_whole_container(container);
-        if (view && !wl_list_empty(&view->saved_buffers)) {
-                struct sway_saved_buffer *saved_buf;
-                wl_list_for_each(saved_buf, &view->saved_buffers, link) {
-                        struct wlr_box box = {
-                                .x = container->current.content_x - view->saved_geometry.x + saved_buf->x,
-                                .y = container->current.content_y - view->saved_geometry.y + saved_buf->y,
-                                .width = saved_buf->width,
-                                .height = saved_buf->height,
-                        };
-                        desktop_damage_box(&box);
-                }
-        }
-
         // There are separate children lists for each instruction state, the
         // container's current state and the container's pending state
         // (ie. con->children). The list itself needs to be freed here.
@@ -232,46 +237,449 @@ static void apply_container_state(struct sway_container *container,
 
         memcpy(&container->current, state, sizeof(struct sway_container_state));
 
-        if (view && !wl_list_empty(&view->saved_buffers)) {
-                if (!container->node.destroying || container->node.ntxnrefs == 1) {
-                        view_remove_saved_buffer(view);
+        if (view) {
+                if (view->saved_surface_tree) {
+                        if (!container->node.destroying || container->node.ntxnrefs == 1) {
+                                view_remove_saved_buffer(view);
+                        }
+                }
+
+                // If the view hasn't responded to the configure, center it within
+                // the container. This is important for fullscreen views which
+                // refuse to resize to the size of the output.
+                if (view->surface) {
+                        view_center_and_clip_surface(view);
+                }
+        }
+}
+
+static void arrange_title_bar(struct sway_container *con,
+                int x, int y, int width, int height) {
+        container_update(con);
+
+        bool has_title_bar = height > 0;
+        wlr_scene_node_set_enabled(&con->title_bar.tree->node, has_title_bar);
+        if (!has_title_bar) {
+                return;
+        }
+
+        wlr_scene_node_set_position(&con->title_bar.tree->node, x, y);
+
+        con->title_width = width;
+        container_arrange_title_bar(con);
+}
+
+static void disable_container(struct sway_container *con) {
+        if (con->view) {
+                wlr_scene_node_reparent(&con->view->scene_tree->node, con->content_tree);
+        } else {
+                for (int i = 0; i < con->current.children->length; i++) {
+                        struct sway_container *child = con->current.children->items[i];
+
+                        wlr_scene_node_reparent(&child->scene_tree->node, con->content_tree);
+
+                        disable_container(child);
+                }
+        }
+}
+
+static void arrange_container(struct sway_container *con,
+                int width, int height, bool title_bar, int gaps);
+
+static void arrange_children(enum sway_container_layout layout, list_t *children,
+                struct sway_container *active, struct wlr_scene_tree *content,
+                int width, int height, int gaps) {
+        int title_bar_height = container_titlebar_height();
+
+        if (layout == L_TABBED) {
+                struct sway_container *first = children->length == 1 ?
+                        ((struct sway_container *)children->items[0]) : NULL;
+                if (config->hide_lone_tab && first && first->view &&
+                                first->current.border != B_NORMAL) {
+                        title_bar_height = 0;
+                }
+
+                double w = (double) width / children->length;
+                int title_offset = 0;
+                for (int i = 0; i < children->length; i++) {
+                        struct sway_container *child = children->items[i];
+                        bool activated = child == active;
+                        int next_title_offset = round(w * i + w);
+
+                        arrange_title_bar(child, title_offset, -title_bar_height,
+                                next_title_offset - title_offset, title_bar_height);
+                        wlr_scene_node_set_enabled(&child->border.tree->node, activated);
+                        wlr_scene_node_set_position(&child->scene_tree->node, 0, title_bar_height);
+                        wlr_scene_node_reparent(&child->scene_tree->node, content);
+
+                        if (activated) {
+                                arrange_container(child, width, height - title_bar_height,
+                                        false, 0);
+                        } else {
+                                disable_container(child);
+                        }
+
+                        title_offset = next_title_offset;
                 }
+        } else if (layout == L_STACKED) {
+                struct sway_container *first = children->length == 1 ?
+                        ((struct sway_container *)children->items[0]) : NULL;
+                if (config->hide_lone_tab && first && first->view &&
+                                first->current.border != B_NORMAL) {
+                        title_bar_height = 0;
+                }
+
+                int title_height = title_bar_height * children->length;
+
+                int y = 0;
+                for (int i = 0; i < children->length; i++) {
+                        struct sway_container *child = children->items[i];
+                        bool activated = child == active;
+
+                        arrange_title_bar(child, 0, y - title_height, width, title_bar_height);
+                        wlr_scene_node_set_enabled(&child->border.tree->node, activated);
+                        wlr_scene_node_set_position(&child->scene_tree->node, 0, title_height);
+                        wlr_scene_node_reparent(&child->scene_tree->node, content);
+
+                        if (activated) {
+                                arrange_container(child, width, height - title_height,
+                                        false, 0);
+                        } else {
+                                disable_container(child);
+                        }
+
+                        y += title_bar_height;
+                }
+        } else if (layout == L_VERT) {
+                int off = 0;
+                for (int i = 0; i < children->length; i++) {
+                        struct sway_container *child = children->items[i];
+                        int cheight = child->current.height;
+
+                        wlr_scene_node_set_enabled(&child->border.tree->node, true);
+                        wlr_scene_node_set_position(&child->scene_tree->node, 0, off);
+                        wlr_scene_node_reparent(&child->scene_tree->node, content);
+                        arrange_container(child, width, cheight, true, gaps);
+                        off += cheight + gaps;
+                }
+        } else if (layout == L_HORIZ) {
+                int off = 0;
+                for (int i = 0; i < children->length; i++) {
+                        struct sway_container *child = children->items[i];
+                        int cwidth = child->current.width;
+
+                        wlr_scene_node_set_enabled(&child->border.tree->node, true);
+                        wlr_scene_node_set_position(&child->scene_tree->node, off, 0);
+                        wlr_scene_node_reparent(&child->scene_tree->node, content);
+                        arrange_container(child, cwidth, height, true, gaps);
+                        off += cwidth + gaps;
+                }
+        } else {
+                sway_assert(false, "unreachable");
+        }
+}
+
+static void arrange_container(struct sway_container *con,
+                int width, int height, bool title_bar, int gaps) {
+        // this container might have previously been in the scratchpad,
+        // make sure it's enabled for viewing
+        wlr_scene_node_set_enabled(&con->scene_tree->node, true);
+
+        if (con->output_handler) {
+                wlr_scene_buffer_set_dest_size(con->output_handler, width, height);
+        }
+
+        if (con->view) {
+                int border_top = container_titlebar_height();
+                int border_width = con->current.border_thickness;
+
+                if (title_bar && con->current.border != B_NORMAL) {
+                        wlr_scene_node_set_enabled(&con->title_bar.tree->node, false);
+                        wlr_scene_node_set_enabled(&con->border.top->node, true);
+                } else {
+                        wlr_scene_node_set_enabled(&con->border.top->node, false);
+                }
+
+                if (con->current.border == B_NORMAL) {
+                        if (title_bar) {
+                                arrange_title_bar(con, 0, 0, width, border_top);
+                        } else {
+                                border_top = 0;
+                                // should be handled by the parent container
+                        }
+                } else if (con->current.border == B_PIXEL) {
+                        container_update(con);
+                        border_top = title_bar && con->current.border_top ? border_width : 0;
+                } else if (con->current.border == B_NONE) {
+                        container_update(con);
+                        border_top = 0;
+                        border_width = 0;
+                } else if (con->current.border == B_CSD) {
+                        border_top = 0;
+                        border_width = 0;
+                } else {
+                        sway_assert(false, "unreachable");
+                }
+
+                int border_bottom = con->current.border_bottom ? border_width : 0;
+                int border_left = con->current.border_left ? border_width : 0;
+                int border_right = con->current.border_right ? border_width : 0;
+
+                wlr_scene_rect_set_size(con->border.top, width, border_top);
+                wlr_scene_rect_set_size(con->border.bottom, width, border_bottom);
+                wlr_scene_rect_set_size(con->border.left,
+                        border_left, height - border_top - border_bottom);
+                wlr_scene_rect_set_size(con->border.right,
+                        border_right, height - border_top - border_bottom);
+
+                wlr_scene_node_set_position(&con->border.top->node, 0, 0);
+                wlr_scene_node_set_position(&con->border.bottom->node,
+                        0, height - border_bottom);
+                wlr_scene_node_set_position(&con->border.left->node,
+                        0, border_top);
+                wlr_scene_node_set_position(&con->border.right->node,
+                        width - border_right, border_top);
+
+                // make sure to reparent, it's possible that the client just came out of
+                // fullscreen mode where the parent of the surface is not the container
+                wlr_scene_node_reparent(&con->view->scene_tree->node, con->content_tree);
+                wlr_scene_node_set_position(&con->view->scene_tree->node,
+                        border_left, border_top);
+        } else {
+                // make sure to disable the title bar if the parent is not managing it
+                if (title_bar) {
+                        wlr_scene_node_set_enabled(&con->title_bar.tree->node, false);
+                }
+
+                arrange_children(con->current.layout, con->current.children,
+                        con->current.focused_inactive_child, con->content_tree,
+                        width, height, gaps);
         }
+}
+
+static int container_get_gaps(struct sway_container *con) {
+        struct sway_workspace *ws = con->current.workspace;
+        struct sway_container *temp = con;
+        while (temp) {
+                enum sway_container_layout layout;
+                if (temp->current.parent) {
+                        layout = temp->current.parent->current.layout;
+                } else {
+                        layout = ws->current.layout;
+                }
+                if (layout == L_TABBED || layout == L_STACKED) {
+                        return 0;
+                }
+                temp = temp->pending.parent;
+        }
+        return ws->gaps_inner;
+}
 
-        // Damage the new location
-        desktop_damage_whole_container(container);
-        if (view && view->surface) {
-                struct wlr_surface *surface = view->surface;
-                struct wlr_box box = {
-                        .x = container->current.content_x - view->geometry.x,
-                        .y = container->current.content_y - view->geometry.y,
-                        .width = surface->current.width,
-                        .height = surface->current.height,
-                };
-                desktop_damage_box(&box);
+static void arrange_fullscreen(struct wlr_scene_tree *tree,
+                struct sway_container *fs, struct sway_workspace *ws,
+                int width, int height) {
+        struct wlr_scene_node *fs_node;
+        if (fs->view) {
+                fs_node = &fs->view->scene_tree->node;
+
+                // if we only care about the view, disable any decorations
+                wlr_scene_node_set_enabled(&fs->scene_tree->node, false);
+        } else {
+                fs_node = &fs->scene_tree->node;
+                arrange_container(fs, width, height, true, container_get_gaps(fs));
         }
 
-        // If the view hasn't responded to the configure, center it within
-        // the container. This is important for fullscreen views which
-        // refuse to resize to the size of the output.
-        if (view && view->surface) {
-                if (view->geometry.width < container->current.content_width) {
-                        container->surface_x = container->current.content_x +
-                                (container->current.content_width - view->geometry.width) / 2;
+        wlr_scene_node_reparent(fs_node, tree);
+        wlr_scene_node_lower_to_bottom(fs_node);
+        wlr_scene_node_set_position(fs_node, 0, 0);
+}
+
+static void arrange_workspace_floating(struct sway_workspace *ws) {
+        for (int i = 0; i < ws->current.floating->length; i++) {
+                struct sway_container *floater = ws->current.floating->items[i];
+                struct wlr_scene_tree *layer = root->layers.floating;
+
+                if (floater->current.fullscreen_mode != FULLSCREEN_NONE) {
+                        continue;
+                }
+
+                if (root->fullscreen_global) {
+                        if (container_is_transient_for(floater, root->fullscreen_global)) {
+                                layer = root->layers.fullscreen_global;
+                        }
                 } else {
-                        container->surface_x = container->current.content_x;
+                        for (int i = 0; i < root->outputs->length; i++) {
+                                struct sway_output *output = root->outputs->items[i];
+                                struct sway_workspace *active = output->current.active_workspace;
+
+                                if (active && active->fullscreen &&
+                                                container_is_transient_for(floater, active->fullscreen)) {
+                                        layer = root->layers.fullscreen;
+                                }
+                        }
+                }
+
+                wlr_scene_node_reparent(&floater->scene_tree->node, layer);
+                wlr_scene_node_set_position(&floater->scene_tree->node,
+                        floater->current.x, floater->current.y);
+                wlr_scene_node_set_enabled(&floater->scene_tree->node, true);
+
+                arrange_container(floater, floater->current.width, floater->current.height,
+                        true, ws->gaps_inner);
+        }
+}
+
+static void arrange_workspace_tiling(struct sway_workspace *ws,
+                int width, int height) {
+        arrange_children(ws->current.layout, ws->current.tiling,
+                ws->current.focused_inactive_child, ws->layers.tiling,
+                width, height, ws->gaps_inner);
+}
+
+static void disable_workspace(struct sway_workspace *ws) {
+        // if any containers were just moved to a disabled workspace it will
+        // have the parent of the old workspace. Move the workspace so that it won't
+        // be shown.
+        for (int i = 0; i < ws->current.tiling->length; i++) {
+                struct sway_container *child = ws->current.tiling->items[i];
+
+                wlr_scene_node_reparent(&child->scene_tree->node, ws->layers.tiling);
+                disable_container(child);
+        }
+
+        for (int i = 0; i < ws->current.floating->length; i++) {
+                struct sway_container *floater = ws->current.floating->items[i];
+                wlr_scene_node_reparent(&floater->scene_tree->node, root->layers.floating);
+                disable_container(floater);
+                wlr_scene_node_set_enabled(&floater->scene_tree->node, false);
+        }
+}
+
+static void arrange_output(struct sway_output *output, int width, int height) {
+        for (int i = 0; i < output->current.workspaces->length; i++) {
+                struct sway_workspace *child = output->current.workspaces->items[i];
+
+                bool activated = output->current.active_workspace == child;
+
+                wlr_scene_node_reparent(&child->layers.tiling->node, output->layers.tiling);
+                wlr_scene_node_reparent(&child->layers.fullscreen->node, output->layers.fullscreen);
+
+                for (int i = 0; i < child->current.floating->length; i++) {
+                        struct sway_container *floater = child->current.floating->items[i];
+                        wlr_scene_node_reparent(&floater->scene_tree->node, root->layers.floating);
+                        wlr_scene_node_set_enabled(&floater->scene_tree->node, activated);
                 }
-                if (view->geometry.height < container->current.content_height) {
-                        container->surface_y = container->current.content_y +
-                                (container->current.content_height - view->geometry.height) / 2;
+
+                if (activated) {
+                        struct sway_container *fs = child->current.fullscreen;
+                        wlr_scene_node_set_enabled(&child->layers.tiling->node, !fs);
+                        wlr_scene_node_set_enabled(&child->layers.fullscreen->node, fs);
+
+                        arrange_workspace_floating(child);
+
+                        wlr_scene_node_set_enabled(&output->layers.shell_background->node, !fs);
+                        wlr_scene_node_set_enabled(&output->layers.shell_bottom->node, !fs);
+                        wlr_scene_node_set_enabled(&output->layers.fullscreen->node, fs);
+
+                        if (fs) {
+                                wlr_scene_rect_set_size(output->fullscreen_background, width, height);
+
+                                arrange_fullscreen(child->layers.fullscreen, fs, child,
+                                        width, height);
+                        } else {
+                                struct wlr_box *area = &output->usable_area;
+                                struct side_gaps *gaps = &child->current_gaps;
+
+                                wlr_scene_node_set_position(&child->layers.tiling->node,
+                                        gaps->left + area->x, gaps->top + area->y);
+
+                                arrange_workspace_tiling(child,
+                                        area->width - gaps->left - gaps->right,
+                                        area->height - gaps->top - gaps->bottom);
+                        }
                 } else {
-                        container->surface_y = container->current.content_y;
+                        wlr_scene_node_set_enabled(&child->layers.tiling->node, false);
+                        wlr_scene_node_set_enabled(&child->layers.fullscreen->node, false);
+
+                        disable_workspace(child);
                 }
         }
+}
+
+static void arrange_popup(struct wlr_scene_tree *popup) {
+        struct wlr_scene_node *node;
+        wl_list_for_each(node, &popup->children, link) {
+                struct sway_xdg_popup *popup = scene_descriptor_try_get(node,
+                        SWAY_SCENE_DESC_POPUP);
+
+                // the popup layer may have popups from layer_shell surfaces, in this
+                // case those don't have a scene descriptor, so lets skip those here.
+                if (popup) {
+                        struct wlr_scene_tree *tree = popup->view->content_tree;
+
+                        int lx, ly;
+                        wlr_scene_node_coords(&tree->node, &lx, &ly);
+                        wlr_scene_node_set_position(&popup->scene_tree->node, lx, ly);
+                }
+        }
+}
+
+static void arrange_root(struct sway_root *root) {
+        struct sway_container *fs = root->fullscreen_global;
+
+        wlr_scene_node_set_enabled(&root->layers.shell_background->node, !fs);
+        wlr_scene_node_set_enabled(&root->layers.shell_bottom->node, !fs);
+        wlr_scene_node_set_enabled(&root->layers.tiling->node, !fs);
+        wlr_scene_node_set_enabled(&root->layers.floating->node, !fs);
+        wlr_scene_node_set_enabled(&root->layers.shell_top->node, !fs);
+        wlr_scene_node_set_enabled(&root->layers.fullscreen->node, !fs);
+
+        // hide all contents in the scratchpad
+        for (int i = 0; i < root->scratchpad->length; i++) {
+                struct sway_container *con = root->scratchpad->items[i];
+
+                wlr_scene_node_set_enabled(&con->scene_tree->node, false);
+        }
+
+        if (fs) {
+                for (int i = 0; i < root->outputs->length; i++) {
+                        struct sway_output *output = root->outputs->items[i];
+                        struct sway_workspace *ws = output->current.active_workspace;
+
+                        if (ws) {
+                                arrange_workspace_floating(ws);
+                        }
+                }
 
-        if (!container->node.destroying) {
-                container_discover_outputs(container);
+                arrange_fullscreen(root->layers.fullscreen_global, fs, NULL,
+                        root->width, root->height);
+        } else {
+                for (int i = 0; i < root->outputs->length; i++) {
+                        struct sway_output *output = root->outputs->items[i];
+
+                        wlr_scene_output_set_position(output->scene_output, output->lx, output->ly);
+
+                        wlr_scene_node_reparent(&output->layers.shell_background->node, root->layers.shell_background);
+                        wlr_scene_node_reparent(&output->layers.shell_bottom->node, root->layers.shell_bottom);
+                        wlr_scene_node_reparent(&output->layers.tiling->node, root->layers.tiling);
+                        wlr_scene_node_reparent(&output->layers.shell_top->node, root->layers.shell_top);
+                        wlr_scene_node_reparent(&output->layers.shell_overlay->node, root->layers.shell_overlay);
+                        wlr_scene_node_reparent(&output->layers.fullscreen->node, root->layers.fullscreen);
+                        wlr_scene_node_reparent(&output->layers.session_lock->node, root->layers.session_lock);
+
+                        wlr_scene_node_set_position(&output->layers.shell_background->node, output->lx, output->ly);
+                        wlr_scene_node_set_position(&output->layers.shell_bottom->node, output->lx, output->ly);
+                        wlr_scene_node_set_position(&output->layers.tiling->node, output->lx, output->ly);
+                        wlr_scene_node_set_position(&output->layers.fullscreen->node, output->lx, output->ly);
+                        wlr_scene_node_set_position(&output->layers.shell_top->node, output->lx, output->ly);
+                        wlr_scene_node_set_position(&output->layers.shell_overlay->node, output->lx, output->ly);
+                        wlr_scene_node_set_position(&output->layers.session_lock->node, output->lx, output->ly);
+
+                        arrange_output(output, output->width, output->height);
+                }
         }
+
+        arrange_popup(root->layers.popup);
 }
 
 /**
@@ -313,74 +721,29 @@ static void transaction_apply(struct sway_transaction *transaction) {
 
                 node->instruction = NULL;
         }
-
-        cursor_rebase_all();
 }
 
-static void transaction_commit(struct sway_transaction *transaction);
-
-// Return true if both transactions operate on the same nodes
-static bool transaction_same_nodes(struct sway_transaction *a,
-                struct sway_transaction *b) {
-        if (a->instructions->length != b->instructions->length) {
-                return false;
-        }
-        for (int i = 0; i < a->instructions->length; ++i) {
-                struct sway_transaction_instruction *a_inst = a->instructions->items[i];
-                struct sway_transaction_instruction *b_inst = b->instructions->items[i];
-                if (a_inst->node != b_inst->node) {
-                        return false;
-                }
-        }
-        return true;
-}
+static void transaction_commit_pending(void);
 
-static void transaction_progress_queue(void) {
-        if (!server.transactions->length) {
+static void transaction_progress(void) {
+        if (!server.queued_transaction) {
                 return;
         }
-        // Only the first transaction in the queue is committed, so that's the one
-        // we try to process.
-        struct sway_transaction *transaction = server.transactions->items[0];
-        if (transaction->num_waiting) {
+        if (server.queued_transaction->num_waiting > 0) {
                 return;
         }
-        transaction_apply(transaction);
-        transaction_destroy(transaction);
-        list_del(server.transactions, 0);
+        transaction_apply(server.queued_transaction);
+        arrange_root(root);
+        cursor_rebase_all();
+        transaction_destroy(server.queued_transaction);
+        server.queued_transaction = NULL;
 
-        if (server.transactions->length == 0) {
-                // The transaction queue is empty, so we're done.
-                sway_idle_inhibit_v1_check_active(server.idle_inhibit_manager_v1);
+        if (!server.pending_transaction) {
+                sway_idle_inhibit_v1_check_active();
                 return;
         }
 
-        // If there's a bunch of consecutive transactions which all apply to the
-        // same views, skip all except the last one.
-        while (server.transactions->length >= 2) {
-                struct sway_transaction *txn = server.transactions->items[0];
-                struct sway_transaction *dup = NULL;
-
-                for (int i = 1; i < server.transactions->length; i++) {
-                        struct sway_transaction *maybe_dup = server.transactions->items[i];
-                        if (transaction_same_nodes(txn, maybe_dup)) {
-                                dup = maybe_dup;
-                                break;
-                        }
-                }
-
-                if (dup) {
-                        list_del(server.transactions, 0);
-                        transaction_destroy(txn);
-                } else {
-                        break;
-                }
-        }
-
-        // We again commit the first transaction in the queue to process it.
-        transaction = server.transactions->items[0];
-        transaction_commit(transaction);
-        transaction_progress_queue();
+        transaction_commit_pending();
 }
 
 static int handle_timeout(void *data) {
@@ -388,7 +751,7 @@ static int handle_timeout(void *data) {
         sway_log(SWAY_DEBUG, "Transaction %p timed out (%zi waiting)",
                         transaction, transaction->num_waiting);
         transaction->num_waiting = 0;
-        transaction_progress_queue();
+        transaction_progress();
         return 0;
 }
 
@@ -400,6 +763,9 @@ static bool should_configure(struct sway_node *node,
         if (node->destroying) {
                 return false;
         }
+        if (!instruction->server_request) {
+                return false;
+        }
         struct sway_container_state *cstate = &node->sway_container->current;
         struct sway_container_state *istate = &instruction->container_state;
 #if HAVE_XWAYLAND
@@ -431,28 +797,24 @@ static void transaction_commit(struct sway_transaction *transaction) {
                 struct sway_transaction_instruction *instruction =
                         transaction->instructions->items[i];
                 struct sway_node *node = instruction->node;
+                bool hidden = node_is_view(node) && !node->destroying &&
+                        !view_is_visible(node->sway_container->view);
                 if (should_configure(node, instruction)) {
                         instruction->serial = view_configure(node->sway_container->view,
                                         instruction->container_state.content_x,
                                         instruction->container_state.content_y,
                                         instruction->container_state.content_width,
                                         instruction->container_state.content_height);
-                        ++transaction->num_waiting;
-
-                        // From here on we are rendering a saved buffer of the view, which
-                        // means we can send a frame done event to make the client redraw it
-                        // as soon as possible. Additionally, this is required if a view is
-                        // mapping and its default geometry doesn't intersect an output.
-                        struct timespec now;
-                        clock_gettime(CLOCK_MONOTONIC, &now);
-                        wlr_surface_send_frame_done(
-                                        node->sway_container->view->surface, &now);
-                }
-                if (node_is_view(node) && wl_list_empty(&node->sway_container->view->saved_buffers)) {
+                        if (!hidden) {
+                                instruction->waiting = true;
+                                ++transaction->num_waiting;
+                        }
+
+                        view_send_frame_done(node->sway_container->view);
+                }
+                if (!hidden && node_is_view(node) &&
+                                !node->sway_container->view->saved_surface_tree) {
                         view_save_buffer(node->sway_container->view);
-                        memcpy(&node->sway_container->view->saved_geometry,
-                                        &node->sway_container->view->geometry,
-                                        sizeof(struct wlr_box));
                 }
                 node->instruction = instruction;
         }
@@ -483,6 +845,17 @@ static void transaction_commit(struct sway_transaction *transaction) {
         }
 }
 
+static void transaction_commit_pending(void) {
+        if (server.queued_transaction) {
+                return;
+        }
+        struct sway_transaction *transaction = server.pending_transaction;
+        server.pending_transaction = NULL;
+        server.queued_transaction = transaction;
+        transaction_commit(transaction);
+        transaction_progress();
+}
+
 static void set_instruction_ready(
                 struct sway_transaction_instruction *instruction) {
         struct sway_transaction *transaction = instruction->transaction;
@@ -501,25 +874,28 @@ static void set_instruction_ready(
         }
 
         // If the transaction has timed out then its num_waiting will be 0 already.
-        if (transaction->num_waiting > 0 && --transaction->num_waiting == 0) {
+        if (instruction->waiting && transaction->num_waiting > 0 &&
+                        --transaction->num_waiting == 0) {
                 sway_log(SWAY_DEBUG, "Transaction %p is ready", transaction);
                 wl_event_source_timer_update(transaction->timer, 0);
         }
 
         instruction->node->instruction = NULL;
-        transaction_progress_queue();
+        transaction_progress();
 }
 
-void transaction_notify_view_ready_by_serial(struct sway_view *view,
+bool transaction_notify_view_ready_by_serial(struct sway_view *view,
                 uint32_t serial) {
         struct sway_transaction_instruction *instruction =
                 view->container->node.instruction;
         if (instruction != NULL && instruction->serial == serial) {
                 set_instruction_ready(instruction);
+                return true;
         }
+        return false;
 }
 
-void transaction_notify_view_ready_by_geometry(struct sway_view *view,
+bool transaction_notify_view_ready_by_geometry(struct sway_view *view,
                 double x, double y, int width, int height) {
         struct sway_transaction_instruction *instruction =
                 view->container->node.instruction;
@@ -529,39 +905,37 @@ void transaction_notify_view_ready_by_geometry(struct sway_view *view,
                         instruction->container_state.content_width == width &&
                         instruction->container_state.content_height == height) {
                 set_instruction_ready(instruction);
+                return true;
         }
+        return false;
 }
 
-void transaction_notify_view_ready_immediately(struct sway_view *view) {
-        struct sway_transaction_instruction *instruction =
-                        view->container->node.instruction;
-        if (instruction != NULL) {
-                set_instruction_ready(instruction);
-        }
-}
-
-void transaction_commit_dirty(void) {
+static void _transaction_commit_dirty(bool server_request) {
         if (!server.dirty_nodes->length) {
                 return;
         }
-        struct sway_transaction *transaction = transaction_create();
-        if (!transaction) {
-                return;
+
+        if (!server.pending_transaction) {
+                server.pending_transaction = transaction_create();
+                if (!server.pending_transaction) {
+                        return;
+                }
         }
+
         for (int i = 0; i < server.dirty_nodes->length; ++i) {
                 struct sway_node *node = server.dirty_nodes->items[i];
-                transaction_add_node(transaction, node);
+                transaction_add_node(server.pending_transaction, node, server_request);
                 node->dirty = false;
         }
         server.dirty_nodes->length = 0;
 
-        list_add(server.transactions, transaction);
+        transaction_commit_pending();
+}
 
-        // We only commit the first transaction added to the queue.
-        if (server.transactions->length == 1) {
-                transaction_commit(transaction);
-                // Attempting to progress the queue here is useful
-                // if the transaction has nothing to wait for.
-                transaction_progress_queue();
-        }
+void transaction_commit_dirty(void) {
+        _transaction_commit_dirty(true);
+}
+
+void transaction_commit_dirty_client(void) {
+        _transaction_commit_dirty(false);
 }