1 files changed, 56 insertions, 51 deletions

diff --git a/sway/desktop/transaction.c b/sway/desktop/transaction.c
index d2932c87..2a89880a 100644
--- a/sway/desktop/transaction.c
+++ b/sway/desktop/transaction.c
@@ -4,8 +4,8 @@
 #include <string.h>
 #include <time.h>
 #include <wlr/types/wlr_buffer.h>
-#include <wlr/types/wlr_linux_dmabuf.h>
 #include "sway/debug.h"
+#include "sway/desktop/idle_inhibit_v1.h"
 #include "sway/desktop/transaction.h"
 #include "sway/output.h"
 #include "sway/tree/container.h"
@@ -18,14 +18,14 @@
  * How long we should wait for views to respond to the configure before giving
  * up and applying the transaction anyway.
  */
-#define TIMEOUT_MS 200
+int txn_timeout_ms = 200;
 
 /**
  * If enabled, sway will always wait for the transaction timeout before
  * applying it, rather than applying it when the views are ready. This allows us
  * to observe the rendered state while a transaction is in progress.
  */
-#define TRANSACTION_DEBUG false
+bool txn_debug = false;
 
 struct sway_transaction {
         struct wl_event_source *timer;
@@ -46,7 +46,7 @@ struct sway_transaction_instruction {
         bool ready;
 };
 
-struct sway_transaction *transaction_create() {
+static struct sway_transaction *transaction_create() {
         struct sway_transaction *transaction =
                 calloc(1, sizeof(struct sway_transaction));
         transaction->instructions = create_list();
@@ -72,8 +72,8 @@ static void save_view_buffer(struct sway_view *view,
         }
         if (view->surface && wlr_surface_has_buffer(view->surface)) {
                 instruction->saved_buffer = wlr_buffer_ref(view->surface->buffer);
-                instruction->saved_buffer_width = view->surface->current->width;
-                instruction->saved_buffer_height = view->surface->current->height;
+                instruction->saved_buffer_width = view->surface->current.width;
+                instruction->saved_buffer_height = view->surface->current.height;
         }
 }
 
@@ -138,25 +138,18 @@ static void copy_pending_state(struct sway_container *container,
                 state->children = create_list();
                 list_cat(state->children, container->children);
         }
-}
 
-static bool transaction_has_container(struct sway_transaction *transaction,
-                struct sway_container *container) {
-        for (int i = 0; i < transaction->instructions->length; ++i) {
-                struct sway_transaction_instruction *instruction =
-                        transaction->instructions->items[i];
-                if (instruction->container == container) {
-                        return true;
-                }
+        struct sway_seat *seat = input_manager_current_seat(input_manager);
+        state->focused = seat_get_focus(seat) == container;
+
+        if (container->type != C_VIEW) {
+                state->focused_inactive_child =
+                        seat_get_active_child(seat, container);
         }
-        return false;
 }
 
-void transaction_add_container(struct sway_transaction *transaction,
+static void transaction_add_container(struct sway_transaction *transaction,
                 struct sway_container *container) {
-        if (transaction_has_container(transaction, container)) {
-                return;
-        }
         struct sway_transaction_instruction *instruction =
                 calloc(1, sizeof(struct sway_transaction_instruction));
         instruction->transaction = transaction;
@@ -174,7 +167,7 @@ void transaction_add_container(struct sway_transaction *transaction,
  * Apply a transaction to the "current" state of the tree.
  */
 static void transaction_apply(struct sway_transaction *transaction) {
-        wlr_log(L_DEBUG, "Applying transaction %p", transaction);
+        wlr_log(WLR_DEBUG, "Applying transaction %p", transaction);
         if (server.debug_txn_timings) {
                 struct timespec now;
                 clock_gettime(CLOCK_MONOTONIC, &now);
@@ -185,9 +178,9 @@ static void transaction_apply(struct sway_transaction *transaction) {
                 float ms_waiting = (now.tv_sec - commit->tv_sec) * 1000 +
                         (now.tv_nsec - commit->tv_nsec) / 1000000.0;
                 float ms_total = ms_arranging + ms_waiting;
-                wlr_log(L_DEBUG, "Transaction %p: %.1fms arranging, %.1fms waiting, "
-                                "%.1fms total (%.1f frames if 60Hz)", transaction,
-                                ms_arranging, ms_waiting, ms_total, ms_total / (1000 / 60));
+                wlr_log(WLR_DEBUG, "Transaction %p: %.1fms arranging, %.1fms waiting, "
+                        "%.1fms total (%.1f frames if 60Hz)", transaction,
+                        ms_arranging, ms_waiting, ms_total, ms_total / (1000.0f / 60));
         }
 
         // Apply the instruction state to the container's current state
@@ -209,10 +202,12 @@ static void transaction_apply(struct sway_transaction *transaction) {
                         .width = instruction->state.swayc_width,
                         .height = instruction->state.swayc_height,
                 };
-                for (int j = 0; j < root_container.children->length; ++j) {
-                        struct sway_container *output = root_container.children->items[j];
-                        output_damage_box(output->sway_output, &old_box);
-                        output_damage_box(output->sway_output, &new_box);
+                for (int j = 0; j < root_container.current.children->length; ++j) {
+                        struct sway_container *output = root_container.current.children->items[j];
+                        if (output->sway_output) {
+                                output_damage_box(output->sway_output, &old_box);
+                                output_damage_box(output->sway_output, &new_box);
+                        }
                 }
 
                 // There are separate children lists for each instruction state, the
@@ -227,29 +222,22 @@ static void transaction_apply(struct sway_transaction *transaction) {
         }
 }
 
-/**
- * For simplicity, we only progress the queue if it can be completely flushed.
- */
 static void transaction_progress_queue() {
-        // We iterate this list in reverse because we're more likely to find a
-        // waiting transactions at the end of the list.
-        for (int i = server.transactions->length - 1; i >= 0; --i) {
-                struct sway_transaction *transaction = server.transactions->items[i];
+        while (server.transactions->length) {
+                struct sway_transaction *transaction = server.transactions->items[0];
                 if (transaction->num_waiting) {
                         return;
                 }
-        }
-        for (int i = 0; i < server.transactions->length; ++i) {
-                struct sway_transaction *transaction = server.transactions->items[i];
                 transaction_apply(transaction);
                 transaction_destroy(transaction);
+                list_del(server.transactions, 0);
         }
-        server.transactions->length = 0;
+        idle_inhibit_v1_check_active(server.idle_inhibit_manager_v1);
 }
 
 static int handle_timeout(void *data) {
         struct sway_transaction *transaction = data;
-        wlr_log(L_DEBUG, "Transaction %p timed out (%li waiting)",
+        wlr_log(WLR_DEBUG, "Transaction %p timed out (%li waiting)",
                         transaction, transaction->num_waiting);
         transaction->num_waiting = 0;
         transaction_progress_queue();
@@ -283,8 +271,8 @@ static bool should_configure(struct sway_container *con,
         return true;
 }
 
-void transaction_commit(struct sway_transaction *transaction) {
-        wlr_log(L_DEBUG, "Transaction %p committing with %i instructions",
+static void transaction_commit(struct sway_transaction *transaction) {
+        wlr_log(WLR_DEBUG, "Transaction %p committing with %i instructions",
                         transaction, transaction->instructions->length);
         transaction->num_waiting = 0;
         for (int i = 0; i < transaction->instructions->length; ++i) {
@@ -317,9 +305,10 @@ void transaction_commit(struct sway_transaction *transaction) {
         } else {
                 // There are no other transactions in progress, and this one has nothing
                 // to wait for, so we can skip the queue.
-                wlr_log(L_DEBUG, "Transaction %p has nothing to wait for", transaction);
+                wlr_log(WLR_DEBUG, "Transaction %p has nothing to wait for", transaction);
                 transaction_apply(transaction);
                 transaction_destroy(transaction);
+                idle_inhibit_v1_check_active(server.idle_inhibit_manager_v1);
                 return;
         }
 
@@ -327,7 +316,7 @@ void transaction_commit(struct sway_transaction *transaction) {
                 // Set up a timer which the views must respond within
                 transaction->timer = wl_event_loop_add_timer(server.wl_event_loop,
                                 handle_timeout, transaction);
-                wl_event_source_timer_update(transaction->timer, TIMEOUT_MS);
+                wl_event_source_timer_update(transaction->timer, txn_timeout_ms);
         }
 
         // The debug tree shows the pending/live tree. Here is a good place to
@@ -347,7 +336,7 @@ static void set_instruction_ready(
                 struct timespec *start = &transaction->commit_time;
                 float ms = (now.tv_sec - start->tv_sec) * 1000 +
                         (now.tv_nsec - start->tv_nsec) / 1000000.0;
-                wlr_log(L_DEBUG, "Transaction %p: %li/%li ready in %.1fms (%s)",
+                wlr_log(WLR_DEBUG, "Transaction %p: %li/%li ready in %.1fms (%s)",
                                 transaction,
                                 transaction->num_configures - transaction->num_waiting + 1,
                                 transaction->num_configures, ms,
@@ -358,11 +347,11 @@ static void set_instruction_ready(
         // If all views are ready, apply the transaction.
         // If the transaction has timed out then its num_waiting will be 0 already.
         if (transaction->num_waiting > 0 && --transaction->num_waiting == 0) {
-#if !TRANSACTION_DEBUG
-                wlr_log(L_DEBUG, "Transaction %p is ready", transaction);
-                wl_event_source_timer_update(transaction->timer, 0);
-                transaction_progress_queue();
-#endif
+                if (!txn_debug) {
+                        wlr_log(WLR_DEBUG, "Transaction %p is ready", transaction);
+                        wl_event_source_timer_update(transaction->timer, 0);
+                        transaction_progress_queue();
+                }
         }
 }
 
@@ -374,7 +363,9 @@ static void set_instructions_ready(struct sway_view *view, int index) {
         for (int i = 0; i <= index; ++i) {
                 struct sway_transaction_instruction *instruction =
                         view->swayc->instructions->items[i];
-                set_instruction_ready(instruction);
+                if (!instruction->ready) {
+                        set_instruction_ready(instruction);
+                }
         }
 }
 
@@ -413,3 +404,17 @@ struct wlr_texture *transaction_get_saved_texture(struct sway_view *view,
         *height = instruction->saved_buffer_height;
         return instruction->saved_buffer->texture;
 }
+
+void transaction_commit_dirty(void) {
+        if (!server.dirty_containers->length) {
+                return;
+        }
+        struct sway_transaction *transaction = transaction_create();
+        for (int i = 0; i < server.dirty_containers->length; ++i) {
+                struct sway_container *container = server.dirty_containers->items[i];
+                transaction_add_container(transaction, container);
+                container->dirty = false;
+        }
+        server.dirty_containers->length = 0;
+        transaction_commit(transaction);
+}