VirtualBox

source: vbox/trunk/src/VBox/Additions/x11/x11include/xorg-server-1.5.3/xkbstr.h@ 17448

Last change on this file since 17448 was 17448, checked in by vboxsync, 16 years ago

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

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