1 files changed, 119 insertions, 134 deletions

diff --git a/sway/desktop/transaction.c b/sway/desktop/transaction.c
index eac38991..b1f3fb32 100644
--- a/sway/desktop/transaction.c
+++ b/sway/desktop/transaction.c
@@ -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,9 +210,6 @@ 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,
@@ -214,8 +238,8 @@ static void apply_container_state(struct sway_container *container,
                 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,
+                                .x = saved_buf->x - view->saved_geometry.x,
+                                .y = saved_buf->y - view->saved_geometry.y,
                                 .width = saved_buf->width,
                                 .height = saved_buf->height,
                         };
@@ -238,6 +262,13 @@ static void apply_container_state(struct sway_container *container,
                 }
         }
 
+        // 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) {
+                view_center_surface(view);
+        }
+
         // Damage the new location
         desktop_damage_whole_container(container);
         if (view && view->surface) {
@@ -251,24 +282,6 @@ static void apply_container_state(struct sway_container *container,
                 desktop_damage_box(&box);
         }
 
-        // 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;
-                } else {
-                        container->surface_x = container->current.content_x;
-                }
-                if (view->geometry.height < container->current.content_height) {
-                        container->surface_y = container->current.content_y +
-                                (container->current.content_height - view->geometry.height) / 2;
-                } else {
-                        container->surface_y = container->current.content_y;
-                }
-        }
-
         if (!container->node.destroying) {
                 container_discover_outputs(container);
         }
@@ -317,70 +330,25 @@ static void transaction_apply(struct sway_transaction *transaction) {
         cursor_rebase_all();
 }
 
-static void transaction_commit(struct sway_transaction *transaction);
+static void transaction_commit_pending(void);
 
-// 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_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);
+        transaction_destroy(server.queued_transaction);
+        server.queued_transaction = NULL;
 
-        if (server.transactions->length == 0) {
-                // The transaction queue is empty, so we're done.
+        if (!server.pending_transaction) {
                 sway_idle_inhibit_v1_check_active(server.idle_inhibit_manager_v1);
                 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 +356,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 +368,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,13 +402,18 @@ 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) &&
+                        !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;
+                        if (!hidden) {
+                                instruction->waiting = true;
+                                ++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
@@ -448,7 +424,8 @@ static void transaction_commit(struct sway_transaction *transaction) {
                         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 && node_is_view(node) &&
+                                wl_list_empty(&node->sway_container->view->saved_buffers)) {
                         view_save_buffer(node->sway_container->view);
                         memcpy(&node->sway_container->view->saved_geometry,
                                         &node->sway_container->view->geometry,
@@ -483,6 +460,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,13 +489,14 @@ 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,
@@ -532,36 +521,32 @@ void transaction_notify_view_ready_by_geometry(struct sway_view *view,
         }
 }
 
-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);
 }