XKBstr.h

   1 /************************************************************
   2 Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
   3
   4 Permission to use, copy, modify, and distribute this
   5 software and its documentation for any purpose and without
   6 fee is hereby granted, provided that the above copyright
   7 notice appear in all copies and that both that copyright
   8 notice and this permission notice appear in supporting
   9 documentation, and that the name of Silicon Graphics not be
  10 used in advertising or publicity pertaining to distribution
  11 of the software without specific prior written permission.
  12 Silicon Graphics makes no representation about the suitability
  13 of this software for any purpose. It is provided "as is"
  14 without any express or implied warranty.
  15
  16 SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS
  17 SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
  18 AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  19 GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL
  20 DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
  21 DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
  22 OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  23 THE 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
  46 typedef 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
  69 typedef struct _XkbMods {
  70         unsigned char   mask;   /* effective mods */
  71         unsigned char   real_mods;
  72         unsigned short  vmods;
  73 } XkbModsRec,*XkbModsPtr;
  74
  75 typedef struct _XkbKTMapEntry {
  76         Bool            active;
  77         unsigned char   level;
  78         XkbModsRec      mods;
  79 } XkbKTMapEntryRec,*XkbKTMapEntryPtr;
  80
  81 typedef 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
 102 typedef struct _XkbBehavior {
 103         unsigned char   type;
 104         unsigned char   data;
 105 } XkbBehavior;
 106
 107 #define XkbAnyActionDataSize 7
 108 typedef struct _XkbAnyAction {
 109         unsigned char   type;
 110         unsigned char   data[XkbAnyActionDataSize];
 111 } XkbAnyAction;
 112
 113 typedef 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
 126 typedef 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
 134 typedef 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
 145 typedef 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
 158 typedef struct _XkbPtrBtnAction {
 159         unsigned char   type;
 160         unsigned char   flags;
 161         unsigned char   count;
 162         unsigned char   button;
 163 } XkbPtrBtnAction;
 164
 165 typedef 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
 174 typedef 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
 182 typedef 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
 199 typedef struct _XkbMessageAction {
 200         unsigned char   type;
 201         unsigned char   flags;
 202         unsigned char   message[6];
 203 } XkbMessageAction;
 204
 205 typedef 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
 225 typedef 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
 233 typedef 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
 244 typedef 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
 261 typedef 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
 290 typedef 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
 313 typedef 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
 320 typedef 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
 347 typedef 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
 356 typedef struct _XkbCompatMapRec {
 357         XkbSymInterpretPtr       sym_interpret;
 358         XkbModsRec               groups[XkbNumKbdGroups];
 359         unsigned short           num_si;
 360         unsigned short           size_si;
 361 } XkbCompatMapRec, *XkbCompatMapPtr;
 362
 363 typedef 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
 380 typedef struct _XkbIndicatorRec {
 381         unsigned long           phys_indicators;
 382         XkbIndicatorMapRec      maps[XkbNumIndicators];
 383 } XkbIndicatorRec,*XkbIndicatorPtr;
 384
 385 typedef struct _XkbKeyNameRec {
 386         char    name[XkbKeyNameLength];
 387 } XkbKeyNameRec,*XkbKeyNamePtr;
 388
 389 typedef struct _XkbKeyAliasRec {
 390         char    real[XkbKeyNameLength];
 391         char    alias[XkbKeyNameLength];
 392 } XkbKeyAliasRec,*XkbKeyAliasPtr;
 393
 394         /*
 395          * Names for everything
 396          */
 397 typedef 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
 416 typedef struct _XkbGeometry     *XkbGeometryPtr;
 417         /*
 418          * Tie it all together into one big keyboard description
 419          */
 420 typedef struct _XkbDesc {
 421         struct _XDisplay *      dpy;
 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          */
 464 typedef 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
 486 typedef struct _XkbControlsChanges {
 487         unsigned int             changed_ctrls;
 488         unsigned int             enabled_ctrls_changes;
 489         Bool                     num_groups_changed;
 490 } XkbControlsChangesRec,*XkbControlsChangesPtr;
 491
 492 typedef struct _XkbIndicatorChanges {
 493         unsigned int             state_changes;
 494         unsigned int             map_changes;
 495 } XkbIndicatorChangesRec,*XkbIndicatorChangesPtr;
 496
 497 typedef 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
 512 typedef struct _XkbCompatChanges {
 513         unsigned char           changed_groups;
 514         unsigned short          first_si;
 515         unsigned short          num_si;
 516 } XkbCompatChangesRec,*XkbCompatChangesPtr;
 517
 518 typedef 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          */
 533 typedef struct _XkbComponentNames {
 534         char *                   keymap;
 535         char *                   keycodes;
 536         char *                   types;
 537         char *                   compat;
 538         char *                   symbols;
 539         char *                   geometry;
 540 } XkbComponentNamesRec, *XkbComponentNamesPtr;
 541
 542 typedef struct _XkbComponentName {
 543         unsigned short          flags;
 544         char *                  name;
 545 } XkbComponentNameRec,*XkbComponentNamePtr;
 546
 547 typedef 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          */
 566 typedef 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
 577 typedef 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
 599 typedef 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
 606 typedef 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_ */