2017-09-23 10:26:01 +02:00
|
|
|
#ifndef WLR_TYPES_WLR_SEAT_H
|
|
|
|
#define WLR_TYPES_WLR_SEAT_H
|
2017-11-12 15:55:28 +01:00
|
|
|
#include <time.h>
|
2017-09-20 13:32:28 +02:00
|
|
|
#include <wlr/types/wlr_surface.h>
|
|
|
|
#include <wlr/types/wlr_input_device.h>
|
2017-09-24 20:12:56 +02:00
|
|
|
#include <wlr/types/wlr_keyboard.h>
|
2017-08-16 14:50:43 +02:00
|
|
|
#include <wayland-server.h>
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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 wlr_seat; some may be NULL.
|
|
|
|
*/
|
2017-10-30 13:37:54 +01:00
|
|
|
struct wlr_seat_client {
|
2017-08-16 14:50:43 +02:00
|
|
|
struct wl_resource *wl_resource;
|
2017-10-30 13:37:54 +01:00
|
|
|
struct wl_client *client;
|
2017-10-30 13:44:39 +01:00
|
|
|
struct wlr_seat *seat;
|
2017-08-16 14:50:43 +02:00
|
|
|
|
|
|
|
struct wl_resource *pointer;
|
|
|
|
struct wl_resource *keyboard;
|
|
|
|
struct wl_resource *touch;
|
2017-08-18 18:51:09 +02:00
|
|
|
struct wl_resource *data_device;
|
2017-08-16 14:50:43 +02:00
|
|
|
|
|
|
|
struct wl_list link;
|
|
|
|
};
|
|
|
|
|
2017-11-14 01:16:34 +01:00
|
|
|
struct wlr_touch_point {
|
|
|
|
int32_t touch_id;
|
|
|
|
struct wlr_surface *surface;
|
|
|
|
struct wlr_seat_client *client;
|
2017-11-14 14:51:37 +01:00
|
|
|
|
|
|
|
struct wlr_surface *focus_surface;
|
|
|
|
struct wlr_seat_client *focus_client;
|
2017-11-14 01:16:34 +01:00
|
|
|
double sx, sy;
|
|
|
|
|
|
|
|
struct wl_listener surface_destroy;
|
2017-11-14 14:51:37 +01:00
|
|
|
struct wl_listener focus_surface_destroy;
|
2017-11-14 01:16:34 +01:00
|
|
|
struct wl_listener resource_destroy;
|
|
|
|
|
|
|
|
struct {
|
|
|
|
struct wl_signal destroy;
|
|
|
|
} events;
|
|
|
|
|
|
|
|
struct wl_list link;
|
|
|
|
};
|
|
|
|
|
2017-10-05 19:28:26 +02:00
|
|
|
struct wlr_seat_pointer_grab;
|
|
|
|
|
|
|
|
struct wlr_pointer_grab_interface {
|
|
|
|
void (*enter)(struct wlr_seat_pointer_grab *grab,
|
|
|
|
struct wlr_surface *surface, double sx, double sy);
|
|
|
|
void (*motion)(struct wlr_seat_pointer_grab *grab, uint32_t time,
|
|
|
|
double sx, double sy);
|
|
|
|
uint32_t (*button)(struct wlr_seat_pointer_grab *grab, uint32_t time,
|
|
|
|
uint32_t button, uint32_t state);
|
|
|
|
void (*axis)(struct wlr_seat_pointer_grab *grab, uint32_t time,
|
|
|
|
enum wlr_axis_orientation orientation, double value);
|
|
|
|
void (*cancel)(struct wlr_seat_pointer_grab *grab);
|
|
|
|
};
|
|
|
|
|
2017-10-07 17:02:11 +02:00
|
|
|
struct wlr_seat_keyboard_grab;
|
|
|
|
|
|
|
|
struct wlr_keyboard_grab_interface {
|
2017-10-30 13:37:54 +01:00
|
|
|
void (*enter)(struct wlr_seat_keyboard_grab *grab,
|
|
|
|
struct wlr_surface *surface);
|
2017-10-07 17:02:11 +02:00
|
|
|
void (*key)(struct wlr_seat_keyboard_grab *grab, uint32_t time,
|
|
|
|
uint32_t key, uint32_t state);
|
2017-11-08 19:02:56 +01:00
|
|
|
void (*modifiers)(struct wlr_seat_keyboard_grab *grab);
|
2017-10-07 17:02:11 +02:00
|
|
|
void (*cancel)(struct wlr_seat_keyboard_grab *grab);
|
|
|
|
};
|
|
|
|
|
2017-11-12 23:04:56 +01:00
|
|
|
struct wlr_seat_touch_grab;
|
|
|
|
|
|
|
|
struct wlr_touch_grab_interface {
|
2017-11-14 01:16:34 +01:00
|
|
|
void (*down)(struct wlr_seat_touch_grab *grab, uint32_t time,
|
|
|
|
struct wlr_touch_point *point);
|
|
|
|
void (*up)(struct wlr_seat_touch_grab *grab, uint32_t time,
|
|
|
|
struct wlr_touch_point *point);
|
|
|
|
void (*motion)(struct wlr_seat_touch_grab *grab, uint32_t time,
|
|
|
|
struct wlr_touch_point *point);
|
2017-11-14 14:51:37 +01:00
|
|
|
void (*enter)(struct wlr_seat_touch_grab *grab, uint32_t time,
|
|
|
|
struct wlr_touch_point *point);
|
2017-11-12 23:04:56 +01:00
|
|
|
// XXX this will conflict with the actual touch cancel which is different so
|
|
|
|
// we need to rename this
|
|
|
|
void (*cancel)(struct wlr_seat_touch_grab *grab);
|
|
|
|
};
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
struct wlr_seat_touch_grab {
|
|
|
|
const struct wlr_touch_grab_interface *interface;
|
|
|
|
struct wlr_seat *seat;
|
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
2017-10-07 17:02:11 +02:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
struct wlr_seat_keyboard_grab {
|
|
|
|
const struct wlr_keyboard_grab_interface *interface;
|
|
|
|
struct wlr_seat *seat;
|
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
2017-10-05 19:28:26 +02:00
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
struct wlr_seat_pointer_grab {
|
|
|
|
const struct wlr_pointer_grab_interface *interface;
|
|
|
|
struct wlr_seat *seat;
|
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
2017-09-20 13:32:28 +02:00
|
|
|
struct wlr_seat_pointer_state {
|
2017-10-30 13:44:39 +01:00
|
|
|
struct wlr_seat *seat;
|
2017-10-30 13:37:54 +01:00
|
|
|
struct wlr_seat_client *focused_client;
|
2017-09-20 13:32:28 +02:00
|
|
|
struct wlr_surface *focused_surface;
|
|
|
|
|
2017-10-05 19:28:26 +02:00
|
|
|
struct wlr_seat_pointer_grab *grab;
|
|
|
|
struct wlr_seat_pointer_grab *default_grab;
|
2017-10-16 12:31:53 +02:00
|
|
|
|
|
|
|
uint32_t button_count;
|
|
|
|
uint32_t grab_button;
|
|
|
|
uint32_t grab_serial;
|
|
|
|
uint32_t grab_time;
|
|
|
|
|
|
|
|
struct wl_listener surface_destroy;
|
|
|
|
struct wl_listener resource_destroy;
|
2017-09-20 13:32:28 +02:00
|
|
|
};
|
|
|
|
|
2017-11-12 23:25:10 +01:00
|
|
|
// TODO: May be useful to be able to simulate keyboard input events
|
2017-09-22 22:07:00 +02:00
|
|
|
struct wlr_seat_keyboard_state {
|
2017-10-30 13:44:39 +01:00
|
|
|
struct wlr_seat *seat;
|
2017-10-23 14:59:55 +02:00
|
|
|
struct wlr_keyboard *keyboard;
|
|
|
|
|
2017-10-30 13:37:54 +01:00
|
|
|
struct wlr_seat_client *focused_client;
|
2017-09-22 22:07:00 +02:00
|
|
|
struct wlr_surface *focused_surface;
|
|
|
|
|
2017-10-23 14:59:55 +02:00
|
|
|
struct wl_listener keyboard_destroy;
|
|
|
|
struct wl_listener keyboard_keymap;
|
|
|
|
|
2017-09-25 14:29:35 +02:00
|
|
|
struct wl_listener surface_destroy;
|
|
|
|
struct wl_listener resource_destroy;
|
2017-10-07 17:02:11 +02:00
|
|
|
|
|
|
|
struct wlr_seat_keyboard_grab *grab;
|
|
|
|
struct wlr_seat_keyboard_grab *default_grab;
|
2017-09-22 22:07:00 +02:00
|
|
|
};
|
|
|
|
|
2017-11-12 17:43:50 +01:00
|
|
|
struct wlr_seat_touch_state {
|
|
|
|
struct wlr_seat *seat;
|
|
|
|
struct wl_list touch_points; // wlr_touch_point::link
|
2017-11-12 23:04:56 +01:00
|
|
|
|
2017-11-13 14:22:04 +01:00
|
|
|
uint32_t grab_serial;
|
2017-11-13 21:41:48 +01:00
|
|
|
uint32_t grab_id;
|
2017-11-13 14:22:04 +01:00
|
|
|
|
2017-11-12 23:04:56 +01:00
|
|
|
struct wlr_seat_touch_grab *grab;
|
|
|
|
struct wlr_seat_touch_grab *default_grab;
|
2017-11-12 17:43:50 +01:00
|
|
|
};
|
|
|
|
|
2017-08-16 14:50:43 +02:00
|
|
|
struct wlr_seat {
|
|
|
|
struct wl_global *wl_global;
|
2017-09-20 13:32:28 +02:00
|
|
|
struct wl_display *display;
|
2017-10-30 13:37:54 +01:00
|
|
|
struct wl_list clients;
|
2017-08-16 14:50:43 +02:00
|
|
|
char *name;
|
|
|
|
uint32_t capabilities;
|
2017-11-12 15:55:28 +01:00
|
|
|
struct timespec last_event;
|
2017-10-11 21:48:40 +02:00
|
|
|
|
|
|
|
struct wlr_data_device *data_device; // TODO needed?
|
|
|
|
struct wlr_data_source *selection_source;
|
|
|
|
uint32_t selection_serial;
|
2017-08-16 14:50:43 +02:00
|
|
|
|
2017-09-20 13:32:28 +02:00
|
|
|
struct wlr_seat_pointer_state pointer_state;
|
2017-09-22 22:07:00 +02:00
|
|
|
struct wlr_seat_keyboard_state keyboard_state;
|
2017-11-12 17:43:50 +01:00
|
|
|
struct wlr_seat_touch_state touch_state;
|
2017-09-20 13:32:28 +02:00
|
|
|
|
2017-10-12 17:41:11 +02:00
|
|
|
struct wl_listener selection_data_source_destroy;
|
|
|
|
|
2017-08-16 14:50:43 +02:00
|
|
|
struct {
|
|
|
|
struct wl_signal client_bound;
|
|
|
|
struct wl_signal client_unbound;
|
2017-10-06 13:32:59 +02:00
|
|
|
|
|
|
|
struct wl_signal pointer_grab_begin;
|
|
|
|
struct wl_signal pointer_grab_end;
|
2017-10-07 17:02:11 +02:00
|
|
|
|
|
|
|
struct wl_signal keyboard_grab_begin;
|
|
|
|
struct wl_signal keyboard_grab_end;
|
2017-10-05 13:11:51 +02:00
|
|
|
|
2017-11-12 23:34:32 +01:00
|
|
|
struct wl_signal touch_grab_begin;
|
|
|
|
struct wl_signal touch_grab_end;
|
|
|
|
|
2017-10-05 13:11:51 +02:00
|
|
|
struct wl_signal request_set_cursor;
|
2017-10-16 11:07:09 +02:00
|
|
|
|
|
|
|
struct wl_signal selection;
|
2017-08-16 14:50:43 +02:00
|
|
|
} events;
|
|
|
|
|
|
|
|
void *data;
|
|
|
|
};
|
|
|
|
|
2017-10-05 13:11:51 +02:00
|
|
|
struct wlr_seat_pointer_request_set_cursor_event {
|
2017-10-30 13:37:54 +01:00
|
|
|
struct wlr_seat_client *seat_client;
|
2017-10-05 13:11:51 +02:00
|
|
|
struct wlr_surface *surface;
|
2017-11-01 18:15:37 +01:00
|
|
|
uint32_t serial;
|
2017-10-05 13:11:51 +02:00
|
|
|
int32_t hotspot_x, hotspot_y;
|
|
|
|
};
|
|
|
|
|
2017-08-16 14:50:43 +02:00
|
|
|
/**
|
|
|
|
* Allocates a new wlr_seat and adds a wl_seat global to the display.
|
|
|
|
*/
|
|
|
|
struct wlr_seat *wlr_seat_create(struct wl_display *display, const char *name);
|
|
|
|
/**
|
|
|
|
* Destroys a wlr_seat and removes its wl_seat global.
|
|
|
|
*/
|
|
|
|
void wlr_seat_destroy(struct wlr_seat *wlr_seat);
|
|
|
|
/**
|
2017-10-30 13:37:54 +01:00
|
|
|
* Gets a wlr_seat_client for the specified client, or returns NULL if no
|
|
|
|
* client is bound for that client.
|
2017-08-16 14:50:43 +02:00
|
|
|
*/
|
2017-10-30 13:37:54 +01:00
|
|
|
struct wlr_seat_client *wlr_seat_client_for_wl_client(struct wlr_seat *wlr_seat,
|
|
|
|
struct wl_client *wl_client);
|
2017-08-16 14:50:43 +02:00
|
|
|
/**
|
|
|
|
* Updates the capabilities available on this seat.
|
2017-08-17 12:55:59 +02:00
|
|
|
* Will automatically send them to all clients.
|
2017-08-16 14:50:43 +02:00
|
|
|
*/
|
2017-09-19 21:38:06 +02:00
|
|
|
void wlr_seat_set_capabilities(struct wlr_seat *wlr_seat,
|
|
|
|
uint32_t capabilities);
|
2017-08-16 14:50:43 +02:00
|
|
|
/**
|
|
|
|
* Updates the name of this seat.
|
2017-08-17 12:55:59 +02:00
|
|
|
* Will automatically send it to all clients.
|
2017-08-16 14:50:43 +02:00
|
|
|
*/
|
|
|
|
void wlr_seat_set_name(struct wlr_seat *wlr_seat, const char *name);
|
|
|
|
|
2017-09-20 13:32:28 +02:00
|
|
|
/**
|
|
|
|
* Whether or not the surface has pointer focus
|
|
|
|
*/
|
|
|
|
bool wlr_seat_pointer_surface_has_focus(struct wlr_seat *wlr_seat,
|
|
|
|
struct wlr_surface *surface);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* 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.
|
2017-10-05 19:28:26 +02:00
|
|
|
* Compositor should use `wlr_seat_pointer_notify_enter()` to change pointer
|
|
|
|
* focus to respect pointer grabs.
|
2017-09-20 13:32:28 +02:00
|
|
|
*/
|
|
|
|
void wlr_seat_pointer_enter(struct wlr_seat *wlr_seat,
|
2017-09-21 17:38:04 +02:00
|
|
|
struct wlr_surface *surface, double sx, double sy);
|
2017-09-20 13:32:28 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Clear the focused surface for the pointer and leave all entered surfaces.
|
|
|
|
*/
|
|
|
|
void wlr_seat_pointer_clear_focus(struct wlr_seat *wlr_seat);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Send a motion event to the surface with pointer focus. Coordinates for the
|
2017-10-05 19:28:26 +02:00
|
|
|
* motion event are surface-local. Compositors should use
|
|
|
|
* `wlr_seat_pointer_notify_motion()` to send motion events to respect pointer
|
|
|
|
* grabs.
|
2017-09-20 13:32:28 +02:00
|
|
|
*/
|
|
|
|
void wlr_seat_pointer_send_motion(struct wlr_seat *wlr_seat, uint32_t time,
|
2017-09-21 17:38:04 +02:00
|
|
|
double sx, double sy);
|
2017-09-20 13:32:28 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Send a button event to the surface with pointer focus. Coordinates for the
|
2017-10-05 19:28:26 +02:00
|
|
|
* button event are surface-local. Returns the serial. Compositors should use
|
|
|
|
* `wlr_seat_pointer_notify_button()` to send button events to respect pointer
|
|
|
|
* grabs.
|
2017-09-20 13:32:28 +02:00
|
|
|
*/
|
2017-09-22 17:11:11 +02:00
|
|
|
uint32_t wlr_seat_pointer_send_button(struct wlr_seat *wlr_seat, uint32_t time,
|
2017-09-22 00:30:04 +02:00
|
|
|
uint32_t button, uint32_t state);
|
2017-09-20 13:32:28 +02:00
|
|
|
|
2017-10-05 19:28:26 +02:00
|
|
|
/**
|
|
|
|
* Send an axis event to the surface with pointer focus. Compositors should use
|
|
|
|
* `wlr_seat_pointer_notify_axis()` to send axis events to respect pointer
|
|
|
|
* grabs.
|
|
|
|
**/
|
2017-09-22 16:30:09 +02:00
|
|
|
void wlr_seat_pointer_send_axis(struct wlr_seat *wlr_seat, uint32_t time,
|
|
|
|
enum wlr_axis_orientation orientation, double value);
|
|
|
|
|
2017-10-05 19:28:26 +02:00
|
|
|
/**
|
|
|
|
* Start a grab of the pointer of this seat. The grabber is responsible for
|
|
|
|
* handling all pointer events until the grab ends.
|
|
|
|
*/
|
|
|
|
void wlr_seat_pointer_start_grab(struct wlr_seat *wlr_seat,
|
|
|
|
struct wlr_seat_pointer_grab *grab);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* End the grab of the pointer of this seat. This reverts the grab back to the
|
|
|
|
* default grab for the pointer.
|
|
|
|
*/
|
|
|
|
void wlr_seat_pointer_end_grab(struct wlr_seat *wlr_seat);
|
|
|
|
|
|
|
|
/**
|
2017-10-30 13:37:54 +01:00
|
|
|
* 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.
|
2017-10-05 19:28:26 +02:00
|
|
|
*/
|
|
|
|
void wlr_seat_pointer_notify_enter(struct wlr_seat *wlr_seat,
|
|
|
|
struct wlr_surface *surface, double sx, double sy);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Notify the seat of motion over the given surface. Pass surface-local
|
|
|
|
* coordinates where the pointer motion occurred.
|
|
|
|
*/
|
|
|
|
void wlr_seat_pointer_notify_motion(struct wlr_seat *wlr_seat, uint32_t time,
|
|
|
|
double sx, double sy);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Notify the seat that a button has been pressed. Returns the serial of the
|
|
|
|
* button press or zero if no button press was sent.
|
|
|
|
*/
|
|
|
|
uint32_t wlr_seat_pointer_notify_button(struct wlr_seat *wlr_seat,
|
|
|
|
uint32_t time, uint32_t button, uint32_t state);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Notify the seat of an axis event.
|
|
|
|
*/
|
|
|
|
void wlr_seat_pointer_notify_axis(struct wlr_seat *wlr_seat, uint32_t time,
|
|
|
|
enum wlr_axis_orientation orientation, double value);
|
|
|
|
|
2017-09-24 20:12:56 +02:00
|
|
|
/**
|
2017-10-23 14:59:55 +02:00
|
|
|
* Set this keyboard as the active keyboard for the seat.
|
2017-09-24 20:12:56 +02:00
|
|
|
*/
|
2017-10-23 14:59:55 +02:00
|
|
|
void wlr_seat_set_keyboard(struct wlr_seat *seat, struct wlr_input_device *dev);
|
2017-09-24 20:12:56 +02:00
|
|
|
|
2017-10-07 17:02:11 +02:00
|
|
|
/**
|
|
|
|
* Start a grab of the keyboard of this seat. The grabber is responsible for
|
|
|
|
* handling all keyboard events until the grab ends.
|
|
|
|
*/
|
|
|
|
void wlr_seat_keyboard_start_grab(struct wlr_seat *wlr_seat,
|
|
|
|
struct wlr_seat_keyboard_grab *grab);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* End the grab of the keyboard of this seat. This reverts the grab back to the
|
|
|
|
* default grab for the keyboard.
|
|
|
|
*/
|
|
|
|
void wlr_seat_keyboard_end_grab(struct wlr_seat *wlr_seat);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* Send the keyboard key to focused keyboard resources. Compositors should use
|
2017-10-23 14:59:55 +02:00
|
|
|
* `wlr_seat_notify_key()` to respect keyboard grabs.
|
2017-10-07 17:02:11 +02:00
|
|
|
*/
|
|
|
|
void wlr_seat_keyboard_send_key(struct wlr_seat *seat, uint32_t time,
|
|
|
|
uint32_t key, uint32_t state);
|
|
|
|
|
2017-10-23 14:59:55 +02:00
|
|
|
/**
|
|
|
|
* Notify the seat that a key has been pressed on the keyboard. Defers to any
|
|
|
|
* keyboard grabs.
|
|
|
|
*/
|
|
|
|
void wlr_seat_keyboard_notify_key(struct wlr_seat *seat, uint32_t time,
|
|
|
|
uint32_t key, uint32_t state);
|
|
|
|
|
2017-10-07 17:02:11 +02:00
|
|
|
/**
|
|
|
|
* Send the modifier state to focused keyboard resources. Compositors should use
|
2017-10-23 14:59:55 +02:00
|
|
|
* `wlr_seat_keyboard_notify_modifiers()` to respect any keyboard grabs.
|
2017-10-07 17:02:11 +02:00
|
|
|
*/
|
2017-11-08 19:02:56 +01:00
|
|
|
void wlr_seat_keyboard_send_modifiers(struct wlr_seat *seat);
|
2017-10-23 14:59:55 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* Notify the seat that the modifiers for the keyboard have changed. Defers to
|
|
|
|
* any keyboard grabs.
|
|
|
|
*/
|
2017-11-08 19:02:56 +01:00
|
|
|
void wlr_seat_keyboard_notify_modifiers(struct wlr_seat *seat);
|
2017-10-07 17:02:11 +02:00
|
|
|
|
|
|
|
/**
|
|
|
|
* 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.
|
|
|
|
*/
|
|
|
|
void wlr_seat_keyboard_notify_enter(struct wlr_seat *wlr_seat,
|
|
|
|
struct wlr_surface *surface);
|
|
|
|
|
2017-09-22 22:07:00 +02:00
|
|
|
/**
|
2017-09-25 14:29:35 +02:00
|
|
|
* 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
|
2017-10-07 17:02:11 +02:00
|
|
|
* surface that was entered. Compositors should use
|
|
|
|
* `wlr_seat_keyboard_notify_enter()` to change keyboard focus to respect
|
|
|
|
* keyboard grabs.
|
2017-09-22 22:07:00 +02:00
|
|
|
*/
|
2017-09-25 14:29:35 +02:00
|
|
|
void wlr_seat_keyboard_enter(struct wlr_seat *wlr_seat,
|
|
|
|
struct wlr_surface *surface);
|
2017-09-22 22:07:00 +02:00
|
|
|
|
2017-09-22 23:09:47 +02:00
|
|
|
/**
|
2017-09-25 14:29:35 +02:00
|
|
|
* Clear the focused surface for the keyboard and leave all entered surfaces.
|
2017-09-22 23:09:47 +02:00
|
|
|
*/
|
2017-09-25 14:29:35 +02:00
|
|
|
void wlr_seat_keyboard_clear_focus(struct wlr_seat *wlr_seat);
|
2017-09-22 23:09:47 +02:00
|
|
|
|
2017-11-12 23:34:32 +01:00
|
|
|
/**
|
|
|
|
* Start a grab of the touch device of this seat. The grabber is responsible for
|
|
|
|
* handling all touch events until the grab ends.
|
|
|
|
*/
|
|
|
|
void wlr_seat_touch_start_grab(struct wlr_seat *wlr_seat,
|
|
|
|
struct wlr_seat_touch_grab *grab);
|
|
|
|
|
|
|
|
/**
|
|
|
|
* End the grab of the touch device of this seat. This reverts the grab back to
|
|
|
|
* the default grab for the touch device.
|
|
|
|
*/
|
|
|
|
void wlr_seat_touch_end_grab(struct wlr_seat *wlr_seat);
|
|
|
|
|
2017-11-12 23:25:10 +01:00
|
|
|
/**
|
|
|
|
* Get the active touch point with the given `touch_id`. If the touch point does
|
|
|
|
* not exist or is no longer active, returns NULL.
|
|
|
|
*/
|
2017-11-12 17:43:50 +01:00
|
|
|
struct wlr_touch_point *wlr_seat_touch_get_point(struct wlr_seat *seat,
|
|
|
|
int32_t touch_id);
|
|
|
|
|
2017-11-12 23:25:10 +01:00
|
|
|
/**
|
|
|
|
* Notify the seat of a touch down on the given surface. Defers to any grab of
|
|
|
|
* the touch device.
|
|
|
|
*/
|
2017-11-12 17:43:50 +01:00
|
|
|
void wlr_seat_touch_notify_down(struct wlr_seat *seat,
|
|
|
|
struct wlr_surface *surface, uint32_t time, int32_t touch_id, double sx,
|
|
|
|
double sy);
|
|
|
|
|
2017-11-12 23:25:10 +01:00
|
|
|
/**
|
|
|
|
* Notify the seat that the touch point given by `touch_id` is up. Defers to any
|
|
|
|
* grab of the touch device.
|
|
|
|
*/
|
2017-11-12 17:43:50 +01:00
|
|
|
void wlr_seat_touch_notify_up(struct wlr_seat *seat, uint32_t time,
|
|
|
|
int32_t touch_id);
|
|
|
|
|
2017-11-12 23:25:10 +01:00
|
|
|
/**
|
|
|
|
* Notify the seat that the touch point given by `touch_id` has moved. Defers to
|
2017-11-14 01:16:34 +01:00
|
|
|
* 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.
|
2017-11-12 23:25:10 +01:00
|
|
|
*/
|
2017-11-14 14:51:37 +01:00
|
|
|
void wlr_seat_touch_notify_motion(struct wlr_seat *seat, uint32_t time,
|
|
|
|
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()`.
|
|
|
|
*/
|
|
|
|
void wlr_seat_touch_point_focus(struct wlr_seat *seat,
|
2017-11-14 01:16:34 +01:00
|
|
|
struct wlr_surface *surface, uint32_t time, int32_t touch_id, double sx,
|
|
|
|
double sy);
|
2017-11-12 17:43:50 +01:00
|
|
|
|
2017-11-14 14:51:37 +01:00
|
|
|
/**
|
|
|
|
* Clear the focused surface for the touch point given by `touch_id`.
|
|
|
|
*/
|
|
|
|
void wlr_seat_touch_point_clear_focus(struct wlr_seat *seat, uint32_t time,
|
|
|
|
int32_t touch_id);
|
|
|
|
|
2017-11-12 23:25:10 +01:00
|
|
|
/**
|
|
|
|
* 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. Compositors should use
|
|
|
|
* `wlr_seat_touch_notify_down()` to respect any grabs of the touch device.
|
|
|
|
*/
|
2017-11-12 23:04:56 +01:00
|
|
|
void wlr_seat_touch_send_down(struct wlr_seat *seat,
|
|
|
|
struct wlr_surface *surface, uint32_t time, int32_t touch_id, double sx,
|
|
|
|
double sy);
|
|
|
|
|
2017-11-12 23:25:10 +01:00
|
|
|
/**
|
|
|
|
* 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 cooresponding touch down
|
|
|
|
* event. This will remove the touch point. Compositors should use
|
|
|
|
* `wlr_seat_touch_notify_up()` to respect any grabs of the touch device.
|
|
|
|
*/
|
2017-11-12 23:04:56 +01:00
|
|
|
void wlr_seat_touch_send_up(struct wlr_seat *seat, uint32_t time,
|
|
|
|
int32_t touch_id);
|
|
|
|
|
2017-11-12 23:25:10 +01:00
|
|
|
/**
|
|
|
|
* Send a touch motion event for the touch point given by the `touch_id`. The
|
2017-11-14 01:16:34 +01:00
|
|
|
* event will go to the client for the surface given in the corresponding touch
|
2017-11-12 23:25:10 +01:00
|
|
|
* down event. Compositors should use `wlr_seat_touch_notify_motion()` to
|
|
|
|
* respect any grabs of the touch device.
|
|
|
|
*/
|
2017-11-12 23:04:56 +01:00
|
|
|
void wlr_seat_touch_send_motion(struct wlr_seat *seat, uint32_t time,
|
|
|
|
int32_t touch_id, double sx, double sy);
|
|
|
|
|
2017-08-16 14:50:43 +02:00
|
|
|
#endif
|