Documentation for <wlr/types/wlr_seat.h>

Back to index

Table of contents

struct wlr_keyboard_grab_interface

struct wlr_keyboard_grab_interface {
	void (*enter)(​struct wlr_seat_keyboard_grab *grab, struct wlr_surface *surface, uint32_t keycodes[], size_t num_keycodes, struct wlr_keyboard_modifiers *modifiers);
	void (*clear_focus)(​struct wlr_seat_keyboard_grab *grab);
	void (*key)(​struct wlr_seat_keyboard_grab *grab, uint32_t time_msec, uint32_t key, uint32_t state);
	void (*modifiers)(​struct wlr_seat_keyboard_grab *grab, struct wlr_keyboard_modifiers *modifiers);
	void (*cancel)(​struct wlr_seat_keyboard_grab *grab);
};

struct wlr_pointer_grab_interface

struct wlr_pointer_grab_interface {
	void (*enter)(​struct wlr_seat_pointer_grab *grab, struct wlr_surface *surface, double sx, double sy);
	void (*clear_focus)(​struct wlr_seat_pointer_grab *grab);
	void (*motion)(​struct wlr_seat_pointer_grab *grab, uint32_t time_msec, double sx, double sy);
	uint32_t (*button)(​struct wlr_seat_pointer_grab *grab, uint32_t time_msec, uint32_t button, enum wlr_button_state state);
	void (*axis)(​struct wlr_seat_pointer_grab *grab, uint32_t time_msec, enum wlr_axis_orientation orientation, double value, int32_t value_discrete, enum wlr_axis_source source);
	void (*frame)(​struct wlr_seat_pointer_grab *grab);
	void (*cancel)(​struct wlr_seat_pointer_grab *grab);
};

struct wlr_seat

struct wlr_seat {
	struct wl_global *global;
	struct wl_display *display;
	struct wl_list clients;
	char *name;
	uint32_t capabilities;
	uint32_t accumulated_capabilities;
	struct timespec last_event;
	struct wlr_data_source *selection_source;
	uint32_t selection_serial;
	struct wl_list selection_offers;
	struct wlr_primary_selection_source *primary_selection_source;
	uint32_t primary_selection_serial;
	struct wlr_drag *drag;
	struct wlr_data_source *drag_source;
	uint32_t drag_serial;
	struct wl_list drag_offers;
	struct wlr_seat_pointer_state pointer_state;
	struct wlr_seat_keyboard_state keyboard_state;
	struct wlr_seat_touch_state touch_state;
	struct wl_listener display_destroy;
	struct wl_listener selection_source_destroy;
	struct wl_listener primary_selection_source_destroy;
	struct wl_listener drag_source_destroy;
	struct {
		struct wl_signal pointer_grab_begin;
		struct wl_signal pointer_grab_end;
		struct wl_signal keyboard_grab_begin;
		struct wl_signal keyboard_grab_end;
		struct wl_signal touch_grab_begin;
		struct wl_signal touch_grab_end;
		struct wl_signal request_set_cursor;
		struct wl_signal request_set_selection;
		struct wl_signal set_selection;
		struct wl_signal request_set_primary_selection;
		struct wl_signal set_primary_selection;
		struct wl_signal request_start_drag;
		struct wl_signal start_drag;
		struct wl_signal destroy;
	} events;
	void *data;
};

struct wlr_seat_client

struct wlr_seat_client {
	struct wl_client *client;
	struct wlr_seat *seat;
	struct wl_list link;
	struct wl_list resources;
	struct wl_list pointers;
	struct wl_list keyboards;
	struct wl_list touches;
	struct wl_list data_devices;
	struct {
		struct wl_signal destroy;
	} events;
	struct wlr_serial_ringset serials;
	bool needs_touch_frame;
};

Contains state for a single client's bound wl_seat resource and can be used to issue input events to that client. The lifetime of these objects is managed by struct wlr_seat; some may be NULL.

wlr_seat_client_for_wl_client()

struct wlr_seat_client *wlr_seat_client_for_wl_client(​struct wlr_seat *wlr_seat, struct wl_client *wl_client);

Gets a struct wlr_seat_client for the specified client, or returns NULL if no client is bound for that client.

wlr_seat_client_from_pointer_resource()

struct wlr_seat_client *wlr_seat_client_from_pointer_resource(​struct wl_resource *resource);

Get a seat client from a pointer resource. Returns NULL if inert.

wlr_seat_client_from_resource()

struct wlr_seat_client *wlr_seat_client_from_resource(​struct wl_resource *resource);

Get a seat client from a seat resource. Returns NULL if inert.

wlr_seat_client_next_serial()

uint32_t wlr_seat_client_next_serial(​struct wlr_seat_client *client);

Return a new serial (from wl_display_serial_next()) for the client, and update the seat client's set of valid serials. Use this for all input events; otherwise wlr_seat_client_validate_event_serial() may fail when handed a correctly functioning client's request serials.

wlr_seat_client_validate_event_serial()

bool wlr_seat_client_validate_event_serial(​struct wlr_seat_client *client, uint32_t serial);

Return true if the serial number could have been produced by wlr_seat_client_next_serial() and is "older" (by less than UINT32_MAX/2) than the current display serial value.

This function should have no false negatives, and the only false positive responses allowed are for elements that are still "older" than the current display serial value and also older than all serial values remaining in the seat client's serial ring buffer, if that buffer is also full.

wlr_seat_create()

struct wlr_seat *wlr_seat_create(​struct wl_display *display, const char *name);

Allocates a new struct wlr_seat and adds a wl_seat global to the display.

wlr_seat_destroy()

void wlr_seat_destroy(​struct wlr_seat *wlr_seat);

Destroys a seat, removes its wl_seat global and clears focus for all devices belonging to the seat.

wlr_seat_get_keyboard()

struct wlr_keyboard *wlr_seat_get_keyboard(​struct wlr_seat *seat);

Get the active keyboard for the seat.

wlr_seat_keyboard_clear_focus()

void wlr_seat_keyboard_clear_focus(​struct wlr_seat *wlr_seat);

Clear the focused surface for the keyboard and leave all entered surfaces. This function does not respect keyboard grabs: you probably want wlr_seat_keyboard_notify_clear_focus() instead.

wlr_seat_keyboard_end_grab()

void wlr_seat_keyboard_end_grab(​struct wlr_seat *wlr_seat);

End the grab of the keyboard of this seat. This reverts the grab back to the default grab for the keyboard.

wlr_seat_keyboard_enter()

void wlr_seat_keyboard_enter(​struct wlr_seat *seat, struct wlr_surface *surface, uint32_t keycodes[], size_t num_keycodes, struct wlr_keyboard_modifiers *modifiers);

Send a keyboard enter event to the given surface and consider it to be the focused surface for the keyboard. This will send a leave event to the last surface that was entered. This function does not respect keyboard grabs: you probably want wlr_seat_keyboard_notify_enter() instead.

struct wlr_seat_keyboard_focus_change_event

struct wlr_seat_keyboard_focus_change_event {
	struct wlr_seat *seat;
	struct wlr_surface *old_surface, *new_surface;
};

struct wlr_seat_keyboard_grab

struct wlr_seat_keyboard_grab {
	const struct wlr_keyboard_grab_interface *interface;
	struct wlr_seat *seat;
	void *data;
};

Passed to wlr_seat_keyboard_start_grab() to start a grab of the keyboard. The grabber is responsible for handling keyboard events for the seat.

wlr_seat_keyboard_has_grab()

bool wlr_seat_keyboard_has_grab(​struct wlr_seat *seat);

Whether or not the keyboard has a grab other than the default grab

wlr_seat_keyboard_notify_clear_focus()

void wlr_seat_keyboard_notify_clear_focus(​struct wlr_seat *wlr_seat);

Notify the seat of a keyboard leave event to the currently-focused surface. Defers to any keyboard grabs.

wlr_seat_keyboard_notify_enter()

void wlr_seat_keyboard_notify_enter(​struct wlr_seat *seat, struct wlr_surface *surface, uint32_t keycodes[], size_t num_keycodes, struct wlr_keyboard_modifiers *modifiers);

Notify the seat that the keyboard focus has changed and request it to be the focused surface for this keyboard. Defers to any current grab of the seat's keyboard.

wlr_seat_keyboard_notify_key()

void wlr_seat_keyboard_notify_key(​struct wlr_seat *seat, uint32_t time_msec, uint32_t key, uint32_t state);

Notify the seat that a key has been pressed on the keyboard. Defers to any keyboard grabs.

wlr_seat_keyboard_notify_modifiers()

void wlr_seat_keyboard_notify_modifiers(​struct wlr_seat *seat, struct wlr_keyboard_modifiers *modifiers);

Notify the seat that the modifiers for the keyboard have changed. Defers to any keyboard grabs.

wlr_seat_keyboard_send_key()

void wlr_seat_keyboard_send_key(​struct wlr_seat *seat, uint32_t time_msec, uint32_t key, uint32_t state);

Send the keyboard key to focused keyboard resources. This function does not respect keyboard grabs: you probably want wlr_seat_keyboard_notify_key() instead.

wlr_seat_keyboard_send_modifiers()

void wlr_seat_keyboard_send_modifiers(​struct wlr_seat *seat, struct wlr_keyboard_modifiers *modifiers);

Send the modifier state to focused keyboard resources. This function does not respect keyboard grabs: you probably want wlr_seat_keyboard_notify_modifiers() instead.

wlr_seat_keyboard_start_grab()

void wlr_seat_keyboard_start_grab(​struct wlr_seat *wlr_seat, struct wlr_seat_keyboard_grab *grab);

Start a grab of the keyboard of this seat. The grabber is responsible for handling all keyboard events until the grab ends.

struct wlr_seat_keyboard_state

struct wlr_seat_keyboard_state {
	struct wlr_seat *seat;
	struct wlr_keyboard *keyboard;
	struct wlr_seat_client *focused_client;
	struct wlr_surface *focused_surface;
	struct wl_listener keyboard_destroy;
	struct wl_listener keyboard_keymap;
	struct wl_listener keyboard_repeat_info;
	struct wl_listener surface_destroy;
	struct wlr_seat_keyboard_grab *grab;
	struct wlr_seat_keyboard_grab *default_grab;
	struct {
		struct wl_signal focus_change;
	} events;
};

wlr_seat_pointer_clear_focus()

void wlr_seat_pointer_clear_focus(​struct wlr_seat *wlr_seat);

Clear the focused surface for the pointer and leave all entered surfaces. This function does not respect pointer grabs: you probably want wlr_seat_pointer_notify_clear_focus() instead.

wlr_seat_pointer_end_grab()

void wlr_seat_pointer_end_grab(​struct wlr_seat *wlr_seat);

End the grab of the pointer of this seat. This reverts the grab back to the default grab for the pointer.

wlr_seat_pointer_enter()

void wlr_seat_pointer_enter(​struct wlr_seat *wlr_seat, struct wlr_surface *surface, double sx, double sy);

Send a pointer enter event to the given surface and consider it to be the focused surface for the pointer. This will send a leave event to the last surface that was entered. Coordinates for the enter event are surface-local. This function does not respect pointer grabs: you probably want wlr_seat_pointer_notify_enter() instead.

struct wlr_seat_pointer_focus_change_event

struct wlr_seat_pointer_focus_change_event {
	struct wlr_seat *seat;
	struct wlr_surface *old_surface, *new_surface;
	double sx, sy;
};

struct wlr_seat_pointer_grab

struct wlr_seat_pointer_grab {
	const struct wlr_pointer_grab_interface *interface;
	struct wlr_seat *seat;
	void *data;
};

Passed to wlr_seat_pointer_start_grab() to start a grab of the pointer. The grabber is responsible for handling pointer events for the seat.

wlr_seat_pointer_has_grab()

bool wlr_seat_pointer_has_grab(​struct wlr_seat *seat);

Whether or not the pointer has a grab other than the default grab.

wlr_seat_pointer_notify_axis()

void wlr_seat_pointer_notify_axis(​struct wlr_seat *wlr_seat, uint32_t time_msec, enum wlr_axis_orientation orientation, double value, int32_t value_discrete, enum wlr_axis_source source);

Notify the seat of an axis event. Defers to any grab of the pointer.

wlr_seat_pointer_notify_button()

uint32_t wlr_seat_pointer_notify_button(​struct wlr_seat *wlr_seat, uint32_t time_msec, uint32_t button, enum wlr_button_state state);

Notify the seat that a button has been pressed. Returns the serial of the button press or zero if no button press was sent. Defers to any grab of the pointer.

wlr_seat_pointer_notify_clear_focus()

void wlr_seat_pointer_notify_clear_focus(​struct wlr_seat *wlr_seat);

Notify the seat of a pointer leave event to the currently-focused surface. Defers to any grab of the pointer.

wlr_seat_pointer_notify_enter()

void wlr_seat_pointer_notify_enter(​struct wlr_seat *wlr_seat, struct wlr_surface *surface, double sx, double sy);

Notify the seat of a pointer enter event to the given surface and request it to be the focused surface for the pointer. Pass surface-local coordinates where the enter occurred. This will send a leave event to the currently- focused surface. Defers to any grab of the pointer.

wlr_seat_pointer_notify_frame()

void wlr_seat_pointer_notify_frame(​struct wlr_seat *wlr_seat);

Notify the seat of a frame event. Frame events are sent to end a group of events that logically belong together. Motion, button and axis events should all be followed by a frame event. Defers to any grab of the pointer.

wlr_seat_pointer_notify_motion()

void wlr_seat_pointer_notify_motion(​struct wlr_seat *wlr_seat, uint32_t time_msec, double sx, double sy);

Notify the seat of motion over the given surface. Pass surface-local coordinates where the pointer motion occurred. Defers to any grab of the pointer.

struct wlr_seat_pointer_request_set_cursor_event

struct wlr_seat_pointer_request_set_cursor_event {
	struct wlr_seat_client *seat_client;
	struct wlr_surface *surface;
	uint32_t serial;
	int32_t hotspot_x, hotspot_y;
};

wlr_seat_pointer_send_axis()

void wlr_seat_pointer_send_axis(​struct wlr_seat *wlr_seat, uint32_t time_msec, enum wlr_axis_orientation orientation, double value, int32_t value_discrete, enum wlr_axis_source source);

Send an axis event to the surface with pointer focus. This function does not respect pointer grabs: you probably want wlr_seat_pointer_notify_axis() instead.

wlr_seat_pointer_send_button()

uint32_t wlr_seat_pointer_send_button(​struct wlr_seat *wlr_seat, uint32_t time_msec, uint32_t button, enum wlr_button_state state);

Send a button event to the surface with pointer focus. Coordinates for the button event are surface-local. Returns the serial. This function does not respect pointer grabs: you probably want wlr_seat_pointer_notify_button() instead.

wlr_seat_pointer_send_frame()

void wlr_seat_pointer_send_frame(​struct wlr_seat *wlr_seat);

Send a frame event to the surface with pointer focus. This function does not respect pointer grabs: you probably want wlr_seat_pointer_notify_frame() instead.

wlr_seat_pointer_send_motion()

void wlr_seat_pointer_send_motion(​struct wlr_seat *wlr_seat, uint32_t time_msec, double sx, double sy);

Send a motion event to the surface with pointer focus. Coordinates for the motion event are surface-local. This function does not respect pointer grabs: you probably want wlr_seat_pointer_notify_motion() instead.

wlr_seat_pointer_start_grab()

void wlr_seat_pointer_start_grab(​struct wlr_seat *wlr_seat, struct wlr_seat_pointer_grab *grab);

Start a grab of the pointer of this seat. The grabber is responsible for handling all pointer events until the grab ends.

struct wlr_seat_pointer_state

struct wlr_seat_pointer_state {
	struct wlr_seat *seat;
	struct wlr_seat_client *focused_client;
	struct wlr_surface *focused_surface;
	double sx, sy;
	struct wlr_seat_pointer_grab *grab;
	struct wlr_seat_pointer_grab *default_grab;
	bool sent_axis_source;
	enum wlr_axis_source cached_axis_source;
	uint32_t buttons[];
	size_t button_count;
	uint32_t grab_button;
	uint32_t grab_serial;
	uint32_t grab_time;
	struct wl_listener surface_destroy;
	struct {
		struct wl_signal focus_change;
	} events;
};

wlr_seat_pointer_surface_has_focus()

bool wlr_seat_pointer_surface_has_focus(​struct wlr_seat *wlr_seat, struct wlr_surface *surface);

Whether or not the surface has pointer focus

wlr_seat_pointer_warp()

void wlr_seat_pointer_warp(​struct wlr_seat *wlr_seat, double sx, double sy);

Warp the pointer of this seat to the given surface-local coordinates, without generating motion events.

struct wlr_seat_request_set_primary_selection_event

struct wlr_seat_request_set_primary_selection_event {
	struct wlr_primary_selection_source *source;
	uint32_t serial;
};

struct wlr_seat_request_set_selection_event

struct wlr_seat_request_set_selection_event {
	struct wlr_data_source *source;
	uint32_t serial;
};

struct wlr_seat_request_start_drag_event

struct wlr_seat_request_start_drag_event {
	struct wlr_drag *drag;
	struct wlr_surface *origin;
	uint32_t serial;
};

wlr_seat_set_capabilities()

void wlr_seat_set_capabilities(​struct wlr_seat *wlr_seat, uint32_t capabilities);

Updates the capabilities available on this seat. Will automatically send them to all clients.

wlr_seat_set_keyboard()

void wlr_seat_set_keyboard(​struct wlr_seat *seat, struct wlr_keyboard *keyboard);

Set this keyboard as the active keyboard for the seat.

wlr_seat_set_name()

void wlr_seat_set_name(​struct wlr_seat *wlr_seat, const char *name);

Updates the name of this seat. Will automatically send it to all clients.

wlr_seat_touch_end_grab()

void wlr_seat_touch_end_grab(​struct wlr_seat *wlr_seat);

End the grab of the touch device of this seat. This reverts the grab back to the default grab for the touch device.

wlr_seat_touch_get_point()

struct wlr_touch_point *wlr_seat_touch_get_point(​struct wlr_seat *seat, int32_t touch_id);

Get the active touch point with the given `touch_id`. If the touch point does not exist or is no longer active, returns NULL.

struct wlr_seat_touch_grab

struct wlr_seat_touch_grab {
	const struct wlr_touch_grab_interface *interface;
	struct wlr_seat *seat;
	void *data;
};

Passed to wlr_seat_touch_start_grab() to start a grab of the touch device. The grabber is responsible for handling touch events for the seat.

wlr_seat_touch_has_grab()

bool wlr_seat_touch_has_grab(​struct wlr_seat *seat);

Whether or not the seat has a touch grab other than the default grab.

wlr_seat_touch_notify_cancel()

void wlr_seat_touch_notify_cancel(​struct wlr_seat *seat, struct wlr_surface *surface);

Notify the seat that this is a global gesture and the client should cancel processing it. Defers to any grab of the touch device.

wlr_seat_touch_notify_down()

uint32_t wlr_seat_touch_notify_down(​struct wlr_seat *seat, struct wlr_surface *surface, uint32_t time_msec, int32_t touch_id, double sx, double sy);

Notify the seat of a touch down on the given surface. Defers to any grab of the touch device.

wlr_seat_touch_notify_frame()

void wlr_seat_touch_notify_frame(​struct wlr_seat *seat);

wlr_seat_touch_notify_motion()

void wlr_seat_touch_notify_motion(​struct wlr_seat *seat, uint32_t time_msec, int32_t touch_id, double sx, double sy);

Notify the seat that the touch point given by `touch_id` has moved. Defers to any grab of the touch device. The seat should be notified of touch motion even if the surface is not the owner of the touch point for processing by grabs.

wlr_seat_touch_notify_up()

void wlr_seat_touch_notify_up(​struct wlr_seat *seat, uint32_t time_msec, int32_t touch_id);

Notify the seat that the touch point given by `touch_id` is up. Defers to any grab of the touch device.

wlr_seat_touch_num_points()

int wlr_seat_touch_num_points(​struct wlr_seat *seat);

How many touch points are currently down for the seat.

wlr_seat_touch_point_clear_focus()

void wlr_seat_touch_point_clear_focus(​struct wlr_seat *seat, uint32_t time_msec, int32_t touch_id);

Clear the focused surface for the touch point given by `touch_id`.

wlr_seat_touch_point_focus()

void wlr_seat_touch_point_focus(​struct wlr_seat *seat, struct wlr_surface *surface, uint32_t time_msec, int32_t touch_id, double sx, double sy);

Notify the seat that the touch point given by `touch_id` has entered a new surface. The surface is required. To clear focus, use wlr_seat_touch_point_clear_focus().

wlr_seat_touch_send_cancel()

void wlr_seat_touch_send_cancel(​struct wlr_seat *seat, struct wlr_surface *surface);

Notify the seat that this is a global gesture and the client should cancel processing it. The event will go to the client for the surface given. This function does not respect touch grabs: you probably want wlr_seat_touch_notify_cancel() instead.

wlr_seat_touch_send_down()

uint32_t wlr_seat_touch_send_down(​struct wlr_seat *seat, struct wlr_surface *surface, uint32_t time_msec, int32_t touch_id, double sx, double sy);

Send a touch down event to the client of the given surface. All future touch events for this point will go to this surface. If the touch down is valid, this will add a new touch point with the given `touch_id`. The touch down may not be valid if the surface seat client does not accept touch input. Coordinates are surface-local. This function does not respect touch grabs: you probably want wlr_seat_touch_notify_down() instead.

wlr_seat_touch_send_frame()

void wlr_seat_touch_send_frame(​struct wlr_seat *seat);

wlr_seat_touch_send_motion()

void wlr_seat_touch_send_motion(​struct wlr_seat *seat, uint32_t time_msec, int32_t touch_id, double sx, double sy);

Send a touch motion event for the touch point given by the `touch_id`. The event will go to the client for the surface given in the corresponding touch down event. This function does not respect touch grabs: you probably want wlr_seat_touch_notify_motion() instead.

wlr_seat_touch_send_up()

void wlr_seat_touch_send_up(​struct wlr_seat *seat, uint32_t time_msec, int32_t touch_id);

Send a touch up event for the touch point given by the `touch_id`. The event will go to the client for the surface given in the corresponding touch down event. This will remove the touch point. This function does not respect touch grabs: you probably want wlr_seat_touch_notify_up() instead.

wlr_seat_touch_start_grab()

void wlr_seat_touch_start_grab(​struct wlr_seat *wlr_seat, struct wlr_seat_touch_grab *grab);

Start a grab of the touch device of this seat. The grabber is responsible for handling all touch events until the grab ends.

struct wlr_seat_touch_state

struct wlr_seat_touch_state {
	struct wlr_seat *seat;
	struct wl_list touch_points;
	uint32_t grab_serial;
	uint32_t grab_id;
	struct wlr_seat_touch_grab *grab;
	struct wlr_seat_touch_grab *default_grab;
};

wlr_seat_validate_grab_serial()

bool wlr_seat_validate_grab_serial(​struct wlr_seat *seat, uint32_t serial);

Check whether this serial is valid to start a grab action such as an interactive move or resize.

wlr_seat_validate_pointer_grab_serial()

bool wlr_seat_validate_pointer_grab_serial(​struct wlr_seat *seat, struct wlr_surface *origin, uint32_t serial);

Check whether this serial is valid to start a pointer grab action.

wlr_seat_validate_touch_grab_serial()

bool wlr_seat_validate_touch_grab_serial(​struct wlr_seat *seat, struct wlr_surface *origin, uint32_t serial, struct wlr_touch_point **point_ptr);

Check whether this serial is valid to start a touch grab action. If it's the case and point_ptr is non-NULL, `*point_ptr` is set to the touch point matching the serial.

struct wlr_serial_range

struct wlr_serial_range {
	uint32_t min_incl;
	uint32_t max_incl;
};

struct wlr_serial_ringset

struct wlr_serial_ringset {
	struct wlr_serial_range data[];
	int end;
	int count;
};

wlr_surface_accepts_touch()

bool wlr_surface_accepts_touch(​struct wlr_seat *wlr_seat, struct wlr_surface *surface);

Check whether a surface has bound to touch events.

struct wlr_touch_grab_interface

struct wlr_touch_grab_interface {
	uint32_t (*down)(​struct wlr_seat_touch_grab *grab, uint32_t time_msec, struct wlr_touch_point *point);
	void (*up)(​struct wlr_seat_touch_grab *grab, uint32_t time_msec, struct wlr_touch_point *point);
	void (*motion)(​struct wlr_seat_touch_grab *grab, uint32_t time_msec, struct wlr_touch_point *point);
	void (*enter)(​struct wlr_seat_touch_grab *grab, uint32_t time_msec, struct wlr_touch_point *point);
	void (*frame)(​struct wlr_seat_touch_grab *grab);
	void (*cancel)(​struct wlr_seat_touch_grab *grab);
	void (*wl_cancel)(​struct wlr_seat_touch_grab *grab, struct wlr_surface *surface);
};

struct wlr_touch_point

struct wlr_touch_point {
	int32_t touch_id;
	struct wlr_surface *surface;
	struct wlr_seat_client *client;
	struct wlr_surface *focus_surface;
	struct wlr_seat_client *focus_client;
	double sx, sy;
	struct wl_listener surface_destroy;
	struct wl_listener focus_surface_destroy;
	struct wl_listener client_destroy;
	struct {
		struct wl_signal destroy;
	} events;
	struct wl_list link;
};