mirror of
https://gitlab.freedesktop.org/wlroots/wlroots.git
synced 2026-04-18 06:47:31 -04:00
Merge branch 'seat-grab-rework' into 'master'
Draft: seat: rework grabs See merge request wlroots/wlroots!3957
This commit is contained in:
Kirill Primak
commit
a2b02dfc36
10 changed files with 261 additions and 346 deletions
|
|
@ -4,9 +4,9 @@
|
|||
#include <wayland-server-core.h>
|
||||
#include <wlr/types/wlr_seat.h>
|
||||
|
||||
extern const struct wlr_pointer_grab_interface default_pointer_grab_impl;
|
||||
extern const struct wlr_keyboard_grab_interface default_keyboard_grab_impl;
|
||||
extern const struct wlr_touch_grab_interface default_touch_grab_impl;
|
||||
extern const struct wlr_pointer_grab default_pointer_grab;
|
||||
extern const struct wlr_keyboard_grab default_keyboard_grab;
|
||||
extern const struct wlr_touch_grab default_touch_grab;
|
||||
|
||||
void seat_client_create_pointer(struct wlr_seat_client *seat_client,
|
||||
uint32_t version, uint32_t id);
|
||||
|
|
|
|||
|
|
@ -12,9 +12,6 @@
|
|||
#include <wayland-server-core.h>
|
||||
#include <wlr/types/wlr_seat.h>
|
||||
|
||||
extern const struct wlr_pointer_grab_interface
|
||||
wlr_data_device_pointer_drag_interface;
|
||||
|
||||
extern const struct wlr_keyboard_grab_interface
|
||||
wlr_data_device_keyboard_drag_interface;
|
||||
|
||||
|
|
@ -112,9 +109,6 @@ enum wlr_drag_grab_type {
|
|||
|
||||
struct wlr_drag {
|
||||
enum wlr_drag_grab_type grab_type;
|
||||
struct wlr_seat_keyboard_grab keyboard_grab;
|
||||
struct wlr_seat_pointer_grab pointer_grab;
|
||||
struct wlr_seat_touch_grab touch_grab;
|
||||
|
||||
struct wlr_seat *seat;
|
||||
struct wlr_seat_client *seat_client;
|
||||
|
|
|
|||
|
|
@ -89,84 +89,46 @@ struct wlr_touch_point {
|
|||
struct wl_list link;
|
||||
};
|
||||
|
||||
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 (*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_pointer_grab {
|
||||
void (*enter)(void *data, struct wlr_surface *surface, double sx, double sy);
|
||||
void (*clear_focus)(void *data);
|
||||
void (*motion)(void *data, uint32_t time_msec,
|
||||
double sx, double sy);
|
||||
uint32_t (*button)(void *data, uint32_t time_msec,
|
||||
uint32_t button, enum wlr_button_state state);
|
||||
void (*axis)(void *data, uint32_t time_msec,
|
||||
enum wlr_axis_orientation orientation, double value,
|
||||
int32_t value_discrete, enum wlr_axis_source source);
|
||||
void (*frame)(void *data);
|
||||
void (*cancel)(void *data);
|
||||
};
|
||||
|
||||
struct wlr_seat_keyboard_grab;
|
||||
|
||||
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_keyboard_grab {
|
||||
void (*enter)(void *data,
|
||||
struct wlr_surface *surface, uint32_t keycodes[],
|
||||
size_t num_keycodes, struct wlr_keyboard_modifiers *modifiers);
|
||||
void (*clear_focus)(void *data);
|
||||
void (*key)(void *data, uint32_t time_msec, uint32_t key, uint32_t state);
|
||||
void (*modifiers)(void *data, struct wlr_keyboard_modifiers *modifiers);
|
||||
void (*cancel)(void *data);
|
||||
};
|
||||
|
||||
struct wlr_seat_touch_grab;
|
||||
|
||||
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);
|
||||
struct wlr_touch_grab {
|
||||
uint32_t (*down)(void *data, uint32_t time_msec,
|
||||
struct wlr_touch_point *point);
|
||||
void (*up)(void *data, uint32_t time_msec,
|
||||
struct wlr_touch_point *point);
|
||||
void (*motion)(void *data, uint32_t time_msec,
|
||||
struct wlr_touch_point *point);
|
||||
void (*enter)(void *data, uint32_t time_msec,
|
||||
struct wlr_touch_point *point);
|
||||
void (*frame)(void *data);
|
||||
// Cancel grab
|
||||
void (*cancel)(struct wlr_seat_touch_grab *grab);
|
||||
void (*cancel)(void *data);
|
||||
// Send wl_touch::cancel
|
||||
void (*wl_cancel)(struct wlr_seat_touch_grab *grab,
|
||||
struct wlr_surface *surface);
|
||||
};
|
||||
|
||||
/**
|
||||
* 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;
|
||||
};
|
||||
|
||||
/**
|
||||
* 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;
|
||||
};
|
||||
|
||||
/**
|
||||
* 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;
|
||||
void (*wl_cancel)(void *data, struct wlr_surface *surface);
|
||||
};
|
||||
|
||||
#define WLR_POINTER_BUTTONS_CAP 16
|
||||
|
|
@ -177,8 +139,8 @@ struct wlr_seat_pointer_state {
|
|||
struct wlr_surface *focused_surface;
|
||||
double sx, sy;
|
||||
|
||||
struct wlr_seat_pointer_grab *grab;
|
||||
struct wlr_seat_pointer_grab *default_grab;
|
||||
const struct wlr_pointer_grab *grab;
|
||||
void *grab_data;
|
||||
|
||||
bool sent_axis_source;
|
||||
enum wlr_axis_source cached_axis_source;
|
||||
|
|
@ -210,8 +172,8 @@ struct wlr_seat_keyboard_state {
|
|||
|
||||
struct wl_listener surface_destroy;
|
||||
|
||||
struct wlr_seat_keyboard_grab *grab;
|
||||
struct wlr_seat_keyboard_grab *default_grab;
|
||||
const struct wlr_keyboard_grab *grab;
|
||||
void *grab_data;
|
||||
|
||||
struct {
|
||||
struct wl_signal focus_change; // struct wlr_seat_keyboard_focus_change_event
|
||||
|
|
@ -225,8 +187,8 @@ struct wlr_seat_touch_state {
|
|||
uint32_t grab_serial;
|
||||
uint32_t grab_id;
|
||||
|
||||
struct wlr_seat_touch_grab *grab;
|
||||
struct wlr_seat_touch_grab *default_grab;
|
||||
const struct wlr_touch_grab *grab;
|
||||
void *grab_data;
|
||||
};
|
||||
|
||||
struct wlr_primary_selection_source;
|
||||
|
|
@ -473,7 +435,7 @@ void wlr_seat_pointer_notify_frame(struct wlr_seat *wlr_seat);
|
|||
* 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);
|
||||
const struct wlr_pointer_grab *grab, void *data);
|
||||
|
||||
/**
|
||||
* End the grab of the pointer of this seat. This reverts the grab back to the
|
||||
|
|
@ -563,7 +525,7 @@ void wlr_seat_keyboard_notify_clear_focus(struct wlr_seat *wlr_seat);
|
|||
* 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);
|
||||
const struct wlr_keyboard_grab *grab, void *data);
|
||||
|
||||
/**
|
||||
* End the grab of the keyboard of this seat. This reverts the grab back to the
|
||||
|
|
@ -681,7 +643,7 @@ int wlr_seat_touch_num_points(struct wlr_seat *seat);
|
|||
* 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);
|
||||
const struct wlr_touch_grab *grab, void *data);
|
||||
|
||||
/**
|
||||
* End the grab of the touch device of this seat. This reverts the grab back to
|
||||
|
|
|
|||
|
|
@ -117,9 +117,6 @@ struct wlr_xdg_popup {
|
|||
// each seat gets a popup grab
|
||||
struct wlr_xdg_popup_grab {
|
||||
struct wl_client *client;
|
||||
struct wlr_seat_pointer_grab pointer_grab;
|
||||
struct wlr_seat_keyboard_grab keyboard_grab;
|
||||
struct wlr_seat_touch_grab touch_grab;
|
||||
struct wlr_seat *seat;
|
||||
struct wl_list popups;
|
||||
struct wl_list link; // wlr_xdg_shell.popup_grabs
|
||||
|
|
|
|||
|
|
@ -160,20 +160,20 @@ static void drag_destroy(struct wlr_drag *drag) {
|
|||
free(drag);
|
||||
}
|
||||
|
||||
static void drag_handle_pointer_enter(struct wlr_seat_pointer_grab *grab,
|
||||
static void drag_handle_pointer_enter(void *data,
|
||||
struct wlr_surface *surface, double sx, double sy) {
|
||||
struct wlr_drag *drag = grab->data;
|
||||
struct wlr_drag *drag = data;
|
||||
drag_set_focus(drag, surface, sx, sy);
|
||||
}
|
||||
|
||||
static void drag_handle_pointer_clear_focus(struct wlr_seat_pointer_grab *grab) {
|
||||
struct wlr_drag *drag = grab->data;
|
||||
static void drag_handle_pointer_clear_focus(void *data) {
|
||||
struct wlr_drag *drag = data;
|
||||
drag_set_focus(drag, NULL, 0, 0);
|
||||
}
|
||||
|
||||
static void drag_handle_pointer_motion(struct wlr_seat_pointer_grab *grab,
|
||||
static void drag_handle_pointer_motion(void *data,
|
||||
uint32_t time, double sx, double sy) {
|
||||
struct wlr_drag *drag = grab->data;
|
||||
struct wlr_drag *drag = data;
|
||||
if (drag->focus != NULL && drag->focus_client != NULL) {
|
||||
struct wl_resource *resource;
|
||||
wl_resource_for_each(resource, &drag->focus_client->data_devices) {
|
||||
|
|
@ -211,12 +211,12 @@ static void drag_drop(struct wlr_drag *drag, uint32_t time) {
|
|||
wl_signal_emit_mutable(&drag->events.drop, &event);
|
||||
}
|
||||
|
||||
static uint32_t drag_handle_pointer_button(struct wlr_seat_pointer_grab *grab,
|
||||
static uint32_t drag_handle_pointer_button(void *data,
|
||||
uint32_t time, uint32_t button, uint32_t state) {
|
||||
struct wlr_drag *drag = grab->data;
|
||||
struct wlr_drag *drag = data;
|
||||
|
||||
if (drag->source &&
|
||||
grab->seat->pointer_state.grab_button == button &&
|
||||
drag->seat->pointer_state.grab_button == button &&
|
||||
state == WL_POINTER_BUTTON_STATE_RELEASED) {
|
||||
if (drag->focus_client && drag->source->current_dnd_action &&
|
||||
drag->source->accepted) {
|
||||
|
|
@ -228,7 +228,7 @@ static uint32_t drag_handle_pointer_button(struct wlr_seat_pointer_grab *grab,
|
|||
}
|
||||
}
|
||||
|
||||
if (grab->seat->pointer_state.button_count == 0 &&
|
||||
if (drag->seat->pointer_state.button_count == 0 &&
|
||||
state == WL_POINTER_BUTTON_STATE_RELEASED) {
|
||||
drag_destroy(drag);
|
||||
}
|
||||
|
|
@ -236,19 +236,18 @@ static uint32_t drag_handle_pointer_button(struct wlr_seat_pointer_grab *grab,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static void drag_handle_pointer_axis(struct wlr_seat_pointer_grab *grab,
|
||||
static void drag_handle_pointer_axis(void *data,
|
||||
uint32_t time, enum wlr_axis_orientation orientation, double value,
|
||||
int32_t value_discrete, enum wlr_axis_source source) {
|
||||
// This space is intentionally left blank
|
||||
}
|
||||
|
||||
static void drag_handle_pointer_cancel(struct wlr_seat_pointer_grab *grab) {
|
||||
struct wlr_drag *drag = grab->data;
|
||||
static void drag_handle_pointer_cancel(void *data) {
|
||||
struct wlr_drag *drag = data;
|
||||
drag_destroy(drag);
|
||||
}
|
||||
|
||||
static const struct wlr_pointer_grab_interface
|
||||
data_device_pointer_drag_interface = {
|
||||
static const struct wlr_pointer_grab drag_pointer_grab = {
|
||||
.enter = drag_handle_pointer_enter,
|
||||
.clear_focus = drag_handle_pointer_clear_focus,
|
||||
.motion = drag_handle_pointer_motion,
|
||||
|
|
@ -257,15 +256,15 @@ static const struct wlr_pointer_grab_interface
|
|||
.cancel = drag_handle_pointer_cancel,
|
||||
};
|
||||
|
||||
static uint32_t drag_handle_touch_down(struct wlr_seat_touch_grab *grab,
|
||||
static uint32_t drag_handle_touch_down(void *data,
|
||||
uint32_t time, struct wlr_touch_point *point) {
|
||||
// eat the event
|
||||
return 0;
|
||||
}
|
||||
|
||||
static void drag_handle_touch_up(struct wlr_seat_touch_grab *grab,
|
||||
static void drag_handle_touch_up(void *data,
|
||||
uint32_t time, struct wlr_touch_point *point) {
|
||||
struct wlr_drag *drag = grab->data;
|
||||
struct wlr_drag *drag = data;
|
||||
if (drag->grab_touch_id != point->touch_id) {
|
||||
return;
|
||||
}
|
||||
|
|
@ -277,9 +276,9 @@ static void drag_handle_touch_up(struct wlr_seat_touch_grab *grab,
|
|||
drag_destroy(drag);
|
||||
}
|
||||
|
||||
static void drag_handle_touch_motion(struct wlr_seat_touch_grab *grab,
|
||||
static void drag_handle_touch_motion(void *data,
|
||||
uint32_t time, struct wlr_touch_point *point) {
|
||||
struct wlr_drag *drag = grab->data;
|
||||
struct wlr_drag *drag = data;
|
||||
if (drag->focus && drag->focus_client) {
|
||||
struct wl_resource *resource;
|
||||
wl_resource_for_each(resource, &drag->focus_client->data_devices) {
|
||||
|
|
@ -290,19 +289,18 @@ static void drag_handle_touch_motion(struct wlr_seat_touch_grab *grab,
|
|||
}
|
||||
}
|
||||
|
||||
static void drag_handle_touch_enter(struct wlr_seat_touch_grab *grab,
|
||||
static void drag_handle_touch_enter(void *data,
|
||||
uint32_t time, struct wlr_touch_point *point) {
|
||||
struct wlr_drag *drag = grab->data;
|
||||
struct wlr_drag *drag = data;
|
||||
drag_set_focus(drag, point->focus_surface, point->sx, point->sy);
|
||||
}
|
||||
|
||||
static void drag_handle_touch_cancel(struct wlr_seat_touch_grab *grab) {
|
||||
struct wlr_drag *drag = grab->data;
|
||||
static void drag_handle_touch_cancel(void *data) {
|
||||
struct wlr_drag *drag = data;
|
||||
drag_destroy(drag);
|
||||
}
|
||||
|
||||
static const struct wlr_touch_grab_interface
|
||||
data_device_touch_drag_interface = {
|
||||
static const struct wlr_touch_grab drag_touch_grab = {
|
||||
.down = drag_handle_touch_down,
|
||||
.up = drag_handle_touch_up,
|
||||
.motion = drag_handle_touch_motion,
|
||||
|
|
@ -310,35 +308,34 @@ static const struct wlr_touch_grab_interface
|
|||
.cancel = drag_handle_touch_cancel,
|
||||
};
|
||||
|
||||
static void drag_handle_keyboard_enter(struct wlr_seat_keyboard_grab *grab,
|
||||
static void drag_handle_keyboard_enter(void *data,
|
||||
struct wlr_surface *surface, uint32_t keycodes[], size_t num_keycodes,
|
||||
struct wlr_keyboard_modifiers *modifiers) {
|
||||
// nothing has keyboard focus during drags
|
||||
}
|
||||
|
||||
static void drag_handle_keyboard_clear_focus(struct wlr_seat_keyboard_grab *grab) {
|
||||
static void drag_handle_keyboard_clear_focus(void *data) {
|
||||
// nothing has keyboard focus during drags
|
||||
}
|
||||
|
||||
static void drag_handle_keyboard_key(struct wlr_seat_keyboard_grab *grab,
|
||||
static void drag_handle_keyboard_key(void *data,
|
||||
uint32_t time, uint32_t key, uint32_t state) {
|
||||
// no keyboard input during drags
|
||||
}
|
||||
|
||||
static void drag_handle_keyboard_modifiers(struct wlr_seat_keyboard_grab *grab,
|
||||
static void drag_handle_keyboard_modifiers(void *data,
|
||||
struct wlr_keyboard_modifiers *modifiers) {
|
||||
//struct wlr_keyboard *keyboard = grab->seat->keyboard_state.keyboard;
|
||||
// TODO change the dnd action based on what modifier is pressed on the
|
||||
// keyboard
|
||||
}
|
||||
|
||||
static void drag_handle_keyboard_cancel(struct wlr_seat_keyboard_grab *grab) {
|
||||
struct wlr_drag *drag = grab->data;
|
||||
static void drag_handle_keyboard_cancel(void *data) {
|
||||
struct wlr_drag *drag = data;
|
||||
drag_destroy(drag);
|
||||
}
|
||||
|
||||
static const struct wlr_keyboard_grab_interface
|
||||
data_device_keyboard_drag_interface = {
|
||||
static const struct wlr_keyboard_grab drag_keyboard_grab = {
|
||||
.enter = drag_handle_keyboard_enter,
|
||||
.clear_focus = drag_handle_keyboard_clear_focus,
|
||||
.key = drag_handle_keyboard_key,
|
||||
|
|
@ -436,15 +433,6 @@ struct wlr_drag *wlr_drag_create(struct wlr_seat_client *seat_client,
|
|||
wl_signal_add(&source->events.destroy, &drag->source_destroy);
|
||||
}
|
||||
|
||||
drag->pointer_grab.data = drag;
|
||||
drag->pointer_grab.interface = &data_device_pointer_drag_interface;
|
||||
|
||||
drag->touch_grab.data = drag;
|
||||
drag->touch_grab.interface = &data_device_touch_drag_interface;
|
||||
|
||||
drag->keyboard_grab.data = drag;
|
||||
drag->keyboard_grab.interface = &data_device_keyboard_drag_interface;
|
||||
|
||||
return drag;
|
||||
}
|
||||
|
||||
|
|
@ -480,7 +468,7 @@ void wlr_seat_start_drag(struct wlr_seat *seat, struct wlr_drag *drag,
|
|||
assert(!drag->started);
|
||||
drag->started = true;
|
||||
|
||||
wlr_seat_keyboard_start_grab(seat, &drag->keyboard_grab);
|
||||
wlr_seat_keyboard_start_grab(seat, &drag_keyboard_grab, drag);
|
||||
|
||||
seat->drag = drag;
|
||||
seat->drag_serial = serial;
|
||||
|
|
@ -502,7 +490,7 @@ void wlr_seat_start_pointer_drag(struct wlr_seat *seat, struct wlr_drag *drag,
|
|||
drag->grab_type = WLR_DRAG_GRAB_KEYBOARD_POINTER;
|
||||
|
||||
wlr_seat_pointer_clear_focus(seat);
|
||||
wlr_seat_pointer_start_grab(seat, &drag->pointer_grab);
|
||||
wlr_seat_pointer_start_grab(seat, &drag_pointer_grab, drag);
|
||||
|
||||
wlr_seat_start_drag(seat, drag, serial);
|
||||
}
|
||||
|
|
@ -513,7 +501,7 @@ void wlr_seat_start_touch_drag(struct wlr_seat *seat, struct wlr_drag *drag,
|
|||
drag->grab_touch_id = seat->touch_state.grab_id;
|
||||
drag->touch_id = point->touch_id;
|
||||
|
||||
wlr_seat_touch_start_grab(seat, &drag->touch_grab);
|
||||
wlr_seat_touch_start_grab(seat, &drag_touch_grab, drag);
|
||||
drag_set_focus(drag, point->surface, point->sx, point->sy);
|
||||
|
||||
wlr_seat_start_drag(seat, drag, serial);
|
||||
|
|
|
|||
|
|
@ -211,9 +211,6 @@ void wlr_seat_destroy(struct wlr_seat *seat) {
|
|||
}
|
||||
|
||||
wlr_global_destroy_safe(seat->global);
|
||||
free(seat->pointer_state.default_grab);
|
||||
free(seat->keyboard_state.default_grab);
|
||||
free(seat->touch_state.default_grab);
|
||||
free(seat->name);
|
||||
free(seat);
|
||||
}
|
||||
|
|
@ -234,60 +231,30 @@ struct wlr_seat *wlr_seat_create(struct wl_display *display, const char *name) {
|
|||
seat->pointer_state.seat = seat;
|
||||
wl_list_init(&seat->pointer_state.surface_destroy.link);
|
||||
|
||||
struct wlr_seat_pointer_grab *pointer_grab =
|
||||
calloc(1, sizeof(struct wlr_seat_pointer_grab));
|
||||
if (!pointer_grab) {
|
||||
free(seat);
|
||||
return NULL;
|
||||
}
|
||||
pointer_grab->interface = &default_pointer_grab_impl;
|
||||
pointer_grab->seat = seat;
|
||||
seat->pointer_state.default_grab = pointer_grab;
|
||||
seat->pointer_state.grab = pointer_grab;
|
||||
seat->pointer_state.grab = &default_pointer_grab;
|
||||
seat->pointer_state.grab_data = seat;
|
||||
|
||||
wl_signal_init(&seat->pointer_state.events.focus_change);
|
||||
|
||||
// keyboard state
|
||||
struct wlr_seat_keyboard_grab *keyboard_grab =
|
||||
calloc(1, sizeof(struct wlr_seat_keyboard_grab));
|
||||
if (!keyboard_grab) {
|
||||
free(pointer_grab);
|
||||
free(seat);
|
||||
return NULL;
|
||||
}
|
||||
keyboard_grab->interface = &default_keyboard_grab_impl;
|
||||
keyboard_grab->seat = seat;
|
||||
seat->keyboard_state.default_grab = keyboard_grab;
|
||||
seat->keyboard_state.grab = keyboard_grab;
|
||||
|
||||
seat->keyboard_state.seat = seat;
|
||||
wl_list_init(&seat->keyboard_state.surface_destroy.link);
|
||||
|
||||
seat->keyboard_state.grab = &default_keyboard_grab;
|
||||
seat->keyboard_state.grab_data = seat;
|
||||
|
||||
wl_signal_init(&seat->keyboard_state.events.focus_change);
|
||||
|
||||
// touch state
|
||||
struct wlr_seat_touch_grab *touch_grab =
|
||||
calloc(1, sizeof(struct wlr_seat_touch_grab));
|
||||
if (!touch_grab) {
|
||||
free(pointer_grab);
|
||||
free(keyboard_grab);
|
||||
free(seat);
|
||||
return NULL;
|
||||
}
|
||||
touch_grab->interface = &default_touch_grab_impl;
|
||||
touch_grab->seat = seat;
|
||||
seat->touch_state.default_grab = touch_grab;
|
||||
seat->touch_state.grab = touch_grab;
|
||||
|
||||
seat->touch_state.seat = seat;
|
||||
wl_list_init(&seat->touch_state.touch_points);
|
||||
|
||||
seat->touch_state.grab = &default_touch_grab;
|
||||
seat->touch_state.grab_data = seat;
|
||||
|
||||
seat->global = wl_global_create(display, &wl_seat_interface,
|
||||
SEAT_VERSION, seat, seat_handle_bind);
|
||||
if (seat->global == NULL) {
|
||||
free(touch_grab);
|
||||
free(pointer_grab);
|
||||
free(keyboard_grab);
|
||||
free(seat);
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,31 +9,31 @@
|
|||
#include "types/wlr_data_device.h"
|
||||
#include "types/wlr_seat.h"
|
||||
|
||||
static void default_keyboard_enter(struct wlr_seat_keyboard_grab *grab,
|
||||
static void default_keyboard_enter(void *data,
|
||||
struct wlr_surface *surface, uint32_t keycodes[], size_t num_keycodes,
|
||||
struct wlr_keyboard_modifiers *modifiers) {
|
||||
wlr_seat_keyboard_enter(grab->seat, surface, keycodes, num_keycodes, modifiers);
|
||||
wlr_seat_keyboard_enter(data, surface, keycodes, num_keycodes, modifiers);
|
||||
}
|
||||
|
||||
static void default_keyboard_clear_focus(struct wlr_seat_keyboard_grab *grab) {
|
||||
wlr_seat_keyboard_clear_focus(grab->seat);
|
||||
static void default_keyboard_clear_focus(void *data) {
|
||||
wlr_seat_keyboard_clear_focus(data);
|
||||
}
|
||||
|
||||
static void default_keyboard_key(struct wlr_seat_keyboard_grab *grab,
|
||||
static void default_keyboard_key(void *data,
|
||||
uint32_t time, uint32_t key, uint32_t state) {
|
||||
wlr_seat_keyboard_send_key(grab->seat, time, key, state);
|
||||
wlr_seat_keyboard_send_key(data, time, key, state);
|
||||
}
|
||||
|
||||
static void default_keyboard_modifiers(struct wlr_seat_keyboard_grab *grab,
|
||||
static void default_keyboard_modifiers(void *data,
|
||||
struct wlr_keyboard_modifiers *modifiers) {
|
||||
wlr_seat_keyboard_send_modifiers(grab->seat, modifiers);
|
||||
wlr_seat_keyboard_send_modifiers(data, modifiers);
|
||||
}
|
||||
|
||||
static void default_keyboard_cancel(struct wlr_seat_keyboard_grab *grab) {
|
||||
static void default_keyboard_cancel(void *data) {
|
||||
// cannot be cancelled
|
||||
}
|
||||
|
||||
const struct wlr_keyboard_grab_interface default_keyboard_grab_impl = {
|
||||
const struct wlr_keyboard_grab default_keyboard_grab = {
|
||||
.enter = default_keyboard_enter,
|
||||
.clear_focus = default_keyboard_clear_focus,
|
||||
.key = default_keyboard_key,
|
||||
|
|
@ -41,7 +41,6 @@ const struct wlr_keyboard_grab_interface default_keyboard_grab_impl = {
|
|||
.cancel = default_keyboard_cancel,
|
||||
};
|
||||
|
||||
|
||||
static void keyboard_release(struct wl_client *client,
|
||||
struct wl_resource *resource) {
|
||||
wl_resource_destroy(resource);
|
||||
|
|
@ -63,7 +62,6 @@ static void keyboard_handle_resource_destroy(struct wl_resource *resource) {
|
|||
seat_client_destroy_keyboard(resource);
|
||||
}
|
||||
|
||||
|
||||
void wlr_seat_keyboard_send_key(struct wlr_seat *wlr_seat, uint32_t time,
|
||||
uint32_t key, uint32_t state) {
|
||||
struct wlr_seat_client *client = wlr_seat->keyboard_state.focused_client;
|
||||
|
|
@ -163,21 +161,24 @@ struct wlr_keyboard *wlr_seat_get_keyboard(struct wlr_seat *seat) {
|
|||
}
|
||||
|
||||
void wlr_seat_keyboard_start_grab(struct wlr_seat *wlr_seat,
|
||||
struct wlr_seat_keyboard_grab *grab) {
|
||||
grab->seat = wlr_seat;
|
||||
const struct wlr_keyboard_grab *grab, void *data) {
|
||||
wlr_seat->keyboard_state.grab = grab;
|
||||
wlr_seat->keyboard_state.grab_data = data;
|
||||
|
||||
wl_signal_emit_mutable(&wlr_seat->events.keyboard_grab_begin, grab);
|
||||
wl_signal_emit_mutable(&wlr_seat->events.keyboard_grab_begin, NULL);
|
||||
}
|
||||
|
||||
void wlr_seat_keyboard_end_grab(struct wlr_seat *wlr_seat) {
|
||||
struct wlr_seat_keyboard_grab *grab = wlr_seat->keyboard_state.grab;
|
||||
const struct wlr_keyboard_grab *grab = wlr_seat->keyboard_state.grab;
|
||||
void *grab_data = wlr_seat->keyboard_state.grab_data;
|
||||
|
||||
if (grab != wlr_seat->keyboard_state.default_grab) {
|
||||
wlr_seat->keyboard_state.grab = wlr_seat->keyboard_state.default_grab;
|
||||
wl_signal_emit_mutable(&wlr_seat->events.keyboard_grab_end, grab);
|
||||
if (grab->interface->cancel) {
|
||||
grab->interface->cancel(grab);
|
||||
if (grab != &default_keyboard_grab) {
|
||||
wlr_seat->keyboard_state.grab = &default_keyboard_grab;
|
||||
wlr_seat->keyboard_state.grab_data = wlr_seat;
|
||||
|
||||
wl_signal_emit_mutable(&wlr_seat->events.keyboard_grab_end, NULL);
|
||||
if (grab->cancel) {
|
||||
grab->cancel(grab_data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -311,8 +312,9 @@ void wlr_seat_keyboard_notify_enter(struct wlr_seat *seat,
|
|||
// NULL surfaces are prohibited in the grab-compatible API. Use
|
||||
// wlr_seat_keyboard_notify_clear_focus() instead.
|
||||
assert(surface);
|
||||
struct wlr_seat_keyboard_grab *grab = seat->keyboard_state.grab;
|
||||
grab->interface->enter(grab, surface, keycodes, num_keycodes, modifiers);
|
||||
struct wlr_seat_keyboard_state *keyboard_state = &seat->keyboard_state;
|
||||
keyboard_state->grab->enter(keyboard_state->grab_data,
|
||||
surface, keycodes, num_keycodes, modifiers);
|
||||
}
|
||||
|
||||
void wlr_seat_keyboard_clear_focus(struct wlr_seat *seat) {
|
||||
|
|
@ -320,29 +322,28 @@ void wlr_seat_keyboard_clear_focus(struct wlr_seat *seat) {
|
|||
}
|
||||
|
||||
void wlr_seat_keyboard_notify_clear_focus(struct wlr_seat *seat) {
|
||||
struct wlr_seat_keyboard_grab *grab = seat->keyboard_state.grab;
|
||||
grab->interface->clear_focus(grab);
|
||||
struct wlr_seat_keyboard_state *keyboard_state = &seat->keyboard_state;
|
||||
keyboard_state->grab->clear_focus(keyboard_state->grab_data);
|
||||
}
|
||||
|
||||
bool wlr_seat_keyboard_has_grab(struct wlr_seat *seat) {
|
||||
return seat->keyboard_state.grab->interface != &default_keyboard_grab_impl;
|
||||
return seat->keyboard_state.grab != &default_keyboard_grab;
|
||||
}
|
||||
|
||||
void wlr_seat_keyboard_notify_modifiers(struct wlr_seat *seat,
|
||||
struct wlr_keyboard_modifiers *modifiers) {
|
||||
clock_gettime(CLOCK_MONOTONIC, &seat->last_event);
|
||||
struct wlr_seat_keyboard_grab *grab = seat->keyboard_state.grab;
|
||||
grab->interface->modifiers(grab, modifiers);
|
||||
struct wlr_seat_keyboard_state *keyboard_state = &seat->keyboard_state;
|
||||
keyboard_state->grab->modifiers(keyboard_state->grab_data, modifiers);
|
||||
}
|
||||
|
||||
void wlr_seat_keyboard_notify_key(struct wlr_seat *seat, uint32_t time,
|
||||
uint32_t key, uint32_t state) {
|
||||
clock_gettime(CLOCK_MONOTONIC, &seat->last_event);
|
||||
struct wlr_seat_keyboard_grab *grab = seat->keyboard_state.grab;
|
||||
grab->interface->key(grab, time, key, state);
|
||||
struct wlr_seat_keyboard_state *keyboard_state = &seat->keyboard_state;
|
||||
keyboard_state->grab->key(keyboard_state->grab_data, time, key, state);
|
||||
}
|
||||
|
||||
|
||||
static void seat_client_send_keymap(struct wlr_seat_client *client,
|
||||
struct wlr_keyboard *keyboard) {
|
||||
if (!keyboard) {
|
||||
|
|
|
|||
|
|
@ -9,41 +9,41 @@
|
|||
#include "types/wlr_seat.h"
|
||||
#include "util/set.h"
|
||||
|
||||
static void default_pointer_enter(struct wlr_seat_pointer_grab *grab,
|
||||
static void default_pointer_enter(void *data,
|
||||
struct wlr_surface *surface, double sx, double sy) {
|
||||
wlr_seat_pointer_enter(grab->seat, surface, sx, sy);
|
||||
wlr_seat_pointer_enter(data, surface, sx, sy);
|
||||
}
|
||||
|
||||
static void default_pointer_clear_focus(struct wlr_seat_pointer_grab *grab) {
|
||||
wlr_seat_pointer_clear_focus(grab->seat);
|
||||
static void default_pointer_clear_focus(void *data) {
|
||||
wlr_seat_pointer_clear_focus(data);
|
||||
}
|
||||
|
||||
static void default_pointer_motion(struct wlr_seat_pointer_grab *grab,
|
||||
static void default_pointer_motion(void *data,
|
||||
uint32_t time, double sx, double sy) {
|
||||
wlr_seat_pointer_send_motion(grab->seat, time, sx, sy);
|
||||
wlr_seat_pointer_send_motion(data, time, sx, sy);
|
||||
}
|
||||
|
||||
static uint32_t default_pointer_button(struct wlr_seat_pointer_grab *grab,
|
||||
static uint32_t default_pointer_button(void *data,
|
||||
uint32_t time, uint32_t button, enum wlr_button_state state) {
|
||||
return wlr_seat_pointer_send_button(grab->seat, time, button, state);
|
||||
return wlr_seat_pointer_send_button(data, time, button, state);
|
||||
}
|
||||
|
||||
static void default_pointer_axis(struct wlr_seat_pointer_grab *grab,
|
||||
static void default_pointer_axis(void *data,
|
||||
uint32_t time, enum wlr_axis_orientation orientation, double value,
|
||||
int32_t value_discrete, enum wlr_axis_source source) {
|
||||
wlr_seat_pointer_send_axis(grab->seat, time, orientation, value,
|
||||
wlr_seat_pointer_send_axis(data, time, orientation, value,
|
||||
value_discrete, source);
|
||||
}
|
||||
|
||||
static void default_pointer_frame(struct wlr_seat_pointer_grab *grab) {
|
||||
wlr_seat_pointer_send_frame(grab->seat);
|
||||
static void default_pointer_frame(void *data) {
|
||||
wlr_seat_pointer_send_frame(data);
|
||||
}
|
||||
|
||||
static void default_pointer_cancel(struct wlr_seat_pointer_grab *grab) {
|
||||
static void default_pointer_cancel(void *data) {
|
||||
// cannot be cancelled
|
||||
}
|
||||
|
||||
const struct wlr_pointer_grab_interface default_pointer_grab_impl = {
|
||||
const struct wlr_pointer_grab default_pointer_grab = {
|
||||
.enter = default_pointer_enter,
|
||||
.clear_focus = default_pointer_clear_focus,
|
||||
.motion = default_pointer_motion,
|
||||
|
|
@ -53,7 +53,6 @@ const struct wlr_pointer_grab_interface default_pointer_grab_impl = {
|
|||
.cancel = default_pointer_cancel,
|
||||
};
|
||||
|
||||
|
||||
static void pointer_send_frame(struct wl_resource *resource) {
|
||||
if (wl_resource_get_version(resource) >=
|
||||
WL_POINTER_FRAME_SINCE_VERSION) {
|
||||
|
|
@ -397,21 +396,23 @@ void wlr_seat_pointer_send_frame(struct wlr_seat *wlr_seat) {
|
|||
}
|
||||
|
||||
void wlr_seat_pointer_start_grab(struct wlr_seat *wlr_seat,
|
||||
struct wlr_seat_pointer_grab *grab) {
|
||||
assert(wlr_seat);
|
||||
grab->seat = wlr_seat;
|
||||
const struct wlr_pointer_grab *grab, void *data) {
|
||||
wlr_seat->pointer_state.grab = grab;
|
||||
wlr_seat->pointer_state.grab_data = data;
|
||||
|
||||
wl_signal_emit_mutable(&wlr_seat->events.pointer_grab_begin, grab);
|
||||
wl_signal_emit_mutable(&wlr_seat->events.pointer_grab_begin, NULL);
|
||||
}
|
||||
|
||||
void wlr_seat_pointer_end_grab(struct wlr_seat *wlr_seat) {
|
||||
struct wlr_seat_pointer_grab *grab = wlr_seat->pointer_state.grab;
|
||||
if (grab != wlr_seat->pointer_state.default_grab) {
|
||||
wlr_seat->pointer_state.grab = wlr_seat->pointer_state.default_grab;
|
||||
wl_signal_emit_mutable(&wlr_seat->events.pointer_grab_end, grab);
|
||||
if (grab->interface->cancel) {
|
||||
grab->interface->cancel(grab);
|
||||
const struct wlr_pointer_grab *grab = wlr_seat->pointer_state.grab;
|
||||
void *grab_data = wlr_seat->pointer_state.grab_data;
|
||||
|
||||
if (grab != &default_pointer_grab) {
|
||||
wlr_seat->pointer_state.grab = &default_pointer_grab;
|
||||
wlr_seat->pointer_state.grab_data = wlr_seat;
|
||||
wl_signal_emit_mutable(&wlr_seat->events.pointer_grab_end, NULL);
|
||||
if (grab->cancel != NULL) {
|
||||
grab->cancel(grab_data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -421,27 +422,27 @@ void wlr_seat_pointer_notify_enter(struct wlr_seat *wlr_seat,
|
|||
// NULL surfaces are prohibited in the grab-compatible API. Use
|
||||
// wlr_seat_pointer_notify_clear_focus() instead.
|
||||
assert(surface);
|
||||
struct wlr_seat_pointer_grab *grab = wlr_seat->pointer_state.grab;
|
||||
grab->interface->enter(grab, surface, sx, sy);
|
||||
struct wlr_seat_pointer_state *pointer_state = &wlr_seat->pointer_state;
|
||||
pointer_state->grab->enter(pointer_state->grab_data, surface, sx, sy);
|
||||
}
|
||||
|
||||
void wlr_seat_pointer_notify_clear_focus(struct wlr_seat *wlr_seat) {
|
||||
struct wlr_seat_pointer_grab *grab = wlr_seat->pointer_state.grab;
|
||||
grab->interface->clear_focus(grab);
|
||||
struct wlr_seat_pointer_state *pointer_state = &wlr_seat->pointer_state;
|
||||
pointer_state->grab->clear_focus(pointer_state->grab_data);
|
||||
}
|
||||
|
||||
void wlr_seat_pointer_notify_motion(struct wlr_seat *wlr_seat, uint32_t time,
|
||||
double sx, double sy) {
|
||||
clock_gettime(CLOCK_MONOTONIC, &wlr_seat->last_event);
|
||||
struct wlr_seat_pointer_grab *grab = wlr_seat->pointer_state.grab;
|
||||
grab->interface->motion(grab, time, sx, sy);
|
||||
struct wlr_seat_pointer_state *pointer_state = &wlr_seat->pointer_state;
|
||||
pointer_state->grab->motion(pointer_state->grab_data, time, sx, sy);
|
||||
}
|
||||
|
||||
uint32_t wlr_seat_pointer_notify_button(struct wlr_seat *wlr_seat,
|
||||
uint32_t time, uint32_t button, enum wlr_button_state state) {
|
||||
clock_gettime(CLOCK_MONOTONIC, &wlr_seat->last_event);
|
||||
|
||||
struct wlr_seat_pointer_state* pointer_state = &wlr_seat->pointer_state;
|
||||
struct wlr_seat_pointer_state *pointer_state = &wlr_seat->pointer_state;
|
||||
|
||||
if (state == WLR_BUTTON_PRESSED) {
|
||||
if (pointer_state->button_count == 0) {
|
||||
|
|
@ -455,9 +456,8 @@ uint32_t wlr_seat_pointer_notify_button(struct wlr_seat *wlr_seat,
|
|||
WLR_POINTER_BUTTONS_CAP, button);
|
||||
}
|
||||
|
||||
|
||||
struct wlr_seat_pointer_grab *grab = pointer_state->grab;
|
||||
uint32_t serial = grab->interface->button(grab, time, button, state);
|
||||
uint32_t serial =
|
||||
pointer_state->grab->button(pointer_state->grab_data, time, button, state);
|
||||
|
||||
if (serial && pointer_state->button_count == 1 &&
|
||||
state == WLR_BUTTON_PRESSED) {
|
||||
|
|
@ -471,24 +471,23 @@ void wlr_seat_pointer_notify_axis(struct wlr_seat *wlr_seat, uint32_t time,
|
|||
enum wlr_axis_orientation orientation, double value,
|
||||
int32_t value_discrete, enum wlr_axis_source source) {
|
||||
clock_gettime(CLOCK_MONOTONIC, &wlr_seat->last_event);
|
||||
struct wlr_seat_pointer_grab *grab = wlr_seat->pointer_state.grab;
|
||||
grab->interface->axis(grab, time, orientation, value, value_discrete,
|
||||
source);
|
||||
struct wlr_seat_pointer_state *pointer_state = &wlr_seat->pointer_state;
|
||||
pointer_state->grab->axis(pointer_state->grab_data, time, orientation,
|
||||
value, value_discrete, source);
|
||||
}
|
||||
|
||||
void wlr_seat_pointer_notify_frame(struct wlr_seat *wlr_seat) {
|
||||
clock_gettime(CLOCK_MONOTONIC, &wlr_seat->last_event);
|
||||
struct wlr_seat_pointer_grab *grab = wlr_seat->pointer_state.grab;
|
||||
if (grab->interface->frame) {
|
||||
grab->interface->frame(grab);
|
||||
struct wlr_seat_pointer_state *pointer_state = &wlr_seat->pointer_state;
|
||||
if (pointer_state->grab->frame != NULL) {
|
||||
pointer_state->grab->frame(pointer_state->grab_data);
|
||||
}
|
||||
}
|
||||
|
||||
bool wlr_seat_pointer_has_grab(struct wlr_seat *seat) {
|
||||
return seat->pointer_state.grab->interface != &default_pointer_grab_impl;
|
||||
return seat->pointer_state.grab != &default_pointer_grab;
|
||||
}
|
||||
|
||||
|
||||
void seat_client_create_pointer(struct wlr_seat_client *seat_client,
|
||||
uint32_t version, uint32_t id) {
|
||||
struct wl_resource *resource = wl_resource_create(seat_client->client,
|
||||
|
|
|
|||
|
|
@ -8,44 +8,44 @@
|
|||
#include <wlr/util/log.h>
|
||||
#include "types/wlr_seat.h"
|
||||
|
||||
static uint32_t default_touch_down(struct wlr_seat_touch_grab *grab,
|
||||
static uint32_t default_touch_down(void *data,
|
||||
uint32_t time, struct wlr_touch_point *point) {
|
||||
return wlr_seat_touch_send_down(grab->seat, point->surface, time,
|
||||
return wlr_seat_touch_send_down(data, point->surface, time,
|
||||
point->touch_id, point->sx, point->sy);
|
||||
}
|
||||
|
||||
static void default_touch_up(struct wlr_seat_touch_grab *grab, uint32_t time,
|
||||
static void default_touch_up(void *data, uint32_t time,
|
||||
struct wlr_touch_point *point) {
|
||||
wlr_seat_touch_send_up(grab->seat, time, point->touch_id);
|
||||
wlr_seat_touch_send_up(data, time, point->touch_id);
|
||||
}
|
||||
|
||||
static void default_touch_motion(struct wlr_seat_touch_grab *grab,
|
||||
static void default_touch_motion(void *data,
|
||||
uint32_t time, struct wlr_touch_point *point) {
|
||||
if (!point->focus_surface || point->focus_surface == point->surface) {
|
||||
wlr_seat_touch_send_motion(grab->seat, time, point->touch_id, point->sx,
|
||||
wlr_seat_touch_send_motion(data, time, point->touch_id, point->sx,
|
||||
point->sy);
|
||||
}
|
||||
}
|
||||
|
||||
static void default_touch_enter(struct wlr_seat_touch_grab *grab,
|
||||
static void default_touch_enter(void *data,
|
||||
uint32_t time, struct wlr_touch_point *point) {
|
||||
// not handled by default
|
||||
}
|
||||
|
||||
static void default_touch_frame(struct wlr_seat_touch_grab *grab) {
|
||||
wlr_seat_touch_send_frame(grab->seat);
|
||||
static void default_touch_frame(void *data) {
|
||||
wlr_seat_touch_send_frame(data);
|
||||
}
|
||||
|
||||
static void default_touch_cancel(struct wlr_seat_touch_grab *grab) {
|
||||
static void default_touch_cancel(void *data) {
|
||||
// cannot be cancelled
|
||||
}
|
||||
|
||||
static void default_touch_wl_cancel(struct wlr_seat_touch_grab *grab,
|
||||
static void default_touch_wl_cancel(void *data,
|
||||
struct wlr_surface *surface) {
|
||||
wlr_seat_touch_send_cancel(grab->seat, surface);
|
||||
wlr_seat_touch_send_cancel(data, surface);
|
||||
}
|
||||
|
||||
const struct wlr_touch_grab_interface default_touch_grab_impl = {
|
||||
const struct wlr_touch_grab default_touch_grab = {
|
||||
.down = default_touch_down,
|
||||
.up = default_touch_up,
|
||||
.motion = default_touch_motion,
|
||||
|
|
@ -55,7 +55,6 @@ const struct wlr_touch_grab_interface default_touch_grab_impl = {
|
|||
.wl_cancel = default_touch_wl_cancel,
|
||||
};
|
||||
|
||||
|
||||
static void touch_release(struct wl_client *client,
|
||||
struct wl_resource *resource) {
|
||||
wl_resource_destroy(resource);
|
||||
|
|
@ -79,21 +78,24 @@ static struct wlr_seat_client *seat_client_from_touch_resource(
|
|||
|
||||
|
||||
void wlr_seat_touch_start_grab(struct wlr_seat *wlr_seat,
|
||||
struct wlr_seat_touch_grab *grab) {
|
||||
grab->seat = wlr_seat;
|
||||
const struct wlr_touch_grab *grab, void *data) {
|
||||
wlr_seat->touch_state.grab = grab;
|
||||
wlr_seat->touch_state.grab_data = data;
|
||||
|
||||
wl_signal_emit_mutable(&wlr_seat->events.touch_grab_begin, grab);
|
||||
wl_signal_emit_mutable(&wlr_seat->events.touch_grab_begin, NULL);
|
||||
}
|
||||
|
||||
void wlr_seat_touch_end_grab(struct wlr_seat *wlr_seat) {
|
||||
struct wlr_seat_touch_grab *grab = wlr_seat->touch_state.grab;
|
||||
const struct wlr_touch_grab *grab = wlr_seat->touch_state.grab;
|
||||
void *grab_data = wlr_seat->touch_state.grab_data;
|
||||
|
||||
if (grab != wlr_seat->touch_state.default_grab) {
|
||||
wlr_seat->touch_state.grab = wlr_seat->touch_state.default_grab;
|
||||
wl_signal_emit_mutable(&wlr_seat->events.touch_grab_end, grab);
|
||||
if (grab->interface->cancel) {
|
||||
grab->interface->cancel(grab);
|
||||
if (grab != &default_touch_grab) {
|
||||
wlr_seat->touch_state.grab = &default_touch_grab;
|
||||
wlr_seat->touch_state.grab_data = wlr_seat;
|
||||
|
||||
wl_signal_emit_mutable(&wlr_seat->events.touch_grab_end, NULL);
|
||||
if (grab->cancel) {
|
||||
grab->cancel(grab_data);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -184,7 +186,7 @@ uint32_t wlr_seat_touch_notify_down(struct wlr_seat *seat,
|
|||
struct wlr_surface *surface, uint32_t time, int32_t touch_id, double sx,
|
||||
double sy) {
|
||||
clock_gettime(CLOCK_MONOTONIC, &seat->last_event);
|
||||
struct wlr_seat_touch_grab *grab = seat->touch_state.grab;
|
||||
struct wlr_seat_touch_state *touch_state = &seat->touch_state;
|
||||
struct wlr_touch_point *point =
|
||||
touch_point_create(seat, touch_id, surface, sx, sy);
|
||||
if (!point) {
|
||||
|
|
@ -192,7 +194,7 @@ uint32_t wlr_seat_touch_notify_down(struct wlr_seat *seat,
|
|||
return 0;
|
||||
}
|
||||
|
||||
uint32_t serial = grab->interface->down(grab, time, point);
|
||||
uint32_t serial = touch_state->grab->down(touch_state->grab_data, time, point);
|
||||
|
||||
if (!serial) {
|
||||
touch_point_destroy(point);
|
||||
|
|
@ -210,13 +212,13 @@ uint32_t wlr_seat_touch_notify_down(struct wlr_seat *seat,
|
|||
void wlr_seat_touch_notify_up(struct wlr_seat *seat, uint32_t time,
|
||||
int32_t touch_id) {
|
||||
clock_gettime(CLOCK_MONOTONIC, &seat->last_event);
|
||||
struct wlr_seat_touch_grab *grab = seat->touch_state.grab;
|
||||
struct wlr_seat_touch_state *touch_state = &seat->touch_state;
|
||||
struct wlr_touch_point *point = wlr_seat_touch_get_point(seat, touch_id);
|
||||
if (!point) {
|
||||
return;
|
||||
}
|
||||
|
||||
grab->interface->up(grab, time, point);
|
||||
touch_state->grab->up(touch_state->grab_data, time, point);
|
||||
|
||||
touch_point_destroy(point);
|
||||
}
|
||||
|
|
@ -224,7 +226,7 @@ void wlr_seat_touch_notify_up(struct wlr_seat *seat, uint32_t time,
|
|||
void wlr_seat_touch_notify_motion(struct wlr_seat *seat, uint32_t time,
|
||||
int32_t touch_id, double sx, double sy) {
|
||||
clock_gettime(CLOCK_MONOTONIC, &seat->last_event);
|
||||
struct wlr_seat_touch_grab *grab = seat->touch_state.grab;
|
||||
struct wlr_seat_touch_state *touch_state = &seat->touch_state;
|
||||
struct wlr_touch_point *point = wlr_seat_touch_get_point(seat, touch_id);
|
||||
if (!point) {
|
||||
return;
|
||||
|
|
@ -233,21 +235,21 @@ void wlr_seat_touch_notify_motion(struct wlr_seat *seat, uint32_t time,
|
|||
point->sx = sx;
|
||||
point->sy = sy;
|
||||
|
||||
grab->interface->motion(grab, time, point);
|
||||
touch_state->grab->motion(touch_state->grab_data, time, point);
|
||||
}
|
||||
|
||||
void wlr_seat_touch_notify_frame(struct wlr_seat *seat) {
|
||||
struct wlr_seat_touch_grab *grab = seat->touch_state.grab;
|
||||
if (grab->interface->frame) {
|
||||
grab->interface->frame(grab);
|
||||
struct wlr_seat_touch_state *touch_state = &seat->touch_state;
|
||||
if (touch_state->grab->frame) {
|
||||
touch_state->grab->frame(touch_state->grab_data);
|
||||
}
|
||||
}
|
||||
|
||||
void wlr_seat_touch_notify_cancel(struct wlr_seat *seat,
|
||||
struct wlr_surface *surface) {
|
||||
struct wlr_seat_touch_grab *grab = seat->touch_state.grab;
|
||||
if (grab->interface->wl_cancel) {
|
||||
grab->interface->wl_cancel(grab, surface);
|
||||
struct wlr_seat_touch_state *touch_state = &seat->touch_state;
|
||||
if (touch_state->grab->wl_cancel) {
|
||||
touch_state->grab->wl_cancel(touch_state->grab_data, surface);
|
||||
}
|
||||
|
||||
struct wl_client *client = wl_resource_get_client(surface->resource);
|
||||
|
|
@ -307,8 +309,8 @@ void wlr_seat_touch_point_focus(struct wlr_seat *seat,
|
|||
touch_point_set_focus(point, surface, sx, sy);
|
||||
|
||||
if (focus != point->focus_surface) {
|
||||
struct wlr_seat_touch_grab *grab = seat->touch_state.grab;
|
||||
grab->interface->enter(grab, time, point);
|
||||
struct wlr_seat_touch_state *touch_state = &seat->touch_state;
|
||||
touch_state->grab->enter(touch_state->grab_data, time, point);
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -422,7 +424,7 @@ int wlr_seat_touch_num_points(struct wlr_seat *seat) {
|
|||
}
|
||||
|
||||
bool wlr_seat_touch_has_grab(struct wlr_seat *seat) {
|
||||
return seat->touch_state.grab->interface != &default_touch_grab_impl;
|
||||
return seat->touch_state.grab != &default_touch_grab;
|
||||
}
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -49,53 +49,58 @@ static void xdg_popup_grab_end(struct wlr_xdg_popup_grab *popup_grab) {
|
|||
wlr_seat_touch_end_grab(popup_grab->seat);
|
||||
}
|
||||
|
||||
static void xdg_pointer_grab_enter(struct wlr_seat_pointer_grab *grab,
|
||||
static void xdg_pointer_grab_enter(void *data,
|
||||
struct wlr_surface *surface, double sx, double sy) {
|
||||
struct wlr_xdg_popup_grab *popup_grab = grab->data;
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
if (wl_resource_get_client(surface->resource) == popup_grab->client) {
|
||||
wlr_seat_pointer_enter(grab->seat, surface, sx, sy);
|
||||
wlr_seat_pointer_enter(popup_grab->seat, surface, sx, sy);
|
||||
} else {
|
||||
wlr_seat_pointer_clear_focus(grab->seat);
|
||||
wlr_seat_pointer_clear_focus(popup_grab->seat);
|
||||
}
|
||||
}
|
||||
|
||||
static void xdg_pointer_grab_clear_focus(struct wlr_seat_pointer_grab *grab) {
|
||||
wlr_seat_pointer_clear_focus(grab->seat);
|
||||
static void xdg_pointer_grab_clear_focus(void *data) {
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
wlr_seat_pointer_clear_focus(popup_grab->seat);
|
||||
}
|
||||
|
||||
static void xdg_pointer_grab_motion(struct wlr_seat_pointer_grab *grab,
|
||||
static void xdg_pointer_grab_motion(void *data,
|
||||
uint32_t time, double sx, double sy) {
|
||||
wlr_seat_pointer_send_motion(grab->seat, time, sx, sy);
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
wlr_seat_pointer_send_motion(popup_grab->seat, time, sx, sy);
|
||||
}
|
||||
|
||||
static uint32_t xdg_pointer_grab_button(struct wlr_seat_pointer_grab *grab,
|
||||
static uint32_t xdg_pointer_grab_button(void *data,
|
||||
uint32_t time, uint32_t button, uint32_t state) {
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
uint32_t serial =
|
||||
wlr_seat_pointer_send_button(grab->seat, time, button, state);
|
||||
wlr_seat_pointer_send_button(popup_grab->seat, time, button, state);
|
||||
if (serial) {
|
||||
return serial;
|
||||
} else {
|
||||
xdg_popup_grab_end(grab->data);
|
||||
xdg_popup_grab_end(data);
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
static void xdg_pointer_grab_axis(struct wlr_seat_pointer_grab *grab,
|
||||
static void xdg_pointer_grab_axis(void *data,
|
||||
uint32_t time, enum wlr_axis_orientation orientation, double value,
|
||||
int32_t value_discrete, enum wlr_axis_source source) {
|
||||
wlr_seat_pointer_send_axis(grab->seat, time, orientation, value,
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
wlr_seat_pointer_send_axis(popup_grab->seat, time, orientation, value,
|
||||
value_discrete, source);
|
||||
}
|
||||
|
||||
static void xdg_pointer_grab_frame(struct wlr_seat_pointer_grab *grab) {
|
||||
wlr_seat_pointer_send_frame(grab->seat);
|
||||
static void xdg_pointer_grab_frame(void *data) {
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
wlr_seat_pointer_send_frame(popup_grab->seat);
|
||||
}
|
||||
|
||||
static void xdg_pointer_grab_cancel(struct wlr_seat_pointer_grab *grab) {
|
||||
xdg_popup_grab_end(grab->data);
|
||||
static void xdg_pointer_grab_cancel(void *data) {
|
||||
xdg_popup_grab_end(data);
|
||||
}
|
||||
|
||||
static const struct wlr_pointer_grab_interface xdg_pointer_grab_impl = {
|
||||
static const struct wlr_pointer_grab xdg_pointer_grab = {
|
||||
.enter = xdg_pointer_grab_enter,
|
||||
.clear_focus = xdg_pointer_grab_clear_focus,
|
||||
.motion = xdg_pointer_grab_motion,
|
||||
|
|
@ -105,31 +110,34 @@ static const struct wlr_pointer_grab_interface xdg_pointer_grab_impl = {
|
|||
.frame = xdg_pointer_grab_frame,
|
||||
};
|
||||
|
||||
static void xdg_keyboard_grab_enter(struct wlr_seat_keyboard_grab *grab,
|
||||
static void xdg_keyboard_grab_enter(void *data,
|
||||
struct wlr_surface *surface, uint32_t keycodes[], size_t num_keycodes,
|
||||
struct wlr_keyboard_modifiers *modifiers) {
|
||||
// keyboard focus should remain on the popup
|
||||
}
|
||||
|
||||
static void xdg_keyboard_grab_clear_focus(struct wlr_seat_keyboard_grab *grab) {
|
||||
static void xdg_keyboard_grab_clear_focus(void *data) {
|
||||
// keyboard focus should remain on the popup
|
||||
}
|
||||
|
||||
static void xdg_keyboard_grab_key(struct wlr_seat_keyboard_grab *grab, uint32_t time,
|
||||
static void xdg_keyboard_grab_key(void *data, uint32_t time,
|
||||
uint32_t key, uint32_t state) {
|
||||
wlr_seat_keyboard_send_key(grab->seat, time, key, state);
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
wlr_seat_keyboard_send_key(popup_grab->seat, time, key, state);
|
||||
}
|
||||
|
||||
static void xdg_keyboard_grab_modifiers(struct wlr_seat_keyboard_grab *grab,
|
||||
static void xdg_keyboard_grab_modifiers(void *data,
|
||||
struct wlr_keyboard_modifiers *modifiers) {
|
||||
wlr_seat_keyboard_send_modifiers(grab->seat, modifiers);
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
wlr_seat_keyboard_send_modifiers(popup_grab->seat, modifiers);
|
||||
}
|
||||
|
||||
static void xdg_keyboard_grab_cancel(struct wlr_seat_keyboard_grab *grab) {
|
||||
wlr_seat_pointer_end_grab(grab->seat);
|
||||
static void xdg_keyboard_grab_cancel(void *data) {
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
wlr_seat_pointer_end_grab(popup_grab->seat);
|
||||
}
|
||||
|
||||
static const struct wlr_keyboard_grab_interface xdg_keyboard_grab_impl = {
|
||||
static const struct wlr_keyboard_grab xdg_keyboard_grab = {
|
||||
.enter = xdg_keyboard_grab_enter,
|
||||
.clear_focus = xdg_keyboard_grab_clear_focus,
|
||||
.key = xdg_keyboard_grab_key,
|
||||
|
|
@ -137,43 +145,47 @@ static const struct wlr_keyboard_grab_interface xdg_keyboard_grab_impl = {
|
|||
.cancel = xdg_keyboard_grab_cancel,
|
||||
};
|
||||
|
||||
static uint32_t xdg_touch_grab_down(struct wlr_seat_touch_grab *grab,
|
||||
static uint32_t xdg_touch_grab_down(void *data,
|
||||
uint32_t time, struct wlr_touch_point *point) {
|
||||
struct wlr_xdg_popup_grab *popup_grab = grab->data;
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
|
||||
if (wl_resource_get_client(point->surface->resource) != popup_grab->client) {
|
||||
xdg_popup_grab_end(grab->data);
|
||||
xdg_popup_grab_end(popup_grab);
|
||||
return 0;
|
||||
}
|
||||
|
||||
return wlr_seat_touch_send_down(grab->seat, point->surface, time,
|
||||
point->touch_id, point->sx, point->sy);
|
||||
return wlr_seat_touch_send_down(popup_grab->seat, point->surface, time,
|
||||
point->touch_id, point->sx, point->sy);
|
||||
}
|
||||
|
||||
static void xdg_touch_grab_up(struct wlr_seat_touch_grab *grab,
|
||||
static void xdg_touch_grab_up(void *data,
|
||||
uint32_t time, struct wlr_touch_point *point) {
|
||||
wlr_seat_touch_send_up(grab->seat, time, point->touch_id);
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
wlr_seat_touch_send_up(popup_grab->seat, time, point->touch_id);
|
||||
}
|
||||
|
||||
static void xdg_touch_grab_motion(struct wlr_seat_touch_grab *grab,
|
||||
static void xdg_touch_grab_motion(void *data,
|
||||
uint32_t time, struct wlr_touch_point *point) {
|
||||
wlr_seat_touch_send_motion(grab->seat, time, point->touch_id, point->sx,
|
||||
point->sy);
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
wlr_seat_touch_send_motion(popup_grab->seat, time, point->touch_id,
|
||||
point->sx, point->sy);
|
||||
}
|
||||
|
||||
static void xdg_touch_grab_enter(struct wlr_seat_touch_grab *grab,
|
||||
static void xdg_touch_grab_enter(void *data,
|
||||
uint32_t time, struct wlr_touch_point *point) {
|
||||
}
|
||||
|
||||
static void xdg_touch_grab_frame(struct wlr_seat_touch_grab *grab) {
|
||||
wlr_seat_touch_send_frame(grab->seat);
|
||||
static void xdg_touch_grab_frame(void *data) {
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
wlr_seat_touch_send_frame(popup_grab->seat);
|
||||
}
|
||||
|
||||
static void xdg_touch_grab_cancel(struct wlr_seat_touch_grab *grab) {
|
||||
wlr_seat_touch_end_grab(grab->seat);
|
||||
static void xdg_touch_grab_cancel(void *data) {
|
||||
struct wlr_xdg_popup_grab *popup_grab = data;
|
||||
wlr_seat_touch_end_grab(popup_grab->seat);
|
||||
}
|
||||
|
||||
static const struct wlr_touch_grab_interface xdg_touch_grab_impl = {
|
||||
static const struct wlr_touch_grab xdg_touch_grab = {
|
||||
.down = xdg_touch_grab_down,
|
||||
.up = xdg_touch_grab_up,
|
||||
.motion = xdg_touch_grab_motion,
|
||||
|
|
@ -219,13 +231,6 @@ static struct wlr_xdg_popup_grab *get_xdg_shell_popup_grab_from_seat(
|
|||
return NULL;
|
||||
}
|
||||
|
||||
xdg_grab->pointer_grab.data = xdg_grab;
|
||||
xdg_grab->pointer_grab.interface = &xdg_pointer_grab_impl;
|
||||
xdg_grab->keyboard_grab.data = xdg_grab;
|
||||
xdg_grab->keyboard_grab.interface = &xdg_keyboard_grab_impl;
|
||||
xdg_grab->touch_grab.data = xdg_grab;
|
||||
xdg_grab->touch_grab.interface = &xdg_touch_grab_impl;
|
||||
|
||||
wl_list_init(&xdg_grab->popups);
|
||||
|
||||
wl_list_insert(&shell->popup_grabs, &xdg_grab->link);
|
||||
|
|
@ -297,11 +302,11 @@ static void xdg_popup_handle_grab(struct wl_client *client,
|
|||
wl_list_insert(&popup_grab->popups, &popup->grab_link);
|
||||
|
||||
wlr_seat_pointer_start_grab(seat_client->seat,
|
||||
&popup_grab->pointer_grab);
|
||||
&xdg_pointer_grab, popup_grab);
|
||||
wlr_seat_keyboard_start_grab(seat_client->seat,
|
||||
&popup_grab->keyboard_grab);
|
||||
&xdg_keyboard_grab, popup_grab);
|
||||
wlr_seat_touch_start_grab(seat_client->seat,
|
||||
&popup_grab->touch_grab);
|
||||
&xdg_touch_grab, popup_grab);
|
||||
}
|
||||
|
||||
static void xdg_popup_handle_reposition(
|
||||
|
|
@ -434,13 +439,13 @@ void unmap_xdg_popup(struct wlr_xdg_popup *popup) {
|
|||
wl_list_remove(&popup->grab_link);
|
||||
|
||||
if (wl_list_empty(&grab->popups)) {
|
||||
if (grab->seat->pointer_state.grab == &grab->pointer_grab) {
|
||||
if (grab->seat->pointer_state.grab == &xdg_pointer_grab) {
|
||||
wlr_seat_pointer_end_grab(grab->seat);
|
||||
}
|
||||
if (grab->seat->keyboard_state.grab == &grab->keyboard_grab) {
|
||||
if (grab->seat->keyboard_state.grab == &xdg_keyboard_grab) {
|
||||
wlr_seat_keyboard_end_grab(grab->seat);
|
||||
}
|
||||
if (grab->seat->touch_state.grab == &grab->touch_grab) {
|
||||
if (grab->seat->touch_state.grab == &xdg_touch_grab) {
|
||||
wlr_seat_touch_end_grab(grab->seat);
|
||||
}
|
||||
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue