xkbstr.h revision 35c4bbdf 
1/************************************************************
2Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
3
4Permission to use, copy, modify, and distribute this
5software and its documentation for any purpose and without
6fee is hereby granted, provided that the above copyright
7notice appear in all copies and that both that copyright
8notice and this permission notice appear in supporting
9documentation, and that the name of Silicon Graphics not be
10used in advertising or publicity pertaining to distribution
11of the software without specific prior written permission.
12Silicon Graphics makes no representation about the suitability
13of this software for any purpose. It is provided "as is"
14without any express or implied warranty.
15
16SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
17SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
18AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
19GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
20DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
21DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
22OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
23THE USE OR PERFORMANCE OF THIS SOFTWARE.
24
25********************************************************/
26
27#ifndef _XKBSTR_H_
28#define	_XKBSTR_H_
29
30#include <X11/extensions/XKB.h>
31
32#define	XkbCharToInt(v) ((int) ((v) & 0x80 ? ((v) | (~0xff)) : ((v) & 0x7f)))
33#define	XkbIntTo2Chars(i, h, l) ((h) = (i >> 8) & 0xff, (l) = (i) & 0xff)
34
35#if defined(WORD64) && defined(UNSIGNEDBITFIELDS)
36#define	Xkb2CharsToInt(h, l) ((int) ((h) & 0x80 ? \
37                              (((h) << 8) | (l) | (~0xffff)) : \
38                              (((h) << 8) | (l) & 0x7fff))
39#else
40#define	Xkb2CharsToInt(h,l)	((short)(((h)<<8)|(l)))
41#endif
42
43        /*
44         * Common data structures and access macros
45         */
46
47typedef struct _XkbStateRec {
48    unsigned char group;        /* base + latched + locked */
49    /* FIXME: Why are base + latched short and not char?? */
50    unsigned short base_group;  /* physically ... down? */
51    unsigned short latched_group;
52    unsigned char locked_group;
53
54    unsigned char mods;         /* base + latched + locked */
55    unsigned char base_mods;    /* physically down */
56    unsigned char latched_mods;
57    unsigned char locked_mods;
58
59    unsigned char compat_state; /* mods + group for core state */
60
61    /* grab mods = all depressed and latched mods, _not_ locked mods */
62    unsigned char grab_mods;    /* grab mods minus internal mods */
63    unsigned char compat_grab_mods;     /* grab mods + group for core state,
64                                           but not locked groups if
65                                           IgnoreGroupLocks set */
66
67    /* effective mods = all mods (depressed, latched, locked) */
68    unsigned char lookup_mods;  /* effective mods minus internal mods */
69    unsigned char compat_lookup_mods;   /* effective mods + group */
70
71    unsigned short ptr_buttons; /* core pointer buttons */
72} XkbStateRec, *XkbStatePtr;
73
74#define	XkbStateFieldFromRec(s)	XkbBuildCoreState((s)->lookup_mods,(s)->group)
75#define	XkbGrabStateFromRec(s)	XkbBuildCoreState((s)->grab_mods,(s)->group)
76
77typedef struct _XkbMods {
78    unsigned char mask;         /* effective mods */
79    unsigned char real_mods;
80    unsigned short vmods;
81} XkbModsRec, *XkbModsPtr;
82
83typedef struct _XkbKTMapEntry {
84    Bool active;
85    unsigned char level;
86    XkbModsRec mods;
87} XkbKTMapEntryRec, *XkbKTMapEntryPtr;
88
89typedef struct _XkbKeyType {
90    XkbModsRec mods;
91    unsigned char num_levels;
92    unsigned char map_count;
93    XkbKTMapEntryPtr map;
94    XkbModsPtr preserve;
95    Atom name;
96    Atom *level_names;
97} XkbKeyTypeRec, *XkbKeyTypePtr;
98
99#define	XkbNumGroups(g)			((g)&0x0f)
100#define	XkbOutOfRangeGroupInfo(g)	((g)&0xf0)
101#define	XkbOutOfRangeGroupAction(g)	((g)&0xc0)
102#define	XkbOutOfRangeGroupNumber(g)	(((g)&0x30)>>4)
103#define	XkbSetGroupInfo(g, w, n) (((w) & 0xc0) | (((n) & 3) << 4) | \
104                                  ((g) & 0x0f))
105#define	XkbSetNumGroups(g,n)	(((g)&0xf0)|((n)&0x0f))
106
107        /*
108         * Structures and access macros used primarily by the server
109         */
110
111typedef struct _XkbBehavior {
112    unsigned char type;
113    unsigned char data;
114} XkbBehavior;
115
116#define	XkbAnyActionDataSize 7
117typedef struct _XkbAnyAction {
118    unsigned char type;
119    unsigned char data[XkbAnyActionDataSize];
120} XkbAnyAction;
121
122typedef struct _XkbModAction {
123    unsigned char type;
124    unsigned char flags;
125    unsigned char mask;
126    unsigned char real_mods;
127    /* FIXME: Make this an int. */
128    unsigned char vmods1;
129    unsigned char vmods2;
130} XkbModAction;
131
132#define	XkbModActionVMods(a) ((short) (((a)->vmods1 << 8) | (a)->vmods2))
133#define	XkbSetModActionVMods(a,v) \
134	((a)->vmods1 = (((v) >> 8) & 0xff), \
135         (a)->vmods2 = (v) & 0xff)
136
137typedef struct _XkbGroupAction {
138    unsigned char type;
139    unsigned char flags;
140    /* FIXME: Make this an int. */
141    char group_XXX;
142} XkbGroupAction;
143
144#define	XkbSAGroup(a)		(XkbCharToInt((a)->group_XXX))
145#define	XkbSASetGroup(a,g)	((a)->group_XXX=(g))
146
147typedef struct _XkbISOAction {
148    unsigned char type;
149    unsigned char flags;
150    unsigned char mask;
151    unsigned char real_mods;
152    /* FIXME: Make this an int. */
153    char group_XXX;
154    unsigned char affect;
155    unsigned char vmods1;
156    unsigned char vmods2;
157} XkbISOAction;
158
159typedef struct _XkbPtrAction {
160    unsigned char type;
161    unsigned char flags;
162    /* FIXME: Make this an int. */
163    unsigned char high_XXX;
164    unsigned char low_XXX;
165    unsigned char high_YYY;
166    unsigned char low_YYY;
167} XkbPtrAction;
168
169#define	XkbPtrActionX(a)      (Xkb2CharsToInt((a)->high_XXX,(a)->low_XXX))
170#define	XkbPtrActionY(a)      (Xkb2CharsToInt((a)->high_YYY,(a)->low_YYY))
171#define	XkbSetPtrActionX(a,x) (XkbIntTo2Chars(x,(a)->high_XXX,(a)->low_XXX))
172#define	XkbSetPtrActionY(a,y) (XkbIntTo2Chars(y,(a)->high_YYY,(a)->low_YYY))
173
174typedef struct _XkbPtrBtnAction {
175    unsigned char type;
176    unsigned char flags;
177    unsigned char count;
178    unsigned char button;
179} XkbPtrBtnAction;
180
181typedef struct _XkbPtrDfltAction {
182    unsigned char type;
183    unsigned char flags;
184    unsigned char affect;
185    char valueXXX;
186} XkbPtrDfltAction;
187
188#define	XkbSAPtrDfltValue(a)		(XkbCharToInt((a)->valueXXX))
189#define	XkbSASetPtrDfltValue(a, c) ((a)->valueXXX = (c) & 0xff)
190
191typedef struct _XkbSwitchScreenAction {
192    unsigned char type;
193    unsigned char flags;
194    char screenXXX;
195} XkbSwitchScreenAction;
196
197#define	XkbSAScreen(a)			(XkbCharToInt((a)->screenXXX))
198#define	XkbSASetScreen(a, s) ((a)->screenXXX = (s) & 0xff)
199
200typedef struct _XkbCtrlsAction {
201    unsigned char type;
202    unsigned char flags;
203    /* FIXME: Make this an int. */
204    unsigned char ctrls3;
205    unsigned char ctrls2;
206    unsigned char ctrls1;
207    unsigned char ctrls0;
208} XkbCtrlsAction;
209
210#define	XkbActionSetCtrls(a, c) ((a)->ctrls3 = ((c) >> 24) & 0xff, \
211                                 (a)->ctrls2 = ((c) >> 16) & 0xff, \
212                                 (a)->ctrls1 = ((c) >> 8) & 0xff, \
213                                 (a)->ctrls0 = (c) & 0xff)
214#define	XkbActionCtrls(a) ((((unsigned int)(a)->ctrls3)<<24)|\
215			   (((unsigned int)(a)->ctrls2)<<16)|\
216			   (((unsigned int)(a)->ctrls1)<<8)|\
217                           ((unsigned int) (a)->ctrls0))
218
219typedef struct _XkbMessageAction {
220    unsigned char type;
221    unsigned char flags;
222    unsigned char message[6];
223} XkbMessageAction;
224
225typedef struct _XkbRedirectKeyAction {
226    unsigned char type;
227    unsigned char new_key;
228    unsigned char mods_mask;
229    unsigned char mods;
230    /* FIXME: Make this an int. */
231    unsigned char vmods_mask0;
232    unsigned char vmods_mask1;
233    unsigned char vmods0;
234    unsigned char vmods1;
235} XkbRedirectKeyAction;
236
237#define	XkbSARedirectVMods(a)		((((unsigned int)(a)->vmods1)<<8)|\
238					((unsigned int)(a)->vmods0))
239/* FIXME: This is blatantly not setting vmods.   Yeesh. */
240#define	XkbSARedirectSetVMods(a,m)	(((a)->vmods_mask1=(((m)>>8)&0xff)),\
241					 ((a)->vmods_mask0=((m)&0xff)))
242#define	XkbSARedirectVModsMask(a)	((((unsigned int)(a)->vmods_mask1)<<8)|\
243					((unsigned int)(a)->vmods_mask0))
244#define	XkbSARedirectSetVModsMask(a,m)	(((a)->vmods_mask1=(((m)>>8)&0xff)),\
245					 ((a)->vmods_mask0=((m)&0xff)))
246
247typedef struct _XkbDeviceBtnAction {
248    unsigned char type;
249    unsigned char flags;
250    unsigned char count;
251    unsigned char button;
252    unsigned char device;
253} XkbDeviceBtnAction;
254
255typedef struct _XkbDeviceValuatorAction {
256    unsigned char type;
257    unsigned char device;
258    unsigned char v1_what;
259    unsigned char v1_ndx;
260    unsigned char v1_value;
261    unsigned char v2_what;
262    unsigned char v2_ndx;
263    unsigned char v2_value;
264} XkbDeviceValuatorAction;
265
266typedef union _XkbAction {
267    XkbAnyAction any;
268    XkbModAction mods;
269    XkbGroupAction group;
270    XkbISOAction iso;
271    XkbPtrAction ptr;
272    XkbPtrBtnAction btn;
273    XkbPtrDfltAction dflt;
274    XkbSwitchScreenAction screen;
275    XkbCtrlsAction ctrls;
276    XkbMessageAction msg;
277    XkbRedirectKeyAction redirect;
278    XkbDeviceBtnAction devbtn;
279    XkbDeviceValuatorAction devval;
280    unsigned char type;
281} XkbAction;
282
283typedef struct _XkbControls {
284    unsigned char mk_dflt_btn;
285    unsigned char num_groups;
286    unsigned char groups_wrap;
287    XkbModsRec internal;
288    XkbModsRec ignore_lock;
289    unsigned int enabled_ctrls;
290    unsigned short repeat_delay;
291    unsigned short repeat_interval;
292    unsigned short slow_keys_delay;
293    unsigned short debounce_delay;
294    unsigned short mk_delay;
295    unsigned short mk_interval;
296    unsigned short mk_time_to_max;
297    unsigned short mk_max_speed;
298    short mk_curve;
299    unsigned short ax_options;
300    unsigned short ax_timeout;
301    unsigned short axt_opts_mask;
302    unsigned short axt_opts_values;
303    unsigned int axt_ctrls_mask;
304    unsigned int axt_ctrls_values;
305    unsigned char per_key_repeat[XkbPerKeyBitArraySize];
306} XkbControlsRec, *XkbControlsPtr;
307
308#define	XkbAX_AnyFeedback(c)	((c)->enabled_ctrls&XkbAccessXFeedbackMask)
309#define	XkbAX_NeedOption(c,w)	((c)->ax_options&(w))
310#define	XkbAX_NeedFeedback(c, w) (XkbAX_AnyFeedback((c)) && \
311                                  XkbAX_NeedOption((c), (w)))
312
313typedef struct _XkbServerMapRec {
314    unsigned short num_acts;
315    unsigned short size_acts;
316    XkbAction *acts;
317
318    XkbBehavior *behaviors;
319    unsigned short *key_acts;
320#if defined(__cplusplus) || defined(c_plusplus)
321    /* explicit is a C++ reserved word */
322    unsigned char *c_explicit;
323#else
324    unsigned char *explicit;
325#endif
326    unsigned char vmods[XkbNumVirtualMods];
327    unsigned short *vmodmap;
328} XkbServerMapRec, *XkbServerMapPtr;
329
330#define	XkbSMKeyActionsPtr(m, k) (&(m)->acts[(m)->key_acts[(k)]])
331
332        /*
333         * Structures and access macros used primarily by clients
334         */
335
336typedef struct _XkbSymMapRec {
337    unsigned char kt_index[XkbNumKbdGroups];
338    unsigned char group_info;
339    unsigned char width;
340    unsigned short offset;
341} XkbSymMapRec, *XkbSymMapPtr;
342
343typedef struct _XkbClientMapRec {
344    unsigned char size_types;
345    unsigned char num_types;
346    XkbKeyTypePtr types;
347
348    unsigned short size_syms;
349    unsigned short num_syms;
350    KeySym *syms;
351    XkbSymMapPtr key_sym_map;
352
353    unsigned char *modmap;
354} XkbClientMapRec, *XkbClientMapPtr;
355
356#define	XkbCMKeyGroupInfo(m, k) ((m)->key_sym_map[(k)].group_info)
357#define	XkbCMKeyNumGroups(m, k) (XkbNumGroups((m)->key_sym_map[(k)].group_info))
358#define	XkbCMKeyGroupWidth(m, k, g) (XkbCMKeyType((m), (k), (g))->num_levels)
359#define	XkbCMKeyGroupsWidth(m, k) ((m)->key_sym_map[(k)].width)
360#define	XkbCMKeyTypeIndex(m, k, g) ((m)->key_sym_map[(k)].kt_index[(g) & 0x3])
361#define	XkbCMKeyType(m, k, g) (&(m)->types[XkbCMKeyTypeIndex((m), (k), (g))])
362#define	XkbCMKeyNumSyms(m, k) (XkbCMKeyGroupsWidth((m), (k)) * \
363                               XkbCMKeyNumGroups((m), (k)))
364#define	XkbCMKeySymsOffset(m, k) ((m)->key_sym_map[(k)].offset)
365#define	XkbCMKeySymsPtr(m, k) (&(m)->syms[XkbCMKeySymsOffset((m), (k))])
366
367        /*
368         * Compatibility structures and access macros
369         */
370
371typedef struct _XkbSymInterpretRec {
372    KeySym sym;
373    unsigned char flags;
374    unsigned char match;
375    unsigned char mods;
376    unsigned char virtual_mod;
377    XkbAnyAction act;
378} XkbSymInterpretRec, *XkbSymInterpretPtr;
379
380typedef struct _XkbCompatMapRec {
381    XkbSymInterpretPtr sym_interpret;
382    XkbModsRec groups[XkbNumKbdGroups];
383    unsigned short num_si;
384    unsigned short size_si;
385} XkbCompatMapRec, *XkbCompatMapPtr;
386
387typedef struct _XkbIndicatorMapRec {
388    unsigned char flags;
389    /* FIXME: For some reason, interepretation of groups is wildly
390     *        different between which being base/latched/locked. */
391    unsigned char which_groups;
392    unsigned char groups;
393    unsigned char which_mods;
394    XkbModsRec mods;
395    unsigned int ctrls;
396} XkbIndicatorMapRec, *XkbIndicatorMapPtr;
397
398#define	XkbIM_IsAuto(i)	(!((i)->flags & XkbIM_NoAutomatic) && \
399			    (((i)->which_groups&&(i)->groups)||\
400			     ((i)->which_mods&&(i)->mods.mask)||\
401                          (i)->ctrls))
402#define	XkbIM_InUse(i)	((i)->flags || (i)->which_groups || (i)->which_mods || \
403                         (i)->ctrls)
404
405typedef struct _XkbIndicatorRec {
406    unsigned long phys_indicators;
407    XkbIndicatorMapRec maps[XkbNumIndicators];
408} XkbIndicatorRec, *XkbIndicatorPtr;
409
410typedef struct _XkbKeyNameRec {
411    char name[XkbKeyNameLength];
412} XkbKeyNameRec, *XkbKeyNamePtr;
413
414typedef struct _XkbKeyAliasRec {
415    char real[XkbKeyNameLength];
416    char alias[XkbKeyNameLength];
417} XkbKeyAliasRec, *XkbKeyAliasPtr;
418
419        /*
420         * Names for everything
421         */
422typedef struct _XkbNamesRec {
423    Atom keycodes;
424    Atom geometry;
425    Atom symbols;
426    Atom types;
427    Atom compat;
428    Atom vmods[XkbNumVirtualMods];
429    Atom indicators[XkbNumIndicators];
430    Atom groups[XkbNumKbdGroups];
431    XkbKeyNamePtr keys;
432    XkbKeyAliasPtr key_aliases;
433    Atom *radio_groups;
434    Atom phys_symbols;
435
436    unsigned char num_keys;
437    unsigned char num_key_aliases;
438    unsigned short num_rg;
439} XkbNamesRec, *XkbNamesPtr;
440
441typedef struct _XkbGeometry *XkbGeometryPtr;
442
443        /*
444         * Tie it all together into one big keyboard description
445         */
446typedef struct _XkbDesc {
447    unsigned int defined;
448    unsigned short flags;
449    unsigned short device_spec;
450    KeyCode min_key_code;
451    KeyCode max_key_code;
452
453    XkbControlsPtr ctrls;
454    XkbServerMapPtr server;
455    XkbClientMapPtr map;
456    XkbIndicatorPtr indicators;
457    XkbNamesPtr names;
458    XkbCompatMapPtr compat;
459    XkbGeometryPtr geom;
460} XkbDescRec, *XkbDescPtr;
461
462#define	XkbKeyKeyTypeIndex(d, k, g)	(XkbCMKeyTypeIndex((d)->map, (k), (g)))
463#define	XkbKeyKeyType(d, k, g)		(XkbCMKeyType((d)->map, (k), (g)))
464#define	XkbKeyGroupWidth(d, k, g)	(XkbCMKeyGroupWidth((d)->map, (k), (g)))
465#define	XkbKeyGroupsWidth(d, k)		(XkbCMKeyGroupsWidth((d)->map, (k)))
466#define	XkbKeyGroupInfo(d,k)		(XkbCMKeyGroupInfo((d)->map,(k)))
467#define	XkbKeyNumGroups(d,k)		(XkbCMKeyNumGroups((d)->map,(k)))
468#define	XkbKeyNumSyms(d,k)		(XkbCMKeyNumSyms((d)->map,(k)))
469#define	XkbKeySymsPtr(d,k)		(XkbCMKeySymsPtr((d)->map,(k)))
470#define	XkbKeySym(d, k, n)		(XkbKeySymsPtr((d), (k))[(n)])
471#define	XkbKeySymEntry(d,k,sl,g) \
472    (XkbKeySym((d), (k), (XkbKeyGroupsWidth((d), (k)) * (g)) + (sl)))
473#define	XkbKeyAction(d,k,n) \
474    (XkbKeyHasActions((d), (k)) ? & XkbKeyActionsPtr((d), (k))[(n)] : NULL)
475#define	XkbKeyActionEntry(d,k,sl,g) \
476    (XkbKeyHasActions((d), (k)) ? \
477     XkbKeyAction((d), (k), ((XkbKeyGroupsWidth((d), (k)) * (g)) + (sl))) : \
478     NULL)
479
480#define	XkbKeyHasActions(d, k) (!!(d)->server->key_acts[(k)])
481#define	XkbKeyNumActions(d, k) (XkbKeyHasActions((d), (k)) ? \
482                                XkbKeyNumSyms((d), (k)) : 1)
483#define	XkbKeyActionsPtr(d, k) (XkbSMKeyActionsPtr((d)->server, (k)))
484#define	XkbKeycodeInRange(d, k) ((k) >= (d)->min_key_code && \
485				 (k) <= (d)->max_key_code)
486#define	XkbNumKeys(d)		((d)->max_key_code-(d)->min_key_code+1)
487
488        /*
489         * The following structures can be used to track changes
490         * to a keyboard device
491         */
492typedef struct _XkbMapChanges {
493    unsigned short changed;
494    KeyCode min_key_code;
495    KeyCode max_key_code;
496    unsigned char first_type;
497    unsigned char num_types;
498    KeyCode first_key_sym;
499    unsigned char num_key_syms;
500    KeyCode first_key_act;
501    unsigned char num_key_acts;
502    KeyCode first_key_behavior;
503    unsigned char num_key_behaviors;
504    KeyCode first_key_explicit;
505    unsigned char num_key_explicit;
506    KeyCode first_modmap_key;
507    unsigned char num_modmap_keys;
508    KeyCode first_vmodmap_key;
509    unsigned char num_vmodmap_keys;
510    unsigned char pad;
511    unsigned short vmods;
512} XkbMapChangesRec, *XkbMapChangesPtr;
513
514typedef struct _XkbControlsChanges {
515    unsigned int changed_ctrls;
516    unsigned int enabled_ctrls_changes;
517    Bool num_groups_changed;
518} XkbControlsChangesRec, *XkbControlsChangesPtr;
519
520typedef struct _XkbIndicatorChanges {
521    unsigned int state_changes;
522    unsigned int map_changes;
523} XkbIndicatorChangesRec, *XkbIndicatorChangesPtr;
524
525typedef struct _XkbNameChanges {
526    unsigned int changed;
527    unsigned char first_type;
528    unsigned char num_types;
529    unsigned char first_lvl;
530    unsigned char num_lvls;
531    unsigned char num_aliases;
532    unsigned char num_rg;
533    unsigned char first_key;
534    unsigned char num_keys;
535    unsigned short changed_vmods;
536    unsigned long changed_indicators;
537    unsigned char changed_groups;
538} XkbNameChangesRec, *XkbNameChangesPtr;
539
540typedef struct _XkbCompatChanges {
541    unsigned char changed_groups;
542    unsigned short first_si;
543    unsigned short num_si;
544} XkbCompatChangesRec, *XkbCompatChangesPtr;
545
546typedef struct _XkbChanges {
547    unsigned short device_spec;
548    unsigned short state_changes;
549    XkbMapChangesRec map;
550    XkbControlsChangesRec ctrls;
551    XkbIndicatorChangesRec indicators;
552    XkbNameChangesRec names;
553    XkbCompatChangesRec compat;
554} XkbChangesRec, *XkbChangesPtr;
555
556        /*
557         * These data structures are used to construct a keymap from
558         * a set of components or to list components in the server
559         * database.
560         */
561typedef struct _XkbComponentNames {
562    char *keycodes;
563    char *types;
564    char *compat;
565    char *symbols;
566    char *geometry;
567} XkbComponentNamesRec, *XkbComponentNamesPtr;
568
569typedef struct _XkbComponentName {
570    unsigned short flags;
571    char *name;
572} XkbComponentNameRec, *XkbComponentNamePtr;
573
574typedef struct _XkbComponentList {
575    int num_keymaps;
576    int num_keycodes;
577    int num_types;
578    int num_compat;
579    int num_symbols;
580    int num_geometry;
581    XkbComponentNamePtr keymaps;
582    XkbComponentNamePtr keycodes;
583    XkbComponentNamePtr types;
584    XkbComponentNamePtr compat;
585    XkbComponentNamePtr symbols;
586    XkbComponentNamePtr geometry;
587} XkbComponentListRec, *XkbComponentListPtr;
588
589        /*
590         * The following data structures describe and track changes to a
591         * non-keyboard extension device
592         */
593typedef struct _XkbDeviceLedInfo {
594    unsigned short led_class;
595    unsigned short led_id;
596    unsigned int phys_indicators;
597    unsigned int maps_present;
598    unsigned int names_present;
599    unsigned int state;
600    Atom names[XkbNumIndicators];
601    XkbIndicatorMapRec maps[XkbNumIndicators];
602} XkbDeviceLedInfoRec, *XkbDeviceLedInfoPtr;
603
604typedef struct _XkbDeviceInfo {
605    char *name;
606    Atom type;
607    unsigned short device_spec;
608    Bool has_own_state;
609    unsigned short supported;
610    unsigned short unsupported;
611
612    unsigned short num_btns;
613    XkbAction *btn_acts;
614
615    unsigned short sz_leds;
616    unsigned short num_leds;
617    unsigned short dflt_kbd_fb;
618    unsigned short dflt_led_fb;
619    XkbDeviceLedInfoPtr leds;
620} XkbDeviceInfoRec, *XkbDeviceInfoPtr;
621
622#define	XkbXI_DevHasBtnActs(d)	((d)->num_btns > 0 && (d)->btn_acts)
623#define	XkbXI_LegalDevBtn(d,b)	(XkbXI_DevHasBtnActs(d) && (b) < (d)->num_btns)
624#define	XkbXI_DevHasLeds(d)	((d)->num_leds > 0 && (d)->leds)
625
626typedef struct _XkbDeviceLedChanges {
627    unsigned short led_class;
628    unsigned short led_id;
629    unsigned int defined;       /* names or maps changed */
630    struct _XkbDeviceLedChanges *next;
631} XkbDeviceLedChangesRec, *XkbDeviceLedChangesPtr;
632
633typedef struct _XkbDeviceChanges {
634    unsigned int changed;
635    unsigned short first_btn;
636    unsigned short num_btns;
637    XkbDeviceLedChangesRec leds;
638} XkbDeviceChangesRec, *XkbDeviceChangesPtr;
639
640#endif                          /* _XKBSTR_H_ */
641