frederik
/
xserver
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Abstract valuator masks through a set of APIs. 

This commit introduces an abstraction API for handling masked valuators. The
intent is that drivers just allocate a mask, set the data and pass the mask
to the server. The actual storage type of the mask is hidden from the
drivers.

The new calls for drivers are:
    valuator_mask_new()     /* to allocate a valuator mask */
    valuator_mask_zero()    /* to reset a mask to zero */
    valuator_mask_set()     /* to set a valuator value */

The new interface to the server is
    xf86PostMotionEventM()
    xf86PostButtonEventM()
    xf86PostKeyboardEventM()
    xf86PostProximityEventM()

all taking a mask instead of the valuator array.

The ValuatorMask is currently defined for MAX_VALUATORS fixed size due to
memory allocation restrictions in SIGIO handlers.

For easier review, a lot of the code still uses separate valuator arrays.
This will be fixed in a later patch.

This patch was initially written by Chase Douglas.

Signed-off-by: Chase Douglas <chase.douglas@canonical.com>
Signed-off-by: Peter Hutterer <peter.hutterer@who-t.net>
Reviewed-by: Chase Douglas <chase.douglas@canonical.com>
This commit is contained in:
Peter Hutterer 2010-10-19 13:37:46 +10:00
parent fc48a8f9f5
commit 675f4a8525
15 changed files with 493 additions and 186 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

10
Xext/xtest.c
View File

@ -52,6 +52,7 @@
#include "mipointer.h" #include "mipointer.h"
#include "xserver-properties.h" #include "xserver-properties.h"
#include "exevents.h" #include "exevents.h"
#include "inpututils.h"
#include "modinit.h" #include "modinit.h"
@ -153,6 +154,7 @@ ProcXTestFakeInput(ClientPtr client)
WindowPtr root; WindowPtr root;
Bool extension = FALSE; Bool extension = FALSE;
deviceValuator *dv = NULL; deviceValuator *dv = NULL;
ValuatorMask mask;
int valuators[MAX_VALUATORS] = {0}; int valuators[MAX_VALUATORS] = {0};
int numValuators = 0; int numValuators = 0;
int firstValuator = 0; int firstValuator = 0;
@ -413,14 +415,14 @@ ProcXTestFakeInput(ClientPtr client)
switch(type) { switch(type) {
case MotionNotify: case MotionNotify:
nevents = GetPointerEvents(xtest_evlist, dev, type, 0, flags, valuator_mask_set_range(&mask, firstValuator, numValuators, valuators);
firstValuator, numValuators, valuators); nevents = GetPointerEvents(xtest_evlist, dev, type, 0, flags, &mask);
break; break;
case ButtonPress: case ButtonPress:
case ButtonRelease: case ButtonRelease:
valuator_mask_set_range(&mask, firstValuator, numValuators, valuators);
nevents = GetPointerEvents(xtest_evlist, dev, type, ev->u.u.detail, nevents = GetPointerEvents(xtest_evlist, dev, type, ev->u.u.detail,
flags, firstValuator, flags, &mask);
numValuators, valuators);
break; break;
case KeyPress: case KeyPress:
case KeyRelease: case KeyRelease:

245
dix/getevents.c
View File

@ -46,6 +46,7 @@
#include "mipointer.h" #include "mipointer.h"
#include "eventstr.h" #include "eventstr.h"
#include "eventconvert.h" #include "eventconvert.h"
#include "inpututils.h"
#include <X11/extensions/XKBproto.h> #include <X11/extensions/XKBproto.h>
#include "xkbsrv.h" #include "xkbsrv.h"
@ -184,34 +185,40 @@ init_raw(DeviceIntPtr dev, RawDeviceEvent *event, Time ms, int type, int detail)
} }
static void static void
set_raw_valuators(RawDeviceEvent *event, int first, int num, int *valuators, int32_t* data) set_raw_valuators(RawDeviceEvent *event, ValuatorMask *mask, int *valuators,
int32_t* data)
{ {
int i; int i;
for (i = first; i < first + num; i++)
SetBit(event->valuators.mask, i);
memcpy(&data[first], valuators, num * sizeof(uint32_t)); for (i = 0; i < valuator_mask_size(mask); i++)
{
if (valuator_mask_isset(mask, i))
{
SetBit(event->valuators.mask, i);
data[i] = valuators[i];
}
}
} }
static void static void
set_valuators(DeviceIntPtr dev, DeviceEvent* event, int first_valuator, set_valuators(DeviceIntPtr dev, DeviceEvent* event, ValuatorMask *mask,
int num_valuators, int *valuators) int *valuators)
{ {
int i; int i;
for (i = first_valuator; i < first_valuator + num_valuators; i++) for (i = 0; i < valuator_mask_size(mask); i++)
{ {
SetBit(event->valuators.mask, i); if (valuator_mask_isset(mask, i))
if (dev->valuator->mode == Absolute) {
SetBit(event->valuators.mode, i); SetBit(event->valuators.mask, i);
event->valuators.data_frac[i] = if (dev->valuator->mode == Absolute)
dev->last.remainder[i] * (1 << 16) * (1 << 16); SetBit(event->valuators.mode, i);
event->valuators.data[i] = valuators[i];
event->valuators.data_frac[i] =
dev->last.remainder[i] * (1 << 16) * (1 << 16);
}
} }
memcpy(&event->valuators.data[first_valuator],
valuators, num_valuators * sizeof(uint32_t));
} }
void void
@ -524,12 +531,12 @@ GetMotionHistory(DeviceIntPtr pDev, xTimecoord **buff, unsigned long start,
* for SDs: [time] [val0] [val1] ... [valn] * for SDs: [time] [val0] [val1] ... [valn]
* for MDs: [time] [min_val0] [max_val0] [val0] [min_val1] ... [valn] * for MDs: [time] [min_val0] [max_val0] [val0] [min_val1] ... [valn]
* *
* For events that have some valuators unset (first_valuator > 0): * For events that have some valuators unset:
* min_val == max_val == val == 0. * min_val == max_val == val == 0.
*/ */
static void static void
updateMotionHistory(DeviceIntPtr pDev, CARD32 ms, int first_valuator, updateMotionHistory(DeviceIntPtr pDev, CARD32 ms, ValuatorMask *mask,
int num_valuators, int *valuators) int *valuators)
{ {
char *buff = (char *) pDev->valuator->motion; char *buff = (char *) pDev->valuator->motion;
ValuatorClassPtr v; ValuatorClassPtr v;
@ -548,17 +555,19 @@ updateMotionHistory(DeviceIntPtr pDev, CARD32 ms, int first_valuator,
buff += sizeof(Time); buff += sizeof(Time);
memset(buff, 0, sizeof(INT32) * 3 * MAX_VALUATORS); memset(buff, 0, sizeof(INT32) * 3 * MAX_VALUATORS);
buff += 3 * sizeof(INT32) * first_valuator;
for (i = first_valuator; i < first_valuator + num_valuators; i++) for (i = 0; i < v->numAxes; i++)
{ {
if (i >= v->numAxes) if (valuator_mask_size(mask) <= i || !valuator_mask_isset(mask, i))
break; {
buff += 3 * sizeof(INT32);
continue;
}
memcpy(buff, &v->axes[i].min_value, sizeof(INT32)); memcpy(buff, &v->axes[i].min_value, sizeof(INT32));
buff += sizeof(INT32); buff += sizeof(INT32);
memcpy(buff, &v->axes[i].max_value, sizeof(INT32)); memcpy(buff, &v->axes[i].max_value, sizeof(INT32));
buff += sizeof(INT32); buff += sizeof(INT32);
memcpy(buff, &valuators[i - first_valuator], sizeof(INT32)); memcpy(buff, &valuators[i], sizeof(INT32));
buff += sizeof(INT32); buff += sizeof(INT32);
} }
} else } else
@ -571,9 +580,17 @@ updateMotionHistory(DeviceIntPtr pDev, CARD32 ms, int first_valuator,
buff += sizeof(Time); buff += sizeof(Time);
memset(buff, 0, sizeof(INT32) * pDev->valuator->numAxes); memset(buff, 0, sizeof(INT32) * pDev->valuator->numAxes);
buff += sizeof(INT32) * first_valuator;
memcpy(buff, valuators, sizeof(INT32) * num_valuators); for (i = 0; i < MAX_VALUATORS; i++)
{
if (valuator_mask_size(mask) <= i || !valuator_mask_isset(mask, i))
{
buff += sizeof(INT32);
continue;
}
memcpy(buff, &valuators[i], sizeof(INT32));
buff += sizeof(INT32);
}
} }
pDev->valuator->last_motion = (pDev->valuator->last_motion + 1) % pDev->valuator->last_motion = (pDev->valuator->last_motion + 1) %
@ -631,13 +648,13 @@ clipAxis(DeviceIntPtr pDev, int axisNum, int *val)
* Clip every axis in the list of valuators to its bounds. * Clip every axis in the list of valuators to its bounds.
*/ */
static void static void
clipValuators(DeviceIntPtr pDev, int first_valuator, int num_valuators, clipValuators(DeviceIntPtr pDev, ValuatorMask *mask, int *valuators)
int *valuators)
{ {
int i; int i;
for (i = 0; i < num_valuators; i++) for (i = 0; i < valuator_mask_size(mask); i++)
clipAxis(pDev, i + first_valuator, &(valuators[i])); if (valuator_mask_isset(mask, i))
clipAxis(pDev, i, &(valuators[i]));
} }
/** /**
@ -680,36 +697,36 @@ UpdateFromMaster(EventListPtr events, DeviceIntPtr dev, int type, int *num_event
* @param dev The device which's pointer is to be moved. * @param dev The device which's pointer is to be moved.
* @param x Returns the x position of the pointer after the move. * @param x Returns the x position of the pointer after the move.
* @param y Returns the y position of the pointer after the move. * @param y Returns the y position of the pointer after the move.
* @param first The first valuator in @valuators * @param mask Bit mask of valid valuators.
* @param num Total number of valuators in @valuators.
* @param valuators Valuator data for each axis between @first and * @param valuators Valuator data for each axis between @first and
* @first+@num. * @first+@num.
*/ */
static void static void
moveAbsolute(DeviceIntPtr dev, int *x, int *y, moveAbsolute(DeviceIntPtr dev, int *x, int *y,
int first, int num, int *valuators) const ValuatorMask *mask, int *valuators)
{ {
int i; int i;
if (valuator_mask_isset(mask, 0))
if (num >= 1 && first == 0)
*x = *(valuators + 0); *x = *(valuators + 0);
else else
*x = dev->last.valuators[0]; *x = dev->last.valuators[0];
if (first <= 1 && num >= (2 - first)) if (valuator_mask_isset(mask, 1))
*y = *(valuators + 1 - first); *y = *(valuators + 1);
else else
*y = dev->last.valuators[1]; *y = dev->last.valuators[1];
clipAxis(dev, 0, x); clipAxis(dev, 0, x);
clipAxis(dev, 1, y); clipAxis(dev, 1, y);
i = (first > 2) ? 0 : 2; for (i = 2; i < valuator_mask_size(mask); i++)
for (; i < num; i++)
{ {
dev->last.valuators[i + first] = valuators[i]; if (valuator_mask_isset(mask, i))
clipAxis(dev, i, &dev->last.valuators[i + first]); {
dev->last.valuators[i] = valuators[i];
clipAxis(dev, i, &dev->last.valuators[i]);
}
} }
} }
@ -719,25 +736,24 @@ moveAbsolute(DeviceIntPtr dev, int *x, int *y,
* @param dev The device which's pointer is to be moved. * @param dev The device which's pointer is to be moved.
* @param x Returns the x position of the pointer after the move. * @param x Returns the x position of the pointer after the move.
* @param y Returns the y position of the pointer after the move. * @param y Returns the y position of the pointer after the move.
* @param first The first valuator in @valuators * @param mask Bit mask of valid valuators.
* @param num Total number of valuators in @valuators.
* @param valuators Valuator data for each axis between @first and * @param valuators Valuator data for each axis between @first and
* @first+@num. * @first+@num.
*/ */
static void static void
moveRelative(DeviceIntPtr dev, int *x, int *y, moveRelative(DeviceIntPtr dev, int *x, int *y,
int first, int num, int *valuators) ValuatorMask *mask, int *valuators)
{ {
int i; int i;
*x = dev->last.valuators[0]; *x = dev->last.valuators[0];
*y = dev->last.valuators[1]; *y = dev->last.valuators[1];
if (num >= 1 && first == 0) if (valuator_mask_isset(mask, 0))
*x += *(valuators +0); *x += *(valuators +0);
if (first <= 1 && num >= (2 - first)) if (valuator_mask_bit_isset(mask, 1))
*y += *(valuators + 1 - first); *y += *(valuators + 1);
/* if attached, clip both x and y to the defined limits (usually /* if attached, clip both x and y to the defined limits (usually
* co-ord space limit). If it is attached, we need x/y to go over the * co-ord space limit). If it is attached, we need x/y to go over the
@ -748,13 +764,15 @@ moveRelative(DeviceIntPtr dev, int *x, int *y,
} }
/* calc other axes, clip, drop back into valuators */ /* calc other axes, clip, drop back into valuators */
i = (first > 2) ? 0 : 2; for (i = 2; i < valuator_mask_size(mask); i++)
for (; i < num; i++)
{ {
dev->last.valuators[i + first] += valuators[i]; if (valuator_mask_isset(mask, i))
if (dev->valuator->mode == Absolute) {
clipAxis(dev, i, &dev->last.valuators[i + first]); dev->last.valuators[i] += valuators[i];
valuators[i] = dev->last.valuators[i + first]; if (dev->valuator->mode == Absolute)
clipAxis(dev, i, &dev->last.valuators[i]);
valuators[i] = dev->last.valuators[i];
}
} }
} }
@ -868,18 +886,18 @@ positionSprite(DeviceIntPtr dev, int *x, int *y, float x_frac, float y_frac,
* Update the motion history for the device and (if appropriate) for its * Update the motion history for the device and (if appropriate) for its
* master device. * master device.
* @param dev Slave device to update. * @param dev Slave device to update.
* @param first First valuator to append to history. * @param mask Bit mask of valid valuators to append to history.
* @param num Total number of valuators to append to history. * @param num Total number of valuators to append to history.
* @param ms Current time * @param ms Current time
*/ */
static void static void
updateHistory(DeviceIntPtr dev, int first, int num, CARD32 ms) updateHistory(DeviceIntPtr dev, ValuatorMask *mask, CARD32 ms)
{ {
updateMotionHistory(dev, ms, first, num, &dev->last.valuators[first]); updateMotionHistory(dev, ms, mask, dev->last.valuators);
if (dev->u.master) if (dev->u.master)
{ {
DeviceIntPtr master = GetMaster(dev, MASTER_POINTER); DeviceIntPtr master = GetMaster(dev, MASTER_POINTER);
updateMotionHistory(master, ms, first, num, &dev->last.valuators[first]); updateMotionHistory(master, ms, mask, dev->last.valuators);
} }
} }
@ -889,7 +907,10 @@ updateHistory(DeviceIntPtr dev, int first, int num, CARD32 ms)
*/ */
int int
GetKeyboardEvents(EventList *events, DeviceIntPtr pDev, int type, int key_code) { GetKeyboardEvents(EventList *events, DeviceIntPtr pDev, int type, int key_code) {
return GetKeyboardValuatorEvents(events, pDev, type, key_code, 0, 0, NULL); ValuatorMask mask;
valuator_mask_zero(&mask);
return GetKeyboardValuatorEvents(events, pDev, type, key_code, &mask);
} }
@ -911,12 +932,12 @@ GetKeyboardEvents(EventList *events, DeviceIntPtr pDev, int type, int key_code)
*/ */
int int
GetKeyboardValuatorEvents(EventList *events, DeviceIntPtr pDev, int type, GetKeyboardValuatorEvents(EventList *events, DeviceIntPtr pDev, int type,
int key_code, int first_valuator, int key_code, const ValuatorMask *mask_in) {
int num_valuators, const int *valuators_in) {
int num_events = 0; int num_events = 0;
CARD32 ms = 0; CARD32 ms = 0;
DeviceEvent *event; DeviceEvent *event;
RawDeviceEvent *raw; RawDeviceEvent *raw;
ValuatorMask mask;
int valuators[MAX_VALUATORS]; int valuators[MAX_VALUATORS];
/* refuse events from disabled devices */ /* refuse events from disabled devices */
@ -924,7 +945,6 @@ GetKeyboardValuatorEvents(EventList *events, DeviceIntPtr pDev, int type,
return 0; return 0;
if (!events ||!pDev->key || !pDev->focus || !pDev->kbdfeed || if (!events ||!pDev->key || !pDev->focus || !pDev->kbdfeed ||
num_valuators > MAX_VALUATORS ||
(type != KeyPress && type != KeyRelease) || (type != KeyPress && type != KeyRelease) ||
(key_code < 8 || key_code > 255)) (key_code < 8 || key_code > 255))
return 0; return 0;
@ -949,17 +969,17 @@ GetKeyboardValuatorEvents(EventList *events, DeviceIntPtr pDev, int type,
events++; events++;
num_events++; num_events++;
memcpy(valuators, valuators_in, num_valuators * sizeof(int)); valuator_mask_copy(&mask, mask_in);
if (valuator_mask_size(&mask) > 0)
valuator_mask_copy_valuators(&mask, valuators);
init_raw(pDev, raw, ms, type, key_code); init_raw(pDev, raw, ms, type, key_code);
set_raw_valuators(raw, first_valuator, num_valuators, valuators, set_raw_valuators(raw, &mask, valuators, raw->valuators.data_raw);
raw->valuators.data_raw);
if (num_valuators) clipValuators(pDev, &mask, valuators);
clipValuators(pDev, first_valuator, num_valuators, valuators);
set_raw_valuators(raw, first_valuator, num_valuators, valuators, set_raw_valuators(raw, &mask, valuators, raw->valuators.data);
raw->valuators.data);
event = (DeviceEvent*) events->event; event = (DeviceEvent*) events->event;
init_event(pDev, event, ms); init_event(pDev, event, ms);
@ -974,10 +994,9 @@ GetKeyboardValuatorEvents(EventList *events, DeviceIntPtr pDev, int type,
set_key_up(pDev, key_code, KEY_POSTED); set_key_up(pDev, key_code, KEY_POSTED);
} }
if (num_valuators) clipValuators(pDev, &mask, valuators);
clipValuators(pDev, first_valuator, num_valuators, valuators);
set_valuators(pDev, event, first_valuator, num_valuators, valuators); set_valuators(pDev, event, &mask, valuators);
return num_events; return num_events;
} }
@ -1070,8 +1089,7 @@ transformAbsolute(DeviceIntPtr dev, int v[MAX_VALUATORS])
*/ */
int int
GetPointerEvents(EventList *events, DeviceIntPtr pDev, int type, int buttons, GetPointerEvents(EventList *events, DeviceIntPtr pDev, int type, int buttons,
int flags, int first_valuator, int num_valuators, int flags, const ValuatorMask *mask_in) {
const int *valuators_in) {
int num_events = 1; int num_events = 1;
CARD32 ms; CARD32 ms;
DeviceEvent *event; DeviceEvent *event;
@ -1080,6 +1098,7 @@ GetPointerEvents(EventList *events, DeviceIntPtr pDev, int type, int buttons,
cx, cy; /* only screen coordinates */ cx, cy; /* only screen coordinates */
float x_frac = 0.0, y_frac = 0.0, cx_frac, cy_frac; float x_frac = 0.0, y_frac = 0.0, cx_frac, cy_frac;
ScreenPtr scr = miPointerGetScreen(pDev); ScreenPtr scr = miPointerGetScreen(pDev);
ValuatorMask mask;
int valuators[MAX_VALUATORS]; int valuators[MAX_VALUATORS];
/* refuse events from disabled devices */ /* refuse events from disabled devices */
@ -1088,13 +1107,14 @@ GetPointerEvents(EventList *events, DeviceIntPtr pDev, int type, int buttons,
ms = GetTimeInMillis(); /* before pointer update to help precision */ ms = GetTimeInMillis(); /* before pointer update to help precision */
if (!scr || !pDev->valuator || first_valuator < 0 || if (!scr || !pDev->valuator ||
num_valuators > MAX_VALUATORS ||
((num_valuators + first_valuator) > pDev->valuator->numAxes) ||
(type != MotionNotify && type != ButtonPress && type != ButtonRelease) || (type != MotionNotify && type != ButtonPress && type != ButtonRelease) ||
(type != MotionNotify && !pDev->button) || (type != MotionNotify && !pDev->button) ||
((type == ButtonPress || type == ButtonRelease) && !buttons) || ((type == ButtonPress || type == ButtonRelease) && !buttons))
(type == MotionNotify && num_valuators <= 0)) return 0;
if (type == MotionNotify &&
(!mask_in || valuator_mask_num_valuators(mask_in) <= 0))
return 0; return 0;
events = UpdateFromMaster(events, pDev, DEVCHANGE_POINTER_EVENT, &num_events); events = UpdateFromMaster(events, pDev, DEVCHANGE_POINTER_EVENT, &num_events);
@ -1103,54 +1123,62 @@ GetPointerEvents(EventList *events, DeviceIntPtr pDev, int type, int buttons,
events++; events++;
num_events++; num_events++;
memcpy(valuators, valuators_in, num_valuators * sizeof(int)); valuator_mask_copy(&mask, mask_in);
if (valuator_mask_size(&mask) > 1)
valuator_mask_copy_valuators(&mask, valuators);
init_raw(pDev, raw, ms, type, buttons); init_raw(pDev, raw, ms, type, buttons);
set_raw_valuators(raw, first_valuator, num_valuators, valuators, set_raw_valuators(raw, &mask, valuators, raw->valuators.data_raw);
raw->valuators.data_raw);
if (flags & POINTER_ABSOLUTE) if (flags & POINTER_ABSOLUTE)
{ {
if (flags & POINTER_SCREEN) /* valuators are in screen coords */ if (flags & POINTER_SCREEN) /* valuators are in screen coords */
{ {
if (num_valuators >= 1 && first_valuator == 0) if (valuator_mask_isset(&mask, 0))
valuators[0] = rescaleValuatorAxis(valuators[0], 0.0, &x_frac, NULL, valuators[0] = rescaleValuatorAxis(valuators[0], 0.0, &x_frac, NULL,
pDev->valuator->axes + 0, pDev->valuator->axes + 0,
scr->width); scr->width);
if (first_valuator <= 1 && num_valuators >= (2 - first_valuator)) if (valuator_mask_isset(&mask, 1))
valuators[1 - first_valuator] = rescaleValuatorAxis(valuators[1 - first_valuator], 0.0, &y_frac, NULL, valuators[1] = rescaleValuatorAxis(valuators[1], 0.0, &y_frac, NULL,
pDev->valuator->axes + 1, pDev->valuator->axes + 1,
scr->height); scr->height);
} }
transformAbsolute(pDev, valuators); transformAbsolute(pDev, valuators);
moveAbsolute(pDev, &x, &y, first_valuator, num_valuators, valuators); moveAbsolute(pDev, &x, &y, &mask, valuators);
} else { } else {
if (flags & POINTER_ACCELERATE) { if (flags & POINTER_ACCELERATE) {
accelPointer(pDev, first_valuator, num_valuators, valuators, ms); /* FIXME: Pointer acceleration only requires X and Y values. This
* should be converted to masked valuators. */
int vals[2];
vals[0] = valuator_mask_isset(&mask, 0) ?
valuators[0] : pDev->last.valuators[0];
vals[1] = valuator_mask_isset(&mask, 1) ?
valuators[1] : pDev->last.valuators[1];
accelPointer(pDev, 0, 2, vals, ms);
/* The pointer acceleration code modifies the fractional part /* The pointer acceleration code modifies the fractional part
* in-place, so we need to extract this information first */ * in-place, so we need to extract this information first */
x_frac = pDev->last.remainder[0]; x_frac = pDev->last.remainder[0];
y_frac = pDev->last.remainder[1]; y_frac = pDev->last.remainder[1];
} }
moveRelative(pDev, &x, &y, first_valuator, num_valuators, valuators); moveRelative(pDev, &x, &y, &mask, valuators);
} }
set_raw_valuators(raw, first_valuator, num_valuators, valuators, set_raw_valuators(raw, &mask, valuators, raw->valuators.data);
raw->valuators.data);
positionSprite(pDev, &x, &y, x_frac, y_frac, scr, &cx, &cy, &cx_frac, &cy_frac); positionSprite(pDev, &x, &y, x_frac, y_frac, scr, &cx, &cy, &cx_frac, &cy_frac);
updateHistory(pDev, first_valuator, num_valuators, ms); updateHistory(pDev, &mask, ms);
/* Update the valuators with the true value sent to the client*/ /* Update the valuators with the true value sent to the client*/
if (num_valuators >= 1 && first_valuator == 0) if (valuator_mask_isset(&mask, 0))
valuators[0] = x; valuators[0] = x;
if (first_valuator <= 1 && num_valuators >= (2 - first_valuator)) if (valuator_mask_isset(&mask, 1))
valuators[1 - first_valuator] = y; valuators[1] = y;
if (num_valuators) clipValuators(pDev, &mask, valuators);
clipValuators(pDev, first_valuator, num_valuators, valuators);
event = (DeviceEvent*) events->event; event = (DeviceEvent*) events->event;
init_event(pDev, event, ms); init_event(pDev, event, ms);
@ -1176,7 +1204,7 @@ GetPointerEvents(EventList *events, DeviceIntPtr pDev, int type, int buttons,
event->root_x_frac = cx_frac; event->root_x_frac = cx_frac;
event->root_y_frac = cy_frac; event->root_y_frac = cy_frac;
set_valuators(pDev, event, first_valuator, num_valuators, valuators); set_valuators(pDev, event, &mask, valuators);
return num_events; return num_events;
} }
@ -1190,11 +1218,11 @@ GetPointerEvents(EventList *events, DeviceIntPtr pDev, int type, int buttons,
* place via GetMaximumEventsNum(), and for freeing it. * place via GetMaximumEventsNum(), and for freeing it.
*/ */
int int
GetProximityEvents(EventList *events, DeviceIntPtr pDev, int type, GetProximityEvents(EventList *events, DeviceIntPtr pDev, int type, const ValuatorMask *mask_in)
int first_valuator, int num_valuators, const int *valuators_in)
{ {
int num_events = 1; int num_events = 1;
DeviceEvent *event; DeviceEvent *event;
ValuatorMask mask;
int valuators[MAX_VALUATORS]; int valuators[MAX_VALUATORS];
/* refuse events from disabled devices */ /* refuse events from disabled devices */
@ -1202,18 +1230,16 @@ GetProximityEvents(EventList *events, DeviceIntPtr pDev, int type,
return 0; return 0;
/* Sanity checks. */ /* Sanity checks. */
if (type != ProximityIn && type != ProximityOut) if ((type != ProximityIn && type != ProximityOut) || !mask_in)
return 0; return 0;
if (!pDev->valuator) if (!pDev->valuator)
return 0; return 0;
valuator_mask_copy(&mask, mask_in);
/* Do we need to send a DeviceValuator event? */ /* Do we need to send a DeviceValuator event? */
if ((pDev->valuator->mode & 1) == Relative) if ((pDev->valuator->mode & 1) == Relative)
num_valuators = 0; valuator_mask_zero(&mask);
/* You fail. */
if (first_valuator < 0 || num_valuators > MAX_VALUATORS ||
(num_valuators + first_valuator) > pDev->valuator->numAxes)
return 0;
events = UpdateFromMaster(events, pDev, DEVCHANGE_POINTER_EVENT, &num_events); events = UpdateFromMaster(events, pDev, DEVCHANGE_POINTER_EVENT, &num_events);
@ -1221,12 +1247,11 @@ GetProximityEvents(EventList *events, DeviceIntPtr pDev, int type,
init_event(pDev, event, GetTimeInMillis()); init_event(pDev, event, GetTimeInMillis());
event->type = (type == ProximityIn) ? ET_ProximityIn : ET_ProximityOut; event->type = (type == ProximityIn) ? ET_ProximityIn : ET_ProximityOut;
if (num_valuators) { if (valuator_mask_size(&mask) > 0)
memcpy(valuators, valuators_in, num_valuators * sizeof(int)); valuator_mask_copy_valuators(&mask, valuators);
clipValuators(pDev, first_valuator, num_valuators, valuators); clipValuators(pDev, &mask, valuators);
}
set_valuators(pDev, event, first_valuator, num_valuators, valuators); set_valuators(pDev, event, &mask, valuators);
return num_events; return num_events;
} }

142
dix/inpututils.c
View File

@ -35,6 +35,7 @@
#include "xace.h" #include "xace.h"
#include "xkbsrv.h" #include "xkbsrv.h"
#include "xkbstr.h" #include "xkbstr.h"
#include "inpututils.h"
/* Check if a button map change is okay with the device. /* Check if a button map change is okay with the device.
* Returns -1 for BadValue, as it collides with MappingBusy. */ * Returns -1 for BadValue, as it collides with MappingBusy. */
@ -418,6 +419,147 @@ FreeInputAttributes(InputAttributes *attrs)
free(attrs); free(attrs);
} }
/**
* Alloc a valuator mask large enough for num_valuators.
*/
ValuatorMask*
valuator_mask_new(int num_valuators)
{
/* alloc a fixed size mask for now and ignore num_valuators. in the
* flying-car future, when we can dynamically alloc the masks and are
* not constrained by signals, we can start using num_valuators */
ValuatorMask *mask = calloc(1, sizeof(ValuatorMask));
mask->last_bit = -1;
return mask;
}
/**
* Sets a range of valuators between first_valuator and num_valuators with
* the data in the valuators array. All other values are set to 0.
*/
void
valuator_mask_set_range(ValuatorMask *mask, int first_valuator, int num_valuators,
const int* valuators)
{
int i;
valuator_mask_zero(mask);
for (i = first_valuator; i < min(first_valuator + num_valuators, MAX_VALUATORS); i++)
valuator_mask_set(mask, i, valuators[i - first_valuator]);
}
/**
* Reset mask to zero.
*/
void
valuator_mask_zero(ValuatorMask *mask)
{
memset(mask, 0, sizeof(*mask));
mask->last_bit = -1;
}
/**
* Returns the current size of the mask (i.e. the highest number of
* valuators currently set + 1).
*/
int
valuator_mask_size(const ValuatorMask *mask)
{
return mask->last_bit + 1;
}
/**
* Returns the number of valuators set in the given mask.
*/
int
valuator_mask_num_valuators(const ValuatorMask *mask)
{
return CountBits(mask->mask, min(mask->last_bit + 1, MAX_VALUATORS));
}
/**
* Return true if the valuator is set in the mask, or false otherwise.
*/
int
valuator_mask_isset(const ValuatorMask *mask, int valuator)
{
return mask->last_bit >= valuator && BitIsOn(mask->mask, valuator);
}
/**
* Set the valuator to the given data.
*/
void
valuator_mask_set(ValuatorMask *mask, int valuator, int data)
{
mask->last_bit = max(valuator, mask->last_bit);
SetBit(mask->mask, valuator);
mask->valuators[valuator] = data;
}
/**
* Return the requested valuator value. If the mask bit is not set for the
* given valuator, the returned value is undefined.
*/
int
valuator_mask_get(const ValuatorMask *mask, int valuator)
{
return mask->valuators[valuator];
}
/**
* Remove the valuator from the mask.
*/
void
valuator_mask_unset(ValuatorMask *mask, int valuator)
{
if (mask->last_bit >= valuator) {
int i, lastbit = -1;
ClearBit(mask->mask, valuator);
mask->valuators[valuator] = 0;
for (i = 0; i <= mask->last_bit; i++)
if (valuator_mask_isset(mask, i))
lastbit = max(lastbit, i);
mask->last_bit = lastbit;
}
}
/**
* Copy the valuator data from the given mask and return it as one closed
* array (i.e., with holes where the masks are unset.
* If valuators_in is not NULL, the valuator data will be copied into
* valuators_in. The caller is responsible to allocate enough memory.
*
* Otherwise, memory is allocated and returned.
*/
int*
valuator_mask_copy_valuators(const ValuatorMask *mask, int *valuators_in)
{
int *valuators;
if (!valuators_in)
valuators = calloc(valuator_mask_size(mask), sizeof(int));
else
valuators = valuators_in;
memcpy(valuators, mask->valuators,
valuator_mask_size(mask) * sizeof(int));
return valuators;
}
void
valuator_mask_copy(ValuatorMask *dest, const ValuatorMask *src)
{
if (src)
memcpy(dest, src, sizeof(*dest));
else
valuator_mask_zero(dest);
}
int int
CountBits(const uint8_t *mask, int len) CountBits(const uint8_t *mask, int len)

49
hw/dmx/input/dmxevents.c
View File

@ -53,6 +53,7 @@
#include <X11/keysym.h> #include <X11/keysym.h>
#include "opaque.h" #include "opaque.h"
#include "inputstr.h" #include "inputstr.h"
#include "inpututils.h"
#include "mipointer.h" #include "mipointer.h"
#include "mi.h" #include "mi.h"
#include "exglobals.h" #include "exglobals.h"
@ -178,12 +179,14 @@ static void enqueueMotion(DevicePtr pDev, int x, int y)
int i, nevents, valuators[3]; int i, nevents, valuators[3];
EventListPtr events; EventListPtr events;
int detail = 0; /* XXX should this be mask of pressed buttons? */ int detail = 0; /* XXX should this be mask of pressed buttons? */
ValuatorMask mask;
valuators[0] = x; valuators[0] = x;
valuators[1] = y; valuators[1] = y;
valuator_mask_set_range(&mask, 0, 2, valuators);
GetEventList(&events); GetEventList(&events);
nevents = GetPointerEvents(events, p, MotionNotify, detail, nevents = GetPointerEvents(events, p, MotionNotify, detail,
POINTER_ABSOLUTE | POINTER_SCREEN, 0, 2, valuators); POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
for (i = 0; i < nevents; i++) for (i = 0; i < nevents; i++)
mieqEnqueue(p, (InternalEvent*)(events + i)->event); mieqEnqueue(p, (InternalEvent*)(events + i)->event);
return; return;
@ -292,6 +295,7 @@ static void dmxExtMotion(DMXLocalInputInfoPtr dmxLocal,
int count; int count;
EventListPtr events; EventListPtr events;
int nevents; int nevents;
ValuatorMask mask;
memset(xE, 0, sizeof(xE)); memset(xE, 0, sizeof(xE));
@ -370,9 +374,10 @@ static void dmxExtMotion(DMXLocalInputInfoPtr dmxLocal,
if (block) if (block)
dmxSigioBlock(); dmxSigioBlock();
valuator_mask_set_range(&mask, firstAxis, axesCount, v);
GetEventList(&events); GetEventList(&events);
nevents = GetPointerEvents(events, pDevice, MotionNotify, 0, POINTER_ABSOLUTE, nevents = GetPointerEvents(events, pDevice, MotionNotify, 0,
firstAxis, axesCount, v); POINTER_ABSOLUTE, &mask);
for (i = 0; i < nevents; i++) for (i = 0; i < nevents; i++)
mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event); mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
@ -388,9 +393,10 @@ static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
XDeviceKeyEvent *ke = (XDeviceKeyEvent *)e; XDeviceKeyEvent *ke = (XDeviceKeyEvent *)e;
XDeviceMotionEvent *me = (XDeviceMotionEvent *)e; XDeviceMotionEvent *me = (XDeviceMotionEvent *)e;
DeviceIntPtr pDevice = dmxLocal->pDevice; DeviceIntPtr pDevice = dmxLocal->pDevice;
int valuators[6]; int valuators[MAX_VALUATORS];
EventListPtr events; EventListPtr events;
int nevents, i; int nevents, i;
ValuatorMask mask;
if (!e) if (!e)
return -1; /* No extended event passed, cannot handle */ return -1; /* No extended event passed, cannot handle */
@ -432,23 +438,23 @@ static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
} }
#define EXTRACT_VALUATORS(ke, valuators) \ #define EXTRACT_VALUATORS(ke, valuators) \
valuators[0] = ke->axis_data[0]; \ valuators[0] = ke->axis_data[0]; \
valuators[1] = ke->axis_data[1]; \ valuators[1] = ke->axis_data[1]; \
valuators[2] = ke->axis_data[2]; \ valuators[2] = ke->axis_data[2]; \
valuators[3] = ke->axis_data[3]; \ valuators[3] = ke->axis_data[3]; \
valuators[4] = ke->axis_data[4]; \ valuators[4] = ke->axis_data[4]; \
valuators[5] = ke->axis_data[5]; \ valuators[5] = ke->axis_data[5]; \
switch (type) { switch (type) {
case XI_DeviceKeyPress: case XI_DeviceKeyPress:
case XI_DeviceKeyRelease: case XI_DeviceKeyRelease:
EXTRACT_VALUATORS(ke, valuators); EXTRACT_VALUATORS(ke, valuators);
valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);
if (block) if (block)
dmxSigioBlock(); dmxSigioBlock();
GetEventList(&events); GetEventList(&events);
nevents = GetKeyboardValuatorEvents(events, pDevice, event, nevents = GetKeyboardValuatorEvents(events, pDevice, event,
ke->keycode, ke->first_axis, ke->keycode, &mask);
ke->axes_count, valuators);
for (i = 0; i < nevents; i++) for (i = 0; i < nevents; i++)
mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event); mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
@ -458,12 +464,12 @@ static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
case XI_DeviceButtonPress: case XI_DeviceButtonPress:
case XI_DeviceButtonRelease: case XI_DeviceButtonRelease:
EXTRACT_VALUATORS(ke, valuators); EXTRACT_VALUATORS(ke, valuators);
valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);
if (block) if (block)
dmxSigioBlock(); dmxSigioBlock();
GetEventList(&events); GetEventList(&events);
nevents = GetPointerEvents(events, pDevice, event, ke->keycode, nevents = GetPointerEvents(events, pDevice, event, ke->keycode,
POINTER_ABSOLUTE, ke->first_axis, POINTER_ABSOLUTE, &mask);
ke->axes_count, valuators);
for (i = 0; i < nevents; i++) for (i = 0; i < nevents; i++)
mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event); mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
@ -473,12 +479,11 @@ static int dmxTranslateAndEnqueueExtEvent(DMXLocalInputInfoPtr dmxLocal,
case XI_ProximityIn: case XI_ProximityIn:
case XI_ProximityOut: case XI_ProximityOut:
EXTRACT_VALUATORS(ke, valuators); EXTRACT_VALUATORS(ke, valuators);
valuator_mask_set_range(&mask, ke->first_axis, ke->axes_count, valuators);
if (block) if (block)
dmxSigioBlock(); dmxSigioBlock();
GetEventList(&events); GetEventList(&events);
nevents = GetProximityEvents(events, pDevice, event, nevents = GetProximityEvents(events, pDevice, event, &mask);
ke->first_axis, ke->axes_count,
valuators);
for (i = 0; i < nevents; i++) for (i = 0; i < nevents; i++)
mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event); mieqEnqueue(pDevice, (InternalEvent*)(events + i)->event);
@ -664,6 +669,7 @@ void dmxEnqueue(DevicePtr pDev, int type, int detail, KeySym keySym,
DeviceIntPtr p = dmxLocal->pDevice; DeviceIntPtr p = dmxLocal->pDevice;
int i, nevents, valuators[3]; int i, nevents, valuators[3];
EventListPtr events; EventListPtr events;
ValuatorMask mask;
DMXDBG2("dmxEnqueue: Enqueuing type=%d detail=0x%0x\n", type, detail); DMXDBG2("dmxEnqueue: Enqueuing type=%d detail=0x%0x\n", type, detail);
@ -687,12 +693,10 @@ void dmxEnqueue(DevicePtr pDev, int type, int detail, KeySym keySym,
case ButtonPress: case ButtonPress:
case ButtonRelease: case ButtonRelease:
detail = dmxGetButtonMapping(dmxLocal, detail); detail = dmxGetButtonMapping(dmxLocal, detail);
valuator_mask_zero(&mask);
GetEventList(&events); GetEventList(&events);
nevents = GetPointerEvents(events, p, type, detail, nevents = GetPointerEvents(events, p, type, detail,
POINTER_ABSOLUTE | POINTER_SCREEN, POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
0, /* first_valuator = 0 */
0, /* num_valuators = 0 */
valuators);
for (i = 0; i < nevents; i++) for (i = 0; i < nevents; i++)
mieqEnqueue(p, (InternalEvent*)(events + i)->event); mieqEnqueue(p, (InternalEvent*)(events + i)->event);
return; return;
@ -702,8 +706,9 @@ void dmxEnqueue(DevicePtr pDev, int type, int detail, KeySym keySym,
valuators[0] = e->xmotion.x; valuators[0] = e->xmotion.x;
valuators[1] = e->xmotion.y; valuators[1] = e->xmotion.y;
valuators[2] = e->xmotion.state; /* FIXME: WTF?? */ valuators[2] = e->xmotion.state; /* FIXME: WTF?? */
valuator_mask_set_range(&mask, 0, 3, valuators);
nevents = GetPointerEvents(events, p, type, detail, nevents = GetPointerEvents(events, p, type, detail,
POINTER_ABSOLUTE | POINTER_SCREEN, 0, 3, valuators); POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
for (i = 0; i < nevents; i++) for (i = 0; i < nevents; i++)
mieqEnqueue(p, (InternalEvent*)(events + i)->event); mieqEnqueue(p, (InternalEvent*)(events + i)->event);
return; return;

7
hw/kdrive/src/kinput.c
View File

@ -48,6 +48,7 @@
#include "exglobals.h" #include "exglobals.h"
#include "eventstr.h" #include "eventstr.h"
#include "xserver-properties.h" #include "xserver-properties.h"
#include "inpututils.h"
#define AtomFromName(x) MakeAtom(x, strlen(x), 1) #define AtomFromName(x) MakeAtom(x, strlen(x), 1)
@ -1967,14 +1968,16 @@ _KdEnqueuePointerEvent (KdPointerInfo *pi, int type, int x, int y, int z,
{ {
int nEvents = 0, i = 0; int nEvents = 0, i = 0;
int valuators[3] = { x, y, z }; int valuators[3] = { x, y, z };
ValuatorMask mask;
/* TRUE from KdHandlePointerEvent, means 'we swallowed the event'. */ /* TRUE from KdHandlePointerEvent, means 'we swallowed the event'. */
if (!force && KdHandlePointerEvent(pi, type, x, y, z, b, absrel)) if (!force && KdHandlePointerEvent(pi, type, x, y, z, b, absrel))
return; return;
valuator_mask_set_range(&mask, 0, 3, valuators);
GetEventList(&kdEvents); GetEventList(&kdEvents);
nEvents = GetPointerEvents(kdEvents, pi->dixdev, type, b, absrel, nEvents = GetPointerEvents(kdEvents, pi->dixdev, type, b, absrel, &mask);
0, 3, valuators);
for (i = 0; i < nEvents; i++) for (i = 0; i < nEvents; i++)
KdQueueEvent(pi->dixdev, (InternalEvent *)((kdEvents + i)->event)); KdQueueEvent(pi->dixdev, (InternalEvent *)((kdEvents + i)->event));
} }

91
hw/xfree86/common/xf86Xinput.c
View File

@ -67,6 +67,7 @@
#include "exevents.h" /* AddInputDevice */ #include "exevents.h" /* AddInputDevice */
#include "exglobals.h" #include "exglobals.h"
#include "eventstr.h" #include "eventstr.h"
#include "inpututils.h"
#include <string.h> /* InputClassMatches */ #include <string.h> /* InputClassMatches */
#ifdef HAVE_FNMATCH_H #ifdef HAVE_FNMATCH_H
@ -98,7 +99,6 @@
return; \ return; \
} }
EventListPtr xf86Events = NULL; EventListPtr xf86Events = NULL;
static int static int
@ -990,6 +990,19 @@ xf86PostMotionEventP(DeviceIntPtr device,
int first_valuator, int first_valuator,
int num_valuators, int num_valuators,
const int *valuators) const int *valuators)
{
ValuatorMask mask;
XI_VERIFY_VALUATORS(num_valuators);
valuator_mask_set_range(&mask, first_valuator, num_valuators, valuators);
xf86PostMotionEventM(device, is_absolute, &mask);
}
void
xf86PostMotionEventM(DeviceIntPtr device,
int is_absolute,
const ValuatorMask *mask)
{ {
int i = 0, nevents = 0; int i = 0, nevents = 0;
DeviceEvent *event; DeviceEvent *event;
@ -1000,8 +1013,6 @@ xf86PostMotionEventP(DeviceIntPtr device,
int dx = 0, dy = 0; int dx = 0, dy = 0;
#endif #endif
XI_VERIFY_VALUATORS(num_valuators);
if (is_absolute) if (is_absolute)
flags = POINTER_ABSOLUTE; flags = POINTER_ABSOLUTE;
else else
@ -1009,19 +1020,20 @@ xf86PostMotionEventP(DeviceIntPtr device,
#if XFreeXDGA #if XFreeXDGA
/* The evdev driver may not always send all axes across. */ /* The evdev driver may not always send all axes across. */
if (num_valuators >= 1 && first_valuator <= 1) { if (valuator_mask_isset(mask, 0) ||
valuator_mask_isset(mask, 1))
if (miPointerGetScreen(device)) { if (miPointerGetScreen(device)) {
index = miPointerGetScreen(device)->myNum; index = miPointerGetScreen(device)->myNum;
if (first_valuator == 0) if (valuator_mask_isset(mask, 0))
{ {
dx = valuators[0]; dx = valuator_mask_get(mask, 0);
if (is_absolute) if (is_absolute)
dx -= device->last.valuators[0]; dx -= device->last.valuators[0];
} }
if (first_valuator == 1 || num_valuators >= 2) if (valuator_mask_isset(mask, 1))
{ {
dy = valuators[1 - first_valuator]; dy = valuator_mask_get(mask, 1);
if (is_absolute) if (is_absolute)
dy -= device->last.valuators[1]; dy -= device->last.valuators[1];
} }
@ -1029,12 +1041,9 @@ xf86PostMotionEventP(DeviceIntPtr device,
if (DGAStealMotionEvent(device, index, dx, dy)) if (DGAStealMotionEvent(device, index, dx, dy))
return; return;
} }
}
#endif #endif
nevents = GetPointerEvents(xf86Events, device, MotionNotify, 0, nevents = GetPointerEvents(xf86Events, device, MotionNotify, 0, flags, mask);
flags, first_valuator, num_valuators,
valuators);
for (i = 0; i < nevents; i++) { for (i = 0; i < nevents; i++) {
event = (DeviceEvent*)((xf86Events + i)->event); event = (DeviceEvent*)((xf86Events + i)->event);
@ -1072,13 +1081,23 @@ xf86PostProximityEventP(DeviceIntPtr device,
int num_valuators, int num_valuators,
const int *valuators) const int *valuators)
{ {
int i, nevents; ValuatorMask mask;
XI_VERIFY_VALUATORS(num_valuators); XI_VERIFY_VALUATORS(num_valuators);
valuator_mask_set_range(&mask, first_valuator, num_valuators, valuators);
xf86PostProximityEventM(device, is_in, &mask);
}
void
xf86PostProximityEventM(DeviceIntPtr device,
int is_in,
const ValuatorMask *mask)
{
int i, nevents;
nevents = GetProximityEvents(xf86Events, device, nevents = GetProximityEvents(xf86Events, device,
is_in ? ProximityIn : ProximityOut, is_in ? ProximityIn : ProximityOut, mask);
first_valuator, num_valuators, valuators);
for (i = 0; i < nevents; i++) for (i = 0; i < nevents; i++)
mieqEnqueue(device, (InternalEvent*)((xf86Events + i)->event)); mieqEnqueue(device, (InternalEvent*)((xf86Events + i)->event));
@ -1117,6 +1136,21 @@ xf86PostButtonEventP(DeviceIntPtr device,
int first_valuator, int first_valuator,
int num_valuators, int num_valuators,
const int *valuators) const int *valuators)
{
ValuatorMask mask;
XI_VERIFY_VALUATORS(num_valuators);
valuator_mask_set_range(&mask, first_valuator, num_valuators, valuators);
xf86PostButtonEventM(device, is_absolute, button, is_down, &mask);
}
void
xf86PostButtonEventM(DeviceIntPtr device,
int is_absolute,
int button,
int is_down,
const ValuatorMask *mask)
{ {
int i = 0, nevents = 0; int i = 0, nevents = 0;
int flags = 0; int flags = 0;
@ -1125,8 +1159,6 @@ xf86PostButtonEventP(DeviceIntPtr device,
int index; int index;
#endif #endif
XI_VERIFY_VALUATORS(num_valuators);
if (is_absolute) if (is_absolute)
flags = POINTER_ABSOLUTE; flags = POINTER_ABSOLUTE;
else else
@ -1142,7 +1174,7 @@ xf86PostButtonEventP(DeviceIntPtr device,
nevents = GetPointerEvents(xf86Events, device, nevents = GetPointerEvents(xf86Events, device,
is_down ? ButtonPress : ButtonRelease, button, is_down ? ButtonPress : ButtonRelease, button,
flags, first_valuator, num_valuators, valuators); flags, mask);
for (i = 0; i < nevents; i++) for (i = 0; i < nevents; i++)
mieqEnqueue(device, (InternalEvent*)((xf86Events + i)->event)); mieqEnqueue(device, (InternalEvent*)((xf86Events + i)->event));
@ -1183,15 +1215,27 @@ xf86PostKeyEventP(DeviceIntPtr device,
int num_valuators, int num_valuators,
const int *valuators) const int *valuators)
{ {
int i = 0, nevents = 0; ValuatorMask mask;
XI_VERIFY_VALUATORS(num_valuators); XI_VERIFY_VALUATORS(num_valuators);
valuator_mask_set_range(&mask, first_valuator, num_valuators, valuators);
xf86PostKeyEventM(device, key_code, is_down, is_absolute, &mask);
}
void
xf86PostKeyEventM(DeviceIntPtr device,
unsigned int key_code,
int is_down,
int is_absolute,
const ValuatorMask *mask)
{
int i = 0, nevents = 0;
if (is_absolute) { if (is_absolute) {
nevents = GetKeyboardValuatorEvents(xf86Events, device, nevents = GetKeyboardValuatorEvents(xf86Events, device,
is_down ? KeyPress : KeyRelease, is_down ? KeyPress : KeyRelease,
key_code, first_valuator, key_code, mask);
num_valuators, valuators);
} }
else { else {
nevents = GetKeyboardEvents(xf86Events, device, nevents = GetKeyboardEvents(xf86Events, device,
@ -1208,7 +1252,10 @@ xf86PostKeyboardEvent(DeviceIntPtr device,
unsigned int key_code, unsigned int key_code,
int is_down) int is_down)
{ {
xf86PostKeyEventP(device, key_code, is_down, 0, 0, 0, NULL); ValuatorMask mask;
valuator_mask_zero(&mask);
xf86PostKeyEventM(device, key_code, is_down, 0, &mask);
} }
InputInfoPtr InputInfoPtr

8
hw/xfree86/common/xf86Xinput.h
View File

@ -115,19 +115,27 @@ extern _X_EXPORT void xf86PostMotionEvent(DeviceIntPtr device, int is_absolute,
int first_valuator, int num_valuators, ...); int first_valuator, int num_valuators, ...);
extern _X_EXPORT void xf86PostMotionEventP(DeviceIntPtr device, int is_absolute, extern _X_EXPORT void xf86PostMotionEventP(DeviceIntPtr device, int is_absolute,
int first_valuator, int num_valuators, const int *valuators); int first_valuator, int num_valuators, const int *valuators);
extern _X_EXPORT void xf86PostMotionEventM(DeviceIntPtr device, int is_absolute,
const ValuatorMask *mask);
extern _X_EXPORT void xf86PostProximityEvent(DeviceIntPtr device, int is_in, extern _X_EXPORT void xf86PostProximityEvent(DeviceIntPtr device, int is_in,
int first_valuator, int num_valuators, ...); int first_valuator, int num_valuators, ...);
extern _X_EXPORT void xf86PostProximityEventP(DeviceIntPtr device, int is_in, int first_valuator, extern _X_EXPORT void xf86PostProximityEventP(DeviceIntPtr device, int is_in, int first_valuator,
int num_valuators, const int *valuators); int num_valuators, const int *valuators);
extern _X_EXPORT void xf86PostProximityEventM(DeviceIntPtr device, int is_in,
const ValuatorMask *mask);
extern _X_EXPORT void xf86PostButtonEvent(DeviceIntPtr device, int is_absolute, int button, extern _X_EXPORT void xf86PostButtonEvent(DeviceIntPtr device, int is_absolute, int button,
int is_down, int first_valuator, int num_valuators, int is_down, int first_valuator, int num_valuators,
...); ...);
extern _X_EXPORT void xf86PostButtonEventP(DeviceIntPtr device, int is_absolute, int button, extern _X_EXPORT void xf86PostButtonEventP(DeviceIntPtr device, int is_absolute, int button,
int is_down, int first_valuator, int num_valuators, int is_down, int first_valuator, int num_valuators,
const int *valuators); const int *valuators);
extern _X_EXPORT void xf86PostButtonEventM(DeviceIntPtr device, int is_absolute, int button,
int is_down, const ValuatorMask *mask);
extern _X_EXPORT void xf86PostKeyEvent(DeviceIntPtr device, unsigned int key_code, int is_down, extern _X_EXPORT void xf86PostKeyEvent(DeviceIntPtr device, unsigned int key_code, int is_down,
int is_absolute, int first_valuator, int num_valuators, int is_absolute, int first_valuator, int num_valuators,
...); ...);
extern _X_EXPORT void xf86PostKeyEventM(DeviceIntPtr device, unsigned int key_code, int is_down,
int is_absolute, const ValuatorMask *mask);
extern _X_EXPORT void xf86PostKeyEventP(DeviceIntPtr device, unsigned int key_code, int is_down, extern _X_EXPORT void xf86PostKeyEventP(DeviceIntPtr device, unsigned int key_code, int is_down,
int is_absolute, int first_valuator, int num_valuators, int is_absolute, int first_valuator, int num_valuators,
const int *valuators); const int *valuators);

14
hw/xnest/Events.c
View File

@ -25,6 +25,7 @@ is" without express or implied warranty.
#include "windowstr.h" #include "windowstr.h"
#include "servermd.h" #include "servermd.h"
#include "inputstr.h" #include "inputstr.h"
#include "inpututils.h"
#include "mi.h" #include "mi.h"
@ -117,6 +118,7 @@ xnestCollectEvents(void)
{ {
XEvent X; XEvent X;
int i, n, valuators[2]; int i, n, valuators[2];
ValuatorMask mask;
ScreenPtr pScreen; ScreenPtr pScreen;
GetEventList(&xnestEvents); GetEventList(&xnestEvents);
@ -133,19 +135,21 @@ xnestCollectEvents(void)
break; break;
case ButtonPress: case ButtonPress:
valuator_mask_set_range(&mask, 0, 0, NULL);
xnestUpdateModifierState(X.xkey.state); xnestUpdateModifierState(X.xkey.state);
lastEventTime = GetTimeInMillis(); lastEventTime = GetTimeInMillis();
n = GetPointerEvents(xnestEvents, xnestPointerDevice, ButtonPress, n = GetPointerEvents(xnestEvents, xnestPointerDevice, ButtonPress,
X.xbutton.button, POINTER_RELATIVE, 0, 0, NULL); X.xbutton.button, POINTER_RELATIVE, &mask);
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event); mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);
break; break;
case ButtonRelease: case ButtonRelease:
valuator_mask_set_range(&mask, 0, 0, NULL);
xnestUpdateModifierState(X.xkey.state); xnestUpdateModifierState(X.xkey.state);
lastEventTime = GetTimeInMillis(); lastEventTime = GetTimeInMillis();
n = GetPointerEvents(xnestEvents, xnestPointerDevice, ButtonRelease, n = GetPointerEvents(xnestEvents, xnestPointerDevice, ButtonRelease,
X.xbutton.button, POINTER_RELATIVE, 0, 0, NULL); X.xbutton.button, POINTER_RELATIVE, &mask);
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event); mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);
break; break;
@ -153,9 +157,10 @@ xnestCollectEvents(void)
case MotionNotify: case MotionNotify:
valuators[0] = X.xmotion.x; valuators[0] = X.xmotion.x;
valuators[1] = X.xmotion.y; valuators[1] = X.xmotion.y;
valuator_mask_set_range(&mask, 0, 2, valuators);
lastEventTime = GetTimeInMillis(); lastEventTime = GetTimeInMillis();
n = GetPointerEvents(xnestEvents, xnestPointerDevice, MotionNotify, n = GetPointerEvents(xnestEvents, xnestPointerDevice, MotionNotify,
0, POINTER_ABSOLUTE, 0, 2, valuators); 0, POINTER_ABSOLUTE, &mask);
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event); mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);
break; break;
@ -186,9 +191,10 @@ xnestCollectEvents(void)
NewCurrentScreen(inputInfo.pointer, pScreen, X.xcrossing.x, X.xcrossing.y); NewCurrentScreen(inputInfo.pointer, pScreen, X.xcrossing.x, X.xcrossing.y);
valuators[0] = X.xcrossing.x; valuators[0] = X.xcrossing.x;
valuators[1] = X.xcrossing.y; valuators[1] = X.xcrossing.y;
valuator_mask_set_range(&mask, 0, 2, valuators);
lastEventTime = GetTimeInMillis(); lastEventTime = GetTimeInMillis();
n = GetPointerEvents(xnestEvents, xnestPointerDevice, MotionNotify, n = GetPointerEvents(xnestEvents, xnestPointerDevice, MotionNotify,
0, POINTER_ABSOLUTE, 0, 2, valuators); 0, POINTER_ABSOLUTE, &mask);
for (i = 0; i < n; i++) for (i = 0; i < n; i++)
mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event); mieqEnqueue(xnestPointerDevice, (InternalEvent*)(xnestEvents + i)->event);
xnestDirectInstallColormaps(pScreen); xnestDirectInstallColormaps(pScreen);

9
hw/xquartz/darwinEvents.c
View File

@ -414,6 +414,7 @@ void DarwinSendPointerEvents(DeviceIntPtr pDev, int ev_type, int ev_button, floa
float pressure, float tilt_x, float tilt_y) { float pressure, float tilt_x, float tilt_y) {
static int darwinFakeMouseButtonDown = 0; static int darwinFakeMouseButtonDown = 0;
int i, num_events; int i, num_events;
ValuatorMask mask;
ScreenPtr screen; ScreenPtr screen;
int valuators[5]; int valuators[5];
@ -464,8 +465,9 @@ void DarwinSendPointerEvents(DeviceIntPtr pDev, int ev_type, int ev_button, floa
DarwinPrepareValuators(pDev, valuators, screen, pointer_x, pointer_y, pressure, tilt_x, tilt_y); DarwinPrepareValuators(pDev, valuators, screen, pointer_x, pointer_y, pressure, tilt_x, tilt_y);
darwinEvents_lock(); { darwinEvents_lock(); {
valuator_mask_set_range(&mask, 0, (pDev == darwinTabletCurrent) ? 5 : 2, valuators);
num_events = GetPointerEvents(darwinEvents, pDev, ev_type, ev_button, num_events = GetPointerEvents(darwinEvents, pDev, ev_type, ev_button,
POINTER_ABSOLUTE, 0, pDev==darwinTabletCurrent?5:2, valuators); POINTER_ABSOLUTE, 0, &mask);
for(i=0; i<num_events; i++) mieqEnqueue (pDev, (InternalEvent*)darwinEvents[i].event); for(i=0; i<num_events; i++) mieqEnqueue (pDev, (InternalEvent*)darwinEvents[i].event);
if(num_events > 0) DarwinPokeEQ(); if(num_events > 0) DarwinPokeEQ();
} darwinEvents_unlock(); } darwinEvents_unlock();
@ -491,6 +493,7 @@ void DarwinSendProximityEvents(int ev_type, float pointer_x, float pointer_y) {
ScreenPtr screen; ScreenPtr screen;
DeviceIntPtr pDev = darwinTabletCurrent; DeviceIntPtr pDev = darwinTabletCurrent;
int valuators[5]; int valuators[5];
ValuatorMask mask;
DEBUG_LOG("DarwinSendProximityEvents(%d, %f, %f)\n", ev_type, pointer_x, pointer_y); DEBUG_LOG("DarwinSendProximityEvents(%d, %f, %f)\n", ev_type, pointer_x, pointer_y);
@ -507,8 +510,8 @@ void DarwinSendProximityEvents(int ev_type, float pointer_x, float pointer_y) {
DarwinPrepareValuators(pDev, valuators, screen, pointer_x, pointer_y, 0.0f, 0.0f, 0.0f); DarwinPrepareValuators(pDev, valuators, screen, pointer_x, pointer_y, 0.0f, 0.0f, 0.0f);
darwinEvents_lock(); { darwinEvents_lock(); {
num_events = GetProximityEvents(darwinEvents, pDev, ev_type, valuator_mask_set_range(&mask, 0, 5, valuators);
0, 5, valuators); num_events = GetProximityEvents(darwinEvents, pDev, ev_type, &mask);
for(i=0; i<num_events; i++) mieqEnqueue (pDev, (InternalEvent*)darwinEvents[i].event); for(i=0; i<num_events; i++) mieqEnqueue (pDev, (InternalEvent*)darwinEvents[i].event);
if(num_events > 0) DarwinPokeEQ(); if(num_events > 0) DarwinPokeEQ();
} darwinEvents_unlock(); } darwinEvents_unlock();

8
hw/xwin/winmouse.c
View File

@ -240,15 +240,17 @@ winMouseButtonsSendEvent (int iEventType, int iButton)
{ {
EventListPtr events; EventListPtr events;
int i, nevents; int i, nevents;
ValuatorMask mask;
#if defined(XFree86Server) #if defined(XFree86Server)
if (g_winMouseButtonMap) if (g_winMouseButtonMap)
iButton = g_winMouseButtonMap[iButton]; iButton = g_winMouseButtonMap[iButton];
#endif #endif
valuator_mask_zero(&mask);
GetEventList(&events); GetEventList(&events);
nevents = GetPointerEvents(events, g_pwinPointer, iEventType, iButton, nevents = GetPointerEvents(events, g_pwinPointer, iEventType, iButton,
POINTER_RELATIVE, 0, 0, NULL); POINTER_RELATIVE, &mask);
for (i = 0; i < nevents; i++) for (i = 0; i < nevents; i++)
mieqEnqueue(g_pwinPointer, events[i].event); mieqEnqueue(g_pwinPointer, events[i].event);
@ -373,15 +375,17 @@ void winEnqueueMotion(int x, int y)
{ {
int i, nevents; int i, nevents;
int valuators[2]; int valuators[2];
ValuatorMask mask;
EventListPtr events; EventListPtr events;
miPointerSetPosition(g_pwinPointer, &x, &y); miPointerSetPosition(g_pwinPointer, &x, &y);
valuators[0] = x; valuators[0] = x;
valuators[1] = y; valuators[1] = y;
valuator_mask_set_range(&mask, 0, 2, valuators);
GetEventList(&events); GetEventList(&events);
nevents = GetPointerEvents(events, g_pwinPointer, MotionNotify, 0, nevents = GetPointerEvents(events, g_pwinPointer, MotionNotify, 0,
POINTER_ABSOLUTE | POINTER_SCREEN, 0, 2, valuators); POINTER_ABSOLUTE | POINTER_SCREEN, &mask);
for (i = 0; i < nevents; i++) for (i = 0; i < nevents; i++)
mieqEnqueue(g_pwinPointer, events[i].event); mieqEnqueue(g_pwinPointer, events[i].event);

2
include/Makefile.am
View File

@ -67,6 +67,6 @@ AM_CFLAGS = $(DIX_CFLAGS)
EXTRA_DIST = \ EXTRA_DIST = \
dix-config-apple-verbatim.h \ dix-config-apple-verbatim.h \
eventconvert.h eventstr.h \ eventconvert.h eventstr.h inpututils.h \
protocol-versions.h \ protocol-versions.h \
xsha1.h xsha1.h

24
include/input.h
View File

@ -157,6 +157,8 @@ typedef struct _DeviceRec {
Bool on; /* used by DDX to keep state */ Bool on; /* used by DDX to keep state */
} DeviceRec, *DevicePtr; } DeviceRec, *DevicePtr;
typedef struct _ValuatorMask ValuatorMask;
typedef struct { typedef struct {
int click, bell, bell_pitch, bell_duration; int click, bell, bell_pitch, bell_duration;
Bool autoRepeat; Bool autoRepeat;
@ -445,9 +447,7 @@ extern _X_EXPORT int GetPointerEvents(
int type, int type,
int buttons, int buttons,
int flags, int flags,
int first_valuator, const ValuatorMask *mask);
int num_valuators,
const int *valuators);
extern _X_EXPORT int GetKeyboardEvents( extern _X_EXPORT int GetKeyboardEvents(
EventListPtr events, EventListPtr events,
@ -460,17 +460,13 @@ extern int GetKeyboardValuatorEvents(
DeviceIntPtr pDev, DeviceIntPtr pDev,
int type, int type,
int key_code, int key_code,
int first_valuator, const ValuatorMask *mask);
int num_valuator,
const int *valuators);
extern int GetProximityEvents( extern int GetProximityEvents(
EventListPtr events, EventListPtr events,
DeviceIntPtr pDev, DeviceIntPtr pDev,
int type, int type,
int first_valuator, const ValuatorMask *mask);
int num_valuators,
const int *valuators);
extern void PostSyntheticMotion( extern void PostSyntheticMotion(
DeviceIntPtr pDev, DeviceIntPtr pDev,
@ -554,4 +550,14 @@ extern _X_EXPORT void DDXRingBell(
xfixes/cursor.c uses it to determine if the cursor is enabled */ xfixes/cursor.c uses it to determine if the cursor is enabled */
extern Bool EnableCursor; extern Bool EnableCursor;
/* For server-internal functions, see inpututil.h */
extern _X_EXPORT ValuatorMask *valuator_mask_new(int num_valuators);
extern _X_EXPORT void valuator_mask_set_range(ValuatorMask *mask,
int first_valuator, int num_valuators,
const int* valuators);
extern _X_EXPORT void valuator_mask_set(ValuatorMask *mask,
int valuator,
int data);
extern _X_EXPORT void valuator_mask_zero(ValuatorMask *mask);
#endif /* INPUT_H */ #endif /* INPUT_H */

49
include/inpututils.h Normal file
View File

@ -0,0 +1,49 @@
/*
* Copyright © 2010 Red Hat, Inc.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice (including the next
* paragraph) shall be included in all copies or substantial portions of the
* Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*
*/
#ifdef HAVE_DIX_CONFIG_H
#include "dix-config.h"
#endif
#ifndef INPUTUTILS_H
#define INPUTUTILS_H
#include "input.h"
struct _ValuatorMask {
int8_t last_bit; /* highest bit set in mask */
uint8_t mask[(MAX_VALUATORS + 7)/8];
int valuators[MAX_VALUATORS]; /* valuator data */
};
/* server-internal */
extern _X_HIDDEN int valuator_mask_size(const ValuatorMask *mask);
extern _X_HIDDEN int valuator_mask_isset(const ValuatorMask *mask, int bit);
extern _X_HIDDEN void valuator_mask_unset(ValuatorMask *mask, int bit);
extern _X_HIDDEN int* valuator_mask_copy_valuators(const ValuatorMask *mask, int *valuators_in);
extern _X_HIDDEN int valuator_mask_num_valuators(const ValuatorMask *mask);
extern _X_HIDDEN void valuator_mask_copy(ValuatorMask *dest, const ValuatorMask *src);
extern _X_HIDDEN int valuator_mask_get(const ValuatorMask *mask, int valnum);
#endif

6
mi/mipointer.c
View File

@ -39,6 +39,7 @@ in this Software without prior written authorization from The Open Group.
# include "cursorstr.h" # include "cursorstr.h"
# include "dixstruct.h" # include "dixstruct.h"
# include "inputstr.h" # include "inputstr.h"
# include "inpututils.h"
DevPrivateKeyRec miPointerScreenKeyRec; DevPrivateKeyRec miPointerScreenKeyRec;
@ -553,6 +554,7 @@ miPointerMove (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
{ {
int i, nevents; int i, nevents;
int valuators[2]; int valuators[2];
ValuatorMask mask;
miPointerMoveNoEvent(pDev, pScreen, x, y); miPointerMoveNoEvent(pDev, pScreen, x, y);
@ -571,7 +573,9 @@ miPointerMove (DeviceIntPtr pDev, ScreenPtr pScreen, int x, int y)
} }
} }
nevents = GetPointerEvents(events, pDev, MotionNotify, 0, POINTER_SCREEN | POINTER_ABSOLUTE, 0, 2, valuators); valuator_mask_set_range(&mask, 0, 2, valuators);
nevents = GetPointerEvents(events, pDev, MotionNotify, 0,
POINTER_SCREEN | POINTER_ABSOLUTE, &mask);
OsBlockSignals(); OsBlockSignals();
#ifdef XQUARTZ #ifdef XQUARTZ

13
xkb/xkbActions.c
View File

@ -42,6 +42,7 @@ THE USE OR PERFORMANCE OF THIS SOFTWARE.
#include <ctype.h> #include <ctype.h>
#include "mi.h" #include "mi.h"
#include "mipointer.h" #include "mipointer.h"
#include "inpututils.h"
#define EXTENSION_EVENT_BASE 64 #define EXTENSION_EVENT_BASE 64
DevPrivateKeyRec xkbDevicePrivateKeyRec; DevPrivateKeyRec xkbDevicePrivateKeyRec;
@ -1354,7 +1355,7 @@ xkbStateNotify sn;
* First one on drinking island wins! * First one on drinking island wins!
*/ */
static void static void
InjectPointerKeyEvents(DeviceIntPtr dev, int type, int button, int flags, int num_valuators, int *valuators) InjectPointerKeyEvents(DeviceIntPtr dev, int type, int button, int flags, ValuatorMask *mask)
{ {
ScreenPtr pScreen; ScreenPtr pScreen;
EventListPtr events; EventListPtr events;
@ -1376,8 +1377,7 @@ InjectPointerKeyEvents(DeviceIntPtr dev, int type, int button, int flags, int nu
OsBlockSignals(); OsBlockSignals();
pScreen = miPointerGetScreen(ptr); pScreen = miPointerGetScreen(ptr);
saveWait = miPointerSetWaitForUpdate(pScreen, FALSE); saveWait = miPointerSetWaitForUpdate(pScreen, FALSE);
nevents = GetPointerEvents(events, ptr, type, button, flags, 0, nevents = GetPointerEvents(events, ptr, type, button, flags, mask);
num_valuators, valuators);
if (IsMaster(dev) && (lastSlave && lastSlave != ptr)) if (IsMaster(dev) && (lastSlave && lastSlave != ptr))
UpdateFromMaster(&events[nevents], lastSlave, DEVCHANGE_POINTER_EVENT, &nevents); UpdateFromMaster(&events[nevents], lastSlave, DEVCHANGE_POINTER_EVENT, &nevents);
miPointerSetWaitForUpdate(pScreen, saveWait); miPointerSetWaitForUpdate(pScreen, saveWait);
@ -1393,6 +1393,7 @@ InjectPointerKeyEvents(DeviceIntPtr dev, int type, int button, int flags, int nu
static void static void
XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags,int x,int y) XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags,int x,int y)
{ {
ValuatorMask mask;
int gpe_flags = 0; int gpe_flags = 0;
/* ignore attached SDs */ /* ignore attached SDs */
@ -1404,7 +1405,9 @@ XkbFakePointerMotion(DeviceIntPtr dev, unsigned flags,int x,int y)
else else
gpe_flags = POINTER_RELATIVE; gpe_flags = POINTER_RELATIVE;
InjectPointerKeyEvents(dev, MotionNotify, 0, gpe_flags, 2, (int[]){x, y}); valuator_mask_set_range(&mask, 0, 2, (int[]){x, y});
InjectPointerKeyEvents(dev, MotionNotify, 0, gpe_flags, &mask);
} }
void void
@ -1434,5 +1437,5 @@ XkbFakeDeviceButton(DeviceIntPtr dev,Bool press,int button)
return; return;
InjectPointerKeyEvents(dev, press ? ButtonPress : ButtonRelease, InjectPointerKeyEvents(dev, press ? ButtonPress : ButtonRelease,
button, 0, 0, NULL); button, 0, NULL);
} }