1 files changed, 88 insertions, 200 deletions

diff --git a/sway/tree/root.c b/sway/tree/root.c
index ebd185ec..ae3c3cb2 100644
--- a/sway/tree/root.c
+++ b/sway/tree/root.c
@@ -1,12 +1,14 @@
-#define _POSIX_C_SOURCE 200809L
 #include <stdbool.h>
 #include <stdlib.h>
 #include <string.h>
 #include <wlr/types/wlr_output_layout.h>
+#include <wlr/types/wlr_scene.h>
+#include <wlr/util/transform.h>
 #include "sway/desktop/transaction.h"
 #include "sway/input/seat.h"
 #include "sway/ipc-server.h"
 #include "sway/output.h"
+#include "sway/scene_descriptor.h"
 #include "sway/tree/arrange.h"
 #include "sway/tree/container.h"
 #include "sway/tree/root.h"
@@ -23,21 +25,60 @@ static void output_layout_handle_change(struct wl_listener *listener,
         transaction_commit_dirty();
 }
 
-struct sway_root *root_create(void) {
+struct sway_root *root_create(struct wl_display *wl_display) {
         struct sway_root *root = calloc(1, sizeof(struct sway_root));
         if (!root) {
                 sway_log(SWAY_ERROR, "Unable to allocate sway_root");
                 return NULL;
         }
+
+        struct wlr_scene *root_scene = wlr_scene_create();
+        if (!root_scene) {
+                sway_log(SWAY_ERROR, "Unable to allocate root scene node");
+                free(root);
+                return NULL;
+        }
+
         node_init(&root->node, N_ROOT, root);
-        root->output_layout = wlr_output_layout_create();
-        wl_list_init(&root->all_outputs);
+        root->root_scene = root_scene;
+
+        bool failed = false;
+        root->staging = alloc_scene_tree(&root_scene->tree, &failed);
+        root->layer_tree = alloc_scene_tree(&root_scene->tree, &failed);
+
+        root->layers.shell_background = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.shell_bottom = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.tiling = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.floating = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.shell_top = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.fullscreen = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.fullscreen_global = alloc_scene_tree(root->layer_tree, &failed);
 #if HAVE_XWAYLAND
-        wl_list_init(&root->xwayland_unmanaged);
+        root->layers.unmanaged = alloc_scene_tree(root->layer_tree, &failed);
 #endif
-        wl_list_init(&root->drag_icons);
+        root->layers.shell_overlay = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.popup = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.seat = alloc_scene_tree(root->layer_tree, &failed);
+        root->layers.session_lock = alloc_scene_tree(root->layer_tree, &failed);
+
+        if (!failed && !scene_descriptor_assign(&root->layers.seat->node,
+                        SWAY_SCENE_DESC_NON_INTERACTIVE, (void *)1)) {
+                failed = true;
+        }
+
+        if (failed) {
+                wlr_scene_node_destroy(&root_scene->tree.node);
+                free(root);
+                return NULL;
+        }
+
+        wlr_scene_node_set_enabled(&root->staging->node, false);
+
+        root->output_layout = wlr_output_layout_create(wl_display);
+        wl_list_init(&root->all_outputs);
         wl_signal_init(&root->events.new_node);
         root->outputs = create_list();
+        root->non_desktop_outputs = create_list();
         root->scratchpad = create_list();
 
         root->output_layout_change.notify = output_layout_handle_change;
@@ -49,21 +90,34 @@ struct sway_root *root_create(void) {
 void root_destroy(struct sway_root *root) {
         wl_list_remove(&root->output_layout_change.link);
         list_free(root->scratchpad);
+        list_free(root->non_desktop_outputs);
         list_free(root->outputs);
-        wlr_output_layout_destroy(root->output_layout);
+        wlr_scene_node_destroy(&root->root_scene->tree.node);
         free(root);
 }
 
+static void set_container_transform(struct sway_workspace *ws,
+                        struct sway_container *con) {
+        struct sway_output *output = ws->output;
+        struct wlr_box box = {0};
+        if (output) {
+                output_get_box(output, &box);
+        }
+        con->transform = box;
+}
+
 void root_scratchpad_add_container(struct sway_container *con, struct sway_workspace *ws) {
         if (!sway_assert(!con->scratchpad, "Container is already in scratchpad")) {
                 return;
         }
 
-        struct sway_container *parent = con->parent;
-        struct sway_workspace *workspace = con->workspace;
+        struct sway_container *parent = con->pending.parent;
+        struct sway_workspace *workspace = con->pending.workspace;
+
+        set_container_transform(workspace, con);
 
         // Clear the fullscreen mode when sending to the scratchpad
-        if (con->fullscreen_mode != FULLSCREEN_NONE) {
+        if (con->pending.fullscreen_mode != FULLSCREEN_NONE) {
                 container_fullscreen_disable(con);
         }
 
@@ -117,7 +171,7 @@ void root_scratchpad_show(struct sway_container *con) {
                 sway_log(SWAY_DEBUG, "No focused workspace to show scratchpad on");
                 return;
         }
-        struct sway_workspace *old_ws = con->workspace;
+        struct sway_workspace *old_ws = con->pending.workspace;
 
         // If the current con or any of its parents are in fullscreen mode, we
         // first need to disable it before showing the scratchpad con.
@@ -131,31 +185,34 @@ void root_scratchpad_show(struct sway_container *con) {
         // Show the container
         if (old_ws) {
                 container_detach(con);
-                workspace_consider_destroy(old_ws);
+                // Make sure the last inactive container on the old workspace is above
+                // the workspace itself in the focus stack.
+                struct sway_node *node = seat_get_focus_inactive(seat, &old_ws->node);
+                seat_set_raw_focus(seat, node);
         } else {
                 // Act on the ancestor of scratchpad hidden split containers
-                while (con->parent) {
-                        con = con->parent;
+                while (con->pending.parent) {
+                        con = con->pending.parent;
                 }
         }
         workspace_add_floating(new_ws, con);
 
-        // Make sure the container's center point overlaps this workspace
-        double center_lx = con->x + con->width / 2;
-        double center_ly = con->y + con->height / 2;
-
-        struct wlr_box workspace_box;
-        workspace_get_box(new_ws, &workspace_box);
-        if (!wlr_box_contains_point(&workspace_box, center_lx, center_ly)) {
-                container_floating_resize_and_center(con);
+        if (new_ws->output) {
+                struct wlr_box output_box;
+                output_get_box(new_ws->output, &output_box);
+                floating_fix_coordinates(con, &con->transform, &output_box);
         }
+        set_container_transform(new_ws, con);
 
         arrange_workspace(new_ws);
         seat_set_focus(seat, seat_get_focus_inactive(seat, &con->node));
+        if (old_ws) {
+                workspace_consider_destroy(old_ws);
+        }
 }
 
 static void disable_fullscreen(struct sway_container *con, void *data) {
-        if (con->fullscreen_mode != FULLSCREEN_NONE) {
+        if (con->pending.fullscreen_mode != FULLSCREEN_NONE) {
                 container_fullscreen_disable(con);
         }
 }
@@ -163,14 +220,16 @@ static void disable_fullscreen(struct sway_container *con, void *data) {
 void root_scratchpad_hide(struct sway_container *con) {
         struct sway_seat *seat = input_manager_current_seat();
         struct sway_node *focus = seat_get_focus_inactive(seat, &root->node);
-        struct sway_workspace *ws = con->workspace;
+        struct sway_workspace *ws = con->pending.workspace;
 
-        if (con->fullscreen_mode == FULLSCREEN_GLOBAL && !con->workspace) {
+        if (con->pending.fullscreen_mode == FULLSCREEN_GLOBAL && !con->pending.workspace) {
                 // If the container was made fullscreen global while in the scratchpad,
                 // it should be shown until fullscreen has been disabled
                 return;
         }
 
+        set_container_transform(con->pending.workspace, con);
+
         disable_fullscreen(con, NULL);
         container_for_each_child(con, disable_fullscreen, NULL);
         container_detach(con);
@@ -183,163 +242,6 @@ void root_scratchpad_hide(struct sway_container *con) {
         ipc_event_window(con, "move");
 }
 
-struct pid_workspace {
-        pid_t pid;
-        char *workspace;
-        struct timespec time_added;
-
-        struct sway_output *output;
-        struct wl_listener output_destroy;
-
-        struct wl_list link;
-};
-
-static struct wl_list pid_workspaces;
-
-/**
- * Get the pid of a parent process given the pid of a child process.
- *
- * Returns the parent pid or NULL if the parent pid cannot be determined.
- */
-static pid_t get_parent_pid(pid_t child) {
-        pid_t parent = -1;
-        char file_name[100];
-        char *buffer = NULL;
-        const char *sep = " ";
-        FILE *stat = NULL;
-        size_t buf_size = 0;
-
-        sprintf(file_name, "/proc/%d/stat", child);
-
-        if ((stat = fopen(file_name, "r"))) {
-                if (getline(&buffer, &buf_size, stat) != -1) {
-                        strtok(buffer, sep); // pid
-                        strtok(NULL, sep);   // executable name
-                        strtok(NULL, sep);   // state
-                        char *token = strtok(NULL, sep);   // parent pid
-                        parent = strtol(token, NULL, 10);
-                }
-                free(buffer);
-                fclose(stat);
-        }
-
-        if (parent) {
-                return (parent == child) ? -1 : parent;
-        }
-
-        return -1;
-}
-
-static void pid_workspace_destroy(struct pid_workspace *pw) {
-        wl_list_remove(&pw->output_destroy.link);
-        wl_list_remove(&pw->link);
-        free(pw->workspace);
-        free(pw);
-}
-
-struct sway_workspace *root_workspace_for_pid(pid_t pid) {
-        if (!pid_workspaces.prev && !pid_workspaces.next) {
-                wl_list_init(&pid_workspaces);
-                return NULL;
-        }
-
-        struct sway_workspace *ws = NULL;
-        struct pid_workspace *pw = NULL;
-
-        sway_log(SWAY_DEBUG, "Looking up workspace for pid %d", pid);
-
-        do {
-                struct pid_workspace *_pw = NULL;
-                wl_list_for_each(_pw, &pid_workspaces, link) {
-                        if (pid == _pw->pid) {
-                                pw = _pw;
-                                sway_log(SWAY_DEBUG,
-                                                "found pid_workspace for pid %d, workspace %s",
-                                                pid, pw->workspace);
-                                goto found;
-                        }
-                }
-                pid = get_parent_pid(pid);
-        } while (pid > 1);
-found:
-
-        if (pw && pw->workspace) {
-                ws = workspace_by_name(pw->workspace);
-
-                if (!ws) {
-                        sway_log(SWAY_DEBUG,
-                                        "Creating workspace %s for pid %d because it disappeared",
-                                        pw->workspace, pid);
-                        ws = workspace_create(pw->output, pw->workspace);
-                }
-
-                pid_workspace_destroy(pw);
-        }
-
-        return ws;
-}
-
-static void pw_handle_output_destroy(struct wl_listener *listener, void *data) {
-        struct pid_workspace *pw = wl_container_of(listener, pw, output_destroy);
-        pw->output = NULL;
-        wl_list_remove(&pw->output_destroy.link);
-        wl_list_init(&pw->output_destroy.link);
-}
-
-void root_record_workspace_pid(pid_t pid) {
-        sway_log(SWAY_DEBUG, "Recording workspace for process %d", pid);
-        if (!pid_workspaces.prev && !pid_workspaces.next) {
-                wl_list_init(&pid_workspaces);
-        }
-
-        struct sway_seat *seat = input_manager_current_seat();
-        struct sway_workspace *ws = seat_get_focused_workspace(seat);
-        if (!ws) {
-                sway_log(SWAY_DEBUG, "Bailing out, no workspace");
-                return;
-        }
-        struct sway_output *output = ws->output;
-        if (!output) {
-                sway_log(SWAY_DEBUG, "Bailing out, no output");
-                return;
-        }
-
-        struct timespec now;
-        clock_gettime(CLOCK_MONOTONIC, &now);
-
-        // Remove expired entries
-        static const int timeout = 60;
-        struct pid_workspace *old, *_old;
-        wl_list_for_each_safe(old, _old, &pid_workspaces, link) {
-                if (now.tv_sec - old->time_added.tv_sec >= timeout) {
-                        pid_workspace_destroy(old);
-                }
-        }
-
-        struct pid_workspace *pw = calloc(1, sizeof(struct pid_workspace));
-        pw->workspace = strdup(ws->name);
-        pw->output = output;
-        pw->pid = pid;
-        memcpy(&pw->time_added, &now, sizeof(struct timespec));
-        pw->output_destroy.notify = pw_handle_output_destroy;
-        wl_signal_add(&output->wlr_output->events.destroy, &pw->output_destroy);
-        wl_list_insert(&pid_workspaces, &pw->link);
-}
-
-void root_remove_workspace_pid(pid_t pid) {
-        if (!pid_workspaces.prev || !pid_workspaces.next) {
-                return;
-        }
-
-        struct pid_workspace *pw, *tmp;
-        wl_list_for_each_safe(pw, tmp, &pid_workspaces, link) {
-                if (pid == pw->pid) {
-                        pid_workspace_destroy(pw);
-                        return;
-                }
-        }
-}
-
 void root_for_each_workspace(void (*f)(struct sway_workspace *ws, void *data),
                 void *data) {
         for (int i = 0; i < root->outputs->length; ++i) {
@@ -365,8 +267,8 @@ void root_for_each_container(void (*f)(struct sway_container *con, void *data),
         }
 
         // Saved workspaces
-        for (int i = 0; i < root->noop_output->workspaces->length; ++i) {
-                struct sway_workspace *ws = root->noop_output->workspaces->items[i];
+        for (int i = 0; i < root->fallback_output->workspaces->length; ++i) {
+                struct sway_workspace *ws = root->fallback_output->workspaces->items[i];
                 workspace_for_each_container(ws, f, data);
         }
 }
@@ -418,8 +320,8 @@ struct sway_container *root_find_container(
         }
 
         // Saved workspaces
-        for (int i = 0; i < root->noop_output->workspaces->length; ++i) {
-                struct sway_workspace *ws = root->noop_output->workspaces->items[i];
+        for (int i = 0; i < root->fallback_output->workspaces->length; ++i) {
+                struct sway_workspace *ws = root->fallback_output->workspaces->items[i];
                 if ((result = workspace_find_container(ws, test, data))) {
                         return result;
                 }
@@ -434,17 +336,3 @@ void root_get_box(struct sway_root *root, struct wlr_box *box) {
         box->width = root->width;
         box->height = root->height;
 }
-
-void root_rename_pid_workspaces(const char *old_name, const char *new_name) {
-        if (!pid_workspaces.prev && !pid_workspaces.next) {
-                wl_list_init(&pid_workspaces);
-        }
-
-        struct pid_workspace *pw = NULL;
-        wl_list_for_each(pw, &pid_workspaces, link) {
-                if (strcmp(pw->workspace, old_name) == 0) {
-                        free(pw->workspace);
-                        pw->workspace = strdup(new_name);
-                }
-        }
-}