1/************************************************************
2
3Copyright 1987, 1998  The Open Group
4
5Permission to use, copy, modify, distribute, and sell this software and its
6documentation for any purpose is hereby granted without fee, provided that
7the above copyright notice appear in all copies and that both that
8copyright notice and this permission notice appear in supporting
9documentation.
10
11The above copyright notice and this permission notice shall be included in
12all copies or substantial portions of the Software.
13
14THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
17OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
18AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
19CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
20
21Except as contained in this notice, the name of The Open Group shall not be
22used in advertising or otherwise to promote the sale, use or other dealings
23in this Software without prior written authorization from The Open Group.
24
25Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
26
27                        All Rights Reserved
28
29Permission to use, copy, modify, and distribute this software and its
30documentation for any purpose and without fee is hereby granted,
31provided that the above copyright notice appear in all copies and that
32both that copyright notice and this permission notice appear in
33supporting documentation, and that the name of Digital not be
34used in advertising or publicity pertaining to distribution of the
35software without specific, written prior permission.
36
37DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
38ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
39DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
40ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
41WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
42ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
43SOFTWARE.
44
45********************************************************/
46
47#ifndef INPUTSTRUCT_H
48#define INPUTSTRUCT_H
49
50#include <X11/extensions/XI2proto.h>
51
52#include <pixman.h>
53#include "input.h"
54#include "window.h"
55#include "dixstruct.h"
56#include "cursorstr.h"
57#include "geext.h"
58#include "privates.h"
59
60extern _X_EXPORT void AssignTypeAndName(DeviceIntPtr dev,
61                                        Atom type,
62                                        const char *name);
63
64#define BitIsOn(ptr, bit) (!!(((const BYTE *) (ptr))[(bit)>>3] & (1 << ((bit) & 7))))
65#define SetBit(ptr, bit)  (((BYTE *) (ptr))[(bit)>>3] |= (1 << ((bit) & 7)))
66#define ClearBit(ptr, bit) (((BYTE *)(ptr))[(bit)>>3] &= ~(1 << ((bit) & 7)))
67extern _X_EXPORT int CountBits(const uint8_t * mask, int len);
68
69#define SameClient(obj,client) \
70	(CLIENT_BITS((obj)->resource) == (client)->clientAsMask)
71
72#define EMASKSIZE	(MAXDEVICES + 2)
73
74/* This is the last XI2 event supported by the server. If you add
75 * events to the protocol, the server will not support these events until
76 * this number here is bumped.
77 */
78#define XI2LASTEVENT    XI_GestureSwipeEnd
79#define XI2MASKSIZE     ((XI2LASTEVENT >> 3) + 1)       /* no of bytes for masks */
80
81/**
82 * Scroll types for ::SetScrollValuator and the scroll type in the
83 * ::ScrollInfoPtr.
84 */
85enum ScrollType {
86    SCROLL_TYPE_NONE = 0,           /**< Not a scrolling valuator */
87    SCROLL_TYPE_VERTICAL = 8,
88    SCROLL_TYPE_HORIZONTAL = 9,
89};
90
91/**
92 * This struct stores the core event mask for each client except the client
93 * that created the window.
94 *
95 * Each window that has events selected from other clients has at least one of
96 * these masks. If multiple clients selected for events on the same window,
97 * these masks are in a linked list.
98 *
99 * The event mask for the client that created the window is stored in
100 * win->eventMask instead.
101 *
102 * The resource id is simply a fake client ID to associate this mask with a
103 * client.
104 *
105 * Kludge: OtherClients and InputClients must be compatible, see code.
106 */
107typedef struct _OtherClients {
108    OtherClientsPtr next;     /**< Pointer to the next mask */
109    XID resource;                 /**< id for putting into resource manager */
110    Mask mask;                /**< Core event mask */
111} OtherClients;
112
113/**
114 * This struct stores the XI event mask for each client.
115 *
116 * Each window that has events selected has at least one of these masks. If
117 * multiple client selected for events on the same window, these masks are in
118 * a linked list.
119 */
120typedef struct _InputClients {
121    InputClientsPtr next;     /**< Pointer to the next mask */
122    XID resource;                 /**< id for putting into resource manager */
123    Mask mask[EMASKSIZE];                /**< Actual XI event mask, deviceid is index */
124    /** XI2 event masks. One per device, each bit is a mask of (1 << type) */
125    struct _XI2Mask *xi2mask;
126} InputClients;
127
128/**
129 * Combined XI event masks from all devices.
130 *
131 * This is the XI equivalent of the deliverableEvents, eventMask and
132 * dontPropagate mask of the WindowRec (or WindowOptRec).
133 *
134 * A window that has an XI client selecting for events has exactly one
135 * OtherInputMasks struct and exactly one InputClients struct hanging off
136 * inputClients. Each further client appends to the inputClients list.
137 * Each Mask field is per-device, with the device id as the index.
138 * Exception: for non-device events (Presence events), the MAXDEVICES
139 * deviceid is used.
140 */
141typedef struct _OtherInputMasks {
142    /**
143     * Bitwise OR of all masks by all clients and the window's parent's masks.
144     */
145    Mask deliverableEvents[EMASKSIZE];
146    /**
147     * Bitwise OR of all masks by all clients on this window.
148     */
149    Mask inputEvents[EMASKSIZE];
150    /** The do-not-propagate masks for each device. */
151    Mask dontPropagateMask[EMASKSIZE];
152    /** The clients that selected for events */
153    InputClientsPtr inputClients;
154    /* XI2 event masks. One per device, each bit is a mask of (1 << type) */
155    struct _XI2Mask *xi2mask;
156} OtherInputMasks;
157
158/*
159 * The following structure gets used for both active and passive grabs. For
160 * active grabs some of the fields (e.g. modifiers) are not used. However,
161 * that is not much waste since there aren't many active grabs (one per
162 * keyboard/pointer device) going at once in the server.
163 */
164
165#define MasksPerDetailMask 8    /* 256 keycodes and 256 possible
166                                   modifier combinations, but only
167                                   3 buttons. */
168
169typedef struct _DetailRec {     /* Grab details may be bit masks */
170    unsigned int exact;
171    Mask *pMask;
172} DetailRec;
173
174union _GrabMask {
175    Mask core;
176    Mask xi;
177    struct _XI2Mask *xi2mask;
178};
179
180/**
181 * Central struct for device grabs.
182 * The same struct is used for both core grabs and device grabs, with
183 * different fields being set.
184 * If the grab is a core grab (GrabPointer/GrabKeyboard), then the eventMask
185 * is a combination of standard event masks (i.e. PointerMotionMask |
186 * ButtonPressMask).
187 * If the grab is a device grab (GrabDevice), then the eventMask is a
188 * combination of event masks for a given XI event type (see SetEventInfo).
189 *
190 * If the grab is a result of a ButtonPress, then eventMask is the core mask
191 * and deviceMask is set to the XI event mask for the grab.
192 */
193typedef struct _GrabRec {
194    GrabPtr next;               /* for chain of passive grabs */
195    XID resource;
196    DeviceIntPtr device;
197    WindowPtr window;
198    unsigned ownerEvents:1;
199    unsigned keyboardMode:1;
200    unsigned pointerMode:1;
201    enum InputLevel grabtype;
202    CARD8 type;                 /* event type for passive grabs, 0 for active grabs */
203    DetailRec modifiersDetail;
204    DeviceIntPtr modifierDevice;
205    DetailRec detail;           /* key or button */
206    WindowPtr confineTo;        /* always NULL for keyboards */
207    CursorPtr cursor;           /* always NULL for keyboards */
208    Mask eventMask;
209    Mask deviceMask;
210    /* XI2 event masks. One per device, each bit is a mask of (1 << type) */
211    struct _XI2Mask *xi2mask;
212} GrabRec;
213
214/**
215 * Sprite information for a device.
216 */
217typedef struct _SpriteRec {
218    CursorPtr current;
219    BoxRec hotLimits;           /* logical constraints of hot spot */
220    Bool confined;              /* confined to screen */
221    RegionPtr hotShape;         /* additional logical shape constraint */
222    BoxRec physLimits;          /* physical constraints of hot spot */
223    WindowPtr win;              /* window of logical position */
224    HotSpot hot;                /* logical pointer position */
225    HotSpot hotPhys;            /* physical pointer position */
226#ifdef PANORAMIX
227    ScreenPtr screen;           /* all others are in Screen 0 coordinates */
228    RegionRec Reg1;             /* Region 1 for confining motion */
229    RegionRec Reg2;             /* Region 2 for confining virtual motion */
230    WindowPtr windows[MAXSCREENS];
231    WindowPtr confineWin;       /* confine window */
232#endif
233    /* The window trace information is used at dix/events.c to avoid having
234     * to compute all the windows between the root and the current pointer
235     * window each time a button or key goes down. The grabs on each of those
236     * windows must be checked.
237     * spriteTraces should only be used at dix/events.c! */
238    WindowPtr *spriteTrace;
239    int spriteTraceSize;
240    int spriteTraceGood;
241
242    /* Due to delays between event generation and event processing, it is
243     * possible that the pointer has crossed screen boundaries between the
244     * time in which it begins generating events and the time when
245     * those events are processed.
246     *
247     * pEnqueueScreen: screen the pointer was on when the event was generated
248     * pDequeueScreen: screen the pointer was on when the event is processed
249     */
250    ScreenPtr pEnqueueScreen;
251    ScreenPtr pDequeueScreen;
252
253} SpriteRec;
254
255typedef struct _KeyClassRec {
256    int sourceid;
257    CARD8 down[DOWN_LENGTH];
258    CARD8 postdown[DOWN_LENGTH];
259    int modifierKeyCount[8];
260    struct _XkbSrvInfo *xkbInfo;
261} KeyClassRec, *KeyClassPtr;
262
263typedef struct _ScrollInfo {
264    enum ScrollType type;
265    double increment;
266    int flags;
267} ScrollInfo, *ScrollInfoPtr;
268
269typedef struct _AxisInfo {
270    int resolution;
271    int min_resolution;
272    int max_resolution;
273    int min_value;
274    int max_value;
275    Atom label;
276    CARD8 mode;
277    ScrollInfo scroll;
278} AxisInfo, *AxisInfoPtr;
279
280typedef struct _ValuatorAccelerationRec {
281    int number;
282    PointerAccelSchemeProc AccelSchemeProc;
283    void *accelData;            /* at disposal of AccelScheme */
284    PointerAccelSchemeInitProc AccelInitProc;
285    DeviceCallbackProc AccelCleanupProc;
286} ValuatorAccelerationRec, *ValuatorAccelerationPtr;
287
288typedef struct _ValuatorClassRec {
289    int sourceid;
290    int numMotionEvents;
291    int first_motion;
292    int last_motion;
293    void *motion;               /* motion history buffer. Different layout
294                                   for MDs and SDs! */
295    WindowPtr motionHintWindow;
296
297    AxisInfoPtr axes;
298    unsigned short numAxes;
299    double *axisVal;            /* always absolute, but device-coord system */
300    ValuatorAccelerationRec accelScheme;
301    int h_scroll_axis;          /* horiz smooth-scrolling axis */
302    int v_scroll_axis;          /* vert smooth-scrolling axis */
303} ValuatorClassRec;
304
305typedef struct _TouchListener {
306    XID listener;           /* grabs/event selection IDs receiving
307                             * events for this touch */
308    int resource_type;      /* listener's resource type */
309    enum TouchListenerType type;
310    enum TouchListenerState state;
311    enum InputLevel level;  /* matters only for emulating touches */
312    WindowPtr window;
313    GrabPtr grab;
314} TouchListener;
315
316typedef struct _TouchPointInfo {
317    uint32_t client_id;         /* touch ID as seen in client events */
318    int sourceid;               /* Source device's ID for this touchpoint */
319    Bool active;                /* whether or not the touch is active */
320    Bool pending_finish;        /* true if the touch is physically inactive
321                                 * but still owned by a grab */
322    SpriteRec sprite;           /* window trace for delivery */
323    ValuatorMask *valuators;    /* last recorded axis values */
324    TouchListener *listeners;   /* set of listeners */
325    int num_listeners;
326    int num_grabs;              /* number of open grabs on this touch
327                                 * which have not accepted or rejected */
328    Bool emulate_pointer;
329    DeviceEvent *history;       /* History of events on this touchpoint */
330    size_t history_elements;    /* Number of current elements in history */
331    size_t history_size;        /* Size of history in elements */
332} TouchPointInfoRec;
333
334typedef struct _DDXTouchPointInfo {
335    uint32_t client_id;         /* touch ID as seen in client events */
336    Bool active;                /* whether or not the touch is active */
337    uint32_t ddx_id;            /* touch ID given by the DDX */
338    Bool emulate_pointer;
339
340    ValuatorMask *valuators;    /* last axis values as posted, pre-transform */
341} DDXTouchPointInfoRec;
342
343typedef struct _TouchClassRec {
344    int sourceid;
345    TouchPointInfoPtr touches;
346    unsigned short num_touches; /* number of allocated touches */
347    unsigned short max_touches; /* maximum number of touches, may be 0 */
348    CARD8 mode;                 /* ::XIDirectTouch, XIDependentTouch */
349    /* for pointer-emulation */
350    CARD8 buttonsDown;          /* number of buttons down */
351    unsigned short state;       /* logical button state */
352    Mask motionMask;
353} TouchClassRec;
354
355typedef struct _GestureListener {
356    XID listener;           /* grabs/event selection IDs receiving
357                             * events for this gesture */
358    int resource_type;      /* listener's resource type */
359    enum GestureListenerType type;
360    WindowPtr window;
361    GrabPtr grab;
362} GestureListener;
363
364typedef struct _GestureInfo {
365    int sourceid;               /* Source device's ID for this gesture */
366    Bool active;                /* whether or not the gesture is active */
367    uint8_t type;               /* Gesture type: either ET_GesturePinchBegin or
368                                   ET_GestureSwipeBegin. Valid if active == TRUE */
369    int num_touches;            /* The number of touches in the gesture */
370    SpriteRec sprite;           /* window trace for delivery */
371    GestureListener listener;   /* the listener that will receive events */
372    Bool has_listener;          /* true if listener has been setup already */
373} GestureInfoRec;
374
375typedef struct _GestureClassRec {
376    int sourceid;
377    GestureInfoRec gesture;
378    unsigned short max_touches; /* maximum number of touches, may be 0 */
379} GestureClassRec;
380
381typedef struct _ButtonClassRec {
382    int sourceid;
383    CARD8 numButtons;
384    CARD8 buttonsDown;          /* number of buttons currently down
385                                   This counts logical buttons, not
386                                   physical ones, i.e if some buttons
387                                   are mapped to 0, they're not counted
388                                   here */
389    unsigned short state;
390    Mask motionMask;
391    CARD8 down[DOWN_LENGTH];
392    CARD8 postdown[DOWN_LENGTH];
393    CARD8 map[MAP_LENGTH];
394    union _XkbAction *xkb_acts;
395    Atom labels[MAX_BUTTONS];
396} ButtonClassRec, *ButtonClassPtr;
397
398typedef struct _FocusClassRec {
399    int sourceid;
400    WindowPtr win;              /* May be set to a int constant (e.g. PointerRootWin)! */
401    int revert;
402    TimeStamp time;
403    WindowPtr *trace;
404    int traceSize;
405    int traceGood;
406} FocusClassRec, *FocusClassPtr;
407
408typedef struct _ProximityClassRec {
409    int sourceid;
410    char in_proximity;
411} ProximityClassRec, *ProximityClassPtr;
412
413typedef struct _KbdFeedbackClassRec *KbdFeedbackPtr;
414typedef struct _PtrFeedbackClassRec *PtrFeedbackPtr;
415typedef struct _IntegerFeedbackClassRec *IntegerFeedbackPtr;
416typedef struct _StringFeedbackClassRec *StringFeedbackPtr;
417typedef struct _BellFeedbackClassRec *BellFeedbackPtr;
418typedef struct _LedFeedbackClassRec *LedFeedbackPtr;
419
420typedef struct _KbdFeedbackClassRec {
421    BellProcPtr BellProc;
422    KbdCtrlProcPtr CtrlProc;
423    KeybdCtrl ctrl;
424    KbdFeedbackPtr next;
425    struct _XkbSrvLedInfo *xkb_sli;
426} KbdFeedbackClassRec;
427
428typedef struct _PtrFeedbackClassRec {
429    PtrCtrlProcPtr CtrlProc;
430    PtrCtrl ctrl;
431    PtrFeedbackPtr next;
432} PtrFeedbackClassRec;
433
434typedef struct _IntegerFeedbackClassRec {
435    IntegerCtrlProcPtr CtrlProc;
436    IntegerCtrl ctrl;
437    IntegerFeedbackPtr next;
438} IntegerFeedbackClassRec;
439
440typedef struct _StringFeedbackClassRec {
441    StringCtrlProcPtr CtrlProc;
442    StringCtrl ctrl;
443    StringFeedbackPtr next;
444} StringFeedbackClassRec;
445
446typedef struct _BellFeedbackClassRec {
447    BellProcPtr BellProc;
448    BellCtrlProcPtr CtrlProc;
449    BellCtrl ctrl;
450    BellFeedbackPtr next;
451} BellFeedbackClassRec;
452
453typedef struct _LedFeedbackClassRec {
454    LedCtrlProcPtr CtrlProc;
455    LedCtrl ctrl;
456    LedFeedbackPtr next;
457    struct _XkbSrvLedInfo *xkb_sli;
458} LedFeedbackClassRec;
459
460typedef struct _ClassesRec {
461    KeyClassPtr key;
462    ValuatorClassPtr valuator;
463    TouchClassPtr touch;
464    GestureClassPtr gesture;
465    ButtonClassPtr button;
466    FocusClassPtr focus;
467    ProximityClassPtr proximity;
468    KbdFeedbackPtr kbdfeed;
469    PtrFeedbackPtr ptrfeed;
470    IntegerFeedbackPtr intfeed;
471    StringFeedbackPtr stringfeed;
472    BellFeedbackPtr bell;
473    LedFeedbackPtr leds;
474} ClassesRec;
475
476/* Device properties */
477typedef struct _XIPropertyValue {
478    Atom type;                  /* ignored by server */
479    short format;               /* format of data for swapping - 8,16,32 */
480    long size;                  /* size of data in (format/8) bytes */
481    void *data;                 /* private to client */
482} XIPropertyValueRec;
483
484typedef struct _XIProperty {
485    struct _XIProperty *next;
486    Atom propertyName;
487    BOOL deletable;             /* clients can delete this prop? */
488    XIPropertyValueRec value;
489} XIPropertyRec;
490
491typedef XIPropertyRec *XIPropertyPtr;
492typedef XIPropertyValueRec *XIPropertyValuePtr;
493
494typedef struct _XIPropertyHandler {
495    struct _XIPropertyHandler *next;
496    long id;
497    int (*SetProperty) (DeviceIntPtr dev,
498                        Atom property, XIPropertyValuePtr prop, BOOL checkonly);
499    int (*GetProperty) (DeviceIntPtr dev, Atom property);
500    int (*DeleteProperty) (DeviceIntPtr dev, Atom property);
501} XIPropertyHandler, *XIPropertyHandlerPtr;
502
503/* states for devices */
504
505#define NOT_GRABBED		0
506#define THAWED			1
507#define THAWED_BOTH		2       /* not a real state */
508#define FREEZE_NEXT_EVENT	3
509#define FREEZE_BOTH_NEXT_EVENT	4
510#define FROZEN			5       /* any state >= has device frozen */
511#define FROZEN_NO_EVENT		5
512#define FROZEN_WITH_EVENT	6
513#define THAW_OTHERS		7
514
515typedef struct _GrabInfoRec {
516    TimeStamp grabTime;
517    Bool fromPassiveGrab;       /* true if from passive grab */
518    Bool implicitGrab;          /* implicit from ButtonPress */
519    GrabPtr unused;             /* Kept for ABI stability, remove soon */
520    GrabPtr grab;
521    CARD8 activatingKey;
522    void (*ActivateGrab) (DeviceIntPtr /*device */ ,
523                          GrabPtr /*grab */ ,
524                          TimeStamp /*time */ ,
525                          Bool /*autoGrab */ );
526    void (*DeactivateGrab) (DeviceIntPtr /*device */ );
527    struct {
528        Bool frozen;
529        int state;
530        GrabPtr other;          /* if other grab has this frozen */
531        InternalEvent *event;   /* saved to be replayed */
532    } sync;
533} GrabInfoRec, *GrabInfoPtr;
534
535typedef struct _SpriteInfoRec {
536    /* sprite must always point to a valid sprite. For devices sharing the
537     * sprite, let sprite point to a paired spriteOwner's sprite. */
538    SpritePtr sprite;           /* sprite information */
539    Bool spriteOwner;           /* True if device owns the sprite */
540    DeviceIntPtr paired;        /* The paired device. Keyboard if
541                                   spriteOwner is TRUE, otherwise the
542                                   pointer that owns the sprite. */
543
544    /* keep states for animated cursor */
545    struct {
546        CursorPtr pCursor;
547        ScreenPtr pScreen;
548        int elt;
549    } anim;
550} SpriteInfoRec, *SpriteInfoPtr;
551
552/* device types */
553#define MASTER_POINTER          1
554#define MASTER_KEYBOARD         2
555#define SLAVE                   3
556/* special types for GetMaster */
557#define MASTER_ATTACHED         4       /* Master for this device */
558#define KEYBOARD_OR_FLOAT       5       /* Keyboard master for this device or this device if floating */
559#define POINTER_OR_FLOAT        6       /* Pointer master for this device or this device if floating */
560
561typedef struct _DeviceIntRec {
562    DeviceRec public;
563    DeviceIntPtr next;
564    Bool startup;               /* true if needs to be turned on at
565                                   server initialization time */
566    DeviceProc deviceProc;      /* proc(DevicePtr, DEVICE_xx). It is
567                                   used to initialize, turn on, or
568                                   turn off the device */
569    Bool inited;                /* TRUE if INIT returns Success */
570    Bool enabled;               /* TRUE if ON returns Success */
571    Bool coreEvents;            /* TRUE if device also sends core */
572    GrabInfoRec deviceGrab;     /* grab on the device */
573    int type;                   /* MASTER_POINTER, MASTER_KEYBOARD, SLAVE */
574    Atom xinput_type;
575    char *name;
576    int id;
577    KeyClassPtr key;
578    ValuatorClassPtr valuator;
579    TouchClassPtr touch;
580    GestureClassPtr gesture;
581    ButtonClassPtr button;
582    FocusClassPtr focus;
583    ProximityClassPtr proximity;
584    KbdFeedbackPtr kbdfeed;
585    PtrFeedbackPtr ptrfeed;
586    IntegerFeedbackPtr intfeed;
587    StringFeedbackPtr stringfeed;
588    BellFeedbackPtr bell;
589    LedFeedbackPtr leds;
590    struct _XkbInterest *xkb_interest;
591    char *config_info;          /* used by the hotplug layer */
592    ClassesPtr unused_classes;  /* for master devices */
593    int saved_master_id;        /* for slaves while grabbed */
594    PrivateRec *devPrivates;
595    DeviceUnwrapProc unwrapProc;
596    SpriteInfoPtr spriteInfo;
597    DeviceIntPtr master;        /* master device */
598    DeviceIntPtr lastSlave;     /* last slave device used */
599
600    /* last valuator values recorded, not posted to client;
601     * for slave devices, valuators is in device coordinates, mapped to the
602     * desktop
603     * for master devices, valuators is in desktop coordinates.
604     * see dix/getevents.c
605     * remainder supports acceleration
606     */
607    struct {
608        double valuators[MAX_VALUATORS];
609        int numValuators;
610        DeviceIntPtr slave;
611        ValuatorMask *scroll;
612        int num_touches;        /* size of the touches array */
613        DDXTouchPointInfoPtr touches;
614    } last;
615
616    /* Input device property handling. */
617    struct {
618        XIPropertyPtr properties;
619        XIPropertyHandlerPtr handlers;  /* NULL-terminated */
620    } properties;
621
622    /* coordinate transformation matrix for relative movement. Matrix with
623     * the translation component dropped */
624    struct pixman_f_transform relative_transform;
625    /* scale matrix for absolute devices, this is the combined matrix of
626       [1/scale] . [transform] . [scale]. See DeviceSetTransform */
627    struct pixman_f_transform scale_and_transform;
628
629    /* XTest related master device id */
630    int xtest_master_id;
631
632    struct _SyncCounter *idle_counter;
633} DeviceIntRec;
634
635typedef struct {
636    int numDevices;             /* total number of devices */
637    DeviceIntPtr devices;       /* all devices turned on */
638    DeviceIntPtr off_devices;   /* all devices turned off */
639    DeviceIntPtr keyboard;      /* the main one for the server */
640    DeviceIntPtr pointer;
641    DeviceIntPtr all_devices;
642    DeviceIntPtr all_master_devices;
643} InputInfo;
644
645extern _X_EXPORT InputInfo inputInfo;
646
647/* for keeping the events for devices grabbed synchronously */
648typedef struct _QdEvent *QdEventPtr;
649typedef struct _QdEvent {
650    struct xorg_list next;
651    DeviceIntPtr device;
652    ScreenPtr pScreen;          /* what screen the pointer was on */
653    unsigned long months;       /* milliseconds is in the event */
654    InternalEvent *event;
655} QdEventRec;
656
657/**
658 * syncEvents is the global structure for queued events.
659 *
660 * Devices can be frozen through GrabModeSync pointer grabs. If this is the
661 * case, events from these devices are added to "pending" instead of being
662 * processed normally. When the device is unfrozen, events in "pending" are
663 * replayed and processed as if they would come from the device directly.
664 */
665typedef struct _EventSyncInfo {
666    struct xorg_list pending;
667
668    /** The device to replay events for. Only set in AllowEvents(), in which
669     * case it is set to the device specified in the request. */
670    DeviceIntPtr replayDev;     /* kludgy rock to put flag for */
671
672    /**
673     * The window the events are supposed to be replayed on.
674     * This window may be set to the grab's window (but only when
675     * Replay{Pointer|Keyboard} is given in the XAllowEvents()
676     * request. */
677    WindowPtr replayWin;        /*   ComputeFreezes            */
678    /**
679     * Flag to indicate whether we're in the process of
680     * replaying events. Only set in ComputeFreezes(). */
681    Bool playingEvents;
682    TimeStamp time;
683} EventSyncInfoRec, *EventSyncInfoPtr;
684
685extern EventSyncInfoRec syncEvents;
686
687/**
688 * Given a sprite, returns the window at the bottom of the trace (i.e. the
689 * furthest window from the root).
690 */
691static inline WindowPtr
692DeepestSpriteWin(SpritePtr sprite)
693{
694    assert(sprite->spriteTraceGood > 0);
695    return sprite->spriteTrace[sprite->spriteTraceGood - 1];
696}
697
698struct _XI2Mask {
699    unsigned char **masks;      /* event mask in masks[deviceid][event type byte] */
700    size_t nmasks;              /* number of masks */
701    size_t mask_size;           /* size of each mask in bytes */
702};
703
704#endif                          /* INPUTSTRUCT_H */
705