Mercurial > repos > rliterman > csp2

comparison CSP2/CSP2_env/env-d9b9114564458d9d-741b3de822f2aaca6c6caa4325c4afce/include/X11/extensions/XInput.h @ 69:33d812a61356

Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
planemo upload commit 2e9511a184a1ca667c7be0c6321a36dc4e3d116d
author jpayne
date Tue, 18 Mar 2025 17:55:14 -0400
parents
children
comparison
equal deleted inserted replaced
67:0e9998148a16 69:33d812a61356
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 /* Definitions used by the library and client */
48
49 #ifndef _XINPUT_H_
50 #define _XINPUT_H_
51
52 #include <X11/Xlib.h>
53 #include <X11/extensions/XI.h>
54
55 #define _deviceKeyPress 0
56 #define _deviceKeyRelease 1
57
58 #define _deviceButtonPress 0
59 #define _deviceButtonRelease 1
60
61 #define _deviceMotionNotify 0
62
63 #define _deviceFocusIn 0
64 #define _deviceFocusOut 1
65
66 #define _proximityIn 0
67 #define _proximityOut 1
68
69 #define _deviceStateNotify 0
70 #define _deviceMappingNotify 1
71 #define _changeDeviceNotify 2
72 /* Space of 3 between is necessary! Reserved for DeviceKeyStateNotify,
73 DeviceButtonStateNotify, DevicePresenceNotify (essentially unused). This
74 code has to be in sync with FixExtensionEvents() in xserver/Xi/extinit.c */
75 #define _propertyNotify 6
76
77 #define FindTypeAndClass(d,type,_class,classid,offset) \
78 { int _i; XInputClassInfo *_ip; \
79 type = 0; _class = 0; \
80 for (_i=0, _ip= ((XDevice *) d)->classes; \
81 _i< ((XDevice *) d)->num_classes; \
82 _i++, _ip++) \
83 if (_ip->input_class == classid) \
84 {type = _ip->event_type_base + offset; \
85 _class = ((XDevice *) d)->device_id << 8 | type;}}
86
87 #define DeviceKeyPress(d,type,_class) \
88 FindTypeAndClass(d, type, _class, KeyClass, _deviceKeyPress)
89
90 #define DeviceKeyRelease(d,type,_class) \
91 FindTypeAndClass(d, type, _class, KeyClass, _deviceKeyRelease)
92
93 #define DeviceButtonPress(d,type,_class) \
94 FindTypeAndClass(d, type, _class, ButtonClass, _deviceButtonPress)
95
96 #define DeviceButtonRelease(d,type,_class) \
97 FindTypeAndClass(d, type, _class, ButtonClass, _deviceButtonRelease)
98
99 #define DeviceMotionNotify(d,type,_class) \
100 FindTypeAndClass(d, type, _class, ValuatorClass, _deviceMotionNotify)
101
102 #define DeviceFocusIn(d,type,_class) \
103 FindTypeAndClass(d, type, _class, FocusClass, _deviceFocusIn)
104
105 #define DeviceFocusOut(d,type,_class) \
106 FindTypeAndClass(d, type, _class, FocusClass, _deviceFocusOut)
107
108 #define ProximityIn(d,type,_class) \
109 FindTypeAndClass(d, type, _class, ProximityClass, _proximityIn)
110
111 #define ProximityOut(d,type,_class) \
112 FindTypeAndClass(d, type, _class, ProximityClass, _proximityOut)
113
114 #define DeviceStateNotify(d,type,_class) \
115 FindTypeAndClass(d, type, _class, OtherClass, _deviceStateNotify)
116
117 #define DeviceMappingNotify(d,type,_class) \
118 FindTypeAndClass(d, type, _class, OtherClass, _deviceMappingNotify)
119
120 #define ChangeDeviceNotify(d,type,_class) \
121 FindTypeAndClass(d, type, _class, OtherClass, _changeDeviceNotify)
122
123 #define DevicePropertyNotify(d, type, _class) \
124 FindTypeAndClass(d, type, _class, OtherClass, _propertyNotify)
125
126 #define DevicePointerMotionHint(d,type,_class) \
127 { _class = ((XDevice *) d)->device_id << 8 | _devicePointerMotionHint;}
128
129 #define DeviceButton1Motion(d,type,_class) \
130 { _class = ((XDevice *) d)->device_id << 8 | _deviceButton1Motion;}
131
132 #define DeviceButton2Motion(d,type,_class) \
133 { _class = ((XDevice *) d)->device_id << 8 | _deviceButton2Motion;}
134
135 #define DeviceButton3Motion(d,type,_class) \
136 { _class = ((XDevice *) d)->device_id << 8 | _deviceButton3Motion;}
137
138 #define DeviceButton4Motion(d,type, _class) \
139 { _class = ((XDevice *) d)->device_id << 8 | _deviceButton4Motion;}
140
141 #define DeviceButton5Motion(d,type,_class) \
142 { _class = ((XDevice *) d)->device_id << 8 | _deviceButton5Motion;}
143
144 #define DeviceButtonMotion(d,type, _class) \
145 { _class = ((XDevice *) d)->device_id << 8 | _deviceButtonMotion;}
146
147 #define DeviceOwnerGrabButton(d,type,_class) \
148 { _class = ((XDevice *) d)->device_id << 8 | _deviceOwnerGrabButton;}
149
150 #define DeviceButtonPressGrab(d,type,_class) \
151 { _class = ((XDevice *) d)->device_id << 8 | _deviceButtonGrab;}
152
153 #define NoExtensionEvent(d,type,_class) \
154 { _class = ((XDevice *) d)->device_id << 8 | _noExtensionEvent;}
155
156
157 /* We need the declaration for DevicePresence. */
158 #if defined(__cplusplus) || defined(c_plusplus)
159 extern "C" {
160 #endif
161 extern int _XiGetDevicePresenceNotifyEvent(Display *);
162 extern void _xibaddevice( Display *dpy, int *error);
163 extern void _xibadclass( Display *dpy, int *error);
164 extern void _xibadevent( Display *dpy, int *error);
165 extern void _xibadmode( Display *dpy, int *error);
166 extern void _xidevicebusy( Display *dpy, int *error);
167 #if defined(__cplusplus) || defined(c_plusplus)
168 }
169 #endif
170
171 #define DevicePresence(dpy, type, _class) \
172 { \
173 type = _XiGetDevicePresenceNotifyEvent(dpy); \
174 _class = (0x10000 | _devicePresence); \
175 }
176
177 /* Errors */
178 #define BadDevice(dpy,error) _xibaddevice(dpy, &error)
179
180 #define BadClass(dpy,error) _xibadclass(dpy, &error)
181
182 #define BadEvent(dpy,error) _xibadevent(dpy, &error)
183
184 #define BadMode(dpy,error) _xibadmode(dpy, &error)
185
186 #define DeviceBusy(dpy,error) _xidevicebusy(dpy, &error)
187
188 typedef struct _XAnyClassinfo *XAnyClassPtr;
189
190 /***************************************************************
191 *
192 * DeviceKey events. These events are sent by input devices that
193 * support input class Keys.
194 * The location of the X pointer is reported in the coordinate
195 * fields of the x,y and x_root,y_root fields.
196 *
197 */
198
199 typedef struct
200 {
201 int type; /* of event */
202 unsigned long serial; /* # of last request processed */
203 Bool send_event; /* true if from SendEvent request */
204 Display *display; /* Display the event was read from */
205 Window window; /* "event" window reported relative to */
206 XID deviceid;
207 Window root; /* root window event occurred on */
208 Window subwindow; /* child window */
209 Time time; /* milliseconds */
210 int x, y; /* x, y coordinates in event window */
211 int x_root; /* coordinates relative to root */
212 int y_root; /* coordinates relative to root */
213 unsigned int state; /* key or button mask */
214 unsigned int keycode; /* detail */
215 Bool same_screen; /* same screen flag */
216 unsigned int device_state; /* device key or button mask */
217 unsigned char axes_count;
218 unsigned char first_axis;
219 int axis_data[6];
220 } XDeviceKeyEvent;
221
222 typedef XDeviceKeyEvent XDeviceKeyPressedEvent;
223 typedef XDeviceKeyEvent XDeviceKeyReleasedEvent;
224
225 /*******************************************************************
226 *
227 * DeviceButton events. These events are sent by extension devices
228 * that support input class Buttons.
229 *
230 */
231
232 typedef struct {
233 int type; /* of event */
234 unsigned long serial; /* # of last request processed by server */
235 Bool send_event; /* true if from a SendEvent request */
236 Display *display; /* Display the event was read from */
237 Window window; /* "event" window reported relative to */
238 XID deviceid;
239 Window root; /* root window that the event occurred on */
240 Window subwindow; /* child window */
241 Time time; /* milliseconds */
242 int x, y; /* x, y coordinates in event window */
243 int x_root; /* coordinates relative to root */
244 int y_root; /* coordinates relative to root */
245 unsigned int state; /* key or button mask */
246 unsigned int button; /* detail */
247 Bool same_screen; /* same screen flag */
248 unsigned int device_state; /* device key or button mask */
249 unsigned char axes_count;
250 unsigned char first_axis;
251 int axis_data[6];
252 } XDeviceButtonEvent;
253
254 typedef XDeviceButtonEvent XDeviceButtonPressedEvent;
255 typedef XDeviceButtonEvent XDeviceButtonReleasedEvent;
256
257 /*******************************************************************
258 *
259 * DeviceMotionNotify event. These events are sent by extension devices
260 * that support input class Valuators.
261 *
262 */
263
264 typedef struct
265 {
266 int type; /* of event */
267 unsigned long serial; /* # of last request processed by server */
268 Bool send_event; /* true if from a SendEvent request */
269 Display *display; /* Display the event was read from */
270 Window window; /* "event" window reported relative to */
271 XID deviceid;
272 Window root; /* root window that the event occurred on */
273 Window subwindow; /* child window */
274 Time time; /* milliseconds */
275 int x, y; /* x, y coordinates in event window */
276 int x_root; /* coordinates relative to root */
277 int y_root; /* coordinates relative to root */
278 unsigned int state; /* key or button mask */
279 char is_hint; /* detail */
280 Bool same_screen; /* same screen flag */
281 unsigned int device_state; /* device key or button mask */
282 unsigned char axes_count;
283 unsigned char first_axis;
284 int axis_data[6];
285 } XDeviceMotionEvent;
286
287 /*******************************************************************
288 *
289 * DeviceFocusChange events. These events are sent when the focus
290 * of an extension device that can be focused is changed.
291 *
292 */
293
294 typedef struct
295 {
296 int type; /* of event */
297 unsigned long serial; /* # of last request processed by server */
298 Bool send_event; /* true if from a SendEvent request */
299 Display *display; /* Display the event was read from */
300 Window window; /* "event" window reported relative to */
301 XID deviceid;
302 int mode; /* NotifyNormal, NotifyGrab, NotifyUngrab */
303 int detail;
304 /*
305 * NotifyAncestor, NotifyVirtual, NotifyInferior,
306 * NotifyNonLinear,NotifyNonLinearVirtual, NotifyPointer,
307 * NotifyPointerRoot, NotifyDetailNone
308 */
309 Time time;
310 } XDeviceFocusChangeEvent;
311
312 typedef XDeviceFocusChangeEvent XDeviceFocusInEvent;
313 typedef XDeviceFocusChangeEvent XDeviceFocusOutEvent;
314
315 /*******************************************************************
316 *
317 * ProximityNotify events. These events are sent by those absolute
318 * positioning devices that are capable of generating proximity information.
319 *
320 */
321
322 typedef struct
323 {
324 int type; /* ProximityIn or ProximityOut */
325 unsigned long serial; /* # of last request processed by server */
326 Bool send_event; /* true if this came from a SendEvent request */
327 Display *display; /* Display the event was read from */
328 Window window;
329 XID deviceid;
330 Window root;
331 Window subwindow;
332 Time time;
333 int x, y;
334 int x_root, y_root;
335 unsigned int state;
336 Bool same_screen;
337 unsigned int device_state; /* device key or button mask */
338 unsigned char axes_count;
339 unsigned char first_axis;
340 int axis_data[6];
341 } XProximityNotifyEvent;
342 typedef XProximityNotifyEvent XProximityInEvent;
343 typedef XProximityNotifyEvent XProximityOutEvent;
344
345 /*******************************************************************
346 *
347 * DeviceStateNotify events are generated on EnterWindow and FocusIn
348 * for those clients who have selected DeviceState.
349 *
350 */
351
352 typedef struct
353 {
354 #if defined(__cplusplus) || defined(c_plusplus)
355 unsigned char c_class;
356 #else
357 unsigned char class;
358 #endif
359 unsigned char length;
360 } XInputClass;
361
362 typedef struct {
363 int type;
364 unsigned long serial; /* # of last request processed by server */
365 Bool send_event; /* true if this came from a SendEvent request */
366 Display *display; /* Display the event was read from */
367 Window window;
368 XID deviceid;
369 Time time;
370 int num_classes;
371 char data[64];
372 } XDeviceStateNotifyEvent;
373
374 typedef struct {
375 #if defined(__cplusplus) || defined(c_plusplus)
376 unsigned char c_class;
377 #else
378 unsigned char class;
379 #endif
380 unsigned char length;
381 unsigned char num_valuators;
382 unsigned char mode;
383 int valuators[6];
384 } XValuatorStatus;
385
386 typedef struct {
387 #if defined(__cplusplus) || defined(c_plusplus)
388 unsigned char c_class;
389 #else
390 unsigned char class;
391 #endif
392 unsigned char length;
393 short num_keys;
394 char keys[32];
395 } XKeyStatus;
396
397 typedef struct {
398 #if defined(__cplusplus) || defined(c_plusplus)
399 unsigned char c_class;
400 #else
401 unsigned char class;
402 #endif
403 unsigned char length;
404 short num_buttons;
405 char buttons[32];
406 } XButtonStatus;
407
408 /*******************************************************************
409 *
410 * DeviceMappingNotify event. This event is sent when the key mapping,
411 * modifier mapping, or button mapping of an extension device is changed.
412 *
413 */
414
415 typedef struct {
416 int type;
417 unsigned long serial; /* # of last request processed by server */
418 Bool send_event; /* true if this came from a SendEvent request */
419 Display *display; /* Display the event was read from */
420 Window window; /* unused */
421 XID deviceid;
422 Time time;
423 int request; /* one of MappingModifier, MappingKeyboard,
424 MappingPointer */
425 int first_keycode;/* first keycode */
426 int count; /* defines range of change w. first_keycode*/
427 } XDeviceMappingEvent;
428
429 /*******************************************************************
430 *
431 * ChangeDeviceNotify event. This event is sent when an
432 * XChangeKeyboard or XChangePointer request is made.
433 *
434 */
435
436 typedef struct {
437 int type;
438 unsigned long serial; /* # of last request processed by server */
439 Bool send_event; /* true if this came from a SendEvent request */
440 Display *display; /* Display the event was read from */
441 Window window; /* unused */
442 XID deviceid;
443 Time time;
444 int request; /* NewPointer or NewKeyboard */
445 } XChangeDeviceNotifyEvent;
446
447 /*******************************************************************
448 *
449 * DevicePresenceNotify event. This event is sent when the list of
450 * input devices changes, in which case devchange will be false, and
451 * no information about the change will be contained in the event;
452 * the client should use XListInputDevices() to learn what has changed.
453 *
454 * If devchange is true, an attribute that the server believes is
455 * important has changed on a device, and the client should use
456 * XGetDeviceControl to examine the device. If control is non-zero,
457 * then that control has changed meaningfully.
458 */
459
460 typedef struct {
461 int type;
462 unsigned long serial; /* # of last request processed by server */
463 Bool send_event; /* true if this came from a SendEvent request */
464 Display *display; /* Display the event was read from */
465 Window window; /* unused */
466 Time time;
467 Bool devchange;
468 XID deviceid;
469 XID control;
470 } XDevicePresenceNotifyEvent;
471
472 /*
473 * Notifies the client that a property on a device has changed value. The
474 * client is expected to query the server for updated value of the property.
475 */
476 typedef struct {
477 int type;
478 unsigned long serial; /* # of last request processed by server */
479 Bool send_event; /* true if this came from a SendEvent request */
480 Display *display; /* Display the event was read from */
481 Window window; /* unused */
482 Time time;
483 XID deviceid; /* id of the device that changed */
484 Atom atom; /* the property that changed */
485 int state; /* PropertyNewValue or PropertyDeleted */
486 } XDevicePropertyNotifyEvent;
487
488
489 /*******************************************************************
490 *
491 * Control structures for input devices that support input class
492 * Feedback. These are used by the XGetFeedbackControl and
493 * XChangeFeedbackControl functions.
494 *
495 */
496
497 typedef struct {
498 #if defined(__cplusplus) || defined(c_plusplus)
499 XID c_class;
500 #else
501 XID class;
502 #endif
503 int length;
504 XID id;
505 } XFeedbackState;
506
507 typedef struct {
508 #if defined(__cplusplus) || defined(c_plusplus)
509 XID c_class;
510 #else
511 XID class;
512 #endif
513 int length;
514 XID id;
515 int click;
516 int percent;
517 int pitch;
518 int duration;
519 int led_mask;
520 int global_auto_repeat;
521 char auto_repeats[32];
522 } XKbdFeedbackState;
523
524 typedef struct {
525 #if defined(__cplusplus) || defined(c_plusplus)
526 XID c_class;
527 #else
528 XID class;
529 #endif
530 int length;
531 XID id;
532 int accelNum;
533 int accelDenom;
534 int threshold;
535 } XPtrFeedbackState;
536
537 typedef struct {
538 #if defined(__cplusplus) || defined(c_plusplus)
539 XID c_class;
540 #else
541 XID class;
542 #endif
543 int length;
544 XID id;
545 int resolution;
546 int minVal;
547 int maxVal;
548 } XIntegerFeedbackState;
549
550 typedef struct {
551 #if defined(__cplusplus) || defined(c_plusplus)
552 XID c_class;
553 #else
554 XID class;
555 #endif
556 int length;
557 XID id;
558 int max_symbols;
559 int num_syms_supported;
560 KeySym *syms_supported;
561 } XStringFeedbackState;
562
563 typedef struct {
564 #if defined(__cplusplus) || defined(c_plusplus)
565 XID c_class;
566 #else
567 XID class;
568 #endif
569 int length;
570 XID id;
571 int percent;
572 int pitch;
573 int duration;
574 } XBellFeedbackState;
575
576 typedef struct {
577 #if defined(__cplusplus) || defined(c_plusplus)
578 XID c_class;
579 #else
580 XID class;
581 #endif
582 int length;
583 XID id;
584 int led_values;
585 int led_mask;
586 } XLedFeedbackState;
587
588 typedef struct {
589 #if defined(__cplusplus) || defined(c_plusplus)
590 XID c_class;
591 #else
592 XID class;
593 #endif
594 int length;
595 XID id;
596 } XFeedbackControl;
597
598 typedef struct {
599 #if defined(__cplusplus) || defined(c_plusplus)
600 XID c_class;
601 #else
602 XID class;
603 #endif
604 int length;
605 XID id;
606 int accelNum;
607 int accelDenom;
608 int threshold;
609 } XPtrFeedbackControl;
610
611 typedef struct {
612 #if defined(__cplusplus) || defined(c_plusplus)
613 XID c_class;
614 #else
615 XID class;
616 #endif
617 int length;
618 XID id;
619 int click;
620 int percent;
621 int pitch;
622 int duration;
623 int led_mask;
624 int led_value;
625 int key;
626 int auto_repeat_mode;
627 } XKbdFeedbackControl;
628
629 typedef struct {
630 #if defined(__cplusplus) || defined(c_plusplus)
631 XID c_class;
632 #else
633 XID class;
634 #endif
635 int length;
636 XID id;
637 int num_keysyms;
638 KeySym *syms_to_display;
639 } XStringFeedbackControl;
640
641 typedef struct {
642 #if defined(__cplusplus) || defined(c_plusplus)
643 XID c_class;
644 #else
645 XID class;
646 #endif
647 int length;
648 XID id;
649 int int_to_display;
650 } XIntegerFeedbackControl;
651
652 typedef struct {
653 #if defined(__cplusplus) || defined(c_plusplus)
654 XID c_class;
655 #else
656 XID class;
657 #endif
658 int length;
659 XID id;
660 int percent;
661 int pitch;
662 int duration;
663 } XBellFeedbackControl;
664
665 typedef struct {
666 #if defined(__cplusplus) || defined(c_plusplus)
667 XID c_class;
668 #else
669 XID class;
670 #endif
671 int length;
672 XID id;
673 int led_mask;
674 int led_values;
675 } XLedFeedbackControl;
676
677 /*******************************************************************
678 *
679 * Device control structures.
680 *
681 */
682
683 typedef struct {
684 XID control;
685 int length;
686 } XDeviceControl;
687
688 typedef struct {
689 XID control;
690 int length;
691 int first_valuator;
692 int num_valuators;
693 int *resolutions;
694 } XDeviceResolutionControl;
695
696 typedef struct {
697 XID control;
698 int length;
699 int num_valuators;
700 int *resolutions;
701 int *min_resolutions;
702 int *max_resolutions;
703 } XDeviceResolutionState;
704
705 typedef struct {
706 XID control;
707 int length;
708 int min_x;
709 int max_x;
710 int min_y;
711 int max_y;
712 int flip_x;
713 int flip_y;
714 int rotation;
715 int button_threshold;
716 } XDeviceAbsCalibControl, XDeviceAbsCalibState;
717
718 typedef struct {
719 XID control;
720 int length;
721 int offset_x;
722 int offset_y;
723 int width;
724 int height;
725 int screen;
726 XID following;
727 } XDeviceAbsAreaControl, XDeviceAbsAreaState;
728
729 typedef struct {
730 XID control;
731 int length;
732 int status;
733 } XDeviceCoreControl;
734
735 typedef struct {
736 XID control;
737 int length;
738 int status;
739 int iscore;
740 } XDeviceCoreState;
741
742 typedef struct {
743 XID control;
744 int length;
745 int enable;
746 } XDeviceEnableControl, XDeviceEnableState;
747
748 /*******************************************************************
749 *
750 * An array of XDeviceList structures is returned by the
751 * XListInputDevices function. Each entry contains information
752 * about one input device. Among that information is an array of
753 * pointers to structures that describe the characteristics of
754 * the input device.
755 *
756 */
757
758 typedef struct _XAnyClassinfo {
759 #if defined(__cplusplus) || defined(c_plusplus)
760 XID c_class;
761 #else
762 XID class;
763 #endif
764 int length;
765 } XAnyClassInfo;
766
767 typedef struct _XDeviceInfo *XDeviceInfoPtr;
768
769 typedef struct _XDeviceInfo
770 {
771 XID id;
772 Atom type;
773 char *name;
774 int num_classes;
775 int use;
776 XAnyClassPtr inputclassinfo;
777 } XDeviceInfo;
778
779 typedef struct _XKeyInfo *XKeyInfoPtr;
780
781 typedef struct _XKeyInfo
782 {
783 #if defined(__cplusplus) || defined(c_plusplus)
784 XID c_class;
785 #else
786 XID class;
787 #endif
788 int length;
789 unsigned short min_keycode;
790 unsigned short max_keycode;
791 unsigned short num_keys;
792 } XKeyInfo;
793
794 typedef struct _XButtonInfo *XButtonInfoPtr;
795
796 typedef struct _XButtonInfo {
797 #if defined(__cplusplus) || defined(c_plusplus)
798 XID c_class;
799 #else
800 XID class;
801 #endif
802 int length;
803 short num_buttons;
804 } XButtonInfo;
805
806 typedef struct _XAxisInfo *XAxisInfoPtr;
807
808 typedef struct _XAxisInfo {
809 int resolution;
810 int min_value;
811 int max_value;
812 } XAxisInfo;
813
814 typedef struct _XValuatorInfo *XValuatorInfoPtr;
815
816 typedef struct _XValuatorInfo
817 {
818 #if defined(__cplusplus) || defined(c_plusplus)
819 XID c_class;
820 #else
821 XID class;
822 #endif
823 int length;
824 unsigned char num_axes;
825 unsigned char mode;
826 unsigned long motion_buffer;
827 XAxisInfoPtr axes;
828 } XValuatorInfo;
829
830 /*******************************************************************
831 *
832 * An XDevice structure is returned by the XOpenDevice function.
833 * It contains an array of pointers to XInputClassInfo structures.
834 * Each contains information about a class of input supported by the
835 * device, including a pointer to an array of data for each type of event
836 * the device reports.
837 *
838 */
839
840
841 typedef struct {
842 unsigned char input_class;
843 unsigned char event_type_base;
844 } XInputClassInfo;
845
846 typedef struct {
847 XID device_id;
848 int num_classes;
849 XInputClassInfo *classes;
850 } XDevice;
851
852
853 /*******************************************************************
854 *
855 * The following structure is used to return information for the
856 * XGetSelectedExtensionEvents function.
857 *
858 */
859
860 typedef struct {
861 XEventClass event_type;
862 XID device;
863 } XEventList;
864
865 /*******************************************************************
866 *
867 * The following structure is used to return motion history data from
868 * an input device that supports the input class Valuators.
869 * This information is returned by the XGetDeviceMotionEvents function.
870 *
871 */
872
873 typedef struct {
874 Time time;
875 int *data;
876 } XDeviceTimeCoord;
877
878
879 /*******************************************************************
880 *
881 * Device state structure.
882 * This is returned by the XQueryDeviceState request.
883 *
884 */
885
886 typedef struct {
887 XID device_id;
888 int num_classes;
889 XInputClass *data;
890 } XDeviceState;
891
892 /*******************************************************************
893 *
894 * Note that the mode field is a bitfield that reports the Proximity
895 * status of the device as well as the mode. The mode field should
896 * be OR'd with the mask DeviceMode and compared with the values
897 * Absolute and Relative to determine the mode, and should be OR'd
898 * with the mask ProximityState and compared with the values InProximity
899 * and OutOfProximity to determine the proximity state.
900 *
901 */
902
903 typedef struct {
904 #if defined(__cplusplus) || defined(c_plusplus)
905 unsigned char c_class;
906 #else
907 unsigned char class;
908 #endif
909 unsigned char length;
910 unsigned char num_valuators;
911 unsigned char mode;
912 int *valuators;
913 } XValuatorState;
914
915 typedef struct {
916 #if defined(__cplusplus) || defined(c_plusplus)
917 unsigned char c_class;
918 #else
919 unsigned char class;
920 #endif
921 unsigned char length;
922 short num_keys;
923 char keys[32];
924 } XKeyState;
925
926 typedef struct {
927 #if defined(__cplusplus) || defined(c_plusplus)
928 unsigned char c_class;
929 #else
930 unsigned char class;
931 #endif
932 unsigned char length;
933 short num_buttons;
934 char buttons[32];
935 } XButtonState;
936
937
938
939 /*******************************************************************
940 *
941 * Function definitions.
942 *
943 */
944
945 _XFUNCPROTOBEGIN
946
947 extern int XChangeKeyboardDevice(
948 Display* /* display */,
949 XDevice* /* device */
950 );
951
952 extern int XChangePointerDevice(
953 Display* /* display */,
954 XDevice* /* device */,
955 int /* xaxis */,
956 int /* yaxis */
957 );
958
959 extern int XGrabDevice(
960 Display* /* display */,
961 XDevice* /* device */,
962 Window /* grab_window */,
963 Bool /* ownerEvents */,
964 int /* event count */,
965 XEventClass* /* event_list */,
966 int /* this_device_mode */,
967 int /* other_devices_mode */,
968 Time /* time */
969 );
970
971 extern int XUngrabDevice(
972 Display* /* display */,
973 XDevice* /* device */,
974 Time /* time */
975 );
976
977 extern int XGrabDeviceKey(
978 Display* /* display */,
979 XDevice* /* device */,
980 unsigned int /* key */,
981 unsigned int /* modifiers */,
982 XDevice* /* modifier_device */,
983 Window /* grab_window */,
984 Bool /* owner_events */,
985 unsigned int /* event_count */,
986 XEventClass* /* event_list */,
987 int /* this_device_mode */,
988 int /* other_devices_mode */
989 );
990
991 extern int XUngrabDeviceKey(
992 Display* /* display */,
993 XDevice* /* device */,
994 unsigned int /* key */,
995 unsigned int /* modifiers */,
996 XDevice* /* modifier_dev */,
997 Window /* grab_window */
998 );
999
1000 extern int XGrabDeviceButton(
1001 Display* /* display */,
1002 XDevice* /* device */,
1003 unsigned int /* button */,
1004 unsigned int /* modifiers */,
1005 XDevice* /* modifier_device */,
1006 Window /* grab_window */,
1007 Bool /* owner_events */,
1008 unsigned int /* event_count */,
1009 XEventClass* /* event_list */,
1010 int /* this_device_mode */,
1011 int /* other_devices_mode */
1012 );
1013
1014 extern int XUngrabDeviceButton(
1015 Display* /* display */,
1016 XDevice* /* device */,
1017 unsigned int /* button */,
1018 unsigned int /* modifiers */,
1019 XDevice* /* modifier_dev */,
1020 Window /* grab_window */
1021 );
1022
1023 extern int XAllowDeviceEvents(
1024 Display* /* display */,
1025 XDevice* /* device */,
1026 int /* event_mode */,
1027 Time /* time */
1028 );
1029
1030 extern int XGetDeviceFocus(
1031 Display* /* display */,
1032 XDevice* /* device */,
1033 Window* /* focus */,
1034 int* /* revert_to */,
1035 Time* /* time */
1036 );
1037
1038 extern int XSetDeviceFocus(
1039 Display* /* display */,
1040 XDevice* /* device */,
1041 Window /* focus */,
1042 int /* revert_to */,
1043 Time /* time */
1044 );
1045
1046 extern XFeedbackState *XGetFeedbackControl(
1047 Display* /* display */,
1048 XDevice* /* device */,
1049 int* /* num_feedbacks */
1050 );
1051
1052 extern void XFreeFeedbackList(
1053 XFeedbackState* /* list */
1054 );
1055
1056 extern int XChangeFeedbackControl(
1057 Display* /* display */,
1058 XDevice* /* device */,
1059 unsigned long /* mask */,
1060 XFeedbackControl* /* f */
1061 );
1062
1063 extern int XDeviceBell(
1064 Display* /* display */,
1065 XDevice* /* device */,
1066 XID /* feedbackclass */,
1067 XID /* feedbackid */,
1068 int /* percent */
1069 );
1070
1071 extern KeySym *XGetDeviceKeyMapping(
1072 Display* /* display */,
1073 XDevice* /* device */,
1074 #if NeedWidePrototypes
1075 unsigned int /* first */,
1076 #else
1077 KeyCode /* first */,
1078 #endif
1079 int /* keycount */,
1080 int* /* syms_per_code */
1081 );
1082
1083 extern int XChangeDeviceKeyMapping(
1084 Display* /* display */,
1085 XDevice* /* device */,
1086 int /* first */,
1087 int /* syms_per_code */,
1088 KeySym* /* keysyms */,
1089 int /* count */
1090 );
1091
1092 extern XModifierKeymap *XGetDeviceModifierMapping(
1093 Display* /* display */,
1094 XDevice* /* device */
1095 );
1096
1097 extern int XSetDeviceModifierMapping(
1098 Display* /* display */,
1099 XDevice* /* device */,
1100 XModifierKeymap* /* modmap */
1101 );
1102
1103 extern int XSetDeviceButtonMapping(
1104 Display* /* display */,
1105 XDevice* /* device */,
1106 unsigned char* /* map[] */,
1107 int /* nmap */
1108 );
1109
1110 extern int XGetDeviceButtonMapping(
1111 Display* /* display */,
1112 XDevice* /* device */,
1113 unsigned char* /* map[] */,
1114 unsigned int /* nmap */
1115 );
1116
1117 extern XDeviceState *XQueryDeviceState(
1118 Display* /* display */,
1119 XDevice* /* device */
1120 );
1121
1122 extern void XFreeDeviceState(
1123 XDeviceState* /* list */
1124 );
1125
1126 extern XExtensionVersion *XGetExtensionVersion(
1127 Display* /* display */,
1128 _Xconst char* /* name */
1129 );
1130
1131 extern XDeviceInfo *XListInputDevices(
1132 Display* /* display */,
1133 int* /* ndevices */
1134 );
1135
1136 extern void XFreeDeviceList(
1137 XDeviceInfo* /* list */
1138 );
1139
1140 extern XDevice *XOpenDevice(
1141 Display* /* display */,
1142 XID /* id */
1143 );
1144
1145 extern int XCloseDevice(
1146 Display* /* display */,
1147 XDevice* /* device */
1148 );
1149
1150 extern int XSetDeviceMode(
1151 Display* /* display */,
1152 XDevice* /* device */,
1153 int /* mode */
1154 );
1155
1156 extern int XSetDeviceValuators(
1157 Display* /* display */,
1158 XDevice* /* device */,
1159 int* /* valuators */,
1160 int /* first_valuator */,
1161 int /* num_valuators */
1162 );
1163
1164 extern XDeviceControl *XGetDeviceControl(
1165 Display* /* display */,
1166 XDevice* /* device */,
1167 int /* control */
1168 );
1169
1170 extern int XChangeDeviceControl(
1171 Display* /* display */,
1172 XDevice* /* device */,
1173 int /* control */,
1174 XDeviceControl* /* d */
1175 );
1176
1177 extern int XSelectExtensionEvent(
1178 Display* /* display */,
1179 Window /* w */,
1180 XEventClass* /* event_list */,
1181 int /* count */
1182 );
1183
1184 extern int XGetSelectedExtensionEvents(
1185 Display* /* display */,
1186 Window /* w */,
1187 int* /* this_client_count */,
1188 XEventClass** /* this_client_list */,
1189 int* /* all_clients_count */,
1190 XEventClass** /* all_clients_list */
1191 );
1192
1193 extern int XChangeDeviceDontPropagateList(
1194 Display* /* display */,
1195 Window /* window */,
1196 int /* count */,
1197 XEventClass* /* events */,
1198 int /* mode */
1199 );
1200
1201 extern XEventClass *XGetDeviceDontPropagateList(
1202 Display* /* display */,
1203 Window /* window */,
1204 int* /* count */
1205 );
1206
1207 extern Status XSendExtensionEvent(
1208 Display* /* display */,
1209 XDevice* /* device */,
1210 Window /* dest */,
1211 Bool /* prop */,
1212 int /* count */,
1213 XEventClass* /* list */,
1214 XEvent* /* event */
1215 );
1216
1217 extern XDeviceTimeCoord *XGetDeviceMotionEvents(
1218 Display* /* display */,
1219 XDevice* /* device */,
1220 Time /* start */,
1221 Time /* stop */,
1222 int* /* nEvents */,
1223 int* /* mode */,
1224 int* /* axis_count */
1225 );
1226
1227 extern void XFreeDeviceMotionEvents(
1228 XDeviceTimeCoord* /* events */
1229 );
1230
1231 extern void XFreeDeviceControl(
1232 XDeviceControl* /* control */
1233 );
1234
1235 extern Atom* XListDeviceProperties(
1236 Display* /* dpy */,
1237 XDevice* /* dev */,
1238 int* /* nprops_return */
1239 );
1240
1241 extern void XChangeDeviceProperty(
1242 Display* /* dpy */,
1243 XDevice* /* dev */,
1244 Atom /* property */,
1245 Atom /* type */,
1246 int /* format */,
1247 int /* mode */,
1248 _Xconst unsigned char * /*data */,
1249 int /* nelements */
1250 );
1251
1252 extern void
1253 XDeleteDeviceProperty(
1254 Display* /* dpy */,
1255 XDevice* /* dev */,
1256 Atom /* property */
1257 );
1258
1259 extern Status
1260 XGetDeviceProperty(
1261 Display* /* dpy*/,
1262 XDevice* /* dev*/,
1263 Atom /* property*/,
1264 long /* offset*/,
1265 long /* length*/,
1266 Bool /* delete*/,
1267 Atom /* req_type*/,
1268 Atom* /* actual_type*/,
1269 int* /* actual_format*/,
1270 unsigned long* /* nitems*/,
1271 unsigned long* /* bytes_after*/,
1272 unsigned char** /* prop*/
1273 );
1274
1275 _XFUNCPROTOEND
1276
1277 #endif /* _XINPUT_H_ */