The C and C++ Include Header Files

/usr/include/X11/extensions/XIproto.h


$ cat -n /usr/include/X11/extensions/XIproto.h

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