| 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) ((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 |
|
|---|
| 47 | typedef 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 |
|
|---|
| 77 | typedef struct _XkbMods {
|
|---|
| 78 | unsigned char mask; /* effective mods */
|
|---|
| 79 | unsigned char real_mods;
|
|---|
| 80 | unsigned short vmods;
|
|---|
| 81 | } XkbModsRec, *XkbModsPtr;
|
|---|
| 82 |
|
|---|
| 83 | typedef struct _XkbKTMapEntry {
|
|---|
| 84 | Bool active;
|
|---|
| 85 | unsigned char level;
|
|---|
| 86 | XkbModsRec mods;
|
|---|
| 87 | } XkbKTMapEntryRec, *XkbKTMapEntryPtr;
|
|---|
| 88 |
|
|---|
| 89 | typedef 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 |
|
|---|
| 111 | typedef struct _XkbBehavior {
|
|---|
| 112 | unsigned char type;
|
|---|
| 113 | unsigned char data;
|
|---|
| 114 | } XkbBehavior;
|
|---|
| 115 |
|
|---|
| 116 | #define XkbAnyActionDataSize 7
|
|---|
| 117 | typedef struct _XkbAnyAction {
|
|---|
| 118 | unsigned char type;
|
|---|
| 119 | unsigned char data[XkbAnyActionDataSize];
|
|---|
| 120 | } XkbAnyAction;
|
|---|
| 121 |
|
|---|
| 122 | typedef 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 |
|
|---|
| 137 | typedef 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 |
|
|---|
| 147 | typedef 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 |
|
|---|
| 159 | typedef 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 |
|
|---|
| 174 | typedef struct _XkbPtrBtnAction {
|
|---|
| 175 | unsigned char type;
|
|---|
| 176 | unsigned char flags;
|
|---|
| 177 | unsigned char count;
|
|---|
| 178 | unsigned char button;
|
|---|
| 179 | } XkbPtrBtnAction;
|
|---|
| 180 |
|
|---|
| 181 | typedef 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 |
|
|---|
| 191 | typedef 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 |
|
|---|
| 200 | typedef 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 |
|
|---|
| 219 | typedef struct _XkbMessageAction {
|
|---|
| 220 | unsigned char type;
|
|---|
| 221 | unsigned char flags;
|
|---|
| 222 | unsigned char message[6];
|
|---|
| 223 | } XkbMessageAction;
|
|---|
| 224 |
|
|---|
| 225 | typedef 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 |
|
|---|
| 247 | typedef 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 |
|
|---|
| 255 | typedef 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 |
|
|---|
| 266 | typedef 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 |
|
|---|
| 283 | typedef 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 |
|
|---|
| 313 | typedef 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 |
|
|---|
| 336 | typedef 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 |
|
|---|
| 343 | typedef 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 |
|
|---|
| 371 | typedef 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 |
|
|---|
| 380 | typedef struct _XkbCompatMapRec {
|
|---|
| 381 | XkbSymInterpretPtr sym_interpret;
|
|---|
| 382 | XkbModsRec groups[XkbNumKbdGroups];
|
|---|
| 383 | unsigned short num_si;
|
|---|
| 384 | unsigned short size_si;
|
|---|
| 385 | } XkbCompatMapRec, *XkbCompatMapPtr;
|
|---|
| 386 |
|
|---|
| 387 | typedef 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 |
|
|---|
| 405 | typedef struct _XkbIndicatorRec {
|
|---|
| 406 | unsigned long phys_indicators;
|
|---|
| 407 | XkbIndicatorMapRec maps[XkbNumIndicators];
|
|---|
| 408 | } XkbIndicatorRec, *XkbIndicatorPtr;
|
|---|
| 409 |
|
|---|
| 410 | typedef struct _XkbKeyNameRec {
|
|---|
| 411 | char name[XkbKeyNameLength];
|
|---|
| 412 | } XkbKeyNameRec, *XkbKeyNamePtr;
|
|---|
| 413 |
|
|---|
| 414 | typedef struct _XkbKeyAliasRec {
|
|---|
| 415 | char real[XkbKeyNameLength];
|
|---|
| 416 | char alias[XkbKeyNameLength];
|
|---|
| 417 | } XkbKeyAliasRec, *XkbKeyAliasPtr;
|
|---|
| 418 |
|
|---|
| 419 | /*
|
|---|
| 420 | * Names for everything
|
|---|
| 421 | */
|
|---|
| 422 | typedef 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 |
|
|---|
| 441 | typedef struct _XkbGeometry *XkbGeometryPtr;
|
|---|
| 442 |
|
|---|
| 443 | /*
|
|---|
| 444 | * Tie it all together into one big keyboard description
|
|---|
| 445 | */
|
|---|
| 446 | typedef 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 | */
|
|---|
| 492 | typedef 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 |
|
|---|
| 514 | typedef struct _XkbControlsChanges {
|
|---|
| 515 | unsigned int changed_ctrls;
|
|---|
| 516 | unsigned int enabled_ctrls_changes;
|
|---|
| 517 | Bool num_groups_changed;
|
|---|
| 518 | } XkbControlsChangesRec, *XkbControlsChangesPtr;
|
|---|
| 519 |
|
|---|
| 520 | typedef struct _XkbIndicatorChanges {
|
|---|
| 521 | unsigned int state_changes;
|
|---|
| 522 | unsigned int map_changes;
|
|---|
| 523 | } XkbIndicatorChangesRec, *XkbIndicatorChangesPtr;
|
|---|
| 524 |
|
|---|
| 525 | typedef 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 |
|
|---|
| 540 | typedef struct _XkbCompatChanges {
|
|---|
| 541 | unsigned char changed_groups;
|
|---|
| 542 | unsigned short first_si;
|
|---|
| 543 | unsigned short num_si;
|
|---|
| 544 | } XkbCompatChangesRec, *XkbCompatChangesPtr;
|
|---|
| 545 |
|
|---|
| 546 | typedef 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 | */
|
|---|
| 561 | typedef struct _XkbComponentNames {
|
|---|
| 562 | char *keycodes;
|
|---|
| 563 | char *types;
|
|---|
| 564 | char *compat;
|
|---|
| 565 | char *symbols;
|
|---|
| 566 | char *geometry;
|
|---|
| 567 | } XkbComponentNamesRec, *XkbComponentNamesPtr;
|
|---|
| 568 |
|
|---|
| 569 | typedef struct _XkbComponentName {
|
|---|
| 570 | unsigned short flags;
|
|---|
| 571 | char *name;
|
|---|
| 572 | } XkbComponentNameRec, *XkbComponentNamePtr;
|
|---|
| 573 |
|
|---|
| 574 | typedef 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 | */
|
|---|
| 593 | typedef 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 |
|
|---|
| 604 | typedef 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 |
|
|---|
| 626 | typedef 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 |
|
|---|
| 633 | typedef 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_ */
|
|---|
