mirrors
/
sway
mirror of https://github.com/swaywm/sway.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

scene_graph: Port ext_session_v1

This commit is contained in:
Alexander Orzechowski 2024-01-18 10:04:26 -05:00 committed by Kirill Primak
parent 0639bde9fb
commit 9a57966606
12 changed files with 280 additions and 192 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
include/sway/output.h
View File

@ -24,6 +24,7 @@ struct sway_output {
struct {
struct wlr_scene_tree *tiling;
struct wlr_scene_tree *fullscreen;
struct wlr_scene_tree *session_lock;
} layers;
// when a container is fullscreen, in case the fullscreen surface is

25
include/sway/server.h
View File

@ -28,6 +28,19 @@
struct sway_transaction;
struct sway_session_lock {
struct wlr_session_lock_v1 *lock;
struct wlr_surface *focused;
bool abandoned;
struct wl_list outputs; // struct sway_session_lock_output
// invalid if the session is abandoned
struct wl_listener new_surface;
struct wl_listener unlock;
struct wl_listener destroy;
};
struct sway_server {
struct wl_display *wl_display;
struct wl_event_loop *wl_event_loop;
@ -92,15 +105,9 @@ struct sway_server {
struct wl_listener gamma_control_set_gamma;
struct {
bool locked;
struct sway_session_lock *lock;
struct wlr_session_lock_manager_v1 *manager;
struct wlr_session_lock_v1 *lock;
struct wlr_surface *focused;
struct wl_listener lock_new_surface;
struct wl_listener lock_unlock;
struct wl_listener lock_destroy;
struct wl_listener new_lock;
struct wl_listener manager_destroy;
} session_lock;
@ -174,6 +181,10 @@ void handle_new_output(struct wl_listener *listener, void *data);
void handle_idle_inhibitor_v1(struct wl_listener *listener, void *data);
void handle_layer_shell_surface(struct wl_listener *listener, void *data);
void sway_session_lock_init(void);
void sway_session_lock_add_output(struct sway_session_lock *lock,
struct sway_output *output);
bool sway_session_lock_has_surface(struct sway_session_lock *lock,
struct wlr_surface *surface);
void handle_xdg_shell_toplevel(struct wl_listener *listener, void *data);
#if HAVE_XWAYLAND
void handle_xwayland_surface(struct wl_listener *listener, void *data);

1
include/sway/tree/root.h
View File

@ -41,6 +41,7 @@ struct sway_root {
struct wlr_scene_tree *fullscreen;
struct wlr_scene_tree *fullscreen_global;
struct wlr_scene_tree *seat;
struct wlr_scene_tree *session_lock;
} layers;
#if HAVE_XWAYLAND

4
sway/desktop/output.c
View File

@ -798,6 +798,10 @@ void handle_new_output(struct wl_listener *listener, void *data) {
output->repaint_timer = wl_event_loop_add_timer(server->wl_event_loop,
output_repaint_timer_handler, output);
if (server->session_lock.lock) {
sway_session_lock_add_output(server->session_lock.lock, output);
}
struct output_config *oc = find_output_config(output);
apply_output_config(oc, output);
free_output_config(oc);

39
sway/desktop/render.c
View File

@ -1012,43 +1012,6 @@ void output_render(struct render_context *ctx) {
pixman_region32_copy(&transformed_damage, damage);
transform_output_damage(&transformed_damage, wlr_output);
if (server.session_lock.locked) {
struct wlr_render_color clear_color = {
.a = 1.0f
};
if (server.session_lock.lock == NULL) {
// abandoned lock -> red BG
clear_color.r = 1.f;
}
wlr_render_pass_add_rect(ctx->pass, &(struct wlr_render_rect_options){
.box = { .width = wlr_output->width, .height = wlr_output->height },
.color = clear_color,
.clip = &transformed_damage,
});
if (server.session_lock.lock != NULL) {
struct render_data data = {
.alpha = 1.0f,
.ctx = ctx,
};
struct wlr_session_lock_surface_v1 *lock_surface;
wl_list_for_each(lock_surface, &server.session_lock.lock->surfaces, link) {
if (lock_surface->output != wlr_output) {
continue;
}
if (!lock_surface->surface->mapped) {
continue;
}
output_surface_for_each_surface(output, lock_surface->surface,
0.0, 0.0, render_surface_iterator, &data);
}
}
goto renderer_end;
}
if (output_has_opaque_overlay_layer_surface(output)) {
goto render_overlay;
}
@ -1122,8 +1085,6 @@ render_overlay:
&output->shell_layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]);
render_layer_popups(ctx,
&output->shell_layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]);
renderer_end:
pixman_region32_fini(&transformed_damage);
wlr_output_add_software_cursors_to_render_pass(wlr_output, ctx->pass, damage);
}

18
sway/input/cursor.c
View File

@ -95,24 +95,6 @@ struct sway_node *node_at_coords(
double ox = lx, oy = ly;
wlr_output_layout_output_coords(root->output_layout, wlr_output, &ox, &oy);
if (server.session_lock.locked) {
if (server.session_lock.lock == NULL) {
return NULL;
}
struct wlr_session_lock_surface_v1 *lock_surf;
wl_list_for_each(lock_surf, &server.session_lock.lock->surfaces, link) {
if (lock_surf->output != wlr_output) {
continue;
}
*surface = wlr_surface_surface_at(lock_surf->surface, ox, oy, sx, sy);
if (*surface != NULL) {
return NULL;
}
}
return NULL;
}
// layer surfaces on the overlay layer are rendered on top
if ((*surface = layer_surface_at(output,
&output->shell_layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],

2
sway/input/keyboard.c
View File

@ -405,7 +405,7 @@ static void handle_key_event(struct sway_keyboard *keyboard,
char *device_identifier = input_device_get_identifier(wlr_device);
bool exact_identifier = keyboard->wlr->group != NULL;
seat_idle_notify_activity(seat, IDLE_SOURCE_KEYBOARD);
bool locked = server.session_lock.locked;
bool locked = server.session_lock.lock;
struct sway_keyboard_shortcuts_inhibitor *sway_inhibitor =
keyboard_shortcuts_inhibitor_get_for_focused_surface(seat);
bool shortcuts_inhibited = sway_inhibitor && sway_inhibitor->inhibitor->active;

19
sway/input/seat.c
View File

@ -1060,19 +1060,10 @@ void seat_configure_xcursor(struct sway_seat *seat) {
bool seat_is_input_allowed(struct sway_seat *seat,
struct wlr_surface *surface) {
if (!server.session_lock.locked) {
return true;
if (server.session_lock.lock) {
return sway_session_lock_has_surface(server.session_lock.lock, surface);
}
if (server.session_lock.lock == NULL) {
return false;
}
struct wlr_session_lock_surface_v1 *lock_surf;
wl_list_for_each(lock_surf, &server.session_lock.lock->surfaces, link) {
if (lock_surf->surface == surface) {
return true;
}
}
return false;
return true;
}
static void send_unfocus(struct sway_container *con, void *data) {
@ -1277,8 +1268,8 @@ void seat_set_focus(struct sway_seat *seat, struct sway_node *node) {
} else {
seat_set_workspace_focus(seat, node);
}
if (server.session_lock.locked) {
seat_set_focus_surface(seat, server.session_lock.focused, false);
if (server.session_lock.lock) {
seat_set_focus_surface(seat, server.session_lock.lock->focused, false);
}
}

2
sway/input/switch.c
View File

@ -34,7 +34,7 @@ static bool sway_switch_trigger_test(enum sway_switch_trigger trigger,
static void execute_binding(struct sway_switch *sway_switch) {
struct sway_seat *seat = sway_switch->seat_device->sway_seat;
bool locked = server.session_lock.locked;
bool locked = server.session_lock.lock;
list_t *bindings = config->current_mode->switch_bindings;
struct sway_switch_binding *matched_binding = NULL;

358
sway/lock.c
View File

@ -1,5 +1,6 @@
#define _POSIX_C_SOURCE 200809L
#include <assert.h>
#include <wlr/types/wlr_scene.h>
#include "log.h"
#include "sway/input/cursor.h"
#include "sway/input/keyboard.h"
@ -9,19 +10,28 @@
#include "sway/server.h"
#include "sway/surface.h"
struct sway_session_lock_surface {
struct wlr_session_lock_surface_v1 *lock_surface;
struct sway_session_lock_output {
struct wlr_scene_tree *tree;
struct wlr_scene_rect *background;
struct sway_session_lock *lock;
struct sway_output *output;
struct wlr_surface *surface;
struct wl_listener map;
struct wl_list link; // sway_session_lock::outputs
struct wl_listener destroy;
struct wl_listener surface_commit;
struct wl_listener output_commit;
struct wl_listener output_destroy;
struct wl_listener commit;
struct wlr_session_lock_surface_v1 *surface;
// invalid if surface is NULL
struct wl_listener surface_destroy;
struct wl_listener surface_map;
};
static void set_lock_focused_surface(struct wlr_surface *focused) {
server.session_lock.focused = focused;
static void focus_surface(struct sway_session_lock *lock,
struct wlr_surface *focused) {
lock->focused = focused;
struct sway_seat *seat;
wl_list_for_each(seat, &server.input->seats, link) {
@ -29,104 +39,189 @@ static void set_lock_focused_surface(struct wlr_surface *focused) {
}
}
static void refocus_output(struct sway_session_lock_output *output) {
// Move the seat focus to another surface if one is available
if (output->lock->focused == output->surface->surface) {
struct wlr_surface *next_focus = NULL;
struct sway_session_lock_output *candidate;
wl_list_for_each(candidate, &output->lock->outputs, link) {
if (candidate == output || !candidate->surface) {
continue;
}
if (candidate->surface->surface->mapped) {
next_focus = candidate->surface->surface;
break;
}
}
focus_surface(output->lock, next_focus);
}
}
static void handle_surface_map(struct wl_listener *listener, void *data) {
struct sway_session_lock_surface *surf = wl_container_of(listener, surf, map);
if (server.session_lock.focused == NULL) {
set_lock_focused_surface(surf->surface);
struct sway_session_lock_output *surf = wl_container_of(listener, surf, surface_map);
if (surf->lock->focused == NULL) {
focus_surface(surf->lock, surf->surface->surface);
}
cursor_rebase_all();
surface_enter_output(surf->surface, surf->output);
output_damage_whole(surf->output);
}
static void handle_surface_commit(struct wl_listener *listener, void *data) {
struct sway_session_lock_surface *surf = wl_container_of(listener, surf, surface_commit);
output_damage_surface(surf->output, 0, 0, surf->surface, false);
static void handle_surface_destroy(struct wl_listener *listener, void *data) {
struct sway_session_lock_output *output =
wl_container_of(listener, output, surface_destroy);
refocus_output(output);
sway_assert(output->surface, "Trying to destroy a surface that the lock doesn't think exists");
output->surface = NULL;
wl_list_remove(&output->surface_destroy.link);
wl_list_remove(&output->surface_map.link);
}
static void handle_output_commit(struct wl_listener *listener, void *data) {
static void lock_output_reconfigure(struct sway_session_lock_output *output) {
int width = output->output->width;
int height = output->output->height;
wlr_scene_rect_set_size(output->background, width, height);
if (output->surface) {
wlr_session_lock_surface_v1_configure(output->surface, width, height);
}
}
static void handle_new_surface(struct wl_listener *listener, void *data) {
struct sway_session_lock *lock = wl_container_of(listener, lock, new_surface);
struct wlr_session_lock_surface_v1 *lock_surface = data;
struct sway_output *output = lock_surface->output->data;
sway_log(SWAY_DEBUG, "new lock layer surface");
struct sway_session_lock_output *current_lock_output, *lock_output = NULL;
wl_list_for_each(current_lock_output, &lock->outputs, link) {
if (current_lock_output->output == output) {
lock_output = current_lock_output;
break;
}
}
sway_assert(lock_output, "Couldn't find output to lock");
sway_assert(!lock_output->surface, "Tried to reassign a surface to an existing output");
lock_output->surface = lock_surface;
wlr_scene_subsurface_tree_create(lock_output->tree, lock_surface->surface);
lock_output->surface_destroy.notify = handle_surface_destroy;
wl_signal_add(&lock_surface->events.destroy, &lock_output->surface_destroy);
lock_output->surface_map.notify = handle_surface_map;
wl_signal_add(&lock_surface->surface->events.map, &lock_output->surface_map);
lock_output_reconfigure(lock_output);
}
static void sway_session_lock_output_destroy(struct sway_session_lock_output *output) {
if (output->surface) {
refocus_output(output);
wl_list_remove(&output->surface_destroy.link);
wl_list_remove(&output->surface_map.link);
}
wl_list_remove(&output->commit.link);
wl_list_remove(&output->destroy.link);
wl_list_remove(&output->link);
free(output);
}
static void lock_node_handle_destroy(struct wl_listener *listener, void *data) {
struct sway_session_lock_output *output =
wl_container_of(listener, output, destroy);
sway_session_lock_output_destroy(output);
}
static void lock_output_handle_commit(struct wl_listener *listener, void *data) {
struct wlr_output_event_commit *event = data;
struct sway_session_lock_surface *surf = wl_container_of(listener, surf, output_commit);
struct sway_session_lock_output *output =
wl_container_of(listener, output, commit);
if (event->state->committed & (
WLR_OUTPUT_STATE_MODE |
WLR_OUTPUT_STATE_SCALE |
WLR_OUTPUT_STATE_TRANSFORM)) {
wlr_session_lock_surface_v1_configure(surf->lock_surface,
surf->output->width, surf->output->height);
lock_output_reconfigure(output);
}
}
static void destroy_lock_surface(struct sway_session_lock_surface *surf) {
// Move the seat focus to another surface if one is available
if (server.session_lock.focused == surf->surface) {
struct wlr_surface *next_focus = NULL;
struct wlr_session_lock_surface_v1 *other;
wl_list_for_each(other, &server.session_lock.lock->surfaces, link) {
if (other != surf->lock_surface && other->surface->mapped) {
next_focus = other->surface;
break;
}
}
set_lock_focused_surface(next_focus);
static struct sway_session_lock_output *session_lock_output_create(
struct sway_session_lock *lock, struct sway_output *output) {
struct sway_session_lock_output *lock_output = calloc(1, sizeof(*lock_output));
if (!lock_output) {
sway_log(SWAY_ERROR, "failed to allocate a session lock output");
return NULL;
}
wl_list_remove(&surf->map.link);
wl_list_remove(&surf->destroy.link);
wl_list_remove(&surf->surface_commit.link);
wl_list_remove(&surf->output_commit.link);
wl_list_remove(&surf->output_destroy.link);
output_damage_whole(surf->output);
free(surf);
}
static void handle_surface_destroy(struct wl_listener *listener, void *data) {
struct sway_session_lock_surface *surf = wl_container_of(listener, surf, destroy);
destroy_lock_surface(surf);
}
static void handle_output_destroy(struct wl_listener *listener, void *data) {
struct sway_session_lock_surface *surf =
wl_container_of(listener, surf, output_destroy);
destroy_lock_surface(surf);
}
static void handle_new_surface(struct wl_listener *listener, void *data) {
struct wlr_session_lock_surface_v1 *lock_surface = data;
struct sway_session_lock_surface *surf = calloc(1, sizeof(*surf));
if (surf == NULL) {
return;
struct wlr_scene_tree *tree = wlr_scene_tree_create(output->layers.session_lock);
if (!tree) {
sway_log(SWAY_ERROR, "failed to allocate a session lock output scene tree");
free(lock_output);
return NULL;
}
sway_log(SWAY_DEBUG, "new lock layer surface");
struct wlr_scene_rect *background = wlr_scene_rect_create(tree, 0, 0, (float[4]){
lock->abandoned ? 1.f : 0.f,
0.f,
0.f,
1.f,
});
if (!background) {
sway_log(SWAY_ERROR, "failed to allocate a session lock output scene background");
wlr_scene_node_destroy(&tree->node);
free(lock_output);
return NULL;
}
struct sway_output *output = lock_surface->output->data;
wlr_session_lock_surface_v1_configure(lock_surface, output->width, output->height);
lock_output->output = output;
lock_output->tree = tree;
lock_output->background = background;
lock_output->lock = lock;
surf->lock_surface = lock_surface;
surf->surface = lock_surface->surface;
surf->output = output;
surf->map.notify = handle_surface_map;
wl_signal_add(&lock_surface->surface->events.map, &surf->map);
surf->destroy.notify = handle_surface_destroy;
wl_signal_add(&lock_surface->events.destroy, &surf->destroy);
surf->surface_commit.notify = handle_surface_commit;
wl_signal_add(&surf->surface->events.commit, &surf->surface_commit);
surf->output_commit.notify = handle_output_commit;
wl_signal_add(&output->wlr_output->events.commit, &surf->output_commit);
surf->output_destroy.notify = handle_output_destroy;
wl_signal_add(&output->node.events.destroy, &surf->output_destroy);
lock_output->destroy.notify = lock_node_handle_destroy;
wl_signal_add(&tree->node.events.destroy, &lock_output->destroy);
lock_output->commit.notify = lock_output_handle_commit;
wl_signal_add(&output->wlr_output->events.commit, &lock_output->commit);
lock_output_reconfigure(lock_output);
wl_list_insert(&lock->outputs, &lock_output->link);
return lock_output;
}
static void sway_session_lock_destroy(struct sway_session_lock* lock) {
struct sway_session_lock_output *lock_output, *tmp_lock_output;
wl_list_for_each_safe(lock_output, tmp_lock_output, &lock->outputs, link) {
// destroying the node will also destroy the whole lock output
wlr_scene_node_destroy(&lock_output->tree->node);
}
if (server.session_lock.lock == lock) {
server.session_lock.lock = NULL;
}
if (!lock->abandoned) {
wl_list_remove(&lock->destroy.link);
wl_list_remove(&lock->unlock.link);
wl_list_remove(&lock->new_surface.link);
}
free(lock);
}
static void handle_unlock(struct wl_listener *listener, void *data) {
struct sway_session_lock *lock = wl_container_of(listener, lock, unlock);
sway_log(SWAY_DEBUG, "session unlocked");
server.session_lock.locked = false;
server.session_lock.lock = NULL;
server.session_lock.focused = NULL;
wl_list_remove(&server.session_lock.lock_new_surface.link);
wl_list_remove(&server.session_lock.lock_unlock.link);
wl_list_remove(&server.session_lock.lock_destroy.link);
sway_session_lock_destroy(lock);
struct sway_seat *seat;
wl_list_for_each(seat, &server.input->seats, link) {
@ -145,28 +240,22 @@ static void handle_unlock(struct wl_listener *listener, void *data) {
struct sway_output *output = root->outputs->items[i];
arrange_layers(output);
}
// redraw everything
for (int i = 0; i < root->outputs->length; ++i) {
struct sway_output *output = root->outputs->items[i];
output_damage_whole(output);
}
}
static void handle_abandon(struct wl_listener *listener, void *data) {
struct sway_session_lock *lock = wl_container_of(listener, lock, destroy);
sway_log(SWAY_INFO, "session lock abandoned");
server.session_lock.lock = NULL;
server.session_lock.focused = NULL;
wl_list_remove(&server.session_lock.lock_new_surface.link);
wl_list_remove(&server.session_lock.lock_unlock.link);
wl_list_remove(&server.session_lock.lock_destroy.link);
// redraw everything
for (int i = 0; i < root->outputs->length; ++i) {
struct sway_output *output = root->outputs->items[i];
output_damage_whole(output);
struct sway_session_lock_output *lock_output;
wl_list_for_each(lock_output, &lock->outputs, link) {
wlr_scene_rect_set_color(lock_output->background,
(float[4]){ 1.f, 0.f, 0.f, 1.f });
}
lock->abandoned = true;
wl_list_remove(&lock->destroy.link);
wl_list_remove(&lock->unlock.link);
wl_list_remove(&lock->new_surface.link);
}
static void handle_session_lock(struct wl_listener *listener, void *data) {
@ -174,44 +263,89 @@ static void handle_session_lock(struct wl_listener *listener, void *data) {
struct wl_client *client = wl_resource_get_client(lock->resource);
if (server.session_lock.lock) {
if (server.session_lock.lock->abandoned) {
sway_log(SWAY_INFO, "Replacing abandoned lock");
sway_session_lock_destroy(server.session_lock.lock);
} else {
sway_log(SWAY_ERROR, "Cannot lock an already locked session");
wlr_session_lock_v1_destroy(lock);
return;
}
}
struct sway_session_lock *sway_lock = calloc(1, sizeof(*sway_lock));
if (!sway_lock) {
sway_log(SWAY_ERROR, "failed to allocate a session lock object");
wlr_session_lock_v1_destroy(lock);
return;
}
wl_list_init(&sway_lock->outputs);
sway_log(SWAY_DEBUG, "session locked");
server.session_lock.locked = true;
server.session_lock.lock = lock;
struct sway_seat *seat;
wl_list_for_each(seat, &server.input->seats, link) {
seat_unfocus_unless_client(seat, client);
}
wl_signal_add(&lock->events.new_surface, &server.session_lock.lock_new_surface);
wl_signal_add(&lock->events.unlock, &server.session_lock.lock_unlock);
wl_signal_add(&lock->events.destroy, &server.session_lock.lock_destroy);
struct sway_output *output;
wl_list_for_each(output, &root->all_outputs, link) {
sway_session_lock_add_output(sway_lock, output);
}
sway_lock->new_surface.notify = handle_new_surface;
wl_signal_add(&lock->events.new_surface, &sway_lock->new_surface);
sway_lock->unlock.notify = handle_unlock;
wl_signal_add(&lock->events.unlock, &sway_lock->unlock);
sway_lock->destroy.notify = handle_abandon;
wl_signal_add(&lock->events.destroy, &sway_lock->destroy);
wlr_session_lock_v1_send_locked(lock);
// redraw everything
for (int i = 0; i < root->outputs->length; ++i) {
struct sway_output *output = root->outputs->items[i];
output_damage_whole(output);
}
server.session_lock.lock = sway_lock;
}
static void handle_session_lock_destroy(struct wl_listener *listener, void *data) {
assert(server.session_lock.lock == NULL);
// if the server shuts down while a lock is active, destroy the lock
if (server.session_lock.lock) {
sway_session_lock_destroy(server.session_lock.lock);
}
wl_list_remove(&server.session_lock.new_lock.link);
wl_list_remove(&server.session_lock.manager_destroy.link);
server.session_lock.manager = NULL;
}
void sway_session_lock_add_output(struct sway_session_lock *lock,
struct sway_output *output) {
struct sway_session_lock_output *lock_output =
session_lock_output_create(lock, output);
// if we run out of memory while trying to lock the screen, the best we
// can do is kill the sway process. Security conscious users will have
// the sway session fall back to a login shell.
if (!lock_output) {
sway_log(SWAY_ERROR, "aborting: failed to allocate a lock output");
abort();
}
}
bool sway_session_lock_has_surface(struct sway_session_lock *lock,
struct wlr_surface *surface) {
struct sway_session_lock_output *lock_output;
wl_list_for_each(lock_output, &lock->outputs, link) {
if (lock_output->surface && lock_output->surface->surface == surface) {
return true;
}
}
return false;
}
void sway_session_lock_init(void) {
server.session_lock.manager = wlr_session_lock_manager_v1_create(server.wl_display);
server.session_lock.lock_new_surface.notify = handle_new_surface;
server.session_lock.lock_unlock.notify = handle_unlock;
server.session_lock.lock_destroy.notify = handle_abandon;
server.session_lock.new_lock.notify = handle_session_lock;
server.session_lock.manager_destroy.notify = handle_session_lock_destroy;
wl_signal_add(&server.session_lock.manager->events.new_lock,

2
sway/tree/output.c
View File

@ -95,6 +95,7 @@ static void destroy_scene_layers(struct sway_output *output) {
wlr_scene_node_destroy(&output->layers.tiling->node);
wlr_scene_node_destroy(&output->layers.fullscreen->node);
wlr_scene_node_destroy(&output->layers.session_lock->node);
}
struct sway_output *output_create(struct wlr_output *wlr_output) {
@ -104,6 +105,7 @@ struct sway_output *output_create(struct wlr_output *wlr_output) {
bool failed = false;
output->layers.tiling = alloc_scene_tree(root->staging, &failed);
output->layers.fullscreen = 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(

1
sway/tree/root.c
View File

@ -50,6 +50,7 @@ struct sway_root *root_create(struct wl_display *wl_display) {
root->layers.fullscreen = alloc_scene_tree(&root_scene->tree, &failed);
root->layers.fullscreen_global = alloc_scene_tree(&root_scene->tree, &failed);
root->layers.seat = alloc_scene_tree(&root_scene->tree, &failed);
root->layers.session_lock = alloc_scene_tree(&root_scene->tree, &failed);
if (failed) {
wlr_scene_node_destroy(&root_scene->tree.node);