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