From e3d47376dc9a7ffef3823cb2b4db78296e3cf717 Mon Sep 17 00:00:00 2001 From: Tony Crisci Date: Sun, 20 Aug 2017 16:02:39 -0400 Subject: [PATCH] add wlr_cursor basic implementation --- backend/drm/drm.c | 27 +++++ examples/pointer.c | 202 ++++++++++++++++++++------------ examples/shared.c | 4 + examples/shared.h | 2 + include/wlr/types/wlr_cursor.h | 81 +++++++++++++ types/meson.build | 1 + types/wlr_cursor.c | 206 +++++++++++++++++++++++++++++++++ 7 files changed, 450 insertions(+), 73 deletions(-) create mode 100644 include/wlr/types/wlr_cursor.h create mode 100644 types/wlr_cursor.c diff --git a/backend/drm/drm.c b/backend/drm/drm.c index 332926b9..5b24e05f 100644 --- a/backend/drm/drm.c +++ b/backend/drm/drm.c @@ -598,6 +598,8 @@ static bool wlr_drm_output_set_cursor(struct wlr_output *_output, wlr_matrix_texture(plane->matrix, plane->width, plane->height, output->output.transform ^ WL_OUTPUT_TRANSFORM_FLIPPED_180); + // TODO the image needs to be rotated depending on the output rotation + plane->wlr_rend = wlr_gles2_renderer_create(&backend->backend); if (!plane->wlr_rend) { return false; @@ -651,6 +653,31 @@ static bool wlr_drm_output_move_cursor(struct wlr_output *_output, struct wlr_drm_output *output = (struct wlr_drm_output *)_output; struct wlr_drm_backend *backend = wl_container_of(output->renderer, backend, renderer); + + int width, height, tmp; + wlr_output_effective_resolution(_output, &width, &height); + + switch (_output->transform) { + case WL_OUTPUT_TRANSFORM_NORMAL: + // nothing to do + break; + case WL_OUTPUT_TRANSFORM_270: + tmp = x; + x = y; + y = -(tmp - width); + break; + case WL_OUTPUT_TRANSFORM_90: + tmp = x; + x = -(y - height); + y = tmp; + break; + default: + // TODO other transformations + wlr_log(L_ERROR, "TODO: handle surface to crtc for transformation = %d", + _output->transform); + break; + } + return backend->iface->crtc_move_cursor(backend, output->crtc, x, y); } diff --git a/examples/pointer.c b/examples/pointer.c index 12253b62..0092c633 100644 --- a/examples/pointer.c +++ b/examples/pointer.c @@ -6,6 +6,7 @@ #include #include #include +#include #include #include #include @@ -16,16 +17,27 @@ #include #include #include +#include #include +#include #include #include "shared.h" #include "cat.h" struct sample_state { - struct wlr_xcursor *cursor; + struct compositor_state *compositor; + struct example_config *config; + struct wlr_xcursor *xcursor; + struct wlr_cursor *cursor; double cur_x, cur_y; float default_color[4]; float clear_color[4]; + struct wlr_output_layout *layout; + + struct wl_listener cursor_motion; + struct wl_listener cursor_motion_absolute; + struct wl_listener cursor_button; + struct wl_listener cursor_axis; }; static void handle_output_frame(struct output_state *output, struct timespec *ts) { @@ -42,74 +54,15 @@ static void handle_output_frame(struct output_state *output, struct timespec *ts wlr_output_swap_buffers(wlr_output); } -static void handle_pointer_motion(struct pointer_state *pstate, - double d_x, double d_y) { - struct sample_state *state = pstate->compositor->data; - state->cur_x += d_x; - state->cur_y += d_y; - - struct wlr_xcursor_image *image = state->cursor->images[0]; - - struct output_state *output; - wl_list_for_each(output, &pstate->compositor->outputs, link) { - wlr_output_move_cursor(output->output, - state->cur_x - image->hotspot_x, - state->cur_y - image->hotspot_y); - } -} - -static void handle_pointer_motion_absolute(struct pointer_state *pstate, - double x, double y) { - struct sample_state *state = pstate->compositor->data; - state->cur_x = x; - state->cur_y = y; - - struct wlr_xcursor_image *image = state->cursor->images[0]; - - struct output_state *output; - wl_list_for_each(output, &pstate->compositor->outputs, link) { - wlr_output_move_cursor(output->output, - state->cur_x - image->hotspot_x, - state->cur_y - image->hotspot_y); - } -} - -static void handle_pointer_button(struct pointer_state *pstate, - uint32_t button, enum wlr_button_state state) { - struct sample_state *sample = pstate->compositor->data; - float (*color)[4]; - if (state == WLR_BUTTON_RELEASED) { - color = &sample->default_color; - } else { - float red[4] = { 0.25f, 0.25f, 0.25f, 1 }; - red[button % 3] = 1; - color = &red; - } - memcpy(&sample->clear_color, color, sizeof(*color)); -} - -static void handle_pointer_axis(struct pointer_state *pstate, - enum wlr_axis_source source, - enum wlr_axis_orientation orientation, - double delta) { - struct sample_state *sample = pstate->compositor->data; - for (size_t i = 0; i < 3; ++i) { - sample->default_color[i] += delta > 0 ? -0.05f : 0.05f; - if (sample->default_color[i] > 1.0f) { - sample->default_color[i] = 1.0f; - } - if (sample->default_color[i] < 0.0f) { - sample->default_color[i] = 0.0f; - } - } - memcpy(&sample->clear_color, &sample->default_color, - sizeof(sample->clear_color)); -} - static void handle_output_add(struct output_state *ostate) { - struct sample_state *state = ostate->compositor->data; + struct sample_state *sample = ostate->compositor->data; struct wlr_output *wlr_output = ostate->output; - struct wlr_xcursor_image *image = state->cursor->images[0]; + struct wlr_xcursor_image *image = sample->xcursor->images[0]; + + wlr_output_layout_destroy(sample->layout); + sample->layout = configure_layout(sample->config, &ostate->compositor->outputs); + wlr_cursor_attach_output_layout(sample->cursor, sample->layout); + if (!wlr_output_set_cursor(wlr_output, image->buffer, image->width, image->width, image->height)) { wlr_log(L_DEBUG, "Failed to set hardware cursor"); @@ -120,34 +73,137 @@ static void handle_output_add(struct output_state *ostate) { } } +static void handle_output_remove(struct output_state *ostate) { + struct sample_state *sample = ostate->compositor->data; + wlr_output_layout_destroy(sample->layout); + sample->layout = configure_layout(sample->config, &ostate->compositor->outputs); + wlr_cursor_attach_output_layout(sample->cursor, sample->layout); +} + +static void handle_output_resolution(struct compositor_state *state, + struct output_state *ostate) { + struct sample_state *sample = ostate->compositor->data; + wlr_output_layout_destroy(sample->layout); + sample->layout = configure_layout(sample->config, &ostate->compositor->outputs); + wlr_cursor_attach_output_layout(sample->cursor, sample->layout); +} + +static void handle_input_add(struct compositor_state *state, struct + wlr_input_device *device) { + struct sample_state *sample = state->data; + + // TODO handle other input devices + if (device->type == WLR_INPUT_DEVICE_POINTER) { + wlr_cursor_attach_input_device(sample->cursor, device); + } +} + +static void handle_cursor_motion(struct wl_listener *listener, void *data) { + struct sample_state *sample = wl_container_of(listener, sample, cursor_motion); + struct wlr_event_pointer_motion *event = data; + wlr_cursor_move(sample->cursor, event->delta_x, event->delta_y); +} + +static void handle_cursor_motion_absolute(struct wl_listener *listener, void *data) { + struct sample_state *sample = wl_container_of(listener, sample, cursor_motion_absolute); + struct wlr_event_pointer_motion_absolute *event = data; + + sample->cur_x = event->x_mm; + sample->cur_y = event->y_mm; + + struct wlr_xcursor_image *image = sample->xcursor->images[0]; + + struct output_state *output; + wl_list_for_each(output, &sample->compositor->outputs, link) { + wlr_output_move_cursor(output->output, + sample->cur_x - image->hotspot_x, + sample->cur_y - image->hotspot_y); + } +} + +static void handle_cursor_button(struct wl_listener *listener, void *data) { + struct sample_state *sample = wl_container_of(listener, sample, cursor_button); + struct wlr_event_pointer_button *event = data; + + float (*color)[4]; + if (event->state == WLR_BUTTON_RELEASED) { + color = &sample->default_color; + memcpy(&sample->clear_color, color, sizeof(*color)); + } else { + float red[4] = { 0.25f, 0.25f, 0.25f, 1 }; + red[event->button % 3] = 1; + color = &red; + memcpy(&sample->clear_color, color, sizeof(*color)); + } +} + +static void handle_cursor_axis(struct wl_listener *listener, void *data) { + struct sample_state *sample = wl_container_of(listener, sample, cursor_axis); + struct wlr_event_pointer_axis *event = data; + + for (size_t i = 0; i < 3; ++i) { + sample->default_color[i] += event->delta > 0 ? -0.05f : 0.05f; + if (sample->default_color[i] > 1.0f) { + sample->default_color[i] = 1.0f; + } + if (sample->default_color[i] < 0.0f) { + sample->default_color[i] = 0.0f; + } + } + + memcpy(&sample->clear_color, &sample->default_color, + sizeof(sample->clear_color)); +} + int main(int argc, char *argv[]) { struct sample_state state = { .default_color = { 0.25f, 0.25f, 0.25f, 1 }, .clear_color = { 0.25f, 0.25f, 0.25f, 1 } }; + + state.config = parse_args(argc, argv); + state.cursor = wlr_cursor_init(); + + wl_signal_add(&state.cursor->events.motion, &state.cursor_motion); + state.cursor_motion.notify = handle_cursor_motion; + + wl_signal_add(&state.cursor->events.motion_absolute, &state.cursor_motion_absolute); + state.cursor_motion_absolute.notify = handle_cursor_motion_absolute; + + wl_signal_add(&state.cursor->events.button, &state.cursor_button); + state.cursor_button.notify = handle_cursor_button; + + wl_signal_add(&state.cursor->events.axis, &state.cursor_axis); + state.cursor_axis.notify = handle_cursor_axis; + struct compositor_state compositor = { 0 }; compositor.data = &state; compositor.output_add_cb = handle_output_add; + compositor.output_remove_cb = handle_output_remove; + compositor.output_resolution_cb = handle_output_resolution; compositor.output_frame_cb = handle_output_frame; - compositor.pointer_motion_cb = handle_pointer_motion; - compositor.pointer_motion_absolute_cb = handle_pointer_motion_absolute; - compositor.pointer_button_cb = handle_pointer_button; - compositor.pointer_axis_cb = handle_pointer_axis; + compositor.input_add_cb = handle_input_add; + + state.compositor = &compositor; struct wlr_xcursor_theme *theme = wlr_xcursor_theme_load("default", 16); if (!theme) { wlr_log(L_ERROR, "Failed to load cursor theme"); return 1; } - state.cursor = wlr_xcursor_theme_get_cursor(theme, "left_ptr"); - if (!state.cursor) { + state.xcursor = wlr_xcursor_theme_get_cursor(theme, "left_ptr"); + if (!state.xcursor) { wlr_log(L_ERROR, "Failed to load left_ptr cursor"); return 1; } + wlr_cursor_set_xcursor(state.cursor, state.xcursor); + compositor_init(&compositor); wl_display_run(compositor.display); compositor_fini(&compositor); wlr_xcursor_theme_destroy(theme); + example_config_destroy(state.config); + wlr_cursor_destroy(state.cursor); } diff --git a/examples/shared.c b/examples/shared.c index f37140cf..1dad8016 100644 --- a/examples/shared.c +++ b/examples/shared.c @@ -441,6 +441,10 @@ static void input_add_notify(struct wl_listener *listener, void *data) { default: break; } + + if (state->input_add_cb) { + state->input_add_cb(state, device); + } } static void keyboard_remove(struct wlr_input_device *device, struct compositor_state *state) { diff --git a/examples/shared.h b/examples/shared.h index d8007753..d9972ffd 100644 --- a/examples/shared.h +++ b/examples/shared.h @@ -93,6 +93,8 @@ struct tablet_pad_state { }; struct compositor_state { + void (*input_add_cb)(struct compositor_state *compositor, + struct wlr_input_device *device); void (*output_add_cb)(struct output_state *s); void (*keyboard_add_cb)(struct keyboard_state *s); void (*output_frame_cb)(struct output_state *s, struct timespec *ts); diff --git a/include/wlr/types/wlr_cursor.h b/include/wlr/types/wlr_cursor.h new file mode 100644 index 00000000..1ea089ef --- /dev/null +++ b/include/wlr/types/wlr_cursor.h @@ -0,0 +1,81 @@ +#ifndef _WLR_TYPES_CURSOR_H +#define _WLR_TYPES_CURSOR_H +#include +#include +#include +#include +#include + +struct wlr_cursor_state; +//struct wlr_cursor_impl *; + +struct wlr_cursor { + struct wlr_cursor_state *state; + //struct wlr_cursor_impl *impl; + int x, y; + + struct { + struct wl_signal motion; + struct wl_signal motion_absolute; + struct wl_signal button; + struct wl_signal axis; + } events; +}; + +struct wlr_cursor *wlr_cursor_init(); + +void wlr_cursor_destroy(struct wlr_cursor *cur); + +void wlr_cursor_set_xcursor(struct wlr_cursor *cur, struct wlr_xcursor *xcur); + +void wlr_cursor_warp(struct wlr_cursor *cur, double x, double y); + +void wlr_cursor_move(struct wlr_cursor *cur, double delta_x, double delta_y); + +/** + * Attaches this input device to this cursor. The input device must be one of: + * + * - WLR_INPUT_DEVICE_POINTER + * - WLR_INPUT_DEVICE_TOUCH + * - WLR_INPUT_DEVICE_TABLET_TOOL + */ +void wlr_cursor_attach_input_device(struct wlr_cursor *cur, + struct wlr_input_device *dev); + +void wlr_cursor_detach_input_device(struct wlr_cursor *cur, + struct wlr_input_device *dev); +/** + * Uses the given layout to establish the boundaries and movement semantics of + * this cursor. Cursors without an output layout allow infinite movement in any + * direction and do not support absolute input events. + */ +void wlr_cursor_attach_output_layout(struct wlr_cursor *cur, + struct wlr_output_layout *l); + +/** + * Attaches this cursor to the given output, which must be among the outputs in + * the current output_layout for this cursor. This call is invalid for a cursor + * without an associated output layout. + */ +void wlr_cursor_map_to_output(struct wlr_cursor *cur, struct wlr_output *output); + +/** + * Maps all input from a specific input device to a given output. The input + * device must be attached to this cursor and the output must be among the + * outputs in the attached output layout. + */ +void wlr_cursor_map_input_to_output(struct wlr_cursor *cur, + struct wlr_input_device *dev, struct wlr_output *output); + +/** + * Maps this cursor to an arbitrary region on the associated wlr_output_layout. + */ +//void wlr_cursor_map_to_region(struct wlr_cursor *cur, struct wlr_geometry *geo); + +/** + * Maps inputs from this input device to an arbitrary region on the associated + * wlr_output_layout. + */ +//void wlr_cursor_map_input_to_region(struct wlr_cursor *cur, struct wlr_input_device *dev, struct wlr_geometry *geo); + +#endif diff --git a/types/meson.build b/types/meson.build index 83b4647c..3992c6e9 100644 --- a/types/meson.build +++ b/types/meson.build @@ -6,6 +6,7 @@ lib_wlr_types = static_library('wlr_types', files( 'wlr_output.c', 'wlr_output_layout.c', 'wlr_pointer.c', + 'wlr_cursor.c', 'wlr_region.c', 'wlr_seat.c', 'wlr_surface.c', diff --git a/types/wlr_cursor.c b/types/wlr_cursor.c new file mode 100644 index 00000000..ed53fa7e --- /dev/null +++ b/types/wlr_cursor.c @@ -0,0 +1,206 @@ +#include +#include +#include +#include +#include +#include +#include +#include + +struct wlr_cursor_device { + struct wlr_cursor *cursor; + struct wlr_input_device *device; + struct wl_list link; + + struct wl_listener motion; + struct wl_listener motion_absolute; + struct wl_listener button; + struct wl_listener axis; +}; + +struct wlr_cursor_state { + struct wl_list devices; + struct wlr_output_layout *layout; + struct wlr_xcursor *xcursor; +}; + +struct wlr_cursor *wlr_cursor_init() { + struct wlr_cursor *cur = calloc(1, sizeof(struct wlr_cursor)); + if (!cur) { + wlr_log(L_ERROR, "Failed to allocate wlr_cursor"); + return NULL; + } + + cur->state = calloc(1, sizeof(struct wlr_cursor_state)); + if (!cur->state) { + wlr_log(L_ERROR, "Failed to allocate wlr_cursor_state"); + return NULL; + } + + wl_list_init(&cur->state->devices); + + wl_signal_init(&cur->events.motion); + wl_signal_init(&cur->events.motion_absolute); + wl_signal_init(&cur->events.button); + wl_signal_init(&cur->events.axis); + + cur->x = 100; + cur->y = 100; + + return cur; +} + +void wlr_cursor_destroy(struct wlr_cursor *cur) { + struct wlr_cursor_device *device; + wl_list_for_each(device, &cur->state->devices, link) { + wl_list_remove(&device->link); + free(device); + } + + free(cur); +} + +void wlr_cursor_set_xcursor(struct wlr_cursor *cur, struct wlr_xcursor *xcur) { + cur->state->xcursor = xcur; +} + +void wlr_cursor_warp(struct wlr_cursor *cur, double x, double y) { +} + +void wlr_cursor_move(struct wlr_cursor *cur, double delta_x, double delta_y) { + //struct wlr_output *current_output; + //current_output = wlr_output_layout_output_at(cur->state->layout, cur->x, cur->y); + + // TODO handle no layout + assert(cur->state->layout); + // TODO handle layout boundaries + double new_x = cur->x + delta_x; + double new_y = cur->y + delta_y; + int hotspot_x = 0; + int hotspot_y = 0; + + if (cur->state->xcursor && cur->state->xcursor->image_count > 0) { + struct wlr_xcursor_image *image = cur->state->xcursor->images[0]; + hotspot_x = image->hotspot_x; + hotspot_y = image->hotspot_y; + } + + struct wlr_output *output; + output = wlr_output_layout_output_at(cur->state->layout, new_x, new_y); + + if (output) { + int output_x = new_x; + int output_y = new_y; + + // TODO fix double to int rounding issues + wlr_output_layout_output_coords(cur->state->layout, output, &output_x, &output_y); + wlr_output_move_cursor(output, output_x - hotspot_x, output_y - hotspot_y); + + cur->x = new_x; + cur->y = new_y; + } +} + +static void handle_pointer_motion(struct wl_listener *listener, void *data) { + struct wlr_event_pointer_motion *event = data; + struct wlr_cursor_device *device = wl_container_of(listener, device, motion); + wl_signal_emit(&device->cursor->events.motion, event); +} + +static void handle_pointer_motion_absolute(struct wl_listener *listener, void *data) { + struct wlr_event_pointer_motion_absolute *event = data; + struct wlr_cursor_device *device = wl_container_of(listener, device, motion_absolute); + wl_signal_emit(&device->cursor->events.motion_absolute, event); +} + +static void handle_pointer_button(struct wl_listener *listener, void *data) { + struct wlr_event_pointer_button *event = data; + struct wlr_cursor_device *device = wl_container_of(listener, device, button); + wl_signal_emit(&device->cursor->events.button, event); +} + +static void handle_pointer_axis(struct wl_listener *listener, void *data) { + struct wlr_event_pointer_axis *event = data; + struct wlr_cursor_device *device = wl_container_of(listener, device, axis); + wl_signal_emit(&device->cursor->events.axis, event); +} + +void wlr_cursor_attach_input_device(struct wlr_cursor *cur, + struct wlr_input_device *dev) { + if (dev->type != WLR_INPUT_DEVICE_POINTER && + dev->type != WLR_INPUT_DEVICE_TOUCH && + dev->type != WLR_INPUT_DEVICE_TABLET_TOOL) { + wlr_log(L_ERROR, "only device types of pointer, touch or tablet tool are" + "supported"); + return; + } + + // TODO support other device types + if (dev->type != WLR_INPUT_DEVICE_POINTER) { + wlr_log(L_ERROR, "TODO: support touch and tablet tool devices"); + return; + } + + // make sure it is not already attached + struct wlr_cursor_device *_dev; + wl_list_for_each(_dev, &cur->state->devices, link) { + if (_dev->device == dev) { + return; + } + } + + struct wlr_cursor_device *device = calloc(1, sizeof(struct wlr_cursor_device)); + if (!device) { + wlr_log(L_ERROR, "Failed to allocate wlr_cursor_device"); + return; + } + + device->cursor = cur; + device->device = dev; + + // listen to events + wl_signal_add(&dev->pointer->events.motion, &device->motion); + device->motion.notify = handle_pointer_motion; + + wl_signal_add(&dev->pointer->events.motion_absolute, &device->motion_absolute); + device->motion_absolute.notify = handle_pointer_motion_absolute; + + wl_signal_add(&dev->pointer->events.button, &device->button); + device->button.notify = handle_pointer_button; + + wl_signal_add(&dev->pointer->events.axis, &device->axis); + device->axis.notify = handle_pointer_axis; + + wl_list_insert(&cur->state->devices, &device->link); +} + +void wlr_cursor_detach_input_device(struct wlr_cursor *cur, + struct wlr_input_device *dev) { + struct wlr_cursor_device *target_device = NULL, *_device = NULL; + wl_list_for_each(_device, &cur->state->devices, link) { + if (_device->device == dev) { + target_device = _device; + break; + } + } + + if (target_device) { + wl_list_remove(&target_device->link); + free(target_device); + } +} + +void wlr_cursor_attach_output_layout(struct wlr_cursor *cur, + struct wlr_output_layout *l) { + cur->state->layout = l; +} + +void wlr_cursor_map_to_output(struct wlr_cursor *cur, + struct wlr_output *output) { + wlr_log(L_DEBUG, "TODO: map to output"); +} + +void wlr_cursor_map_input_to_output(struct wlr_cursor *cur, + struct wlr_input_device *dev, struct wlr_output *output) { + wlr_log(L_DEBUG, "TODO map input to output"); +}