mirrors/cage
1
0
Fork 0
mirror of https://github.com/cage-kiosk/cage.git synced 2026-03-22 05:34:01 -04:00
Code Issues Projects Releases Packages Wiki Activity Actions

updates from PR comment

Browse source
This commit is contained in:
Troye Stonich 2026-02-14 19:58:03 -05:00
parent c050f2484c
commit 25e4d1938b
2 changed files with 464 additions and 464 deletions
Download patch file Download diff file Expand all files Collapse all files

4
meson.build
View file

@ -41,10 +41,6 @@ wayland_server = dependency('wayland-server')
xkbcommon = dependency('xkbcommon') xkbcommon = dependency('xkbcommon')
math = cc.find_library('m') math = cc.find_library('m')
# Add wlroots protocol directory to include path
wlroots_incdir = wlroots.get_variable('includedir', default_value: '/usr/local/include')
add_project_arguments('-I' + wlroots_incdir + '/wlroots-0.19/protocol', language: 'c')
wl_protocol_dir = wayland_protos.get_variable('pkgdatadir') wl_protocol_dir = wayland_protos.get_variable('pkgdatadir')
wayland_scanner = find_program('wayland-scanner') wayland_scanner = find_program('wayland-scanner')
wayland_scanner_server = generator( wayland_scanner_server = generator(

924
output.c
View file

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