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 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;

24
include/session-lock.h
View file

@ -7,20 +7,30 @@
struct output;
struct server;
struct session_lock {
struct wlr_session_lock_v1 *lock;
struct session_lock_manager {
struct server *server;
struct wlr_session_lock_manager_v1 *wlr_manager;
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_listener new_surface;
struct wl_listener unlock;
struct wl_listener new_lock;
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_output_create(struct session_lock *lock, struct output *output);
void session_lock_update_for_layout_change(void);
void session_lock_output_create(struct session_lock_manager *manager, struct output *output);
void session_lock_update_for_layout_change(struct server *server);
#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) {
return false;
}
if (seat->server->session_lock) {
if (seat->server->session_lock_manager->locked) {
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 */
regions_reconfigure_output(output);
if (server->session_lock) {
session_lock_output_create(server->session_lock, output);
if (server->session_lock_manager->locked) {
session_lock_output_create(server->session_lock_manager, output);
}
server->pending_output_layout_change--;
@ -442,7 +442,7 @@ static void
output_update_for_layout_change(struct server *server)
{
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

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.
*/
struct server *server = seat->server;
if (server->session_lock && !is_lock_surface) {
if (server->session_lock_manager->locked && !is_lock_surface) {
return;
}

181
src/session-lock.c
View file

@ -4,20 +4,14 @@
#include "common/mem.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 wlr_scene_tree *tree;
struct wlr_scene_rect *background;
struct session_lock *lock;
struct session_lock_manager *manager;
struct output *output;
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 commit;
@ -26,39 +20,40 @@ struct session_lock_output {
};
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;
seat_focus_lock_surface(&g_server->seat, focused);
manager->focused = focused;
seat_focus_lock_surface(&manager->server->seat, focused);
}
static void
refocus_output(struct session_lock_output *output)
{
/* Try to focus another session-lock surface */
if (output->lock->focused != output->surface->surface) {
if (output->manager->focused != output->surface->surface) {
return;
}
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) {
continue;
}
if (iter->surface->surface->mapped) {
focus_surface(output->lock, iter->surface->surface);
focus_surface(output->manager, iter->surface->surface);
return;
}
}
focus_surface(output->lock, NULL);
focus_surface(output->manager, NULL);
}
static void
handle_surface_map(struct wl_listener *listener, void *data)
{
struct session_lock_output *surf = wl_container_of(listener, surf, surface_map);
if (!surf->lock->focused) {
focus_surface(surf->lock, surf->surface->surface);
struct session_lock_output *output =
wl_container_of(listener, output, surface_map);
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)
{
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);
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
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 output *output = lock_surface->output->data;
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) {
goto found_lock_output;
}
@ -130,14 +128,14 @@ session_lock_output_destroy(struct session_lock_output *output)
}
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);
session_lock_output_destroy(output);
}
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 session_lock_output *output = wl_container_of(listener, output, commit);
@ -152,18 +150,15 @@ static void
align_session_lock_tree(struct output *output)
{
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);
}
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);
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);
if (!tree) {
@ -191,17 +186,17 @@ session_lock_output_create(struct session_lock *lock, struct output *output)
lock_output->output = output;
lock_output->tree = tree;
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);
lock_output->commit.notify = handle_commit;
lock_output->commit.notify = handle_output_commit;
wl_signal_add(&output->wlr_output->events.commit, &lock_output->commit);
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;
exit_session:
@ -211,130 +206,126 @@ exit_session:
}
static void
session_lock_destroy(struct session_lock *lock)
session_lock_destroy(struct session_lock_manager *manager)
{
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);
}
if (g_server->session_lock == lock) {
g_server->session_lock = NULL;
if (manager->lock) {
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) {
wl_list_remove(&lock->destroy.link);
wl_list_remove(&lock->unlock.link);
wl_list_remove(&lock->new_surface.link);
}
free(lock);
manager->lock = NULL;
}
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);
session_lock_destroy(lock);
desktop_focus_topmost_view(g_server);
struct session_lock_manager *manager =
wl_container_of(listener, manager, lock_unlock);
session_lock_destroy(manager);
manager->locked = false;
desktop_focus_topmost_view(manager->server);
}
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 };
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);
}
lock->abandoned = true;
wl_list_remove(&lock->destroy.link);
wl_list_remove(&lock->unlock.link);
wl_list_remove(&lock->new_surface.link);
wl_list_remove(&manager->lock_destroy.link);
wl_list_remove(&manager->lock_unlock.link);
wl_list_remove(&manager->lock_new_surface.link);
}
static void
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;
/* One already exists */
if (g_server->session_lock) {
if (g_server->session_lock->abandoned) {
wlr_log(WLR_INFO, "replacing abandoned lock");
session_lock_destroy(g_server->session_lock);
} else {
if (manager->lock) {
wlr_log(WLR_ERROR, "session already locked");
wlr_session_lock_v1_destroy(lock);
return;
}
if (manager->locked) {
wlr_log(WLR_INFO, "replacing abandoned lock");
session_lock_destroy(manager);
}
assert(wl_list_empty(&manager->session_lock_outputs));
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);
return;
}
wl_list_init(&session_lock->session_lock_outputs);
struct output *output;
wl_list_for_each(output, &g_server->outputs, link) {
session_lock_output_create(session_lock, output);
wl_list_for_each(output, &manager->server->outputs, link) {
session_lock_output_create(manager, output);
}
session_lock->new_surface.notify = handle_new_surface;
wl_signal_add(&lock->events.new_surface, &session_lock->new_surface);
manager->lock_new_surface.notify = handle_new_surface;
wl_signal_add(&lock->events.new_surface, &manager->lock_new_surface);
session_lock->unlock.notify = handle_unlock;
wl_signal_add(&lock->events.unlock, &session_lock->unlock);
manager->lock_unlock.notify = handle_lock_unlock;
wl_signal_add(&lock->events.unlock, &manager->lock_unlock);
session_lock->destroy.notify = handle_session_lock_destroy;
wl_signal_add(&lock->events.destroy, &session_lock->destroy);
manager->lock_destroy.notify = handle_lock_destroy;
wl_signal_add(&lock->events.destroy, &manager->lock_destroy);
manager->locked = true;
wlr_session_lock_v1_send_locked(lock);
g_server->session_lock = session_lock;
}
static void
handle_manager_destroy(struct wl_listener *listener, void *data)
{
if (g_server->session_lock) {
session_lock_destroy(g_server->session_lock);
}
wl_list_remove(&new_lock.link);
wl_list_remove(&manager_destroy.link);
wlr_session_lock_manager = NULL;
struct session_lock_manager *manager =
wl_container_of(listener, manager, destroy);
session_lock_destroy(manager);
wl_list_remove(&manager->new_lock.link);
wl_list_remove(&manager->destroy.link);
manager->server->session_lock_manager = NULL;
free(manager);
}
void
session_lock_init(struct server *server)
{
g_server = server;
wlr_session_lock_manager = wlr_session_lock_manager_v1_create(server->wl_display);
struct session_lock_manager *manager = znew(*manager);
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;
wl_signal_add(&wlr_session_lock_manager->events.new_lock, &new_lock);
manager->new_lock.notify = handle_new_session_lock;
wl_signal_add(&manager->wlr_manager->events.new_lock, &manager->new_lock);
manager_destroy.notify = handle_manager_destroy;
wl_signal_add(&wlr_session_lock_manager->events.destroy, &manager_destroy);
manager->destroy.notify = handle_manager_destroy;
wl_signal_add(&manager->wlr_manager->events.destroy, &manager->destroy);
}
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;
}
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);
}
struct session_lock *lock = g_server->session_lock;
struct session_lock_manager *manager = server->session_lock_manager;
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);
}
}