eventconvert.c revision ed6184df 
1/*
2 * Copyright © 2009 Red Hat, Inc.
3 *
4 * Permission is hereby granted, free of charge, to any person obtaining a
5 * copy of this software and associated documentation files (the "Software"),
6 * to deal in the Software without restriction, including without limitation
7 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
8 * and/or sell copies of the Software, and to permit persons to whom the
9 * Software is furnished to do so, subject to the following conditions:
10 *
11 * The above copyright notice and this permission notice (including the next
12 * paragraph) shall be included in all copies or substantial portions of the
13 * Software.
14 *
15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
21 * DEALINGS IN THE SOFTWARE.
22 *
23 */
24
25/**
26 * @file eventconvert.c
27 * This file contains event conversion routines from InternalEvent to the
28 * matching protocol events.
29 */
30
31#ifdef HAVE_DIX_CONFIG_H
32#include <dix-config.h>
33#endif
34
35#include <stdint.h>
36#include <X11/X.h>
37#include <X11/extensions/XIproto.h>
38#include <X11/extensions/XI2proto.h>
39#include <X11/extensions/XI.h>
40#include <X11/extensions/XI2.h>
41
42#include "dix.h"
43#include "inputstr.h"
44#include "misc.h"
45#include "eventstr.h"
46#include "exevents.h"
47#include "exglobals.h"
48#include "eventconvert.h"
49#include "inpututils.h"
50#include "xiquerydevice.h"
51#include "xkbsrv.h"
52#include "inpututils.h"
53
54static int countValuators(DeviceEvent *ev, int *first);
55static int getValuatorEvents(DeviceEvent *ev, deviceValuator * xv);
56static int eventToKeyButtonPointer(DeviceEvent *ev, xEvent **xi, int *count);
57static int eventToDeviceChanged(DeviceChangedEvent *ev, xEvent **dcce);
58static int eventToDeviceEvent(DeviceEvent *ev, xEvent **xi);
59static int eventToRawEvent(RawDeviceEvent *ev, xEvent **xi);
60static int eventToBarrierEvent(BarrierEvent *ev, xEvent **xi);
61static int eventToTouchOwnershipEvent(TouchOwnershipEvent *ev, xEvent **xi);
62static int eventToGestureSwipeEvent(GestureEvent *ev, xEvent **xi);
63static int eventToGesturePinchEvent(GestureEvent *ev, xEvent **xi);
64
65/* Do not use, read comments below */
66BOOL EventIsKeyRepeat(xEvent *event);
67
68/**
69 * Hack to allow detectable autorepeat for core and XI1 events.
70 * The sequence number is unused until we send to the client and can be
71 * misused to store data. More or less, anyway.
72 *
73 * Do not use this. It may change any time without warning, eat your babies
74 * and piss on your cat.
75 */
76static void
77EventSetKeyRepeatFlag(xEvent *event, BOOL on)
78{
79    event->u.u.sequenceNumber = on;
80}
81
82/**
83 * Check if the event was marked as a repeat event before.
84 * NOTE: This is a nasty hack and should NOT be used by anyone else but
85 * TryClientEvents.
86 */
87BOOL
88EventIsKeyRepeat(xEvent *event)
89{
90    return ! !event->u.u.sequenceNumber;
91}
92
93/**
94 * Convert the given event to the respective core event.
95 *
96 * Return values:
97 * Success ... core contains the matching core event.
98 * BadValue .. One or more values in the internal event are invalid.
99 * BadMatch .. The event has no core equivalent.
100 *
101 * @param[in] event The event to convert into a core event.
102 * @param[in] core The memory location to store the core event at.
103 * @return Success or the matching error code.
104 */
105int
106EventToCore(InternalEvent *event, xEvent **core_out, int *count_out)
107{
108    xEvent *core = NULL;
109    int count = 0;
110    int ret = BadImplementation;
111
112    switch (event->any.type) {
113    case ET_Motion:
114    {
115        DeviceEvent *e = &event->device_event;
116
117        /* Don't create core motion event if neither x nor y are
118         * present */
119        if (!BitIsOn(e->valuators.mask, 0) && !BitIsOn(e->valuators.mask, 1)) {
120            ret = BadMatch;
121            goto out;
122        }
123    }
124        /* fallthrough */
125    case ET_ButtonPress:
126    case ET_ButtonRelease:
127    case ET_KeyPress:
128    case ET_KeyRelease:
129    {
130        DeviceEvent *e = &event->device_event;
131
132        if (e->detail.key > 0xFF) {
133            ret = BadMatch;
134            goto out;
135        }
136
137        core = calloc(1, sizeof(*core));
138        if (!core)
139            return BadAlloc;
140        count = 1;
141        core->u.u.type = e->type - ET_KeyPress + KeyPress;
142        core->u.u.detail = e->detail.key & 0xFF;
143        core->u.keyButtonPointer.time = e->time;
144        core->u.keyButtonPointer.rootX = e->root_x;
145        core->u.keyButtonPointer.rootY = e->root_y;
146        core->u.keyButtonPointer.state = e->corestate;
147        core->u.keyButtonPointer.root = e->root;
148        EventSetKeyRepeatFlag(core, (e->type == ET_KeyPress && e->key_repeat));
149        ret = Success;
150    }
151        break;
152    case ET_ProximityIn:
153    case ET_ProximityOut:
154    case ET_RawKeyPress:
155    case ET_RawKeyRelease:
156    case ET_RawButtonPress:
157    case ET_RawButtonRelease:
158    case ET_RawMotion:
159    case ET_RawTouchBegin:
160    case ET_RawTouchUpdate:
161    case ET_RawTouchEnd:
162    case ET_TouchBegin:
163    case ET_TouchUpdate:
164    case ET_TouchEnd:
165    case ET_TouchOwnership:
166    case ET_BarrierHit:
167    case ET_BarrierLeave:
168    case ET_GesturePinchBegin:
169    case ET_GesturePinchUpdate:
170    case ET_GesturePinchEnd:
171    case ET_GestureSwipeBegin:
172    case ET_GestureSwipeUpdate:
173    case ET_GestureSwipeEnd:
174        ret = BadMatch;
175        break;
176    default:
177        /* XXX: */
178        ErrorF("[dix] EventToCore: Not implemented yet \n");
179        ret = BadImplementation;
180    }
181
182 out:
183    *core_out = core;
184    *count_out = count;
185    return ret;
186}
187
188/**
189 * Convert the given event to the respective XI 1.x event and store it in
190 * xi. xi is allocated on demand and must be freed by the caller.
191 * count returns the number of events in xi. If count is 1, and the type of
192 * xi is GenericEvent, then xi may be larger than 32 bytes.
193 *
194 * Return values:
195 * Success ... core contains the matching core event.
196 * BadValue .. One or more values in the internal event are invalid.
197 * BadMatch .. The event has no XI equivalent.
198 *
199 * @param[in] ev The event to convert into an XI 1 event.
200 * @param[out] xi Future memory location for the XI event.
201 * @param[out] count Number of elements in xi.
202 *
203 * @return Success or the error code.
204 */
205int
206EventToXI(InternalEvent *ev, xEvent **xi, int *count)
207{
208    switch (ev->any.type) {
209    case ET_Motion:
210    case ET_ButtonPress:
211    case ET_ButtonRelease:
212    case ET_KeyPress:
213    case ET_KeyRelease:
214    case ET_ProximityIn:
215    case ET_ProximityOut:
216        return eventToKeyButtonPointer(&ev->device_event, xi, count);
217    case ET_DeviceChanged:
218    case ET_RawKeyPress:
219    case ET_RawKeyRelease:
220    case ET_RawButtonPress:
221    case ET_RawButtonRelease:
222    case ET_RawMotion:
223    case ET_RawTouchBegin:
224    case ET_RawTouchUpdate:
225    case ET_RawTouchEnd:
226    case ET_TouchBegin:
227    case ET_TouchUpdate:
228    case ET_TouchEnd:
229    case ET_TouchOwnership:
230    case ET_BarrierHit:
231    case ET_BarrierLeave:
232    case ET_GesturePinchBegin:
233    case ET_GesturePinchUpdate:
234    case ET_GesturePinchEnd:
235    case ET_GestureSwipeBegin:
236    case ET_GestureSwipeUpdate:
237    case ET_GestureSwipeEnd:
238        *count = 0;
239        *xi = NULL;
240        return BadMatch;
241    default:
242        break;
243    }
244
245    ErrorF("[dix] EventToXI: Not implemented for %d \n", ev->any.type);
246    return BadImplementation;
247}
248
249/**
250 * Convert the given event to the respective XI 2.x event and store it in xi.
251 * xi is allocated on demand and must be freed by the caller.
252 *
253 * Return values:
254 * Success ... core contains the matching core event.
255 * BadValue .. One or more values in the internal event are invalid.
256 * BadMatch .. The event has no XI2 equivalent.
257 *
258 * @param[in] ev The event to convert into an XI2 event
259 * @param[out] xi Future memory location for the XI2 event.
260 *
261 * @return Success or the error code.
262 */
263int
264EventToXI2(InternalEvent *ev, xEvent **xi)
265{
266    switch (ev->any.type) {
267        /* Enter/FocusIn are for grabs. We don't need an actual event, since
268         * the real events delivered are triggered elsewhere */
269    case ET_Enter:
270    case ET_FocusIn:
271        *xi = NULL;
272        return Success;
273    case ET_Motion:
274    case ET_ButtonPress:
275    case ET_ButtonRelease:
276    case ET_KeyPress:
277    case ET_KeyRelease:
278    case ET_TouchBegin:
279    case ET_TouchUpdate:
280    case ET_TouchEnd:
281        return eventToDeviceEvent(&ev->device_event, xi);
282    case ET_TouchOwnership:
283        return eventToTouchOwnershipEvent(&ev->touch_ownership_event, xi);
284    case ET_ProximityIn:
285    case ET_ProximityOut:
286        *xi = NULL;
287        return BadMatch;
288    case ET_DeviceChanged:
289        return eventToDeviceChanged(&ev->changed_event, xi);
290    case ET_RawKeyPress:
291    case ET_RawKeyRelease:
292    case ET_RawButtonPress:
293    case ET_RawButtonRelease:
294    case ET_RawMotion:
295    case ET_RawTouchBegin:
296    case ET_RawTouchUpdate:
297    case ET_RawTouchEnd:
298        return eventToRawEvent(&ev->raw_event, xi);
299    case ET_BarrierHit:
300    case ET_BarrierLeave:
301        return eventToBarrierEvent(&ev->barrier_event, xi);
302    case ET_GesturePinchBegin:
303    case ET_GesturePinchUpdate:
304    case ET_GesturePinchEnd:
305        return eventToGesturePinchEvent(&ev->gesture_event, xi);
306    case ET_GestureSwipeBegin:
307    case ET_GestureSwipeUpdate:
308    case ET_GestureSwipeEnd:
309        return eventToGestureSwipeEvent(&ev->gesture_event, xi);
310    default:
311        break;
312    }
313
314    ErrorF("[dix] EventToXI2: Not implemented for %d \n", ev->any.type);
315    return BadImplementation;
316}
317
318static int
319eventToKeyButtonPointer(DeviceEvent *ev, xEvent **xi, int *count)
320{
321    int num_events;
322    int first;                  /* dummy */
323    deviceKeyButtonPointer *kbp;
324
325    /* Sorry, XI 1.x protocol restrictions. */
326    if (ev->detail.button > 0xFF || ev->deviceid >= 0x80) {
327        *count = 0;
328        return Success;
329    }
330
331    num_events = (countValuators(ev, &first) + 5) / 6;  /* valuator ev */
332    if (num_events <= 0) {
333        switch (ev->type) {
334        case ET_KeyPress:
335        case ET_KeyRelease:
336        case ET_ButtonPress:
337        case ET_ButtonRelease:
338            /* no axes is ok */
339            break;
340        case ET_Motion:
341        case ET_ProximityIn:
342        case ET_ProximityOut:
343            *count = 0;
344            return BadMatch;
345        default:
346            *count = 0;
347            return BadImplementation;
348        }
349    }
350
351    num_events++;               /* the actual event event */
352
353    *xi = calloc(num_events, sizeof(xEvent));
354    if (!(*xi)) {
355        return BadAlloc;
356    }
357
358    kbp = (deviceKeyButtonPointer *) (*xi);
359    kbp->detail = ev->detail.button;
360    kbp->time = ev->time;
361    kbp->root = ev->root;
362    kbp->root_x = ev->root_x;
363    kbp->root_y = ev->root_y;
364    kbp->deviceid = ev->deviceid;
365    kbp->state = ev->corestate;
366    EventSetKeyRepeatFlag((xEvent *) kbp,
367                          (ev->type == ET_KeyPress && ev->key_repeat));
368
369    if (num_events > 1)
370        kbp->deviceid |= MORE_EVENTS;
371
372    switch (ev->type) {
373    case ET_Motion:
374        kbp->type = DeviceMotionNotify;
375        break;
376    case ET_ButtonPress:
377        kbp->type = DeviceButtonPress;
378        break;
379    case ET_ButtonRelease:
380        kbp->type = DeviceButtonRelease;
381        break;
382    case ET_KeyPress:
383        kbp->type = DeviceKeyPress;
384        break;
385    case ET_KeyRelease:
386        kbp->type = DeviceKeyRelease;
387        break;
388    case ET_ProximityIn:
389        kbp->type = ProximityIn;
390        break;
391    case ET_ProximityOut:
392        kbp->type = ProximityOut;
393        break;
394    default:
395        break;
396    }
397
398    if (num_events > 1) {
399        getValuatorEvents(ev, (deviceValuator *) (kbp + 1));
400    }
401
402    *count = num_events;
403    return Success;
404}
405
406/**
407 * Set first to the first valuator in the event ev and return the number of
408 * valuators from first to the last set valuator.
409 */
410static int
411countValuators(DeviceEvent *ev, int *first)
412{
413    int first_valuator = -1, last_valuator = -1, num_valuators = 0;
414    int i;
415
416    for (i = 0; i < sizeof(ev->valuators.mask) * 8; i++) {
417        if (BitIsOn(ev->valuators.mask, i)) {
418            if (first_valuator == -1)
419                first_valuator = i;
420            last_valuator = i;
421        }
422    }
423
424    if (first_valuator != -1) {
425        num_valuators = last_valuator - first_valuator + 1;
426        *first = first_valuator;
427    }
428
429    return num_valuators;
430}
431
432static int
433getValuatorEvents(DeviceEvent *ev, deviceValuator * xv)
434{
435    int i;
436    int state = 0;
437    int first_valuator, num_valuators;
438
439    num_valuators = countValuators(ev, &first_valuator);
440    if (num_valuators > 0) {
441        DeviceIntPtr dev = NULL;
442
443        dixLookupDevice(&dev, ev->deviceid, serverClient, DixUseAccess);
444        /* State needs to be assembled BEFORE the device is updated. */
445        state = (dev &&
446                 dev->key) ? XkbStateFieldFromRec(&dev->key->xkbInfo->
447                                                  state) : 0;
448        state |= (dev && dev->button) ? (dev->button->state) : 0;
449    }
450
451    for (i = 0; i < num_valuators; i += 6, xv++) {
452        INT32 *valuators = &xv->valuator0;      // Treat all 6 vals as an array
453        int j;
454
455        xv->type = DeviceValuator;
456        xv->first_valuator = first_valuator + i;
457        xv->num_valuators = ((num_valuators - i) > 6) ? 6 : (num_valuators - i);
458        xv->deviceid = ev->deviceid;
459        xv->device_state = state;
460
461        /* Unset valuators in masked valuator events have the proper data values
462         * in the case of an absolute axis in between two set valuators. */
463        for (j = 0; j < xv->num_valuators; j++)
464            valuators[j] = ev->valuators.data[xv->first_valuator + j];
465
466        if (i + 6 < num_valuators)
467            xv->deviceid |= MORE_EVENTS;
468    }
469
470    return (num_valuators + 5) / 6;
471}
472
473static int
474appendKeyInfo(DeviceChangedEvent *dce, xXIKeyInfo * info)
475{
476    uint32_t *kc;
477    int i;
478
479    info->type = XIKeyClass;
480    info->num_keycodes = dce->keys.max_keycode - dce->keys.min_keycode + 1;
481    info->length = sizeof(xXIKeyInfo) / 4 + info->num_keycodes;
482    info->sourceid = dce->sourceid;
483
484    kc = (uint32_t *) &info[1];
485    for (i = 0; i < info->num_keycodes; i++)
486        *kc++ = i + dce->keys.min_keycode;
487
488    return info->length * 4;
489}
490
491static int
492appendButtonInfo(DeviceChangedEvent *dce, xXIButtonInfo * info)
493{
494    unsigned char *bits;
495    int mask_len;
496
497    mask_len = bytes_to_int32(bits_to_bytes(dce->buttons.num_buttons));
498
499    info->type = XIButtonClass;
500    info->num_buttons = dce->buttons.num_buttons;
501    info->length = bytes_to_int32(sizeof(xXIButtonInfo)) +
502        info->num_buttons + mask_len;
503    info->sourceid = dce->sourceid;
504
505    bits = (unsigned char *) &info[1];
506    memset(bits, 0, mask_len * 4);
507    /* FIXME: is_down? */
508
509    bits += mask_len * 4;
510    memcpy(bits, dce->buttons.names, dce->buttons.num_buttons * sizeof(Atom));
511
512    return info->length * 4;
513}
514
515static int
516appendValuatorInfo(DeviceChangedEvent *dce, xXIValuatorInfo * info,
517                   int axisnumber)
518{
519    info->type = XIValuatorClass;
520    info->length = sizeof(xXIValuatorInfo) / 4;
521    info->label = dce->valuators[axisnumber].name;
522    info->min.integral = dce->valuators[axisnumber].min;
523    info->min.frac = 0;
524    info->max.integral = dce->valuators[axisnumber].max;
525    info->max.frac = 0;
526    info->value = double_to_fp3232(dce->valuators[axisnumber].value);
527    info->resolution = dce->valuators[axisnumber].resolution;
528    info->number = axisnumber;
529    info->mode = dce->valuators[axisnumber].mode;
530    info->sourceid = dce->sourceid;
531
532    return info->length * 4;
533}
534
535static int
536appendScrollInfo(DeviceChangedEvent *dce, xXIScrollInfo * info, int axisnumber)
537{
538    if (dce->valuators[axisnumber].scroll.type == SCROLL_TYPE_NONE)
539        return 0;
540
541    info->type = XIScrollClass;
542    info->length = sizeof(xXIScrollInfo) / 4;
543    info->number = axisnumber;
544    switch (dce->valuators[axisnumber].scroll.type) {
545    case SCROLL_TYPE_VERTICAL:
546        info->scroll_type = XIScrollTypeVertical;
547        break;
548    case SCROLL_TYPE_HORIZONTAL:
549        info->scroll_type = XIScrollTypeHorizontal;
550        break;
551    default:
552        ErrorF("[Xi] Unknown scroll type %d. This is a bug.\n",
553               dce->valuators[axisnumber].scroll.type);
554        break;
555    }
556    info->increment =
557        double_to_fp3232(dce->valuators[axisnumber].scroll.increment);
558    info->sourceid = dce->sourceid;
559
560    info->flags = 0;
561
562    if (dce->valuators[axisnumber].scroll.flags & SCROLL_FLAG_DONT_EMULATE)
563        info->flags |= XIScrollFlagNoEmulation;
564    if (dce->valuators[axisnumber].scroll.flags & SCROLL_FLAG_PREFERRED)
565        info->flags |= XIScrollFlagPreferred;
566
567    return info->length * 4;
568}
569
570static int
571eventToDeviceChanged(DeviceChangedEvent *dce, xEvent **xi)
572{
573    xXIDeviceChangedEvent *dcce;
574    int len = sizeof(xXIDeviceChangedEvent);
575    int nkeys;
576    char *ptr;
577
578    if (dce->buttons.num_buttons) {
579        len += sizeof(xXIButtonInfo);
580        len += dce->buttons.num_buttons * sizeof(Atom); /* button names */
581        len += pad_to_int32(bits_to_bytes(dce->buttons.num_buttons));
582    }
583    if (dce->num_valuators) {
584        int i;
585
586        len += sizeof(xXIValuatorInfo) * dce->num_valuators;
587
588        for (i = 0; i < dce->num_valuators; i++)
589            if (dce->valuators[i].scroll.type != SCROLL_TYPE_NONE)
590                len += sizeof(xXIScrollInfo);
591    }
592
593    nkeys = (dce->keys.max_keycode > 0) ?
594        dce->keys.max_keycode - dce->keys.min_keycode + 1 : 0;
595    if (nkeys > 0) {
596        len += sizeof(xXIKeyInfo);
597        len += sizeof(CARD32) * nkeys;  /* keycodes */
598    }
599
600    dcce = calloc(1, len);
601    if (!dcce) {
602        ErrorF("[Xi] BadAlloc in SendDeviceChangedEvent.\n");
603        return BadAlloc;
604    }
605
606    dcce->type = GenericEvent;
607    dcce->extension = IReqCode;
608    dcce->evtype = XI_DeviceChanged;
609    dcce->time = dce->time;
610    dcce->deviceid = dce->deviceid;
611    dcce->sourceid = dce->sourceid;
612    dcce->reason =
613        (dce->flags & DEVCHANGE_DEVICE_CHANGE) ? XIDeviceChange : XISlaveSwitch;
614    dcce->num_classes = 0;
615    dcce->length = bytes_to_int32(len - sizeof(xEvent));
616
617    ptr = (char *) &dcce[1];
618    if (dce->buttons.num_buttons) {
619        dcce->num_classes++;
620        ptr += appendButtonInfo(dce, (xXIButtonInfo *) ptr);
621    }
622
623    if (nkeys) {
624        dcce->num_classes++;
625        ptr += appendKeyInfo(dce, (xXIKeyInfo *) ptr);
626    }
627
628    if (dce->num_valuators) {
629        int i;
630
631        dcce->num_classes += dce->num_valuators;
632        for (i = 0; i < dce->num_valuators; i++)
633            ptr += appendValuatorInfo(dce, (xXIValuatorInfo *) ptr, i);
634
635        for (i = 0; i < dce->num_valuators; i++) {
636            if (dce->valuators[i].scroll.type != SCROLL_TYPE_NONE) {
637                dcce->num_classes++;
638                ptr += appendScrollInfo(dce, (xXIScrollInfo *) ptr, i);
639            }
640        }
641    }
642
643    *xi = (xEvent *) dcce;
644
645    return Success;
646}
647
648static int
649count_bits(unsigned char *ptr, int len)
650{
651    int bits = 0;
652    unsigned int i;
653    unsigned char x;
654
655    for (i = 0; i < len; i++) {
656        x = ptr[i];
657        while (x > 0) {
658            bits += (x & 0x1);
659            x >>= 1;
660        }
661    }
662    return bits;
663}
664
665static int
666eventToDeviceEvent(DeviceEvent *ev, xEvent **xi)
667{
668    int len = sizeof(xXIDeviceEvent);
669    xXIDeviceEvent *xde;
670    int i, btlen, vallen;
671    char *ptr;
672    FP3232 *axisval;
673
674    /* FIXME: this should just send the buttons we have, not MAX_BUTTONs. Same
675     * with MAX_VALUATORS below */
676    /* btlen is in 4 byte units */
677    btlen = bytes_to_int32(bits_to_bytes(MAX_BUTTONS));
678    len += btlen * 4;           /* buttonmask len */
679
680    vallen = count_bits(ev->valuators.mask, ARRAY_SIZE(ev->valuators.mask));
681    len += vallen * 2 * sizeof(uint32_t);       /* axisvalues */
682    vallen = bytes_to_int32(bits_to_bytes(MAX_VALUATORS));
683    len += vallen * 4;          /* valuators mask */
684
685    *xi = calloc(1, len);
686    xde = (xXIDeviceEvent *) * xi;
687    xde->type = GenericEvent;
688    xde->extension = IReqCode;
689    xde->evtype = GetXI2Type(ev->type);
690    xde->time = ev->time;
691    xde->length = bytes_to_int32(len - sizeof(xEvent));
692    if (IsTouchEvent((InternalEvent *) ev))
693        xde->detail = ev->touchid;
694    else
695        xde->detail = ev->detail.button;
696
697    xde->root = ev->root;
698    xde->buttons_len = btlen;
699    xde->valuators_len = vallen;
700    xde->deviceid = ev->deviceid;
701    xde->sourceid = ev->sourceid;
702    xde->root_x = double_to_fp1616(ev->root_x + ev->root_x_frac);
703    xde->root_y = double_to_fp1616(ev->root_y + ev->root_y_frac);
704
705    if (IsTouchEvent((InternalEvent *)ev)) {
706        if (ev->type == ET_TouchUpdate)
707            xde->flags |= (ev->flags & TOUCH_PENDING_END) ? XITouchPendingEnd : 0;
708
709        if (ev->flags & TOUCH_POINTER_EMULATED)
710            xde->flags |= XITouchEmulatingPointer;
711    } else {
712        xde->flags = ev->flags;
713
714        if (ev->key_repeat)
715            xde->flags |= XIKeyRepeat;
716    }
717
718    xde->mods.base_mods = ev->mods.base;
719    xde->mods.latched_mods = ev->mods.latched;
720    xde->mods.locked_mods = ev->mods.locked;
721    xde->mods.effective_mods = ev->mods.effective;
722
723    xde->group.base_group = ev->group.base;
724    xde->group.latched_group = ev->group.latched;
725    xde->group.locked_group = ev->group.locked;
726    xde->group.effective_group = ev->group.effective;
727
728    ptr = (char *) &xde[1];
729    for (i = 0; i < sizeof(ev->buttons) * 8; i++) {
730        if (BitIsOn(ev->buttons, i))
731            SetBit(ptr, i);
732    }
733
734    ptr += xde->buttons_len * 4;
735    axisval = (FP3232 *) (ptr + xde->valuators_len * 4);
736    for (i = 0; i < sizeof(ev->valuators.mask) * 8; i++) {
737        if (BitIsOn(ev->valuators.mask, i)) {
738            SetBit(ptr, i);
739            *axisval = double_to_fp3232(ev->valuators.data[i]);
740            axisval++;
741        }
742    }
743
744    return Success;
745}
746
747static int
748eventToTouchOwnershipEvent(TouchOwnershipEvent *ev, xEvent **xi)
749{
750    int len = sizeof(xXITouchOwnershipEvent);
751    xXITouchOwnershipEvent *xtoe;
752
753    *xi = calloc(1, len);
754    xtoe = (xXITouchOwnershipEvent *) * xi;
755    xtoe->type = GenericEvent;
756    xtoe->extension = IReqCode;
757    xtoe->length = bytes_to_int32(len - sizeof(xEvent));
758    xtoe->evtype = GetXI2Type(ev->type);
759    xtoe->deviceid = ev->deviceid;
760    xtoe->time = ev->time;
761    xtoe->sourceid = ev->sourceid;
762    xtoe->touchid = ev->touchid;
763    xtoe->flags = 0;            /* we don't have wire flags for ownership yet */
764
765    return Success;
766}
767
768static int
769eventToRawEvent(RawDeviceEvent *ev, xEvent **xi)
770{
771    xXIRawEvent *raw;
772    int vallen, nvals;
773    int i, len = sizeof(xXIRawEvent);
774    char *ptr;
775    FP3232 *axisval, *axisval_raw;
776
777    nvals = count_bits(ev->valuators.mask, sizeof(ev->valuators.mask));
778    len += nvals * sizeof(FP3232) * 2;  /* 8 byte per valuator, once
779                                           raw, once processed */
780    vallen = bytes_to_int32(bits_to_bytes(MAX_VALUATORS));
781    len += vallen * 4;          /* valuators mask */
782
783    *xi = calloc(1, len);
784    raw = (xXIRawEvent *) * xi;
785    raw->type = GenericEvent;
786    raw->extension = IReqCode;
787    raw->evtype = GetXI2Type(ev->type);
788    raw->time = ev->time;
789    raw->length = bytes_to_int32(len - sizeof(xEvent));
790    raw->detail = ev->detail.button;
791    raw->deviceid = ev->deviceid;
792    raw->sourceid = ev->sourceid;
793    raw->valuators_len = vallen;
794    raw->flags = ev->flags;
795
796    ptr = (char *) &raw[1];
797    axisval = (FP3232 *) (ptr + raw->valuators_len * 4);
798    axisval_raw = axisval + nvals;
799    for (i = 0; i < sizeof(ev->valuators.mask) * 8; i++) {
800        if (BitIsOn(ev->valuators.mask, i)) {
801            SetBit(ptr, i);
802            *axisval = double_to_fp3232(ev->valuators.data[i]);
803            *axisval_raw = double_to_fp3232(ev->valuators.data_raw[i]);
804            axisval++;
805            axisval_raw++;
806        }
807    }
808
809    return Success;
810}
811
812static int
813eventToBarrierEvent(BarrierEvent *ev, xEvent **xi)
814{
815    xXIBarrierEvent *barrier;
816    int len = sizeof(xXIBarrierEvent);
817
818    *xi = calloc(1, len);
819    barrier = (xXIBarrierEvent*) *xi;
820    barrier->type = GenericEvent;
821    barrier->extension = IReqCode;
822    barrier->evtype = GetXI2Type(ev->type);
823    barrier->length = bytes_to_int32(len - sizeof(xEvent));
824    barrier->deviceid = ev->deviceid;
825    barrier->sourceid = ev->sourceid;
826    barrier->time = ev->time;
827    barrier->event = ev->window;
828    barrier->root = ev->root;
829    barrier->dx = double_to_fp3232(ev->dx);
830    barrier->dy = double_to_fp3232(ev->dy);
831    barrier->dtime = ev->dt;
832    barrier->flags = ev->flags;
833    barrier->eventid = ev->event_id;
834    barrier->barrier = ev->barrierid;
835    barrier->root_x = double_to_fp1616(ev->root_x);
836    barrier->root_y = double_to_fp1616(ev->root_y);
837
838    return Success;
839}
840
841int
842eventToGesturePinchEvent(GestureEvent *ev, xEvent **xi)
843{
844    int len = sizeof(xXIGesturePinchEvent);
845    xXIGesturePinchEvent *xpe;
846
847    *xi = calloc(1, len);
848    xpe = (xXIGesturePinchEvent *) * xi;
849    xpe->type = GenericEvent;
850    xpe->extension = IReqCode;
851    xpe->evtype = GetXI2Type(ev->type);
852    xpe->time = ev->time;
853    xpe->length = bytes_to_int32(len - sizeof(xEvent));
854    xpe->detail = ev->num_touches;
855
856    xpe->root = ev->root;
857    xpe->deviceid = ev->deviceid;
858    xpe->sourceid = ev->sourceid;
859    xpe->root_x = double_to_fp1616(ev->root_x);
860    xpe->root_y = double_to_fp1616(ev->root_y);
861    xpe->flags |= (ev->flags & GESTURE_CANCELLED) ? XIGesturePinchEventCancelled : 0;
862
863    xpe->delta_x = double_to_fp1616(ev->delta_x);
864    xpe->delta_y = double_to_fp1616(ev->delta_y);
865    xpe->delta_unaccel_x = double_to_fp1616(ev->delta_unaccel_x);
866    xpe->delta_unaccel_y = double_to_fp1616(ev->delta_unaccel_y);
867    xpe->scale = double_to_fp1616(ev->scale);
868    xpe->delta_angle = double_to_fp1616(ev->delta_angle);
869
870    xpe->mods.base_mods = ev->mods.base;
871    xpe->mods.latched_mods = ev->mods.latched;
872    xpe->mods.locked_mods = ev->mods.locked;
873    xpe->mods.effective_mods = ev->mods.effective;
874
875    xpe->group.base_group = ev->group.base;
876    xpe->group.latched_group = ev->group.latched;
877    xpe->group.locked_group = ev->group.locked;
878    xpe->group.effective_group = ev->group.effective;
879
880    return Success;
881}
882
883int
884eventToGestureSwipeEvent(GestureEvent *ev, xEvent **xi)
885{
886    int len = sizeof(xXIGestureSwipeEvent);
887    xXIGestureSwipeEvent *xde;
888
889    *xi = calloc(1, len);
890    xde = (xXIGestureSwipeEvent *) * xi;
891    xde->type = GenericEvent;
892    xde->extension = IReqCode;
893    xde->evtype = GetXI2Type(ev->type);
894    xde->time = ev->time;
895    xde->length = bytes_to_int32(len - sizeof(xEvent));
896    xde->detail = ev->num_touches;
897
898    xde->root = ev->root;
899    xde->deviceid = ev->deviceid;
900    xde->sourceid = ev->sourceid;
901    xde->root_x = double_to_fp1616(ev->root_x);
902    xde->root_y = double_to_fp1616(ev->root_y);
903    xde->flags |= (ev->flags & GESTURE_CANCELLED) ? XIGestureSwipeEventCancelled : 0;
904
905    xde->delta_x = double_to_fp1616(ev->delta_x);
906    xde->delta_y = double_to_fp1616(ev->delta_y);
907    xde->delta_unaccel_x = double_to_fp1616(ev->delta_unaccel_x);
908    xde->delta_unaccel_y = double_to_fp1616(ev->delta_unaccel_y);
909
910    xde->mods.base_mods = ev->mods.base;
911    xde->mods.latched_mods = ev->mods.latched;
912    xde->mods.locked_mods = ev->mods.locked;
913    xde->mods.effective_mods = ev->mods.effective;
914
915    xde->group.base_group = ev->group.base;
916    xde->group.latched_group = ev->group.latched;
917    xde->group.locked_group = ev->group.locked;
918    xde->group.effective_group = ev->group.effective;
919
920    return Success;
921}
922
923/**
924 * Return the corresponding core type for the given event or 0 if no core
925 * equivalent exists.
926 */
927int
928GetCoreType(enum EventType type)
929{
930    int coretype = 0;
931
932    switch (type) {
933    case ET_Motion:
934        coretype = MotionNotify;
935        break;
936    case ET_ButtonPress:
937        coretype = ButtonPress;
938        break;
939    case ET_ButtonRelease:
940        coretype = ButtonRelease;
941        break;
942    case ET_KeyPress:
943        coretype = KeyPress;
944        break;
945    case ET_KeyRelease:
946        coretype = KeyRelease;
947        break;
948    default:
949        break;
950    }
951    return coretype;
952}
953
954/**
955 * Return the corresponding XI 1.x type for the given event or 0 if no
956 * equivalent exists.
957 */
958int
959GetXIType(enum EventType type)
960{
961    int xitype = 0;
962
963    switch (type) {
964    case ET_Motion:
965        xitype = DeviceMotionNotify;
966        break;
967    case ET_ButtonPress:
968        xitype = DeviceButtonPress;
969        break;
970    case ET_ButtonRelease:
971        xitype = DeviceButtonRelease;
972        break;
973    case ET_KeyPress:
974        xitype = DeviceKeyPress;
975        break;
976    case ET_KeyRelease:
977        xitype = DeviceKeyRelease;
978        break;
979    case ET_ProximityIn:
980        xitype = ProximityIn;
981        break;
982    case ET_ProximityOut:
983        xitype = ProximityOut;
984        break;
985    default:
986        break;
987    }
988    return xitype;
989}
990
991/**
992 * Return the corresponding XI 2.x type for the given event or 0 if no
993 * equivalent exists.
994 */
995int
996GetXI2Type(enum EventType type)
997{
998    int xi2type = 0;
999
1000    switch (type) {
1001    case ET_Motion:
1002        xi2type = XI_Motion;
1003        break;
1004    case ET_ButtonPress:
1005        xi2type = XI_ButtonPress;
1006        break;
1007    case ET_ButtonRelease:
1008        xi2type = XI_ButtonRelease;
1009        break;
1010    case ET_KeyPress:
1011        xi2type = XI_KeyPress;
1012        break;
1013    case ET_KeyRelease:
1014        xi2type = XI_KeyRelease;
1015        break;
1016    case ET_Enter:
1017        xi2type = XI_Enter;
1018        break;
1019    case ET_Leave:
1020        xi2type = XI_Leave;
1021        break;
1022    case ET_Hierarchy:
1023        xi2type = XI_HierarchyChanged;
1024        break;
1025    case ET_DeviceChanged:
1026        xi2type = XI_DeviceChanged;
1027        break;
1028    case ET_RawKeyPress:
1029        xi2type = XI_RawKeyPress;
1030        break;
1031    case ET_RawKeyRelease:
1032        xi2type = XI_RawKeyRelease;
1033        break;
1034    case ET_RawButtonPress:
1035        xi2type = XI_RawButtonPress;
1036        break;
1037    case ET_RawButtonRelease:
1038        xi2type = XI_RawButtonRelease;
1039        break;
1040    case ET_RawMotion:
1041        xi2type = XI_RawMotion;
1042        break;
1043    case ET_RawTouchBegin:
1044        xi2type = XI_RawTouchBegin;
1045        break;
1046    case ET_RawTouchUpdate:
1047        xi2type = XI_RawTouchUpdate;
1048        break;
1049    case ET_RawTouchEnd:
1050        xi2type = XI_RawTouchEnd;
1051        break;
1052    case ET_FocusIn:
1053        xi2type = XI_FocusIn;
1054        break;
1055    case ET_FocusOut:
1056        xi2type = XI_FocusOut;
1057        break;
1058    case ET_TouchBegin:
1059        xi2type = XI_TouchBegin;
1060        break;
1061    case ET_TouchEnd:
1062        xi2type = XI_TouchEnd;
1063        break;
1064    case ET_TouchUpdate:
1065        xi2type = XI_TouchUpdate;
1066        break;
1067    case ET_TouchOwnership:
1068        xi2type = XI_TouchOwnership;
1069        break;
1070    case ET_BarrierHit:
1071        xi2type = XI_BarrierHit;
1072        break;
1073    case ET_BarrierLeave:
1074        xi2type = XI_BarrierLeave;
1075        break;
1076    case ET_GesturePinchBegin:
1077        xi2type = XI_GesturePinchBegin;
1078        break;
1079    case ET_GesturePinchUpdate:
1080        xi2type = XI_GesturePinchUpdate;
1081        break;
1082    case ET_GesturePinchEnd:
1083        xi2type = XI_GesturePinchEnd;
1084        break;
1085    case ET_GestureSwipeBegin:
1086        xi2type = XI_GestureSwipeBegin;
1087        break;
1088    case ET_GestureSwipeUpdate:
1089        xi2type = XI_GestureSwipeUpdate;
1090        break;
1091    case ET_GestureSwipeEnd:
1092        xi2type = XI_GestureSwipeEnd;
1093        break;
1094    default:
1095        break;
1096    }
1097    return xi2type;
1098}
1099
1100/**
1101 * Converts a gesture type to corresponding Gesture{Pinch,Swipe}Begin.
1102 * Returns 0 if the input type is not a gesture.
1103 */
1104enum EventType
1105GestureTypeToBegin(enum EventType type)
1106{
1107    switch (type) {
1108    case ET_GesturePinchBegin:
1109    case ET_GesturePinchUpdate:
1110    case ET_GesturePinchEnd:
1111        return ET_GesturePinchBegin;
1112    case ET_GestureSwipeBegin:
1113    case ET_GestureSwipeUpdate:
1114    case ET_GestureSwipeEnd:
1115        return ET_GestureSwipeBegin;
1116    default:
1117        return 0;
1118    }
1119}
1120
1121/**
1122 * Converts a gesture type to corresponding Gesture{Pinch,Swipe}End.
1123 * Returns 0 if the input type is not a gesture.
1124 */
1125enum EventType
1126GestureTypeToEnd(enum EventType type)
1127{
1128    switch (type) {
1129    case ET_GesturePinchBegin:
1130    case ET_GesturePinchUpdate:
1131    case ET_GesturePinchEnd:
1132        return ET_GesturePinchEnd;
1133    case ET_GestureSwipeBegin:
1134    case ET_GestureSwipeUpdate:
1135    case ET_GestureSwipeEnd:
1136        return ET_GestureSwipeEnd;
1137    default:
1138        return 0;
1139    }
1140}
1141