int num_vmods = 0;
int i;
- for (i = 0; i < XkbNumVirtualMods; i++) {
+ for (i = 0; i < XKB_NUM_VIRTUAL_MODS; i++) {
if (!keymap->vmod_names[i])
continue;
if (num_vmods == 0)
if (key->vmodmap && (key->explicit & XkbExplicitVModMapMask)) {
/* XXX: vmodmap cmask? */
write_buf(buf, "\n\t\t\tvirtualMods= %s,",
- VModMaskText(keymap, key->vmodmap << XkbNumModifiers));
+ VModMaskText(keymap, key->vmodmap << XKB_NUM_CORE_MODS));
}
switch (key->out_of_range_group_action) {
if (key->modmap == 0)
continue;
- for (mod = 0; mod < XkbNumModifiers; mod++) {
+ for (mod = 0; mod < XKB_NUM_CORE_MODS; mod++) {
if (!(key->modmap & (1 << mod)))
continue;
{
xkb_mod_index_t i;
- for (i = 0; i < XkbNumVirtualMods; i++)
+ for (i = 0; i < XKB_NUM_VIRTUAL_MODS; i++)
if (!keymap->vmod_names[i])
break;
/* We always have all the core modifiers (for now), plus any virtual
* modifiers we may have defined. */
- return i + XkbNumModifiers;
+ return i + XKB_NUM_CORE_MODS;
}
/**
name = ModIndexToName(idx);
if (!name)
name = xkb_atom_text(keymap->ctx,
- keymap->vmod_names[idx - XkbNumModifiers]);
+ keymap->vmod_names[idx - XKB_NUM_CORE_MODS]);
return name;
}
if (atom == XKB_ATOM_NONE)
return XKB_MOD_INVALID;
- for (i = 0; i < XkbNumVirtualMods; i++) {
+ for (i = 0; i < XKB_NUM_VIRTUAL_MODS; i++) {
if (keymap->vmod_names[i] == XKB_ATOM_NONE)
break;
if (keymap->vmod_names[i] == atom)
- return i + XkbNumModifiers;
+ return i + XKB_NUM_CORE_MODS;
}
return XKB_MOD_INVALID;
/*
* Get a vmod name's text, where the vmod index is zero based
- * (0..XkbNumVirtualMods-1).
+ * (0..XKB_NUM_VIRTUAL_MODS-1).
*/
static const char *
VModIndexText(struct xkb_keymap *keymap, xkb_mod_index_t ndx)
const char *tmp = NULL;
char buf[20];
- if (ndx >= XkbNumVirtualMods)
+ if (ndx >= XKB_NUM_VIRTUAL_MODS)
tmp = "illegal";
else
tmp = xkb_atom_text(keymap->ctx, keymap->vmod_names[ndx]);
char buf[BUFFER_SIZE];
rmask = cmask & 0xff;
- vmask = cmask >> XkbNumModifiers;
+ vmask = cmask >> XKB_NUM_CORE_MODS;
if (rmask == 0 && vmask == 0)
return "none";
rem = BUFFER_SIZE;
if (vmask != 0) {
- for (i = 0, bit = 1; i < XkbNumVirtualMods && rem > 1; i++, bit <<=
+ for (i = 0, bit = 1; i < XKB_NUM_VIRTUAL_MODS && rem > 1; i++, bit <<=
1) {
if (!(vmask & bit))
continue;
* ShiftMapIndex, LockMapIndex, etc. from X11/X.h. Take note before
* changing.
*/
-static const char *modNames[XkbNumModifiers] = {
+static const char *modNames[XKB_NUM_CORE_MODS] = {
"Shift",
"Lock",
"Control",
{
xkb_mod_index_t i;
- for (i = 0; i < XkbNumModifiers; i++)
+ for (i = 0; i < XKB_NUM_CORE_MODS; i++)
if (istreq(name, modNames[i]))
return i;
const char *
ModIndexToName(xkb_mod_index_t ndx)
{
- if (ndx < XkbNumModifiers)
+ if (ndx < XKB_NUM_CORE_MODS)
return modNames[ndx];
return NULL;
}
buf = GetBuffer(rem);
str = buf;
buf[0] = '\0';
- for (i = 0, bit = 1; i < XkbNumModifiers && rem > 1; i++, bit <<= 1) {
+ for (i = 0, bit = 1; i < XKB_NUM_CORE_MODS && rem > 1; i++, bit <<= 1) {
int len;
if (!(mask & bit))
/* These should all be dynamic. */
#define XKB_NUM_GROUPS 4
#define XKB_NUM_INDICATORS 32
+#define XKB_NUM_VIRTUAL_MODS 16
+#define XKB_NUM_CORE_MODS 8
struct xkb_context {
int refcnt;
darray(struct xkb_sym_interpret) sym_interpret;
/* vmod -> mod mapping */
- xkb_mod_mask_t vmods[XkbNumVirtualMods];
- xkb_atom_t vmod_names[XkbNumVirtualMods];
+ xkb_mod_mask_t vmods[XKB_NUM_VIRTUAL_MODS];
+ xkb_atom_t vmod_names[XKB_NUM_VIRTUAL_MODS];
/* Number of groups in the key with the most groups. */
xkb_group_index_t num_groups;
else
act->mods &= ~(t2 & 0xff);
- t2 = (t2 >> XkbNumModifiers) & 0xffff;
+ t2 = (t2 >> XKB_NUM_CORE_MODS) & 0xffff;
act->vmods_mask |= t2;
if (field == ACTION_FIELD_MODIFIERS)
act->vmods |= t2;
ComputeEffectiveMask(struct xkb_keymap *keymap, struct xkb_mods *mods)
{
xkb_mod_index_t i;
- xkb_mod_mask_t vmask = mods->mods >> XkbNumModifiers;
+ xkb_mod_mask_t vmask = mods->mods >> XKB_NUM_CORE_MODS;
/* The effective mask is only real mods for now. */
mods->mask = mods->mods & 0xff;
- for (i = 0; i < XkbNumVirtualMods; i++) {
+ for (i = 0; i < XKB_NUM_VIRTUAL_MODS; i++) {
if (!(vmask & (1 << i)))
continue;
mods->mask |= keymap->vmods[i];
return false;
/* Update keymap->vmods, the virtual -> real mod mapping. */
- for (vmod = 0; vmod < XkbNumVirtualMods; vmod++)
+ for (vmod = 0; vmod < XKB_NUM_VIRTUAL_MODS; vmod++)
keymap->vmods[vmod] = 0;
xkb_foreach_key(key, keymap) {
if (!key->vmodmap)
continue;
- for (vmod = 0; vmod < XkbNumVirtualMods; vmod++) {
+ for (vmod = 0; vmod < XKB_NUM_VIRTUAL_MODS; vmod++) {
if (!(key->vmodmap & (1 << vmod)))
continue;
keymap->vmods[vmod] |= key->modmap;
ok = ExprResolveVModMask(info->keymap, value, &mask);
if (ok) {
- keyi->vmodmap = (mask >> XkbNumModifiers) & 0xffff;
+ keyi->vmodmap = (mask >> XKB_NUM_CORE_MODS) & 0xffff;
keyi->defined |= KEY_FIELD_VMODMAP;
}
else {
info->defined = info->available = 0;
- for (i = 0; i < XkbNumVirtualMods; i++)
+ for (i = 0; i < XKB_NUM_VIRTUAL_MODS; i++)
if (keymap->vmod_names[i])
info->defined |= (1 << i);
}
"Value ignored\n");
nextFree = -1;
- for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
+ for (i = 0, bit = 1; i < XKB_NUM_VIRTUAL_MODS; i++, bit <<= 1) {
if (!(info->defined & bit)) {
if (nextFree < 0)
nextFree = i;
if (nextFree < 0) {
log_err(keymap->ctx,
"Too many virtual modifiers defined (maximum %d)\n",
- XkbNumVirtualMods);
+ XKB_NUM_VIRTUAL_MODS);
return false;
}
if (type != EXPR_TYPE_INT)
return false;
- for (i = 0; i < XkbNumVirtualMods; i++) {
+ for (i = 0; i < XKB_NUM_VIRTUAL_MODS; i++) {
if (keymap->vmod_names[i] == field) {
*val_rtrn = i;
return true;
return true;
}
else if (LookupVModIndex(priv, field, type, &ndx)) {
- *val_rtrn = (1 << (XkbNumModifiers + ndx));
+ *val_rtrn = (1 << (XKB_NUM_CORE_MODS + ndx));
return true;
}
return false;
}
- for (i = 0; i < XkbNumVirtualMods; i++) {
+ for (i = 0; i < XKB_NUM_VIRTUAL_MODS; i++) {
if ((info->available & (1 << i)) && keymap->vmod_names[i] == name) {
*ndx_rtrn = i;
return true;