VirtualBox

source: vbox/trunk/src/VBox/Additions/x11/x11include/4.3/include/extensions/XKBstr.h@ 49762

Last change on this file since 49762 was 25452, checked in by vboxsync, 15 years ago

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