diff options
Diffstat (limited to 'backend/x11')
| -rw-r--r-- | backend/x11/backend.c | 314 | ||||
| -rw-r--r-- | backend/x11/input_device.c | 244 | ||||
| -rw-r--r-- | backend/x11/meson.build | 35 | ||||
| -rw-r--r-- | backend/x11/output.c | 236 |
4 files changed, 829 insertions, 0 deletions
diff --git a/backend/x11/backend.c b/backend/x11/backend.c new file mode 100644 index 00000000..38715631 --- /dev/null +++ b/backend/x11/backend.c @@ -0,0 +1,314 @@ +#define _POSIX_C_SOURCE 200112L + +#include <assert.h> +#include <limits.h> +#include <stdbool.h> +#include <stdio.h> +#include <stdlib.h> +#include <time.h> + +#include <wlr/config.h> + +#include <X11/Xlib-xcb.h> +#include <wayland-server.h> +#include <xcb/xcb.h> +#include <xcb/xfixes.h> +#include <xcb/xinput.h> + +#include <wlr/backend/interface.h> +#include <wlr/backend/x11.h> +#include <wlr/interfaces/wlr_input_device.h> +#include <wlr/interfaces/wlr_keyboard.h> +#include <wlr/interfaces/wlr_pointer.h> +#include <wlr/render/egl.h> +#include <wlr/render/wlr_renderer.h> +#include <wlr/util/log.h> + +#include "backend/x11.h" +#include "util/signal.h" + +struct wlr_x11_output *get_x11_output_from_window_id( + struct wlr_x11_backend *x11, xcb_window_t window) { + struct wlr_x11_output *output; + wl_list_for_each(output, &x11->outputs, link) { + if (output->win == window) { + return output; + } + } + return NULL; +} + +static void handle_x11_event(struct wlr_x11_backend *x11, + xcb_generic_event_t *event) { + switch (event->response_type & XCB_EVENT_RESPONSE_TYPE_MASK) { + case XCB_EXPOSE: { + xcb_expose_event_t *ev = (xcb_expose_event_t *)event; + struct wlr_x11_output *output = + get_x11_output_from_window_id(x11, ev->window); + if (output != NULL) { + wlr_output_update_needs_swap(&output->wlr_output); + } + break; + } + case XCB_CONFIGURE_NOTIFY: { + xcb_configure_notify_event_t *ev = + (xcb_configure_notify_event_t *)event; + struct wlr_x11_output *output = + get_x11_output_from_window_id(x11, ev->window); + if (output != NULL) { + handle_x11_configure_notify(output, ev); + } + break; + } + case XCB_CLIENT_MESSAGE: { + xcb_client_message_event_t *ev = (xcb_client_message_event_t *)event; + if (ev->data.data32[0] == x11->atoms.wm_delete_window) { + struct wlr_x11_output *output = + get_x11_output_from_window_id(x11, ev->window); + if (output != NULL) { + wlr_output_destroy(&output->wlr_output); + } + } + break; + } + case XCB_GE_GENERIC: { + xcb_ge_generic_event_t *ev = (xcb_ge_generic_event_t *)event; + if (ev->extension == x11->xinput_opcode) { + handle_x11_xinput_event(x11, ev); + } + } + } +} + +static int x11_event(int fd, uint32_t mask, void *data) { + struct wlr_x11_backend *x11 = data; + + if ((mask & WL_EVENT_HANGUP) || (mask & WL_EVENT_ERROR)) { + wl_display_terminate(x11->wl_display); + return 0; + } + + xcb_generic_event_t *e; + while ((e = xcb_poll_for_event(x11->xcb))) { + handle_x11_event(x11, e); + free(e); + } + + return 0; +} + +struct wlr_x11_backend *get_x11_backend_from_backend( + struct wlr_backend *wlr_backend) { + assert(wlr_backend_is_x11(wlr_backend)); + return (struct wlr_x11_backend *)wlr_backend; +} + +static bool backend_start(struct wlr_backend *backend) { + struct wlr_x11_backend *x11 = get_x11_backend_from_backend(backend); + x11->started = true; + + wlr_signal_emit_safe(&x11->backend.events.new_input, &x11->keyboard_dev); + + for (size_t i = 0; i < x11->requested_outputs; ++i) { + wlr_x11_output_create(&x11->backend); + } + + return true; +} + +static void backend_destroy(struct wlr_backend *backend) { + if (!backend) { + return; + } + + struct wlr_x11_backend *x11 = get_x11_backend_from_backend(backend); + + struct wlr_x11_output *output, *tmp; + wl_list_for_each_safe(output, tmp, &x11->outputs, link) { + wlr_output_destroy(&output->wlr_output); + } + + wlr_input_device_destroy(&x11->keyboard_dev); + + wlr_signal_emit_safe(&backend->events.destroy, backend); + + if (x11->event_source) { + wl_event_source_remove(x11->event_source); + } + wl_list_remove(&x11->display_destroy.link); + + wlr_renderer_destroy(x11->renderer); + wlr_egl_finish(&x11->egl); + + if (x11->xlib_conn) { + XCloseDisplay(x11->xlib_conn); + } + free(x11); +} + +static struct wlr_renderer *backend_get_renderer( + struct wlr_backend *backend) { + struct wlr_x11_backend *x11 = get_x11_backend_from_backend(backend); + return x11->renderer; +} + +static const struct wlr_backend_impl backend_impl = { + .start = backend_start, + .destroy = backend_destroy, + .get_renderer = backend_get_renderer, +}; + +bool wlr_backend_is_x11(struct wlr_backend *backend) { + return backend->impl == &backend_impl; +} + +static void handle_display_destroy(struct wl_listener *listener, void *data) { + struct wlr_x11_backend *x11 = + wl_container_of(listener, x11, display_destroy); + backend_destroy(&x11->backend); +} + +struct wlr_backend *wlr_x11_backend_create(struct wl_display *display, + const char *x11_display, + wlr_renderer_create_func_t create_renderer_func) { + struct wlr_x11_backend *x11 = calloc(1, sizeof(*x11)); + if (!x11) { + return NULL; + } + + wlr_backend_init(&x11->backend, &backend_impl); + x11->wl_display = display; + wl_list_init(&x11->outputs); + + x11->xlib_conn = XOpenDisplay(x11_display); + if (!x11->xlib_conn) { + wlr_log(WLR_ERROR, "Failed to open X connection"); + goto error_x11; + } + + x11->xcb = XGetXCBConnection(x11->xlib_conn); + if (!x11->xcb || xcb_connection_has_error(x11->xcb)) { + wlr_log(WLR_ERROR, "Failed to open xcb connection"); + goto error_display; + } + + XSetEventQueueOwner(x11->xlib_conn, XCBOwnsEventQueue); + + struct { + const char *name; + xcb_intern_atom_cookie_t cookie; + xcb_atom_t *atom; + } atom[] = { + { .name = "WM_PROTOCOLS", .atom = &x11->atoms.wm_protocols }, + { .name = "WM_DELETE_WINDOW", .atom = &x11->atoms.wm_delete_window }, + { .name = "_NET_WM_NAME", .atom = &x11->atoms.net_wm_name }, + { .name = "UTF8_STRING", .atom = &x11->atoms.utf8_string }, + }; + + for (size_t i = 0; i < sizeof(atom) / sizeof(atom[0]); ++i) { + atom[i].cookie = xcb_intern_atom(x11->xcb, + true, strlen(atom[i].name), atom[i].name); + } + + for (size_t i = 0; i < sizeof(atom) / sizeof(atom[0]); ++i) { + xcb_intern_atom_reply_t *reply = xcb_intern_atom_reply( + x11->xcb, atom[i].cookie, NULL); + + if (reply) { + *atom[i].atom = reply->atom; + free(reply); + } else { + *atom[i].atom = XCB_ATOM_NONE; + } + } + + const xcb_query_extension_reply_t *ext; + + ext = xcb_get_extension_data(x11->xcb, &xcb_xfixes_id); + if (!ext || !ext->present) { + wlr_log(WLR_ERROR, "X11 does not support Xfixes extension"); + goto error_display; + } + + xcb_xfixes_query_version_cookie_t fixes_cookie = + xcb_xfixes_query_version(x11->xcb, 4, 0); + xcb_xfixes_query_version_reply_t *fixes_reply = + xcb_xfixes_query_version_reply(x11->xcb, fixes_cookie, NULL); + + if (!fixes_reply || fixes_reply->major_version < 4) { + wlr_log(WLR_ERROR, "X11 does not support required Xfixes version"); + free(fixes_reply); + goto error_display; + } + free(fixes_reply); + + ext = xcb_get_extension_data(x11->xcb, &xcb_input_id); + if (!ext || !ext->present) { + wlr_log(WLR_ERROR, "X11 does not support Xinput extension"); + goto error_display; + } + x11->xinput_opcode = ext->major_opcode; + + xcb_input_xi_query_version_cookie_t xi_cookie = + xcb_input_xi_query_version(x11->xcb, 2, 0); + xcb_input_xi_query_version_reply_t *xi_reply = + xcb_input_xi_query_version_reply(x11->xcb, xi_cookie, NULL); + + if (!xi_reply || xi_reply->major_version < 2) { + wlr_log(WLR_ERROR, "X11 does not support required Xinput version"); + free(xi_reply); + goto error_display; + } + free(xi_reply); + + int fd = xcb_get_file_descriptor(x11->xcb); + struct wl_event_loop *ev = wl_display_get_event_loop(display); + uint32_t events = WL_EVENT_READABLE | WL_EVENT_ERROR | WL_EVENT_HANGUP; + x11->event_source = wl_event_loop_add_fd(ev, fd, events, x11_event, x11); + if (!x11->event_source) { + wlr_log(WLR_ERROR, "Could not create event source"); + goto error_display; + } + wl_event_source_check(x11->event_source); + + x11->screen = xcb_setup_roots_iterator(xcb_get_setup(x11->xcb)).data; + + if (!create_renderer_func) { + create_renderer_func = wlr_renderer_autocreate; + } + + static EGLint config_attribs[] = { + EGL_SURFACE_TYPE, EGL_WINDOW_BIT, + EGL_RED_SIZE, 1, + EGL_GREEN_SIZE, 1, + EGL_BLUE_SIZE, 1, + EGL_ALPHA_SIZE, 0, + EGL_NONE, + }; + + x11->renderer = create_renderer_func(&x11->egl, EGL_PLATFORM_X11_KHR, + x11->xlib_conn, config_attribs, x11->screen->root_visual); + + if (x11->renderer == NULL) { + wlr_log(WLR_ERROR, "Failed to create renderer"); + goto error_event; + } + + wlr_input_device_init(&x11->keyboard_dev, WLR_INPUT_DEVICE_KEYBOARD, + &input_device_impl, "X11 keyboard", 0, 0); + wlr_keyboard_init(&x11->keyboard, &keyboard_impl); + x11->keyboard_dev.keyboard = &x11->keyboard; + + x11->display_destroy.notify = handle_display_destroy; + wl_display_add_destroy_listener(display, &x11->display_destroy); + + return &x11->backend; + +error_event: + wl_event_source_remove(x11->event_source); +error_display: + XCloseDisplay(x11->xlib_conn); +error_x11: + free(x11); + return NULL; +} diff --git a/backend/x11/input_device.c b/backend/x11/input_device.c new file mode 100644 index 00000000..a50f478a --- /dev/null +++ b/backend/x11/input_device.c @@ -0,0 +1,244 @@ +#include <stdlib.h> + +#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> +#include <xcb/xinput.h> + +#include <wlr/interfaces/wlr_input_device.h> +#include <wlr/interfaces/wlr_keyboard.h> +#include <wlr/interfaces/wlr_pointer.h> +#include <wlr/util/log.h> + +#include "backend/x11.h" +#include "util/signal.h" + +static void send_key_event(struct wlr_x11_backend *x11, uint32_t key, + enum wlr_key_state st, xcb_timestamp_t time) { + struct wlr_event_keyboard_key ev = { + .time_msec = time, + .keycode = key, + .state = st, + .update_state = true, + }; + wlr_keyboard_notify_key(&x11->keyboard, &ev); +} + +static void send_button_event(struct wlr_x11_output *output, uint32_t key, + enum wlr_button_state st, xcb_timestamp_t time) { + struct wlr_event_pointer_button ev = { + .device = &output->pointer_dev, + .time_msec = time, + .button = key, + .state = st, + }; + wlr_signal_emit_safe(&output->pointer.events.button, &ev); +} + +static void send_axis_event(struct wlr_x11_output *output, int32_t delta, + xcb_timestamp_t time) { + struct wlr_event_pointer_axis ev = { + .device = &output->pointer_dev, + .time_msec = time, + .source = WLR_AXIS_SOURCE_WHEEL, + .orientation = WLR_AXIS_ORIENTATION_VERTICAL, + // 15 is a typical value libinput sends for one scroll + .delta = delta * 15, + .delta_discrete = delta, + }; + wlr_signal_emit_safe(&output->pointer.events.axis, &ev); +} + +static void send_pointer_position_event(struct wlr_x11_output *output, + int16_t x, int16_t y, xcb_timestamp_t time) { + struct wlr_event_pointer_motion_absolute ev = { + .device = &output->pointer_dev, + .time_msec = time, + .x = (double)x / output->wlr_output.width, + .y = (double)y / output->wlr_output.height, + }; + wlr_signal_emit_safe(&output->pointer.events.motion_absolute, &ev); +} + +void handle_x11_xinput_event(struct wlr_x11_backend *x11, + xcb_ge_generic_event_t *event) { + struct wlr_x11_output *output; + + switch (event->event_type) { + case XCB_INPUT_KEY_PRESS: { + xcb_input_key_press_event_t *ev = + (xcb_input_key_press_event_t *)event; + + wlr_keyboard_notify_modifiers(&x11->keyboard, ev->mods.base, + ev->mods.latched, ev->mods.locked, ev->mods.effective); + send_key_event(x11, ev->detail - 8, WLR_KEY_PRESSED, ev->time); + x11->time = ev->time; + break; + } + case XCB_INPUT_KEY_RELEASE: { + xcb_input_key_release_event_t *ev = + (xcb_input_key_release_event_t *)event; + + wlr_keyboard_notify_modifiers(&x11->keyboard, ev->mods.base, + ev->mods.latched, ev->mods.locked, ev->mods.effective); + send_key_event(x11, ev->detail - 8, WLR_KEY_RELEASED, ev->time); + x11->time = ev->time; + break; + } + case XCB_INPUT_BUTTON_PRESS: { + xcb_input_button_press_event_t *ev = + (xcb_input_button_press_event_t *)event; + + output = get_x11_output_from_window_id(x11, ev->event); + if (!output) { + return; + } + + switch (ev->detail) { + case XCB_BUTTON_INDEX_1: + send_button_event(output, BTN_LEFT, WLR_BUTTON_PRESSED, + ev->time); + break; + case XCB_BUTTON_INDEX_2: + send_button_event(output, BTN_MIDDLE, WLR_BUTTON_PRESSED, + ev->time); + break; + case XCB_BUTTON_INDEX_3: + send_button_event(output, BTN_RIGHT, WLR_BUTTON_PRESSED, + ev->time); + break; + case XCB_BUTTON_INDEX_4: + send_axis_event(output, -1, ev->time); + break; + case XCB_BUTTON_INDEX_5: + send_axis_event(output, 1, ev->time); + break; + } + + x11->time = ev->time; + break; + } + case XCB_INPUT_BUTTON_RELEASE: { + xcb_input_button_release_event_t *ev = + (xcb_input_button_release_event_t *)event; + + output = get_x11_output_from_window_id(x11, ev->event); + if (!output) { + return; + } + + switch (ev->detail) { + case XCB_BUTTON_INDEX_1: + send_button_event(output, BTN_LEFT, WLR_BUTTON_RELEASED, + ev->time); + break; + case XCB_BUTTON_INDEX_2: + send_button_event(output, BTN_MIDDLE, WLR_BUTTON_RELEASED, + ev->time); + break; + case XCB_BUTTON_INDEX_3: + send_button_event(output, BTN_RIGHT, WLR_BUTTON_RELEASED, + ev->time); + break; + } + + x11->time = ev->time; + break; + } + case XCB_INPUT_MOTION: { + xcb_input_motion_event_t *ev = (xcb_input_motion_event_t *)event; + + output = get_x11_output_from_window_id(x11, ev->event); + if (!output) { + return; + } + + send_pointer_position_event(output, ev->event_x >> 16, + ev->event_y >> 16, ev->time); + x11->time = ev->time; + break; + } + case XCB_INPUT_ENTER: { + xcb_input_enter_event_t *ev = (xcb_input_enter_event_t *)event; + + output = get_x11_output_from_window_id(x11, ev->event); + if (!output) { + return; + } + + if (!output->cursor_hidden) { + xcb_xfixes_hide_cursor(x11->xcb, output->win); + xcb_flush(x11->xcb); + output->cursor_hidden = true; + } + break; + } + case XCB_INPUT_LEAVE: { + xcb_input_leave_event_t *ev = (xcb_input_leave_event_t *)event; + + output = get_x11_output_from_window_id(x11, ev->event); + if (!output) { + return; + } + + if (output->cursor_hidden) { + xcb_xfixes_show_cursor(x11->xcb, output->win); + xcb_flush(x11->xcb); + output->cursor_hidden = false; + } + break; + } + } +} + +static void input_device_destroy(struct wlr_input_device *wlr_device) { + // Don't free the input device, it's on the stack +} + +const struct wlr_input_device_impl input_device_impl = { + .destroy = input_device_destroy, +}; + +static void keyboard_destroy(struct wlr_keyboard *wlr_keyboard) { + // Don't free the keyboard, it's on the stack +} + +const struct wlr_keyboard_impl keyboard_impl = { + .destroy = keyboard_destroy, +}; + +static void pointer_destroy(struct wlr_pointer *wlr_pointer) { + // Don't free the pointer, it's on the stack +} + +const struct wlr_pointer_impl pointer_impl = { + .destroy = pointer_destroy, +}; + +void update_x11_pointer_position(struct wlr_x11_output *output, + xcb_timestamp_t time) { + struct wlr_x11_backend *x11 = output->x11; + + xcb_query_pointer_cookie_t cookie = + xcb_query_pointer(x11->xcb, output->win); + xcb_query_pointer_reply_t *reply = + xcb_query_pointer_reply(x11->xcb, cookie, NULL); + if (!reply) { + return; + } + + send_pointer_position_event(output, reply->win_x, reply->win_y, time); + + free(reply); +} + +bool wlr_input_device_is_x11(struct wlr_input_device *wlr_dev) { + return wlr_dev->impl == &input_device_impl; +} diff --git a/backend/x11/meson.build b/backend/x11/meson.build new file mode 100644 index 00000000..19e873ab --- /dev/null +++ b/backend/x11/meson.build @@ -0,0 +1,35 @@ +x11_libs = [] +x11_required = [ + 'x11-xcb', + 'xcb', + 'xcb-xinput', + 'xcb-xfixes', +] + +foreach lib : x11_required + dep = dependency(lib, required: get_option('x11-backend')) + if not dep.found() + subdir_done() + endif + + x11_libs += dep +endforeach + +lib_wlr_backend_x11 = static_library( + 'wlr_backend_x11', + files( + 'backend.c', + 'input_device.c', + 'output.c', + ), + include_directories: wlr_inc, + dependencies: [ + wayland_server, + pixman, + xkbcommon, + x11_libs, + ], +) + +backend_parts += lib_wlr_backend_x11 +conf_data.set10('WLR_HAS_X11_BACKEND', true) diff --git a/backend/x11/output.c b/backend/x11/output.c new file mode 100644 index 00000000..6f98c590 --- /dev/null +++ b/backend/x11/output.c @@ -0,0 +1,236 @@ +#define _POSIX_C_SOURCE 200809L + +#include <assert.h> +#include <stdlib.h> +#include <string.h> + +#include <xcb/xcb.h> +#include <xcb/xinput.h> + +#include <wlr/interfaces/wlr_output.h> +#include <wlr/interfaces/wlr_pointer.h> +#include <wlr/util/log.h> + +#include "backend/x11.h" +#include "util/signal.h" + +static int signal_frame(void *data) { + struct wlr_x11_output *output = data; + wlr_output_send_frame(&output->wlr_output); + wl_event_source_timer_update(output->frame_timer, output->frame_delay); + return 0; +} + +static void parse_xcb_setup(struct wlr_output *output, + xcb_connection_t *xcb) { + const xcb_setup_t *xcb_setup = xcb_get_setup(xcb); + + snprintf(output->make, sizeof(output->make), "%.*s", + xcb_setup_vendor_length(xcb_setup), + xcb_setup_vendor(xcb_setup)); + snprintf(output->model, sizeof(output->model), "%"PRIu16".%"PRIu16, + xcb_setup->protocol_major_version, + xcb_setup->protocol_minor_version); +} + +static struct wlr_x11_output *get_x11_output_from_output( + struct wlr_output *wlr_output) { + assert(wlr_output_is_x11(wlr_output)); + return (struct wlr_x11_output *)wlr_output; +} + +static void output_set_refresh(struct wlr_output *wlr_output, int32_t refresh) { + struct wlr_x11_output *output = get_x11_output_from_output(wlr_output); + + if (refresh <= 0) { + refresh = X11_DEFAULT_REFRESH; + } + + wlr_output_update_custom_mode(&output->wlr_output, wlr_output->width, + wlr_output->height, refresh); + + output->frame_delay = 1000000 / refresh; +} + +static bool output_set_custom_mode(struct wlr_output *wlr_output, + int32_t width, int32_t height, int32_t refresh) { + struct wlr_x11_output *output = get_x11_output_from_output(wlr_output); + struct wlr_x11_backend *x11 = output->x11; + + output_set_refresh(&output->wlr_output, refresh); + + const uint32_t values[] = { width, height }; + xcb_void_cookie_t cookie = xcb_configure_window_checked( + x11->xcb, output->win, + XCB_CONFIG_WINDOW_WIDTH | XCB_CONFIG_WINDOW_HEIGHT, values); + + xcb_generic_error_t *error; + if ((error = xcb_request_check(x11->xcb, cookie))) { + wlr_log(WLR_ERROR, "Could not set window size to %dx%d\n", + width, height); + free(error); + return false; + } + + return true; +} + +static void output_transform(struct wlr_output *wlr_output, + enum wl_output_transform transform) { + struct wlr_x11_output *output = get_x11_output_from_output(wlr_output); + output->wlr_output.transform = transform; +} + +static void output_destroy(struct wlr_output *wlr_output) { + struct wlr_x11_output *output = get_x11_output_from_output(wlr_output); + struct wlr_x11_backend *x11 = output->x11; + + wlr_input_device_destroy(&output->pointer_dev); + + wl_list_remove(&output->link); + wl_event_source_remove(output->frame_timer); + wlr_egl_destroy_surface(&x11->egl, output->surf); + xcb_destroy_window(x11->xcb, output->win); + xcb_flush(x11->xcb); + free(output); +} + +static bool output_make_current(struct wlr_output *wlr_output, + int *buffer_age) { + struct wlr_x11_output *output = get_x11_output_from_output(wlr_output); + struct wlr_x11_backend *x11 = output->x11; + + return wlr_egl_make_current(&x11->egl, output->surf, buffer_age); +} + +static bool output_swap_buffers(struct wlr_output *wlr_output, + pixman_region32_t *damage) { + struct wlr_x11_output *output = (struct wlr_x11_output *)wlr_output; + struct wlr_x11_backend *x11 = output->x11; + + if (!wlr_egl_swap_buffers(&x11->egl, output->surf, damage)) { + return false; + } + + wlr_output_send_present(wlr_output, NULL); + return true; +} + +static const struct wlr_output_impl output_impl = { + .set_custom_mode = output_set_custom_mode, + .transform = output_transform, + .destroy = output_destroy, + .make_current = output_make_current, + .swap_buffers = output_swap_buffers, +}; + +struct wlr_output *wlr_x11_output_create(struct wlr_backend *backend) { + struct wlr_x11_backend *x11 = get_x11_backend_from_backend(backend); + + if (!x11->started) { + ++x11->requested_outputs; + return NULL; + } + + struct wlr_x11_output *output = calloc(1, sizeof(struct wlr_x11_output)); + if (output == NULL) { + return NULL; + } + output->x11 = x11; + + struct wlr_output *wlr_output = &output->wlr_output; + wlr_output_init(wlr_output, &x11->backend, &output_impl, x11->wl_display); + + wlr_output->width = 1024; + wlr_output->height = 768; + + output_set_refresh(&output->wlr_output, 0); + + snprintf(wlr_output->name, sizeof(wlr_output->name), "X11-%d", + wl_list_length(&x11->outputs) + 1); + parse_xcb_setup(wlr_output, x11->xcb); + + uint32_t mask = XCB_CW_EVENT_MASK; + uint32_t values[] = { + XCB_EVENT_MASK_EXPOSURE | XCB_EVENT_MASK_STRUCTURE_NOTIFY + }; + output->win = xcb_generate_id(x11->xcb); + xcb_create_window(x11->xcb, XCB_COPY_FROM_PARENT, output->win, + x11->screen->root, 0, 0, wlr_output->width, wlr_output->height, 1, + XCB_WINDOW_CLASS_INPUT_OUTPUT, x11->screen->root_visual, mask, values); + + struct { + xcb_input_event_mask_t head; + xcb_input_xi_event_mask_t mask; + } xinput_mask = { + .head = { .deviceid = XCB_INPUT_DEVICE_ALL_MASTER, .mask_len = 1 }, + .mask = XCB_INPUT_XI_EVENT_MASK_KEY_PRESS | + XCB_INPUT_XI_EVENT_MASK_KEY_RELEASE | + XCB_INPUT_XI_EVENT_MASK_BUTTON_PRESS | + XCB_INPUT_XI_EVENT_MASK_BUTTON_RELEASE | + XCB_INPUT_XI_EVENT_MASK_MOTION | + XCB_INPUT_XI_EVENT_MASK_ENTER | + XCB_INPUT_XI_EVENT_MASK_LEAVE, + }; + xcb_input_xi_select_events(x11->xcb, output->win, 1, &xinput_mask.head); + + output->surf = wlr_egl_create_surface(&x11->egl, &output->win); + if (!output->surf) { + wlr_log(WLR_ERROR, "Failed to create EGL surface"); + free(output); + return NULL; + } + + xcb_change_property(x11->xcb, XCB_PROP_MODE_REPLACE, output->win, + x11->atoms.wm_protocols, XCB_ATOM_ATOM, 32, 1, + &x11->atoms.wm_delete_window); + + char title[32]; + if (snprintf(title, sizeof(title), "wlroots - %s", wlr_output->name)) { + xcb_change_property(x11->xcb, XCB_PROP_MODE_REPLACE, output->win, + x11->atoms.net_wm_name, x11->atoms.utf8_string, 8, + strlen(title), title); + } + + xcb_map_window(x11->xcb, output->win); + xcb_flush(x11->xcb); + + struct wl_event_loop *ev = wl_display_get_event_loop(x11->wl_display); + output->frame_timer = wl_event_loop_add_timer(ev, signal_frame, output); + + wl_list_insert(&x11->outputs, &output->link); + + wl_event_source_timer_update(output->frame_timer, output->frame_delay); + wlr_output_update_enabled(wlr_output, true); + + wlr_input_device_init(&output->pointer_dev, WLR_INPUT_DEVICE_POINTER, + &input_device_impl, "X11 pointer", 0, 0); + wlr_pointer_init(&output->pointer, &pointer_impl); + output->pointer_dev.pointer = &output->pointer; + output->pointer_dev.output_name = strdup(wlr_output->name); + + wlr_signal_emit_safe(&x11->backend.events.new_output, wlr_output); + wlr_signal_emit_safe(&x11->backend.events.new_input, &output->pointer_dev); + + return wlr_output; +} + +void handle_x11_configure_notify(struct wlr_x11_output *output, + xcb_configure_notify_event_t *ev) { + // ignore events that set an invalid size: + if (ev->width > 0 && ev->height > 0) { + wlr_output_update_custom_mode(&output->wlr_output, ev->width, + ev->height, output->wlr_output.refresh); + + // Move the pointer to its new location + update_x11_pointer_position(output, output->x11->time); + } else { + wlr_log(WLR_DEBUG, + "Ignoring X11 configure event for height=%d, width=%d", + ev->width, ev->height); + } +} + +bool wlr_output_is_x11(struct wlr_output *wlr_output) { + return wlr_output->impl == &output_impl; +} |