"Fossies" - the Fresh Open Source Software Archive  

Source code changes of the file "hw/xwayland/xwayland-input.c" between
xorg-server-1.20.8.tar.bz2 and xorg-server-1.20.9.tar.bz2

About: The X.Org X Server component of the X Window System architecture.

xwayland-input.c  (xorg-server-1.20.8.tar.bz2):xwayland-input.c  (xorg-server-1.20.9.tar.bz2)
skipping to change at line 51 skipping to change at line 51
struct xorg_list l; struct xorg_list l;
uint32_t axis; uint32_t axis;
int32_t discrete; int32_t discrete;
}; };
struct sync_pending { struct sync_pending {
struct xorg_list l; struct xorg_list l;
DeviceIntPtr pending_dev; DeviceIntPtr pending_dev;
}; };
static DevPrivateKeyRec xwl_tablet_private_key;
static void static void
xwl_pointer_warp_emulator_handle_motion(struct xwl_pointer_warp_emulator *warp_e mulator, xwl_pointer_warp_emulator_handle_motion(struct xwl_pointer_warp_emulator *warp_e mulator,
double dx, double dx,
double dy, double dy,
double dx_unaccel, double dx_unaccel,
double dy_unaccel); double dy_unaccel);
static void static void
xwl_pointer_warp_emulator_maybe_lock(struct xwl_pointer_warp_emulator *warp_emul ator, xwl_pointer_warp_emulator_maybe_lock(struct xwl_pointer_warp_emulator *warp_emul ator,
struct xwl_window *xwl_window, struct xwl_window *xwl_window,
SpritePtr sprite, SpritePtr sprite,
skipping to change at line 834 skipping to change at line 836
XkbSendStateNotify(dev, &sn); XkbSendStateNotify(dev, &sn);
} }
} }
static void static void
remove_sync_pending(DeviceIntPtr dev) remove_sync_pending(DeviceIntPtr dev)
{ {
struct xwl_seat *xwl_seat = dev->public.devicePrivate; struct xwl_seat *xwl_seat = dev->public.devicePrivate;
struct sync_pending *p, *npd; struct sync_pending *p, *npd;
if (!xwl_seat)
return;
xorg_list_for_each_entry_safe(p, npd, &xwl_seat->sync_pending, l) { xorg_list_for_each_entry_safe(p, npd, &xwl_seat->sync_pending, l) {
if (p->pending_dev == dev) { if (p->pending_dev == dev) {
xorg_list_del(&xwl_seat->sync_pending); xorg_list_del(&xwl_seat->sync_pending);
free (p); free (p);
return; return;
} }
} }
} }
static void static void
skipping to change at line 860 skipping to change at line 865
} }
static const struct wl_callback_listener sync_listener = { static const struct wl_callback_listener sync_listener = {
sync_callback sync_callback
}; };
static Bool static Bool
keyboard_check_repeat (DeviceIntPtr dev, XkbSrvInfoPtr xkbi, unsigned key) keyboard_check_repeat (DeviceIntPtr dev, XkbSrvInfoPtr xkbi, unsigned key)
{ {
struct xwl_seat *xwl_seat = dev->public.devicePrivate; struct xwl_seat *xwl_seat = dev->public.devicePrivate;
struct xwl_screen *xwl_screen = xwl_seat->xwl_screen; struct xwl_screen *xwl_screen;
struct wl_callback *callback; struct wl_callback *callback;
struct sync_pending *p; struct sync_pending *p;
if (!xwl_seat)
return FALSE;
/* Make sure we didn't miss a possible reply from the compositor */ /* Make sure we didn't miss a possible reply from the compositor */
xwl_screen = xwl_seat->xwl_screen;
xwl_sync_events (xwl_screen); xwl_sync_events (xwl_screen);
xorg_list_for_each_entry(p, &xwl_seat->sync_pending, l) { xorg_list_for_each_entry(p, &xwl_seat->sync_pending, l) {
if (p->pending_dev == dev) { if (p->pending_dev == dev) {
ErrorF("Key repeat discarded, Wayland compositor doesn't " ErrorF("Key repeat discarded, Wayland compositor doesn't "
"seem to be processing events fast enough!\n"); "seem to be processing events fast enough!\n");
return FALSE; return FALSE;
} }
} }
skipping to change at line 1153 skipping to change at line 1162
snprintf(name, sizeof name, "%s:%d", driver, xwl_seat->id); snprintf(name, sizeof name, "%s:%d", driver, xwl_seat->id);
AssignTypeAndName(dev, type_atom, name); AssignTypeAndName(dev, type_atom, name);
dev->public.devicePrivate = xwl_seat; dev->public.devicePrivate = xwl_seat;
dev->type = SLAVE; dev->type = SLAVE;
dev->spriteInfo->spriteOwner = FALSE; dev->spriteInfo->spriteOwner = FALSE;
return dev; return dev;
} }
static void static void
disable_device(DeviceIntPtr dev)
{
DisableDevice(dev, TRUE);
dev->public.devicePrivate = NULL;
}
static void
enable_device(struct xwl_seat *xwl_seat, DeviceIntPtr dev)
{
dev->public.devicePrivate = xwl_seat;
EnableDevice(dev, TRUE);
}
static void
init_pointer(struct xwl_seat *xwl_seat) init_pointer(struct xwl_seat *xwl_seat)
{ {
xwl_seat->wl_pointer = wl_seat_get_pointer(xwl_seat->seat); xwl_seat->wl_pointer = wl_seat_get_pointer(xwl_seat->seat);
wl_pointer_add_listener(xwl_seat->wl_pointer, wl_pointer_add_listener(xwl_seat->wl_pointer,
&pointer_listener, xwl_seat); &pointer_listener, xwl_seat);
if (xwl_seat->pointer == NULL) { if (xwl_seat->pointer == NULL) {
xwl_seat_set_cursor(xwl_seat); xwl_seat_set_cursor(xwl_seat);
xwl_seat->pointer = xwl_seat->pointer =
add_device(xwl_seat, "xwayland-pointer", xwl_pointer_proc); add_device(xwl_seat, "xwayland-pointer", xwl_pointer_proc);
ActivateDevice(xwl_seat->pointer, TRUE); ActivateDevice(xwl_seat->pointer, TRUE);
} }
EnableDevice(xwl_seat->pointer, TRUE); enable_device(xwl_seat, xwl_seat->pointer);
} }
static void static void
release_pointer(struct xwl_seat *xwl_seat) release_pointer(struct xwl_seat *xwl_seat)
{ {
wl_pointer_release(xwl_seat->wl_pointer); wl_pointer_release(xwl_seat->wl_pointer);
xwl_seat->wl_pointer = NULL; xwl_seat->wl_pointer = NULL;
if (xwl_seat->pointer) if (xwl_seat->pointer)
DisableDevice(xwl_seat->pointer, TRUE); disable_device(xwl_seat->pointer);
} }
static void static void
init_relative_pointer(struct xwl_seat *xwl_seat) init_relative_pointer(struct xwl_seat *xwl_seat)
{ {
struct zwp_relative_pointer_manager_v1 *relative_pointer_manager = struct zwp_relative_pointer_manager_v1 *relative_pointer_manager =
xwl_seat->xwl_screen->relative_pointer_manager; xwl_seat->xwl_screen->relative_pointer_manager;
if (relative_pointer_manager) { if (relative_pointer_manager) {
xwl_seat->wp_relative_pointer = xwl_seat->wp_relative_pointer =
skipping to change at line 1199 skipping to change at line 1222
&relative_pointer_listener, &relative_pointer_listener,
xwl_seat); xwl_seat);
} }
if (xwl_seat->relative_pointer == NULL) { if (xwl_seat->relative_pointer == NULL) {
xwl_seat->relative_pointer = xwl_seat->relative_pointer =
add_device(xwl_seat, "xwayland-relative-pointer", add_device(xwl_seat, "xwayland-relative-pointer",
xwl_pointer_proc_relative); xwl_pointer_proc_relative);
ActivateDevice(xwl_seat->relative_pointer, TRUE); ActivateDevice(xwl_seat->relative_pointer, TRUE);
} }
EnableDevice(xwl_seat->relative_pointer, TRUE); enable_device(xwl_seat, xwl_seat->relative_pointer);
} }
static void static void
release_relative_pointer(struct xwl_seat *xwl_seat) release_relative_pointer(struct xwl_seat *xwl_seat)
{ {
if (xwl_seat->wp_relative_pointer) { if (xwl_seat->wp_relative_pointer) {
zwp_relative_pointer_v1_destroy(xwl_seat->wp_relative_pointer); zwp_relative_pointer_v1_destroy(xwl_seat->wp_relative_pointer);
xwl_seat->wp_relative_pointer = NULL; xwl_seat->wp_relative_pointer = NULL;
} }
if (xwl_seat->relative_pointer) if (xwl_seat->relative_pointer)
DisableDevice(xwl_seat->relative_pointer, TRUE); disable_device(xwl_seat->relative_pointer);
} }
static void static void
init_keyboard(struct xwl_seat *xwl_seat) init_keyboard(struct xwl_seat *xwl_seat)
{ {
DeviceIntPtr master; DeviceIntPtr master;
xwl_seat->wl_keyboard = wl_seat_get_keyboard(xwl_seat->seat); xwl_seat->wl_keyboard = wl_seat_get_keyboard(xwl_seat->seat);
wl_keyboard_add_listener(xwl_seat->wl_keyboard, wl_keyboard_add_listener(xwl_seat->wl_keyboard,
&keyboard_listener, xwl_seat); &keyboard_listener, xwl_seat);
if (xwl_seat->keyboard == NULL) { if (xwl_seat->keyboard == NULL) {
xwl_seat->keyboard = xwl_seat->keyboard =
add_device(xwl_seat, "xwayland-keyboard", xwl_keyboard_proc); add_device(xwl_seat, "xwayland-keyboard", xwl_keyboard_proc);
ActivateDevice(xwl_seat->keyboard, TRUE); ActivateDevice(xwl_seat->keyboard, TRUE);
} }
EnableDevice(xwl_seat->keyboard, TRUE); enable_device(xwl_seat, xwl_seat->keyboard);
xwl_seat->keyboard->key->xkbInfo->checkRepeat = keyboard_check_repeat; xwl_seat->keyboard->key->xkbInfo->checkRepeat = keyboard_check_repeat;
if (xwl_seat->xwl_screen->wp_grab) { if (xwl_seat->xwl_screen->wp_grab) {
/* We have Xwayland grab protocol supported by the compositor */ /* We have Xwayland grab protocol supported by the compositor */
master = GetMaster(xwl_seat->keyboard, MASTER_KEYBOARD); master = GetMaster(xwl_seat->keyboard, MASTER_KEYBOARD);
if (master) if (master)
setup_keyboard_grab_handler(master); setup_keyboard_grab_handler(master);
} }
} }
static void static void
release_keyboard(struct xwl_seat *xwl_seat) release_keyboard(struct xwl_seat *xwl_seat)
{ {
release_grab(xwl_seat); release_grab(xwl_seat);
wl_keyboard_release(xwl_seat->wl_keyboard); wl_keyboard_release(xwl_seat->wl_keyboard);
xwl_seat->wl_keyboard = NULL; xwl_seat->wl_keyboard = NULL;
if (xwl_seat->keyboard) { if (xwl_seat->keyboard) {
remove_sync_pending(xwl_seat->keyboard); remove_sync_pending(xwl_seat->keyboard);
DisableDevice(xwl_seat->keyboard, TRUE); disable_device(xwl_seat->keyboard);
} }
} }
static void static void
init_touch(struct xwl_seat *xwl_seat) init_touch(struct xwl_seat *xwl_seat)
{ {
xwl_seat->wl_touch = wl_seat_get_touch(xwl_seat->seat); xwl_seat->wl_touch = wl_seat_get_touch(xwl_seat->seat);
wl_touch_add_listener(xwl_seat->wl_touch, wl_touch_add_listener(xwl_seat->wl_touch,
&touch_listener, xwl_seat); &touch_listener, xwl_seat);
if (xwl_seat->touch == NULL) { if (xwl_seat->touch == NULL) {
xwl_seat->touch = xwl_seat->touch =
add_device(xwl_seat, "xwayland-touch", xwl_touch_proc); add_device(xwl_seat, "xwayland-touch", xwl_touch_proc);
ActivateDevice(xwl_seat->touch, TRUE); ActivateDevice(xwl_seat->touch, TRUE);
} }
EnableDevice(xwl_seat->touch, TRUE); enable_device(xwl_seat, xwl_seat->touch);
} }
static void static void
release_touch(struct xwl_seat *xwl_seat) release_touch(struct xwl_seat *xwl_seat)
{ {
wl_touch_release(xwl_seat->wl_touch); wl_touch_release(xwl_seat->wl_touch);
xwl_seat->wl_touch = NULL; xwl_seat->wl_touch = NULL;
if (xwl_seat->touch) if (xwl_seat->touch)
DisableDevice(xwl_seat->touch, TRUE); disable_device(xwl_seat->touch);
} }
static void static void
seat_handle_capabilities(void *data, struct wl_seat *seat, seat_handle_capabilities(void *data, struct wl_seat *seat,
enum wl_seat_capability caps) enum wl_seat_capability caps)
{ {
struct xwl_seat *xwl_seat = data; struct xwl_seat *xwl_seat = data;
if (caps & WL_SEAT_CAPABILITY_POINTER && xwl_seat->wl_pointer == NULL) { if (caps & WL_SEAT_CAPABILITY_POINTER && xwl_seat->wl_pointer == NULL) {
init_pointer(xwl_seat); init_pointer(xwl_seat);
skipping to change at line 1434 skipping to change at line 1456
static void static void
tablet_handle_done(void *data, struct zwp_tablet_v2 *tablet) tablet_handle_done(void *data, struct zwp_tablet_v2 *tablet)
{ {
struct xwl_tablet *xwl_tablet = data; struct xwl_tablet *xwl_tablet = data;
struct xwl_seat *xwl_seat = xwl_tablet->seat; struct xwl_seat *xwl_seat = xwl_tablet->seat;
if (xwl_seat->stylus == NULL) { if (xwl_seat->stylus == NULL) {
xwl_seat->stylus = add_device(xwl_seat, "xwayland-stylus", xwl_tablet_pr oc); xwl_seat->stylus = add_device(xwl_seat, "xwayland-stylus", xwl_tablet_pr oc);
ActivateDevice(xwl_seat->stylus, TRUE); ActivateDevice(xwl_seat->stylus, TRUE);
} }
EnableDevice(xwl_seat->stylus, TRUE); enable_device(xwl_seat, xwl_seat->stylus);
if (xwl_seat->eraser == NULL) { if (xwl_seat->eraser == NULL) {
xwl_seat->eraser = add_device(xwl_seat, "xwayland-eraser", xwl_tablet_pr oc); xwl_seat->eraser = add_device(xwl_seat, "xwayland-eraser", xwl_tablet_pr oc);
ActivateDevice(xwl_seat->eraser, TRUE); ActivateDevice(xwl_seat->eraser, TRUE);
} }
EnableDevice(xwl_seat->eraser, TRUE); enable_device(xwl_seat, xwl_seat->eraser);
if (xwl_seat->puck == NULL) { if (xwl_seat->puck == NULL) {
xwl_seat->puck = add_device(xwl_seat, "xwayland-cursor", xwl_tablet_proc ); xwl_seat->puck = add_device(xwl_seat, "xwayland-cursor", xwl_tablet_proc );
ActivateDevice(xwl_seat->puck, TRUE); ActivateDevice(xwl_seat->puck, TRUE);
} }
EnableDevice(xwl_seat->puck, TRUE); enable_device(xwl_seat, xwl_seat->puck);
} }
static void static void
tablet_handle_removed(void *data, struct zwp_tablet_v2 *tablet) tablet_handle_removed(void *data, struct zwp_tablet_v2 *tablet)
{ {
struct xwl_tablet *xwl_tablet = data; struct xwl_tablet *xwl_tablet = data;
struct xwl_seat *xwl_seat = xwl_tablet->seat; struct xwl_seat *xwl_seat = xwl_tablet->seat;
xorg_list_del(&xwl_tablet->link); xorg_list_del(&xwl_tablet->link);
/* The tablet is merely disabled, not removed. The next tablet /* The tablet is merely disabled, not removed. The next tablet
will re-use the same X devices */ will re-use the same X devices */
if (xorg_list_is_empty(&xwl_seat->tablets)) { if (xorg_list_is_empty(&xwl_seat->tablets)) {
if (xwl_seat->stylus) if (xwl_seat->stylus)
DisableDevice(xwl_seat->stylus, TRUE); disable_device(xwl_seat->stylus);
if (xwl_seat->eraser) if (xwl_seat->eraser)
DisableDevice(xwl_seat->eraser, TRUE); disable_device(xwl_seat->eraser);
if (xwl_seat->puck) if (xwl_seat->puck)
DisableDevice(xwl_seat->puck, TRUE); disable_device(xwl_seat->puck);
/* pads are removed separately */ /* pads are removed separately */
} }
zwp_tablet_v2_destroy(tablet); zwp_tablet_v2_destroy(tablet);
free(xwl_tablet); free(xwl_tablet);
} }
static const struct zwp_tablet_v2_listener tablet_listener = { static const struct zwp_tablet_v2_listener tablet_listener = {
tablet_handle_name, tablet_handle_name,
tablet_handle_id, tablet_handle_id,
skipping to change at line 2066 skipping to change at line 2088
tablet_pad_group_ring, tablet_pad_group_ring,
tablet_pad_group_strip, tablet_pad_group_strip,
tablet_pad_group_modes, tablet_pad_group_modes,
tablet_pad_group_done, tablet_pad_group_done,
tablet_pad_group_mode_switch, tablet_pad_group_mode_switch,
}; };
static int static int
xwl_tablet_pad_proc(DeviceIntPtr device, int what) xwl_tablet_pad_proc(DeviceIntPtr device, int what)
{ {
struct xwl_tablet_pad *pad = device->public.devicePrivate; struct xwl_tablet_pad *pad = dixGetPrivate(&device->devPrivates,
&xwl_tablet_private_key);
/* Axis layout mirrors that of xf86-input-wacom to have better /* Axis layout mirrors that of xf86-input-wacom to have better
compatibility with existing clients */ compatibility with existing clients */
#define NAXES 7 #define NAXES 7
Atom axes_labels[NAXES] = { 0 }; Atom axes_labels[NAXES] = { 0 };
BYTE map[MAX_BUTTONS + 1]; BYTE map[MAX_BUTTONS + 1];
int i = 0; int i = 0;
Atom btn_labels[MAX_BUTTONS] = { 0 }; /* btn labels are meaningless */ Atom btn_labels[MAX_BUTTONS] = { 0 }; /* btn labels are meaningless */
int nbuttons; int nbuttons;
switch (what) { switch (what) {
skipping to change at line 2190 skipping to change at line 2213
} }
static void static void
tablet_pad_done(void *data, tablet_pad_done(void *data,
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2) struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2)
{ {
struct xwl_tablet_pad *pad = data; struct xwl_tablet_pad *pad = data;
pad->xdevice = add_device(pad->seat, "xwayland-pad", pad->xdevice = add_device(pad->seat, "xwayland-pad",
xwl_tablet_pad_proc); xwl_tablet_pad_proc);
pad->xdevice->public.devicePrivate = pad; dixSetPrivate(&pad->xdevice->devPrivates, &xwl_tablet_private_key, pad);
ActivateDevice(pad->xdevice, TRUE); ActivateDevice(pad->xdevice, TRUE);
EnableDevice(pad->xdevice, TRUE); EnableDevice(pad->xdevice, TRUE);
} }
static void static void
tablet_pad_button(void *data, tablet_pad_button(void *data,
struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2, struct zwp_tablet_pad_v2 *zwp_tablet_pad_v2,
uint32_t time, uint32_t time,
uint32_t button, uint32_t button,
uint32_t state) uint32_t state)
skipping to change at line 2526 skipping to change at line 2549
/* Ignore non-wayland devices */ /* Ignore non-wayland devices */
if (device->deviceProc == xwl_pointer_proc && if (device->deviceProc == xwl_pointer_proc &&
device->spriteInfo->sprite == sprite) device->spriteInfo->sprite == sprite)
break; break;
} }
if (!device) if (!device)
return FALSE; return FALSE;
xwl_seat = device->public.devicePrivate; xwl_seat = device->public.devicePrivate;
if (!xwl_seat)
return FALSE;
master = GetMaster(device, POINTER_OR_FLOAT); master = GetMaster(device, POINTER_OR_FLOAT);
if (!master || !master->lastSlave) if (!master || !master->lastSlave)
return FALSE; return FALSE;
/* We do want the last active slave, we only check on slave xwayland /* We do want the last active slave, we only check on slave xwayland
* devices so we can find out the xwl_seat, but those don't actually own * devices so we can find out the xwl_seat, but those don't actually own
* their sprite, so the match doesn't mean a lot. * their sprite, so the match doesn't mean a lot.
*/ */
if (master->lastSlave == xwl_seat->pointer && if (master->lastSlave == xwl_seat->pointer &&
skipping to change at line 2759 skipping to change at line 2784
if (xwl_seat->confined_pointer) if (xwl_seat->confined_pointer)
xwl_seat_destroy_confined_pointer(xwl_seat); xwl_seat_destroy_confined_pointer(xwl_seat);
xwl_seat->pointer_warp_emulator = xwl_seat->pointer_warp_emulator =
xwl_pointer_warp_emulator_create(xwl_seat); xwl_pointer_warp_emulator_create(xwl_seat);
} }
static Bool static Bool
xwl_seat_can_emulate_pointer_warp(struct xwl_seat *xwl_seat) xwl_seat_can_emulate_pointer_warp(struct xwl_seat *xwl_seat)
{ {
struct xwl_screen *xwl_screen = xwl_seat->xwl_screen; struct xwl_screen *xwl_screen;
if (!xwl_seat)
return FALSE;
if (!xwl_seat->pointer)
return FALSE;
xwl_screen = xwl_seat->xwl_screen;
if (!xwl_screen->relative_pointer_manager) if (!xwl_screen->relative_pointer_manager)
return FALSE; return FALSE;
if (!xwl_screen->pointer_constraints) if (!xwl_screen->pointer_constraints)
return FALSE; return FALSE;
return TRUE; return TRUE;
} }
skipping to change at line 2853 skipping to change at line 2886
void void
xwl_seat_confine_pointer(struct xwl_seat *xwl_seat, xwl_seat_confine_pointer(struct xwl_seat *xwl_seat,
struct xwl_window *xwl_window) struct xwl_window *xwl_window)
{ {
struct zwp_pointer_constraints_v1 *pointer_constraints = struct zwp_pointer_constraints_v1 *pointer_constraints =
xwl_seat->xwl_screen->pointer_constraints; xwl_seat->xwl_screen->pointer_constraints;
if (!pointer_constraints) if (!pointer_constraints)
return; return;
if (!xwl_seat->wl_pointer)
return;
if (xwl_seat->cursor_confinement_window == xwl_window && if (xwl_seat->cursor_confinement_window == xwl_window &&
xwl_seat->confined_pointer) xwl_seat->confined_pointer)
return; return;
xwl_seat_unconfine_pointer(xwl_seat); xwl_seat_unconfine_pointer(xwl_seat);
xwl_seat->cursor_confinement_window = xwl_window; xwl_seat->cursor_confinement_window = xwl_window;
if (xwl_seat->pointer_warp_emulator) if (xwl_seat->pointer_warp_emulator)
return; return;
skipping to change at line 2897 skipping to change at line 2933
if (xwl_seat->confined_pointer) if (xwl_seat->confined_pointer)
xwl_seat_destroy_confined_pointer(xwl_seat); xwl_seat_destroy_confined_pointer(xwl_seat);
} }
void void
InitInput(int argc, char *argv[]) InitInput(int argc, char *argv[])
{ {
ScreenPtr pScreen = screenInfo.screens[0]; ScreenPtr pScreen = screenInfo.screens[0];
struct xwl_screen *xwl_screen = xwl_screen_get(pScreen); struct xwl_screen *xwl_screen = xwl_screen_get(pScreen);
if (!dixRegisterPrivateKey(&xwl_tablet_private_key, PRIVATE_DEVICE, 0)) {
ErrorF("Failed to register private key\n");
return;
}
mieqInit(); mieqInit();
xwl_screen->input_registry = wl_display_get_registry(xwl_screen->display); xwl_screen->input_registry = wl_display_get_registry(xwl_screen->display);
wl_registry_add_listener(xwl_screen->input_registry, &input_listener, wl_registry_add_listener(xwl_screen->input_registry, &input_listener,
xwl_screen); xwl_screen);
xwl_screen->XYToWindow = pScreen->XYToWindow; xwl_screen->XYToWindow = pScreen->XYToWindow;
pScreen->XYToWindow = xwl_xy_to_window; pScreen->XYToWindow = xwl_xy_to_window;
wl_display_roundtrip(xwl_screen->display); xwl_screen_roundtrip(xwl_screen);
while (xwl_screen->expecting_event)
wl_display_roundtrip(xwl_screen->display);
} }
void void
CloseInput(void) CloseInput(void)
{ {
mieqFini(); mieqFini();
} }
 End of changes. 27 change blocks. 
22 lines changed or deleted 61 lines changed or added

Home  |  About  |  Features  |  All  |  Newest  |  Dox  |  Diffs  |  RSS Feeds  |  Screenshots  |  Comments  |  Imprint  |  Privacy  |  HTTP(S)