mirror of
https://gitlab.freedesktop.org/wlroots/wlroots.git
synced 2025-10-31 22:25:21 -04:00
Refactor out wlr_backend_state from wl/multi
This commit is contained in:
Drew DeVault
parent
e2386043f6
commit
81cd90297d
13 changed files with 233 additions and 230 deletions
|
|
@ -12,17 +12,17 @@
|
|||
#include "backend/wayland.h"
|
||||
|
||||
static int dispatch_events(int fd, uint32_t mask, void *data) {
|
||||
struct wlr_backend_state *state = data;
|
||||
struct wlr_wl_backend *backend = data;
|
||||
int count = 0;
|
||||
if (mask & WL_EVENT_READABLE) {
|
||||
count = wl_display_dispatch(state->remote_display);
|
||||
count = wl_display_dispatch(backend->remote_display);
|
||||
}
|
||||
if (mask & WL_EVENT_WRITABLE) {
|
||||
count = wl_display_flush(state->remote_display);
|
||||
count = wl_display_flush(backend->remote_display);
|
||||
}
|
||||
if (mask == 0) {
|
||||
count = wl_display_dispatch_pending(state->remote_display);
|
||||
wl_display_flush(state->remote_display);
|
||||
count = wl_display_dispatch_pending(backend->remote_display);
|
||||
wl_display_flush(backend->remote_display);
|
||||
}
|
||||
return count;
|
||||
}
|
||||
|
|
@ -32,73 +32,76 @@ static int dispatch_events(int fd, uint32_t mask, void *data) {
|
|||
* compositor and creates surfaces for each output, then registers globals on
|
||||
* the specified display.
|
||||
*/
|
||||
static bool wlr_wl_backend_init(struct wlr_backend_state* state) {
|
||||
static bool wlr_wl_backend_init(struct wlr_backend *_backend) {
|
||||
struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend;
|
||||
wlr_log(L_INFO, "Initializating wayland backend");
|
||||
|
||||
state->remote_display = wl_display_connect(NULL);
|
||||
if (!state->remote_display) {
|
||||
backend->remote_display = wl_display_connect(NULL);
|
||||
if (!backend->remote_display) {
|
||||
wlr_log_errno(L_ERROR, "Could not connect to remote display");
|
||||
return false;
|
||||
}
|
||||
|
||||
if (!(state->registry = wl_display_get_registry(state->remote_display))) {
|
||||
if (!(backend->registry = wl_display_get_registry(backend->remote_display))) {
|
||||
wlr_log_errno(L_ERROR, "Could not obtain reference to remote registry");
|
||||
return false;
|
||||
}
|
||||
|
||||
wlr_wl_registry_poll(state);
|
||||
if (!(state->compositor) || (!(state->shell))) {
|
||||
wlr_wl_registry_poll(backend);
|
||||
if (!(backend->compositor) || (!(backend->shell))) {
|
||||
wlr_log_errno(L_ERROR, "Could not obtain retrieve required globals");
|
||||
return false;
|
||||
}
|
||||
|
||||
wlr_egl_init(&state->egl, EGL_PLATFORM_WAYLAND_EXT, state->remote_display);
|
||||
wlr_egl_bind_display(&state->egl, state->local_display);
|
||||
wlr_egl_init(&backend->egl, EGL_PLATFORM_WAYLAND_EXT, backend->remote_display);
|
||||
wlr_egl_bind_display(&backend->egl, backend->local_display);
|
||||
|
||||
for (size_t i = 0; i < state->requested_outputs; ++i) {
|
||||
wlr_wl_output_create(state->backend);
|
||||
for (size_t i = 0; i < backend->requested_outputs; ++i) {
|
||||
wlr_wl_output_create(&backend->backend);
|
||||
}
|
||||
|
||||
struct wl_event_loop *loop = wl_display_get_event_loop(state->local_display);
|
||||
int fd = wl_display_get_fd(state->remote_display);
|
||||
struct wl_event_loop *loop = wl_display_get_event_loop(backend->local_display);
|
||||
int fd = wl_display_get_fd(backend->remote_display);
|
||||
int events = WL_EVENT_READABLE | WL_EVENT_ERROR |
|
||||
WL_EVENT_HANGUP | WL_EVENT_WRITABLE;
|
||||
state->remote_display_src = wl_event_loop_add_fd(loop, fd, events,
|
||||
dispatch_events, state);
|
||||
wl_event_source_check(state->remote_display_src);
|
||||
backend->remote_display_src = wl_event_loop_add_fd(loop, fd, events,
|
||||
dispatch_events, backend);
|
||||
wl_event_source_check(backend->remote_display_src);
|
||||
|
||||
return true;
|
||||
}
|
||||
|
||||
static void wlr_wl_backend_destroy(struct wlr_backend_state *state) {
|
||||
if (!state) {
|
||||
static void wlr_wl_backend_destroy(struct wlr_backend *_backend) {
|
||||
struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend;
|
||||
if (!_backend) {
|
||||
return;
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < state->outputs->length; ++i) {
|
||||
wlr_output_destroy(state->outputs->items[i]);
|
||||
for (size_t i = 0; i < backend->outputs->length; ++i) {
|
||||
wlr_output_destroy(backend->outputs->items[i]);
|
||||
}
|
||||
|
||||
for (size_t i = 0; i < state->devices->length; ++i) {
|
||||
wlr_input_device_destroy(state->devices->items[i]);
|
||||
for (size_t i = 0; i < backend->devices->length; ++i) {
|
||||
wlr_input_device_destroy(backend->devices->items[i]);
|
||||
}
|
||||
|
||||
list_free(state->devices);
|
||||
list_free(state->outputs);
|
||||
free(state->seatName);
|
||||
list_free(backend->devices);
|
||||
list_free(backend->outputs);
|
||||
free(backend->seat_name);
|
||||
|
||||
wlr_egl_free(&state->egl);
|
||||
if (state->seat) wl_seat_destroy(state->seat);
|
||||
if (state->shm) wl_shm_destroy(state->shm);
|
||||
if (state->shell) wl_shell_destroy(state->shell);
|
||||
if (state->compositor) wl_compositor_destroy(state->compositor);
|
||||
if (state->registry) wl_registry_destroy(state->registry);
|
||||
if (state->remote_display) wl_display_disconnect(state->remote_display);
|
||||
free(state);
|
||||
wlr_egl_free(&backend->egl);
|
||||
if (backend->seat) wl_seat_destroy(backend->seat);
|
||||
if (backend->shm) wl_shm_destroy(backend->shm);
|
||||
if (backend->shell) wl_shell_destroy(backend->shell);
|
||||
if (backend->compositor) wl_compositor_destroy(backend->compositor);
|
||||
if (backend->registry) wl_registry_destroy(backend->registry);
|
||||
if (backend->remote_display) wl_display_disconnect(backend->remote_display);
|
||||
free(backend);
|
||||
}
|
||||
|
||||
static struct wlr_egl *wlr_wl_backend_get_egl(struct wlr_backend_state *state) {
|
||||
return &state->egl;
|
||||
static struct wlr_egl *wlr_wl_backend_get_egl(struct wlr_backend *_backend) {
|
||||
struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend;
|
||||
return &backend->egl;
|
||||
}
|
||||
|
||||
static struct wlr_backend_impl backend_impl = {
|
||||
|
|
@ -111,52 +114,45 @@ bool wlr_backend_is_wl(struct wlr_backend *b) {
|
|||
return b->impl == &backend_impl;
|
||||
}
|
||||
|
||||
struct wlr_output *wlr_wl_output_for_surface(struct wlr_backend_state *backend,
|
||||
struct wl_surface *surface) {
|
||||
struct wlr_output *wlr_wl_output_for_surface(struct wlr_wl_backend *backend,
|
||||
struct wl_surface *surface) {
|
||||
for (size_t i = 0; i < backend->outputs->length; ++i) {
|
||||
struct wlr_output *output = backend->outputs->items[i];
|
||||
if(output->state->surface == surface)
|
||||
if (output->state->surface == surface) {
|
||||
return output;
|
||||
}
|
||||
}
|
||||
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) {
|
||||
wlr_log(L_INFO, "Creating wayland backend");
|
||||
|
||||
struct wlr_backend_state *state = calloc(1, sizeof(struct wlr_backend_state));
|
||||
if (!state) {
|
||||
wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
|
||||
struct wlr_backend *backend = wlr_backend_create(&backend_impl, state);
|
||||
struct wlr_wl_backend *backend = calloc(1, sizeof(struct wlr_wl_backend));
|
||||
if (!backend) {
|
||||
wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
|
||||
return NULL;
|
||||
}
|
||||
wlr_backend_create(&backend->backend, &backend_impl);
|
||||
|
||||
if (!(state->devices = list_create())) {
|
||||
if (!(backend->devices = list_create())) {
|
||||
wlr_log(L_ERROR, "Could not allocate devices list");
|
||||
goto error;
|
||||
}
|
||||
|
||||
if (!(state->outputs = list_create())) {
|
||||
if (!(backend->outputs = list_create())) {
|
||||
wlr_log(L_ERROR, "Could not allocate outputs list");
|
||||
goto error;
|
||||
}
|
||||
|
||||
state->local_display = display;
|
||||
state->backend = backend;
|
||||
return backend;
|
||||
backend->local_display = display;
|
||||
return &backend->backend;
|
||||
|
||||
error:
|
||||
if (state) {
|
||||
list_free(state->devices);
|
||||
list_free(state->outputs);
|
||||
if (backend) {
|
||||
list_free(backend->devices);
|
||||
list_free(backend->outputs);
|
||||
}
|
||||
free(state);
|
||||
free(backend);
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -46,8 +46,10 @@ static void wlr_wl_output_transform(struct wlr_output_state *output,
|
|||
}
|
||||
|
||||
static void wlr_wl_output_destroy(struct wlr_output_state *output) {
|
||||
wl_signal_emit(&output->backend->backend->events.output_remove, output->wlr_output);
|
||||
if(output->frame_callback) wl_callback_destroy(output->frame_callback);
|
||||
wl_signal_emit(&output->backend->backend.events.output_remove, output->wlr_output);
|
||||
if (output->frame_callback) {
|
||||
wl_callback_destroy(output->frame_callback);
|
||||
}
|
||||
eglDestroySurface(output->backend->egl.display, output->surface);
|
||||
wl_egl_window_destroy(output->egl_window);
|
||||
wl_shell_surface_destroy(output->shell_surface);
|
||||
|
|
@ -92,7 +94,7 @@ static struct wl_shell_surface_listener shell_surface_listener = {
|
|||
|
||||
struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
|
||||
assert(wlr_backend_is_wl(_backend));
|
||||
struct wlr_backend_state *backend = _backend->state;
|
||||
struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend;
|
||||
if (!backend->remote_display) {
|
||||
++backend->requested_outputs;
|
||||
return NULL;
|
||||
|
|
@ -158,6 +160,6 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
|
|||
|
||||
wlr_output_create_global(wlr_output, backend->local_display);
|
||||
list_add(backend->outputs, wlr_output);
|
||||
wl_signal_emit(&backend->backend->events.output_add, wlr_output);
|
||||
wl_signal_emit(&backend->backend.events.output_add, wlr_output);
|
||||
return wlr_output;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -7,22 +7,22 @@
|
|||
|
||||
static void registry_global(void *data, struct wl_registry *registry,
|
||||
uint32_t name, const char *interface, uint32_t version) {
|
||||
struct wlr_backend_state *state = data;
|
||||
struct wlr_wl_backend *backend = data;
|
||||
wlr_log(L_DEBUG, "Remote wayland global: %s v%d", interface, version);
|
||||
|
||||
if (strcmp(interface, wl_compositor_interface.name) == 0) {
|
||||
state->compositor = wl_registry_bind(registry, name,
|
||||
backend->compositor = wl_registry_bind(registry, name,
|
||||
&wl_compositor_interface, version);
|
||||
} else if (strcmp(interface, wl_shell_interface.name) == 0) {
|
||||
state->shell = wl_registry_bind(registry, name,
|
||||
backend->shell = wl_registry_bind(registry, name,
|
||||
&wl_shell_interface, version);
|
||||
} else if (strcmp(interface, wl_shm_interface.name) == 0) {
|
||||
state->shm = wl_registry_bind(registry, name,
|
||||
backend->shm = wl_registry_bind(registry, name,
|
||||
&wl_shm_interface, version);
|
||||
} else if (strcmp(interface, wl_seat_interface.name) == 0) {
|
||||
state->seat = wl_registry_bind(registry, name,
|
||||
backend->seat = wl_registry_bind(registry, name,
|
||||
&wl_seat_interface, version);
|
||||
wl_seat_add_listener(state->seat, &seat_listener, state);
|
||||
wl_seat_add_listener(backend->seat, &seat_listener, backend);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -36,8 +36,8 @@ static const struct wl_registry_listener registry_listener = {
|
|||
.global_remove = registry_global_remove
|
||||
};
|
||||
|
||||
void wlr_wl_registry_poll(struct wlr_backend_state *state) {
|
||||
wl_registry_add_listener(state->registry, ®istry_listener, state);
|
||||
wl_display_dispatch(state->remote_display);
|
||||
wl_display_roundtrip(state->remote_display);
|
||||
void wlr_wl_registry_poll(struct wlr_wl_backend *backend) {
|
||||
wl_registry_add_listener(backend->registry, ®istry_listener, backend);
|
||||
wl_display_dispatch(backend->remote_display);
|
||||
wl_display_roundtrip(backend->remote_display);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -169,7 +169,7 @@ static struct wl_keyboard_listener keyboard_listener = {
|
|||
};
|
||||
|
||||
static void input_device_destroy(struct wlr_input_device_state *state) {
|
||||
wl_signal_emit(&state->backend->backend->events.input_remove, state->wlr_device);
|
||||
wl_signal_emit(&state->backend->backend.events.input_remove, state->wlr_device);
|
||||
if (state->resource)
|
||||
wl_proxy_destroy(state->resource);
|
||||
free(state);
|
||||
|
|
@ -187,7 +187,7 @@ static struct wlr_pointer_impl pointer_impl = {
|
|||
.destroy = pointer_destroy
|
||||
};
|
||||
|
||||
static struct wlr_input_device *allocate_device(struct wlr_backend_state *state,
|
||||
static struct wlr_input_device *allocate_device(struct wlr_wl_backend *backend,
|
||||
enum wlr_input_device_type type) {
|
||||
struct wlr_input_device_state *devstate;
|
||||
if (!(devstate = calloc(1, sizeof(struct wlr_input_device_state)))) {
|
||||
|
|
@ -195,7 +195,7 @@ static struct wlr_input_device *allocate_device(struct wlr_backend_state *state,
|
|||
return NULL;
|
||||
}
|
||||
|
||||
devstate->backend = state;
|
||||
devstate->backend = backend;
|
||||
|
||||
int vendor = 0;
|
||||
int product = 0;
|
||||
|
|
@ -208,14 +208,14 @@ static struct wlr_input_device *allocate_device(struct wlr_backend_state *state,
|
|||
return NULL;
|
||||
}
|
||||
devstate->wlr_device = wlr_device;
|
||||
list_add(state->devices, wlr_device);
|
||||
list_add(backend->devices, wlr_device);
|
||||
return wlr_device;
|
||||
}
|
||||
|
||||
static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
|
||||
enum wl_seat_capability caps) {
|
||||
struct wlr_backend_state *state = data;
|
||||
assert(state->seat == wl_seat);
|
||||
struct wlr_wl_backend *backend = data;
|
||||
assert(backend->seat == wl_seat);
|
||||
|
||||
if ((caps & WL_SEAT_CAPABILITY_POINTER)) {
|
||||
wlr_log(L_DEBUG, "seat %p offered pointer", (void*) wl_seat);
|
||||
|
|
@ -226,7 +226,7 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
|
|||
}
|
||||
|
||||
struct wlr_input_device *wlr_device;
|
||||
if (!(wlr_device = allocate_device(state, WLR_INPUT_DEVICE_POINTER))) {
|
||||
if (!(wlr_device = allocate_device(backend, WLR_INPUT_DEVICE_POINTER))) {
|
||||
free(pointer_state);
|
||||
wlr_log(L_ERROR, "Unable to allocate wlr_device for pointer");
|
||||
return;
|
||||
|
|
@ -236,11 +236,11 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
|
|||
wl_pointer_add_listener(wl_pointer, &pointer_listener, wlr_device);
|
||||
wlr_device->pointer = wlr_pointer_create(&pointer_impl, pointer_state);
|
||||
wlr_device->state->resource = wl_pointer;
|
||||
wl_signal_emit(&state->backend->events.input_add, wlr_device);
|
||||
wl_signal_emit(&backend->backend.events.input_add, wlr_device);
|
||||
}
|
||||
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD)) {
|
||||
wlr_log(L_DEBUG, "seat %p offered keyboard", (void*) wl_seat);
|
||||
struct wlr_input_device *wlr_device = allocate_device(state,
|
||||
struct wlr_input_device *wlr_device = allocate_device(backend,
|
||||
WLR_INPUT_DEVICE_KEYBOARD);
|
||||
if (!wlr_device) {
|
||||
wlr_log(L_ERROR, "Unable to allocate wl_pointer device");
|
||||
|
|
@ -251,15 +251,16 @@ static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
|
|||
wl_keyboard_add_listener(wl_keyboard, &keyboard_listener, wlr_device);
|
||||
wlr_device->keyboard = wlr_keyboard_create(NULL, NULL);
|
||||
wlr_device->state->resource = wl_keyboard;
|
||||
wl_signal_emit(&state->backend->events.input_add, wlr_device);
|
||||
wl_signal_emit(&backend->backend.events.input_add, wlr_device);
|
||||
}
|
||||
}
|
||||
|
||||
static void seat_handle_name(void *data, struct wl_seat *wl_seat, const char *name) {
|
||||
struct wlr_backend_state *state = data;
|
||||
assert(state->seat == wl_seat);
|
||||
struct wlr_wl_backend *backend = data;
|
||||
assert(backend->seat == wl_seat);
|
||||
// Do we need to check if seatName was previously set for name change?
|
||||
state->seatName = strdup(name);
|
||||
free(backend->seat_name);
|
||||
backend->seat_name = strdup(name);
|
||||
}
|
||||
|
||||
const struct wl_seat_listener seat_listener = {
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue