aboutsummaryrefslogtreecommitdiff
path: root/backend
diff options
context:
space:
mode:
Diffstat (limited to 'backend')
-rw-r--r--backend/backend.c17
-rw-r--r--backend/drm/drm.c17
-rw-r--r--backend/meson.build2
-rw-r--r--backend/noop/backend.c68
-rw-r--r--backend/noop/output.c75
-rw-r--r--backend/session/direct-freebsd.c2
-rw-r--r--backend/session/direct-ipc.c2
-rw-r--r--backend/wayland/backend.c30
-rw-r--r--backend/wayland/output.c37
-rw-r--r--backend/x11/input_device.c4
10 files changed, 214 insertions, 40 deletions
diff --git a/backend/backend.c b/backend/backend.c
index b369a135..33ad20f2 100644
--- a/backend/backend.c
+++ b/backend/backend.c
@@ -11,6 +11,7 @@
#include <wlr/backend/interface.h>
#include <wlr/backend/libinput.h>
#include <wlr/backend/multi.h>
+#include <wlr/backend/noop.h>
#include <wlr/backend/session.h>
#include <wlr/backend/wayland.h>
#include <wlr/config.h>
@@ -133,6 +134,20 @@ static struct wlr_backend *attempt_headless_backend(
return backend;
}
+static struct wlr_backend *attempt_noop_backend(struct wl_display *display) {
+ struct wlr_backend *backend = wlr_noop_backend_create(display);
+ if (backend == NULL) {
+ return NULL;
+ }
+
+ size_t outputs = parse_outputs_env("WLR_NOOP_OUTPUTS");
+ for (size_t i = 0; i < outputs; ++i) {
+ wlr_noop_add_output(backend);
+ }
+
+ return backend;
+}
+
static struct wlr_backend *attempt_drm_backend(struct wl_display *display,
struct wlr_backend *backend, struct wlr_session *session,
wlr_renderer_create_func_t create_renderer_func) {
@@ -170,6 +185,8 @@ static struct wlr_backend *attempt_backend_by_name(struct wl_display *display,
#endif
} else if (strcmp(name, "headless") == 0) {
return attempt_headless_backend(display, create_renderer_func);
+ } else if (strcmp(name, "noop") == 0) {
+ return attempt_noop_backend(display);
} else if (strcmp(name, "drm") == 0 || strcmp(name, "libinput") == 0) {
// DRM and libinput need a session
if (!*session) {
diff --git a/backend/drm/drm.c b/backend/drm/drm.c
index 735b7c29..28ee41a5 100644
--- a/backend/drm/drm.c
+++ b/backend/drm/drm.c
@@ -391,6 +391,8 @@ static void attempt_enable_needs_modeset(struct wlr_drm_backend *drm) {
if (conn->state == WLR_DRM_CONN_NEEDS_MODESET &&
conn->crtc != NULL && conn->desired_mode != NULL &&
conn->desired_enabled) {
+ wlr_log(WLR_DEBUG, "Output %s has a desired mode and a CRTC, "
+ "attempting a modeset", conn->output.name);
drm_connector_set_mode(&conn->output, conn->desired_mode);
}
}
@@ -637,7 +639,7 @@ static bool drm_connector_set_cursor(struct wlr_output *output,
plane->surf.height, output->transform);
struct wlr_box hotspot = { .x = hotspot_x, .y = hotspot_y };
- wlr_box_transform(&hotspot, &hotspot,
+ wlr_box_transform(&hotspot, &hotspot,
wlr_output_transform_invert(output->transform),
plane->surf.width, plane->surf.height);
@@ -981,8 +983,17 @@ static void realloc_crtcs(struct wlr_drm_backend *drm, bool *changed_outputs) {
i++;
struct wlr_output_mode *mode = conn->output.current_mode;
- if (conn->state != WLR_DRM_CONN_CONNECTED || !changed_outputs[i]
- || conn->crtc == NULL) {
+ if (conn->state != WLR_DRM_CONN_CONNECTED || !changed_outputs[i]) {
+ continue;
+ }
+
+ if (conn->crtc == NULL) {
+ wlr_log(WLR_DEBUG, "Output has %s lost its CRTC",
+ conn->output.name);
+ conn->state = WLR_DRM_CONN_NEEDS_MODESET;
+ wlr_output_update_enabled(&conn->output, false);
+ conn->desired_mode = conn->output.current_mode;
+ wlr_output_update_mode(&conn->output, NULL);
continue;
}
diff --git a/backend/meson.build b/backend/meson.build
index bf9b4f83..39769ecd 100644
--- a/backend/meson.build
+++ b/backend/meson.build
@@ -20,6 +20,8 @@ backend_files = files(
'libinput/tablet_tool.c',
'libinput/touch.c',
'multi/backend.c',
+ 'noop/backend.c',
+ 'noop/output.c',
'session/direct-ipc.c',
'session/session.c',
'wayland/backend.c',
diff --git a/backend/noop/backend.c b/backend/noop/backend.c
new file mode 100644
index 00000000..340fce0d
--- /dev/null
+++ b/backend/noop/backend.c
@@ -0,0 +1,68 @@
+#include <assert.h>
+#include <stdlib.h>
+#include <wlr/interfaces/wlr_output.h>
+#include <wlr/util/log.h>
+#include "backend/noop.h"
+#include "util/signal.h"
+
+struct wlr_noop_backend *noop_backend_from_backend(
+ struct wlr_backend *wlr_backend) {
+ assert(wlr_backend_is_noop(wlr_backend));
+ return (struct wlr_noop_backend *)wlr_backend;
+}
+
+static bool backend_start(struct wlr_backend *wlr_backend) {
+ struct wlr_noop_backend *backend = noop_backend_from_backend(wlr_backend);
+ wlr_log(WLR_INFO, "Starting noop backend");
+
+ struct wlr_noop_output *output;
+ wl_list_for_each(output, &backend->outputs, link) {
+ wlr_output_update_enabled(&output->wlr_output, true);
+ wlr_signal_emit_safe(&backend->backend.events.new_output,
+ &output->wlr_output);
+ }
+
+ backend->started = true;
+ return true;
+}
+
+static void backend_destroy(struct wlr_backend *wlr_backend) {
+ struct wlr_noop_backend *backend = noop_backend_from_backend(wlr_backend);
+ if (!wlr_backend) {
+ return;
+ }
+
+ struct wlr_noop_output *output, *output_tmp;
+ wl_list_for_each_safe(output, output_tmp, &backend->outputs, link) {
+ wlr_output_destroy(&output->wlr_output);
+ }
+
+ wlr_signal_emit_safe(&wlr_backend->events.destroy, backend);
+
+ free(backend);
+}
+
+static const struct wlr_backend_impl backend_impl = {
+ .start = backend_start,
+ .destroy = backend_destroy,
+};
+
+struct wlr_backend *wlr_noop_backend_create(struct wl_display *display) {
+ wlr_log(WLR_INFO, "Creating noop backend");
+
+ struct wlr_noop_backend *backend =
+ calloc(1, sizeof(struct wlr_noop_backend));
+ if (!backend) {
+ wlr_log(WLR_ERROR, "Failed to allocate wlr_noop_backend");
+ return NULL;
+ }
+ wlr_backend_init(&backend->backend, &backend_impl);
+ backend->display = display;
+ wl_list_init(&backend->outputs);
+
+ return &backend->backend;
+}
+
+bool wlr_backend_is_noop(struct wlr_backend *backend) {
+ return backend->impl == &backend_impl;
+}
diff --git a/backend/noop/output.c b/backend/noop/output.c
new file mode 100644
index 00000000..a2595eff
--- /dev/null
+++ b/backend/noop/output.c
@@ -0,0 +1,75 @@
+#include <assert.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <wlr/interfaces/wlr_output.h>
+#include <wlr/util/log.h>
+#include "backend/noop.h"
+#include "util/signal.h"
+
+static struct wlr_noop_output *noop_output_from_output(
+ struct wlr_output *wlr_output) {
+ assert(wlr_output_is_noop(wlr_output));
+ return (struct wlr_noop_output *)wlr_output;
+}
+
+static void output_transform(struct wlr_output *wlr_output,
+ enum wl_output_transform transform) {
+ // empty
+}
+
+static bool output_make_current(struct wlr_output *wlr_output, int *buffer_age) {
+ return true;
+}
+
+static bool output_swap_buffers(struct wlr_output *wlr_output,
+ pixman_region32_t *damage) {
+ return true;
+}
+
+static void output_destroy(struct wlr_output *wlr_output) {
+ struct wlr_noop_output *output =
+ noop_output_from_output(wlr_output);
+
+ wl_list_remove(&output->link);
+
+ free(output);
+}
+
+static const struct wlr_output_impl output_impl = {
+ .transform = output_transform,
+ .destroy = output_destroy,
+ .make_current = output_make_current,
+ .swap_buffers = output_swap_buffers,
+};
+
+bool wlr_output_is_noop(struct wlr_output *wlr_output) {
+ return wlr_output->impl == &output_impl;
+}
+
+struct wlr_output *wlr_noop_add_output(struct wlr_backend *wlr_backend) {
+ struct wlr_noop_backend *backend = noop_backend_from_backend(wlr_backend);
+
+ struct wlr_noop_output *output = calloc(1, sizeof(struct wlr_noop_output));
+ if (output == NULL) {
+ wlr_log(WLR_ERROR, "Failed to allocate wlr_noop_output");
+ return NULL;
+ }
+ output->backend = backend;
+ wlr_output_init(&output->wlr_output, &backend->backend, &output_impl,
+ backend->display);
+ struct wlr_output *wlr_output = &output->wlr_output;
+
+ strncpy(wlr_output->make, "noop", sizeof(wlr_output->make));
+ strncpy(wlr_output->model, "noop", sizeof(wlr_output->model));
+ snprintf(wlr_output->name, sizeof(wlr_output->name), "NOOP-%d",
+ wl_list_length(&backend->outputs) + 1);
+
+ wl_list_insert(&backend->outputs, &output->link);
+
+ if (backend->started) {
+ wlr_output_update_enabled(wlr_output, true);
+ wlr_signal_emit_safe(&backend->backend.events.new_output, wlr_output);
+ }
+
+ return wlr_output;
+}
diff --git a/backend/session/direct-freebsd.c b/backend/session/direct-freebsd.c
index 342d0d4e..391cc3fd 100644
--- a/backend/session/direct-freebsd.c
+++ b/backend/session/direct-freebsd.c
@@ -1,5 +1,5 @@
#include <assert.h>
-#include <dev/evdev/input.h>
+#include <linux/input.h>
#include <errno.h>
#include <fcntl.h>
#include <signal.h>
diff --git a/backend/session/direct-ipc.c b/backend/session/direct-ipc.c
index 2b9634da..42ca00e1 100644
--- a/backend/session/direct-ipc.c
+++ b/backend/session/direct-ipc.c
@@ -1,7 +1,7 @@
#define _POSIX_C_SOURCE 200809L
#ifdef __FreeBSD__
#define __BSD_VISIBLE 1
-#include <dev/evdev/input.h>
+#include <linux/input.h>
#endif
#include <errno.h>
#include <fcntl.h>
diff --git a/backend/wayland/backend.c b/backend/wayland/backend.c
index df1bf431..da41af02 100644
--- a/backend/wayland/backend.c
+++ b/backend/wayland/backend.c
@@ -18,7 +18,7 @@
#include "backend/wayland.h"
#include "util/signal.h"
-#include "xdg-shell-unstable-v6-client-protocol.h"
+#include "xdg-shell-client-protocol.h"
struct wlr_wl_backend *get_wl_backend_from_backend(struct wlr_backend *backend) {
assert(wlr_backend_is_wl(backend));
@@ -49,13 +49,13 @@ static int dispatch_events(int fd, uint32_t mask, void *data) {
return 0;
}
-static void xdg_shell_handle_ping(void *data, struct zxdg_shell_v6 *shell,
- uint32_t serial) {
- zxdg_shell_v6_pong(shell, serial);
+static void xdg_wm_base_handle_ping(void *data,
+ struct xdg_wm_base *base, uint32_t serial) {
+ xdg_wm_base_pong(base, serial);
}
-static const struct zxdg_shell_v6_listener xdg_shell_listener = {
- xdg_shell_handle_ping,
+static const struct xdg_wm_base_listener xdg_wm_base_listener = {
+ xdg_wm_base_handle_ping,
};
static void registry_global(void *data, struct wl_registry *registry,
@@ -77,10 +77,10 @@ static void registry_global(void *data, struct wl_registry *registry,
wl->shm = wl_registry_bind(registry, name,
&wl_shm_interface, 1);
- } else if (strcmp(iface, zxdg_shell_v6_interface.name) == 0) {
- wl->shell = wl_registry_bind(registry, name,
- &zxdg_shell_v6_interface, 1);
- zxdg_shell_v6_add_listener(wl->shell, &xdg_shell_listener, NULL);
+ } else if (strcmp(iface, xdg_wm_base_interface.name) == 0) {
+ wl->xdg_wm_base = wl_registry_bind(registry, name,
+ &xdg_wm_base_interface, 1);
+ xdg_wm_base_add_listener(wl->xdg_wm_base, &xdg_wm_base_listener, NULL);
}
}
@@ -153,7 +153,7 @@ static void backend_destroy(struct wlr_backend *backend) {
if (wl->shm) {
wl_shm_destroy(wl->shm);
}
- zxdg_shell_v6_destroy(wl->shell);
+ xdg_wm_base_destroy(wl->xdg_wm_base);
wl_compositor_destroy(wl->compositor);
wl_registry_destroy(wl->registry);
wl_display_disconnect(wl->remote_display);
@@ -218,9 +218,9 @@ struct wlr_backend *wlr_wl_backend_create(struct wl_display *display,
"Remote Wayland compositor does not support wl_compositor");
goto error_registry;
}
- if (!wl->shell) {
+ if (!wl->xdg_wm_base) {
wlr_log(WLR_ERROR,
- "Remote Wayland compositor does not support zxdg_shell_v6");
+ "Remote Wayland compositor does not support xdg-shell");
goto error_registry;
}
@@ -267,8 +267,8 @@ error_registry:
if (wl->compositor) {
wl_compositor_destroy(wl->compositor);
}
- if (wl->shell) {
- zxdg_shell_v6_destroy(wl->shell);
+ if (wl->xdg_wm_base) {
+ xdg_wm_base_destroy(wl->xdg_wm_base);
}
wl_registry_destroy(wl->registry);
error_display:
diff --git a/backend/wayland/output.c b/backend/wayland/output.c
index 89d5b5c9..a515374b 100644
--- a/backend/wayland/output.c
+++ b/backend/wayland/output.c
@@ -16,7 +16,7 @@
#include "backend/wayland.h"
#include "util/signal.h"
-#include "xdg-shell-unstable-v6-client-protocol.h"
+#include "xdg-shell-client-protocol.h"
static struct wlr_wl_output *get_wl_output_from_output(
struct wlr_output *wlr_output) {
@@ -181,8 +181,8 @@ static void output_destroy(struct wlr_output *wlr_output) {
wlr_egl_destroy_surface(&output->backend->egl, output->egl_surface);
wl_egl_window_destroy(output->egl_window);
- zxdg_toplevel_v6_destroy(output->xdg_toplevel);
- zxdg_surface_v6_destroy(output->xdg_surface);
+ xdg_toplevel_destroy(output->xdg_toplevel);
+ xdg_surface_destroy(output->xdg_surface);
wl_surface_destroy(output->surface);
free(output);
}
@@ -229,22 +229,22 @@ bool wlr_output_is_wl(struct wlr_output *wlr_output) {
return wlr_output->impl == &output_impl;
}
-static void xdg_surface_handle_configure(void *data, struct zxdg_surface_v6 *xdg_surface,
- uint32_t serial) {
+static void xdg_surface_handle_configure(void *data,
+ struct xdg_surface *xdg_surface, uint32_t serial) {
struct wlr_wl_output *output = data;
assert(output && output->xdg_surface == xdg_surface);
- zxdg_surface_v6_ack_configure(xdg_surface, serial);
+ xdg_surface_ack_configure(xdg_surface, serial);
// nothing else?
}
-static struct zxdg_surface_v6_listener xdg_surface_listener = {
+static struct xdg_surface_listener xdg_surface_listener = {
.configure = xdg_surface_handle_configure,
};
static void xdg_toplevel_handle_configure(void *data,
- struct zxdg_toplevel_v6 *xdg_toplevel,
+ struct xdg_toplevel *xdg_toplevel,
int32_t width, int32_t height, struct wl_array *states) {
struct wlr_wl_output *output = data;
assert(output && output->xdg_toplevel == xdg_toplevel);
@@ -258,14 +258,14 @@ static void xdg_toplevel_handle_configure(void *data,
}
static void xdg_toplevel_handle_close(void *data,
- struct zxdg_toplevel_v6 *xdg_toplevel) {
+ struct xdg_toplevel *xdg_toplevel) {
struct wlr_wl_output *output = data;
assert(output && output->xdg_toplevel == xdg_toplevel);
wlr_output_destroy((struct wlr_output *)output);
}
-static struct zxdg_toplevel_v6_listener xdg_toplevel_listener = {
+static struct xdg_toplevel_listener xdg_toplevel_listener = {
.configure = xdg_toplevel_handle_configure,
.close = xdg_toplevel_handle_close,
};
@@ -301,13 +301,13 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *wlr_backend) {
}
wl_surface_set_user_data(output->surface, output);
output->xdg_surface =
- zxdg_shell_v6_get_xdg_surface(backend->shell, output->surface);
+ xdg_wm_base_get_xdg_surface(backend->xdg_wm_base, output->surface);
if (!output->xdg_surface) {
wlr_log_errno(WLR_ERROR, "Could not get xdg surface");
goto error;
}
output->xdg_toplevel =
- zxdg_surface_v6_get_toplevel(output->xdg_surface);
+ xdg_surface_get_toplevel(output->xdg_surface);
if (!output->xdg_toplevel) {
wlr_log_errno(WLR_ERROR, "Could not get xdg toplevel");
goto error;
@@ -315,13 +315,13 @@ struct wlr_output *wlr_wl_output_create(struct wlr_backend *wlr_backend) {
char title[32];
if (snprintf(title, sizeof(title), "wlroots - %s", wlr_output->name)) {
- zxdg_toplevel_v6_set_title(output->xdg_toplevel, title);
+ xdg_toplevel_set_title(output->xdg_toplevel, title);
}
- zxdg_toplevel_v6_set_app_id(output->xdg_toplevel, "wlroots");
- zxdg_surface_v6_add_listener(output->xdg_surface,
+ xdg_toplevel_set_app_id(output->xdg_toplevel, "wlroots");
+ xdg_surface_add_listener(output->xdg_surface,
&xdg_surface_listener, output);
- zxdg_toplevel_v6_add_listener(output->xdg_toplevel,
+ xdg_toplevel_add_listener(output->xdg_toplevel,
&xdg_toplevel_listener, output);
wl_surface_commit(output->surface);
@@ -365,3 +365,8 @@ error:
wlr_output_destroy(&output->wlr_output);
return NULL;
}
+
+void wlr_wl_output_set_title(struct wlr_output *output, const char *title) {
+ struct wlr_wl_output *wl_output = get_wl_output_from_output(output);
+ xdg_toplevel_set_title(wl_output->xdg_toplevel, title);
+}
diff --git a/backend/x11/input_device.c b/backend/x11/input_device.c
index a50f478a..915d9958 100644
--- a/backend/x11/input_device.c
+++ b/backend/x11/input_device.c
@@ -2,11 +2,7 @@
#include <wlr/config.h>
-#ifdef __linux__
#include <linux/input-event-codes.h>
-#elif __FreeBSD__
-#include <dev/evdev/input-event-codes.h>
-#endif
#include <xcb/xcb.h>
#include <xcb/xfixes.h>
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-12 02:36:11 +0000