VirtualBox

source: vbox/trunk/src/VBox/Additions/x11/x11include/XFree86-4.3/X11/extensions/XIproto.h@ 99743

Last change on this file since 99743 was 69098, checked in by vboxsync, 7 years ago

Clean up XFree86 driver header files.
bugref:3810: X11 Guest Additions maintenance
Over the years we have cleaned up the layout in the tree of the X.Org
header files we use to build drivers. The XFree86 ones were still in their
original, rather sub-optimal layout. This change fixes that.
  • Property svn:eol-style set to native
File size: 36.6 KB
Line 
1/* $Xorg: XIproto.h,v 1.5 2001/02/09 02:03:24 xorgcvs Exp $ */
2
3/************************************************************
4
5Copyright 1989, 1998 The Open Group
6
7Permission to use, copy, modify, distribute, and sell this software and its
8documentation for any purpose is hereby granted without fee, provided that
9the above copyright notice appear in all copies and that both that
10copyright notice and this permission notice appear in supporting
11documentation.
12
13The above copyright notice and this permission notice shall be included in
14all copies or substantial portions of the Software.
15
16THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
19OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
20AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22
23Except as contained in this notice, the name of The Open Group shall not be
24used in advertising or otherwise to promote the sale, use or other dealings
25in this Software without prior written authorization from The Open Group.
26
27Copyright 1989 by Hewlett-Packard Company, Palo Alto, California.
28
29 All Rights Reserved
30
31Permission to use, copy, modify, and distribute this software and its
32documentation for any purpose and without fee is hereby granted,
33provided that the above copyright notice appear in all copies and that
34both that copyright notice and this permission notice appear in
35supporting documentation, and that the name of Hewlett-Packard not be
36used in advertising or publicity pertaining to distribution of the
37software without specific, written prior permission.
38
39HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
40ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
41HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
42ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
43WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
44ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
45SOFTWARE.
46
47********************************************************/
48/* $XFree86: xc/include/extensions/XIproto.h,v 1.5 2001/12/14 19:53:28 dawes Exp $ */
49
50#ifndef _XIPROTO_H
51#define _XIPROTO_H
52
53#include <X11/Xproto.h>
54#include <X11/X.h>
55
56/* make sure types have right sizes for protocol structures. */
57#define Window CARD32
58#define Time CARD32
59#define KeyCode CARD8
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 15
76#define IERRORS 5
77
78#define CLIENT_REQ 1
79
80typedef struct _XExtEventInfo
81 {
82 Mask mask;
83 BYTE type;
84 BYTE word;
85 } XExtEventInfo;
86
87typedef unsigned char *Pointer;
88
89struct tmask
90 {
91 Mask mask;
92 Pointer dev;
93 };
94
95/*********************************************************
96 *
97 * Event constants used by library.
98 *
99 */
100
101#define XI_DeviceValuator 0
102#define XI_DeviceKeyPress 1
103#define XI_DeviceKeyRelease 2
104#define XI_DeviceButtonPress 3
105#define XI_DeviceButtonRelease 4
106#define XI_DeviceMotionNotify 5
107#define XI_DeviceFocusIn 6
108#define XI_DeviceFocusOut 7
109#define XI_ProximityIn 8
110#define XI_ProximityOut 9
111#define XI_DeviceStateNotify 10
112#define XI_DeviceMappingNotify 11
113#define XI_ChangeDeviceNotify 12
114#define XI_DeviceKeystateNotify 13
115#define XI_DeviceButtonstateNotify 14
116
117/*********************************************************
118 *
119 * Protocol request constants
120 *
121 */
122
123#define X_GetExtensionVersion 1
124#define X_ListInputDevices 2
125#define X_OpenDevice 3
126#define X_CloseDevice 4
127#define X_SetDeviceMode 5
128#define X_SelectExtensionEvent 6
129#define X_GetSelectedExtensionEvents 7
130#define X_ChangeDeviceDontPropagateList 8
131#define X_GetDeviceDontPropagateList 9
132#define X_GetDeviceMotionEvents 10
133#define X_ChangeKeyboardDevice 11
134#define X_ChangePointerDevice 12
135#define X_GrabDevice 13
136#define X_UngrabDevice 14
137#define X_GrabDeviceKey 15
138#define X_UngrabDeviceKey 16
139#define X_GrabDeviceButton 17
140#define X_UngrabDeviceButton 18
141#define X_AllowDeviceEvents 19
142#define X_GetDeviceFocus 20
143#define X_SetDeviceFocus 21
144#define X_GetFeedbackControl 22
145#define X_ChangeFeedbackControl 23
146#define X_GetDeviceKeyMapping 24
147#define X_ChangeDeviceKeyMapping 25
148#define X_GetDeviceModifierMapping 26
149#define X_SetDeviceModifierMapping 27
150#define X_GetDeviceButtonMapping 28
151#define X_SetDeviceButtonMapping 29
152#define X_QueryDeviceState 30
153#define X_SendExtensionEvent 31
154#define X_DeviceBell 32
155#define X_SetDeviceValuators 33
156#define X_GetDeviceControl 34
157#define X_ChangeDeviceControl 35
158
159/*********************************************************
160 *
161 * Protocol request and reply structures.
162 *
163 * GetExtensionVersion.
164 *
165 */
166
167typedef struct {
168 CARD8 reqType; /* input extension major code */
169 CARD8 ReqType; /* always X_GetExtensionVersion */
170 CARD16 length B16;
171 CARD16 nbytes B16;
172 CARD8 pad1, pad2;
173} xGetExtensionVersionReq;
174
175typedef struct {
176 CARD8 repType; /* X_Reply */
177 CARD8 RepType; /* always X_GetExtensionVersion */
178 CARD16 sequenceNumber B16;
179 CARD32 length B32;
180 CARD16 major_version B16;
181 CARD16 minor_version B16;
182 BOOL present;
183 CARD8 pad1, pad2, pad3;
184 CARD32 pad01 B32;
185 CARD32 pad02 B32;
186 CARD32 pad03 B32;
187 CARD32 pad04 B32;
188} xGetExtensionVersionReply;
189
190/*********************************************************
191 *
192 * ListInputDevices.
193 *
194 */
195
196typedef struct {
197 CARD8 reqType; /* input extension major code */
198 CARD8 ReqType; /* always X_ListInputDevices */
199 CARD16 length B16;
200} xListInputDevicesReq;
201
202typedef struct {
203 CARD8 repType; /* X_Reply */
204 CARD8 RepType; /* always X_ListInputDevices */
205 CARD16 sequenceNumber B16;
206 CARD32 length B32;
207 CARD8 ndevices;
208 CARD8 pad1, pad2, pad3;
209 CARD32 pad01 B32;
210 CARD32 pad02 B32;
211 CARD32 pad03 B32;
212 CARD32 pad04 B32;
213 CARD32 pad05 B32;
214} xListInputDevicesReply;
215
216typedef struct _xDeviceInfo *xDeviceInfoPtr;
217
218typedef struct _xAnyClassinfo *xAnyClassPtr;
219
220typedef struct _xAnyClassinfo {
221#if defined(__cplusplus) || defined(c_plusplus)
222 CARD8 c_class;
223#else
224 CARD8 class;
225#endif
226 CARD8 length;
227 } xAnyClassInfo;
228
229typedef struct _xDeviceInfo {
230 CARD32 type B32;
231 CARD8 id;
232 CARD8 num_classes;
233 CARD8 use;
234 CARD8 pad1;
235 } xDeviceInfo;
236
237typedef struct _xKeyInfo *xKeyInfoPtr;
238
239typedef struct _xKeyInfo {
240#if defined(__cplusplus) || defined(c_plusplus)
241 CARD8 c_class;
242#else
243 CARD8 class;
244#endif
245 CARD8 length;
246 KeyCode min_keycode;
247 KeyCode max_keycode;
248 CARD16 num_keys B16;
249 CARD8 pad1,pad2;
250 } xKeyInfo;
251
252typedef struct _xButtonInfo *xButtonInfoPtr;
253
254typedef struct _xButtonInfo {
255#if defined(__cplusplus) || defined(c_plusplus)
256 CARD8 c_class;
257#else
258 CARD8 class;
259#endif
260 CARD8 length;
261 CARD16 num_buttons B16;
262 } xButtonInfo;
263
264typedef struct _xValuatorInfo *xValuatorInfoPtr;
265
266typedef struct _xValuatorInfo {
267#if defined(__cplusplus) || defined(c_plusplus)
268 CARD8 c_class;
269#else
270 CARD8 class;
271#endif
272 CARD8 length;
273 CARD8 num_axes;
274 CARD8 mode;
275 CARD32 motion_buffer_size B32;
276 } xValuatorInfo;
277
278typedef struct _xAxisInfo *xAxisInfoPtr;
279
280typedef struct _xAxisInfo {
281 CARD32 resolution B32;
282 CARD32 min_value B32;
283 CARD32 max_value B32;
284 } xAxisInfo;
285
286/*********************************************************
287 *
288 * OpenDevice.
289 *
290 */
291
292typedef struct {
293 CARD8 reqType; /* input extension major code */
294 CARD8 ReqType; /* always X_OpenDevice */
295 CARD16 length B16;
296 CARD8 deviceid;
297 BYTE pad1, pad2, pad3;
298} xOpenDeviceReq;
299
300typedef struct {
301 CARD8 repType; /* X_Reply */
302 CARD8 RepType; /* always X_OpenDevice */
303 CARD16 sequenceNumber B16;
304 CARD32 length B32;
305 CARD8 num_classes;
306 BYTE pad1, pad2, pad3;
307 CARD32 pad00 B32;
308 CARD32 pad01 B32;
309 CARD32 pad02 B32;
310 CARD32 pad03 B32;
311 CARD32 pad04 B32;
312 } xOpenDeviceReply;
313
314typedef struct {
315#if defined(__cplusplus) || defined(c_plusplus)
316 CARD8 c_class;
317#else
318 CARD8 class;
319#endif
320 CARD8 event_type_base;
321 } xInputClassInfo;
322
323/*********************************************************
324 *
325 * CloseDevice.
326 *
327 */
328
329typedef struct {
330 CARD8 reqType; /* input extension major code */
331 CARD8 ReqType; /* always X_CloseDevice */
332 CARD16 length B16;
333 CARD8 deviceid;
334 BYTE pad1, pad2, pad3;
335} xCloseDeviceReq;
336
337/*********************************************************
338 *
339 * SetDeviceMode.
340 *
341 */
342
343typedef struct {
344 CARD8 reqType; /* input extension major code */
345 CARD8 ReqType; /* always X_SetDeviceMode */
346 CARD16 length B16;
347 CARD8 deviceid;
348 CARD8 mode;
349 BYTE pad1, pad2;
350} xSetDeviceModeReq;
351
352typedef struct {
353 CARD8 repType; /* X_Reply */
354 CARD8 RepType; /* always X_SetDeviceMode */
355 CARD16 sequenceNumber B16;
356 CARD32 length B32;
357 CARD8 status;
358 BYTE pad1, pad2, pad3;
359 CARD32 pad01 B32;
360 CARD32 pad02 B32;
361 CARD32 pad03 B32;
362 CARD32 pad04 B32;
363 CARD32 pad05 B32;
364} xSetDeviceModeReply;
365
366/*********************************************************
367 *
368 * SelectExtensionEvent.
369 *
370 */
371
372typedef struct {
373 CARD8 reqType; /* input extension major code */
374 CARD8 ReqType; /* always X_SelectExtensionEvent */
375 CARD16 length B16;
376 Window window B32;
377 CARD16 count B16;
378 CARD16 pad00 B16;
379} xSelectExtensionEventReq;
380
381/*********************************************************
382 *
383 * GetSelectedExtensionEvent.
384 *
385 */
386
387typedef struct {
388 CARD8 reqType; /* input extension major code */
389 CARD8 ReqType; /* X_GetSelectedExtensionEvents */
390 CARD16 length B16;
391 Window window B32;
392} xGetSelectedExtensionEventsReq;
393
394typedef struct {
395 CARD8 repType; /* X_Reply */
396 CARD8 RepType; /* GetSelectedExtensionEvents */
397 CARD16 sequenceNumber B16;
398 CARD32 length B32;
399 CARD16 this_client_count B16;
400 CARD16 all_clients_count B16;
401 CARD32 pad01 B32;
402 CARD32 pad02 B32;
403 CARD32 pad03 B32;
404 CARD32 pad04 B32;
405 CARD32 pad05 B32;
406} xGetSelectedExtensionEventsReply;
407
408/*********************************************************
409 *
410 * ChangeDeviceDontPropagateList.
411 *
412 */
413
414typedef struct {
415 CARD8 reqType; /* input extension major code */
416 CARD8 ReqType; /* X_ChangeDeviceDontPropagateList */
417 CARD16 length B16;
418 Window window B32;
419 CARD16 count B16;
420 CARD8 mode;
421 BYTE pad;
422} xChangeDeviceDontPropagateListReq;
423
424/*********************************************************
425 *
426 * GetDeviceDontPropagateList.
427 *
428 */
429
430typedef struct {
431 CARD8 reqType; /* input extension major code */
432 CARD8 ReqType; /* X_GetDeviceDontPropagateList */
433 CARD16 length B16;
434 Window window B32;
435} xGetDeviceDontPropagateListReq;
436
437typedef struct {
438 CARD8 repType; /* X_Reply */
439 CARD8 RepType; /* GetDeviceDontPropagateList */
440 CARD16 sequenceNumber B16;
441 CARD32 length B32;
442 CARD16 count B16;
443 CARD16 pad00 B16;
444 CARD32 pad01 B32;
445 CARD32 pad02 B32;
446 CARD32 pad03 B32;
447 CARD32 pad04 B32;
448 CARD32 pad05 B32;
449 } xGetDeviceDontPropagateListReply;
450
451/*********************************************************
452 *
453 * GetDeviceMotionEvents.
454 *
455 */
456
457typedef struct {
458 CARD8 reqType; /* input extension major code */
459 CARD8 ReqType; /* always X_GetDeviceMotionEvents*/
460 CARD16 length B16;
461 Time start B32;
462 Time stop B32;
463 CARD8 deviceid;
464 BYTE pad1, pad2, pad3;
465} xGetDeviceMotionEventsReq;
466
467typedef struct {
468 CARD8 repType; /* X_Reply */
469 CARD8 RepType; /* always X_GetDeviceMotionEvents */
470 CARD16 sequenceNumber B16;
471 CARD32 length B32;
472 CARD32 nEvents B32;
473 CARD8 axes;
474 CARD8 mode;
475 BYTE pad1, pad2;
476 CARD32 pad01 B32;
477 CARD32 pad02 B32;
478 CARD32 pad03 B32;
479 CARD32 pad04 B32;
480} xGetDeviceMotionEventsReply;
481
482/*********************************************************
483 *
484 * ChangeKeyboardDevice.
485 *
486 */
487
488typedef struct {
489 CARD8 reqType; /* input extension major code */
490 CARD8 ReqType; /* X_ChangeKeyboardDevice */
491 CARD16 length B16;
492 CARD8 deviceid;
493 BYTE pad1, pad2, pad3;
494} xChangeKeyboardDeviceReq;
495
496typedef struct {
497 CARD8 repType; /* X_Reply */
498 CARD8 RepType; /* always X_ChangeKeyboardDevice*/
499 CARD16 sequenceNumber B16;
500 CARD32 length B32; /* 0 */
501 CARD8 status;
502 BYTE pad1, pad2, pad3;
503 CARD32 pad01 B32;
504 CARD32 pad02 B32;
505 CARD32 pad03 B32;
506 CARD32 pad04 B32;
507 CARD32 pad05 B32;
508 } xChangeKeyboardDeviceReply;
509
510/*********************************************************
511 *
512 * ChangePointerDevice.
513 *
514 */
515
516typedef struct {
517 CARD8 reqType; /* input extension major code */
518 CARD8 ReqType; /* X_ChangePointerDevice */
519 CARD16 length B16;
520 CARD8 xaxis;
521 CARD8 yaxis;
522 CARD8 deviceid;
523 BYTE pad1;
524} xChangePointerDeviceReq;
525
526typedef struct {
527 CARD8 repType; /* X_Reply */
528 CARD8 RepType; /* always X_ChangePointerDevice */
529 CARD16 sequenceNumber B16;
530 CARD32 length B32; /* 0 */
531 CARD8 status;
532 BYTE pad1, pad2, pad3;
533 CARD32 pad01 B32;
534 CARD32 pad02 B32;
535 CARD32 pad03 B32;
536 CARD32 pad04 B32;
537 CARD32 pad05 B32;
538 } xChangePointerDeviceReply;
539
540/*********************************************************
541 *
542 * GrabDevice.
543 *
544 */
545
546typedef struct {
547 CARD8 reqType; /* input extension major code */
548 CARD8 ReqType; /* always X_GrabDevice */
549 CARD16 length B16;
550 Window grabWindow B32;
551 Time time B32;
552 CARD16 event_count B16;
553 CARD8 this_device_mode;
554 CARD8 other_devices_mode;
555 BOOL ownerEvents;
556 CARD8 deviceid;
557 CARD16 pad01 B16;
558} xGrabDeviceReq;
559
560typedef struct {
561 CARD8 repType; /* X_Reply */
562 CARD8 RepType; /* always X_GrabDevice */
563 CARD16 sequenceNumber B16;
564 CARD32 length B32; /* 0 */
565 CARD8 status;
566 BYTE pad1, pad2, pad3;
567 CARD32 pad01 B32;
568 CARD32 pad02 B32;
569 CARD32 pad03 B32;
570 CARD32 pad04 B32;
571 CARD32 pad05 B32;
572 } xGrabDeviceReply;
573
574/*********************************************************
575 *
576 * UngrabDevice.
577 *
578 */
579
580typedef struct {
581 CARD8 reqType; /* input extension major code */
582 CARD8 ReqType; /* always X_UnGrabDevice */
583 CARD16 length B16;
584 Time time B32;
585 CARD8 deviceid;
586 BYTE pad1, pad2, pad3;
587} xUngrabDeviceReq;
588
589/*********************************************************
590 *
591 * GrabDeviceKey.
592 *
593 */
594
595typedef struct {
596 CARD8 reqType; /* input extension major code */
597 CARD8 ReqType; /* always X_GrabDeviceKey */
598 CARD16 length B16;
599 Window grabWindow B32;
600 CARD16 event_count B16;
601 CARD16 modifiers B16;
602 CARD8 modifier_device;
603 CARD8 grabbed_device;
604 CARD8 key;
605 BYTE this_device_mode;
606 BYTE other_devices_mode;
607 BOOL ownerEvents;
608 BYTE pad1, pad2;
609} xGrabDeviceKeyReq;
610
611/*********************************************************
612 *
613 * UngrabDeviceKey.
614 *
615 */
616
617typedef struct {
618 CARD8 reqType; /* input extension major code */
619 CARD8 ReqType; /* always X_UngrabDeviceKey */
620 CARD16 length B16;
621 Window grabWindow B32;
622 CARD16 modifiers B16;
623 CARD8 modifier_device;
624 CARD8 key;
625 CARD8 grabbed_device;
626 BYTE pad1, pad2, pad3;
627} xUngrabDeviceKeyReq;
628
629/*********************************************************
630 *
631 * GrabDeviceButton.
632 *
633 */
634
635typedef struct {
636 CARD8 reqType; /* input extension major code */
637 CARD8 ReqType; /* always X_GrabDeviceButton */
638 CARD16 length B16;
639 Window grabWindow B32;
640 CARD8 grabbed_device;
641 CARD8 modifier_device;
642 CARD16 event_count B16;
643 CARD16 modifiers B16;
644 BYTE this_device_mode;
645 BYTE other_devices_mode;
646 CARD8 button;
647 BOOL ownerEvents;
648 BYTE pad1, pad2;
649} xGrabDeviceButtonReq;
650
651/*********************************************************
652 *
653 * UngrabDeviceButton.
654 *
655 */
656
657typedef struct {
658 CARD8 reqType; /* input extension major code */
659 CARD8 ReqType; /* always X_UngrabDeviceButton */
660 CARD16 length B16;
661 Window grabWindow B32;
662 CARD16 modifiers B16;
663 CARD8 modifier_device;
664 CARD8 button;
665 CARD8 grabbed_device;
666 BYTE pad1, pad2, pad3;
667} xUngrabDeviceButtonReq;
668
669/*********************************************************
670 *
671 * AllowDeviceEvents.
672 *
673 */
674
675typedef struct {
676 CARD8 reqType; /* input extension major code */
677 CARD8 ReqType; /* always X_AllowDeviceEvents */
678 CARD16 length B16;
679 Time time B32;
680 CARD8 mode;
681 CARD8 deviceid;
682 BYTE pad1, pad2;
683} xAllowDeviceEventsReq;
684
685/*********************************************************
686 *
687 * GetDeviceFocus.
688 *
689 */
690
691typedef struct {
692 CARD8 reqType; /* input extension major code */
693 CARD8 ReqType; /* always X_GetDeviceFocus */
694 CARD16 length B16;
695 CARD8 deviceid;
696 BYTE pad1, pad2, pad3;
697} xGetDeviceFocusReq;
698
699typedef struct {
700 CARD8 repType; /* X_Reply */
701 CARD8 RepType; /* always X_GetDeviceFocus */
702 CARD16 sequenceNumber B16;
703 CARD32 length B32;
704 CARD32 focus B32;
705 Time time B32;
706 CARD8 revertTo;
707 BYTE pad1, pad2, pad3;
708 CARD32 pad01 B32;
709 CARD32 pad02 B32;
710 CARD32 pad03 B32;
711 } xGetDeviceFocusReply;
712
713/*********************************************************
714 *
715 * SetDeviceFocus.
716 *
717 */
718
719typedef struct {
720 CARD8 reqType; /* input extension major code */
721 CARD8 ReqType; /* always X_SetDeviceFocus */
722 CARD16 length B16;
723 Window focus B32;
724 Time time B32;
725 CARD8 revertTo;
726 CARD8 device;
727 CARD16 pad01 B16;
728} xSetDeviceFocusReq;
729
730/*********************************************************
731 *
732 * GetFeedbackControl.
733 *
734 */
735
736typedef struct {
737 CARD8 reqType; /* input extension major code */
738 CARD8 ReqType; /* X_GetFeedbackControl */
739 CARD16 length B16;
740 CARD8 deviceid;
741 BYTE pad1, pad2, pad3;
742} xGetFeedbackControlReq;
743
744typedef struct {
745 CARD8 repType; /* X_Reply */
746 CARD8 RepType; /* always X_GetFeedbackControl */
747 CARD16 sequenceNumber B16;
748 CARD32 length B32;
749 CARD16 num_feedbacks B16;
750 CARD16 pad01 B16;
751 CARD32 pad02 B32;
752 CARD32 pad03 B32;
753 CARD32 pad04 B32;
754 CARD32 pad05 B32;
755 CARD32 pad06 B32;
756} xGetFeedbackControlReply;
757
758typedef struct {
759#if defined(__cplusplus) || defined(c_plusplus)
760 CARD8 c_class; /* feedback class */
761#else
762 CARD8 class; /* feedback class */
763#endif
764 CARD8 id; /* feedback id */
765 CARD16 length B16; /* feedback length */
766} xFeedbackState;
767
768typedef struct {
769#if defined(__cplusplus) || defined(c_plusplus)
770 CARD8 c_class;
771#else
772 CARD8 class;
773#endif
774 CARD8 id;
775 CARD16 length B16;
776 CARD16 pitch B16;
777 CARD16 duration B16;
778 CARD32 led_mask B32;
779 CARD32 led_values B32;
780 BOOL global_auto_repeat;
781 CARD8 click;
782 CARD8 percent;
783 BYTE pad;
784 BYTE auto_repeats[32];
785} xKbdFeedbackState;
786
787typedef struct {
788#if defined(__cplusplus) || defined(c_plusplus)
789 CARD8 c_class;
790#else
791 CARD8 class;
792#endif
793 CARD8 id;
794 CARD16 length B16;
795 CARD8 pad1,pad2;
796 CARD16 accelNum B16;
797 CARD16 accelDenom B16;
798 CARD16 threshold B16;
799} xPtrFeedbackState;
800
801typedef struct {
802#if defined(__cplusplus) || defined(c_plusplus)
803 CARD8 c_class; /* feedback class id */
804#else
805 CARD8 class; /* feedback class id */
806#endif
807 CARD8 id;
808 CARD16 length B16; /* feedback length */
809 CARD32 resolution B32;
810 INT32 min_value B32;
811 INT32 max_value B32;
812} xIntegerFeedbackState;
813
814typedef struct {
815#if defined(__cplusplus) || defined(c_plusplus)
816 CARD8 c_class; /* feedback class id */
817#else
818 CARD8 class; /* feedback class id */
819#endif
820 CARD8 id;
821 CARD16 length B16; /* feedback length */
822 CARD16 max_symbols B16;
823 CARD16 num_syms_supported B16;
824} xStringFeedbackState;
825
826typedef struct {
827#if defined(__cplusplus) || defined(c_plusplus)
828 CARD8 c_class; /* feedback class id */
829#else
830 CARD8 class; /* feedback class id */
831#endif
832 CARD8 id;
833 CARD16 length B16; /* feedback length */
834 CARD8 percent;
835 BYTE pad1, pad2, pad3;
836 CARD16 pitch B16;
837 CARD16 duration B16;
838} xBellFeedbackState;
839
840typedef struct {
841#if defined(__cplusplus) || defined(c_plusplus)
842 CARD8 c_class; /* feedback class id */
843#else
844 CARD8 class; /* feedback class id */
845#endif
846 CARD8 id;
847 CARD16 length B16; /* feedback length */
848 CARD32 led_mask B32;
849 CARD32 led_values B32;
850} xLedFeedbackState;
851
852/*********************************************************
853 *
854 * ChangeFeedbackControl.
855 *
856 */
857
858typedef struct {
859 CARD8 reqType; /* input extension major code */
860 CARD8 ReqType; /* X_ChangeFeedbackControl */
861 CARD16 length B16;
862 CARD32 mask B32;
863 CARD8 deviceid;
864 CARD8 feedbackid;
865 BYTE pad1, pad2;
866} xChangeFeedbackControlReq;
867
868typedef struct {
869#if defined(__cplusplus) || defined(c_plusplus)
870 CARD8 c_class; /* feedback class id */
871#else
872 CARD8 class; /* feedback class id */
873#endif
874 CARD8 id; /* feedback id */
875 CARD16 length B16; /* feedback length */
876} xFeedbackCtl;
877
878typedef 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 length */
885 CARD16 length B16; /* feedback length */
886 KeyCode key;
887 CARD8 auto_repeat_mode;
888 INT8 click;
889 INT8 percent;
890 INT16 pitch B16;
891 INT16 duration B16;
892 CARD32 led_mask B32;
893 CARD32 led_values B32;
894} xKbdFeedbackCtl;
895
896typedef struct {
897#if defined(__cplusplus) || defined(c_plusplus)
898 CARD8 c_class; /* feedback class id */
899#else
900 CARD8 class; /* feedback class id */
901#endif
902 CARD8 id; /* feedback id */
903 CARD16 length B16; /* feedback length */
904 CARD8 pad1,pad2;
905 INT16 num B16;
906 INT16 denom B16;
907 INT16 thresh B16;
908} xPtrFeedbackCtl;
909
910typedef struct {
911#if defined(__cplusplus) || defined(c_plusplus)
912 CARD8 c_class; /* feedback class id */
913#else
914 CARD8 class; /* feedback class id */
915#endif
916 CARD8 id; /* feedback id */
917 CARD16 length B16; /* feedback length */
918 INT32 int_to_display B32;
919} xIntegerFeedbackCtl;
920
921typedef struct {
922#if defined(__cplusplus) || defined(c_plusplus)
923 CARD8 c_class; /* feedback class id */
924#else
925 CARD8 class; /* feedback class id */
926#endif
927 CARD8 id; /* feedback id */
928 CARD16 length B16; /* feedback length */
929 CARD8 pad1,pad2;
930 CARD16 num_keysyms B16;
931} xStringFeedbackCtl;
932
933typedef struct {
934#if defined(__cplusplus) || defined(c_plusplus)
935 CARD8 c_class; /* feedback class id */
936#else
937 CARD8 class; /* feedback class id */
938#endif
939 CARD8 id; /* feedback id */
940 CARD16 length B16; /* feedback length */
941 INT8 percent;
942 BYTE pad1, pad2, pad3;
943 INT16 pitch B16;
944 INT16 duration B16;
945} xBellFeedbackCtl;
946
947typedef struct {
948#if defined(__cplusplus) || defined(c_plusplus)
949 CARD8 c_class; /* feedback class id */
950#else
951 CARD8 class; /* feedback class id */
952#endif
953 CARD8 id; /* feedback id */
954 CARD16 length B16; /* feedback length */
955 CARD32 led_mask B32;
956 CARD32 led_values B32;
957} xLedFeedbackCtl;
958
959/*********************************************************
960 *
961 * GetDeviceKeyMapping.
962 *
963 */
964
965typedef struct {
966 CARD8 reqType; /* input extension major code */
967 CARD8 ReqType; /* always X_GetDeviceKeyMapping */
968 CARD16 length B16;
969 CARD8 deviceid;
970 KeyCode firstKeyCode;
971 CARD8 count;
972 BYTE pad1;
973} xGetDeviceKeyMappingReq;
974
975typedef struct {
976 CARD8 repType; /* X_Reply */
977 CARD8 RepType; /* always X_GetDeviceKeyMapping */
978 CARD16 sequenceNumber B16;
979 CARD32 length B32;
980 CARD8 keySymsPerKeyCode;
981 CARD8 pad0;
982 CARD16 pad1 B16;
983 CARD32 pad2 B32;
984 CARD32 pad3 B32;
985 CARD32 pad4 B32;
986 CARD32 pad5 B32;
987 CARD32 pad6 B32;
988} xGetDeviceKeyMappingReply;
989
990/*********************************************************
991 *
992 * ChangeDeviceKeyMapping.
993 *
994 */
995
996typedef struct {
997 CARD8 reqType; /* input extension major code */
998 CARD8 ReqType; /* always X_ChangeDeviceKeyMapping */
999 CARD16 length B16;
1000 CARD8 deviceid;
1001 KeyCode firstKeyCode;
1002 CARD8 keySymsPerKeyCode;
1003 CARD8 keyCodes;
1004} xChangeDeviceKeyMappingReq;
1005
1006/*********************************************************
1007 *
1008 * GetDeviceModifierMapping.
1009 *
1010 */
1011
1012typedef struct {
1013 CARD8 reqType; /* input extension major code */
1014 CARD8 ReqType; /* always X_GetDeviceModifierMapping */
1015 CARD16 length B16;
1016 CARD8 deviceid;
1017 BYTE pad1, pad2, pad3;
1018} xGetDeviceModifierMappingReq;
1019
1020typedef struct {
1021 CARD8 repType; /* X_Reply */
1022 CARD8 RepType; /* always X_GetDeviceModifierMapping */
1023 CARD16 sequenceNumber B16;
1024 CARD32 length B32;
1025 CARD8 numKeyPerModifier;
1026 CARD8 pad0;
1027 CARD16 pad1 B16;
1028 CARD32 pad2 B32;
1029 CARD32 pad3 B32;
1030 CARD32 pad4 B32;
1031 CARD32 pad5 B32;
1032 CARD32 pad6 B32;
1033} xGetDeviceModifierMappingReply;
1034
1035/*********************************************************
1036 *
1037 * SetDeviceModifierMapping.
1038 *
1039 */
1040
1041typedef struct {
1042 CARD8 reqType; /* input extension major code */
1043 CARD8 ReqType; /* always X_SetDeviceModifierMapping */
1044 CARD16 length B16;
1045 CARD8 deviceid;
1046 CARD8 numKeyPerModifier;
1047 CARD16 pad1 B16;
1048} xSetDeviceModifierMappingReq;
1049
1050typedef struct {
1051 CARD8 repType; /* X_Reply */
1052 CARD8 RepType; /* always X_SetDeviceModifierMapping */
1053 CARD16 sequenceNumber B16;
1054 CARD32 length B32;
1055 CARD8 success;
1056 CARD8 pad0;
1057 CARD16 pad1 B16;
1058 CARD32 pad2 B32;
1059 CARD32 pad3 B32;
1060 CARD32 pad4 B32;
1061 CARD32 pad5 B32;
1062 CARD32 pad6 B32;
1063} xSetDeviceModifierMappingReply;
1064
1065/*********************************************************
1066 *
1067 * GetDeviceButtonMapping.
1068 *
1069 */
1070
1071typedef struct {
1072 CARD8 reqType; /* input extension major code */
1073 CARD8 ReqType; /* X_GetDeviceButtonMapping */
1074 CARD16 length B16;
1075 CARD8 deviceid;
1076 BYTE pad1, pad2, pad3;
1077} xGetDeviceButtonMappingReq;
1078
1079typedef struct {
1080 CARD8 repType; /* X_Reply */
1081 CARD8 RepType; /* always X_GetDeviceButtonMapping */
1082 CARD16 sequenceNumber B16;
1083 CARD32 length B32;
1084 CARD8 nElts;
1085 BYTE pad1, pad2, pad3;
1086 CARD32 pad01 B32;
1087 CARD32 pad02 B32;
1088 CARD32 pad03 B32;
1089 CARD32 pad04 B32;
1090 CARD32 pad05 B32;
1091} xGetDeviceButtonMappingReply;
1092
1093/*********************************************************
1094 *
1095 * SetDeviceButtonMapping.
1096 *
1097 */
1098
1099typedef struct {
1100 CARD8 reqType; /* input extension major code */
1101 CARD8 ReqType; /* X_SetDeviceButtonMapping */
1102 CARD16 length B16;
1103 CARD8 deviceid;
1104 CARD8 map_length;
1105 BYTE pad1, pad2;
1106} xSetDeviceButtonMappingReq;
1107
1108typedef struct {
1109 CARD8 repType; /* X_Reply */
1110 CARD8 RepType; /* always X_SetDeviceButtonMapping */
1111 CARD16 sequenceNumber B16;
1112 CARD32 length B32;
1113 CARD8 status;
1114 BYTE pad0;
1115 CARD16 pad1 B16;
1116 CARD32 pad2 B32;
1117 CARD32 pad3 B32;
1118 CARD32 pad4 B32;
1119 CARD32 pad5 B32;
1120 CARD32 pad6 B32;
1121} xSetDeviceButtonMappingReply;
1122
1123/*********************************************************
1124 *
1125 * QueryDeviceState.
1126 *
1127 */
1128
1129typedef struct {
1130 CARD8 reqType;
1131 CARD8 ReqType; /* always X_QueryDeviceState */
1132 CARD16 length B16;
1133 CARD8 deviceid;
1134 BYTE pad1, pad2, pad3;
1135} xQueryDeviceStateReq;
1136
1137typedef struct {
1138 CARD8 repType; /* X_Reply */
1139 CARD8 RepType; /* always X_QueryDeviceState */
1140 CARD16 sequenceNumber B16;
1141 CARD32 length B32;
1142 CARD8 num_classes;
1143 BYTE pad0;
1144 CARD16 pad1 B16;
1145 CARD32 pad2 B32;
1146 CARD32 pad3 B32;
1147 CARD32 pad4 B32;
1148 CARD32 pad5 B32;
1149 CARD32 pad6 B32;
1150} xQueryDeviceStateReply;
1151
1152typedef struct {
1153#if defined(__cplusplus) || defined(c_plusplus)
1154 CARD8 c_class;
1155#else
1156 CARD8 class;
1157#endif
1158 CARD8 length;
1159 CARD8 num_keys;
1160 BYTE pad1;
1161 CARD8 keys[32];
1162} xKeyState;
1163
1164typedef struct {
1165#if defined(__cplusplus) || defined(c_plusplus)
1166 CARD8 c_class;
1167#else
1168 CARD8 class;
1169#endif
1170 CARD8 length;
1171 CARD8 num_buttons;
1172 BYTE pad1;
1173 CARD8 buttons[32];
1174} xButtonState;
1175
1176typedef struct {
1177#if defined(__cplusplus) || defined(c_plusplus)
1178 CARD8 c_class;
1179#else
1180 CARD8 class;
1181#endif
1182 CARD8 length;
1183 CARD8 num_valuators;
1184 CARD8 mode;
1185} xValuatorState;
1186
1187/*********************************************************
1188 *
1189 * SendExtensionEvent.
1190 * THIS REQUEST MUST BE KEPT A MULTIPLE OF 8 BYTES IN LENGTH!
1191 * MORE EVENTS MAY FOLLOW AND THEY MUST BE QUAD-ALIGNED!
1192 *
1193 */
1194
1195typedef struct {
1196 CARD8 reqType;
1197 CARD8 ReqType; /* always X_SendExtensionEvent */
1198 CARD16 length B16;
1199 Window destination B32;
1200 CARD8 deviceid;
1201 BOOL propagate;
1202 CARD16 count B16;
1203 CARD8 num_events;
1204 BYTE pad1,pad2,pad3;
1205} xSendExtensionEventReq;
1206
1207/*********************************************************
1208 *
1209 * DeviceBell.
1210 *
1211 */
1212
1213typedef struct {
1214 CARD8 reqType;
1215 CARD8 ReqType; /* always X_DeviceBell */
1216 CARD16 length B16;
1217 CARD8 deviceid;
1218 CARD8 feedbackid;
1219 CARD8 feedbackclass;
1220 INT8 percent;
1221} xDeviceBellReq;
1222
1223/*********************************************************
1224 *
1225 * SetDeviceValuators.
1226 *
1227 */
1228
1229typedef struct {
1230 CARD8 reqType; /* input extension major code */
1231 CARD8 ReqType; /* always X_SetDeviceValuators */
1232 CARD16 length B16;
1233 CARD8 deviceid;
1234 CARD8 first_valuator;
1235 CARD8 num_valuators;
1236 BYTE pad1;
1237} xSetDeviceValuatorsReq;
1238
1239typedef struct {
1240 CARD8 repType; /* X_Reply */
1241 CARD8 RepType; /* always X_SetDeviceValuators */
1242 CARD16 sequenceNumber B16;
1243 CARD32 length B32;
1244 CARD8 status;
1245 BYTE pad1, pad2, pad3;
1246 CARD32 pad01 B32;
1247 CARD32 pad02 B32;
1248 CARD32 pad03 B32;
1249 CARD32 pad04 B32;
1250 CARD32 pad05 B32;
1251} xSetDeviceValuatorsReply;
1252
1253/*********************************************************
1254 *
1255 * GetDeviceControl.
1256 *
1257 */
1258
1259typedef struct {
1260 CARD8 reqType; /* input extension major code */
1261 CARD8 ReqType; /* always X_GetDeviceControl */
1262 CARD16 length B16;
1263 CARD16 control B16;
1264 CARD8 deviceid;
1265 BYTE pad2;
1266} xGetDeviceControlReq;
1267
1268typedef struct {
1269 CARD8 repType; /* X_Reply */
1270 CARD8 RepType; /* always X_GetDeviceControl */
1271 CARD16 sequenceNumber B16;
1272 CARD32 length B32;
1273 CARD8 status;
1274 BYTE pad1, pad2, pad3;
1275 CARD32 pad01 B32;
1276 CARD32 pad02 B32;
1277 CARD32 pad03 B32;
1278 CARD32 pad04 B32;
1279 CARD32 pad05 B32;
1280} xGetDeviceControlReply;
1281
1282typedef struct {
1283 CARD16 control B16; /* control type */
1284 CARD16 length B16; /* control length */
1285} xDeviceState;
1286
1287typedef struct {
1288 CARD16 control B16; /* control type */
1289 CARD16 length B16; /* control length */
1290 CARD32 num_valuators B32; /* number of valuators */
1291} xDeviceResolutionState;
1292
1293/*********************************************************
1294 *
1295 * ChangeDeviceControl.
1296 *
1297 */
1298
1299typedef struct {
1300 CARD8 reqType; /* input extension major code */
1301 CARD8 ReqType; /* always X_ChangeDeviceControl */
1302 CARD16 length B16;
1303 CARD16 control B16;
1304 CARD8 deviceid;
1305 BYTE pad0;
1306} xChangeDeviceControlReq;
1307
1308typedef struct {
1309 CARD8 repType; /* X_Reply */
1310 CARD8 RepType; /* always X_ChangeDeviceControl */
1311 CARD16 sequenceNumber B16;
1312 CARD32 length B32;
1313 CARD8 status;
1314 BYTE pad1, pad2, pad3;
1315 CARD32 pad01 B32;
1316 CARD32 pad02 B32;
1317 CARD32 pad03 B32;
1318 CARD32 pad04 B32;
1319 CARD32 pad05 B32;
1320} xChangeDeviceControlReply;
1321
1322typedef struct {
1323 CARD16 control B16; /* control type */
1324 CARD16 length B16; /* control length */
1325} xDeviceCtl;
1326
1327typedef struct {
1328 CARD16 control B16; /* control type */
1329 CARD16 length B16; /* control length */
1330 CARD8 first_valuator; /* first valuator to change */
1331 CARD8 num_valuators; /* number of valuators to change*/
1332 CARD8 pad1,pad2;
1333} xDeviceResolutionCtl;
1334
1335
1336/* Merged from Metrolink tree for XINPUT stuff */
1337
1338typedef struct {
1339 CARD16 control;
1340 CARD16 length;
1341 CARD32 min_x;
1342 CARD32 max_x;
1343 CARD32 min_y;
1344 CARD32 max_y;
1345 CARD32 button_threshold;
1346} xDeviceTSCalibrationCtl;
1347
1348/* End of merged section */
1349
1350
1351/**********************************************************
1352 *
1353 * Input extension events.
1354 *
1355 * DeviceValuator
1356 *
1357 */
1358
1359typedef struct
1360 {
1361 BYTE type;
1362 CARD8 deviceid;
1363 CARD16 sequenceNumber B16;
1364 KeyButMask device_state B16;
1365 CARD8 num_valuators;
1366 CARD8 first_valuator;
1367 INT32 valuator0 B32;
1368 INT32 valuator1 B32;
1369 INT32 valuator2 B32;
1370 INT32 valuator3 B32;
1371 INT32 valuator4 B32;
1372 INT32 valuator5 B32;
1373 } deviceValuator;
1374
1375/**********************************************************
1376 *
1377 * DeviceKeyButtonPointer.
1378 *
1379 * Used for: DeviceKeyPress, DeviceKeyRelease,
1380 * DeviceButtonPress, DeviceButtonRelease,
1381 * ProximityIn, ProximityOut
1382 * DeviceMotionNotify,
1383 *
1384 */
1385
1386typedef struct
1387 {
1388 BYTE type;
1389 BYTE detail;
1390 CARD16 sequenceNumber B16;
1391 Time time B32;
1392 Window root B32;
1393 Window event B32;
1394 Window child B32;
1395 INT16 root_x B16;
1396 INT16 root_y B16;
1397 INT16 event_x B16;
1398 INT16 event_y B16;
1399 KeyButMask state B16;
1400 BOOL same_screen;
1401 CARD8 deviceid;
1402 } deviceKeyButtonPointer;
1403
1404/**********************************************************
1405 *
1406 * DeviceFocus.
1407 *
1408 */
1409
1410typedef struct
1411 {
1412 BYTE type;
1413 BYTE detail;
1414 CARD16 sequenceNumber B16;
1415 Time time B32;
1416 Window window B32;
1417 BYTE mode;
1418 CARD8 deviceid;
1419 BYTE pad1, pad2;
1420 CARD32 pad00 B32;
1421 CARD32 pad01 B32;
1422 CARD32 pad02 B32;
1423 CARD32 pad03 B32;
1424 } deviceFocus;
1425
1426/**********************************************************
1427 *
1428 * DeviceStateNotify.
1429 *
1430 * Note that the two high-order bits in the classes_reported
1431 * field are the proximity state (InProximity or OutOfProximity),
1432 * and the device mode (Absolute or Relative), respectively.
1433 *
1434 */
1435
1436typedef struct
1437 {
1438 BYTE type;
1439 BYTE deviceid;
1440 CARD16 sequenceNumber B16;
1441 Time time B32;
1442 CARD8 num_keys;
1443 CARD8 num_buttons;
1444 CARD8 num_valuators;
1445 CARD8 classes_reported;
1446 CARD8 buttons[4];
1447 CARD8 keys[4];
1448 INT32 valuator0 B32;
1449 INT32 valuator1 B32;
1450 INT32 valuator2 B32;
1451 } deviceStateNotify;
1452
1453/**********************************************************
1454 *
1455 * DeviceKeyStateNotify.
1456 *
1457 */
1458
1459typedef struct
1460 {
1461 BYTE type;
1462 BYTE deviceid;
1463 CARD16 sequenceNumber B16;
1464 CARD8 keys[28];
1465 } deviceKeyStateNotify;
1466
1467/**********************************************************
1468 *
1469 * DeviceButtonStateNotify.
1470 *
1471 */
1472
1473typedef struct
1474 {
1475 BYTE type;
1476 BYTE deviceid;
1477 CARD16 sequenceNumber B16;
1478 CARD8 buttons[28];
1479 } deviceButtonStateNotify;
1480
1481/**********************************************************
1482 *
1483 * DeviceMappingNotify.
1484 * Fields must be kept in sync with core mappingnotify event.
1485 *
1486 */
1487
1488typedef struct
1489 {
1490 BYTE type;
1491 BYTE deviceid;
1492 CARD16 sequenceNumber B16;
1493 CARD8 request;
1494 KeyCode firstKeyCode;
1495 CARD8 count;
1496 BYTE pad1;
1497 Time time B32;
1498 CARD32 pad00 B32;
1499 CARD32 pad01 B32;
1500 CARD32 pad02 B32;
1501 CARD32 pad03 B32;
1502 CARD32 pad04 B32;
1503 } deviceMappingNotify;
1504
1505/**********************************************************
1506 *
1507 * ChangeDeviceNotify.
1508 *
1509 */
1510
1511typedef struct
1512 {
1513 BYTE type;
1514 BYTE deviceid;
1515 CARD16 sequenceNumber B16;
1516 Time time B32;
1517 CARD8 request;
1518 BYTE pad1, pad2, pad3;
1519 CARD32 pad00 B32;
1520 CARD32 pad01 B32;
1521 CARD32 pad02 B32;
1522 CARD32 pad03 B32;
1523 CARD32 pad04 B32;
1524 } changeDeviceNotify;
1525
1526#undef Window
1527#undef Time
1528#undef KeyCode
1529
1530#endif
Note: See TracBrowser for help on using the repository browser.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette