int
XkbcAllocClientMap(struct xkb_keymap *keymap, unsigned which,
- unsigned nTotalTypes)
+ size_t nTotalTypes)
{
- struct xkb_client_map * map;
-
if (!keymap || ((nTotalTypes > 0) && (nTotalTypes < XkbNumRequiredTypes)))
return BadValue;
if (!keymap->map) {
- map = uTypedCalloc(1, struct xkb_client_map);
- if (!map)
+ keymap->map = calloc(1, sizeof(*keymap->map));
+ if (!keymap->map)
return BadAlloc;
- keymap->map = map;
+ darray_init(keymap->map->types);
}
- else
- map = keymap->map;
-
- if ((which & XkbKeyTypesMask) && (nTotalTypes > 0)) {
- if (!map->types) {
- map->types = uTypedCalloc(nTotalTypes, struct xkb_key_type);
- if (!map->types)
- return BadAlloc;
-
- map->num_types = 0;
- map->size_types = nTotalTypes;
- }
- else if (map->size_types < nTotalTypes) {
- struct xkb_key_type *prev_types = map->types;
-
- map->types = uTypedRealloc(map->types, nTotalTypes,
- struct xkb_key_type);
- if (!map->types) {
- free(prev_types);
- map->num_types = map->size_types = 0;
- return BadAlloc;
- }
- map->size_types = nTotalTypes;
- memset(&map->types[map->num_types], 0,
- (map->size_types - map->num_types) * sizeof(struct xkb_key_type));
- }
- }
+ if (which & XkbKeyTypesMask)
+ darray_growalloc(keymap->map->types, nTotalTypes);
if (which & XkbKeySymsMask) {
- if (!map->key_sym_map) {
- map->key_sym_map = uTypedCalloc(keymap->max_key_code + 1,
- struct xkb_sym_map);
- if (!map->key_sym_map)
+ if (!keymap->map->key_sym_map) {
+ keymap->map->key_sym_map = uTypedCalloc(keymap->max_key_code + 1,
+ struct xkb_sym_map);
+ if (!keymap->map->key_sym_map)
return BadAlloc;
}
}
if (which & XkbModifierMapMask) {
- if (!map->modmap) {
- map->modmap = uTypedCalloc(keymap->max_key_code + 1,
- unsigned char);
- if (!map->modmap)
+ if (!keymap->map->modmap) {
+ keymap->map->modmap = uTypedCalloc(keymap->max_key_code + 1,
+ unsigned char);
+ if (!keymap->map->modmap)
return BadAlloc;
}
}
struct xkb_client_map * map;
struct xkb_key_type * type;
xkb_keycode_t key;
- int i;
if (!keymap || !keymap->map)
return;
map = keymap->map;
- for (i = 0, type = map->types; i < map->num_types && type; i++, type++) {
+ darray_foreach(type, map->types) {
int j;
free(type->map);
free(type->preserve);
free(type->level_names);
free(UNCONSTIFY(type->name));
}
- free(map->types);
+ darray_free(map->types);
if (map->key_sym_map) {
for (key = keymap->min_key_code; key < keymap->max_key_code; key++) {
}
names = keymap->names;
- if ((which & XkbKTLevelNamesMask) && keymap->map && keymap->map->types) {
- int i;
+ if ((which & XkbKTLevelNamesMask) && keymap->map) {
struct xkb_key_type * type;
- type = keymap->map->types;
- for (i = 0; i < keymap->map->num_types; i++, type++) {
+ darray_foreach(type, keymap->map->types) {
if (!type->level_names) {
type->level_names = uTypedCalloc(type->num_levels, const char *);
if (!type->level_names)
{
struct xkb_names * names;
struct xkb_client_map * map;
+ struct xkb_key_type *type;
int i;
if (!keymap || !keymap->names)
names = keymap->names;
map = keymap->map;
- if (map && map->types) {
- struct xkb_key_type * type = map->types;
-
- for (i = 0; i < map->num_types; i++, type++) {
+ if (map) {
+ darray_foreach(type, map->types) {
int j;
for (j = 0; j < type->num_levels; j++)
free(UNCONSTIFY(type->level_names[j]));
extern int
XkbcAllocClientMap(struct xkb_keymap *keymap, unsigned which,
- unsigned nTotalTypes);
+ size_t nTotalTypes);
extern int
XkbcAllocServerMap(struct xkb_keymap *keymap, unsigned which,
int keypadVMod)
{
struct xkb_client_map * map;
- struct xkb_key_type *from, *to;
+ struct xkb_key_type *from;
int rtrn;
if (!keymap)
rtrn = Success;
from = canonicalTypes;
- to = map->types;
if (which & XkbOneLevelMask)
- rtrn = XkbcCopyKeyType(&from[XkbOneLevelIndex], &to[XkbOneLevelIndex]);
+ rtrn = XkbcCopyKeyType(&from[XkbOneLevelIndex],
+ &darray_item(map->types, XkbOneLevelIndex));
if ((which & XkbTwoLevelMask) && (rtrn == Success))
- rtrn = XkbcCopyKeyType(&from[XkbTwoLevelIndex], &to[XkbTwoLevelIndex]);
+ rtrn = XkbcCopyKeyType(&from[XkbTwoLevelIndex],
+ &darray_item(map->types, XkbTwoLevelIndex));
if ((which & XkbAlphabeticMask) && (rtrn == Success))
rtrn = XkbcCopyKeyType(&from[XkbAlphabeticIndex],
- &to[XkbAlphabeticIndex]);
+ &darray_item(map->types, XkbAlphabeticIndex));
if ((which & XkbKeypadMask) && (rtrn == Success)) {
struct xkb_key_type * type;
- rtrn = XkbcCopyKeyType(&from[XkbKeypadIndex], &to[XkbKeypadIndex]);
- type = &to[XkbKeypadIndex];
+ rtrn = XkbcCopyKeyType(&from[XkbKeypadIndex],
+ &darray_item(map->types, XkbKeypadIndex));
+ type = &darray_item(map->types, XkbKeypadIndex);
if ((keypadVMod >= 0) && (keypadVMod < XkbNumVirtualMods) &&
(rtrn == Success)) {
};
struct xkb_client_map {
- unsigned char size_types;
- unsigned char num_types;
- struct xkb_key_type * types;
+ darray(struct xkb_key_type) types;
struct xkb_sym_map * key_sym_map;
unsigned char *modmap;
};
#define XkbKeyGroupWidth(d,k,g) (XkbKeyType(d,k,g)->num_levels)
#define XkbKeyGroupsWidth(d,k) ((d)->map->key_sym_map[k].width)
#define XkbKeyTypeIndex(d,k,g) ((d)->map->key_sym_map[k].kt_index[g&0x3])
-#define XkbKeyType(d,k,g) (&(d)->map->types[XkbKeyTypeIndex(d,k,g)])
+#define XkbKeyType(d,k,g) (&darray_item((d)->map->types, XkbKeyTypeIndex(d,k,g)))
#define XkbKeyNumSyms(d,k,g,sl) \
((d)->map->key_sym_map[k].num_syms[(g*XkbKeyGroupsWidth(d,k))+sl])
#define XkbKeySym(d,k,n) (&(d)->map->key_sym_map[k].syms[n])
{
xkb_keycode_t key;
int i;
+ struct xkb_key_type *type;
/* Find all the interprets for the key and bind them to actions,
* which will also update the vmodmap. */
}
/* Now update the level masks for all the types to reflect the vmods. */
- for (i = 0; i < keymap->map->num_types; i++) {
- struct xkb_key_type *type = &keymap->map->types[i];
+ darray_foreach(type, keymap->map->types) {
uint32_t mask = 0;
int j;
type->mods.mask = type->mods.real_mods;
goto err_info;
}
- keymap->map->num_types = i;
+ darray_resize0(keymap->map->types, i);
if (XkbAllRequiredTypes & (~info.stdPresent)) {
unsigned missing, keypadVMod;
}
if (missing & XkbOneLevelMask)
- keymap->map->types[XkbOneLevelIndex].name =
+ darray_item(keymap->map->types, XkbOneLevelIndex).name =
xkb_atom_strdup(keymap->ctx, tok_ONE_LEVEL);
if (missing & XkbTwoLevelMask)
- keymap->map->types[XkbTwoLevelIndex].name =
+ darray_item(keymap->map->types, XkbTwoLevelIndex).name =
xkb_atom_strdup(keymap->ctx, tok_TWO_LEVEL);
if (missing & XkbAlphabeticMask)
- keymap->map->types[XkbAlphabeticIndex].name =
+ darray_item(keymap->map->types, XkbAlphabeticIndex).name =
xkb_atom_strdup(keymap->ctx, tok_ALPHABETIC);
if (missing & XkbKeypadMask)
- keymap->map->types[XkbKeypadIndex].name =
+ darray_item(keymap->map->types, XkbKeypadIndex).name =
xkb_atom_strdup(keymap->ctx, tok_KEYPAD);
}
- next = &keymap->map->types[XkbLastRequiredType + 1];
+ next = &darray_item(keymap->map->types, XkbLastRequiredType + 1);
for (i = 0, def = info.types; i < info.nTypes; i++) {
if (def->name == tok_ONE_LEVEL)
- type = &keymap->map->types[XkbOneLevelIndex];
+ type = &darray_item(keymap->map->types, XkbOneLevelIndex);
else if (def->name == tok_TWO_LEVEL)
- type = &keymap->map->types[XkbTwoLevelIndex];
+ type = &darray_item(keymap->map->types, XkbTwoLevelIndex);
else if (def->name == tok_ALPHABETIC)
- type = &keymap->map->types[XkbAlphabeticIndex];
+ type = &darray_item(keymap->map->types, XkbAlphabeticIndex);
else if (def->name == tok_KEYPAD)
- type = &keymap->map->types[XkbKeypadIndex];
+ type = &darray_item(keymap->map->types, XkbKeypadIndex);
else
type = next++;
static bool
FindNamedType(struct xkb_keymap *keymap, xkb_atom_t atom, unsigned *type_rtrn)
{
- unsigned n;
+ unsigned n = 0;
const char *name = xkb_atom_text(keymap->ctx, atom);
+ struct xkb_key_type *type;
- if (keymap && keymap->map && keymap->map->types)
- {
- for (n = 0; n < keymap->map->num_types; n++)
- {
- if (strcmp(keymap->map->types[n].name, name) == 0)
- {
+ if (keymap && keymap->map) {
+ darray_foreach(type, keymap->map->types) {
+ if (strcmp(type->name, name) == 0) {
*type_rtrn = n;
return true;
}
+ n++;
}
}
return false;
types[i] = XkbTwoLevelIndex;
}
/* if the type specifies fewer levels than the key has, shrink the key */
- type = &keymap->map->types[types[i]];
+ type = &darray_item(keymap->map->types, types[i]);
if (type->num_levels < key->numLevels[i])
{
if (warningLevel > 0)