session-lock: refactor

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

diff --git a/include/labwc.h b/include/labwc.h
index ed858e64fa573d8c83f186477b80909e4a0befd6..a47b3a39d08c0a686c1d00bb30e8c75850c67247 100644 (file)
--- a/include/labwc.h
+++ b/include/labwc.h
@@ -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;
 

diff --git a/include/session-lock.h b/include/session-lock.h
index d43003c72e70737ee7921c654cf8c6331c236140..0a11e7b4e4eb5d4034a2089145030f7f4d2ed315 100644 (file)
--- a/include/session-lock.h
+++ b/include/session-lock.h
@@ -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 */

diff --git a/src/input/keyboard.c b/src/input/keyboard.c
index 59761681476403906795d3c204665fd7a29b528f..1d1467cea4f1a7a0da2cd0741c31a8bde4e1319a 100644 (file)
--- a/src/input/keyboard.c
+++ b/src/input/keyboard.c
@@ -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;
        }
 

diff --git a/src/output.c b/src/output.c
index 67d8de7764667e71abaaa5cdb76259afd496f4a6..bb2b9760e79c4aaffca4cbda25d38d91cc4158db 100644 (file)
--- a/src/output.c
+++ b/src/output.c
@@ -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

diff --git a/src/seat.c b/src/seat.c
index 4ba5fa30f88c9b85cc985726883bd874555ae46f..e850694c1a8e15d78af4d09fe9592f7e75cbe598 100644 (file)
--- a/src/seat.c
+++ b/src/seat.c
@@ -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;
        }
 

diff --git a/src/session-lock.c b/src/session-lock.c
index ba0d407a519c204ba7f6a414b601f5f1cfcbeb2e..11f0c58701c8adbb37f9a9eda0b9830359fa2337 100644 (file)
--- a/src/session-lock.c
+++ b/src/session-lock.c
@@ -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 (!lock->abandoned) {
-               wl_list_remove(&lock->destroy.link);
-               wl_list_remove(&lock->unlock.link);
-               wl_list_remove(&lock->new_surface.link);
+       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);
        }
-       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 {
-                       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");
+       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));
 
-       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);
        }
 }