Xi 2.1 adds TouchClasses to devices, as well as TouchBegin, TouchMotion and TouchEnd events, to allow support for multiple touchpoints on a single device. This is missing support for any type of grabbing.
Based on an initial patch by Daniel Stone. Signed-off-by: Daniel Stone <[email protected]> Signed-off-by: Chase Douglas <[email protected]> --- Xi/exevents.c | 107 ++++++++++++++++++++++++++++++++++++ Xi/extinit.c | 3 + Xi/xiquerydevice.c | 95 ++++++++++++++++++++++++++++++++ Xi/xiquerydevice.h | 3 + Xi/xiselectev.c | 31 +++++++++++ configure.ac | 2 +- dix/devices.c | 100 ++++++++++++++++++++++++++++++++++ dix/eventconvert.c | 12 ++++ dix/events.c | 16 ++---- dix/getevents.c | 117 ++++++++++++++++++++++++++++++++++++++++ dix/inpututils.c | 45 +++++++++++++++ hw/xfree86/common/xf86Xinput.c | 20 +++++++ hw/xfree86/common/xf86Xinput.h | 3 + include/eventstr.h | 3 + include/exevents.h | 8 +++ include/input.h | 16 ++++++ include/inputstr.h | 111 +++++++++++++++++++++++-------------- include/protocol-versions.h | 2 +- mi/mieq.c | 6 ++ 19 files changed, 645 insertions(+), 55 deletions(-) diff --git a/Xi/exevents.c b/Xi/exevents.c index 0cd2246..bec4ef7 100644 --- a/Xi/exevents.c +++ b/Xi/exevents.c @@ -77,6 +77,7 @@ SOFTWARE. #include "xiquerydevice.h" /* For List*Info */ #include "eventconvert.h" #include "eventstr.h" +#include "xserver-properties.h" #include <X11/extensions/XKBproto.h> #include "xkbsrv.h" @@ -923,6 +924,74 @@ ProcessRawEvent(RawDeviceEvent *ev, DeviceIntPtr device) } } +static void +ProcessTouchEvent(DeviceEvent *ev, DeviceIntPtr device) +{ + TouchClassPtr t = device->touch; + Window child; + SpritePtr sprite; + xEvent *xi2; + Mask filter; + int err, touch, i; + + if (!t) + return; + + touch = FindTouchPoint(device, ev->valuators.data[t->id_axis]); + if (touch < 0) + { + DebugF("[Xi] %s: Received touch event for inactive touchpoint %d\n", + device->name, ev->valuators.data[t->id_axis]); + return; + } + + err = EventToXI2((InternalEvent *) ev, &xi2); + if (err != Success) + { + ErrorF("[Xi] %s: XI2 conversion failed in ProcessTouchBegin (%d)\n", + device->name, err); + return; + } + + /* In direct touch mode, we focus immediately under the touchpoint, so + * we need to build a window trace; in Relative, we just use the sprite. */ + if (device->touch->mode == XIDirectTouch) { + sprite = &device->touch->sprite[touch]; + if (sprite->spriteTraceGood <= 0) + XYToWindow(sprite, ev->valuators.data[t->x_axis], + ev->valuators.data[t->y_axis]); + } else + sprite = device->spriteInfo->sprite; + + child = sprite->spriteTrace[sprite->spriteTraceGood - 1]->drawable.id; + for (i = 0; i < sprite->spriteTraceGood; i++) + { + WindowPtr win = sprite->spriteTrace[i]; + int mask; + int deliveries; + + mask = EventIsDeliverable(device, (InternalEvent *)ev, win); + if (!(mask & XI2_MASK)) + continue; + + filter = GetEventFilter(device, xi2); + FixUpEventFromWindow(sprite, xi2, win, child, FALSE); + deliveries = DeliverEventsToWindow(device, win, xi2, 1, filter, + NullGrab); + if (deliveries > 0) + /* FIXME: mark event as "not-for-you-yet" for further deliveries */ + ; + } + + if (ev->type == ET_TouchEnd) + { + FinishTouchPoint(device, ev->valuators.data[t->id_axis]); + sprite->spriteTraceGood = 0; + } + + free(xi2); +} + /** * Main device event processing function. * Called from when processing the events from the event queue. @@ -952,6 +1021,12 @@ ProcessOtherEvent(InternalEvent *ev, DeviceIntPtr device) { ProcessRawEvent(&ev->raw_event, device); return; + } else if (ev->any.type == ET_TouchBegin || + ev->any.type == ET_TouchMotion || + ev->any.type == ET_TouchEnd) + { + ProcessTouchEvent(&ev->device_event, device); + return; } if (IsPointerDevice(device)) @@ -1150,6 +1225,38 @@ InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, int minval, int dev->proximity->in_proximity = FALSE; } +void +InitTouchValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, int minval, + int maxval, int resolution) +{ + TouchAxisInfoPtr ax; + + if (!dev || !dev->touch || minval > maxval) + return; + if (axnum >= dev->touch->numAxes) + return; + + ax = dev->touch->axes + axnum; + + ax->min_value = minval; + ax->max_value = maxval; + ax->resolution = resolution; + ax->label = label; + + if (ax->label == XIGetKnownProperty(AXIS_LABEL_PROP_ABS_MT_POSITION_X)) + dev->touch->x_axis = axnum; + else if (ax->label == XIGetKnownProperty(AXIS_LABEL_PROP_ABS_MT_POSITION_Y)) + dev->touch->y_axis = axnum; + else if (ax->label == + XIGetKnownProperty(AXIS_LABEL_PROP_ABS_MT_TRACKING_ID)) { + int i; + + dev->touch->id_axis = axnum; + for (i = 0; i < dev->touch->numTouches; i++) + dev->touch->last.valuators[i][axnum] = -1; + } +} + static void FixDeviceStateNotify(DeviceIntPtr dev, deviceStateNotify * ev, KeyClassPtr k, ButtonClassPtr b, ValuatorClassPtr v, int first) diff --git a/Xi/extinit.c b/Xi/extinit.c index eda4efb..d70a6a9 100644 --- a/Xi/extinit.c +++ b/Xi/extinit.c @@ -880,6 +880,9 @@ XI2EventSwap(xGenericEvent *from, xGenericEvent *to) case XI_KeyRelease: case XI_ButtonPress: case XI_ButtonRelease: + case XI_TouchBegin: + case XI_TouchMotion: + case XI_TouchEnd: SDeviceEvent((xXIDeviceEvent*)from, (xXIDeviceEvent*)to); break; case XI_RawMotion: diff --git a/Xi/xiquerydevice.c b/Xi/xiquerydevice.c index fdd2c05..421ac6d 100644 --- a/Xi/xiquerydevice.c +++ b/Xi/xiquerydevice.c @@ -232,6 +232,12 @@ SizeDeviceClasses(DeviceIntPtr dev) if (dev->valuator) len += sizeof(xXIValuatorInfo) * dev->valuator->numAxes; + if (dev->touch) + { + len += sizeof(xXITouchInfo); + len += sizeof(xXITouchValuatorInfo) * dev->touch->numAxes; + } + return len; } @@ -373,6 +379,73 @@ SwapValuatorInfo(DeviceIntPtr dev, xXIValuatorInfo* info) swaps(&info->sourceid, n); } +/** + * List multitouch information + * + * @return The number of bytes written into info. + */ +int +ListTouchInfo(DeviceIntPtr dev, xXITouchInfo *touch) +{ + touch->type = XITouchClass; + touch->length = sizeof(xXITouchInfo) >> 2; + touch->sourceid = dev->id; + touch->mode = dev->touch->mode; + touch->num_touches = dev->touch->numTouches; + + return touch->length << 2; +} + +static void +SwapTouchInfo(DeviceIntPtr dev, xXITouchInfo* touch) +{ + char n; + swaps(&touch->type, n); + swaps(&touch->length, n); + swaps(&touch->sourceid, n); +} + +/** + * List multitouch axis information + * + * @return The number of bytes written into info. + */ +int +ListTouchValuatorInfo(DeviceIntPtr dev, xXITouchValuatorInfo* val, + int axisnumber) +{ + TouchClassPtr t = dev->touch; + + val->type = XITouchValuatorClass; + val->length = sizeof(xXITouchValuatorInfo) >> 2; + val->sourceid = dev->id; + val->number = axisnumber; + val->label = t->axes[axisnumber].label; + val->min.integral = t->axes[axisnumber].min_value; + val->min.frac = 0; + val->max.integral = t->axes[axisnumber].max_value; + val->max.frac = 0; + val->resolution = t->axes[axisnumber].resolution; + + return val->length << 2; +} + +static void +SwapTouchValuatorInfo(DeviceIntPtr dev, xXITouchValuatorInfo* val) +{ + char n; + swaps(&val->type, n); + swaps(&val->length, n); + swaps(&val->sourceid, n); + swaps(&val->number, n); + swapl(&val->label, n); + swapl(&val->min.integral, n); + swapl(&val->min.frac, n); + swapl(&val->max.integral, n); + swapl(&val->max.frac, n); + swapl(&val->resolution, n); +} + int GetDeviceUse(DeviceIntPtr dev, uint16_t *attachment) { DeviceIntPtr master = dev->u.master; @@ -462,6 +535,22 @@ ListDeviceClasses(ClientPtr client, DeviceIntPtr dev, total_len += len; } + if (dev->touch) + { + (*nclasses)++; + len = ListTouchInfo(dev, (xXITouchInfo*)any); + any += len; + total_len += len; + + for (i = 0; i < dev->touch->numAxes; i++) + { + (*nclasses)++; + len = ListTouchValuatorInfo(dev, (xXITouchValuatorInfo*)any, i); + any += len; + total_len += len; + } + } + return total_len; } @@ -489,6 +578,12 @@ SwapDeviceInfo(DeviceIntPtr dev, xXIDeviceInfo* info) case XIValuatorClass: SwapValuatorInfo(dev, (xXIValuatorInfo*)any); break; + case XITouchClass: + SwapTouchInfo(dev, (xXITouchInfo*)any); + break; + case XITouchValuatorClass: + SwapTouchValuatorInfo(dev, (xXITouchValuatorInfo*)any); + break; } any += len * 4; diff --git a/Xi/xiquerydevice.h b/Xi/xiquerydevice.h index 02f0659..59326f7 100644 --- a/Xi/xiquerydevice.h +++ b/Xi/xiquerydevice.h @@ -44,4 +44,7 @@ int ListButtonInfo(DeviceIntPtr dev, xXIButtonInfo* info, Bool reportState); int ListKeyInfo(DeviceIntPtr dev, xXIKeyInfo* info); int ListValuatorInfo(DeviceIntPtr dev, xXIValuatorInfo* info, int axisnumber, Bool reportState); +int ListTouchInfo(DeviceIntPtr dev, xXITouchInfo* info); +int ListTouchValuatorInfo(DeviceIntPtr dev, xXITouchValuatorInfo* val, + int axisnumber); #endif /* QUERYDEV_H */ diff --git a/Xi/xiselectev.c b/Xi/xiselectev.c index 7aa3f0a..32937fb 100644 --- a/Xi/xiselectev.c +++ b/Xi/xiselectev.c @@ -141,6 +141,37 @@ ProcXISelectEvents(ClientPtr client) return BadValue; } + if (evmask->mask_len >= 1) + { + unsigned char *bits = (unsigned char*)&evmask[1]; + + /* All three touch events must be selected at once */ + if ((BitIsOn(bits, XI_TouchBegin) || + BitIsOn(bits, XI_TouchMotion) || + BitIsOn(bits, XI_TouchEnd)) && + (!BitIsOn(bits, XI_TouchBegin) || + !BitIsOn(bits, XI_TouchMotion) || + !BitIsOn(bits, XI_TouchEnd))) + return BadValue; + + /* All master devices doesn't make sense for touch events */ + if (BitIsOn(bits, XI_TouchBegin) && + evmask->deviceid == XIAllMasterDevices) + return BadValue; + + /* Only one client per window may select for touch begin events */ + if (BitIsOn(bits, XI_TouchBegin)) + { + OtherInputMasks *inputMasks = wOtherInputMasks(win); + if (inputMasks && + (BitIsOn(inputMasks->xi2mask[evmask->deviceid], + XI_TouchBegin) || + BitIsOn(inputMasks->xi2mask[XIAllDevices], + XI_TouchBegin))) + return BadValue; + } + } + if (XICheckInvalidMaskBits((unsigned char*)&evmask[1], evmask->mask_len * 4) != Success) return BadValue; diff --git a/configure.ac b/configure.ac index 77cad54..207205d 100644 --- a/configure.ac +++ b/configure.ac @@ -794,7 +794,7 @@ WINDOWSWMPROTO="windowswmproto" APPLEWMPROTO="applewmproto >= 1.4" dnl Core modules for most extensions, et al. -SDK_REQUIRED_MODULES="[xproto >= 7.0.17] [randrproto >= 1.2.99.3] [renderproto >= 0.11] [xextproto >= 7.0.99.3] [inputproto >= 1.9.99.902] [kbproto >= 1.0.3] fontsproto" +SDK_REQUIRED_MODULES="[xproto >= 7.0.17] [randrproto >= 1.2.99.3] [renderproto >= 0.11] [xextproto >= 7.0.99.3] [inputproto >= 2.1] [kbproto >= 1.0.3] fontsproto" # Make SDK_REQUIRED_MODULES available for inclusion in xorg-server.pc AC_SUBST(SDK_REQUIRED_MODULES) diff --git a/dix/devices.c b/dix/devices.c index 67b7cde..490ec0b 100644 --- a/dix/devices.c +++ b/dix/devices.c @@ -754,6 +754,17 @@ FreeDeviceClass(int type, pointer *class) free((*v)); break; } + case XITouchClass: + { + TouchClassPtr *t = (TouchClassPtr*)class; + int i; + + for (i = 0; i < (*t)->numTouches; i++) + free((*t)->sprite[i].spriteTrace); + + free((*t)); + break; + } case FocusClass: { FocusClassPtr *f = (FocusClassPtr*)class; @@ -862,6 +873,7 @@ FreeAllDeviceClasses(ClassesPtr classes) FreeDeviceClass(KeyClass, (pointer)&classes->key); FreeDeviceClass(ValuatorClass, (pointer)&classes->valuator); + FreeDeviceClass(XITouchClass, (pointer)&classes->touch); FreeDeviceClass(ButtonClass, (pointer)&classes->button); FreeDeviceClass(FocusClass, (pointer)&classes->focus); FreeDeviceClass(ProximityClass, (pointer)&classes->proximity); @@ -1543,6 +1555,94 @@ InitPointerDeviceStruct(DevicePtr device, CARD8 *map, int numButtons, Atom* btn_ InitPtrFeedbackClassDeviceStruct(dev, controlProc)); } +/** + * Sets up multitouch capabilities on @device. + * + * @max_touches The maximum number of simultaneous touches, or 0 for unlimited. + * @mode The mode of the touch device (XIDirectTouch or XIDependentTouch). + * @numAxes The number of valuator axes for the touch device + */ +Bool +InitTouchClassDeviceStruct(DeviceIntPtr device, unsigned int max_touches, + unsigned int mode, unsigned int numAxes) +{ + TouchClassPtr touch; + int *valuators; + float *remainder; + int i; + + if (device->touch) + return FALSE; + + if ((mode != XIDirectTouch && mode != XIDependentTouch) || + max_touches == 0 || numAxes <= 4) + return FALSE; + + if (numAxes > MAX_VALUATORS) + { + LogMessage(X_WARNING, + "Device '%s' has %d axes, only using first %d.\n", + device->name, numAxes, MAX_VALUATORS); + numAxes = MAX_VALUATORS; + } + + + touch = calloc(1, + sizeof(TouchClassRec) + + numAxes * sizeof(TouchAxisInfo) + + max_touches * sizeof(SpriteRec) + + max_touches * sizeof(int *) + + max_touches * numAxes * sizeof(int) + + max_touches * sizeof(float *) + + max_touches * numAxes * sizeof(float)); + if (!touch) + return FALSE; + + touch->axes = (TouchAxisInfoPtr)(touch + 1); + touch->sprite = (SpriteRec *)(touch->axes + numAxes); + touch->last.valuators = (int **)(touch->sprite + max_touches); + + valuators = (int *)(touch->last.valuators + max_touches); + for (i = 0; i < max_touches; i++) + { + touch->last.valuators[i] = valuators; + valuators += numAxes; + } + + touch->last.remainder = (float **)valuators; + remainder = (float *)(touch->last.remainder + max_touches); + for (i = 0; i < max_touches; i++) + { + touch->last.remainder[i] = remainder; + remainder += numAxes; + } + + for (i = 0; i < max_touches; i++) + { + SpritePtr sprite = &touch->sprite[i]; + + sprite->spriteTrace = (WindowPtr *)calloc(1, 32*sizeof(WindowPtr)); + if (!sprite->spriteTrace) + FatalError("Failed to allocate touch spriteTrace"); + sprite->spriteTraceSize = 32; + sprite->spriteTrace[0] = screenInfo.screens[0]->root; + sprite->hot.pScreen = screenInfo.screens[0]; + sprite->hotPhys.pScreen = screenInfo.screens[0]; + } + + touch->sourceid = device->id; + touch->numAxes = numAxes; + touch->numTouches = max_touches; + touch->mode = mode; + touch->x_axis = -1; + touch->y_axis = -1; + touch->id_axis = -1; + + device->touch = touch; + + return TRUE; +} + /* * Check if the given buffer contains elements between low (inclusive) and * high (inclusive) only. diff --git a/dix/eventconvert.c b/dix/eventconvert.c index 991298e..b931065 100644 --- a/dix/eventconvert.c +++ b/dix/eventconvert.c @@ -130,6 +130,9 @@ EventToCore(InternalEvent *event, xEvent *core) case ET_RawButtonPress: case ET_RawButtonRelease: case ET_RawMotion: + case ET_TouchBegin: + case ET_TouchEnd: + case ET_TouchMotion: return BadMatch; default: /* XXX: */ @@ -175,6 +178,9 @@ EventToXI(InternalEvent *ev, xEvent **xi, int *count) case ET_RawButtonPress: case ET_RawButtonRelease: case ET_RawMotion: + case ET_TouchBegin: + case ET_TouchEnd: + case ET_TouchMotion: *count = 0; *xi = NULL; return BadMatch; @@ -216,6 +222,9 @@ EventToXI2(InternalEvent *ev, xEvent **xi) case ET_ButtonRelease: case ET_KeyPress: case ET_KeyRelease: + case ET_TouchBegin: + case ET_TouchMotion: + case ET_TouchEnd: return eventToDeviceEvent(&ev->device_event, xi); case ET_ProximityIn: case ET_ProximityOut: @@ -724,6 +733,9 @@ GetXI2Type(InternalEvent *event) case ET_RawMotion: xi2type = XI_RawMotion; break; case ET_FocusIn: xi2type = XI_FocusIn; break; case ET_FocusOut: xi2type = XI_FocusOut; break; + case ET_TouchBegin: xi2type = XI_TouchBegin; break; + case ET_TouchEnd: xi2type = XI_TouchEnd; break; + case ET_TouchMotion: xi2type = XI_TouchMotion; break; default: break; } diff --git a/dix/events.c b/dix/events.c index 9c56bb5..dc1727e 100644 --- a/dix/events.c +++ b/dix/events.c @@ -334,12 +334,6 @@ IsMaster(DeviceIntPtr dev) return dev->type == MASTER_POINTER || dev->type == MASTER_KEYBOARD; } -static WindowPtr XYToWindow( - SpritePtr pSprite, - int x, - int y -); - /** * Max event opcode. */ @@ -447,7 +441,7 @@ GetWindowXI2Mask(DeviceIntPtr dev, WindowPtr win, xEvent* ev) (inputMasks->xi2mask[XIAllMasterDevices][evtype/8] && IsMaster(dev))); } -static Mask +Mask GetEventMask(DeviceIntPtr dev, xEvent *event, InputClients* other) { /* XI2 filters are only ever 8 bit, so let's return a 8 bit mask */ @@ -1277,7 +1271,6 @@ ComputeFreezes(void) { DeviceIntPtr replayDev = syncEvents.replayDev; int i; - SpritePtr pSprite = replayDev->spriteInfo->sprite; WindowPtr w; GrabPtr grab; DeviceIntPtr dev; @@ -1291,6 +1284,7 @@ ComputeFreezes(void) if (replayDev) { DeviceEvent* event = replayDev->deviceGrab.sync.event; + SpritePtr pSprite = replayDev->spriteInfo->sprite; syncEvents.replayDev = (DeviceIntPtr)NULL; @@ -2571,7 +2565,7 @@ PointInBorderSize(WindowPtr pWin, int x, int y) * * @returns the window at the given coordinates. */ -static WindowPtr +WindowPtr XYToWindow(SpritePtr pSprite, int x, int y) { WindowPtr pWin; @@ -3440,9 +3434,9 @@ CheckPassiveGrabsOnWindow( tempGrab.detail.exact = event->detail.key; if (!match) { - tempGrab.type = GetXIType((InternalEvent*)event); tempGrab.grabtype = GRABTYPE_XI; - if (GrabMatchesSecond(&tempGrab, grab, FALSE)) + if ((tempGrab.type = GetXIType((InternalEvent*)event)) && + (GrabMatchesSecond(&tempGrab, grab, FALSE))) match = XI_MATCH; } diff --git a/dix/getevents.c b/dix/getevents.c index 8ebd63b..a785a0c 100644 --- a/dix/getevents.c +++ b/dix/getevents.c @@ -47,6 +47,7 @@ #include "eventstr.h" #include "eventconvert.h" #include "inpututils.h" +#include "windowstr.h" #include <X11/extensions/XKBproto.h> #include "xkbsrv.h" @@ -1274,6 +1275,122 @@ GetProximityEvents(EventList *events, DeviceIntPtr pDev, int type, const Valuato } /** + * Get events for a touch. Generates a TouchBegin event if end is not set and + * the touch id is not active. Generates a TouchMotion event if end is not set + * and the touch id is active. Generates a TouchEnd event if end is set and the + * touch id is active. + * + * events is not NULL-terminated; the return value is the number of events. + * The DDX is responsible for allocating the event structure in the first + * place via GetMaximumEventsNum(), and for freeing it. + */ +int +GetTouchEvents(EventList *events, DeviceIntPtr pDev, + const ValuatorMask *mask_in, Bool end) +{ + int x, y; + float x_frac = 0.0, y_frac = 0.0; + DeviceEvent *event; + ValuatorMask mask; + int touch; + TouchClassPtr t = pDev->touch; + ScreenPtr scr = pDev->spriteInfo->sprite->hotPhys.pScreen; + CARD32 ms = GetTimeInMillis(); + + /* refuse events from disabled devices */ + if (!pDev->enabled) + return 0; + + /* Sanity check. */ + if (!t) + return 0; + + /* These axes must exist */ + if (t->x_axis < 0 || t->y_axis < 0 || t->id_axis < 0) { + return 0; + } + + /* Touch ID must exist */ + if (!valuator_mask_isset(mask_in, t->id_axis)) + return 0; + + touch = FindTouchPoint(pDev, valuator_mask_get(mask_in, t->id_axis)); + + /* Touch must exist or must be starting and have both X and Y */ + if (touch < 0 && (end || !valuator_mask_isset(mask_in, t->x_axis) || + !valuator_mask_isset(mask_in, t->y_axis))) + return 0; + + valuator_mask_copy(&mask, mask_in); + + /* Get our screen event co-ordinates (root_x/root_y/event_x/event_y): + * these come from the touchpoint in Absolute mode, or the sprite in + * Relative. */ + if (t->mode == XIDirectTouch) { + int scaled; + + if (valuator_mask_isset(&mask, t->x_axis)) + { + scaled = rescaleValuatorAxis(valuator_mask_get(&mask, t->x_axis), + 0.0, &x_frac, + (AxisInfoPtr)(t->axes + t->x_axis), + NULL, scr->width); + valuator_mask_set(&mask, t->x_axis, scaled); + x = scaled; + } else { + x = t->last.valuators[touch][t->x_axis]; + x_frac = t->last.remainder[touch][t->x_axis]; + } + + if (valuator_mask_isset(&mask, t->y_axis)) + { + scaled = rescaleValuatorAxis(valuator_mask_get(&mask, t->y_axis), + 0.0, &y_frac, + (AxisInfoPtr)(t->axes + t->y_axis), + NULL, scr->height); + valuator_mask_set(&mask, t->y_axis, scaled); + y = scaled; + } else { + y = t->last.valuators[touch][t->y_axis]; + y_frac = t->last.remainder[touch][t->y_axis]; + } + } + else { + x = pDev->spriteInfo->sprite->hotPhys.x; + y = pDev->spriteInfo->sprite->hotPhys.y; + } + + event = (DeviceEvent *)events->event; + init_event(pDev, event, ms); + event->root = scr->root->drawable.id; + event->root_x = x; + event->root_y = y; + event->root_x_frac = x_frac; + event->root_y_frac = y_frac; + + set_valuators(pDev, event, &mask); + + if (touch < 0) { + touch = CreateTouchPoint(pDev, valuator_mask_get(&mask, t->id_axis)); + if (touch < 0) + return 0; + + event->type = ET_TouchBegin; + } + else if (end) + event->type = ET_TouchEnd; + else + event->type = ET_TouchMotion; + + t->last.valuators[touch][t->x_axis] = x; + t->last.remainder[touch][t->x_axis] = x_frac; + t->last.valuators[touch][t->y_axis] = y; + t->last.remainder[touch][t->y_axis] = y_frac; + + return 1; +} + +/** * Synthesize a single motion event for the core pointer. * * Used in cursor functions, e.g. when cursor confinement changes, and we need diff --git a/dix/inpututils.c b/dix/inpututils.c index 3d96ec7..ab8d9ce 100644 --- a/dix/inpututils.c +++ b/dix/inpututils.c @@ -546,3 +546,48 @@ CountBits(const uint8_t *mask, int len) return ret; } + +int +FindTouchPoint(DeviceIntPtr dev, unsigned int touchid) +{ + int i; + + if (!dev->touch) + return -1; + + for (i = 0; i < dev->touch->numTouches; i++) + if (dev->touch->last.valuators[i][dev->touch->id_axis] == (int)touchid) + return i; + + return -1; +} + +int +CreateTouchPoint(DeviceIntPtr dev, unsigned int touchid) +{ + int touch; + + if (!dev->touch) + return -1; + + if (FindTouchPoint(dev, touchid) >= 0) + return -1; + + touch = FindTouchPoint(dev, -1); + if (touch < 0) + return -1; + + dev->touch->last.valuators[touch][dev->touch->id_axis] = touchid; + return touch; +} + +void +FinishTouchPoint(DeviceIntPtr dev, unsigned int touchid) +{ + int touch = FindTouchPoint(dev, touchid); + + if (touch < 0) + return; + + dev->touch->last.valuators[touch][dev->touch->id_axis] = -1; +} diff --git a/hw/xfree86/common/xf86Xinput.c b/hw/xfree86/common/xf86Xinput.c index b910cf8..1ca9dfb 100644 --- a/hw/xfree86/common/xf86Xinput.c +++ b/hw/xfree86/common/xf86Xinput.c @@ -1334,6 +1334,16 @@ xf86InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, int minval, max_res, mode); } +void +xf86InitTouchValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, + int minval, int maxval, int resolution) +{ + if (!dev || !dev->touch) + return; + + InitTouchValuatorAxisStruct(dev, axnum, label, minval, maxval, resolution); +} + /* * Set the valuator values to be in synch with dix/event.c * DefineInitialRootWindow(). @@ -1385,4 +1395,14 @@ xf86EnableDevice(DeviceIntPtr dev) EnableDevice(dev, TRUE); } +void +xf86PostTouchEvent(DeviceIntPtr dev, const ValuatorMask *mask, int end) +{ + int i, nevents; + + nevents = GetTouchEvents(xf86Events, dev, mask, end); + for (i = 0; i < nevents; i++) + mieqEnqueue(dev, (InternalEvent *)((xf86Events + i)->event)); +} + /* end of xf86Xinput.c */ diff --git a/hw/xfree86/common/xf86Xinput.h b/hw/xfree86/common/xf86Xinput.h index b310eaf..8ceb96d 100644 --- a/hw/xfree86/common/xf86Xinput.h +++ b/hw/xfree86/common/xf86Xinput.h @@ -141,6 +141,7 @@ extern _X_EXPORT void xf86PostKeyEventP(DeviceIntPtr device, unsigned int key_co const int *valuators); extern _X_EXPORT void xf86PostKeyboardEvent(DeviceIntPtr device, unsigned int key_code, int is_down); +extern _X_EXPORT void xf86PostTouchEvent(DeviceIntPtr dev, const ValuatorMask *mask, int end); extern _X_EXPORT InputInfoPtr xf86FirstLocalDevice(void); extern _X_EXPORT int xf86ScaleAxis(int Cx, int Sxhigh, int Sxlow, int Rxhigh, int Rxlow); extern _X_EXPORT void xf86XInputSetScreen(InputInfoPtr pInfo, int screen_number, int x, int y); @@ -148,6 +149,8 @@ extern _X_EXPORT void xf86ProcessCommonOptions(InputInfoPtr pInfo, pointer optio extern _X_EXPORT void xf86InitValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, int minval, int maxval, int resolution, int min_res, int max_res, int mode); +extern _X_EXPORT void xf86InitTouchValuatorAxisStruct(DeviceIntPtr dev, int axnum, Atom label, + int minval, int maxval, int resolution); extern _X_EXPORT void xf86InitValuatorDefaults(DeviceIntPtr dev, int axnum); extern _X_EXPORT void xf86AddEnabledDevice(InputInfoPtr pInfo); extern _X_EXPORT void xf86RemoveEnabledDevice(InputInfoPtr pInfo); diff --git a/include/eventstr.h b/include/eventstr.h index 433227e..61c4c24 100644 --- a/include/eventstr.h +++ b/include/eventstr.h @@ -65,6 +65,9 @@ enum EventType { ET_RawButtonRelease, ET_RawMotion, ET_XQuartz, + ET_TouchBegin, + ET_TouchEnd, + ET_TouchMotion, ET_Internal = 0xFF /* First byte */ }; diff --git a/include/exevents.h b/include/exevents.h index bfee385..3961c68 100644 --- a/include/exevents.h +++ b/include/exevents.h @@ -51,6 +51,14 @@ extern _X_EXPORT void InitValuatorAxisStruct( int /* max_res */, int /* mode */); +extern _X_EXPORT void InitTouchValuatorAxisStruct( + DeviceIntPtr /* dev */, + int /* axnum */, + Atom /* label */, + int /* minval */, + int /* maxval */, + int /* resolution */); + /* Input device properties */ extern _X_EXPORT void XIDeleteAllDeviceProperties( DeviceIntPtr /* device */ diff --git a/include/input.h b/include/input.h index c1db544..36c176c 100644 --- a/include/input.h +++ b/include/input.h @@ -314,6 +314,12 @@ extern _X_EXPORT Bool InitAbsoluteClassDeviceStruct( extern _X_EXPORT Bool InitFocusClassDeviceStruct( DeviceIntPtr /*device*/); +extern _X_EXPORT Bool InitTouchClassDeviceStruct( + DeviceIntPtr /*device*/, + unsigned int /*max_touches*/, + unsigned int /*mode*/, + unsigned int /*numAxes*/); + typedef void (*BellProcPtr)( int /*percent*/, DeviceIntPtr /*device*/, @@ -463,6 +469,12 @@ extern int GetKeyboardValuatorEvents( int key_code, const ValuatorMask *mask); +extern int GetTouchEvents( + EventListPtr events, + DeviceIntPtr pDev, + const ValuatorMask *mask, + int end); + extern int GetProximityEvents( EventListPtr events, DeviceIntPtr pDev, @@ -524,8 +536,12 @@ extern DeviceIntPtr GetXTestDevice(DeviceIntPtr master); extern void SendDevicePresenceEvent(int deviceid, int type); extern _X_EXPORT InputAttributes *DuplicateInputAttributes(InputAttributes *attrs); extern _X_EXPORT void FreeInputAttributes(InputAttributes *attrs); +extern int CreateTouchPoint(DeviceIntPtr dev, unsigned int touchid); +extern int FindTouchPoint(DeviceIntPtr dev, unsigned int touchid); +extern void FinishTouchPoint(DeviceIntPtr dev, unsigned int touchid); /* misc event helpers */ +extern Mask GetEventMask(DeviceIntPtr dev, xEvent* ev, InputClientsPtr clients); extern Mask GetEventFilter(DeviceIntPtr dev, xEvent *event); extern Mask GetWindowXI2Mask(DeviceIntPtr dev, WindowPtr win, xEvent* ev); void FixUpEventFromWindow(SpritePtr pSprite, diff --git a/include/inputstr.h b/include/inputstr.h index b3c60b2..cb0ba32 100644 --- a/include/inputstr.h +++ b/include/inputstr.h @@ -49,6 +49,8 @@ SOFTWARE. #ifndef INPUTSTRUCT_H #define INPUTSTRUCT_H +#include <X11/extensions/XI2proto.h> + #include <pixman.h> #include "input.h" #include "window.h" @@ -71,7 +73,7 @@ extern _X_EXPORT int CountBits(const uint8_t *mask, int len); * events to the protocol, the server will not support these events until * this number here is bumped. */ -#define XI2LASTEVENT 17 /* XI_RawMotion */ +#define XI2LASTEVENT XI_TouchMotion #define XI2MASKSIZE ((XI2LASTEVENT + 7)/8) /* no of bits for masks */ /** @@ -203,6 +205,47 @@ typedef struct _GrabRec { unsigned char xi2mask[EMASKSIZE][XI2MASKSIZE]; } GrabRec; +/** + * Sprite information for a device. + */ +typedef struct _SpriteRec { + CursorPtr current; + BoxRec hotLimits; /* logical constraints of hot spot */ + Bool confined; /* confined to screen */ + RegionPtr hotShape; /* additional logical shape constraint */ + BoxRec physLimits; /* physical constraints of hot spot */ + WindowPtr win; /* window of logical position */ + HotSpot hot; /* logical pointer position */ + HotSpot hotPhys; /* physical pointer position */ +#ifdef PANORAMIX + ScreenPtr screen; /* all others are in Screen 0 coordinates */ + RegionRec Reg1; /* Region 1 for confining motion */ + RegionRec Reg2; /* Region 2 for confining virtual motion */ + WindowPtr windows[MAXSCREENS]; + WindowPtr confineWin; /* confine window */ +#endif + /* The window trace information is used at dix/events.c to avoid having + * to compute all the windows between the root and the current pointer + * window each time a button or key goes down. The grabs on each of those + * windows must be checked. + * spriteTraces should only be used at dix/events.c! */ + WindowPtr *spriteTrace; + int spriteTraceSize; + int spriteTraceGood; + + /* Due to delays between event generation and event processing, it is + * possible that the pointer has crossed screen boundaries between the + * time in which it begins generating events and the time when + * those events are processed. + * + * pEnqueueScreen: screen the pointer was on when the event was generated + * pDequeueScreen: screen the pointer was on when the event is processed + */ + ScreenPtr pEnqueueScreen; + ScreenPtr pDequeueScreen; + +} SpriteRec; + typedef struct _KeyClassRec { int sourceid; CARD8 down[DOWN_LENGTH]; @@ -243,6 +286,29 @@ typedef struct _ValuatorClassRec { ValuatorAccelerationRec accelScheme; } ValuatorClassRec, *ValuatorClassPtr; +typedef struct _TouchAxisInfo { + int resolution; + int min_value; + int max_value; + Atom label; +} TouchAxisInfo, *TouchAxisInfoPtr; + +typedef struct _TouchClassRec { + int sourceid; + TouchAxisInfoPtr axes; + unsigned short numAxes; + unsigned short numTouches; + SpriteRec *sprite; + struct { + int **valuators; + float **remainder; + } last; + CARD8 mode; + int x_axis; + int y_axis; + int id_axis; +} TouchClassRec, *TouchClassPtr; + typedef struct _ButtonClassRec { int sourceid; CARD8 numButtons; @@ -347,6 +413,7 @@ typedef struct _LedFeedbackClassRec { typedef struct _ClassesRec { KeyClassPtr key; ValuatorClassPtr valuator; + TouchClassPtr touch; ButtonClassPtr button; FocusClassPtr focus; ProximityClassPtr proximity; @@ -360,47 +427,6 @@ typedef struct _ClassesRec { } ClassesRec; -/** - * Sprite information for a device. - */ -typedef struct _SpriteRec { - CursorPtr current; - BoxRec hotLimits; /* logical constraints of hot spot */ - Bool confined; /* confined to screen */ - RegionPtr hotShape; /* additional logical shape constraint */ - BoxRec physLimits; /* physical constraints of hot spot */ - WindowPtr win; /* window of logical position */ - HotSpot hot; /* logical pointer position */ - HotSpot hotPhys; /* physical pointer position */ -#ifdef PANORAMIX - ScreenPtr screen; /* all others are in Screen 0 coordinates */ - RegionRec Reg1; /* Region 1 for confining motion */ - RegionRec Reg2; /* Region 2 for confining virtual motion */ - WindowPtr windows[MAXSCREENS]; - WindowPtr confineWin; /* confine window */ -#endif - /* The window trace information is used at dix/events.c to avoid having - * to compute all the windows between the root and the current pointer - * window each time a button or key goes down. The grabs on each of those - * windows must be checked. - * spriteTraces should only be used at dix/events.c! */ - WindowPtr *spriteTrace; - int spriteTraceSize; - int spriteTraceGood; - - /* Due to delays between event generation and event processing, it is - * possible that the pointer has crossed screen boundaries between the - * time in which it begins generating events and the time when - * those events are processed. - * - * pEnqueueScreen: screen the pointer was on when the event was generated - * pDequeueScreen: screen the pointer was on when the event is processed - */ - ScreenPtr pEnqueueScreen; - ScreenPtr pDequeueScreen; - -} SpriteRec; - /* Device properties */ typedef struct _XIPropertyValue { @@ -512,6 +538,7 @@ typedef struct _DeviceIntRec { int id; KeyClassPtr key; ValuatorClassPtr valuator; + TouchClassPtr touch; ButtonClassPtr button; FocusClassPtr focus; ProximityClassPtr proximity; diff --git a/include/protocol-versions.h b/include/protocol-versions.h index c674465..f21d632 100644 --- a/include/protocol-versions.h +++ b/include/protocol-versions.h @@ -127,7 +127,7 @@ /* X Input */ #define SERVER_XI_MAJOR_VERSION 2 -#define SERVER_XI_MINOR_VERSION 0 +#define SERVER_XI_MINOR_VERSION 1 /* XKB */ #define SERVER_XKB_MAJOR_VERSION 1 diff --git a/mi/mieq.c b/mi/mieq.c index d1441e2..f176ec0 100644 --- a/mi/mieq.c +++ b/mi/mieq.c @@ -269,6 +269,9 @@ ChangeDeviceID(DeviceIntPtr dev, InternalEvent* event) case ET_ProximityOut: case ET_Hierarchy: case ET_DeviceChanged: + case ET_TouchBegin: + case ET_TouchEnd: + case ET_TouchMotion: event->device_event.deviceid = dev->id; break; #if XFreeXDGA @@ -381,6 +384,9 @@ mieqProcessDeviceEvent(DeviceIntPtr dev, case ET_KeyRelease: case ET_ButtonPress: case ET_ButtonRelease: + case ET_TouchBegin: + case ET_TouchEnd: + case ET_TouchMotion: if (dev && screen && screen != DequeueScreen(dev) && !handler) { DequeueScreen(dev) = screen; x = event->device_event.root_x; -- 1.7.1 _______________________________________________ [email protected]: X.Org development Archives: http://lists.x.org/archives/xorg-devel Info: http://lists.x.org/mailman/listinfo/xorg-devel
