mirrors/cage
1
0
Fork 0
mirror of https://github.com/cage-kiosk/cage.git synced 2026-03-29 07:58:14 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

Merge 25e4d1938b into dcd64ae48b

Browse source
This commit is contained in:
Troye Stonich 2026-02-15 00:58:13 +00:00 • committed by GitHub
commit ff95df0822
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
4 changed files with 479 additions and 432 deletions
Download patch file Download diff file Expand all files Collapse all files

11
cage.c
View file

@ -31,6 +31,7 @@
#include <wlr/types/wlr_idle_notify_v1.h> #include <wlr/types/wlr_idle_notify_v1.h>
#include <wlr/types/wlr_output_layout.h> #include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_output_management_v1.h> #include <wlr/types/wlr_output_management_v1.h>
#include <wlr/types/wlr_output_power_management_v1.h>
#include <wlr/types/wlr_presentation_time.h> #include <wlr/types/wlr_presentation_time.h>
#include <wlr/types/wlr_primary_selection_v1.h> #include <wlr/types/wlr_primary_selection_v1.h>
#include <wlr/types/wlr_relative_pointer_v1.h> #include <wlr/types/wlr_relative_pointer_v1.h>
@ -511,6 +512,15 @@ main(int argc, char *argv[])
server.output_manager_test.notify = handle_output_manager_test; server.output_manager_test.notify = handle_output_manager_test;
wl_signal_add(&server.output_manager_v1->events.test, &server.output_manager_test); wl_signal_add(&server.output_manager_v1->events.test, &server.output_manager_test);
server.output_power_manager_v1 = wlr_output_power_manager_v1_create(server.wl_display);
if (!server.output_power_manager_v1) {
wlr_log(WLR_ERROR, "Unable to create output power manager");
ret = 1;
goto end;
}
server.output_power_manager_set_mode.notify = handle_output_power_manager_set_mode;
wl_signal_add(&server.output_power_manager_v1->events.set_mode, &server.output_power_manager_set_mode);
#if WLR_HAS_DRM_BACKEND #if WLR_HAS_DRM_BACKEND
server.drm_lease_v1 = wlr_drm_lease_v1_manager_create(server.wl_display, server.backend); server.drm_lease_v1 = wlr_drm_lease_v1_manager_create(server.wl_display, server.backend);
if (server.drm_lease_v1) { if (server.drm_lease_v1) {
@ -643,6 +653,7 @@ main(int argc, char *argv[])
#endif #endif
wl_list_remove(&server.new_virtual_pointer.link); wl_list_remove(&server.new_virtual_pointer.link);
wl_list_remove(&server.new_virtual_keyboard.link); wl_list_remove(&server.new_virtual_keyboard.link);
wl_list_remove(&server.output_power_manager_set_mode.link);
wl_list_remove(&server.output_manager_apply.link); wl_list_remove(&server.output_manager_apply.link);
wl_list_remove(&server.output_manager_test.link); wl_list_remove(&server.output_manager_test.link);
wl_list_remove(&server.xdg_toplevel_decoration.link); wl_list_remove(&server.xdg_toplevel_decoration.link);

896
output.c
View file

@ -1,432 +1,464 @@
/* /*
* Cage: A Wayland kiosk. * Cage: A Wayland kiosk.
* *
* Copyright (C) 2018-2021 Jente Hidskes * Copyright (C) 2018-2021 Jente Hidskes
* Copyright (C) 2019 The Sway authors * Copyright (C) 2019 The Sway authors
* *
* See the LICENSE file accompanying this file. * See the LICENSE file accompanying this file.
*/ */
#define _POSIX_C_SOURCE 200112L #define _POSIX_C_SOURCE 200112L
#include "config.h" #include "config.h"
#include <assert.h> #include <assert.h>
#include <stdlib.h> #include <stdlib.h>
#include <unistd.h> #include <unistd.h>
#include <wayland-server-core.h> #include <wayland-server-core.h>
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/backend/wayland.h> #include <wlr/backend/wayland.h>
#include <wlr/config.h> #include <wlr/config.h>
#if WLR_HAS_X11_BACKEND #if WLR_HAS_X11_BACKEND
#include <wlr/backend/x11.h> #include <wlr/backend/x11.h>
#endif #endif
#include <wlr/render/swapchain.h> #include <wlr/render/swapchain.h>
#include <wlr/render/wlr_renderer.h> #include <wlr/render/wlr_renderer.h>
#include <wlr/types/wlr_compositor.h> #include <wlr/types/wlr_compositor.h>
#include <wlr/types/wlr_data_device.h> #include <wlr/types/wlr_data_device.h>
#include <wlr/types/wlr_output.h> #include <wlr/types/wlr_output.h>
#include <wlr/types/wlr_output_layout.h> #include <wlr/types/wlr_output_layout.h>
#include <wlr/types/wlr_output_management_v1.h> #include <wlr/types/wlr_output_management_v1.h>
#include <wlr/types/wlr_output_swapchain_manager.h> #include <wlr/types/wlr_output_power_management_v1.h>
#include <wlr/types/wlr_scene.h> #include <wlr/types/wlr_output_swapchain_manager.h>
#include <wlr/types/wlr_xdg_shell.h> #include <wlr/types/wlr_scene.h>
#include <wlr/util/log.h> #include <wlr/types/wlr_xdg_shell.h>
#include <wlr/util/region.h> #include <wlr/util/log.h>
#include <wlr/util/region.h>
#include "output.h"
#include "seat.h" #include "output.h"
#include "server.h" #include "seat.h"
#include "view.h" #include "server.h"
#if CAGE_HAS_XWAYLAND #include "view.h"
#include "xwayland.h" #if CAGE_HAS_XWAYLAND
#endif #include "xwayland.h"
#endif
#define OUTPUT_CONFIG_UPDATED \
(WLR_OUTPUT_STATE_ENABLED | WLR_OUTPUT_STATE_MODE | WLR_OUTPUT_STATE_SCALE | WLR_OUTPUT_STATE_TRANSFORM | \ #define OUTPUT_CONFIG_UPDATED \
WLR_OUTPUT_STATE_ADAPTIVE_SYNC_ENABLED) (WLR_OUTPUT_STATE_ENABLED | WLR_OUTPUT_STATE_MODE | WLR_OUTPUT_STATE_SCALE | WLR_OUTPUT_STATE_TRANSFORM | \
WLR_OUTPUT_STATE_ADAPTIVE_SYNC_ENABLED)
static void
update_output_manager_config(struct cg_server *server) static void
{ update_output_manager_config(struct cg_server *server)
struct wlr_output_configuration_v1 *config = wlr_output_configuration_v1_create(); {
struct wlr_output_configuration_v1 *config = wlr_output_configuration_v1_create();
struct cg_output *output;
wl_list_for_each (output, &server->outputs, link) { struct cg_output *output;
struct wlr_output *wlr_output = output->wlr_output; wl_list_for_each (output, &server->outputs, link) {
struct wlr_output_configuration_head_v1 *config_head = struct wlr_output *wlr_output = output->wlr_output;
wlr_output_configuration_head_v1_create(config, wlr_output); struct wlr_output_configuration_head_v1 *config_head =
struct wlr_box output_box; wlr_output_configuration_head_v1_create(config, wlr_output);
struct wlr_box output_box;
wlr_output_layout_get_box(server->output_layout, wlr_output, &output_box);
if (!wlr_box_empty(&output_box)) { bool in_layout = wlr_output_layout_get(server->output_layout, wlr_output) != NULL;
config_head->state.x = output_box.x; config_head->state.enabled = in_layout;
config_head->state.y = output_box.y;
} if (in_layout) {
} wlr_output_layout_get_box(server->output_layout, wlr_output, &output_box);
if (!wlr_box_empty(&output_box)) {
wlr_output_manager_v1_set_configuration(server->output_manager_v1, config); config_head->state.x = output_box.x;
} config_head->state.y = output_box.y;
}
static inline void }
output_layout_add_auto(struct cg_output *output) }
{
assert(output->scene_output != NULL); wlr_output_manager_v1_set_configuration(server->output_manager_v1, config);
struct wlr_output_layout_output *layout_output = }
wlr_output_layout_add_auto(output->server->output_layout, output->wlr_output);
wlr_scene_output_layout_add_output(output->server->scene_output_layout, layout_output, output->scene_output); static inline void
} output_layout_add_auto(struct cg_output *output)
{
static inline void assert(output->scene_output != NULL);
output_layout_add(struct cg_output *output, int32_t x, int32_t y) struct wlr_output_layout_output *layout_output =
{ wlr_output_layout_add_auto(output->server->output_layout, output->wlr_output);
assert(output->scene_output != NULL); wlr_scene_output_layout_add_output(output->server->scene_output_layout, layout_output, output->scene_output);
bool exists = wlr_output_layout_get(output->server->output_layout, output->wlr_output); }
struct wlr_output_layout_output *layout_output =
wlr_output_layout_add(output->server->output_layout, output->wlr_output, x, y); static inline void
if (exists) { output_layout_add(struct cg_output *output, int32_t x, int32_t y)
return; {
} assert(output->scene_output != NULL);
wlr_scene_output_layout_add_output(output->server->scene_output_layout, layout_output, output->scene_output); bool exists = wlr_output_layout_get(output->server->output_layout, output->wlr_output);
} struct wlr_output_layout_output *layout_output =
wlr_output_layout_add(output->server->output_layout, output->wlr_output, x, y);
static inline void if (exists) {
output_layout_remove(struct cg_output *output) return;
{ }
wlr_output_layout_remove(output->server->output_layout, output->wlr_output); wlr_scene_output_layout_add_output(output->server->scene_output_layout, layout_output, output->scene_output);
} }
static void static inline void
output_enable(struct cg_output *output) output_layout_remove(struct cg_output *output)
{ {
struct wlr_output *wlr_output = output->wlr_output; wlr_output_layout_remove(output->server->output_layout, output->wlr_output);
}
/* Outputs get enabled by the backend before firing the new_output event,
* so we can't do a check for already enabled outputs here unless we static void
* duplicate the enabled property in cg_output. */ output_enable(struct cg_output *output)
wlr_log(WLR_DEBUG, "Enabling output %s", wlr_output->name); {
struct wlr_output *wlr_output = output->wlr_output;
struct wlr_output_state state = {0};
wlr_output_state_set_enabled(&state, true); /* Outputs get enabled by the backend before firing the new_output event,
* so we can't do a check for already enabled outputs here unless we
if (wlr_output_commit_state(wlr_output, &state)) { * duplicate the enabled property in cg_output. */
output_layout_add_auto(output); wlr_log(WLR_DEBUG, "Enabling output %s", wlr_output->name);
}
struct wlr_output_state state = {0};
update_output_manager_config(output->server); wlr_output_state_set_enabled(&state, true);
}
if (wlr_output_commit_state(wlr_output, &state)) {
static void output_layout_add_auto(output);
output_disable(struct cg_output *output) }
{
struct wlr_output *wlr_output = output->wlr_output; update_output_manager_config(output->server);
if (!wlr_output->enabled) { }
wlr_log(WLR_DEBUG, "Not disabling already disabled output %s", wlr_output->name);
return; static void
} output_disable(struct cg_output *output)
{
wlr_log(WLR_DEBUG, "Disabling output %s", wlr_output->name); struct wlr_output *wlr_output = output->wlr_output;
struct wlr_output_state state = {0}; if (!wlr_output->enabled) {
wlr_output_state_set_enabled(&state, false); wlr_log(WLR_DEBUG, "Not disabling already disabled output %s", wlr_output->name);
wlr_output_commit_state(wlr_output, &state); return;
output_layout_remove(output); }
}
wlr_log(WLR_DEBUG, "Disabling output %s", wlr_output->name);
static void struct wlr_output_state state = {0};
handle_output_frame(struct wl_listener *listener, void *data) wlr_output_state_set_enabled(&state, false);
{ wlr_output_commit_state(wlr_output, &state);
struct cg_output *output = wl_container_of(listener, output, frame); output_layout_remove(output);
}
if (!output->wlr_output->enabled || !output->scene_output) {
return; static void
} handle_output_frame(struct wl_listener *listener, void *data)
{
wlr_scene_output_commit(output->scene_output, NULL); struct cg_output *output = wl_container_of(listener, output, frame);
struct timespec now = {0}; if (!output->wlr_output->enabled || !output->scene_output) {
clock_gettime(CLOCK_MONOTONIC, &now); return;
wlr_scene_output_send_frame_done(output->scene_output, &now); }
}
wlr_scene_output_commit(output->scene_output, NULL);
static void
handle_output_commit(struct wl_listener *listener, void *data) struct timespec now = {0};
{ clock_gettime(CLOCK_MONOTONIC, &now);
struct cg_output *output = wl_container_of(listener, output, commit); wlr_scene_output_send_frame_done(output->scene_output, &now);
struct wlr_output_event_commit *event = data; }
/* Notes: static void
* - output layout change will also be called if needed to position the views handle_output_commit(struct wl_listener *listener, void *data)
* - always update output manager configuration even if the output is now disabled */ {
struct cg_output *output = wl_container_of(listener, output, commit);
if (event->state->committed & OUTPUT_CONFIG_UPDATED) { struct wlr_output_event_commit *event = data;
update_output_manager_config(output->server);
} /* Notes:
} * - output layout change will also be called if needed to position the views
* - always update output manager configuration even if the output is now disabled */
static void
handle_output_request_state(struct wl_listener *listener, void *data) if (event->state->committed & OUTPUT_CONFIG_UPDATED) {
{ update_output_manager_config(output->server);
struct cg_output *output = wl_container_of(listener, output, request_state); }
struct wlr_output_event_request_state *event = data; }
if (wlr_output_commit_state(output->wlr_output, event->state)) { static void
update_output_manager_config(output->server); handle_output_request_state(struct wl_listener *listener, void *data)
} {
} struct cg_output *output = wl_container_of(listener, output, request_state);
struct wlr_output_event_request_state *event = data;
void
handle_output_layout_change(struct wl_listener *listener, void *data) if (wlr_output_commit_state(output->wlr_output, event->state)) {
{ update_output_manager_config(output->server);
struct cg_server *server = wl_container_of(listener, server, output_layout_change); }
}
view_position_all(server);
update_output_manager_config(server); void
} handle_output_layout_change(struct wl_listener *listener, void *data)
{
static bool struct cg_server *server = wl_container_of(listener, server, output_layout_change);
is_nested_output(struct cg_output *output)
{ view_position_all(server);
if (wlr_output_is_wl(output->wlr_output)) { update_output_manager_config(server);
return true; }
}
#if WLR_HAS_X11_BACKEND static bool
if (wlr_output_is_x11(output->wlr_output)) { is_nested_output(struct cg_output *output)
return true; {
} if (wlr_output_is_wl(output->wlr_output)) {
#endif return true;
return false; }
} #if WLR_HAS_X11_BACKEND
if (wlr_output_is_x11(output->wlr_output)) {
static void return true;
output_destroy(struct cg_output *output) }
{ #endif
struct cg_server *server = output->server; return false;
bool was_nested_output = is_nested_output(output); }
output->wlr_output->data = NULL; static void
output_destroy(struct cg_output *output)
wl_list_remove(&output->destroy.link); {
wl_list_remove(&output->commit.link); struct cg_server *server = output->server;
wl_list_remove(&output->request_state.link); bool was_nested_output = is_nested_output(output);
wl_list_remove(&output->frame.link);
wl_list_remove(&output->link); output->wlr_output->data = NULL;
output_layout_remove(output); wl_list_remove(&output->destroy.link);
wl_list_remove(&output->commit.link);
free(output); wl_list_remove(&output->request_state.link);
wl_list_remove(&output->frame.link);
if (wl_list_empty(&server->outputs) && was_nested_output) { wl_list_remove(&output->link);
server_terminate(server);
} else if (server->output_mode == CAGE_MULTI_OUTPUT_MODE_LAST && !wl_list_empty(&server->outputs)) { output_layout_remove(output);
struct cg_output *prev = wl_container_of(server->outputs.next, prev, link);
output_enable(prev); free(output);
view_position_all(server);
} if (wl_list_empty(&server->outputs) && was_nested_output) {
} server_terminate(server);
} else if (server->output_mode == CAGE_MULTI_OUTPUT_MODE_LAST && !wl_list_empty(&server->outputs)) {
static void struct cg_output *prev = wl_container_of(server->outputs.next, prev, link);
handle_output_destroy(struct wl_listener *listener, void *data) output_enable(prev);
{ view_position_all(server);
struct cg_output *output = wl_container_of(listener, output, destroy); }
output_destroy(output); }
}
static void
void handle_output_destroy(struct wl_listener *listener, void *data)
handle_new_output(struct wl_listener *listener, void *data) {
{ struct cg_output *output = wl_container_of(listener, output, destroy);
struct cg_server *server = wl_container_of(listener, server, new_output); output_destroy(output);
struct wlr_output *wlr_output = data; }
if (wlr_output->non_desktop) { void
wlr_log(WLR_DEBUG, "Not configuring non-desktop output: %s", wlr_output->name); handle_new_output(struct wl_listener *listener, void *data)
#if WLR_HAS_DRM_BACKEND {
if (server->drm_lease_v1) { struct cg_server *server = wl_container_of(listener, server, new_output);
wlr_drm_lease_v1_manager_offer_output(server->drm_lease_v1, wlr_output); struct wlr_output *wlr_output = data;
}
#endif if (wlr_output->non_desktop) {
return; wlr_log(WLR_DEBUG, "Not configuring non-desktop output: %s", wlr_output->name);
} #if WLR_HAS_DRM_BACKEND
if (server->drm_lease_v1) {
if (!wlr_output_init_render(wlr_output, server->allocator, server->renderer)) { wlr_drm_lease_v1_manager_offer_output(server->drm_lease_v1, wlr_output);
wlr_log(WLR_ERROR, "Failed to initialize output rendering"); }
return; #endif
} return;
}
struct cg_output *output = calloc(1, sizeof(struct cg_output));
if (!output) { if (!wlr_output_init_render(wlr_output, server->allocator, server->renderer)) {
wlr_log(WLR_ERROR, "Failed to allocate output"); wlr_log(WLR_ERROR, "Failed to initialize output rendering");
return; return;
} }
output->wlr_output = wlr_output; struct cg_output *output = calloc(1, sizeof(struct cg_output));
wlr_output->data = output; if (!output) {
output->server = server; wlr_log(WLR_ERROR, "Failed to allocate output");
return;
wl_list_insert(&server->outputs, &output->link); }
output->commit.notify = handle_output_commit; output->wlr_output = wlr_output;
wl_signal_add(&wlr_output->events.commit, &output->commit); wlr_output->data = output;
output->request_state.notify = handle_output_request_state; output->server = server;
wl_signal_add(&wlr_output->events.request_state, &output->request_state);
output->destroy.notify = handle_output_destroy; wl_list_insert(&server->outputs, &output->link);
wl_signal_add(&wlr_output->events.destroy, &output->destroy);
output->frame.notify = handle_output_frame; output->commit.notify = handle_output_commit;
wl_signal_add(&wlr_output->events.frame, &output->frame); wl_signal_add(&wlr_output->events.commit, &output->commit);
output->request_state.notify = handle_output_request_state;
output->scene_output = wlr_scene_output_create(server->scene, wlr_output); wl_signal_add(&wlr_output->events.request_state, &output->request_state);
if (!output->scene_output) { output->destroy.notify = handle_output_destroy;
wlr_log(WLR_ERROR, "Failed to allocate scene output"); wl_signal_add(&wlr_output->events.destroy, &output->destroy);
return; output->frame.notify = handle_output_frame;
} wl_signal_add(&wlr_output->events.frame, &output->frame);
struct wlr_output_state state = {0}; output->scene_output = wlr_scene_output_create(server->scene, wlr_output);
wlr_output_state_set_enabled(&state, true); if (!output->scene_output) {
if (!wl_list_empty(&wlr_output->modes)) { wlr_log(WLR_ERROR, "Failed to allocate scene output");
struct wlr_output_mode *preferred_mode = wlr_output_preferred_mode(wlr_output); return;
if (preferred_mode) { }
wlr_output_state_set_mode(&state, preferred_mode);
} struct wlr_output_state state = {0};
if (!wlr_output_test_state(wlr_output, &state)) { wlr_output_state_set_enabled(&state, true);
struct wlr_output_mode *mode; if (!wl_list_empty(&wlr_output->modes)) {
wl_list_for_each (mode, &wlr_output->modes, link) { struct wlr_output_mode *preferred_mode = wlr_output_preferred_mode(wlr_output);
if (mode == preferred_mode) { if (preferred_mode) {
continue; wlr_output_state_set_mode(&state, preferred_mode);
} }
if (!wlr_output_test_state(wlr_output, &state)) {
wlr_output_state_set_mode(&state, mode); struct wlr_output_mode *mode;
if (wlr_output_test_state(wlr_output, &state)) { wl_list_for_each (mode, &wlr_output->modes, link) {
break; if (mode == preferred_mode) {
} continue;
} }
}
} wlr_output_state_set_mode(&state, mode);
if (wlr_output_test_state(wlr_output, &state)) {
if (server->output_mode == CAGE_MULTI_OUTPUT_MODE_LAST && wl_list_length(&server->outputs) > 1) { break;
struct cg_output *next = wl_container_of(output->link.next, next, link); }
output_disable(next); }
} }
}
if (!wlr_xcursor_manager_load(server->seat->xcursor_manager, wlr_output->scale)) {
wlr_log(WLR_ERROR, "Cannot load XCursor theme for output '%s' with scale %f", wlr_output->name, if (server->output_mode == CAGE_MULTI_OUTPUT_MODE_LAST && wl_list_length(&server->outputs) > 1) {
wlr_output->scale); struct cg_output *next = wl_container_of(output->link.next, next, link);
} output_disable(next);
}
wlr_log(WLR_DEBUG, "Enabling new output %s", wlr_output->name);
if (wlr_output_commit_state(wlr_output, &state)) { if (!wlr_xcursor_manager_load(server->seat->xcursor_manager, wlr_output->scale)) {
output_layout_add_auto(output); wlr_log(WLR_ERROR, "Cannot load XCursor theme for output '%s' with scale %f", wlr_output->name,
} wlr_output->scale);
}
view_position_all(output->server);
update_output_manager_config(output->server); wlr_log(WLR_DEBUG, "Enabling new output %s", wlr_output->name);
} if (wlr_output_commit_state(wlr_output, &state)) {
output_layout_add_auto(output);
void }
output_set_window_title(struct cg_output *output, const char *title)
{ view_position_all(output->server);
struct wlr_output *wlr_output = output->wlr_output; update_output_manager_config(output->server);
}
if (!wlr_output->enabled) {
wlr_log(WLR_DEBUG, "Not setting window title for disabled output %s", wlr_output->name); void
return; output_set_window_title(struct cg_output *output, const char *title)
} {
struct wlr_output *wlr_output = output->wlr_output;
if (wlr_output_is_wl(wlr_output)) {
wlr_wl_output_set_title(wlr_output, title); if (!wlr_output->enabled) {
#if WLR_HAS_X11_BACKEND wlr_log(WLR_DEBUG, "Not setting window title for disabled output %s", wlr_output->name);
} else if (wlr_output_is_x11(wlr_output)) { return;
wlr_x11_output_set_title(wlr_output, title); }
#endif
} if (wlr_output_is_wl(wlr_output)) {
} wlr_wl_output_set_title(wlr_output, title);
#if WLR_HAS_X11_BACKEND
static bool } else if (wlr_output_is_x11(wlr_output)) {
output_config_apply(struct cg_server *server, struct wlr_output_configuration_v1 *config, bool test_only) wlr_x11_output_set_title(wlr_output, title);
{ #endif
bool ok = false; }
}
size_t states_len;
struct wlr_backend_output_state *states = wlr_output_configuration_v1_build_state(config, &states_len); static bool
if (states == NULL) { output_config_apply(struct cg_server *server, struct wlr_output_configuration_v1 *config, bool test_only)
return false; {
} bool ok = false;
struct wlr_output_swapchain_manager swapchain_manager; size_t states_len;
wlr_output_swapchain_manager_init(&swapchain_manager, server->backend); struct wlr_backend_output_state *states = wlr_output_configuration_v1_build_state(config, &states_len);
if (states == NULL) {
ok = wlr_output_swapchain_manager_prepare(&swapchain_manager, states, states_len); return false;
if (!ok || test_only) { }
goto out;
} struct wlr_output_swapchain_manager swapchain_manager;
wlr_output_swapchain_manager_init(&swapchain_manager, server->backend);
for (size_t i = 0; i < states_len; i++) {
struct wlr_backend_output_state *backend_state = &states[i]; ok = wlr_output_swapchain_manager_prepare(&swapchain_manager, states, states_len);
struct cg_output *output = backend_state->output->data; if (!ok || test_only) {
goto out;
struct wlr_swapchain *swapchain = }
wlr_output_swapchain_manager_get_swapchain(&swapchain_manager, backend_state->output);
struct wlr_scene_output_state_options options = { for (size_t i = 0; i < states_len; i++) {
.swapchain = swapchain, struct wlr_backend_output_state *backend_state = &states[i];
}; struct cg_output *output = backend_state->output->data;
struct wlr_output_state *state = &backend_state->base;
if (!wlr_scene_output_build_state(output->scene_output, state, &options)) { struct wlr_swapchain *swapchain =
ok = false; wlr_output_swapchain_manager_get_swapchain(&swapchain_manager, backend_state->output);
goto out; struct wlr_scene_output_state_options options = {
} .swapchain = swapchain,
} };
struct wlr_output_state *state = &backend_state->base;
ok = wlr_backend_commit(server->backend, states, states_len); if (!wlr_scene_output_build_state(output->scene_output, state, &options)) {
if (!ok) { ok = false;
goto out; goto out;
} }
}
wlr_output_swapchain_manager_apply(&swapchain_manager);
ok = wlr_backend_commit(server->backend, states, states_len);
struct wlr_output_configuration_head_v1 *head; if (!ok) {
wl_list_for_each (head, &config->heads, link) { goto out;
struct cg_output *output = head->state.output->data; }
if (head->state.enabled) { wlr_output_swapchain_manager_apply(&swapchain_manager);
output_layout_add(output, head->state.x, head->state.y);
} else { struct wlr_output_configuration_head_v1 *head;
output_layout_remove(output); wl_list_for_each (head, &config->heads, link) {
} struct cg_output *output = head->state.output->data;
}
if (head->state.enabled) {
out: output_layout_add(output, head->state.x, head->state.y);
wlr_output_swapchain_manager_finish(&swapchain_manager); } else {
for (size_t i = 0; i < states_len; i++) { output_layout_remove(output);
wlr_output_state_finish(&states[i].base); }
} }
free(states);
return ok; out:
} wlr_output_swapchain_manager_finish(&swapchain_manager);
for (size_t i = 0; i < states_len; i++) {
void wlr_output_state_finish(&states[i].base);
handle_output_manager_apply(struct wl_listener *listener, void *data) }
{ free(states);
struct cg_server *server = wl_container_of(listener, server, output_manager_apply); return ok;
struct wlr_output_configuration_v1 *config = data; }
if (output_config_apply(server, config, false)) { void
wlr_output_configuration_v1_send_succeeded(config); handle_output_manager_apply(struct wl_listener *listener, void *data)
} else { {
wlr_output_configuration_v1_send_failed(config); struct cg_server *server = wl_container_of(listener, server, output_manager_apply);
} struct wlr_output_configuration_v1 *config = data;
wlr_output_configuration_v1_destroy(config); if (output_config_apply(server, config, false)) {
} wlr_output_configuration_v1_send_succeeded(config);
} else {
void wlr_output_configuration_v1_send_failed(config);
handle_output_manager_test(struct wl_listener *listener, void *data) }
{
struct cg_server *server = wl_container_of(listener, server, output_manager_test); wlr_output_configuration_v1_destroy(config);
struct wlr_output_configuration_v1 *config = data; }
if (output_config_apply(server, config, true)) { void
wlr_output_configuration_v1_send_succeeded(config); handle_output_manager_test(struct wl_listener *listener, void *data)
} else { {
wlr_output_configuration_v1_send_failed(config); struct cg_server *server = wl_container_of(listener, server, output_manager_test);
} struct wlr_output_configuration_v1 *config = data;
wlr_output_configuration_v1_destroy(config); if (output_config_apply(server, config, true)) {
} wlr_output_configuration_v1_send_succeeded(config);
} else {
wlr_output_configuration_v1_send_failed(config);
}
wlr_output_configuration_v1_destroy(config);
}
void
handle_output_power_manager_set_mode(struct wl_listener *listener, void *data)
{
struct cg_server *server = wl_container_of(listener, server, output_power_manager_set_mode);
struct wlr_output_power_v1_set_mode_event *event = data;
struct cg_output *output = event->output->data;
if (!output) {
return;
}
struct wlr_output_state state = {0};
switch (event->mode) {
case ZWLR_OUTPUT_POWER_V1_MODE_OFF:
wlr_output_state_set_enabled(&state, false);
break;
case ZWLR_OUTPUT_POWER_V1_MODE_ON:
wlr_output_state_set_enabled(&state, true);
break;
}
wlr_output_commit_state(event->output, &state);
wlr_output_state_finish(&state);
}

1
output.h
View file

@ -22,6 +22,7 @@ struct cg_output {
void handle_output_manager_apply(struct wl_listener *listener, void *data); void handle_output_manager_apply(struct wl_listener *listener, void *data);
void handle_output_manager_test(struct wl_listener *listener, void *data); void handle_output_manager_test(struct wl_listener *listener, void *data);
void handle_output_power_manager_set_mode(struct wl_listener *listener, void *data);
void handle_output_layout_change(struct wl_listener *listener, void *data); void handle_output_layout_change(struct wl_listener *listener, void *data);
void handle_new_output(struct wl_listener *listener, void *data); void handle_new_output(struct wl_listener *listener, void *data);
void output_set_window_title(struct cg_output *output, const char *title); void output_set_window_title(struct cg_output *output, const char *title);

3
server.h
View file

@ -61,6 +61,9 @@ struct cg_server {
struct wl_listener output_manager_apply; struct wl_listener output_manager_apply;
struct wl_listener output_manager_test; struct wl_listener output_manager_test;
struct wlr_output_power_manager_v1 *output_power_manager_v1;
struct wl_listener output_power_manager_set_mode;
#if WLR_HAS_DRM_BACKEND #if WLR_HAS_DRM_BACKEND
struct wlr_drm_lease_v1_manager *drm_lease_v1; struct wlr_drm_lease_v1_manager *drm_lease_v1;
struct wl_listener drm_lease_request; struct wl_listener drm_lease_request;