1 /************************************************************
2 
3 Copyright 1989, 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 1989 by Hewlett-Packard Company, Palo Alto, California.
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 Hewlett-Packard not be
34 used in advertising or publicity pertaining to distribution of the
35 software without specific, written prior permission.
36 
37 HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
38 ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
39 HEWLETT-PACKARD 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 _XIPROTO_H
48 #define _XIPROTO_H
49 
50 #include <X11/Xproto.h>
51 #include <X11/X.h>
52 
53 /* make sure types have right sizes for protocol structures. */
54 #define Window CARD32
55 #define Time CARD32
56 #define KeyCode CARD8
57 #define Mask CARD32
58 #define Atom CARD32
59 #define Cursor CARD32
60 
61 /*********************************************************
62  *
63  * number of events, errors, and extension name.
64  *
65  */
66 
67 #define MORE_EVENTS	0x80
68 #define DEVICE_BITS	0x7F
69 
70 #define InputClassBits	0x3F	/* bits in mode field for input classes */
71 #define ModeBitsShift	6	/* amount to shift the remaining bits   */
72 
73 #define numInputClasses 7
74 
75 #define IEVENTS         17       /* does NOT include generic events */
76 #define IERRORS         5
77 #define IREQUESTS       39
78 
79 #define CLIENT_REQ      1
80 
81 typedef struct  _XExtEventInfo
82     {
83     Mask	mask;
84     BYTE	type;
85     BYTE	word;
86     } XExtEventInfo;
87 
88 #ifndef _XITYPEDEF_POINTER
89 typedef void *Pointer;
90 #endif
91 
92 struct tmask
93     {
94     Mask	mask;
95     void        *dev;
96     };
97 
98 /*********************************************************
99  *
100  * Event constants used by library.
101  *
102  */
103 
104 #define XI_DeviceValuator		0
105 #define XI_DeviceKeyPress		1
106 #define XI_DeviceKeyRelease		2
107 #define XI_DeviceButtonPress		3
108 #define XI_DeviceButtonRelease		4
109 #define XI_DeviceMotionNotify		5
110 #define XI_DeviceFocusIn		6
111 #define XI_DeviceFocusOut		7
112 #define XI_ProximityIn			8
113 #define XI_ProximityOut			9
114 #define XI_DeviceStateNotify		10
115 #define XI_DeviceMappingNotify		11
116 #define XI_ChangeDeviceNotify		12
117 #define XI_DeviceKeystateNotify		13
118 #define XI_DeviceButtonstateNotify	14
119 #define XI_DevicePresenceNotify		15
120 #define XI_DevicePropertyNotify         16
121 
122 /*********************************************************
123  *
124  * Protocol request constants
125  *
126  */
127 
128 #define X_GetExtensionVersion		1
129 #define X_ListInputDevices		2
130 #define X_OpenDevice			3
131 #define X_CloseDevice			4
132 #define X_SetDeviceMode			5
133 #define X_SelectExtensionEvent		6
134 #define X_GetSelectedExtensionEvents	7
135 #define X_ChangeDeviceDontPropagateList 8
136 #define X_GetDeviceDontPropagateList	9
137 #define X_GetDeviceMotionEvents		10
138 #define X_ChangeKeyboardDevice		11
139 #define X_ChangePointerDevice		12
140 #define X_GrabDevice			13
141 #define X_UngrabDevice			14
142 #define X_GrabDeviceKey			15
143 #define X_UngrabDeviceKey		16
144 #define X_GrabDeviceButton		17
145 #define X_UngrabDeviceButton		18
146 #define X_AllowDeviceEvents		19
147 #define X_GetDeviceFocus		20
148 #define X_SetDeviceFocus		21
149 #define X_GetFeedbackControl		22
150 #define X_ChangeFeedbackControl		23
151 #define X_GetDeviceKeyMapping		24
152 #define X_ChangeDeviceKeyMapping	25
153 #define X_GetDeviceModifierMapping	26
154 #define X_SetDeviceModifierMapping	27
155 #define X_GetDeviceButtonMapping	28
156 #define X_SetDeviceButtonMapping	29
157 #define X_QueryDeviceState		30
158 #define X_SendExtensionEvent		31
159 #define X_DeviceBell			32
160 #define X_SetDeviceValuators		33
161 #define X_GetDeviceControl		34
162 #define X_ChangeDeviceControl		35
163 /* XI 1.5 */
164 #define X_ListDeviceProperties          36
165 #define X_ChangeDeviceProperty          37
166 #define X_DeleteDeviceProperty          38
167 #define X_GetDeviceProperty             39
168 
169 /*********************************************************
170  *
171  * Protocol request and reply structures.
172  *
173  * GetExtensionVersion.
174  *
175  */
176 
177 typedef struct {
178     CARD8	reqType;       /* input extension major code   */
179     CARD8	ReqType;       /* always X_GetExtensionVersion */
180     CARD16	length;
181     CARD16	nbytes;
182     CARD8	pad1, pad2;
183 } xGetExtensionVersionReq;
184 
185 typedef struct {
186     CARD8	repType;	/* X_Reply			*/
187     CARD8	RepType;	/* always X_GetExtensionVersion */
188     CARD16	sequenceNumber;
189     CARD32	length;
190     CARD16	major_version;
191     CARD16	minor_version;
192     BOOL	present;
193     CARD8	pad1, pad2, pad3;
194     CARD32	pad01;
195     CARD32	pad02;
196     CARD32	pad03;
197     CARD32	pad04;
198 } xGetExtensionVersionReply;
199 
200 /*********************************************************
201  *
202  * ListInputDevices.
203  *
204  */
205 
206 typedef struct {
207     CARD8	reqType;	/* input extension major code	*/
208     CARD8	ReqType;	/* always X_ListInputDevices	*/
209     CARD16	length;
210 } xListInputDevicesReq;
211 
212 typedef struct {
213     CARD8	repType;	/* X_Reply			*/
214     CARD8	RepType;        /* always X_ListInputDevices	*/
215     CARD16	sequenceNumber;
216     CARD32	length;
217     CARD8	ndevices;
218     CARD8	pad1, pad2, pad3;
219     CARD32	pad01;
220     CARD32	pad02;
221     CARD32	pad03;
222     CARD32	pad04;
223     CARD32	pad05;
224 } xListInputDevicesReply;
225 
226 typedef struct _xDeviceInfo *xDeviceInfoPtr;
227 
228 typedef struct _xAnyClassinfo *xAnyClassPtr;
229 
230 typedef struct _xAnyClassinfo {
231 #if defined(__cplusplus) || defined(c_plusplus)
232     CARD8	c_class;
233 #else
234     CARD8	class;
235 #endif
236     CARD8	length;
237     } xAnyClassInfo;
238 
239 typedef struct _xDeviceInfo {
240     CARD32	type;
241     CARD8	id;
242     CARD8	num_classes;
243     CARD8	use;      /* IsXPointer | IsXKeyboard | IsXExtension... */
244     CARD8	attached; /* id of master dev (if IsXExtension..) */
245     } xDeviceInfo;
246 
247 typedef struct _xKeyInfo *xKeyInfoPtr;
248 
249 typedef struct _xKeyInfo {
250 #if defined(__cplusplus) || defined(c_plusplus)
251     CARD8	c_class;
252 #else
253     CARD8	class;
254 #endif
255     CARD8	length;
256     KeyCode	min_keycode;
257     KeyCode	max_keycode;
258     CARD16	num_keys;
259     CARD8	pad1,pad2;
260     } xKeyInfo;
261 
262 typedef struct _xButtonInfo *xButtonInfoPtr;
263 
264 typedef struct _xButtonInfo {
265 #if defined(__cplusplus) || defined(c_plusplus)
266     CARD8	c_class;
267 #else
268     CARD8	class;
269 #endif
270     CARD8	length;
271     CARD16	num_buttons;
272     } xButtonInfo;
273 
274 typedef struct _xValuatorInfo *xValuatorInfoPtr;
275 
276 typedef struct _xValuatorInfo {
277 #if defined(__cplusplus) || defined(c_plusplus)
278     CARD8	c_class;
279 #else
280     CARD8	class;
281 #endif
282     CARD8	length;
283     CARD8	num_axes;
284     CARD8	mode;
285     CARD32	motion_buffer_size;
286     } xValuatorInfo;
287 
288 typedef struct _xAxisInfo *xAxisInfoPtr;
289 
290 typedef struct _xAxisInfo {
291     CARD32	resolution;
292     CARD32	min_value;
293     CARD32	max_value;
294     } xAxisInfo;
295 
296 /*********************************************************
297  *
298  * OpenDevice.
299  *
300  */
301 
302 typedef struct {
303     CARD8	reqType;	/* input extension major code	*/
304     CARD8	ReqType;        /* always X_OpenDevice		*/
305     CARD16	length;
306     CARD8       deviceid;
307     BYTE	pad1, pad2, pad3;
308 } xOpenDeviceReq;
309 
310 typedef struct {
311     CARD8	repType;	/* X_Reply			*/
312     CARD8	RepType;	/* always X_OpenDevice		*/
313     CARD16	sequenceNumber;
314     CARD32	length;
315     CARD8	num_classes;
316     BYTE	pad1, pad2, pad3;
317     CARD32	pad00;
318     CARD32	pad01;
319     CARD32	pad02;
320     CARD32	pad03;
321     CARD32	pad04;
322     } xOpenDeviceReply;
323 
324 typedef struct {
325 #if defined(__cplusplus) || defined(c_plusplus)
326     CARD8	c_class;
327 #else
328     CARD8	class;
329 #endif
330     CARD8	event_type_base;
331     } xInputClassInfo;
332 
333 /*********************************************************
334  *
335  * CloseDevice.
336  *
337  */
338 
339 typedef struct {
340     CARD8	reqType;	/* input extension major code	*/
341     CARD8	ReqType;        /* always X_CloseDevice	*/
342     CARD16	length;
343     CARD8       deviceid;
344     BYTE	pad1, pad2, pad3;
345 } xCloseDeviceReq;
346 
347 /*********************************************************
348  *
349  * SetDeviceMode.
350  *
351  */
352 
353 typedef struct {
354     CARD8	reqType;	/* input extension major code	*/
355     CARD8	ReqType;	/* always X_SetDeviceMode	*/
356     CARD16	length;
357     CARD8       deviceid;
358     CARD8       mode;
359     BYTE	pad1, pad2;
360 } xSetDeviceModeReq;
361 
362 typedef struct {
363     CARD8	repType;	/* X_Reply			*/
364     CARD8	RepType;	/* always X_SetDeviceMode	*/
365     CARD16	sequenceNumber;
366     CARD32	length;
367     CARD8	status;
368     BYTE	pad1, pad2, pad3;
369     CARD32	pad01;
370     CARD32	pad02;
371     CARD32	pad03;
372     CARD32	pad04;
373     CARD32	pad05;
374 } xSetDeviceModeReply;
375 
376 /*********************************************************
377  *
378  * SelectExtensionEvent.
379  *
380  */
381 
382 typedef struct {
383     CARD8	reqType;	/* input extension major code	*/
384     CARD8	ReqType;        /* always X_SelectExtensionEvent */
385     CARD16	length;
386     Window	window;
387     CARD16	count;
388     CARD16	pad00;
389 } xSelectExtensionEventReq;
390 
391 /*********************************************************
392  *
393  * GetSelectedExtensionEvent.
394  *
395  */
396 
397 typedef struct {
398     CARD8	reqType;	/* input extension major code	*/
399     CARD8	ReqType;        /* X_GetSelectedExtensionEvents */
400     CARD16	length;
401     Window	window;
402 } xGetSelectedExtensionEventsReq;
403 
404 typedef struct {
405     CARD8	repType;	/* X_Reply			*/
406     CARD8	RepType;	/* GetSelectedExtensionEvents	*/
407     CARD16	sequenceNumber;
408     CARD32	length;
409     CARD16	this_client_count;
410     CARD16	all_clients_count;
411     CARD32	pad01;
412     CARD32	pad02;
413     CARD32	pad03;
414     CARD32	pad04;
415     CARD32	pad05;
416 } xGetSelectedExtensionEventsReply;
417 
418 /*********************************************************
419  *
420  * ChangeDeviceDontPropagateList.
421  *
422  */
423 
424 typedef struct {
425     CARD8	reqType;	/* input extension major code	*/
426     CARD8	ReqType;        /* X_ChangeDeviceDontPropagateList */
427     CARD16	length;
428     Window	window;
429     CARD16	count;
430     CARD8	mode;
431     BYTE	pad;
432 } xChangeDeviceDontPropagateListReq;
433 
434 /*********************************************************
435  *
436  * GetDeviceDontPropagateList.
437  *
438  */
439 
440 typedef struct {
441     CARD8	reqType;	/* input extension major code	*/
442     CARD8	ReqType;        /* X_GetDeviceDontPropagateList */
443     CARD16	length;
444     Window	window;
445 } xGetDeviceDontPropagateListReq;
446 
447 typedef struct {
448     CARD8	repType;	/* X_Reply			*/
449     CARD8	RepType;        /* GetDeviceDontPropagateList   */
450     CARD16	sequenceNumber;
451     CARD32	length;
452     CARD16	count;
453     CARD16	pad00;
454     CARD32	pad01;
455     CARD32	pad02;
456     CARD32	pad03;
457     CARD32	pad04;
458     CARD32	pad05;
459     } xGetDeviceDontPropagateListReply;
460 
461 /*********************************************************
462  *
463  * GetDeviceMotionEvents.
464  *
465  */
466 
467 typedef struct {
468     CARD8	reqType;	/* input extension major code	*/
469     CARD8	ReqType;        /* always X_GetDeviceMotionEvents*/
470     CARD16	length;
471     Time	start;
472     Time	stop;
473     CARD8	deviceid;
474     BYTE	pad1, pad2, pad3;
475 } xGetDeviceMotionEventsReq;
476 
477 typedef struct {
478     CARD8	repType;	/* X_Reply */
479     CARD8	RepType;        /* always X_GetDeviceMotionEvents  */
480     CARD16	sequenceNumber;
481     CARD32	length;
482     CARD32	nEvents;
483     CARD8	axes;
484     CARD8	mode;
485     BYTE	pad1, pad2;
486     CARD32	pad01;
487     CARD32	pad02;
488     CARD32	pad03;
489     CARD32	pad04;
490 } xGetDeviceMotionEventsReply;
491 
492 /*********************************************************
493  *
494  * ChangeKeyboardDevice.
495  *
496  */
497 
498 typedef struct {
499     CARD8	reqType;	/* input extension major code	*/
500     CARD8	ReqType;        /* X_ChangeKeyboardDevice	*/
501     CARD16	length;
502     CARD8	deviceid;
503     BYTE	pad1, pad2, pad3;
504 } xChangeKeyboardDeviceReq;
505 
506 typedef struct {
507     CARD8	repType;	/* X_Reply			*/
508     CARD8	RepType;        /* always X_ChangeKeyboardDevice*/
509     CARD16	sequenceNumber;
510     CARD32	length;		/* 0 */
511     CARD8	status;
512     BYTE	pad1, pad2, pad3;
513     CARD32	pad01;
514     CARD32	pad02;
515     CARD32	pad03;
516     CARD32	pad04;
517     CARD32	pad05;
518     } xChangeKeyboardDeviceReply;
519 
520 /*********************************************************
521  *
522  * ChangePointerDevice.
523  *
524  */
525 
526 typedef struct {
527     CARD8	reqType;	/* input extension major code	*/
528     CARD8	ReqType;        /* X_ChangePointerDevice	*/
529     CARD16	length;
530     CARD8	xaxis;
531     CARD8	yaxis;
532     CARD8	deviceid;
533     BYTE	pad1;
534 } xChangePointerDeviceReq;
535 
536 typedef struct {
537     CARD8	repType;	/* X_Reply			*/
538     CARD8	RepType;        /* always X_ChangePointerDevice */
539     CARD16	sequenceNumber;
540     CARD32	length;		/* 0 */
541     CARD8	status;
542     BYTE	pad1, pad2, pad3;
543     CARD32	pad01;
544     CARD32	pad02;
545     CARD32	pad03;
546     CARD32	pad04;
547     CARD32	pad05;
548     } xChangePointerDeviceReply;
549 
550 /*********************************************************
551  *
552  * GrabDevice.
553  *
554  */
555 
556 typedef struct {
557     CARD8	reqType;	/* input extension major code	*/
558     CARD8	ReqType;        /* always X_GrabDevice */
559     CARD16	length;
560     Window	grabWindow;
561     Time	time;
562     CARD16	event_count;
563     CARD8	this_device_mode;
564     CARD8	other_devices_mode;
565     BOOL	ownerEvents;
566     CARD8	deviceid;
567     CARD16	pad01;
568 } xGrabDeviceReq;
569 
570 typedef struct {
571     CARD8	repType;	/* X_Reply			*/
572     CARD8	RepType;        /* always X_GrabDevice	*/
573     CARD16	sequenceNumber;
574     CARD32	length;		/* 0 */
575     CARD8	status;
576     BYTE	pad1, pad2, pad3;
577     CARD32	pad01;
578     CARD32	pad02;
579     CARD32	pad03;
580     CARD32	pad04;
581     CARD32	pad05;
582     } xGrabDeviceReply;
583 
584 /*********************************************************
585  *
586  * UngrabDevice.
587  *
588  */
589 
590 typedef struct {
591     CARD8	reqType;	/* input extension major code	*/
592     CARD8	ReqType;        /* always X_UnGrabDevice	*/
593     CARD16	length;
594     Time	time;
595     CARD8	deviceid;
596     BYTE	pad1, pad2, pad3;
597 } xUngrabDeviceReq;
598 
599 /*********************************************************
600  *
601  * GrabDeviceKey.
602  *
603  */
604 
605 typedef struct {
606     CARD8	reqType;	/* input extension major code	*/
607     CARD8	ReqType;        /* always X_GrabDeviceKey	*/
608     CARD16	length;
609     Window	grabWindow;
610     CARD16	event_count;
611     CARD16	modifiers;
612     CARD8	modifier_device;
613     CARD8	grabbed_device;
614     CARD8	key;
615     BYTE	this_device_mode;
616     BYTE	other_devices_mode;
617     BOOL	ownerEvents;
618     BYTE	pad1, pad2;
619 } xGrabDeviceKeyReq;
620 
621 /*********************************************************
622  *
623  * UngrabDeviceKey.
624  *
625  */
626 
627 typedef struct {
628     CARD8	reqType;	/* input extension major code	*/
629     CARD8	ReqType;        /* always X_UngrabDeviceKey	*/
630     CARD16	length;
631     Window	grabWindow;
632     CARD16	modifiers;
633     CARD8	modifier_device;
634     CARD8	key;
635     CARD8	grabbed_device;
636     BYTE	pad1, pad2, pad3;
637 } xUngrabDeviceKeyReq;
638 
639 /*********************************************************
640  *
641  * GrabDeviceButton.
642  *
643  */
644 
645 typedef struct {
646     CARD8	reqType;	/* input extension major code	*/
647     CARD8	ReqType;        /* always X_GrabDeviceButton	*/
648     CARD16	length;
649     Window	grabWindow;
650     CARD8	grabbed_device;
651     CARD8	modifier_device;
652     CARD16	event_count;
653     CARD16	modifiers;
654     BYTE	this_device_mode;
655     BYTE	other_devices_mode;
656     CARD8	button;
657     BOOL	ownerEvents;
658     BYTE	pad1, pad2;
659 } xGrabDeviceButtonReq;
660 
661 /*********************************************************
662  *
663  * UngrabDeviceButton.
664  *
665  */
666 
667 typedef struct {
668     CARD8	reqType;	/* input extension major code	*/
669     CARD8	ReqType;        /* always X_UngrabDeviceButton	*/
670     CARD16	length;
671     Window	grabWindow;
672     CARD16	modifiers;
673     CARD8	modifier_device;
674     CARD8	button;
675     CARD8	grabbed_device;
676     BYTE	pad1, pad2, pad3;
677 } xUngrabDeviceButtonReq;
678 
679 /*********************************************************
680  *
681  * AllowDeviceEvents.
682  *
683  */
684 
685 typedef struct {
686     CARD8	reqType;	/* input extension major code	*/
687     CARD8	ReqType;        /* always X_AllowDeviceEvents	*/
688     CARD16	length;
689     Time	time;
690     CARD8	mode;
691     CARD8	deviceid;
692     BYTE	pad1, pad2;
693 } xAllowDeviceEventsReq;
694 
695 /*********************************************************
696  *
697  * GetDeviceFocus.
698  *
699  */
700 
701 typedef struct {
702     CARD8	reqType;        /* input extension major code   */
703     CARD8	ReqType;        /* always X_GetDeviceFocus	*/
704     CARD16	length;
705     CARD8	deviceid;
706     BYTE	pad1, pad2, pad3;
707 } xGetDeviceFocusReq;
708 
709 typedef struct {
710     CARD8	repType;	/* X_Reply			*/
711     CARD8	RepType;        /* always X_GetDeviceFocus	*/
712     CARD16	sequenceNumber;
713     CARD32	length;
714     CARD32	focus;
715     Time	time;
716     CARD8	revertTo;
717     BYTE	pad1, pad2, pad3;
718     CARD32	pad01;
719     CARD32	pad02;
720     CARD32	pad03;
721     } xGetDeviceFocusReply;
722 
723 /*********************************************************
724  *
725  * SetDeviceFocus.
726  *
727  */
728 
729 typedef struct {
730     CARD8	reqType;        /* input extension major code   */
731     CARD8	ReqType;        /* always X_SetDeviceFocus	*/
732     CARD16	length;
733     Window	focus;
734     Time	time;
735     CARD8	revertTo;
736     CARD8	device;
737     CARD16	pad01;
738 } xSetDeviceFocusReq;
739 
740 /*********************************************************
741  *
742  * GetFeedbackControl.
743  *
744  */
745 
746 typedef struct {
747     CARD8	reqType;	/* input extension major code	*/
748     CARD8	ReqType;        /* X_GetFeedbackControl	*/
749     CARD16	length;
750     CARD8	deviceid;
751     BYTE	pad1, pad2, pad3;
752 } xGetFeedbackControlReq;
753 
754 typedef struct {
755     CARD8	repType;	/* X_Reply			*/
756     CARD8	RepType;        /* always X_GetFeedbackControl	*/
757     CARD16	sequenceNumber;
758     CARD32	length;
759     CARD16	num_feedbacks;
760     CARD16	pad01;
761     CARD32	pad02;
762     CARD32	pad03;
763     CARD32	pad04;
764     CARD32	pad05;
765     CARD32	pad06;
766 } xGetFeedbackControlReply;
767 
768 typedef struct {
769 #if defined(__cplusplus) || defined(c_plusplus)
770     CARD8	c_class;	/* feedback class		*/
771 #else
772     CARD8	class;		/* feedback class		*/
773 #endif
774     CARD8	id;		/* feedback id		*/
775     CARD16	length;		/* feedback length		*/
776 } xFeedbackState;
777 
778 typedef struct {
779 #if defined(__cplusplus) || defined(c_plusplus)
780     CARD8   c_class;
781 #else
782     CARD8   class;
783 #endif
784     CARD8   id;
785     CARD16  length;
786     CARD16  pitch;
787     CARD16  duration;
788     CARD32  led_mask;
789     CARD32  led_values;
790     BOOL    global_auto_repeat;
791     CARD8   click;
792     CARD8   percent;
793     BYTE    pad;
794     BYTE    auto_repeats[32];
795 } xKbdFeedbackState;
796 
797 typedef struct {
798 #if defined(__cplusplus) || defined(c_plusplus)
799     CARD8   c_class;
800 #else
801     CARD8   class;
802 #endif
803     CARD8   id;
804     CARD16  length;
805     CARD8   pad1,pad2;
806     CARD16  accelNum;
807     CARD16  accelDenom;
808     CARD16  threshold;
809 } xPtrFeedbackState;
810 
811 typedef struct {
812 #if defined(__cplusplus) || defined(c_plusplus)
813     CARD8	c_class;	/* feedback class id		*/
814 #else
815     CARD8	class;		/* feedback class id		*/
816 #endif
817     CARD8	id;
818     CARD16	length;		/* feedback length		*/
819     CARD32	resolution;
820     INT32	min_value;
821     INT32	max_value;
822 } xIntegerFeedbackState;
823 
824 typedef struct {
825 #if defined(__cplusplus) || defined(c_plusplus)
826     CARD8	c_class;	/* feedback class id		*/
827 #else
828     CARD8	class;		/* feedback class id		*/
829 #endif
830     CARD8	id;
831     CARD16	length;		/* feedback length		*/
832     CARD16	max_symbols;
833     CARD16	num_syms_supported;
834 } xStringFeedbackState;
835 
836 typedef struct {
837 #if defined(__cplusplus) || defined(c_plusplus)
838     CARD8	c_class;	/* feedback class id		*/
839 #else
840     CARD8	class;		/* feedback class id		*/
841 #endif
842     CARD8	id;
843     CARD16	length;		/* feedback length		*/
844     CARD8	percent;
845     BYTE	pad1, pad2, pad3;
846     CARD16	pitch;
847     CARD16	duration;
848 } xBellFeedbackState;
849 
850 typedef struct {
851 #if defined(__cplusplus) || defined(c_plusplus)
852     CARD8	c_class;	/* feedback class id		*/
853 #else
854     CARD8	class;		/* feedback class id		*/
855 #endif
856     CARD8	id;
857     CARD16	length;		/* feedback length		*/
858     CARD32	led_mask;
859     CARD32	led_values;
860 } xLedFeedbackState;
861 
862 /*********************************************************
863  *
864  * ChangeFeedbackControl.
865  *
866  */
867 
868 typedef struct {
869     CARD8	reqType;	/* input extension major code	*/
870     CARD8	ReqType;        /* X_ChangeFeedbackControl	*/
871     CARD16	length;
872     CARD32	mask;
873     CARD8	deviceid;
874     CARD8	feedbackid;
875     BYTE	pad1, pad2;
876 } xChangeFeedbackControlReq;
877 
878 typedef struct {
879 #if defined(__cplusplus) || defined(c_plusplus)
880     CARD8	c_class;	/* feedback class id		*/
881 #else
882     CARD8	class;		/* feedback class id		*/
883 #endif
884     CARD8	id;		/* feedback id		*/
885     CARD16	length;		/* feedback length		*/
886 } xFeedbackCtl;
887 
888 typedef struct {
889 #if defined(__cplusplus) || defined(c_plusplus)
890     CARD8	c_class;	/* feedback class id		*/
891 #else
892     CARD8	class;		/* feedback class id		*/
893 #endif
894     CARD8	id;		/* feedback length		*/
895     CARD16	length;		/* feedback length		*/
896     KeyCode	key;
897     CARD8	auto_repeat_mode;
898     INT8	click;
899     INT8	percent;
900     INT16	pitch;
901     INT16	duration;
902     CARD32	led_mask;
903     CARD32	led_values;
904 } xKbdFeedbackCtl;
905 
906 typedef struct {
907 #if defined(__cplusplus) || defined(c_plusplus)
908     CARD8	c_class;	/* feedback class id		*/
909 #else
910     CARD8	class;		/* feedback class id		*/
911 #endif
912     CARD8	id;		/* feedback id		*/
913     CARD16	length;		/* feedback length		*/
914     CARD8	pad1,pad2;
915     INT16	num;
916     INT16	denom;
917     INT16	thresh;
918 } xPtrFeedbackCtl;
919 
920 typedef struct {
921 #if defined(__cplusplus) || defined(c_plusplus)
922     CARD8	c_class;	/* feedback class id		*/
923 #else
924     CARD8	class;		/* feedback class id		*/
925 #endif
926     CARD8	id;		/* feedback id		*/
927     CARD16	length;		/* feedback length		*/
928     INT32	int_to_display;
929 } xIntegerFeedbackCtl;
930 
931 typedef struct {
932 #if defined(__cplusplus) || defined(c_plusplus)
933     CARD8	c_class;	/* feedback class id		*/
934 #else
935     CARD8	class;		/* feedback class id		*/
936 #endif
937     CARD8	id;		/* feedback id		*/
938     CARD16	length;		/* feedback length		*/
939     CARD8	pad1,pad2;
940     CARD16	num_keysyms;
941 } xStringFeedbackCtl;
942 
943 typedef struct {
944 #if defined(__cplusplus) || defined(c_plusplus)
945     CARD8	c_class;	/* feedback class id		*/
946 #else
947     CARD8	class;		/* feedback class id		*/
948 #endif
949     CARD8	id;		/* feedback id		*/
950     CARD16	length;		/* feedback length		*/
951     INT8	percent;
952     BYTE	pad1, pad2, pad3;
953     INT16	pitch;
954     INT16	duration;
955 } xBellFeedbackCtl;
956 
957 typedef struct {
958 #if defined(__cplusplus) || defined(c_plusplus)
959     CARD8	c_class;	/* feedback class id		*/
960 #else
961     CARD8	class;		/* feedback class id		*/
962 #endif
963     CARD8	id;		/* feedback id		*/
964     CARD16	length;		/* feedback length		*/
965     CARD32	led_mask;
966     CARD32	led_values;
967 } xLedFeedbackCtl;
968 
969 /*********************************************************
970  *
971  * GetDeviceKeyMapping.
972  *
973  */
974 
975 typedef struct {
976     CARD8	reqType;        /* input extension major code   */
977     CARD8	ReqType;	/* always X_GetDeviceKeyMapping */
978     CARD16	length;
979     CARD8	deviceid;
980     KeyCode	firstKeyCode;
981     CARD8	count;
982     BYTE	pad1;
983 } xGetDeviceKeyMappingReq;
984 
985 typedef struct {
986     CARD8	repType;	/* X_Reply			*/
987     CARD8	RepType;	/* always X_GetDeviceKeyMapping */
988     CARD16	sequenceNumber;
989     CARD32	length;
990     CARD8	keySymsPerKeyCode;
991     CARD8	pad0;
992     CARD16	pad1;
993     CARD32	pad2;
994     CARD32	pad3;
995     CARD32	pad4;
996     CARD32	pad5;
997     CARD32	pad6;
998 } xGetDeviceKeyMappingReply;
999 
1000 /*********************************************************
1001  *
1002  * ChangeDeviceKeyMapping.
1003  *
1004  */
1005 
1006 typedef struct {
1007     CARD8	reqType;        /* input extension major code   */
1008     CARD8	ReqType;        /* always X_ChangeDeviceKeyMapping */
1009     CARD16	length;
1010     CARD8	deviceid;
1011     KeyCode	firstKeyCode;
1012     CARD8	keySymsPerKeyCode;
1013     CARD8	keyCodes;
1014 } xChangeDeviceKeyMappingReq;
1015 
1016 /*********************************************************
1017  *
1018  * GetDeviceModifierMapping.
1019  *
1020  */
1021 
1022 typedef struct {
1023     CARD8	reqType;        /* input extension major code   */
1024     CARD8	ReqType;        /* always X_GetDeviceModifierMapping */
1025     CARD16	length;
1026     CARD8	deviceid;
1027     BYTE	pad1, pad2, pad3;
1028 } xGetDeviceModifierMappingReq;
1029 
1030 typedef struct {
1031     CARD8	repType;	/* X_Reply */
1032     CARD8	RepType;        /* always X_GetDeviceModifierMapping */
1033     CARD16	sequenceNumber;
1034     CARD32	length;
1035     CARD8	numKeyPerModifier;
1036     CARD8	pad0;
1037     CARD16	pad1;
1038     CARD32	pad2;
1039     CARD32	pad3;
1040     CARD32	pad4;
1041     CARD32	pad5;
1042     CARD32	pad6;
1043 } xGetDeviceModifierMappingReply;
1044 
1045 /*********************************************************
1046  *
1047  * SetDeviceModifierMapping.
1048  *
1049  */
1050 
1051 typedef struct {
1052     CARD8	reqType;        /* input extension major code   */
1053     CARD8	ReqType;        /* always X_SetDeviceModifierMapping */
1054     CARD16	length;
1055     CARD8	deviceid;
1056     CARD8	numKeyPerModifier;
1057     CARD16	pad1;
1058 } xSetDeviceModifierMappingReq;
1059 
1060 typedef struct {
1061     CARD8	repType;	/* X_Reply */
1062     CARD8	RepType;        /* always X_SetDeviceModifierMapping */
1063     CARD16	sequenceNumber;
1064     CARD32	length;
1065     CARD8	success;
1066     CARD8	pad0;
1067     CARD16	pad1;
1068     CARD32	pad2;
1069     CARD32	pad3;
1070     CARD32	pad4;
1071     CARD32	pad5;
1072     CARD32	pad6;
1073 } xSetDeviceModifierMappingReply;
1074 
1075 /*********************************************************
1076  *
1077  * GetDeviceButtonMapping.
1078  *
1079  */
1080 
1081 typedef struct {
1082     CARD8	reqType;	/* input extension major code	*/
1083     CARD8	ReqType;        /* X_GetDeviceButtonMapping     */
1084     CARD16	length;
1085     CARD8	deviceid;
1086     BYTE	pad1, pad2, pad3;
1087 } xGetDeviceButtonMappingReq;
1088 
1089 typedef struct {
1090     CARD8	repType;	/* X_Reply */
1091     CARD8	RepType;        /* always X_GetDeviceButtonMapping */
1092     CARD16	sequenceNumber;
1093     CARD32	length;
1094     CARD8	nElts;
1095     BYTE	pad1, pad2, pad3;
1096     CARD32	pad01;
1097     CARD32	pad02;
1098     CARD32	pad03;
1099     CARD32	pad04;
1100     CARD32	pad05;
1101 } xGetDeviceButtonMappingReply;
1102 
1103 /*********************************************************
1104  *
1105  * SetDeviceButtonMapping.
1106  *
1107  */
1108 
1109 typedef struct {
1110     CARD8	reqType;	/* input extension major code	*/
1111     CARD8	ReqType;        /* X_SetDeviceButtonMapping     */
1112     CARD16	length;
1113     CARD8	deviceid;
1114     CARD8	map_length;
1115     BYTE	pad1, pad2;
1116 } xSetDeviceButtonMappingReq;
1117 
1118 typedef struct {
1119     CARD8	repType;		/* X_Reply */
1120     CARD8	RepType;	/* always X_SetDeviceButtonMapping */
1121     CARD16	sequenceNumber;
1122     CARD32	length;
1123     CARD8	status;
1124     BYTE	pad0;
1125     CARD16	pad1;
1126     CARD32	pad2;
1127     CARD32	pad3;
1128     CARD32	pad4;
1129     CARD32	pad5;
1130     CARD32	pad6;
1131 } xSetDeviceButtonMappingReply;
1132 
1133 /*********************************************************
1134  *
1135  * QueryDeviceState.
1136  *
1137  */
1138 
1139 typedef struct {
1140     CARD8	reqType;
1141     CARD8	ReqType;        /* always X_QueryDeviceState */
1142     CARD16	length;
1143     CARD8	deviceid;
1144     BYTE	pad1, pad2, pad3;
1145 } xQueryDeviceStateReq;
1146 
1147 typedef struct {
1148     CARD8	repType;		/* X_Reply */
1149     CARD8	RepType;	/* always X_QueryDeviceState	*/
1150     CARD16	sequenceNumber;
1151     CARD32	length;
1152     CARD8	num_classes;
1153     BYTE	pad0;
1154     CARD16	pad1;
1155     CARD32	pad2;
1156     CARD32	pad3;
1157     CARD32	pad4;
1158     CARD32	pad5;
1159     CARD32	pad6;
1160 } xQueryDeviceStateReply;
1161 
1162 typedef struct {
1163 #if defined(__cplusplus) || defined(c_plusplus)
1164     CARD8	c_class;
1165 #else
1166     CARD8	class;
1167 #endif
1168     CARD8	length;
1169     CARD8	num_keys;
1170     BYTE	pad1;
1171     CARD8	keys[32];
1172 } xKeyState;
1173 
1174 typedef struct {
1175 #if defined(__cplusplus) || defined(c_plusplus)
1176     CARD8	c_class;
1177 #else
1178     CARD8	class;
1179 #endif
1180     CARD8	length;
1181     CARD8	num_buttons;
1182     BYTE	pad1;
1183     CARD8	buttons[32];
1184 } xButtonState;
1185 
1186 typedef struct {
1187 #if defined(__cplusplus) || defined(c_plusplus)
1188     CARD8	c_class;
1189 #else
1190     CARD8	class;
1191 #endif
1192     CARD8	length;
1193     CARD8	num_valuators;
1194     CARD8	mode;
1195 } xValuatorState;
1196 
1197 /*********************************************************
1198  *
1199  * SendExtensionEvent.
1200  * THIS REQUEST MUST BE KEPT A MULTIPLE OF 8 BYTES IN LENGTH!
1201  * MORE EVENTS MAY FOLLOW AND THEY MUST BE QUAD-ALIGNED!
1202  *
1203  */
1204 
1205 typedef struct {
1206     CARD8	reqType;
1207     CARD8	ReqType;        /* always X_SendExtensionEvent */
1208     CARD16	length;
1209     Window	destination;
1210     CARD8	deviceid;
1211     BOOL	propagate;
1212     CARD16	count;
1213     CARD8	num_events;
1214     BYTE	pad1,pad2,pad3;
1215 } xSendExtensionEventReq;
1216 
1217 /*********************************************************
1218  *
1219  * DeviceBell.
1220  *
1221  */
1222 
1223 typedef struct {
1224     CARD8	reqType;
1225     CARD8	ReqType;        /* always X_DeviceBell */
1226     CARD16	length;
1227     CARD8	deviceid;
1228     CARD8	feedbackid;
1229     CARD8	feedbackclass;
1230     INT8	percent;
1231 } xDeviceBellReq;
1232 
1233 /*********************************************************
1234  *
1235  * SetDeviceValuators.
1236  *
1237  */
1238 
1239 typedef struct {
1240     CARD8	reqType;	/* input extension major code	*/
1241     CARD8	ReqType;	/* always X_SetDeviceValuators	*/
1242     CARD16	length;
1243     CARD8       deviceid;
1244     CARD8       first_valuator;
1245     CARD8       num_valuators;
1246     BYTE	pad1;
1247 } xSetDeviceValuatorsReq;
1248 
1249 typedef struct {
1250     CARD8	repType;	/* X_Reply			*/
1251     CARD8	RepType;	/* always X_SetDeviceValuators	*/
1252     CARD16	sequenceNumber;
1253     CARD32	length;
1254     CARD8	status;
1255     BYTE	pad1, pad2, pad3;
1256     CARD32	pad01;
1257     CARD32	pad02;
1258     CARD32	pad03;
1259     CARD32	pad04;
1260     CARD32	pad05;
1261 } xSetDeviceValuatorsReply;
1262 
1263 /*********************************************************
1264  *
1265  * GetDeviceControl.
1266  *
1267  */
1268 
1269 typedef struct {
1270     CARD8	reqType;	/* input extension major code	*/
1271     CARD8	ReqType;	/* always X_GetDeviceControl	*/
1272     CARD16	length;
1273     CARD16	control;
1274     CARD8       deviceid;
1275     BYTE	pad2;
1276 } xGetDeviceControlReq;
1277 
1278 typedef struct {
1279     CARD8	repType;	/* X_Reply			*/
1280     CARD8	RepType;	/* always X_GetDeviceControl	*/
1281     CARD16	sequenceNumber;
1282     CARD32	length;
1283     CARD8	status;
1284     BYTE	pad1, pad2, pad3;
1285     CARD32	pad01;
1286     CARD32	pad02;
1287     CARD32	pad03;
1288     CARD32	pad04;
1289     CARD32	pad05;
1290 } xGetDeviceControlReply;
1291 
1292 typedef struct {
1293     CARD16	control;	/* control type			*/
1294     CARD16	length;		/* control length		*/
1295 } xDeviceState;
1296 
1297 typedef struct {
1298     CARD16	control;	/* control type			*/
1299     CARD16	length;		/* control length		*/
1300     CARD32	num_valuators;	/* number of valuators		*/
1301 } xDeviceResolutionState;
1302 
1303 typedef struct {
1304      CARD16         control;
1305      CARD16         length;
1306      INT32          min_x;
1307      INT32          max_x;
1308      INT32          min_y;
1309      INT32          max_y;
1310      CARD32         flip_x;
1311      CARD32         flip_y;
1312      CARD32         rotation;
1313      CARD32         button_threshold;
1314 } xDeviceAbsCalibState;
1315 
1316 typedef struct {
1317      CARD16         control;
1318      CARD16         length;
1319      CARD32         offset_x;
1320      CARD32         offset_y;
1321      CARD32         width;
1322      CARD32         height;
1323      CARD32         screen;
1324      CARD32         following;
1325 } xDeviceAbsAreaState;
1326 
1327 typedef struct {
1328     CARD16      control;	/* control type                 */
1329     CARD16      length; 	/* control length               */
1330     CARD8       status;
1331     CARD8       iscore;
1332     CARD16      pad1;
1333 } xDeviceCoreState;
1334 
1335 typedef struct {
1336     CARD16      control;	/* control type                 */
1337     CARD16      length; 	/* control length               */
1338     CARD8       enable;
1339     CARD8       pad0;
1340     CARD16      pad1;
1341 } xDeviceEnableState;
1342 
1343 /*********************************************************
1344  *
1345  * ChangeDeviceControl.
1346  *
1347  */
1348 
1349 typedef struct {
1350     CARD8	reqType;	/* input extension major code	*/
1351     CARD8	ReqType;	/* always X_ChangeDeviceControl */
1352     CARD16	length;
1353     CARD16      control;
1354     CARD8       deviceid;
1355     BYTE        pad0;
1356 } xChangeDeviceControlReq;
1357 
1358 typedef struct {
1359     CARD8	repType;	/* X_Reply			*/
1360     CARD8	RepType;	/* always X_ChangeDeviceControl	*/
1361     CARD16	sequenceNumber;
1362     CARD32	length;
1363     CARD8	status;
1364     BYTE	pad1, pad2, pad3;
1365     CARD32	pad01;
1366     CARD32	pad02;
1367     CARD32	pad03;
1368     CARD32	pad04;
1369     CARD32	pad05;
1370 } xChangeDeviceControlReply;
1371 
1372 typedef struct {
1373     CARD16	control;		/* control type			*/
1374     CARD16	length;			/* control length		*/
1375 } xDeviceCtl;
1376 
1377 typedef struct {
1378     CARD16	control;		/* control type			*/
1379     CARD16	length;			/* control length		*/
1380     CARD8	first_valuator;		/* first valuator to change     */
1381     CARD8	num_valuators;		/* number of valuators to change*/
1382     CARD8	pad1,pad2;
1383 } xDeviceResolutionCtl;
1384 
1385 typedef struct {
1386      CARD16         control;
1387      CARD16         length;
1388      INT32          min_x;
1389      INT32          max_x;
1390      INT32          min_y;
1391      INT32          max_y;
1392      CARD32         flip_x;
1393      CARD32         flip_y;
1394      CARD32         rotation;
1395      CARD32         button_threshold;
1396 } xDeviceAbsCalibCtl;
1397 
1398 typedef struct {
1399      CARD16         control;
1400      CARD16         length;
1401      CARD32         offset_x;
1402      CARD32         offset_y;
1403      INT32          width;
1404      INT32          height;
1405      INT32          screen;
1406      CARD32         following;
1407 } xDeviceAbsAreaCtl;
1408 
1409 typedef struct {
1410     CARD16          control;
1411     CARD16          length;
1412     CARD8           status;
1413     CARD8           pad0;
1414     CARD16          pad1;
1415 } xDeviceCoreCtl;
1416 
1417 typedef struct {
1418     CARD16          control;
1419     CARD16          length;
1420     CARD8           enable;
1421     CARD8           pad0;
1422     CARD16          pad1;
1423 } xDeviceEnableCtl;
1424 
1425 /* XI 1.5 */
1426 
1427 /*********************************************************
1428  *
1429  * ListDeviceProperties.
1430  *
1431  */
1432 
1433 typedef struct {
1434     CARD8       reqType;        /* input extension major opcode */
1435     CARD8       ReqType;        /* always X_ListDeviceProperties */
1436     CARD16      length;
1437     CARD8       deviceid;
1438     CARD8       pad0;
1439     CARD16      pad1;
1440 } xListDevicePropertiesReq;
1441 
1442 typedef struct {
1443     CARD8       repType;        /* X_Reply                       */
1444     CARD8       RepType;        /* always X_ListDeviceProperties */
1445     CARD16      sequenceNumber;
1446     CARD32      length;
1447     CARD16      nAtoms;
1448     CARD16      pad1;
1449     CARD32      pad2;
1450     CARD32      pad3;
1451     CARD32      pad4;
1452     CARD32      pad5;
1453     CARD32      pad6;
1454 } xListDevicePropertiesReply;
1455 
1456 /*********************************************************
1457  *
1458  * ChangeDeviceProperty.
1459  *
1460  */
1461 
1462 typedef struct {
1463     CARD8       reqType;        /* input extension major opcode */
1464     CARD8       ReqType;        /* always X_ChangeDeviceProperty */
1465     CARD16      length;
1466     Atom        property;
1467     Atom        type;
1468     CARD8       deviceid;
1469     CARD8       format;
1470     CARD8       mode;
1471     CARD8       pad;
1472     CARD32      nUnits;
1473 } xChangeDevicePropertyReq;
1474 
1475 /*********************************************************
1476  *
1477  * DeleteDeviceProperty.
1478  *
1479  */
1480 
1481 typedef struct {
1482     CARD8       reqType;        /* input extension major opcode */
1483     CARD8       ReqType;        /* always X_DeleteDeviceProperty */
1484     CARD16      length;
1485     Atom        property;
1486     CARD8       deviceid;
1487     CARD8       pad0;
1488     CARD16      pad1;
1489 } xDeleteDevicePropertyReq;
1490 
1491 /*********************************************************
1492  *
1493  * GetDeviceProperty.
1494  *
1495  */
1496 
1497 typedef struct {
1498     CARD8       reqType;        /* input extension major opcode */
1499     CARD8       ReqType;        /* always X_GetDeviceProperty */
1500     CARD16      length;
1501     Atom        property;
1502     Atom        type;
1503     CARD32      longOffset;
1504     CARD32      longLength;
1505     CARD8       deviceid;
1506 #if defined(__cplusplus) || defined(c_plusplus)
1507     BOOL        c_delete;
1508 #else
1509     BOOL        delete;
1510 #endif
1511     CARD16      pad;
1512 } xGetDevicePropertyReq;
1513 
1514 typedef struct {
1515     CARD8       repType;        /* X_Reply                        */
1516     CARD8       RepType;        /* always X_GetDeviceProperty   */
1517     CARD16      sequenceNumber;
1518     CARD32      length;
1519     Atom        propertyType;
1520     CARD32      bytesAfter;
1521     CARD32      nItems;
1522     CARD8       format;
1523     CARD8       deviceid;
1524     CARD16      pad1;
1525     CARD32      pad2;
1526     CARD32      pad3;
1527 } xGetDevicePropertyReply;
1528 
1529 
1530 /**********************************************************
1531  *
1532  * Input extension events.
1533  *
1534  * DeviceValuator
1535  *
1536  */
1537 
1538 typedef struct
1539     {
1540     BYTE	type;
1541     CARD8       deviceid;
1542     CARD16	sequenceNumber;
1543     KeyButMask	device_state;
1544     CARD8	num_valuators;
1545     CARD8       first_valuator;
1546     INT32	valuator0;
1547     INT32	valuator1;
1548     INT32	valuator2;
1549     INT32	valuator3;
1550     INT32	valuator4;
1551     INT32	valuator5;
1552     }  deviceValuator;
1553 
1554 /**********************************************************
1555  *
1556  * DeviceKeyButtonPointer.
1557  *
1558  * Used for: DeviceKeyPress, DeviceKeyRelease,
1559  *	     DeviceButtonPress, DeviceButtonRelease,
1560  *	     ProximityIn, ProximityOut
1561  *	     DeviceMotionNotify,
1562  *
1563  */
1564 
1565 typedef struct
1566     {
1567     BYTE	type;
1568     BYTE        detail;
1569     CARD16      sequenceNumber;
1570     Time        time;
1571     Window      root;
1572     Window      event;
1573     Window      child;
1574     INT16       root_x;
1575     INT16       root_y;
1576     INT16       event_x;
1577     INT16       event_y;
1578     KeyButMask  state;
1579     BOOL        same_screen;
1580     CARD8       deviceid;
1581     }  deviceKeyButtonPointer;
1582 
1583 /**********************************************************
1584  *
1585  * DeviceFocus.
1586  *
1587  */
1588 
1589 typedef struct
1590     {
1591     BYTE	type;
1592     BYTE        detail;
1593     CARD16	sequenceNumber;
1594     Time	time;
1595     Window	window;
1596     BYTE	mode;
1597     CARD8       deviceid;
1598     BYTE	pad1, pad2;
1599     CARD32	pad00;
1600     CARD32	pad01;
1601     CARD32	pad02;
1602     CARD32	pad03;
1603     }  deviceFocus;
1604 
1605 /**********************************************************
1606  *
1607  * DeviceStateNotify.
1608  *
1609  * Note that the two high-order bits in the classes_reported
1610  * field are the proximity state (InProximity or OutOfProximity),
1611  * and the device mode (Absolute or Relative), respectively.
1612  *
1613  */
1614 
1615 typedef struct
1616     {
1617     BYTE	type;
1618     BYTE        deviceid;
1619     CARD16	sequenceNumber;
1620     Time	time;
1621     CARD8	num_keys;
1622     CARD8	num_buttons;
1623     CARD8	num_valuators;
1624     CARD8       classes_reported;
1625     CARD8       buttons[4];
1626     CARD8       keys[4];
1627     INT32	valuator0;
1628     INT32	valuator1;
1629     INT32	valuator2;
1630     }  deviceStateNotify;
1631 
1632 /**********************************************************
1633  *
1634  * DeviceKeyStateNotify.
1635  *
1636  */
1637 
1638 typedef struct
1639     {
1640     BYTE	type;
1641     BYTE        deviceid;
1642     CARD16	sequenceNumber;
1643     CARD8       keys[28];
1644     }  deviceKeyStateNotify;
1645 
1646 /**********************************************************
1647  *
1648  * DeviceButtonStateNotify.
1649  *
1650  */
1651 
1652 typedef struct
1653     {
1654     BYTE	type;
1655     BYTE        deviceid;
1656     CARD16	sequenceNumber;
1657     CARD8       buttons[28];
1658     }  deviceButtonStateNotify;
1659 
1660 /**********************************************************
1661  *
1662  * DeviceMappingNotify.
1663  * Fields must be kept in sync with core mappingnotify event.
1664  *
1665  */
1666 
1667 typedef struct
1668     {
1669     BYTE	type;
1670     BYTE        deviceid;
1671     CARD16      sequenceNumber;
1672     CARD8       request;
1673     KeyCode     firstKeyCode;
1674     CARD8       count;
1675     BYTE        pad1;
1676     Time        time;
1677     CARD32      pad00;
1678     CARD32      pad01;
1679     CARD32      pad02;
1680     CARD32      pad03;
1681     CARD32      pad04;
1682     }  deviceMappingNotify;
1683 
1684 /**********************************************************
1685  *
1686  * ChangeDeviceNotify.
1687  *
1688  */
1689 
1690 typedef struct
1691     {
1692     BYTE	type;
1693     BYTE        deviceid;
1694     CARD16      sequenceNumber;
1695     Time        time;
1696     CARD8       request;
1697     BYTE        pad1, pad2, pad3;
1698     CARD32      pad00;
1699     CARD32      pad01;
1700     CARD32      pad02;
1701     CARD32      pad03;
1702     CARD32      pad04;
1703     }  changeDeviceNotify;
1704 
1705 /**********************************************************
1706  *
1707  * devicePresenceNotify.
1708  *
1709  */
1710 
1711 typedef struct
1712     {
1713     BYTE	type;
1714     BYTE        pad00;
1715     CARD16      sequenceNumber;
1716     Time        time;
1717     BYTE        devchange; /* Device{Added|Removed|Enabled|Disabled|ControlChanged} */
1718     BYTE        deviceid;
1719     CARD16      control;
1720     CARD32      pad02;
1721     CARD32      pad03;
1722     CARD32      pad04;
1723     CARD32      pad05;
1724     CARD32      pad06;
1725     }  devicePresenceNotify;
1726 
1727 
1728 /*********************************************************
1729  * DevicePropertyNotifyEvent
1730  *
1731  * Sent whenever a device's property changes.
1732  *
1733  */
1734 
1735 typedef struct
1736     {
1737     BYTE        type;
1738     BYTE        state;               /* NewValue or Deleted */
1739     CARD16      sequenceNumber;
1740     CARD32      time;
1741     Atom        atom;                /* affected property */
1742     CARD32      pad0;
1743     CARD32      pad1;
1744     CARD32      pad2;
1745     CARD32      pad3;
1746     CARD16      pad5;
1747     CARD8       pad4;
1748     CARD8       deviceid;            /* id of device */
1749     } devicePropertyNotify;
1750 
1751 #undef Window
1752 #undef Time
1753 #undef KeyCode
1754 #undef Mask
1755 #undef Atom
1756 #undef Cursor
1757 
1758 #endif
1759