That's a better name and fits more nicely.
Also change type->map to type->entries.
Signed-off-by: Ran Benita <ran234@gmail.com>
free(keymap->keys);
}
for (i = 0; i < keymap->num_types; i++) {
free(keymap->keys);
}
for (i = 0; i < keymap->num_types; i++) {
- free(keymap->types[i].map);
+ free(keymap->types[i].entries);
free(keymap->types[i].level_names);
}
free(keymap->types);
free(keymap->types[i].level_names);
}
free(keymap->types);
struct xkb_private_action priv;
};
struct xkb_private_action priv;
};
-struct xkb_kt_map_entry {
+struct xkb_key_type_entry {
xkb_level_index_t level;
struct xkb_mods mods;
struct xkb_mods preserve;
};
struct xkb_key_type {
xkb_level_index_t level;
struct xkb_mods mods;
struct xkb_mods preserve;
};
struct xkb_key_type {
struct xkb_mods mods;
xkb_level_index_t num_levels;
struct xkb_mods mods;
xkb_level_index_t num_levels;
- struct xkb_kt_map_entry *map;
- unsigned int num_entries;
- xkb_atom_t name;
+ unsigned int num_entries;
+ struct xkb_key_type_entry *entries;
};
struct xkb_sym_interpret {
};
struct xkb_sym_interpret {
struct xkb_keymap *keymap;
};
struct xkb_keymap *keymap;
};
-static const struct xkb_kt_map_entry *
+static const struct xkb_key_type_entry *
get_entry_for_key_state(struct xkb_state *state, const struct xkb_key *key,
xkb_layout_index_t group)
{
get_entry_for_key_state(struct xkb_state *state, const struct xkb_key *key,
xkb_layout_index_t group)
{
* supposed to skip the entry (xserver does this with cached
* entry->active field).
*/
* supposed to skip the entry (xserver does this with cached
* entry->active field).
*/
- if (!type->map[i].mods.mask)
+ if (!type->entries[i].mods.mask)
- if (type->map[i].mods.mask == active_mods)
- return &type->map[i];
+ if (type->entries[i].mods.mask == active_mods)
+ return &type->entries[i];
xkb_layout_index_t layout)
{
const struct xkb_key *key = XkbKey(state->keymap, kc);
xkb_layout_index_t layout)
{
const struct xkb_key *key = XkbKey(state->keymap, kc);
- const struct xkb_kt_map_entry *entry;
+ const struct xkb_key_type_entry *entry;
if (!key || layout >= key->num_groups)
return XKB_LEVEL_INVALID;
if (!key || layout >= key->num_groups)
return XKB_LEVEL_INVALID;
static xkb_mod_mask_t
key_get_consumed(struct xkb_state *state, const struct xkb_key *key)
{
static xkb_mod_mask_t
key_get_consumed(struct xkb_state *state, const struct xkb_key *key)
{
- const struct xkb_kt_map_entry *entry;
+ const struct xkb_key_type_entry *entry;
xkb_layout_index_t group;
group = xkb_state_key_get_layout(state, key->keycode);
xkb_layout_index_t group;
group = xkb_state_key_get_layout(state, key->keycode);
for (unsigned j = 0; j < type->num_entries; j++) {
const char *str;
for (unsigned j = 0; j < type->num_entries; j++) {
const char *str;
- const struct xkb_kt_map_entry *entry = &type->map[j];
+ const struct xkb_key_type_entry *entry = &type->entries[j];
/*
* Printing level 1 entries is redundant, it's the default,
/*
* Printing level 1 entries is redundant, it's the default,
ComputeEffectiveMask(keymap, &keymap->types[i].mods);
for (j = 0; j < keymap->types[i].num_entries; j++) {
ComputeEffectiveMask(keymap, &keymap->types[i].mods);
for (j = 0; j < keymap->types[i].num_entries; j++) {
- ComputeEffectiveMask(keymap, &keymap->types[i].map[j].mods);
- ComputeEffectiveMask(keymap, &keymap->types[i].map[j].preserve);
+ ComputeEffectiveMask(keymap, &keymap->types[i].entries[j].mods);
+ ComputeEffectiveMask(keymap, &keymap->types[i].entries[j].preserve);
xkb_atom_t name;
xkb_mod_mask_t mods;
xkb_level_index_t num_levels;
xkb_atom_t name;
xkb_mod_mask_t mods;
xkb_level_index_t num_levels;
- darray(struct xkb_kt_map_entry) entries;
+ darray(struct xkb_key_type_entry) entries;
darray(xkb_atom_t) level_names;
} KeyTypeInfo;
darray(xkb_atom_t) level_names;
} KeyTypeInfo;
/***====================================================================***/
static inline const char *
/***====================================================================***/
static inline const char *
-MapEntryTxt(KeyTypesInfo *info, struct xkb_kt_map_entry *entry)
+MapEntryTxt(KeyTypesInfo *info, struct xkb_key_type_entry *entry)
{
return ModMaskText(info->keymap, entry->mods.mods);
}
{
return ModMaskText(info->keymap, entry->mods.mods);
}
/***====================================================================***/
/***====================================================================***/
-static struct xkb_kt_map_entry *
+static struct xkb_key_type_entry *
FindMatchingMapEntry(KeyTypeInfo *type, xkb_mod_mask_t mods)
{
FindMatchingMapEntry(KeyTypeInfo *type, xkb_mod_mask_t mods)
{
- struct xkb_kt_map_entry *entry;
+ struct xkb_key_type_entry *entry;
darray_foreach(entry, type->entries)
if (entry->mods.mods == mods)
darray_foreach(entry, type->entries)
if (entry->mods.mods == mods)
static bool
AddMapEntry(KeyTypesInfo *info, KeyTypeInfo *type,
static bool
AddMapEntry(KeyTypesInfo *info, KeyTypeInfo *type,
- struct xkb_kt_map_entry *new, bool clobber, bool report)
+ struct xkb_key_type_entry *new, bool clobber, bool report)
- struct xkb_kt_map_entry *old;
+ struct xkb_key_type_entry *old;
old = FindMatchingMapEntry(type, new->mods.mods);
if (old) {
old = FindMatchingMapEntry(type, new->mods.mods);
if (old) {
SetMapEntry(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
ExprDef *value)
{
SetMapEntry(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
ExprDef *value)
{
- struct xkb_kt_map_entry entry;
+ struct xkb_key_type_entry entry;
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "map entry");
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "map entry");
AddPreserve(KeyTypesInfo *info, KeyTypeInfo *type,
xkb_mod_mask_t mods, xkb_mod_mask_t preserve_mods)
{
AddPreserve(KeyTypesInfo *info, KeyTypeInfo *type,
xkb_mod_mask_t mods, xkb_mod_mask_t preserve_mods)
{
- struct xkb_kt_map_entry *entry;
- struct xkb_kt_map_entry new;
+ struct xkb_key_type_entry *entry;
+ struct xkb_key_type_entry new;
darray_foreach(entry, type->entries) {
if (entry->mods.mods != mods)
darray_foreach(entry, type->entries) {
if (entry->mods.mods != mods)
type->mods.mods = 0;
type->num_levels = 1;
type->mods.mods = 0;
type->num_levels = 1;
type->num_entries = 0;
type->name = xkb_atom_intern(keymap->ctx, "default");
type->level_names = NULL;
type->num_entries = 0;
type->name = xkb_atom_intern(keymap->ctx, "default");
type->level_names = NULL;
type->mods.mods = def->mods;
type->num_levels = def->num_levels;
type->mods.mods = def->mods;
type->num_levels = def->num_levels;
- type->map = darray_mem(def->entries, 0);
+ type->entries = darray_mem(def->entries, 0);
type->num_entries = darray_size(def->entries);
darray_init(def->entries);
type->name = def->name;
type->num_entries = darray_size(def->entries);
darray_init(def->entries);
type->name = def->name;