← Back to branch summary

~ubuntu-branches/ubuntu/karmic/virtualbox-ose/karmic-updates

« back to all changes in this revision

Viewing changes to src/VBox/Additions/x11/x11include/7.0/X11/extensions/XIproto.h

  • Committer: Bazaar Package Importer
  • Author(s): Felix Geyer
  • Date: 2009-09-14 18:25:07 UTC
  • mfrom: (0.4.1 squeeze)
  • Revision ID: james.westby@ubuntu.com-20090914182507-c98g07mq16hjmn6d
Tags: 3.0.6-dfsg-1ubuntu1
https://launchpad.net/bugs/429697
https://launchpad.net/bugs/267097
https://launchpad.net/bugs/288590
https://launchpad.net/bugs/379878
* Merge from debian unstable (LP: #429697), remaining changes:
  - Enable DKMS support on virtualbox host and guest modules (LP: #267097)
    - Drop virtualbox-ose{-guest,}-modules-* package templates
    - Recommend *-source instead of *-modules packages
    - Replace error messages related to missing/mismatched
      kernel module accordingly
  - Autoload kernel module
    - LOAD_VBOXDRV_MODULE=1 in virtualbox-ose.default
  - Disable update action
    - patches/u01-disable-update-action.dpatch
  - Virtualbox should go in Accessories, not in System tools (LP: #288590)
    - virtualbox-ose-qt.files/virtualbox-ose.desktop
  - Add apport hook
    - virtualbox-ose.files/source_virtualbox-ose.py
    - virtualbox-ose.install
  - Add launchpad integration
    - control
    - lpi-bug.xpm
    - patches/u02-lp-integration.dpatch
  - virtualbox, virtualbox-* (names of the upstream proprietary packages)
    conflict with virtualbox-ose (LP: #379878)
* Make debug package depend on normal or guest utils package
* Drop patches/22-pulseaudio-stubs.dpatch (applied upstream)
* Rename Ubuntu specific patches to uXX-*.dpatch
* Fix lintian warnings in maintainer scripts

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/VBox/Additions/x11/x11include/7.0/X11/extensions/XIproto.h
1
 
/* $Xorg: XIproto.h,v 1.5 2001/02/09 02:03:24 xorgcvs Exp $ */
2
 
 
3
 
/************************************************************
4
 
 
5
 
Copyright 1989, 1998  The Open Group
6
 
 
7
 
Permission to use, copy, modify, distribute, and sell this software and its
8
 
documentation for any purpose is hereby granted without fee, provided that
9
 
the above copyright notice appear in all copies and that both that
10
 
copyright notice and this permission notice appear in supporting
11
 
documentation.
12
 
 
13
 
The above copyright notice and this permission notice shall be included in
14
 
all copies or substantial portions of the Software.
15
 
 
16
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17
 
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18
 
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL THE
19
 
OPEN GROUP BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN
20
 
AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
21
 
CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
22
 
 
23
 
Except as contained in this notice, the name of The Open Group shall not be
24
 
used in advertising or otherwise to promote the sale, use or other dealings
25
 
in this Software without prior written authorization from The Open Group.
26
 
 
27
 
Copyright 1989 by Hewlett-Packard Company, Palo Alto, California.
28
 
 
29
 
                        All Rights Reserved
30
 
 
31
 
Permission to use, copy, modify, and distribute this software and its
32
 
documentation for any purpose and without fee is hereby granted,
33
 
provided that the above copyright notice appear in all copies and that
34
 
both that copyright notice and this permission notice appear in
35
 
supporting documentation, and that the name of Hewlett-Packard not be
36
 
used in advertising or publicity pertaining to distribution of the
37
 
software without specific, written prior permission.
38
 
 
39
 
HEWLETT-PACKARD DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
40
 
ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
41
 
HEWLETT-PACKARD BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
42
 
ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
43
 
WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
44
 
ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
45
 
SOFTWARE.
46
 
 
47
 
********************************************************/
48
 
/* $XFree86: xc/include/extensions/XIproto.h,v 1.4 2001/01/17 17:53:17 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
 
 
80
 
typedef struct  _XExtEventInfo
81
 
    {
82
 
    Mask        mask;
83
 
    BYTE        type;
84
 
    BYTE        word;
85
 
    } XExtEventInfo;
86
 
 
87
 
typedef unsigned char *Pointer;
88
 
 
89
 
struct 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
 
 
167
 
typedef 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
 
 
175
 
typedef 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
 
 
196
 
typedef struct {
197
 
    CARD8       reqType;        /* input extension major code   */
198
 
    CARD8       ReqType;        /* always X_ListInputDevices    */
199
 
    CARD16      length B16;
200
 
} xListInputDevicesReq;
201
 
 
202
 
typedef 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
 
 
216
 
typedef struct _xDeviceInfo *xDeviceInfoPtr;
217
 
 
218
 
typedef struct _xAnyClassinfo *xAnyClassPtr;
219
 
 
220
 
typedef 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
 
 
229
 
typedef struct _xDeviceInfo {
230
 
    CARD32      type B32;
231
 
    CARD8       id;
232
 
    CARD8       num_classes;
233
 
    CARD8       use;
234
 
    CARD8       pad1;
235
 
    } xDeviceInfo;
236
 
 
237
 
typedef struct _xKeyInfo *xKeyInfoPtr;
238
 
 
239
 
typedef 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
 
 
252
 
typedef struct _xButtonInfo *xButtonInfoPtr;
253
 
 
254
 
typedef 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
 
 
264
 
typedef struct _xValuatorInfo *xValuatorInfoPtr;
265
 
 
266
 
typedef 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
 
 
278
 
typedef struct _xAxisInfo *xAxisInfoPtr;
279
 
 
280
 
typedef 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
 
 
292
 
typedef 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
 
 
300
 
typedef 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
 
 
314
 
typedef 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
 
 
329
 
typedef 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
 
 
343
 
typedef 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
 
 
352
 
typedef 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
 
 
372
 
typedef 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
 
 
387
 
typedef struct {
388
 
    CARD8       reqType;        /* input extension major code   */
389
 
    CARD8       ReqType;        /* X_GetSelectedExtensionEvents */
390
 
    CARD16      length B16;
391
 
    Window      window B32;
392
 
} xGetSelectedExtensionEventsReq;
393
 
 
394
 
typedef 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
 
 
414
 
typedef 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
 
 
430
 
typedef struct {
431
 
    CARD8       reqType;        /* input extension major code   */
432
 
    CARD8       ReqType;        /* X_GetDeviceDontPropagateList */
433
 
    CARD16      length B16;
434
 
    Window      window B32;
435
 
} xGetDeviceDontPropagateListReq;
436
 
 
437
 
typedef 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
 
 
457
 
typedef 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
 
 
467
 
typedef 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
 
 
488
 
typedef 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
 
 
496
 
typedef 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
 
 
516
 
typedef 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
 
 
526
 
typedef 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
 
 
546
 
typedef 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
 
 
560
 
typedef 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
 
 
580
 
typedef 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
 
 
595
 
typedef 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
 
 
617
 
typedef 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
 
 
635
 
typedef 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
 
 
657
 
typedef 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
 
 
675
 
typedef 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
 
 
691
 
typedef 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
 
 
699
 
typedef 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
 
 
719
 
typedef 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
 
 
736
 
typedef 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
 
 
744
 
typedef 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
 
 
758
 
typedef 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
 
 
768
 
typedef 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
 
 
787
 
typedef 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
 
 
801
 
typedef 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
 
 
814
 
typedef 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
 
 
826
 
typedef 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
 
 
840
 
typedef 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
 
 
858
 
typedef 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
 
 
868
 
typedef 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
 
 
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 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
 
 
896
 
typedef 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
 
 
910
 
typedef 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
 
 
921
 
typedef 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
 
 
933
 
typedef 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
 
 
947
 
typedef 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
 
 
965
 
typedef 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
 
 
975
 
typedef 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
 
 
996
 
typedef 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
 
 
1012
 
typedef 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
 
 
1020
 
typedef 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
 
 
1041
 
typedef 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
 
 
1050
 
typedef 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
 
 
1071
 
typedef 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
 
 
1079
 
typedef 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
 
 
1099
 
typedef 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
 
 
1108
 
typedef 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
 
 
1129
 
typedef 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
 
 
1137
 
typedef 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
 
 
1152
 
typedef 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
 
 
1164
 
typedef 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
 
 
1176
 
typedef 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
 
 
1195
 
typedef 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
 
 
1213
 
typedef 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
 
 
1229
 
typedef 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
 
 
1239
 
typedef 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
 
 
1259
 
typedef 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
 
 
1268
 
typedef 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
 
 
1282
 
typedef struct {
1283
 
    CARD16      control B16;    /* control type                 */
1284
 
    CARD16      length B16;     /* control length               */
1285
 
} xDeviceState;
1286
 
 
1287
 
typedef 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
 
 
1299
 
typedef 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
 
 
1308
 
typedef 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
 
 
1322
 
typedef struct {
1323
 
    CARD16      control B16;    /* control type                 */
1324
 
    CARD16      length B16;     /* control length               */
1325
 
} xDeviceCtl;
1326
 
 
1327
 
typedef 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
 
 
1338
 
typedef 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
 
 
1359
 
typedef 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
 
 
1386
 
typedef 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
 
 
1410
 
typedef 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
 
 
1436
 
typedef 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
 
 
1459
 
typedef 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
 
 
1473
 
typedef 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
 
 
1488
 
typedef 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
 
 
1511
 
typedef 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