itycodes
/
convince
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

scene_graph: Port ext_session_v1

Browse Source
master
Alexander Orzechowski 11 months ago committed by Kirill Primak
parent 0639bde9fb
commit 9a57966606
12 changed files with 276 additions and 188 deletions
Show Stats Download Patch File Download Diff File

1
include/sway/output.h
Unescape View File

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

25
include/sway/server.h
Unescape View File

@ -28,6 +28,19 @@
struct sway_transaction; 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 sway_server {
struct wl_display *wl_display; struct wl_display *wl_display;
struct wl_event_loop *wl_event_loop; struct wl_event_loop *wl_event_loop;
@ -92,15 +105,9 @@ struct sway_server {
struct wl_listener gamma_control_set_gamma; struct wl_listener gamma_control_set_gamma;
struct { struct {
bool locked; struct sway_session_lock *lock;
struct wlr_session_lock_manager_v1 *manager; 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 new_lock;
struct wl_listener manager_destroy; struct wl_listener manager_destroy;
} session_lock; } 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_idle_inhibitor_v1(struct wl_listener *listener, void *data);
void handle_layer_shell_surface(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_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); void handle_xdg_shell_toplevel(struct wl_listener *listener, void *data);
#if HAVE_XWAYLAND #if HAVE_XWAYLAND
void handle_xwayland_surface(struct wl_listener *listener, void *data); void handle_xwayland_surface(struct wl_listener *listener, void *data);

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

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

4
sway/desktop/output.c
Unescape 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 = wl_event_loop_add_timer(server->wl_event_loop,
output_repaint_timer_handler, output); 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); struct output_config *oc = find_output_config(output);
apply_output_config(oc, output); apply_output_config(oc, output);
free_output_config(oc); free_output_config(oc);

39
sway/desktop/render.c
Unescape View File

@ -1012,43 +1012,6 @@ void output_render(struct render_context *ctx) {
pixman_region32_copy(&transformed_damage, damage); pixman_region32_copy(&transformed_damage, damage);
transform_output_damage(&transformed_damage, wlr_output); 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)) { if (output_has_opaque_overlay_layer_surface(output)) {
goto render_overlay; goto render_overlay;
} }
@ -1122,8 +1085,6 @@ render_overlay:
&output->shell_layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]); &output->shell_layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]);
render_layer_popups(ctx, render_layer_popups(ctx,
&output->shell_layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]); &output->shell_layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY]);
renderer_end:
pixman_region32_fini(&transformed_damage); pixman_region32_fini(&transformed_damage);
wlr_output_add_software_cursors_to_render_pass(wlr_output, ctx->pass, damage); wlr_output_add_software_cursors_to_render_pass(wlr_output, ctx->pass, damage);
} }

18
sway/input/cursor.c
Unescape View File

@ -95,24 +95,6 @@ struct sway_node *node_at_coords(
double ox = lx, oy = ly; double ox = lx, oy = ly;
wlr_output_layout_output_coords(root->output_layout, wlr_output, &ox, &oy); 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 // layer surfaces on the overlay layer are rendered on top
if ((*surface = layer_surface_at(output, if ((*surface = layer_surface_at(output,
&output->shell_layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY], &output->shell_layers[ZWLR_LAYER_SHELL_V1_LAYER_OVERLAY],

2
sway/input/keyboard.c
Unescape View File

@ -405,7 +405,7 @@ static void handle_key_event(struct sway_keyboard *keyboard,
char *device_identifier = input_device_get_identifier(wlr_device); char *device_identifier = input_device_get_identifier(wlr_device);
bool exact_identifier = keyboard->wlr->group != NULL; bool exact_identifier = keyboard->wlr->group != NULL;
seat_idle_notify_activity(seat, IDLE_SOURCE_KEYBOARD); 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 = struct sway_keyboard_shortcuts_inhibitor *sway_inhibitor =
keyboard_shortcuts_inhibitor_get_for_focused_surface(seat); keyboard_shortcuts_inhibitor_get_for_focused_surface(seat);
bool shortcuts_inhibited = sway_inhibitor && sway_inhibitor->inhibitor->active; bool shortcuts_inhibited = sway_inhibitor && sway_inhibitor->inhibitor->active;

19
sway/input/seat.c
Unescape View File

@ -1060,19 +1060,10 @@ void seat_configure_xcursor(struct sway_seat *seat) {
bool seat_is_input_allowed(struct sway_seat *seat, bool seat_is_input_allowed(struct sway_seat *seat,
struct wlr_surface *surface) { struct wlr_surface *surface) {
if (!server.session_lock.locked) { if (server.session_lock.lock) {
return true; 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) { 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 { } else {
seat_set_workspace_focus(seat, node); seat_set_workspace_focus(seat, node);
} }
if (server.session_lock.locked) { if (server.session_lock.lock) {
seat_set_focus_surface(seat, server.session_lock.focused, false); seat_set_focus_surface(seat, server.session_lock.lock->focused, false);
} }
} }

2
sway/input/switch.c
Unescape 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) { static void execute_binding(struct sway_switch *sway_switch) {
struct sway_seat *seat = sway_switch->seat_device->sway_seat; 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; list_t *bindings = config->current_mode->switch_bindings;
struct sway_switch_binding *matched_binding = NULL; struct sway_switch_binding *matched_binding = NULL;

350
sway/lock.c
Unescape View File

@ -1,5 +1,6 @@
#define _POSIX_C_SOURCE 200809L #define _POSIX_C_SOURCE 200809L
#include <assert.h> #include <assert.h>
#include <wlr/types/wlr_scene.h>
#include "log.h" #include "log.h"
#include "sway/input/cursor.h" #include "sway/input/cursor.h"
#include "sway/input/keyboard.h" #include "sway/input/keyboard.h"
@ -9,19 +10,28 @@
#include "sway/server.h" #include "sway/server.h"
#include "sway/surface.h" #include "sway/surface.h"
struct sway_session_lock_surface { struct sway_session_lock_output {
struct wlr_session_lock_surface_v1 *lock_surface; struct wlr_scene_tree *tree;
struct wlr_scene_rect *background;
struct sway_session_lock *lock;
struct sway_output *output; 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 destroy;
struct wl_listener surface_commit; struct wl_listener commit;
struct wl_listener output_commit;
struct wl_listener output_destroy; 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) { static void focus_surface(struct sway_session_lock *lock,
server.session_lock.focused = focused; struct wlr_surface *focused) {
lock->focused = focused;
struct sway_seat *seat; struct sway_seat *seat;
wl_list_for_each(seat, &server.input->seats, link) { 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) { static void handle_surface_map(struct wl_listener *listener, void *data) {
struct sway_session_lock_surface *surf = wl_container_of(listener, surf, map); struct sway_session_lock_output *surf = wl_container_of(listener, surf, surface_map);
if (server.session_lock.focused == NULL) { if (surf->lock->focused == NULL) {
set_lock_focused_surface(surf->surface); focus_surface(surf->lock, surf->surface->surface);
} }
cursor_rebase_all(); 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) { static void handle_surface_destroy(struct wl_listener *listener, void *data) {
struct sway_session_lock_surface *surf = wl_container_of(listener, surf, surface_commit); struct sway_session_lock_output *output =
output_damage_surface(surf->output, 0, 0, surf->surface, false); 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 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_output_commit(struct wl_listener *listener, void *data) { 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 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 & ( if (event->state->committed & (
WLR_OUTPUT_STATE_MODE | WLR_OUTPUT_STATE_MODE |
WLR_OUTPUT_STATE_SCALE | WLR_OUTPUT_STATE_SCALE |
WLR_OUTPUT_STATE_TRANSFORM)) { WLR_OUTPUT_STATE_TRANSFORM)) {
wlr_session_lock_surface_v1_configure(surf->lock_surface, lock_output_reconfigure(output);
surf->output->width, surf->output->height);
} }
} }
static void destroy_lock_surface(struct sway_session_lock_surface *surf) { static struct sway_session_lock_output *session_lock_output_create(
// Move the seat focus to another surface if one is available struct sway_session_lock *lock, struct sway_output *output) {
if (server.session_lock.focused == surf->surface) { struct sway_session_lock_output *lock_output = calloc(1, sizeof(*lock_output));
struct wlr_surface *next_focus = NULL; if (!lock_output) {
sway_log(SWAY_ERROR, "failed to allocate a session lock output");
return NULL;
}
struct wlr_session_lock_surface_v1 *other; struct wlr_scene_tree *tree = wlr_scene_tree_create(output->layers.session_lock);
wl_list_for_each(other, &server.session_lock.lock->surfaces, link) { if (!tree) {
if (other != surf->lock_surface && other->surface->mapped) { sway_log(SWAY_ERROR, "failed to allocate a session lock output scene tree");
next_focus = other->surface; free(lock_output);
break; return NULL;
}
}
set_lock_focused_surface(next_focus);
} }
wl_list_remove(&surf->map.link); struct wlr_scene_rect *background = wlr_scene_rect_create(tree, 0, 0, (float[4]){
wl_list_remove(&surf->destroy.link); lock->abandoned ? 1.f : 0.f,
wl_list_remove(&surf->surface_commit.link); 0.f,
wl_list_remove(&surf->output_commit.link); 0.f,
wl_list_remove(&surf->output_destroy.link); 1.f,
output_damage_whole(surf->output); });
free(surf); 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;
}
static void handle_surface_destroy(struct wl_listener *listener, void *data) { lock_output->output = output;
struct sway_session_lock_surface *surf = wl_container_of(listener, surf, destroy); lock_output->tree = tree;
destroy_lock_surface(surf); lock_output->background = background;
} lock_output->lock = lock;
lock_output->destroy.notify = lock_node_handle_destroy;
wl_signal_add(&tree->node.events.destroy, &lock_output->destroy);
static void handle_output_destroy(struct wl_listener *listener, void *data) { lock_output->commit.notify = lock_output_handle_commit;
struct sway_session_lock_surface *surf = wl_signal_add(&output->wlr_output->events.commit, &lock_output->commit);
wl_container_of(listener, surf, output_destroy);
destroy_lock_surface(surf); lock_output_reconfigure(lock_output);
wl_list_insert(&lock->outputs, &lock_output->link);
return lock_output;
} }
static void handle_new_surface(struct wl_listener *listener, void *data) { static void sway_session_lock_destroy(struct sway_session_lock* lock) {
struct wlr_session_lock_surface_v1 *lock_surface = data; struct sway_session_lock_output *lock_output, *tmp_lock_output;
struct sway_session_lock_surface *surf = calloc(1, sizeof(*surf)); wl_list_for_each_safe(lock_output, tmp_lock_output, &lock->outputs, link) {
if (surf == NULL) { // destroying the node will also destroy the whole lock output
return; wlr_scene_node_destroy(&lock_output->tree->node);
} }
sway_log(SWAY_DEBUG, "new lock layer surface"); if (server.session_lock.lock == lock) {
server.session_lock.lock = NULL;
}
struct sway_output *output = lock_surface->output->data; if (!lock->abandoned) {
wlr_session_lock_surface_v1_configure(lock_surface, output->width, output->height); wl_list_remove(&lock->destroy.link);
wl_list_remove(&lock->unlock.link);
surf->lock_surface = lock_surface; wl_list_remove(&lock->new_surface.link);
surf->surface = lock_surface->surface; }
surf->output = output;
surf->map.notify = handle_surface_map; free(lock);
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);
} }
static void handle_unlock(struct wl_listener *listener, void *data) { 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"); 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); sway_session_lock_destroy(lock);
wl_list_remove(&server.session_lock.lock_unlock.link);
wl_list_remove(&server.session_lock.lock_destroy.link);
struct sway_seat *seat; struct sway_seat *seat;
wl_list_for_each(seat, &server.input->seats, link) { 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]; struct sway_output *output = root->outputs->items[i];
arrange_layers(output); 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) { 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"); 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); struct sway_session_lock_output *lock_output;
wl_list_remove(&server.session_lock.lock_unlock.link); wl_list_for_each(lock_output, &lock->outputs, link) {
wl_list_remove(&server.session_lock.lock_destroy.link); wlr_scene_rect_set_color(lock_output->background,
(float[4]){ 1.f, 0.f, 0.f, 1.f });
// redraw everything
for (int i = 0; i < root->outputs->length; ++i) {
struct sway_output *output = root->outputs->items[i];
output_damage_whole(output);
} }
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) { 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); struct wl_client *client = wl_resource_get_client(lock->resource);
if (server.session_lock.lock) { 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); wlr_session_lock_v1_destroy(lock);
return; return;
} }
wl_list_init(&sway_lock->outputs);
sway_log(SWAY_DEBUG, "session locked"); sway_log(SWAY_DEBUG, "session locked");
server.session_lock.locked = true;
server.session_lock.lock = lock;
struct sway_seat *seat; struct sway_seat *seat;
wl_list_for_each(seat, &server.input->seats, link) { wl_list_for_each(seat, &server.input->seats, link) {
seat_unfocus_unless_client(seat, client); seat_unfocus_unless_client(seat, client);
} }
wl_signal_add(&lock->events.new_surface, &server.session_lock.lock_new_surface); struct sway_output *output;
wl_signal_add(&lock->events.unlock, &server.session_lock.lock_unlock); wl_list_for_each(output, &root->all_outputs, link) {
wl_signal_add(&lock->events.destroy, &server.session_lock.lock_destroy); 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); wlr_session_lock_v1_send_locked(lock);
server.session_lock.lock = sway_lock;
// 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_session_lock_destroy(struct wl_listener *listener, void *data) { 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.new_lock.link);
wl_list_remove(&server.session_lock.manager_destroy.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) { void sway_session_lock_init(void) {
server.session_lock.manager = wlr_session_lock_manager_v1_create(server.wl_display); 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.new_lock.notify = handle_session_lock;
server.session_lock.manager_destroy.notify = handle_session_lock_destroy; server.session_lock.manager_destroy.notify = handle_session_lock_destroy;
wl_signal_add(&server.session_lock.manager->events.new_lock, wl_signal_add(&server.session_lock.manager->events.new_lock,

2
sway/tree/output.c
Unescape 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.tiling->node);
wlr_scene_node_destroy(&output->layers.fullscreen->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) { 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; bool failed = false;
output->layers.tiling = 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.fullscreen = alloc_scene_tree(root->staging, &failed);
output->layers.session_lock = alloc_scene_tree(root->staging, &failed);
if (!failed) { if (!failed) {
output->fullscreen_background = wlr_scene_rect_create( output->fullscreen_background = wlr_scene_rect_create(

1
sway/tree/root.c
Unescape 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 = alloc_scene_tree(&root_scene->tree, &failed);
root->layers.fullscreen_global = 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.seat = alloc_scene_tree(&root_scene->tree, &failed);
root->layers.session_lock = alloc_scene_tree(&root_scene->tree, &failed);
if (failed) { if (failed) {
wlr_scene_node_destroy(&root_scene->tree.node); wlr_scene_node_destroy(&root_scene->tree.node);

Write Preview
Loading…
Cancel
Save