hyprwm/wlroots-hyprland
1
0
Fork 0
mirror of https://github.com/hyprwm/wlroots-hyprland.git synced 2024-12-23 02:19:49 +01:00
Code Issues Projects Releases Packages Wiki Activity

Refactor out wlr_backend_state from wl/multi

Browse source
This commit is contained in:
Drew DeVault 2017-08-12 11:43:36 -04:00
parent e2386043f6
commit 81cd90297d
13 changed files with 233 additions and 230 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

151
backend/backend.c
View file

@ -3,47 +3,45 @@
#include <stdlib.h> #include <stdlib.h>
#include <string.h> #include <string.h>
#include <errno.h> #include <errno.h>
#include <assert.h>
#include <libinput.h> #include <libinput.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
#include <wlr/backend/interface.h> #include <wlr/backend/interface.h>
#include <wlr/backend/drm.h> //#include <wlr/backend/drm.h>
#include <wlr/backend/libinput.h> //#include <wlr/backend/libinput.h>
#include <wlr/backend/wayland.h> #include <wlr/backend/wayland.h>
#include <wlr/backend/multi.h> //#include <wlr/backend/multi.h>
#include <wlr/util/log.h> #include <wlr/util/log.h>
#include "backend/libinput.h"
#include "backend/udev.h" #include "backend/udev.h"
struct wlr_backend *wlr_backend_create(const struct wlr_backend_impl *impl, void wlr_backend_create(struct wlr_backend *backend,
struct wlr_backend_state *state) { const struct wlr_backend_impl *impl) {
struct wlr_backend *backend = calloc(1, sizeof(struct wlr_backend)); assert(backend);
if (!backend) {
wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
return NULL;
}
backend->state = state;
backend->impl = impl; backend->impl = impl;
wl_signal_init(&backend->events.input_add); wl_signal_init(&backend->events.input_add);
wl_signal_init(&backend->events.input_remove); wl_signal_init(&backend->events.input_remove);
wl_signal_init(&backend->events.output_add); wl_signal_init(&backend->events.output_add);
wl_signal_init(&backend->events.output_remove); wl_signal_init(&backend->events.output_remove);
return backend;
} }
bool wlr_backend_init(struct wlr_backend *backend) { bool wlr_backend_init(struct wlr_backend *backend) {
return backend->impl->init(backend->state); if (backend->impl->init) {
return backend->impl->init(backend);
}
return true;
} }
void wlr_backend_destroy(struct wlr_backend *backend) { void wlr_backend_destroy(struct wlr_backend *backend) {
backend->impl->destroy(backend->state); if (backend->impl->destroy) {
free(backend); backend->impl->destroy(backend);
}
} }
struct wlr_egl *wlr_backend_get_egl(struct wlr_backend *backend) { struct wlr_egl *wlr_backend_get_egl(struct wlr_backend *backend) {
if (!backend->impl->get_egl) { if (backend->impl->get_egl) {
return NULL; return backend->impl->get_egl(backend);
} }
return backend->impl->get_egl(backend->state); return NULL;
} }
static struct wlr_backend *attempt_wl_backend(struct wl_display *display) { static struct wlr_backend *attempt_wl_backend(struct wl_display *display) {
@ -77,64 +75,65 @@ struct wlr_backend *wlr_backend_autocreate(struct wl_display *display) {
return backend; return backend;
} }
} }
if (getenv("DISPLAY")) {
wlr_log(L_ERROR, "X11 backend is not implemented"); // TODO
return NULL; return NULL;
}
// Attempt DRM+libinput // if (getenv("DISPLAY")) {
// wlr_log(L_ERROR, "X11 backend is not implemented"); // TODO
struct wlr_session *session = wlr_session_start(display); // return NULL;
if (!session) { // }
wlr_log(L_ERROR, "Failed to start a DRM session"); //
return NULL; // // Attempt DRM+libinput
} //
// struct wlr_session *session = wlr_session_start(display);
struct wlr_udev *udev = wlr_udev_create(display); // if (!session) {
if (!udev) { // wlr_log(L_ERROR, "Failed to start a DRM session");
wlr_log(L_ERROR, "Failed to start udev"); // return NULL;
goto error_session; // }
} //
// struct wlr_udev *udev = wlr_udev_create(display);
int gpu = wlr_udev_find_gpu(udev, session); // if (!udev) {
if (gpu == -1) { // wlr_log(L_ERROR, "Failed to start udev");
wlr_log(L_ERROR, "Failed to open DRM device"); // goto error_session;
goto error_udev; // }
} //
// int gpu = wlr_udev_find_gpu(udev, session);
backend = wlr_multi_backend_create(session, udev); // if (gpu == -1) {
if (!backend) { // wlr_log(L_ERROR, "Failed to open DRM device");
goto error_gpu; // goto error_udev;
} // }
//
struct wlr_backend *libinput = wlr_libinput_backend_create(display, session, udev); // backend = wlr_multi_backend_create(session, udev);
if (!libinput) { // if (!backend) {
goto error_multi; // goto error_gpu;
} // }
//
struct wlr_backend *drm = wlr_drm_backend_create(display, session, udev, gpu); // struct wlr_backend *libinput = wlr_libinput_backend_create(display, session, udev);
if (!drm) { // if (!libinput) {
goto error_libinput; // goto error_multi;
} // }
//
wlr_multi_backend_add(backend, libinput); // struct wlr_backend *drm = wlr_drm_backend_create(display, session, udev, gpu);
wlr_multi_backend_add(backend, drm); // if (!drm) {
return backend; // goto error_libinput;
// }
error_libinput: //
wlr_backend_destroy(libinput); // wlr_multi_backend_add(backend, libinput);
error_multi: // wlr_multi_backend_add(backend, drm);
wlr_backend_destroy(backend); // return backend;
error_gpu: //
wlr_session_close_file(session, gpu); //error_libinput:
error_udev: // wlr_backend_destroy(libinput);
wlr_udev_destroy(udev); //error_multi:
error_session: // wlr_backend_destroy(backend);
wlr_session_finish(session); //error_gpu:
return NULL; // wlr_session_close_file(session, gpu);
//error_udev:
// wlr_udev_destroy(udev);
//error_session:
// wlr_session_finish(session);
// return NULL;
} }
struct libinput_device *wlr_libinput_get_device_handle(struct wlr_input_device *dev) { //struct libinput_device *wlr_libinput_get_device_handle(struct wlr_input_device *dev) {
return dev->state->handle; // return dev->state->handle;
} //}

26
backend/meson.build
View file

@ -4,19 +4,19 @@ backend_files = files(
'session/direct-ipc.c', 'session/direct-ipc.c',
'session/direct.c', 'session/direct.c',
'session/session.c', 'session/session.c',
'drm/backend.c', #'drm/backend.c',
'drm/drm.c', #'drm/drm.c',
'drm/drm-atomic.c', #'drm/drm-atomic.c',
'drm/drm-legacy.c', #'drm/drm-legacy.c',
'drm/drm-properties.c', #'drm/drm-properties.c',
'drm/drm-util.c', #'drm/drm-util.c',
'libinput/backend.c', #'libinput/backend.c',
'libinput/events.c', #'libinput/events.c',
'libinput/keyboard.c', #'libinput/keyboard.c',
'libinput/pointer.c', #'libinput/pointer.c',
'libinput/tablet_pad.c', #'libinput/tablet_pad.c',
'libinput/tablet_tool.c', #'libinput/tablet_tool.c',
'libinput/touch.c', #'libinput/touch.c',
'multi/backend.c', 'multi/backend.c',
'wayland/backend.c', 'wayland/backend.c',
'wayland/output.c', 'wayland/output.c',

69
backend/multi/backend.c
View file

@ -15,9 +15,10 @@ struct subbackend_state {
struct wl_listener output_remove; struct wl_listener output_remove;
}; };
static bool multi_backend_init(struct wlr_backend_state *state) { static bool multi_backend_init(struct wlr_backend *_backend) {
for (size_t i = 0; i < state->backends->length; ++i) { struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
struct subbackend_state *sub = state->backends->items[i]; for (size_t i = 0; i < backend->backends->length; ++i) {
struct subbackend_state *sub = backend->backends->items[i];
if (!wlr_backend_init(sub->backend)) { if (!wlr_backend_init(sub->backend)) {
wlr_log(L_ERROR, "Failed to initialize backend %zd", i); wlr_log(L_ERROR, "Failed to initialize backend %zd", i);
return false; return false;
@ -26,21 +27,23 @@ static bool multi_backend_init(struct wlr_backend_state *state) {
return true; return true;
} }
static void multi_backend_destroy(struct wlr_backend_state *state) { static void multi_backend_destroy(struct wlr_backend *_backend) {
for (size_t i = 0; i < state->backends->length; ++i) { struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
struct subbackend_state *sub = state->backends->items[i]; for (size_t i = 0; i < backend->backends->length; ++i) {
struct subbackend_state *sub = backend->backends->items[i];
wlr_backend_destroy(sub->backend); wlr_backend_destroy(sub->backend);
free(sub); free(sub);
} }
list_free(state->backends); list_free(backend->backends);
wlr_session_finish(state->session); wlr_session_finish(backend->session);
wlr_udev_destroy(state->udev); wlr_udev_destroy(backend->udev);
free(state); free(backend);
} }
static struct wlr_egl *multi_backend_get_egl(struct wlr_backend_state *state) { static struct wlr_egl *multi_backend_get_egl(struct wlr_backend *_backend) {
for (size_t i = 0; i < state->backends->length; ++i) { struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
struct subbackend_state *sub = state->backends->items[i]; for (size_t i = 0; i < backend->backends->length; ++i) {
struct subbackend_state *sub = backend->backends->items[i];
struct wlr_egl *egl = wlr_backend_get_egl(sub->backend); struct wlr_egl *egl = wlr_backend_get_egl(sub->backend);
if (egl) { if (egl) {
return egl; return egl;
@ -57,25 +60,25 @@ struct wlr_backend_impl backend_impl = {
struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session, struct wlr_backend *wlr_multi_backend_create(struct wlr_session *session,
struct wlr_udev *udev) { struct wlr_udev *udev) {
struct wlr_backend_state *state = struct wlr_multi_backend *backend =
calloc(1, sizeof(struct wlr_backend_state)); calloc(1, sizeof(struct wlr_multi_backend));
if (!state) { if (!backend) {
wlr_log(L_ERROR, "Backend allocation failed"); wlr_log(L_ERROR, "Backend allocation failed");
return NULL; return NULL;
} }
state->backends = list_create(); backend->backends = list_create();
if (!state->backends) { if (!backend->backends) {
free(state); free(backend);
wlr_log(L_ERROR, "Backend allocation failed"); wlr_log(L_ERROR, "Backend allocation failed");
return NULL; return NULL;
} }
struct wlr_backend *backend = wlr_backend_create(&backend_impl, state); wlr_backend_create(&backend->backend, &backend_impl);
state->backend = backend;
state->session = session; backend->session = session;
state->udev = udev; backend->udev = udev;
return backend; return &backend->backend;
} }
bool wlr_backend_is_multi(struct wlr_backend *b) { bool wlr_backend_is_multi(struct wlr_backend *b) {
@ -106,11 +109,12 @@ static void output_remove_reemit(struct wl_listener *listener, void *data) {
wl_signal_emit(&state->container->events.output_remove, data); wl_signal_emit(&state->container->events.output_remove, data);
} }
void wlr_multi_backend_add(struct wlr_backend *multi, void wlr_multi_backend_add(struct wlr_backend *_multi,
struct wlr_backend *backend) { struct wlr_backend *backend) {
struct wlr_multi_backend *multi = (struct wlr_multi_backend *)_multi;
struct subbackend_state *sub = calloc(1, sizeof(struct subbackend_state)); struct subbackend_state *sub = calloc(1, sizeof(struct subbackend_state));
sub->backend = backend; sub->backend = backend;
sub->container = multi; sub->container = &multi->backend;
sub->input_add.notify = input_add_reemit; sub->input_add.notify = input_add_reemit;
sub->input_remove.notify = input_remove_reemit; sub->input_remove.notify = input_remove_reemit;
@ -127,13 +131,14 @@ void wlr_multi_backend_add(struct wlr_backend *multi,
wl_signal_add(&backend->events.output_add, &sub->output_add); wl_signal_add(&backend->events.output_add, &sub->output_add);
wl_signal_add(&backend->events.output_remove, &sub->output_remove); wl_signal_add(&backend->events.output_remove, &sub->output_remove);
list_add(multi->state->backends, sub); list_add(multi->backends, sub);
} }
struct wlr_session *wlr_multi_get_session(struct wlr_backend *base) { struct wlr_session *wlr_multi_get_session(struct wlr_backend *_backend) {
if (base->impl != &backend_impl) // TODO: assert(wlr_backend_is_multi(_backend));
if (_backend->impl != &backend_impl) {
return NULL; return NULL;
}
struct wlr_backend_state *multi = base->state; struct wlr_multi_backend *backend = (struct wlr_multi_backend *)_backend;
return multi->session; return backend->session;
} }

112
backend/wayland/backend.c
View file

@ -12,17 +12,17 @@
#include "backend/wayland.h" #include "backend/wayland.h"
static int dispatch_events(int fd, uint32_t mask, void *data) { 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; int count = 0;
if (mask & WL_EVENT_READABLE) { if (mask & WL_EVENT_READABLE) {
count = wl_display_dispatch(state->remote_display); count = wl_display_dispatch(backend->remote_display);
} }
if (mask & WL_EVENT_WRITABLE) { if (mask & WL_EVENT_WRITABLE) {
count = wl_display_flush(state->remote_display); count = wl_display_flush(backend->remote_display);
} }
if (mask == 0) { if (mask == 0) {
count = wl_display_dispatch_pending(state->remote_display); count = wl_display_dispatch_pending(backend->remote_display);
wl_display_flush(state->remote_display); wl_display_flush(backend->remote_display);
} }
return count; 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 * compositor and creates surfaces for each output, then registers globals on
* the specified display. * 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"); wlr_log(L_INFO, "Initializating wayland backend");
state->remote_display = wl_display_connect(NULL); backend->remote_display = wl_display_connect(NULL);
if (!state->remote_display) { if (!backend->remote_display) {
wlr_log_errno(L_ERROR, "Could not connect to remote display"); wlr_log_errno(L_ERROR, "Could not connect to remote display");
return false; 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"); wlr_log_errno(L_ERROR, "Could not obtain reference to remote registry");
return false; return false;
} }
wlr_wl_registry_poll(state); wlr_wl_registry_poll(backend);
if (!(state->compositor) || (!(state->shell))) { if (!(backend->compositor) || (!(backend->shell))) {
wlr_log_errno(L_ERROR, "Could not obtain retrieve required globals"); wlr_log_errno(L_ERROR, "Could not obtain retrieve required globals");
return false; return false;
} }
wlr_egl_init(&state->egl, EGL_PLATFORM_WAYLAND_EXT, state->remote_display); wlr_egl_init(&backend->egl, EGL_PLATFORM_WAYLAND_EXT, backend->remote_display);
wlr_egl_bind_display(&state->egl, state->local_display); wlr_egl_bind_display(&backend->egl, backend->local_display);
for (size_t i = 0; i < state->requested_outputs; ++i) { for (size_t i = 0; i < backend->requested_outputs; ++i) {
wlr_wl_output_create(state->backend); wlr_wl_output_create(&backend->backend);
} }
struct wl_event_loop *loop = wl_display_get_event_loop(state->local_display); struct wl_event_loop *loop = wl_display_get_event_loop(backend->local_display);
int fd = wl_display_get_fd(state->remote_display); int fd = wl_display_get_fd(backend->remote_display);
int events = WL_EVENT_READABLE | WL_EVENT_ERROR | int events = WL_EVENT_READABLE | WL_EVENT_ERROR |
WL_EVENT_HANGUP | WL_EVENT_WRITABLE; WL_EVENT_HANGUP | WL_EVENT_WRITABLE;
state->remote_display_src = wl_event_loop_add_fd(loop, fd, events, backend->remote_display_src = wl_event_loop_add_fd(loop, fd, events,
dispatch_events, state); dispatch_events, backend);
wl_event_source_check(state->remote_display_src); wl_event_source_check(backend->remote_display_src);
return true; return true;
} }
static void wlr_wl_backend_destroy(struct wlr_backend_state *state) { static void wlr_wl_backend_destroy(struct wlr_backend *_backend) {
if (!state) { struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend;
if (!_backend) {
return; return;
} }
for (size_t i = 0; i < state->outputs->length; ++i) { for (size_t i = 0; i < backend->outputs->length; ++i) {
wlr_output_destroy(state->outputs->items[i]); wlr_output_destroy(backend->outputs->items[i]);
} }
for (size_t i = 0; i < state->devices->length; ++i) { for (size_t i = 0; i < backend->devices->length; ++i) {
wlr_input_device_destroy(state->devices->items[i]); wlr_input_device_destroy(backend->devices->items[i]);
} }
list_free(state->devices); list_free(backend->devices);
list_free(state->outputs); list_free(backend->outputs);
free(state->seatName); free(backend->seat_name);
wlr_egl_free(&state->egl); wlr_egl_free(&backend->egl);
if (state->seat) wl_seat_destroy(state->seat); if (backend->seat) wl_seat_destroy(backend->seat);
if (state->shm) wl_shm_destroy(state->shm); if (backend->shm) wl_shm_destroy(backend->shm);
if (state->shell) wl_shell_destroy(state->shell); if (backend->shell) wl_shell_destroy(backend->shell);
if (state->compositor) wl_compositor_destroy(state->compositor); if (backend->compositor) wl_compositor_destroy(backend->compositor);
if (state->registry) wl_registry_destroy(state->registry); if (backend->registry) wl_registry_destroy(backend->registry);
if (state->remote_display) wl_display_disconnect(state->remote_display); if (backend->remote_display) wl_display_disconnect(backend->remote_display);
free(state); free(backend);
} }
static struct wlr_egl *wlr_wl_backend_get_egl(struct wlr_backend_state *state) { static struct wlr_egl *wlr_wl_backend_get_egl(struct wlr_backend *_backend) {
return &state->egl; struct wlr_wl_backend *backend = (struct wlr_wl_backend *)_backend;
return &backend->egl;
} }
static struct wlr_backend_impl backend_impl = { 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; return b->impl == &backend_impl;
} }
struct wlr_output *wlr_wl_output_for_surface(struct wlr_backend_state *backend, struct wlr_output *wlr_wl_output_for_surface(struct wlr_wl_backend *backend,
struct wl_surface *surface) { struct wl_surface *surface) {
for (size_t i = 0; i < backend->outputs->length; ++i) { for (size_t i = 0; i < backend->outputs->length; ++i) {
struct wlr_output *output = backend->outputs->items[i]; struct wlr_output *output = backend->outputs->items[i];
if(output->state->surface == surface) if (output->state->surface == surface) {
return output; return output;
} }
}
return NULL; return NULL;
} }
struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) { struct wlr_backend *wlr_wl_backend_create(struct wl_display *display) {
wlr_log(L_INFO, "Creating wayland backend"); wlr_log(L_INFO, "Creating wayland backend");
struct wlr_backend_state *state = calloc(1, sizeof(struct wlr_backend_state)); struct wlr_wl_backend *backend = calloc(1, sizeof(struct wlr_wl_backend));
if (!state) {
wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
return NULL;
}
struct wlr_backend *backend = wlr_backend_create(&backend_impl, state);
if (!backend) { if (!backend) {
wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno)); wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
return NULL; 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"); wlr_log(L_ERROR, "Could not allocate devices list");
goto error; goto error;
} }
if (!(state->outputs = list_create())) { if (!(backend->outputs = list_create())) {
wlr_log(L_ERROR, "Could not allocate outputs list"); wlr_log(L_ERROR, "Could not allocate outputs list");
goto error; goto error;
} }
state->local_display = display; backend->local_display = display;
state->backend = backend; return &backend->backend;
return backend;
error: error:
if (state) { if (backend) {
list_free(state->devices); list_free(backend->devices);
list_free(state->outputs); list_free(backend->outputs);
} }
free(state);
free(backend); free(backend);
return NULL; return NULL;
} }

10
backend/wayland/output.c
View file

@ -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) { static void wlr_wl_output_destroy(struct wlr_output_state *output) {
wl_signal_emit(&output->backend->backend->events.output_remove, output->wlr_output); wl_signal_emit(&output->backend->backend.events.output_remove, output->wlr_output);
if(output->frame_callback) wl_callback_destroy(output->frame_callback); if (output->frame_callback) {
wl_callback_destroy(output->frame_callback);
}
eglDestroySurface(output->backend->egl.display, output->surface); eglDestroySurface(output->backend->egl.display, output->surface);
wl_egl_window_destroy(output->egl_window); wl_egl_window_destroy(output->egl_window);
wl_shell_surface_destroy(output->shell_surface); 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) { struct wlr_output *wlr_wl_output_create(struct wlr_backend *_backend) {
assert(wlr_backend_is_wl(_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) { if (!backend->remote_display) {
++backend->requested_outputs; ++backend->requested_outputs;
return NULL; 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); wlr_output_create_global(wlr_output, backend->local_display);
list_add(backend->outputs, wlr_output); 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; return wlr_output;
} }

20
backend/wayland/registry.c
View file

@ -7,22 +7,22 @@
static void registry_global(void *data, struct wl_registry *registry, static void registry_global(void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version) { 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); wlr_log(L_DEBUG, "Remote wayland global: %s v%d", interface, version);
if (strcmp(interface, wl_compositor_interface.name) == 0) { 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); &wl_compositor_interface, version);
} else if (strcmp(interface, wl_shell_interface.name) == 0) { } 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); &wl_shell_interface, version);
} else if (strcmp(interface, wl_shm_interface.name) == 0) { } 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); &wl_shm_interface, version);
} else if (strcmp(interface, wl_seat_interface.name) == 0) { } 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_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 .global_remove = registry_global_remove
}; };
void wlr_wl_registry_poll(struct wlr_backend_state *state) { void wlr_wl_registry_poll(struct wlr_wl_backend *backend) {
wl_registry_add_listener(state->registry, &registry_listener, state); wl_registry_add_listener(backend->registry, &registry_listener, backend);
wl_display_dispatch(state->remote_display); wl_display_dispatch(backend->remote_display);
wl_display_roundtrip(state->remote_display); wl_display_roundtrip(backend->remote_display);
} }

27
backend/wayland/wl_seat.c
View file

@ -169,7 +169,7 @@ static struct wl_keyboard_listener keyboard_listener = {
}; };
static void input_device_destroy(struct wlr_input_device_state *state) { 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) if (state->resource)
wl_proxy_destroy(state->resource); wl_proxy_destroy(state->resource);
free(state); free(state);
@ -187,7 +187,7 @@ static struct wlr_pointer_impl pointer_impl = {
.destroy = pointer_destroy .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) { enum wlr_input_device_type type) {
struct wlr_input_device_state *devstate; struct wlr_input_device_state *devstate;
if (!(devstate = calloc(1, sizeof(struct wlr_input_device_state)))) { 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; return NULL;
} }
devstate->backend = state; devstate->backend = backend;
int vendor = 0; int vendor = 0;
int product = 0; int product = 0;
@ -208,14 +208,14 @@ static struct wlr_input_device *allocate_device(struct wlr_backend_state *state,
return NULL; return NULL;
} }
devstate->wlr_device = wlr_device; devstate->wlr_device = wlr_device;
list_add(state->devices, wlr_device); list_add(backend->devices, wlr_device);
return wlr_device; return wlr_device;
} }
static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat, static void seat_handle_capabilities(void *data, struct wl_seat *wl_seat,
enum wl_seat_capability caps) { enum wl_seat_capability caps) {
struct wlr_backend_state *state = data; struct wlr_wl_backend *backend = data;
assert(state->seat == wl_seat); assert(backend->seat == wl_seat);
if ((caps & WL_SEAT_CAPABILITY_POINTER)) { if ((caps & WL_SEAT_CAPABILITY_POINTER)) {
wlr_log(L_DEBUG, "seat %p offered pointer", (void*) wl_seat); 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; 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); free(pointer_state);
wlr_log(L_ERROR, "Unable to allocate wlr_device for pointer"); wlr_log(L_ERROR, "Unable to allocate wlr_device for pointer");
return; 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); wl_pointer_add_listener(wl_pointer, &pointer_listener, wlr_device);
wlr_device->pointer = wlr_pointer_create(&pointer_impl, pointer_state); wlr_device->pointer = wlr_pointer_create(&pointer_impl, pointer_state);
wlr_device->state->resource = wl_pointer; 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)) { if ((caps & WL_SEAT_CAPABILITY_KEYBOARD)) {
wlr_log(L_DEBUG, "seat %p offered keyboard", (void*) wl_seat); 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); WLR_INPUT_DEVICE_KEYBOARD);
if (!wlr_device) { if (!wlr_device) {
wlr_log(L_ERROR, "Unable to allocate wl_pointer 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); wl_keyboard_add_listener(wl_keyboard, &keyboard_listener, wlr_device);
wlr_device->keyboard = wlr_keyboard_create(NULL, NULL); wlr_device->keyboard = wlr_keyboard_create(NULL, NULL);
wlr_device->state->resource = wl_keyboard; 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) { static void seat_handle_name(void *data, struct wl_seat *wl_seat, const char *name) {
struct wlr_backend_state *state = data; struct wlr_wl_backend *backend = data;
assert(state->seat == wl_seat); assert(backend->seat == wl_seat);
// Do we need to check if seatName was previously set for name change? // 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 = { const struct wl_seat_listener seat_listener = {

5
include/backend/drm.h
View file

@ -81,8 +81,9 @@ void wlr_drm_renderer_free(struct wlr_drm_renderer *renderer);
struct wlr_drm_interface; struct wlr_drm_interface;
struct wlr_backend_state { struct wlr_drm_backend_state {
struct wlr_backend *base; struct wlr_backend backend;
const struct wlr_drm_interface *iface; const struct wlr_drm_interface *iface;
int fd; int fd;

5
include/backend/libinput.h
View file

@ -7,8 +7,9 @@
#include <wlr/util/list.h> #include <wlr/util/list.h>
#include "backend/udev.h" #include "backend/udev.h"
struct wlr_backend_state { struct wlr_libinput_backend_state {
struct wlr_backend *backend; struct wlr_backend backend;
struct wlr_session *session; struct wlr_session *session;
struct wlr_udev *udev; struct wlr_udev *udev;
struct wl_display *display; struct wl_display *display;

5
include/backend/multi.h
View file

@ -7,8 +7,9 @@
#include <wlr/util/list.h> #include <wlr/util/list.h>
#include <wlr/backend/session.h> #include <wlr/backend/session.h>
struct wlr_backend_state { struct wlr_multi_backend {
struct wlr_backend *backend; struct wlr_backend backend;
struct wlr_session *session; struct wlr_session *session;
struct wlr_udev *udev; struct wlr_udev *udev;
list_t *backends; list_t *backends;

15
include/backend/wayland.h
View file

@ -9,10 +9,11 @@
#include <wlr/types/wlr_input_device.h> #include <wlr/types/wlr_input_device.h>
#include <wlr/util/list.h> #include <wlr/util/list.h>
struct wlr_backend_state { struct wlr_wl_backend {
struct wlr_backend backend;
/* local state */ /* local state */
struct wl_display *local_display; struct wl_display *local_display;
struct wlr_backend *backend;
list_t *devices; list_t *devices;
list_t *outputs; list_t *outputs;
struct wlr_egl egl; struct wlr_egl egl;
@ -25,11 +26,11 @@ struct wlr_backend_state {
struct wl_shell *shell; struct wl_shell *shell;
struct wl_shm *shm; struct wl_shm *shm;
struct wl_seat *seat; struct wl_seat *seat;
char *seatName; char *seat_name;
}; };
struct wlr_output_state { struct wlr_output_state {
struct wlr_backend_state *backend; struct wlr_wl_backend *backend;
struct wlr_output *wlr_output; struct wlr_output *wlr_output;
struct wl_surface *surface; struct wl_surface *surface;
struct wl_shell_surface *shell_surface; struct wl_shell_surface *shell_surface;
@ -39,7 +40,7 @@ struct wlr_output_state {
}; };
struct wlr_input_device_state { struct wlr_input_device_state {
struct wlr_backend_state *backend; struct wlr_wl_backend *backend;
struct wlr_input_device *wlr_device; struct wlr_input_device *wlr_device;
void *resource; void *resource;
}; };
@ -49,8 +50,8 @@ struct wlr_pointer_state {
struct wlr_output *current_output; struct wlr_output *current_output;
}; };
void wlr_wl_registry_poll(struct wlr_backend_state *backend); void wlr_wl_registry_poll(struct wlr_wl_backend *backend);
struct wlr_output *wlr_wl_output_for_surface(struct wlr_backend_state *backend, struct wlr_output *wlr_wl_output_for_surface(struct wlr_wl_backend *backend,
struct wl_surface *surface); struct wl_surface *surface);
extern const struct wl_seat_listener seat_listener; extern const struct wl_seat_listener seat_listener;

2
include/wlr/backend.h
View file

@ -6,11 +6,9 @@
#include <wlr/egl.h> #include <wlr/egl.h>
struct wlr_backend_impl; struct wlr_backend_impl;
struct wlr_backend_state;
struct wlr_backend { struct wlr_backend {
const struct wlr_backend_impl *impl; const struct wlr_backend_impl *impl;
struct wlr_backend_state *state;
struct { struct {
struct wl_signal input_add; struct wl_signal input_add;

12
include/wlr/backend/interface.h
View file

@ -5,15 +5,13 @@
#include <wlr/backend.h> #include <wlr/backend.h>
#include <wlr/egl.h> #include <wlr/egl.h>
struct wlr_backend_state;
struct wlr_backend_impl { struct wlr_backend_impl {
bool (*init)(struct wlr_backend_state *state); bool (*init)(struct wlr_backend *backend);
void (*destroy)(struct wlr_backend_state *state); void (*destroy)(struct wlr_backend *backend);
struct wlr_egl *(*get_egl)(struct wlr_backend_state *state); struct wlr_egl *(*get_egl)(struct wlr_backend *backend);
}; };
struct wlr_backend *wlr_backend_create(const struct wlr_backend_impl *impl, void wlr_backend_create(struct wlr_backend *backend,
struct wlr_backend_state *state); const struct wlr_backend_impl *impl);
#endif #endif