}
xkb_mod_index_t
-XkbModNameToIndex(const struct xkb_keymap *keymap, xkb_atom_t name,
+XkbModNameToIndex(const struct xkb_mod_set *mods, xkb_atom_t name,
enum mod_type type)
{
xkb_mod_index_t i;
const struct xkb_mod *mod;
- darray_enumerate(i, mod, keymap->mods.mods)
+ darray_enumerate(i, mod, mods->mods)
if ((mod->type & type) && name == mod->name)
return i;
if (atom == XKB_ATOM_NONE)
return XKB_MOD_INVALID;
- return XkbModNameToIndex(keymap, atom, MOD_BOTH);
+ return XkbModNameToIndex(&keymap->mods, atom, MOD_BOTH);
}
/**
XkbEscapeMapName(char *name);
xkb_mod_index_t
-XkbModNameToIndex(const struct xkb_keymap *keymap, xkb_atom_t name,
+XkbModNameToIndex(const struct xkb_mod_set *mods, xkb_atom_t name,
enum mod_type type);
xkb_layout_index_t
};
const char *
-ModIndexText(const struct xkb_keymap *keymap, xkb_mod_index_t ndx)
+ModIndexText(struct xkb_context *ctx, const struct xkb_mod_set *mods,
+ xkb_mod_index_t ndx)
{
if (ndx == XKB_MOD_INVALID)
return "none";
- if (ndx >= darray_size(keymap->mods.mods))
+ if (ndx >= darray_size(mods->mods))
return NULL;
- return xkb_atom_text(keymap->ctx,
- darray_item(keymap->mods.mods, ndx).name);
+ return xkb_atom_text(ctx, darray_item(mods->mods, ndx).name);
}
const char *
}
const char *
-ModMaskText(const struct xkb_keymap *keymap, xkb_mod_mask_t mask)
+ModMaskText(struct xkb_context *ctx, const struct xkb_mod_set *mods,
+ xkb_mod_mask_t mask)
{
char buf[1024];
size_t pos = 0;
if (mask == MOD_REAL_MASK_ALL)
return "all";
- darray_enumerate(i, mod, keymap->mods.mods) {
+ darray_enumerate(i, mod, mods->mods) {
int ret;
if (!(mask & (1u << i)))
ret = snprintf(buf + pos, sizeof(buf) - pos, "%s%s",
pos == 0 ? "" : "+",
- xkb_atom_text(keymap->ctx, mod->name));
+ xkb_atom_text(ctx, mod->name));
if (ret <= 0 || pos + ret >= sizeof(buf))
break;
else
pos += ret;
}
- return strcpy(xkb_context_get_buffer(keymap->ctx, pos + 1), buf);
+ return strcpy(xkb_context_get_buffer(ctx, pos + 1), buf);
}
const char *
extern const LookupEntry symInterpretMatchMaskNames[];
const char *
-ModMaskText(const struct xkb_keymap *keymap, xkb_mod_mask_t mask);
+ModMaskText(struct xkb_context *ctx, const struct xkb_mod_set *mods,
+ xkb_mod_mask_t mask);
const char *
-ModIndexText(const struct xkb_keymap *keymap, xkb_mod_index_t ndx);
+ModIndexText(struct xkb_context *ctx, const struct xkb_mod_set *mods,
+ xkb_mod_index_t ndx);
const char *
ActionTypeText(enum xkb_action_type type);
snprintf(buf, 128, "%s+%s(%s)",
KeysymText(info->ctx, si->interp.sym),
SIMatchText(si->interp.match),
- ModMaskText(info->keymap, si->interp.mods));
+ ModMaskText(info->ctx, &info->keymap->mods, si->interp.mods));
return buf;
}
return true;
}
- ndx = XkbModNameToIndex(keymap, field, mod_type);
+ ndx = XkbModNameToIndex(&keymap->mods, field, mod_type);
if (ndx == XKB_MOD_INVALID)
return false;
}
name = def->ident.ident;
- ndx = XkbModNameToIndex(keymap, name, mod_type);
+ ndx = XkbModNameToIndex(&keymap->mods, name, mod_type);
if (ndx == XKB_MOD_INVALID) {
log_err(keymap->ctx,
"Cannot resolve virtual modifier: "
xkb_atom_text(keymap->ctx, type->name));
write_buf(buf, "\t\tmodifiers= %s;\n",
- ModMaskText(keymap, type->mods.mods));
+ ModMaskText(keymap->ctx, &keymap->mods, type->mods.mods));
for (unsigned j = 0; j < type->num_entries; j++) {
const char *str;
if (entry->level == 0 && entry->preserve.mods == 0)
continue;
- str = ModMaskText(keymap, entry->mods.mods);
+ str = ModMaskText(keymap->ctx, &keymap->mods, entry->mods.mods);
write_buf(buf, "\t\tmap[%s]= Level%u;\n",
str, entry->level + 1);
if (entry->preserve.mods)
write_buf(buf, "\t\tpreserve[%s]= %s;\n",
- str, ModMaskText(keymap, entry->preserve.mods));
+ str, ModMaskText(keymap->ctx, &keymap->mods,
+ entry->preserve.mods));
}
for (xkb_level_index_t n = 0; n < type->num_levels; n++)
LedStateMaskText(keymap->ctx, led->which_mods));
}
write_buf(buf, "\t\tmodifiers= %s;\n",
- ModMaskText(keymap, led->mods.mods));
+ ModMaskText(keymap->ctx, &keymap->mods, led->mods.mods));
}
if (led->ctrls) {
if (action->mods.flags & ACTION_MODS_LOOKUP_MODMAP)
args = "modMapMods";
else
- args = ModMaskText(keymap, action->mods.mods.mods);
+ args = ModMaskText(keymap->ctx, &keymap->mods,
+ action->mods.mods.mods);
write_buf(buf, "%s%s(modifiers=%s%s%s%s)%s", prefix, type, args,
(action->type != ACTION_TYPE_MOD_LOCK && (action->mods.flags & ACTION_LOCK_CLEAR)) ? ",clearLocks" : "",
(action->type != ACTION_TYPE_MOD_LOCK && (action->mods.flags & ACTION_LATCH_TO_LOCK)) ? ",latchToLock" : "",
write_buf(buf, "\tinterpret %s+%s(%s) {\n",
si->sym ? KeysymText(keymap->ctx, si->sym) : "Any",
SIMatchText(si->match),
- ModMaskText(keymap, si->mods));
+ ModMaskText(keymap->ctx, &keymap->mods, si->mods));
if (si->virtual_mod != XKB_MOD_INVALID)
write_buf(buf, "\t\tvirtualModifier= %s;\n",
- ModIndexText(keymap, si->virtual_mod));
+ ModIndexText(keymap->ctx, &keymap->mods,
+ si->virtual_mod));
if (si->level_one_only)
write_buf(buf, "\t\tuseModMapMods=level1;\n");
if (key->vmodmap && (key->explicit & EXPLICIT_VMODMAP))
write_buf(buf, "\n\t\tvirtualMods= %s,",
- ModMaskText(keymap, key->vmodmap));
+ ModMaskText(keymap->ctx, &keymap->mods, key->vmodmap));
switch (key->out_of_range_group_action) {
case RANGE_SATURATE:
"Symbol \"%s\" added to modifier map for multiple modifiers; "
"Using %s, ignoring %s\n",
KeysymText(info->ctx, new->u.keySym),
- ModIndexText(info->keymap, use),
- ModIndexText(info->keymap, ignore));
+ ModIndexText(info->ctx, &info->keymap->mods, use),
+ ModIndexText(info->ctx, &info->keymap->mods, ignore));
else
log_err(info->ctx,
"Key \"%s\" added to modifier map for multiple modifiers; "
"Using %s, ignoring %s\n",
KeyNameText(info->ctx, new->u.keyName),
- ModIndexText(info->keymap, use),
- ModIndexText(info->keymap, ignore));
+ ModIndexText(info->ctx, &info->keymap->mods, use),
+ ModIndexText(info->ctx, &info->keymap->mods, ignore));
old->modifier = use;
return true;
bool ok;
struct xkb_context *ctx = info->ctx;
- ndx = XkbModNameToIndex(info->keymap, def->modifier, MOD_REAL);
+ ndx = XkbModNameToIndex(&info->keymap->mods, def->modifier, MOD_REAL);
if (ndx == XKB_MOD_INVALID) {
log_err(info->ctx,
"Illegal modifier map definition; "
log_err(info->ctx,
"Modmap entries may contain only key names or keysyms; "
"Illegal definition for %s modifier ignored\n",
- ModIndexText(info->keymap, tmp.modifier));
+ ModIndexText(info->ctx, &info->keymap->mods, tmp.modifier));
continue;
}
"Key %s not found in keycodes; "
"Modifier map entry for %s not updated\n",
KeyNameText(keymap->ctx, entry->u.keyName),
- ModIndexText(info->keymap, entry->modifier));
+ ModIndexText(info->ctx, &info->keymap->mods, entry->modifier));
return false;
}
}
"Key \"%s\" not found in symbol map; "
"Modifier map entry for %s not updated\n",
KeysymText(info->ctx, entry->u.keySym),
- ModIndexText(info->keymap, entry->modifier));
+ ModIndexText(info->ctx, &info->keymap->mods, entry->modifier));
return false;
}
}
static inline const char *
MapEntryTxt(KeyTypesInfo *info, struct xkb_key_type_entry *entry)
{
- return ModMaskText(info->keymap, entry->mods.mods);
+ return ModMaskText(info->ctx, &info->keymap->mods, entry->mods.mods);
}
static inline const char *
static inline const char *
TypeMaskTxt(KeyTypesInfo *info, KeyTypeInfo *type)
{
- return ModMaskText(info->keymap, type->mods);
+ return ModMaskText(info->ctx, &info->keymap->mods, type->mods);
}
static inline bool
"Using %s, ignoring %s\n",
xkb_atom_text(info->ctx, type->name),
TypeMaskTxt(info, type),
- ModMaskText(info->keymap, mods));
+ ModMaskText(info->ctx, &info->keymap->mods, mods));
return false;
}
"Map entry for unused modifiers in %s; "
"Using %s instead of %s\n",
TypeTxt(info, type),
- ModMaskText(info->keymap, entry.mods.mods & type->mods),
+ ModMaskText(info->ctx, &info->keymap->mods,
+ entry.mods.mods & type->mods),
MapEntryTxt(info, &entry));
entry.mods.mods &= type->mods;
}
log_vrb(info->ctx, 10,
"Identical definitions for preserve[%s] in %s; "
"Ignored\n",
- ModMaskText(info->keymap, mods),
+ ModMaskText(info->ctx, &info->keymap->mods, mods),
TypeTxt(info, type));
return true;
}
log_vrb(info->ctx, 1,
"Multiple definitions for preserve[%s] in %s; "
"Using %s, ignoring %s\n",
- ModMaskText(info->keymap, mods),
+ ModMaskText(info->ctx, &info->keymap->mods, mods),
TypeTxt(info, type),
- ModMaskText(info->keymap, preserve_mods),
- ModMaskText(info->keymap, entry->preserve.mods));
+ ModMaskText(info->ctx, &info->keymap->mods, preserve_mods),
+ ModMaskText(info->ctx, &info->keymap->mods, entry->preserve.mods));
entry->preserve.mods = preserve_mods;
return true;
if (mods & ~type->mods) {
const char *before, *after;
- before = ModMaskText(info->keymap, mods);
+ before = ModMaskText(info->ctx, &info->keymap->mods, mods);
mods &= type->mods;
- after = ModMaskText(info->keymap, mods);
+ after = ModMaskText(info->ctx, &info->keymap->mods, mods);
log_vrb(info->ctx, 1,
"Preserve for modifiers not used by the %s type; "
log_err(info->ctx,
"Preserve value in a key type is not a modifier mask; "
"Ignoring preserve[%s] in type %s\n",
- ModMaskText(info->keymap, mods),
+ ModMaskText(info->ctx, &info->keymap->mods, mods),
TypeTxt(info, type));
return false;
}
if (preserve_mods & ~mods) {
const char *before, *after;
- before = ModMaskText(info->keymap, preserve_mods);
+ before = ModMaskText(info->ctx, &info->keymap->mods, preserve_mods);
preserve_mods &= mods;
- after = ModMaskText(info->keymap, preserve_mods);
+ after = ModMaskText(info->ctx, &info->keymap->mods, preserve_mods);
log_vrb(info->ctx, 1,
"Illegal value for preserve[%s] in type %s; "
"Converted %s to %s\n",
- ModMaskText(info->keymap, mods),
+ ModMaskText(info->ctx, &info->keymap->mods, mods),
TypeTxt(info, type), before, after);
}
"Virtual modifier %s defined multiple times; "
"Using %s, ignoring %s\n",
xkb_atom_text(keymap->ctx, stmt->name),
- ModMaskText(keymap, use),
- ModMaskText(keymap, ignore));
+ ModMaskText(keymap->ctx, &keymap->mods, use),
+ ModMaskText(keymap->ctx, &keymap->mods, ignore));
mapping = use;
}