mirrors/labwc
1
0
Fork 0
mirror of https://github.com/labwc/labwc.git synced 2025-11-01 22:58:47 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

session-lock: refactor

Browse source 
- Replaced `session_lock` with `session_lock_manager` which is
  persistent throughout the session.
- Replaced `session_lock->abandoned` with `session_lock_manager->locked`.
  Old `session_lock->abandoned` is equal to
  `!session_lock_manager->lock && session_lock_manager->locked`.
- Eliminated the use of global variables in `session-lock.c`.
- Changed some function names.
This commit is contained in:
tokyo4j 2024-05-30 00:13:34 +09:00 • committed by Hiroaki Yamamoto
parent 65f7499f1c
commit a39c8afc10
6 changed files with 111 additions and 110 deletions
Download patch file Download diff file Expand all files Collapse all files

2
include/labwc.h
View file

@ -314,7 +314,7 @@ struct server {
struct wlr_gamma_control_manager_v1 *gamma_control_manager_v1; struct wlr_gamma_control_manager_v1 *gamma_control_manager_v1;
struct wl_listener gamma_control_set_gamma; struct wl_listener gamma_control_set_gamma;
struct session_lock *session_lock; struct session_lock_manager *session_lock_manager;
struct wlr_foreign_toplevel_manager_v1 *foreign_toplevel_manager; struct wlr_foreign_toplevel_manager_v1 *foreign_toplevel_manager;

24
include/session-lock.h
View file

@ -7,20 +7,30 @@
struct output; struct output;
struct server; struct server;
struct session_lock { struct session_lock_manager {
struct wlr_session_lock_v1 *lock; struct server *server;
struct wlr_session_lock_manager_v1 *wlr_manager;
struct wlr_surface *focused; struct wlr_surface *focused;
bool abandoned; /*
* When not locked: lock=NULL, locked=false
* When locked: lock=non-NULL, locked=true
* When lock is destroyed without being unlocked: lock=NULL, locked=true
*/
struct wlr_session_lock_v1 *lock;
bool locked;
struct wl_list session_lock_outputs; struct wl_list session_lock_outputs;
struct wl_listener new_surface; struct wl_listener new_lock;
struct wl_listener unlock;
struct wl_listener destroy; struct wl_listener destroy;
struct wl_listener lock_new_surface;
struct wl_listener lock_unlock;
struct wl_listener lock_destroy;
}; };
void session_lock_init(struct server *server); void session_lock_init(struct server *server);
void session_lock_output_create(struct session_lock *lock, struct output *output); void session_lock_output_create(struct session_lock_manager *manager, struct output *output);
void session_lock_update_for_layout_change(void); void session_lock_update_for_layout_change(struct server *server);
#endif /* LABWC_SESSION_LOCK_H */ #endif /* LABWC_SESSION_LOCK_H */

2
src/input/keyboard.c
View file

@ -424,7 +424,7 @@ handle_compositor_keybindings(struct keyboard *keyboard,
if (seat->active_client_while_inhibited) { if (seat->active_client_while_inhibited) {
return false; return false;
} }
if (seat->server->session_lock) { if (seat->server->session_lock_manager->locked) {
return false; return false;
} }

6
src/output.c
View file

@ -395,8 +395,8 @@ new_output_notify(struct wl_listener *listener, void *data)
/* Create regions from config */ /* Create regions from config */
regions_reconfigure_output(output); regions_reconfigure_output(output);
if (server->session_lock) { if (server->session_lock_manager->locked) {
session_lock_output_create(server->session_lock, output); session_lock_output_create(server->session_lock_manager, output);
} }
server->pending_output_layout_change--; server->pending_output_layout_change--;
@ -442,7 +442,7 @@ static void
output_update_for_layout_change(struct server *server) output_update_for_layout_change(struct server *server)
{ {
output_update_all_usable_areas(server, /*layout_changed*/ true); output_update_all_usable_areas(server, /*layout_changed*/ true);
session_lock_update_for_layout_change(); session_lock_update_for_layout_change(server);
/* /*
* "Move" each wlr_output_cursor (in per-output coordinates) to * "Move" each wlr_output_cursor (in per-output coordinates) to

2
src/seat.c
View file

@ -621,7 +621,7 @@ seat_focus(struct seat *seat, struct wlr_surface *surface, bool is_lock_surface)
* lock screen may lose focus and become impossible to unlock. * lock screen may lose focus and become impossible to unlock.
*/ */
struct server *server = seat->server; struct server *server = seat->server;
if (server->session_lock && !is_lock_surface) { if (server->session_lock_manager->locked && !is_lock_surface) {
return; return;
} }

185
src/session-lock.c
View file

@ -4,20 +4,14 @@
#include "common/mem.h" #include "common/mem.h"
#include "labwc.h" #include "labwc.h"
static struct wl_listener new_lock;
static struct wl_listener manager_destroy;
static struct wlr_session_lock_manager_v1 *wlr_session_lock_manager;
static struct server *g_server;
struct session_lock_output { struct session_lock_output {
struct wlr_scene_tree *tree; struct wlr_scene_tree *tree;
struct wlr_scene_rect *background; struct wlr_scene_rect *background;
struct session_lock *lock; struct session_lock_manager *manager;
struct output *output; struct output *output;
struct wlr_session_lock_surface_v1 *surface; struct wlr_session_lock_surface_v1 *surface;
struct wl_list link; /* session_lock.outputs */ struct wl_list link; /* session_lock_manager.outputs */
struct wl_listener destroy; struct wl_listener destroy;
struct wl_listener commit; struct wl_listener commit;
@ -26,39 +20,40 @@ struct session_lock_output {
}; };
static void static void
focus_surface(struct session_lock *lock, struct wlr_surface *focused) focus_surface(struct session_lock_manager *manager, struct wlr_surface *focused)
{ {
lock->focused = focused; manager->focused = focused;
seat_focus_lock_surface(&g_server->seat, focused); seat_focus_lock_surface(&manager->server->seat, focused);
} }
static void static void
refocus_output(struct session_lock_output *output) refocus_output(struct session_lock_output *output)
{ {
/* Try to focus another session-lock surface */ /* Try to focus another session-lock surface */
if (output->lock->focused != output->surface->surface) { if (output->manager->focused != output->surface->surface) {
return; return;
} }
struct session_lock_output *iter; struct session_lock_output *iter;
wl_list_for_each(iter, &output->lock->session_lock_outputs, link) { wl_list_for_each(iter, &output->manager->session_lock_outputs, link) {
if (iter == output || !iter->surface || !iter->surface->surface) { if (iter == output || !iter->surface || !iter->surface->surface) {
continue; continue;
} }
if (iter->surface->surface->mapped) { if (iter->surface->surface->mapped) {
focus_surface(output->lock, iter->surface->surface); focus_surface(output->manager, iter->surface->surface);
return; return;
} }
} }
focus_surface(output->lock, NULL); focus_surface(output->manager, NULL);
} }
static void static void
handle_surface_map(struct wl_listener *listener, void *data) handle_surface_map(struct wl_listener *listener, void *data)
{ {
struct session_lock_output *surf = wl_container_of(listener, surf, surface_map); struct session_lock_output *output =
if (!surf->lock->focused) { wl_container_of(listener, output, surface_map);
focus_surface(surf->lock, surf->surface->surface); if (!output->manager->focused) {
focus_surface(output->manager, output->surface->surface);
} }
} }
@ -79,21 +74,24 @@ static void
lock_output_reconfigure(struct session_lock_output *output) lock_output_reconfigure(struct session_lock_output *output)
{ {
struct wlr_box box; struct wlr_box box;
wlr_output_layout_get_box(g_server->output_layout, output->output->wlr_output, &box); wlr_output_layout_get_box(output->manager->server->output_layout,
output->output->wlr_output, &box);
wlr_scene_rect_set_size(output->background, box.width, box.height); wlr_scene_rect_set_size(output->background, box.width, box.height);
if (output->surface) { if (output->surface) {
wlr_session_lock_surface_v1_configure(output->surface, box.width, box.height); wlr_session_lock_surface_v1_configure(
output->surface, box.width, box.height);
} }
} }
static void static void
handle_new_surface(struct wl_listener *listener, void *data) handle_new_surface(struct wl_listener *listener, void *data)
{ {
struct session_lock *lock = wl_container_of(listener, lock, new_surface); struct session_lock_manager *manager =
wl_container_of(listener, manager, lock_new_surface);
struct wlr_session_lock_surface_v1 *lock_surface = data; struct wlr_session_lock_surface_v1 *lock_surface = data;
struct output *output = lock_surface->output->data; struct output *output = lock_surface->output->data;
struct session_lock_output *lock_output; struct session_lock_output *lock_output;
wl_list_for_each(lock_output, &lock->session_lock_outputs, link) { wl_list_for_each(lock_output, &manager->session_lock_outputs, link) {
if (lock_output->output == output) { if (lock_output->output == output) {
goto found_lock_output; goto found_lock_output;
} }
@ -130,14 +128,14 @@ session_lock_output_destroy(struct session_lock_output *output)
} }
static void static void
handle_destroy(struct wl_listener *listener, void *data) handle_output_destroy(struct wl_listener *listener, void *data)
{ {
struct session_lock_output *output = wl_container_of(listener, output, destroy); struct session_lock_output *output = wl_container_of(listener, output, destroy);
session_lock_output_destroy(output); session_lock_output_destroy(output);
} }
static void static void
handle_commit(struct wl_listener *listener, void *data) handle_output_commit(struct wl_listener *listener, void *data)
{ {
struct wlr_output_event_commit *event = data; struct wlr_output_event_commit *event = data;
struct session_lock_output *output = wl_container_of(listener, output, commit); struct session_lock_output *output = wl_container_of(listener, output, commit);
@ -152,18 +150,15 @@ static void
align_session_lock_tree(struct output *output) align_session_lock_tree(struct output *output)
{ {
struct wlr_box box; struct wlr_box box;
wlr_output_layout_get_box(g_server->output_layout, output->wlr_output, &box); wlr_output_layout_get_box(output->server->output_layout,
output->wlr_output, &box);
wlr_scene_node_set_position(&output->session_lock_tree->node, box.x, box.y); wlr_scene_node_set_position(&output->session_lock_tree->node, box.x, box.y);
} }
void void
session_lock_output_create(struct session_lock *lock, struct output *output) session_lock_output_create(struct session_lock_manager *manager, struct output *output)
{ {
struct session_lock_output *lock_output = znew(*lock_output); struct session_lock_output *lock_output = znew(*lock_output);
if (!lock_output) {
wlr_log(WLR_ERROR, "session-lock: out of memory");
goto exit_session;
}
struct wlr_scene_tree *tree = wlr_scene_tree_create(output->session_lock_tree); struct wlr_scene_tree *tree = wlr_scene_tree_create(output->session_lock_tree);
if (!tree) { if (!tree) {
@ -191,17 +186,17 @@ session_lock_output_create(struct session_lock *lock, struct output *output)
lock_output->output = output; lock_output->output = output;
lock_output->tree = tree; lock_output->tree = tree;
lock_output->background = background; lock_output->background = background;
lock_output->lock = lock; lock_output->manager = manager;
lock_output->destroy.notify = handle_destroy; lock_output->destroy.notify = handle_output_destroy;
wl_signal_add(&tree->node.events.destroy, &lock_output->destroy); wl_signal_add(&tree->node.events.destroy, &lock_output->destroy);
lock_output->commit.notify = handle_commit; lock_output->commit.notify = handle_output_commit;
wl_signal_add(&output->wlr_output->events.commit, &lock_output->commit); wl_signal_add(&output->wlr_output->events.commit, &lock_output->commit);
lock_output_reconfigure(lock_output); lock_output_reconfigure(lock_output);
wl_list_insert(&lock->session_lock_outputs, &lock_output->link); wl_list_insert(&manager->session_lock_outputs, &lock_output->link);
return; return;
exit_session: exit_session:
@ -211,130 +206,126 @@ exit_session:
} }
static void static void
session_lock_destroy(struct session_lock *lock) session_lock_destroy(struct session_lock_manager *manager)
{ {
struct session_lock_output *lock_output, *next; struct session_lock_output *lock_output, *next;
wl_list_for_each_safe(lock_output, next, &lock->session_lock_outputs, link) { wl_list_for_each_safe(lock_output, next, &manager->session_lock_outputs, link) {
wlr_scene_node_destroy(&lock_output->tree->node); wlr_scene_node_destroy(&lock_output->tree->node);
} }
if (g_server->session_lock == lock) { if (manager->lock) {
g_server->session_lock = NULL; wl_list_remove(&manager->lock_destroy.link);
wl_list_remove(&manager->lock_unlock.link);
wl_list_remove(&manager->lock_new_surface.link);
} }
if (!lock->abandoned) { manager->lock = NULL;
wl_list_remove(&lock->destroy.link);
wl_list_remove(&lock->unlock.link);
wl_list_remove(&lock->new_surface.link);
}
free(lock);
} }
static void static void
handle_unlock(struct wl_listener *listener, void *data) handle_lock_unlock(struct wl_listener *listener, void *data)
{ {
struct session_lock *lock = wl_container_of(listener, lock, unlock); struct session_lock_manager *manager =
session_lock_destroy(lock); wl_container_of(listener, manager, lock_unlock);
desktop_focus_topmost_view(g_server); session_lock_destroy(manager);
manager->locked = false;
desktop_focus_topmost_view(manager->server);
} }
static void static void
handle_session_lock_destroy(struct wl_listener *listener, void *data) handle_lock_destroy(struct wl_listener *listener, void *data)
{ {
struct session_lock *lock = wl_container_of(listener, lock, destroy); struct session_lock_manager *manager =
wl_container_of(listener, manager, lock_destroy);
float *black = (float[4]) { 0.f, 0.f, 0.f, 1.f }; float *black = (float[4]) { 0.f, 0.f, 0.f, 1.f };
struct session_lock_output *lock_output; struct session_lock_output *lock_output;
wl_list_for_each(lock_output, &lock->session_lock_outputs, link) { wl_list_for_each(lock_output, &manager->session_lock_outputs, link) {
wlr_scene_rect_set_color(lock_output->background, black); wlr_scene_rect_set_color(lock_output->background, black);
} }
lock->abandoned = true; wl_list_remove(&manager->lock_destroy.link);
wl_list_remove(&lock->destroy.link); wl_list_remove(&manager->lock_unlock.link);
wl_list_remove(&lock->unlock.link); wl_list_remove(&manager->lock_new_surface.link);
wl_list_remove(&lock->new_surface.link);
} }
static void static void
handle_new_session_lock(struct wl_listener *listener, void *data) handle_new_session_lock(struct wl_listener *listener, void *data)
{ {
struct session_lock_manager *manager =
wl_container_of(listener, manager, new_lock);
struct wlr_session_lock_v1 *lock = data; struct wlr_session_lock_v1 *lock = data;
/* One already exists */ if (manager->lock) {
if (g_server->session_lock) { wlr_log(WLR_ERROR, "session already locked");
if (g_server->session_lock->abandoned) {
wlr_log(WLR_INFO, "replacing abandoned lock");
session_lock_destroy(g_server->session_lock);
} else {
wlr_log(WLR_ERROR, "session already locked");
wlr_session_lock_v1_destroy(lock);
return;
}
}
struct session_lock *session_lock = znew(*session_lock);
if (!session_lock) {
wlr_log(WLR_ERROR, "session-lock: out of memory");
wlr_session_lock_v1_destroy(lock); wlr_session_lock_v1_destroy(lock);
return; return;
} }
if (manager->locked) {
wlr_log(WLR_INFO, "replacing abandoned lock");
session_lock_destroy(manager);
}
assert(wl_list_empty(&manager->session_lock_outputs));
wl_list_init(&session_lock->session_lock_outputs);
struct output *output; struct output *output;
wl_list_for_each(output, &g_server->outputs, link) { wl_list_for_each(output, &manager->server->outputs, link) {
session_lock_output_create(session_lock, output); session_lock_output_create(manager, output);
} }
session_lock->new_surface.notify = handle_new_surface; manager->lock_new_surface.notify = handle_new_surface;
wl_signal_add(&lock->events.new_surface, &session_lock->new_surface); wl_signal_add(&lock->events.new_surface, &manager->lock_new_surface);
session_lock->unlock.notify = handle_unlock; manager->lock_unlock.notify = handle_lock_unlock;
wl_signal_add(&lock->events.unlock, &session_lock->unlock); wl_signal_add(&lock->events.unlock, &manager->lock_unlock);
session_lock->destroy.notify = handle_session_lock_destroy; manager->lock_destroy.notify = handle_lock_destroy;
wl_signal_add(&lock->events.destroy, &session_lock->destroy); wl_signal_add(&lock->events.destroy, &manager->lock_destroy);
manager->locked = true;
wlr_session_lock_v1_send_locked(lock); wlr_session_lock_v1_send_locked(lock);
g_server->session_lock = session_lock;
} }
static void static void
handle_manager_destroy(struct wl_listener *listener, void *data) handle_manager_destroy(struct wl_listener *listener, void *data)
{ {
if (g_server->session_lock) { struct session_lock_manager *manager =
session_lock_destroy(g_server->session_lock); wl_container_of(listener, manager, destroy);
} session_lock_destroy(manager);
wl_list_remove(&new_lock.link); wl_list_remove(&manager->new_lock.link);
wl_list_remove(&manager_destroy.link); wl_list_remove(&manager->destroy.link);
wlr_session_lock_manager = NULL; manager->server->session_lock_manager = NULL;
free(manager);
} }
void void
session_lock_init(struct server *server) session_lock_init(struct server *server)
{ {
g_server = server; struct session_lock_manager *manager = znew(*manager);
wlr_session_lock_manager = wlr_session_lock_manager_v1_create(server->wl_display); server->session_lock_manager = manager;
manager->server = server;
manager->wlr_manager = wlr_session_lock_manager_v1_create(server->wl_display);
wl_list_init(&manager->session_lock_outputs);
new_lock.notify = handle_new_session_lock; manager->new_lock.notify = handle_new_session_lock;
wl_signal_add(&wlr_session_lock_manager->events.new_lock, &new_lock); wl_signal_add(&manager->wlr_manager->events.new_lock, &manager->new_lock);
manager_destroy.notify = handle_manager_destroy; manager->destroy.notify = handle_manager_destroy;
wl_signal_add(&wlr_session_lock_manager->events.destroy, &manager_destroy); wl_signal_add(&manager->wlr_manager->events.destroy, &manager->destroy);
} }
void void
session_lock_update_for_layout_change(void) session_lock_update_for_layout_change(struct server *server)
{ {
if (!g_server->session_lock) { if (!server->session_lock_manager->locked) {
return; return;
} }
struct output *output; struct output *output;
wl_list_for_each(output, &g_server->outputs, link) { wl_list_for_each(output, &server->outputs, link) {
align_session_lock_tree(output); align_session_lock_tree(output);
} }
struct session_lock *lock = g_server->session_lock; struct session_lock_manager *manager = server->session_lock_manager;
struct session_lock_output *lock_output; struct session_lock_output *lock_output;
wl_list_for_each(lock_output, &lock->session_lock_outputs, link) { wl_list_for_each(lock_output, &manager->session_lock_outputs, link) {
lock_output_reconfigure(lock_output); lock_output_reconfigure(lock_output);
} }
} }