aboutsummaryrefslogtreecommitdiff
path: root/backend
diff options
context:
space:
mode:
Diffstat (limited to 'backend')
-rw-r--r--backend/CMakeLists.txt9
-rw-r--r--backend/backend.c4
-rw-r--r--backend/drm/drm.c1
-rw-r--r--backend/egl.c18
-rw-r--r--backend/wayland/backend.c155
-rw-r--r--backend/wayland/output.c149
-rw-r--r--backend/wayland/registry.c72
-rw-r--r--backend/wayland/wl_output.c64
-rw-r--r--backend/wayland/wl_seat.c78
9 files changed, 363 insertions, 187 deletions
diff --git a/backend/CMakeLists.txt b/backend/CMakeLists.txt
index 9594c318..37cee892 100644
--- a/backend/CMakeLists.txt
+++ b/backend/CMakeLists.txt
@@ -6,11 +6,10 @@ include_directories(
)
add_library(wlr-backend
- #wayland/backend.c
- #wayland/registry.c
- #wayland/wl_seat.c
- #wayland/wl_output.c
-
+ wayland/backend.c
+ wayland/registry.c
+ wayland/wl_seat.c
+ wayland/output.c
drm/backend.c
drm/drm.c
diff --git a/backend/backend.c b/backend/backend.c
index 02fd7479..30ced3e8 100644
--- a/backend/backend.c
+++ b/backend/backend.c
@@ -8,6 +8,7 @@
#include <wlr/backend/interface.h>
#include <wlr/backend/drm.h>
#include <wlr/backend/libinput.h>
+#include <wlr/backend/wayland.h>
#include <wlr/backend/multi.h>
#include "backend/libinput.h"
#include "backend/udev.h"
@@ -42,6 +43,9 @@ struct wlr_backend *wlr_backend_autocreate(struct wl_display *display,
struct wlr_session *session) {
// TODO: Choose the most appropriate backend for the situation
// Attempt DRM+libinput
+ if (getenv("WAYLAND_DISPLAY") || getenv("_WAYLAND_DISPLAY")) {
+ return wlr_wl_backend_create(display, 1);
+ }
struct wlr_udev *udev;
if (!(udev = wlr_udev_create(display))) {
wlr_log(L_ERROR, "Failed to start udev");
diff --git a/backend/drm/drm.c b/backend/drm/drm.c
index befbfb94..5afdf3c3 100644
--- a/backend/drm/drm.c
+++ b/backend/drm/drm.c
@@ -260,6 +260,7 @@ static bool wlr_drm_output_set_mode(struct wlr_output_state *output,
output->width = output->wlr_output->width = mode->width;
output->height = output->wlr_output->height = mode->height;
output->wlr_output->current_mode = mode;
+ wl_signal_emit(&output->wlr_output->events.resolution, output->wlr_output);
if (!display_init_renderer(&state->renderer, output)) {
wlr_log(L_ERROR, "Failed to initalise renderer for %s", output->wlr_output->name);
diff --git a/backend/egl.c b/backend/egl.c
index 2aac25b7..1ce2d8a7 100644
--- a/backend/egl.c
+++ b/backend/egl.c
@@ -6,7 +6,7 @@
#include "backend/egl.h"
#include "common/log.h"
-static const char *egl_error(void) {
+const char *egl_error(void) {
switch (eglGetError()) {
case EGL_SUCCESS:
return "Success";
@@ -68,11 +68,12 @@ static bool egl_exts() {
return true;
}
-static bool egl_get_config(EGLDisplay disp, EGLConfig *out) {
+static bool egl_get_config(EGLDisplay disp, EGLConfig *out, EGLenum platform) {
EGLint count = 0, matched = 0, ret;
ret = eglGetConfigs(disp, NULL, 0, &count);
if (ret == EGL_FALSE || count == 0) {
+ wlr_log(L_ERROR, "eglGetConfigs returned no configs");
return false;
}
@@ -80,12 +81,18 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out) {
ret = eglChooseConfig(disp, NULL, configs, count, &matched);
if (ret == EGL_FALSE) {
+ wlr_log(L_ERROR, "eglChooseConfig failed");
return false;
}
for (int i = 0; i < matched; ++i) {
EGLint gbm_format;
+ if(platform == EGL_PLATFORM_WAYLAND_EXT) {
+ *out = configs[i];
+ return true;
+ }
+
if (!eglGetConfigAttrib(disp,
configs[i],
EGL_NATIVE_VISUAL_ID,
@@ -101,6 +108,7 @@ static bool egl_get_config(EGLDisplay disp, EGLConfig *out) {
}
}
+ wlr_log(L_ERROR, "no valid egl config found");
return false;
}
@@ -109,7 +117,7 @@ bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, void *display) {
if (!egl_exts()) {
return false;
}
-
+
if (eglBindAPI(EGL_OPENGL_ES_API) == EGL_FALSE) {
wlr_log(L_ERROR, "Failed to bind to the OpenGL ES API: %s", egl_error());
goto error;
@@ -127,7 +135,7 @@ bool wlr_egl_init(struct wlr_egl *egl, EGLenum platform, void *display) {
goto error;
}
- if (!egl_get_config(egl->display, &egl->config)) {
+ if (!egl_get_config(egl->display, &egl->config, platform)) {
wlr_log(L_ERROR, "Failed to get EGL config");
goto error;
}
@@ -163,7 +171,7 @@ void wlr_egl_free(struct wlr_egl *egl) {
eglDestroyContext(egl->display, egl->context);
eglTerminate(egl->display);
eglReleaseThread();
- eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
+ eglMakeCurrent(EGL_NO_DISPLAY, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
}
EGLSurface wlr_egl_create_surface(struct wlr_egl *egl, void *window) {
diff --git a/backend/wayland/backend.c b/backend/wayland/backend.c
index 7f73c501..344cc35d 100644
--- a/backend/wayland/backend.c
+++ b/backend/wayland/backend.c
@@ -2,26 +2,28 @@
#include <stdint.h>
#include <wayland-server.h>
#include <assert.h>
+#include <wlr/backend/interface.h>
+#include <wlr/types.h>
#include "backend/wayland.h"
#include "common/log.h"
+#include "types.h"
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
-void wlr_wl_backend_free(struct wlr_wl_backend *backend) {
- if (!backend) {
- return;
+static int dispatch_events(int fd, uint32_t mask, void *data) {
+ struct wlr_backend_state *state = data;
+ int count = 0;
+ if (mask & WL_EVENT_READABLE) {
+ count = wl_display_dispatch(state->remote_display);
}
- // TODO: Free surfaces
- for (size_t i = 0; backend->outputs && i < backend->outputs->length; ++i) {
- struct wlr_wl_output *output = backend->outputs->items[i];
- wlr_wl_output_free(output);
- }
- list_free(backend->outputs);
- if (backend->seat) wlr_wl_seat_free(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);
+ if (mask & WL_EVENT_WRITABLE) {
+ count = wl_display_flush(state->remote_display);
+ }
+ if (mask == 0) {
+ count = wl_display_dispatch_pending(state->remote_display);
+ wl_display_flush(state->remote_display);
+ }
+ return count;
}
/*
@@ -29,31 +31,116 @@ void wlr_wl_backend_free(struct wlr_wl_backend *backend) {
* compositor and creates surfaces for each output, then registers globals on
* the specified display.
*/
-struct wlr_wl_backend *wlr_wl_backend_init(
- struct wl_display *display, size_t outputs) {
- assert(display);
- struct wlr_wl_backend *backend;
- if (!(backend = calloc(sizeof(struct wlr_wl_backend), 1))) {
- wlr_log(L_ERROR, "Could not allocate backend");
- goto error;
+static bool wlr_wl_backend_init(struct wlr_backend_state* state) {
+ wlr_log(L_INFO, "Initializating wayland backend");
+
+ state->remote_display = wl_display_connect(getenv("_WAYLAND_DISPLAY"));
+ if (!state->remote_display) {
+ wlr_log_errno(L_ERROR, "Could not connect to remote display");
+ return false;
}
- if (!(backend->outputs = list_create())) {
- wlr_log(L_ERROR, "Could not allocate output list");
- goto error;
+
+ if (!(state->registry = wl_display_get_registry(state->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_log_errno(L_ERROR, "Could not obtain retrieve required globals");
+ return false;
+ }
+
+ wlr_egl_init(&state->egl, EGL_PLATFORM_WAYLAND_EXT, state->remote_display);
+ for (size_t i = 0; i < state->num_outputs; ++i) {
+ if(!(state->outputs[i] = wlr_wl_output_create(state, i))) {
+ wlr_log_errno(L_ERROR, "Failed to create %zuth output", i);
+ return false;
+ }
+ }
+
+ struct wl_event_loop *loop = wl_display_get_event_loop(state->local_display);
+ int fd = wl_display_get_fd(state->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);
+
+ return true;
+}
+
+static void wlr_wl_backend_destroy(struct wlr_backend_state *state) {
+ if (!state) {
+ return;
+ }
+
+ for (size_t i = 0; i < state->num_outputs; ++i) {
+ wlr_output_destroy(state->outputs[i]);
}
- backend->local_display = display;
- backend->remote_display = wl_display_connect(getenv("_WAYLAND_DISPLAY"));
- if (!backend->remote_display) {
- wlr_log(L_ERROR, "Could not connect to remote display");
+
+ for (size_t i = 0; state->devices && i < state->devices->length; ++i) {
+ wlr_input_device_destroy(state->devices->items[i]);
+ }
+
+ list_free(state->devices);
+
+ wlr_egl_free(&state->egl);
+ free(state->outputs);
+ 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);
+}
+
+static struct wlr_backend_impl backend_impl = {
+ .init = wlr_wl_backend_init,
+ .destroy = wlr_wl_backend_destroy
+};
+
+
+struct wlr_backend *wlr_wl_backend_create(struct wl_display *display,
+ size_t num_outputs) {
+ 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);
+ if (!backend) {
+ wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
+ return NULL;
+ }
+
+ if (!(state->devices = list_create())) {
+ wlr_log(L_ERROR, "Could not allocate devices list");
goto error;
}
- if (!(backend->registry = wl_display_get_registry(backend->remote_display))) {
- wlr_log(L_ERROR, "Could not obtain reference to remote registry");
+
+ if (!(state->outputs = calloc(sizeof(void*), num_outputs))) {
+ wlr_log(L_ERROR, "Could not allocate outputs list");
goto error;
}
- wlr_wlb_registry_poll(backend);
+
+ state->local_display = display;
+ state->backend = backend;
+ state->num_outputs = num_outputs;
+
return backend;
+
error:
- wlr_wl_backend_free(backend);
+ if (state) {
+ free(state->outputs);
+ free(state->devices);
+ free(state->devices);
+ }
+ free(state);
+ free(backend);
return NULL;
}
diff --git a/backend/wayland/output.c b/backend/wayland/output.c
new file mode 100644
index 00000000..de4d2f4d
--- /dev/null
+++ b/backend/wayland/output.c
@@ -0,0 +1,149 @@
+#include <stdio.h>
+#include <assert.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wayland-client.h>
+#include <wlr/types.h>
+#include <GLES3/gl3.h>
+#include "types.h"
+#include "backend/wayland.h"
+#include "common/log.h"
+
+static struct wl_callback_listener frame_listener;
+
+static void surface_frame_callback(void *data, struct wl_callback *cb, uint32_t time) {
+ struct wlr_output_state *output = data;
+ assert(output);
+
+ if (!eglMakeCurrent(output->backend->egl.display,
+ output->egl_surface, output->egl_surface,
+ output->backend->egl.context)) {
+ wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error());
+ return;
+ }
+
+ wl_signal_emit(&output->output->events.frame, output->output);
+ output->frame_callback = wl_surface_frame(output->surface);
+ wl_callback_add_listener(output->frame_callback, &frame_listener, output);
+ wl_callback_destroy(cb);
+
+ if (!eglSwapBuffers(output->backend->egl.display, output->egl_surface)) {
+ wlr_log(L_ERROR, "eglSwapBuffers failed: %s", egl_error());
+ return;
+ }
+}
+
+static struct wl_callback_listener frame_listener = {
+ .done = surface_frame_callback
+};
+
+static void wlr_wl_output_transform(struct wlr_output_state *output,
+ enum wl_output_transform transform) {
+ // TODO
+}
+
+static void wlr_wl_output_destroy(struct wlr_output_state *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);
+ wl_surface_destroy(output->surface);
+ free(output);
+}
+
+static struct wlr_output_impl output_impl = {
+ .transform = wlr_wl_output_transform,
+ .destroy = wlr_wl_output_destroy,
+};
+
+void handle_ping(void* data, struct wl_shell_surface* ssurface, uint32_t serial) {
+ struct wlr_output_state *output = data;
+ assert(output && output->shell_surface == ssurface);
+ wl_shell_surface_pong(ssurface, serial);
+}
+
+void handle_configure(void *data, struct wl_shell_surface *wl_shell_surface,
+ uint32_t edges, int32_t width, int32_t height){
+ struct wlr_output_state *ostate = data;
+ assert(ostate && ostate->shell_surface == wl_shell_surface);
+ struct wlr_output *output = ostate->output;
+ wl_egl_window_resize(ostate->egl_window, width, height, 0, 0);
+ output->width = width;
+ output->height = height;
+ wlr_output_update_matrix(output);
+ wl_signal_emit(&output->events.resolution, output);
+}
+
+void handle_popup_done(void *data, struct wl_shell_surface *wl_shell_surface) {
+ wlr_log(L_ERROR, "Unexpected wl_shell_surface.popup_done event");
+}
+
+static struct wl_shell_surface_listener shell_surface_listener = {
+ .ping = handle_ping,
+ .configure = handle_configure,
+ .popup_done = handle_popup_done
+};
+
+struct wlr_output *wlr_wl_output_create(struct wlr_backend_state* backend,
+ size_t id) {
+ struct wlr_output_state *ostate;
+ if (!(ostate = calloc(sizeof(struct wlr_output_state), 1))) {
+ wlr_log(L_ERROR, "Failed to allocate wlr_output_state");
+ return NULL;
+ }
+
+ struct wlr_output *wlr_output = wlr_output_create(&output_impl, ostate);
+ if (!wlr_output) {
+ free(ostate);
+ wlr_log_errno(L_ERROR, "Allocation failed");
+ return NULL;
+ }
+
+ wlr_output->width = 640;
+ wlr_output->height = 480;
+ wlr_output->scale = 1;
+ strncpy(wlr_output->make, "wayland", sizeof(wlr_output->make));
+ strncpy(wlr_output->model, "wayland", sizeof(wlr_output->model));
+ snprintf(wlr_output->name, sizeof(wlr_output->name), "WL-%d", 1);
+
+ ostate->id = id;
+ ostate->backend = backend;
+ ostate->output = wlr_output;
+
+ // TODO: error handling
+ ostate->surface = wl_compositor_create_surface(backend->compositor);
+ ostate->shell_surface = wl_shell_get_shell_surface(backend->shell, ostate->surface);
+
+ wl_shell_surface_set_class(ostate->shell_surface, "sway");
+ wl_shell_surface_set_title(ostate->shell_surface, "sway-wl");
+ wl_shell_surface_add_listener(ostate->shell_surface, &shell_surface_listener, ostate);
+ wl_shell_surface_set_toplevel(ostate->shell_surface);
+
+ ostate->egl_window = wl_egl_window_create(ostate->surface,
+ wlr_output->width, wlr_output->height);
+ ostate->egl_surface = wlr_egl_create_surface(&backend->egl, ostate->egl_window);
+
+ // start rendering loop per callbacks by rendering first frame
+ if (!eglMakeCurrent(ostate->backend->egl.display,
+ ostate->egl_surface, ostate->egl_surface,
+ ostate->backend->egl.context)) {
+ wlr_log(L_ERROR, "eglMakeCurrent failed: %s", egl_error());
+ return false;
+ }
+
+ glViewport(0, 0, wlr_output->width, wlr_output->height);
+ glClearColor(1.0, 1.0, 1.0, 1.0);
+ glClear(GL_COLOR_BUFFER_BIT);
+
+ ostate->frame_callback = wl_surface_frame(ostate->surface);
+ wl_callback_add_listener(ostate->frame_callback, &frame_listener, ostate);
+
+ if (!eglSwapBuffers(ostate->backend->egl.display, ostate->egl_surface)) {
+ wlr_log(L_ERROR, "eglSwapBuffers failed: %s", egl_error());
+ return false;
+ }
+
+ wl_signal_emit(&backend->backend->events.output_add, wlr_output);
+ return wlr_output;
+}
diff --git a/backend/wayland/registry.c b/backend/wayland/registry.c
index 4a639f62..dfe3e37a 100644
--- a/backend/wayland/registry.c
+++ b/backend/wayland/registry.c
@@ -2,77 +2,29 @@
#include <stdlib.h>
#include <string.h>
#include <wayland-client.h>
+#include <wlr/types.h>
+#include "types.h"
#include "backend/wayland.h"
#include "common/log.h"
-static void registry_wl_seat(struct wlr_wl_backend *backend,
- struct wl_seat *wl_seat, struct wl_registry *registry, uint32_t version) {
- struct wlr_wl_seat *seat;
- if (!(seat = calloc(sizeof(struct wlr_wl_seat), 1))) {
- wlr_log(L_ERROR, "Failed to allocate wlr_wl_seat");
- goto error;
- }
- if (!(seat->keyboards = list_create())) {
- wlr_log(L_ERROR, "Failed to allocate wlr_wl_seat");
- goto error;
- }
- if (!(seat->pointers = list_create())) {
- wlr_log(L_ERROR, "Failed to allocate wlr_wl_pointer");
- goto error;
- }
- seat->wl_seat = wl_seat;
- wl_seat_set_user_data(wl_seat, backend);
- wl_seat_add_listener(wl_seat, &seat_listener, seat);
- return;
-error:
- wlr_wl_seat_free(seat);
- return;
-}
-
-static void registry_wl_output(struct wlr_wl_backend *backend,
- struct wl_output *wl_output, struct wl_registry *registry, uint32_t version) {
- struct wlr_wl_output *output;
- if (!(output = calloc(sizeof(struct wlr_wl_output), 1))) {
- wlr_log(L_ERROR, "Failed to allocate wlr_wl_output");
- goto error;
- }
- if (!(output->modes = list_create())) {
- wlr_log(L_ERROR, "Failed to allocate wlr_wl_output");
- goto error;
- }
- output->wl_output = wl_output;
- output->scale = 1;
- list_add(backend->outputs, output);
- wl_output_set_user_data(wl_output, backend);
- wl_output_add_listener(wl_output, &output_listener, output);
- return;
-error:
- wlr_wl_output_free(output);
- return;
-}
-
static void registry_global(void *data, struct wl_registry *registry,
uint32_t name, const char *interface, uint32_t version) {
- struct wlr_wl_backend *backend = data;
+ struct wlr_backend_state *state = data;
wlr_log(L_DEBUG, "Remote wayland global: %s v%d", interface, version);
if (strcmp(interface, wl_compositor_interface.name) == 0) {
- backend->compositor = wl_registry_bind(registry, name,
+ state->compositor = wl_registry_bind(registry, name,
&wl_compositor_interface, version);
} else if (strcmp(interface, wl_shell_interface.name) == 0) {
- backend->shell = wl_registry_bind(registry, name,
+ state->shell = wl_registry_bind(registry, name,
&wl_shell_interface, version);
} else if (strcmp(interface, wl_shm_interface.name) == 0) {
- backend->shm = wl_registry_bind(registry, name,
+ state->shm = wl_registry_bind(registry, name,
&wl_shm_interface, version);
} else if (strcmp(interface, wl_seat_interface.name) == 0) {
- struct wl_seat *wl_seat = wl_registry_bind(registry, name,
+ state->seat = wl_registry_bind(registry, name,
&wl_seat_interface, version);
- registry_wl_seat(backend, wl_seat, registry, version);
- } else if (strcmp(interface, wl_output_interface.name) == 0) {
- struct wl_output *wl_output = wl_registry_bind(registry, name,
- &wl_output_interface, version);
- registry_wl_output(backend, wl_output, registry, version);
+ wl_seat_add_listener(state->seat, &seat_listener, state);
}
}
@@ -86,8 +38,8 @@ static const struct wl_registry_listener registry_listener = {
.global_remove = registry_global_remove
};
-void wlr_wlb_registry_poll(struct wlr_wl_backend *backend) {
- wl_registry_add_listener(backend->registry, &registry_listener, backend);
- wl_display_dispatch(backend->remote_display);
- wl_display_roundtrip(backend->remote_display);
+void wlr_wl_registry_poll(struct wlr_backend_state *state) {
+ wl_registry_add_listener(state->registry, &registry_listener, state);
+ wl_display_dispatch(state->remote_display);
+ wl_display_roundtrip(state->remote_display);
}
diff --git a/backend/wayland/wl_output.c b/backend/wayland/wl_output.c
deleted file mode 100644
index cc4e9cce..00000000
--- a/backend/wayland/wl_output.c
+++ /dev/null
@@ -1,64 +0,0 @@
-#define _XOPEN_SOURCE 500
-#include <string.h>
-#include <assert.h>
-#include <stdlib.h>
-#include <stdint.h>
-#include <wayland-client.h>
-#include "backend/wayland.h"
-#include "common/log.h"
-
-static void wl_output_handle_mode(void *data, struct wl_output *wl_output,
- uint32_t flags, int32_t width, int32_t height, int32_t refresh) {
- struct wlr_wl_output *output = data;
- assert(output->wl_output == wl_output);
- struct wlr_wl_output_mode *mode;
- if (!(mode = calloc(sizeof(struct wlr_wl_output_mode), 1))) {
- wlr_log(L_ERROR, "Failed to allocate wlr_wl_output_mode");
- return;
- }
- mode->flags = flags;
- mode->width = width;
- mode->height = height;
- mode->refresh = refresh;
- list_add(output->modes, mode);
- wlr_log(L_DEBUG, "Got mode for output %p: %dx%d @ %.2fHz%s%s",
- wl_output, width, height, refresh / 1000.0,
- (flags & WL_OUTPUT_MODE_PREFERRED) ? " (preferred)" : "",
- (flags & WL_OUTPUT_MODE_CURRENT) ? " (current)" : "");
-}
-
-static void wl_output_handle_geometry(void *data, struct wl_output *wl_output,
- int32_t x, int32_t y, int32_t physical_width, int32_t physical_height,
- int32_t subpixel, const char *make, const char *model, int32_t transform) {
- struct wlr_wl_output *output = data;
- assert(output->wl_output == wl_output);
- output->x = x;
- output->y = y;
- output->phys_width = physical_width;
- output->phys_height = physical_height;
- output->subpixel = subpixel;
- output->make = strdup(make);
- output->model = strdup(model);
- output->transform = transform;
- wlr_log(L_DEBUG, "Got info for output %p %dx%d (%dmm x %dmm) %s %s",
- wl_output, (int)x, (int)y, (int)physical_width, (int)physical_height,
- make, model);
-}
-
-static void wl_output_handle_scale(void *data, struct wl_output *wl_output, int32_t factor) {
- struct wlr_wl_output *output = data;
- assert(output->wl_output == wl_output);
- output->scale = factor;
- wlr_log(L_DEBUG, "Got scale factor for output %p: %d", wl_output, factor);
-}
-
-static void wl_output_handle_done(void *data, struct wl_output *wl_output) {
- // TODO: notify of changes? Probably not necessary for this backend
-}
-
-const struct wl_output_listener output_listener = {
- .mode = wl_output_handle_mode,
- .geometry = wl_output_handle_geometry,
- .scale = wl_output_handle_scale,
- .done = wl_output_handle_done
-};
diff --git a/backend/wayland/wl_seat.c b/backend/wayland/wl_seat.c
index bc2b21a8..240cbbb0 100644
--- a/backend/wayland/wl_seat.c
+++ b/backend/wayland/wl_seat.c
@@ -4,49 +4,89 @@
#include <stdint.h>
#include <string.h>
#include <wayland-client.h>
+#include <wlr/types.h>
+#include "types.h"
#include "backend/wayland.h"
#include "common/log.h"
+static void wlr_wl_device_destroy(struct wlr_input_device_state *state) {
+ free(state);
+}
+
+static struct wlr_input_device_impl input_device_impl = {
+ .destroy = wlr_wl_device_destroy
+};
+
+static struct wlr_input_device *allocate_device(struct wlr_backend_state *state,
+ enum wlr_input_device_type type) {
+ struct wlr_input_device_state *devstate =
+ calloc(1, sizeof(struct wlr_input_device_state));
+ if(!devstate) {
+ wlr_log(L_ERROR, "Allocation failed: %s", strerror(errno));
+ return NULL;
+ }
+
+ // TODO: any way to retrieve those information?
+ int vendor = 0;
+ int product = 0;
+ const char *name = "unknown;wayland";
+ struct wlr_input_device *wlr_device = wlr_input_device_create(
+ type, &input_device_impl, devstate,
+ name, vendor, product);
+ if(!wlr_device) {
+ free(devstate);
+ return NULL;
+ }
+
+ list_add(state->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_wl_seat *seat = data;
- assert(seat->wl_seat == wl_seat);
- struct wlr_wl_backend *backend = wl_seat_get_user_data(wl_seat);
- assert(backend);
+ struct wlr_backend_state *state = data;
+ assert(state->seat == wl_seat);
+ // TODO: add listeners and receive input
if ((caps & WL_SEAT_CAPABILITY_POINTER)) {
wlr_log(L_DEBUG, "seat %p offered pointer", wl_seat);
struct wl_pointer *wl_pointer = wl_seat_get_pointer(wl_seat);
- struct wlr_wl_pointer *pointer;
- if (!(pointer = calloc(sizeof(struct wlr_wl_pointer), 1))) {
+
+ struct wlr_input_device *wlr_device = allocate_device(state,
+ WLR_INPUT_DEVICE_POINTER);
+ if(!wlr_device) {
wl_pointer_destroy(wl_pointer);
- wlr_log(L_ERROR, "Unable to allocate wlr_wl_pointer");
+ wlr_log(L_ERROR, "Unable to allocate wl_pointer device");
return;
}
- pointer->wl_pointer = wl_pointer;
- //wl_pointer_add_listener(wl_pointer, &pointer_listener, backend->registry); TODO
- }
+ wlr_device->pointer = wlr_pointer_create(NULL, NULL);
+ list_add(state->devices, wlr_device);
+ wl_signal_emit(&state->backend->events.input_add, wlr_device);
+ }
if ((caps & WL_SEAT_CAPABILITY_KEYBOARD)) {
wlr_log(L_DEBUG, "seat %p offered keyboard", wl_seat);
struct wl_keyboard *wl_keyboard = wl_seat_get_keyboard(wl_seat);
- struct wlr_wl_keyboard *keyboard;
- if (!(keyboard = calloc(sizeof(struct wlr_wl_pointer), 1))) {
- wl_keyboard_destroy(wl_keyboard);
- wlr_log(L_ERROR, "Unable to allocate wlr_wl_keyboard");
+ struct wlr_input_device *wlr_device = allocate_device(state,
+ WLR_INPUT_DEVICE_KEYBOARD);
+ if(!wlr_device) {
+ wl_keyboard_release(wl_keyboard);
+ wlr_log(L_ERROR, "Unable to allocate wl_pointer device");
return;
}
- keyboard->wl_keyboard = wl_keyboard;
- //wl_keyboard_add_listener(wl_keyboard, &keyboard_listener, backend->registry); TODO
+
+ wlr_device->keyboard = wlr_keyboard_create(NULL, NULL);
+ list_add(state->devices, wlr_device);
+ wl_signal_emit(&state->backend->events.input_add, wlr_device);
}
// TODO: touch
}
static void seat_handle_name(void *data, struct wl_seat *wl_seat, const char *name) {
- struct wlr_wl_seat *seat = data;
- assert(seat->wl_seat == wl_seat);
- seat->name = strdup(name);
+ struct wlr_backend_state *state = data;
+ assert(state->seat == wl_seat);
+ state->seatName = strdup(name);
}
const struct wl_seat_listener seat_listener = {
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-07 13:01:48 +0000