1 files changed, 91 insertions, 40 deletions

diff --git a/sway/tree/output.c b/sway/tree/output.c
index a8ae30f7..2d11195e 100644
--- a/sway/tree/output.c
+++ b/sway/tree/output.c
@@ -1,14 +1,13 @@
-#define _POSIX_C_SOURCE 200809L
 #include <assert.h>
 #include <ctype.h>
 #include <string.h>
 #include <strings.h>
-#include <wlr/types/wlr_output_damage.h>
 #include "sway/ipc-server.h"
 #include "sway/layers.h"
 #include "sway/output.h"
 #include "sway/tree/arrange.h"
 #include "sway/tree/workspace.h"
+#include "sway/server.h"
 #include "log.h"
 #include "util.h"
 
@@ -56,8 +55,8 @@ static void restore_workspaces(struct sway_output *output) {
         }
 
         // Saved workspaces
-        while (root->noop_output->workspaces->length) {
-                struct sway_workspace *ws = root->noop_output->workspaces->items[0];
+        while (root->fallback_output->workspaces->length) {
+                struct sway_workspace *ws = root->fallback_output->workspaces->items[0];
                 workspace_detach(ws);
                 output_add_workspace(output, ws);
 
@@ -70,13 +69,13 @@ static void restore_workspaces(struct sway_output *output) {
                 // floater re-centered
                 for (int i = 0; i < ws->floating->length; i++) {
                         struct sway_container *floater = ws->floating->items[i];
-                        if (floater->width == 0 || floater->height == 0 ||
-                                        floater->width > output->width ||
-                                        floater->height > output->height ||
-                                        floater->x > output->lx + output->width ||
-                                        floater->y > output->ly + output->height ||
-                                        floater->x + floater->width < output->lx ||
-                                        floater->y + floater->height < output->ly) {
+                        if (floater->pending.width == 0 || floater->pending.height == 0 ||
+                                        floater->pending.width > output->width ||
+                                        floater->pending.height > output->height ||
+                                        floater->pending.x > output->lx + output->width ||
+                                        floater->pending.y > output->ly + output->height ||
+                                        floater->pending.x + floater->pending.width < output->lx ||
+                                        floater->pending.y + floater->pending.height < output->ly) {
                                 container_floating_resize_and_center(floater);
                         }
                 }
@@ -87,26 +86,63 @@ static void restore_workspaces(struct sway_output *output) {
         output_sort_workspaces(output);
 }
 
+static void destroy_scene_layers(struct sway_output *output) {
+        wlr_scene_node_destroy(&output->fullscreen_background->node);
+
+        scene_node_disown_children(output->layers.tiling);
+        scene_node_disown_children(output->layers.fullscreen);
+
+        wlr_scene_node_destroy(&output->layers.shell_background->node);
+        wlr_scene_node_destroy(&output->layers.shell_bottom->node);
+        wlr_scene_node_destroy(&output->layers.tiling->node);
+        wlr_scene_node_destroy(&output->layers.fullscreen->node);
+        wlr_scene_node_destroy(&output->layers.shell_top->node);
+        wlr_scene_node_destroy(&output->layers.shell_overlay->node);
+        wlr_scene_node_destroy(&output->layers.session_lock->node);
+}
+
 struct sway_output *output_create(struct wlr_output *wlr_output) {
         struct sway_output *output = calloc(1, sizeof(struct sway_output));
         node_init(&output->node, N_OUTPUT, output);
+
+        bool failed = false;
+        output->layers.shell_background = alloc_scene_tree(root->staging, &failed);
+        output->layers.shell_bottom = alloc_scene_tree(root->staging, &failed);
+        output->layers.tiling = alloc_scene_tree(root->staging, &failed);
+        output->layers.fullscreen = alloc_scene_tree(root->staging, &failed);
+        output->layers.shell_top = alloc_scene_tree(root->staging, &failed);
+        output->layers.shell_overlay = alloc_scene_tree(root->staging, &failed);
+        output->layers.session_lock = alloc_scene_tree(root->staging, &failed);
+
+        if (!failed) {
+                output->fullscreen_background = wlr_scene_rect_create(
+                        output->layers.fullscreen, 0, 0, (float[4]){0.f, 0.f, 0.f, 1.f});
+
+                if (!output->fullscreen_background) {
+                        sway_log(SWAY_ERROR, "Unable to allocate a background rect");
+                        failed = true;
+                }
+        }
+
+        if (failed) {
+                destroy_scene_layers(output);
+                wlr_scene_output_destroy(output->scene_output);
+                free(output);
+                return NULL;
+        }
+
         output->wlr_output = wlr_output;
         wlr_output->data = output;
         output->detected_subpixel = wlr_output->subpixel;
         output->scale_filter = SCALE_FILTER_NEAREST;
 
-        wl_signal_init(&output->events.destroy);
+        wl_signal_init(&output->events.disable);
 
         wl_list_insert(&root->all_outputs, &output->link);
 
         output->workspaces = create_list();
         output->current.workspaces = create_list();
 
-        size_t len = sizeof(output->layers) / sizeof(output->layers[0]);
-        for (size_t i = 0; i < len; ++i) {
-                wl_list_init(&output->layers[i]);
-        }
-
         return output;
 }
 
@@ -146,7 +182,7 @@ void output_enable(struct sway_output *output) {
 
         input_manager_configure_xcursor();
 
-        wl_signal_emit(&root->events.new_node, &output->node);
+        wl_signal_emit_mutable(&root->events.new_node, &output->node);
 
         arrange_layers(output);
         arrange_root();
@@ -192,7 +228,7 @@ static void output_evacuate(struct sway_output *output) {
                         new_output = fallback_output;
                 }
                 if (!new_output) {
-                        new_output = root->noop_output;
+                        new_output = root->fallback_output;
                 }
 
                 struct sway_workspace *new_output_ws =
@@ -238,20 +274,14 @@ void output_destroy(struct sway_output *output) {
                                 "which is still referenced by transactions")) {
                 return;
         }
+
+        destroy_scene_layers(output);
         list_free(output->workspaces);
         list_free(output->current.workspaces);
         wl_event_source_remove(output->repaint_timer);
         free(output);
 }
 
-static void untrack_output(struct sway_container *con, void *data) {
-        struct sway_output *output = data;
-        int index = list_find(con->outputs, output);
-        if (index != -1) {
-                list_del(con->outputs, index);
-        }
-}
-
 void output_disable(struct sway_output *output) {
         if (!sway_assert(output->enabled, "Expected an enabled output")) {
                 return;
@@ -262,23 +292,20 @@ void output_disable(struct sway_output *output) {
         }
 
         sway_log(SWAY_DEBUG, "Disabling output '%s'", output->wlr_output->name);
-        wl_signal_emit(&output->events.destroy, output);
+        wl_signal_emit_mutable(&output->events.disable, output);
 
         output_evacuate(output);
 
-        root_for_each_container(untrack_output, output);
-
         list_del(root->outputs, index);
 
         output->enabled = false;
-        output->current_mode = NULL;
 
         arrange_root();
 
         // Reconfigure all devices, since devices with map_to_output directives for
         // an output that goes offline should stop sending events as long as the
         // output remains offline.
-        input_manager_configure_all_inputs();
+        input_manager_configure_all_input_mappings();
 }
 
 void output_begin_destroy(struct sway_output *output) {
@@ -286,13 +313,10 @@ void output_begin_destroy(struct sway_output *output) {
                 return;
         }
         sway_log(SWAY_DEBUG, "Destroying output '%s'", output->wlr_output->name);
+        wl_signal_emit_mutable(&output->node.events.destroy, &output->node);
 
         output->node.destroying = true;
         node_set_dirty(&output->node);
-
-        wl_list_remove(&output->link);
-        output->wlr_output->data = NULL;
-        output->wlr_output = NULL;
 }
 
 struct sway_output *output_from_wlr_output(struct wlr_output *output) {
@@ -304,10 +328,10 @@ struct sway_output *output_get_in_direction(struct sway_output *reference,
         if (!sway_assert(direction, "got invalid direction: %d", direction)) {
                 return NULL;
         }
-        struct wlr_box *output_box =
-                wlr_output_layout_get_box(root->output_layout, reference->wlr_output);
-        int lx = output_box->x + output_box->width / 2;
-        int ly = output_box->y + output_box->height / 2;
+        struct wlr_box output_box;
+        wlr_output_layout_get_box(root->output_layout, reference->wlr_output, &output_box);
+        int lx = output_box.x + output_box.width / 2;
+        int ly = output_box.y + output_box.height / 2;
         struct wlr_output *wlr_adjacent = wlr_output_layout_adjacent_output(
                         root->output_layout, direction, reference->wlr_output, lx, ly);
         if (!wlr_adjacent) {
@@ -393,6 +417,33 @@ void output_get_box(struct sway_output *output, struct wlr_box *box) {
         box->height = output->height;
 }
 
+static void handle_destroy_non_desktop(struct wl_listener *listener, void *data) {
+        struct sway_output_non_desktop *output =
+                wl_container_of(listener, output, destroy);
+
+        sway_log(SWAY_DEBUG, "Destroying non-desktop output '%s'", output->wlr_output->name);
+
+        int index = list_find(root->non_desktop_outputs, output);
+        list_del(root->non_desktop_outputs, index);
+
+        wl_list_remove(&output->destroy.link);
+
+        free(output);
+}
+
+struct sway_output_non_desktop *output_non_desktop_create(
+                struct wlr_output *wlr_output) {
+        struct sway_output_non_desktop *output =
+                calloc(1, sizeof(struct sway_output_non_desktop));
+
+        output->wlr_output = wlr_output;
+
+        wl_signal_add(&wlr_output->events.destroy, &output->destroy);
+        output->destroy.notify = handle_destroy_non_desktop;
+
+        return output;
+}
+
 enum sway_container_layout output_get_default_layout(
                 struct sway_output *output) {
         if (config->default_orientation != L_NONE) {