1 /************************************************************
2 Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
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.
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.
25 ********************************************************/
28 #include "X11/extensions/XKBcommon.h"
29 #include "XKBcommonint.h"
32 XkbcAllocClientMap(XkbcDescPtr xkb, unsigned which, unsigned nTotalTypes)
37 if (!xkb || ((nTotalTypes > 0) && (nTotalTypes < XkbNumRequiredTypes)))
40 if ((which & XkbKeySymsMask) &&
41 ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
42 (!XkbIsLegalKeycode(xkb->max_key_code)) ||
43 (xkb->max_key_code < xkb->min_key_code))) {
45 fprintf(stderr, "bad keycode (%d,%d) in XkbAllocClientMap\n",
46 xkb->min_key_code, xkb->max_key_code);
52 map = _XkbTypedCalloc(1, XkbcClientMapRec);
60 if ((which & XkbKeyTypesMask) && (nTotalTypes > 0)) {
62 map->types = _XkbTypedCalloc(nTotalTypes, XkbcKeyTypeRec);
67 map->size_types = nTotalTypes;
69 else if (map->size_types < nTotalTypes) {
70 XkbcKeyTypeRec *prev_types = map->types;
72 map->types = _XkbTypedRealloc(map->types, nTotalTypes,
76 map->num_types = map->size_types = 0;
80 map->size_types = nTotalTypes;
81 bzero(&map->types[map->num_types],
82 (map->size_types - map->num_types) * sizeof(XkbcKeyTypeRec));
86 if (which & XkbKeySymsMask) {
87 int nKeys = XkbNumKeys(xkb);
90 map->size_syms = (nKeys * 15) / 10;
91 map->syms = _XkbTypedCalloc(map->size_syms, uint32_t);
97 map->syms[0] = NoSymbol;
100 if (!map->key_sym_map) {
101 i = xkb->max_key_code + 1;
102 map->key_sym_map = _XkbTypedCalloc(i, XkbSymMapRec);
103 if (!map->key_sym_map)
108 if (which & XkbModifierMapMask) {
109 if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
110 (!XkbIsLegalKeycode(xkb->max_key_code)) ||
111 (xkb->max_key_code < xkb->min_key_code))
115 i = xkb->max_key_code + 1;
116 map->modmap = _XkbTypedCalloc(i, unsigned char);
126 XkbcAllocServerMap(XkbcDescPtr xkb, unsigned which, unsigned nNewActions)
129 XkbcServerMapPtr map;
135 map = _XkbTypedCalloc(1, XkbcServerMapRec);
139 for (i = 0; i < XkbNumVirtualMods; i++)
140 map->vmods[i] = XkbNoModifierMask;
147 if (which & XkbExplicitComponentsMask) {
148 if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
149 (!XkbIsLegalKeycode(xkb->max_key_code)) ||
150 (xkb->max_key_code < xkb->min_key_code))
153 if (!map->explicit) {
154 i = xkb->max_key_code + 1;
155 map->explicit = _XkbTypedCalloc(i, unsigned char);
161 if (which&XkbKeyActionsMask) {
162 if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
163 (!XkbIsLegalKeycode(xkb->max_key_code)) ||
164 (xkb->max_key_code < xkb->min_key_code))
171 map->acts = _XkbTypedCalloc(nNewActions + 1, XkbcAction);
175 map->size_acts = nNewActions + 1;
177 else if ((map->size_acts - map->num_acts) < nNewActions) {
179 XkbcAction *prev_acts = map->acts;
181 need = map->num_acts + nNewActions;
182 map->acts = _XkbTypedRealloc(map->acts, need, XkbcAction);
185 map->num_acts = map->size_acts = 0;
189 map->size_acts = need;
190 bzero(&map->acts[map->num_acts],
191 (map->size_acts - map->num_acts) * sizeof(XkbcAction));
194 if (!map->key_acts) {
195 i = xkb->max_key_code + 1;
196 map->key_acts = _XkbTypedCalloc(i, unsigned short);
202 if (which & XkbKeyBehaviorsMask) {
203 if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
204 (!XkbIsLegalKeycode(xkb->max_key_code)) ||
205 (xkb->max_key_code < xkb->min_key_code))
208 if (!map->behaviors) {
209 i = xkb->max_key_code + 1;
210 map->behaviors = _XkbTypedCalloc(i, XkbBehavior);
216 if (which & XkbVirtualModMapMask) {
217 if ((!XkbIsLegalKeycode(xkb->min_key_code)) ||
218 (!XkbIsLegalKeycode(xkb->max_key_code)) ||
219 (xkb->max_key_code < xkb->min_key_code))
223 i = xkb->max_key_code + 1;
224 map->vmodmap = _XkbTypedCalloc(i, uint32_t);
234 XkbcCopyKeyType(XkbcKeyTypePtr from, XkbcKeyTypePtr into)
243 if (into->preserve) {
244 _XkbFree(into->preserve);
245 into->preserve= NULL;
247 if (into->level_names) {
248 _XkbFree(into->level_names);
249 into->level_names = NULL;
254 if (from->map && (into->map_count > 0)) {
255 into->map = _XkbTypedCalloc(into->map_count, XkbKTMapEntryRec);
258 memcpy(into->map, from->map,
259 into->map_count * sizeof(XkbKTMapEntryRec));
262 if (from->preserve && (into->map_count > 0)) {
263 into->preserve = _XkbTypedCalloc(into->map_count, XkbModsRec);
266 memcpy(into->preserve, from->preserve,
267 into->map_count * sizeof(XkbModsRec));
270 if (from->level_names && (into->num_levels > 0)) {
271 into->level_names = _XkbTypedCalloc(into->num_levels, CARD32);
272 if (!into->level_names)
274 memcpy(into->level_names, from->level_names,
275 into->num_levels * sizeof(CARD32));
282 XkbcCopyKeyTypes(XkbcKeyTypePtr from, XkbcKeyTypePtr into, int num_types)
286 if (!from || !into || (num_types < 0))
289 for (i = 0; i < num_types; i++) {
290 if ((rtrn = XkbcCopyKeyType(from++, into++)) != Success)
298 XkbcResizeKeyType(XkbcDescPtr xkb, int type_ndx, int map_count,
299 Bool want_preserve, int new_num_lvls)
302 KeyCode matchingKeys[XkbMaxKeyCount], nMatchingKeys;
304 if ((type_ndx < 0) || (type_ndx >= xkb->map->num_types) ||
305 (map_count < 0)|| (new_num_lvls < 1))
309 case XkbOneLevelIndex:
310 if (new_num_lvls != 1)
312 case XkbTwoLevelIndex:
313 case XkbAlphabeticIndex:
315 if (new_num_lvls != 2)
319 type = &xkb->map->types[type_ndx];
321 if (map_count == 0) {
327 _XkbFree(type->preserve);
328 type->preserve = NULL;
333 XkbKTMapEntryRec *prev_map = type->map;
335 if ((map_count > type->map_count) || !type->map)
336 type->map = _XkbTypedRealloc(type->map, map_count,
345 XkbModsRec *prev_preserve = type->preserve;
347 if ((map_count > type->map_count) || !type->preserve)
348 type->preserve = _XkbTypedRealloc(type->preserve, map_count,
350 if (!type->preserve) {
352 _XkbFree(prev_preserve);
356 else if (type->preserve) {
357 _XkbFree(type->preserve);
358 type->preserve = NULL;
361 type->map_count = map_count;
364 if ((new_num_lvls > type->num_levels) || !type->level_names) {
365 CARD32 *prev_level_names = type->level_names;
367 type->level_names = _XkbTypedRealloc(type->level_names, new_num_lvls,
369 if (!type->level_names) {
370 if (prev_level_names)
371 _XkbFree(prev_level_names);
378 * If the width of the type changed, we might have to resize the symbol
379 * maps for any keys that use the type for one or more groups. This is
380 * expensive, so we'll try to cull out any keys that are obviously okay:
382 * - keys that have a group width <= the old width are okay (because
383 * they could not possibly have been associated with the old type)
384 * If the key type increased in size:
385 * - keys that already have a group width >= to the new width are okay
386 * + keys that have a group width >= the old width but < the new width
387 * might have to be enlarged.
388 * If the key type decreased in size:
389 * - keys that have a group width > the old width don't have to be
390 * resized (because they must have some other wider type associated
392 * + keys that have a group width == the old width might have to be
394 * The possibilities marked with '+' require us to examine the key types
395 * associated with each group for the key.
397 bzero(matchingKeys, XkbMaxKeyCount * sizeof(KeyCode));
399 if (new_num_lvls > type->num_levels) {
402 int width, match, nResize = 0;
405 for (nTotal = 1, i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
406 width = XkbKeyGroupsWidth(xkb, i);
407 if (width < type->num_levels)
410 for (match = 0, g = XkbKeyNumGroups(xkb, i) - 1;
411 (g >= 0) && !match; g--) {
412 if (XkbKeyKeyTypeIndex(xkb, i, g) == type_ndx) {
413 matchingKeys[nMatchingKeys++] = i;
418 if (!match || (width >= new_num_lvls))
419 nTotal += XkbKeyNumSyms(xkb, i);
421 nTotal += XkbKeyNumGroups(xkb, i) * new_num_lvls;
429 xkb->map->size_syms = (nTotal * 12) / 10;
430 newSyms = _XkbTypedCalloc(xkb->map->size_syms, CARD32);
436 for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
437 if (matchingKeys[nextMatch] == i) {
441 width = XkbKeyGroupsWidth(xkb, i);
442 pOld = XkbKeySymsPtr(xkb, i);
443 for (g = XkbKeyNumGroups(xkb, i) - 1; g >= 0; g--)
444 memcpy(&newSyms[nSyms+(new_num_lvls * g)],
445 &pOld[width * g], width * sizeof(CARD32));
446 xkb->map->key_sym_map[i].offset = nSyms;
447 nSyms += XkbKeyNumGroups(xkb, i) * new_num_lvls;
450 memcpy(&newSyms[nSyms], XkbKeySymsPtr(xkb, i),
451 XkbKeyNumSyms(xkb, i) * sizeof(CARD32));
452 xkb->map->key_sym_map[i].offset = nSyms;
453 nSyms += XkbKeyNumSyms(xkb,i);
457 type->num_levels = new_num_lvls;
458 _XkbFree(xkb->map->syms);
459 xkb->map->syms = newSyms;
460 xkb->map->num_syms = nSyms;
465 else if (new_num_lvls < type->num_levels) {
469 for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
470 width = XkbKeyGroupsWidth(xkb, i);
471 if (width < type->num_levels)
474 for (match = 0, g = XkbKeyNumGroups(xkb, i) - 1;
475 (g >= 0) && !match; g--) {
476 if (XkbKeyKeyTypeIndex(xkb, i, g) == type_ndx) {
477 matchingKeys[nMatchingKeys++] = i;
484 if (nMatchingKeys > 0) {
488 if (new_num_lvls > type->num_levels)
489 firstClear = type->num_levels;
491 firstClear = new_num_lvls;
493 for (i = 0; i < nMatchingKeys; i++) {
497 key = matchingKeys[i];
498 width = XkbKeyGroupsWidth(xkb, key);
499 nClear = width - firstClear;
500 pSyms = XkbKeySymsPtr(xkb, key);
501 for (g = XkbKeyNumGroups(xkb, key) - 1; g >= 0; g--) {
502 if (XkbKeyKeyTypeIndex(xkb, key, g) == type_ndx) {
504 bzero(&pSyms[g * width + firstClear],
505 nClear * sizeof(CARD32));
511 type->num_levels = new_num_lvls;
517 XkbcResizeKeySyms(XkbcDescPtr xkb, int key, int needed)
519 int i, nSyms, nKeySyms;
524 xkb->map->key_sym_map[key].offset = 0;
525 return xkb->map->syms;
528 nOldSyms = XkbKeyNumSyms(xkb, key);
529 if (nOldSyms >= (unsigned)needed)
530 return XkbKeySymsPtr(xkb, key);
532 if (xkb->map->size_syms - xkb->map->num_syms >= (unsigned)needed) {
534 memcpy(&xkb->map->syms[xkb->map->num_syms],
535 XkbKeySymsPtr(xkb, key), nOldSyms * sizeof(CARD32));
537 if ((needed - nOldSyms) > 0)
538 bzero(&xkb->map->syms[xkb->map->num_syms + XkbKeyNumSyms(xkb, key)],
539 (needed - nOldSyms) * sizeof(CARD32));
541 xkb->map->key_sym_map[key].offset = xkb->map->num_syms;
542 xkb->map->num_syms += needed;
544 return &xkb->map->syms[xkb->map->key_sym_map[key].offset];
547 xkb->map->size_syms += (needed > 32 ? needed : 32);
548 newSyms = _XkbTypedCalloc(xkb->map->size_syms, CARD32);
552 newSyms[0] = NoSymbol;
554 for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
557 nCopy = nKeySyms = XkbKeyNumSyms(xkb, i);
558 if ((nKeySyms == 0) && (i != key))
564 memcpy(&newSyms[nSyms], XkbKeySymsPtr(xkb, i),
565 nCopy * sizeof(CARD32));
566 if (nKeySyms > nCopy)
567 bzero(&newSyms[nSyms+nCopy], (nKeySyms - nCopy) * sizeof(CARD32));
569 xkb->map->key_sym_map[i].offset = nSyms;
573 _XkbFree(xkb->map->syms);
574 xkb->map->syms = newSyms;
575 xkb->map->num_syms = nSyms;
577 return &xkb->map->syms[xkb->map->key_sym_map[key].offset];
581 _ExtendRange(unsigned int old_flags, unsigned int flag, KeyCode newKC,
582 KeyCode *old_min, unsigned char *old_num)
584 if ((old_flags & flag) == 0) {
590 int last = (*old_min) + (*old_num) - 1;
592 if (newKC < *old_min) {
594 *old_num = last - newKC + 1;
596 else if (newKC > last) {
597 *old_num = newKC - (*old_min) + 1;
605 XkbcChangeKeycodeRange(XkbcDescPtr xkb, int minKC, int maxKC,
606 XkbChangesPtr changes)
610 if (!xkb || (minKC < XkbMinLegalKeyCode) || (maxKC > XkbMaxLegalKeyCode))
616 if (minKC < xkb->min_key_code) {
618 changes->map.min_key_code = minKC;
619 tmp = xkb->min_key_code - minKC;
622 if (xkb->map->key_sym_map) {
623 bzero(&xkb->map->key_sym_map[minKC],
624 tmp * sizeof(XkbSymMapRec));
626 changes->map.changed = _ExtendRange(changes->map.changed,
627 XkbKeySymsMask, minKC,
628 &changes->map.first_key_sym,
629 &changes->map.num_key_syms);
632 if (xkb->map->modmap) {
633 bzero(&xkb->map->modmap[minKC], tmp);
635 changes->map.changed = _ExtendRange(changes->map.changed,
636 XkbModifierMapMask, minKC,
637 &changes->map.first_modmap_key,
638 &changes->map.num_modmap_keys);
643 if (xkb->server->behaviors) {
644 bzero(&xkb->server->behaviors[minKC],
645 tmp * sizeof(XkbBehavior));
647 changes->map.changed = _ExtendRange(changes->map.changed,
648 XkbKeyBehaviorsMask, minKC,
649 &changes->map.first_key_behavior,
650 &changes->map.num_key_behaviors);
653 if (xkb->server->key_acts) {
654 bzero(&xkb->server->key_acts[minKC],
655 tmp * sizeof(unsigned short));
657 changes->map.changed = _ExtendRange(changes->map.changed,
658 XkbKeyActionsMask, minKC,
659 &changes->map.first_key_act,
660 &changes->map.num_key_acts);
663 if (xkb->server->vmodmap) {
664 bzero(&xkb->server->vmodmap[minKC],
665 tmp * sizeof(uint32_t));
667 changes->map.changed = _ExtendRange(changes->map.changed,
668 XkbVirtualModMapMask, minKC,
669 &changes->map.first_modmap_key,
670 &changes->map.num_vmodmap_keys);
674 if (xkb->names && xkb->names->keys) {
675 bzero(&xkb->names->keys[minKC], tmp * sizeof(XkbKeyNameRec));
677 changes->names.changed = _ExtendRange(changes->names.changed,
678 XkbKeyNamesMask, minKC,
679 &changes->names.first_key,
680 &changes->names.num_keys);
683 xkb->min_key_code = minKC;
686 if (maxKC > xkb->max_key_code) {
688 changes->map.max_key_code = maxKC;
689 tmp = maxKC-xkb->max_key_code;
692 if (xkb->map->key_sym_map) {
693 XkbSymMapRec *prev_key_sym_map = xkb->map->key_sym_map;
695 xkb->map->key_sym_map = _XkbTypedRealloc(xkb->map->key_sym_map,
698 if (!xkb->map->key_sym_map) {
699 _XkbFree(prev_key_sym_map);
703 bzero(&xkb->map->key_sym_map[xkb->max_key_code],
704 tmp * sizeof(XkbSymMapRec));
706 changes->map.changed = _ExtendRange(changes->map.changed,
707 XkbKeySymsMask, maxKC,
708 &changes->map.first_key_sym,
709 &changes->map.num_key_syms);
712 if (xkb->map->modmap) {
713 unsigned char *prev_modmap = xkb->map->modmap;
715 xkb->map->modmap = _XkbTypedRealloc(xkb->map->modmap,
716 maxKC + 1, unsigned char);
717 if (!xkb->map->modmap) {
718 _XkbFree(prev_modmap);
722 bzero(&xkb->map->modmap[xkb->max_key_code], tmp);
724 changes->map.changed = _ExtendRange(changes->map.changed,
725 XkbModifierMapMask, maxKC,
726 &changes->map.first_modmap_key,
727 &changes->map.num_modmap_keys);
732 if (xkb->server->behaviors) {
733 XkbBehavior *prev_behaviors = xkb->server->behaviors;
735 xkb->server->behaviors = _XkbTypedRealloc(xkb->server->behaviors,
738 if (!xkb->server->behaviors) {
739 _XkbFree(prev_behaviors);
743 bzero(&xkb->server->behaviors[xkb->max_key_code],
744 tmp * sizeof(XkbBehavior));
746 changes->map.changed = _ExtendRange(changes->map.changed,
747 XkbKeyBehaviorsMask, maxKC,
748 &changes->map.first_key_behavior,
749 &changes->map.num_key_behaviors);
752 if (xkb->server->key_acts) {
753 unsigned short *prev_key_acts = xkb->server->key_acts;
755 xkb->server->key_acts = _XkbTypedRealloc(xkb->server->key_acts,
758 if (!xkb->server->key_acts) {
759 _XkbFree(prev_key_acts);
763 bzero(&xkb->server->key_acts[xkb->max_key_code],
764 tmp * sizeof(unsigned short));
766 changes->map.changed = _ExtendRange(changes->map.changed,
767 XkbKeyActionsMask, maxKC,
768 &changes->map.first_key_act,
769 &changes->map.num_key_acts);
772 if (xkb->server->vmodmap) {
773 uint32_t *prev_vmodmap = xkb->server->vmodmap;
775 xkb->server->vmodmap = _XkbTypedRealloc(xkb->server->vmodmap,
778 if (!xkb->server->vmodmap) {
779 _XkbFree(prev_vmodmap);
783 bzero(&xkb->server->vmodmap[xkb->max_key_code],
784 tmp * sizeof(uint32_t));
786 changes->map.changed = _ExtendRange(changes->map.changed,
787 XkbVirtualModMapMask, maxKC,
788 &changes->map.first_modmap_key,
789 &changes->map.num_vmodmap_keys);
793 if (xkb->names && xkb->names->keys ) {
794 XkbKeyNameRec *prev_keys = xkb->names->keys;
796 xkb->names->keys = _XkbTypedRealloc(xkb->names->keys, maxKC + 1,
798 if (!xkb->names->keys) {
803 bzero(&xkb->names->keys[xkb->max_key_code],
804 tmp * sizeof(XkbKeyNameRec));
806 changes->names.changed = _ExtendRange(changes->names.changed,
807 XkbKeyNamesMask, maxKC,
808 &changes->names.first_key,
809 &changes->names.num_keys);
812 xkb->max_key_code = maxKC;
819 XkbcResizeKeyActions(XkbcDescPtr xkb, int key, int needed)
825 xkb->server->key_acts[key] = 0;
829 if (XkbKeyHasActions(xkb, key) &&
830 (XkbKeyNumSyms(xkb, key) >= (unsigned)needed))
831 return XkbKeyActionsPtr(xkb, key);
833 if (xkb->server->size_acts - xkb->server->num_acts >= (unsigned)needed) {
834 xkb->server->key_acts[key] = xkb->server->num_acts;
835 xkb->server->num_acts += needed;
837 return &xkb->server->acts[xkb->server->key_acts[key]];
840 xkb->server->size_acts = xkb->server->num_acts + needed + 8;
841 newActs = _XkbTypedCalloc(xkb->server->size_acts, XkbcAction);
844 newActs[0].type = XkbSA_NoAction;
847 for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
850 if ((xkb->server->key_acts[i] == 0) && (i != key))
853 nCopy = nKeyActs = XkbKeyNumActions(xkb, i);
861 memcpy(&newActs[nActs], XkbKeyActionsPtr(xkb, i),
862 nCopy * sizeof(XkbcAction));
863 if (nCopy < nKeyActs)
864 bzero(&newActs[nActs + nCopy],
865 (nKeyActs - nCopy) * sizeof(XkbcAction));
867 xkb->server->key_acts[i] = nActs;
871 _XkbFree(xkb->server->acts);
872 xkb->server->acts = newActs;
873 xkb->server->num_acts = nActs;
875 return &xkb->server->acts[xkb->server->key_acts[key]];
879 XkbcFreeClientMap(XkbcDescPtr xkb, unsigned what, Bool freeMap)
881 XkbcClientMapPtr map;
883 if (!xkb || !xkb->map)
887 what = XkbAllClientInfoMask;
890 if (what & XkbKeyTypesMask) {
892 if (map->num_types > 0) {
896 for (i = 0, type = map->types; i < map->num_types; i++, type++) {
901 if (type->preserve) {
902 _XkbFree(type->preserve);
903 type->preserve = NULL;
906 if (type->level_names) {
907 _XkbFree(type->level_names);
908 type->level_names = NULL;
912 _XkbFree(map->types);
913 map->num_types = map->size_types = 0;
918 if (what & XkbKeySymsMask) {
919 if (map->key_sym_map) {
920 _XkbFree(map->key_sym_map);
921 map->key_sym_map = NULL;
925 map->size_syms = map->num_syms = 0;
930 if ((what & XkbModifierMapMask) && map->modmap) {
931 _XkbFree(map->modmap);
942 XkbcFreeServerMap(XkbcDescPtr xkb, unsigned what, Bool freeMap)
944 XkbcServerMapPtr map;
946 if (!xkb || !xkb->server)
950 what = XkbAllServerInfoMask;
953 if ((what & XkbExplicitComponentsMask) && map->explicit) {
954 _XkbFree(map->explicit);
955 map->explicit = NULL;
958 if (what & XkbKeyActionsMask) {
960 _XkbFree(map->key_acts);
961 map->key_acts = NULL;
965 map->num_acts = map->size_acts = 0;
970 if ((what & XkbKeyBehaviorsMask) && map->behaviors) {
971 _XkbFree(map->behaviors);
972 map->behaviors = NULL;
975 if ((what & XkbVirtualModMapMask) && map->vmodmap) {
976 _XkbFree(map->vmodmap);
981 _XkbFree(xkb->server);