WIP: Atomic layout updates ground work

1 files changed, 214 insertions, 0 deletions

diff --git a/sway/desktop/transaction.c b/sway/desktop/transaction.c
new file mode 100644
index 00000000..69f97e3d
--- /dev/null
+++ b/sway/desktop/transaction.c
@@ -0,0 +1,214 @@
+#define _POSIX_C_SOURCE 200809L
+#include <stdbool.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wlr/types/wlr_linux_dmabuf.h>
+#include "sway/debug.h"
+#include "sway/desktop/transaction.h"
+#include "sway/output.h"
+#include "sway/tree/container.h"
+#include "sway/tree/view.h"
+#include "list.h"
+#include "log.h"
+
+/**
+ * How long we should wait for views to respond to the configure before giving
+ * up and applying the transaction anyway.
+ */
+#define TIMEOUT_MS 200
+
+struct sway_transaction_instruction {
+        struct sway_transaction *transaction;
+        struct sway_container *container;
+        struct sway_container_state state;
+        uint32_t serial;
+};
+
+struct sway_transaction *transaction_create() {
+        struct sway_transaction *transaction =
+                calloc(1, sizeof(struct sway_transaction));
+        transaction->instructions = create_list();
+        transaction->damage = create_list();
+        return transaction;
+}
+
+static void transaction_destroy(struct sway_transaction *transaction) {
+        int i;
+        // Free instructions
+        for (i = 0; i < transaction->instructions->length; ++i) {
+                struct sway_transaction_instruction *instruction =
+                        transaction->instructions->items[i];
+                if (instruction->container->type == C_VIEW) {
+                        struct sway_view *view = instruction->container->sway_view;
+                        for (int j = 0; j < view->instructions->length; ++j) {
+                                if (view->instructions->items[j] == instruction) {
+                                        list_del(view->instructions, j);
+                                        break;
+                                }
+                        }
+                }
+                free(instruction);
+        }
+        list_free(transaction->instructions);
+
+        // Free damage
+        for (i = 0; i < transaction->damage->length; ++i) {
+                struct wlr_box *box = transaction->damage->items[i];
+                free(box);
+        }
+        list_free(transaction->damage);
+
+        free(transaction);
+}
+
+void transaction_add_container(struct sway_transaction *transaction,
+                struct sway_container *container) {
+        struct sway_transaction_instruction *instruction =
+                calloc(1, sizeof(struct sway_transaction_instruction));
+        instruction->transaction = transaction;
+        instruction->container = container;
+        memcpy(&instruction->state, &container->pending,
+                        sizeof(struct sway_container_state));
+        list_add(transaction->instructions, instruction);
+}
+
+void transaction_add_damage(struct sway_transaction *transaction,
+                struct wlr_box *_box) {
+        struct wlr_box *box = calloc(1, sizeof(struct wlr_box));
+        memcpy(box, _box, sizeof(struct wlr_box));
+        list_add(transaction->damage, box);
+}
+
+static void save_view_texture(struct sway_view *view) {
+        wlr_texture_destroy(view->saved_texture);
+        view->saved_texture = NULL;
+
+        // TODO: Copy the texture and store it in view->saved_texture.
+}
+
+static void remove_saved_view_texture(struct sway_view *view) {
+        wlr_texture_destroy(view->saved_texture);
+        view->saved_texture = NULL;
+}
+
+/**
+ * Apply a transaction to the "current" state of the tree.
+ *
+ * This is mostly copying stuff from the pending state into the main swayc
+ * properties, but also includes reparenting and deleting containers.
+ */
+static void transaction_apply(struct sway_transaction *transaction) {
+        int i;
+        for (i = 0; i < transaction->instructions->length; ++i) {
+                struct sway_transaction_instruction *instruction =
+                        transaction->instructions->items[i];
+                struct sway_container_state *state = &instruction->state;
+                struct sway_container *container = instruction->container;
+
+                container->layout = state->layout;
+                container->x = state->swayc_x;
+                container->y = state->swayc_y;
+                container->width = state->swayc_width;
+                container->height = state->swayc_height;
+
+                if (container->type == C_VIEW) {
+                        struct sway_view *view = container->sway_view;
+                        view->x = state->view_x;
+                        view->y = state->view_y;
+                        view->width = state->view_width;
+                        view->height = state->view_height;
+                        view->is_fullscreen = state->is_fullscreen;
+                        view->border = state->border;
+                        view->border_thickness = state->border_thickness;
+                        view->border_top = state->border_top;
+                        view->border_left = state->border_left;
+                        view->border_right = state->border_right;
+                        view->border_bottom = state->border_bottom;
+
+                        remove_saved_view_texture(view);
+                }
+        }
+
+        // Damage
+        for (i = 0; i < transaction->damage->length; ++i) {
+                struct wlr_box *box = transaction->damage->items[i];
+                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, box);
+                }
+        }
+
+        update_debug_tree();
+}
+
+static int handle_timeout(void *data) {
+        struct sway_transaction *transaction = data;
+        wlr_log(L_DEBUG, "Transaction %p timed out (%li waiting), applying anyway",
+                        transaction, transaction->num_waiting);
+        transaction_apply(transaction);
+        transaction_destroy(transaction);
+        return 0;
+}
+
+void transaction_commit(struct sway_transaction *transaction) {
+        wlr_log(L_DEBUG, "Transaction %p committing with %i instructions",
+                        transaction, transaction->instructions->length);
+        transaction->num_waiting = 0;
+        for (int i = 0; i < transaction->instructions->length; ++i) {
+                struct sway_transaction_instruction *instruction =
+                        transaction->instructions->items[i];
+                if (instruction->container->type == C_VIEW) {
+                        struct sway_view *view = instruction->container->sway_view;
+                        instruction->serial = view_configure(view,
+                                        instruction->state.view_x,
+                                        instruction->state.view_y,
+                                        instruction->state.view_width,
+                                        instruction->state.view_height);
+                        if (instruction->serial) {
+                                save_view_texture(view);
+                                list_add(view->instructions, instruction);
+                                ++transaction->num_waiting;
+                        }
+                }
+        }
+        if (!transaction->num_waiting) {
+                // This can happen if the transaction only contains xwayland views
+                wlr_log(L_DEBUG, "Transaction %p has nothing to wait for, applying",
+                                transaction);
+                transaction_apply(transaction);
+                transaction_destroy(transaction);
+                return;
+        }
+
+        // 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);
+}
+
+void transaction_notify_view_ready(struct sway_view *view, uint32_t serial) {
+        // Find the instruction
+        struct sway_transaction_instruction *instruction = NULL;
+        for (int i = 0; i < view->instructions->length; ++i) {
+                struct sway_transaction_instruction *tmp_instruction =
+                        view->instructions->items[i];
+                if (tmp_instruction->serial == serial) {
+                        instruction = tmp_instruction;
+                        list_del(view->instructions, i);
+                        break;
+                }
+        }
+        if (!instruction) {
+                // This can happen if the view acknowledges the configure after the
+                // transaction has timed out and applied.
+                return;
+        }
+        // If all views are ready, apply the transaction
+        struct sway_transaction *transaction = instruction->transaction;
+        if (--transaction->num_waiting == 0) {
+                wlr_log(L_DEBUG, "Transaction %p is ready, applying", transaction);
+                wl_event_source_timer_update(transaction->timer, 0);
+                transaction_apply(transaction);
+                transaction_destroy(transaction);
+        }
+}