Currently xkb_mods has the following members:
- uint8_t real_mods - 8 X11 core mods
- xkb_mod_mask_t vmods - 16 virtual mods, zero-based index
- xkb_mod_mask_t mask - the computed effective *real* modifier mask,
basically a cache for the first two which is:
real_mods | real mods computed from vmods
Our API acts on masks which combine the real_mods and vmods into a
single value, which is:
8 first bits real mods | 16 next bits virtual mods
(XkbNumModifiers = 8, XkbNumVirtualMods = 16). This is also the format
which ResolveVModMask uses (which is where all the modifier masks really
"come from", e.g. "Shift+Lock+Level5" -> xkb_mod_mask_t).
What the code does now after getting the mask from ResolveVModMask, is
to break it into real part and virtual part and store them seperately,
and then join them back together when the effective mask is calculated.
This is all pretty useless work. We change xkb_mods to the following:
- xkb_mod_mask_t mods - usually what ResolveVModMask returns
- xkb_mod_mask_t mask - the computed mask cache
And try to consistently use the word "mods" for the original,
non-effective mods and mask for the effective mods (which can only
contain real mods for now, because things break otherwise).
The separation is also made clearer. The effective masks are computed by
UpdateModifiersFromCompat after all the sections have been compiled;
before this the mask field is never touched; after this (i.e. map.c and
state.c) the original mods field is never touched. This single execption
to this rule is keymap-dump.c: it needs to print out only the original
modifiers, not computed ones. This is also the reason why we actually
keep two fields instead keeping one and modifying it in place.
The next logical step is probably to turn the real mods into vmods
themselves, and get rid of the distinction entirely (in a compatible
way).
Signed-off-by: Ran Benita <ran234@gmail.com>
write_buf(buf, "\t\ttype \"%s\" {\n",
xkb_atom_text(keymap->ctx, type->name));
write_buf(buf, "\t\t\tmodifiers= %s;\n",
write_buf(buf, "\t\ttype \"%s\" {\n",
xkb_atom_text(keymap->ctx, type->name));
write_buf(buf, "\t\t\tmodifiers= %s;\n",
- VModMaskText(keymap, type->mods.real_mods,
- type->mods.vmods));
+ VModMaskText(keymap, type->mods.mods));
for (j = 0; j < type->num_entries; j++) {
const char *str;
for (j = 0; j < type->num_entries; j++) {
const char *str;
* Printing level 1 entries is redundant, it's the default,
* unless there's preserve info.
*/
* Printing level 1 entries is redundant, it's the default,
* unless there's preserve info.
*/
- if (entry->level == 0 && entry->preserve.mask == 0)
+ if (entry->level == 0 && entry->preserve.mods == 0)
- str = VModMaskText(keymap, entry->mods.real_mods,
- entry->mods.vmods);
+ str = VModMaskText(keymap, entry->mods.mods);
write_buf(buf, "\t\t\tmap[%s]= Level%d;\n",
str, entry->level + 1);
write_buf(buf, "\t\t\tmap[%s]= Level%d;\n",
str, entry->level + 1);
- if (!entry->preserve.real_mods && !entry->preserve.vmods)
+ if (entry->preserve.mods == 0)
continue;
write_buf(buf, "\t\t\tpreserve[%s]= ", str);
continue;
write_buf(buf, "\t\t\tpreserve[%s]= ", str);
- write_buf(buf, "%s;\n",
- VModMaskText(keymap, entry->preserve.real_mods,
- entry->preserve.vmods));
+ write_buf(buf, "%s;\n", VModMaskText(keymap, entry->preserve.mods));
}
if (type->level_names) {
}
if (type->level_names) {
get_indicator_state_text(led->which_mods));
}
write_buf(buf, "\t\t\tmodifiers= %s;\n",
get_indicator_state_text(led->which_mods));
}
write_buf(buf, "\t\t\tmodifiers= %s;\n",
- VModMaskText(keymap, led->mods.real_mods,
- led->mods.vmods));
+ VModMaskText(keymap, led->mods.mods));
if (action->mods.flags & XkbSA_UseModMapMods)
args = "modMapMods";
else
if (action->mods.flags & XkbSA_UseModMapMods)
args = "modMapMods";
else
- args = VModMaskText(keymap, action->mods.real_mods,
- action->mods.vmods);
+ args = VModMaskText(keymap, action->mods.mods.mods);
write_buf(buf, "%s%s(modifiers=%s%s%s)%s", prefix, type, args,
(action->any.type != XkbSA_LockGroup &&
(action->mods.flags & XkbSA_ClearLocks)) ?
write_buf(buf, "%s%s(modifiers=%s%s%s)%s", prefix, type, args,
(action->any.type != XkbSA_LockGroup &&
(action->mods.flags & XkbSA_ClearLocks)) ?
write_buf(buf, "\t\tinterpret %s+%s(%s) {\n",
keysym_name,
SIMatchText(interp->match),
write_buf(buf, "\t\tinterpret %s+%s(%s) {\n",
keysym_name,
SIMatchText(interp->match),
- VModMaskText(keymap, interp->mods, 0));
+ VModMaskText(keymap, interp->mods));
if (interp->virtual_mod != XkbNoModifier) {
write_buf(buf, "\t\t\tvirtualModifier= %s;\n",
if (interp->virtual_mod != XkbNoModifier) {
write_buf(buf, "\t\t\tvirtualModifier= %s;\n",
struct xkb_mods *gc;
gc = &keymap->groups[i];
struct xkb_mods *gc;
gc = &keymap->groups[i];
- if (gc->real_mods == 0 && gc->vmods == 0)
continue;
write_buf(buf, "\t\tgroup %d = %s;\n", i + 1,
continue;
write_buf(buf, "\t\tgroup %d = %s;\n", i + 1,
- VModMaskText(keymap, gc->real_mods, gc->vmods));
+ VModMaskText(keymap, gc->mods));
}
for (i = 0; i < XkbNumIndicators; i++) {
struct xkb_indicator_map *map = &keymap->indicators[i];
if (map->flags == 0 && map->which_groups == 0 &&
map->groups == 0 && map->which_mods == 0 &&
}
for (i = 0; i < XkbNumIndicators; i++) {
struct xkb_indicator_map *map = &keymap->indicators[i];
if (map->flags == 0 && map->which_groups == 0 &&
map->groups == 0 && map->which_mods == 0 &&
- map->mods.real_mods == 0 && map->mods.vmods == 0 &&
- map->ctrls == 0)
+ map->mods.mods == 0 && map->ctrls == 0)
continue;
write_indicator_map(keymap, buf, i);
}
continue;
write_indicator_map(keymap, buf, i);
}
}
if (key->vmodmap && (key->explicit & XkbExplicitVModMapMask)) {
}
if (key->vmodmap && (key->explicit & XkbExplicitVModMapMask)) {
+ /* XXX: vmodmap cmask? */
write_buf(buf, "\n\t\t\tvirtualMods= %s,",
write_buf(buf, "\n\t\t\tvirtualMods= %s,",
- VModMaskText(keymap, 0, key->vmodmap));
+ VModMaskText(keymap, key->vmodmap << XkbNumModifiers));
}
switch (key->out_of_range_group_action) {
}
switch (key->out_of_range_group_action) {
- filter->state->clear_mods = filter->action.mods.mask;
+ filter->state->clear_mods = filter->action.mods.mods.mask;
if (filter->action.mods.flags & XkbSA_ClearLocks)
if (filter->action.mods.flags & XkbSA_ClearLocks)
- filter->state->locked_mods &= ~filter->action.mods.mask;
+ filter->state->locked_mods &= ~filter->action.mods.mods.mask;
filter->func = xkb_filter_mod_set_func;
filter->action = *action;
filter->func = xkb_filter_mod_set_func;
filter->action = *action;
- filter->state->set_mods = action->mods.mask;
+ filter->state->set_mods = action->mods.mods.mask;
filter->kc = kc;
filter->func = xkb_filter_mod_lock_func;
filter->action = *action;
filter->kc = kc;
filter->func = xkb_filter_mod_lock_func;
filter->action = *action;
- filter->priv = state->locked_mods & action->mods.mask;
- state->locked_mods |= action->mods.mask;
+ filter->priv = state->locked_mods & action->mods.mods.mask;
+ state->locked_mods |= action->mods.mods.mask;
union xkb_action *action = xkb_key_get_action(filter->state, kc);
if (action->type == XkbSA_LatchMods &&
action->mods.flags == filter->action.mods.flags &&
union xkb_action *action = xkb_key_get_action(filter->state, kc);
if (action->type == XkbSA_LatchMods &&
action->mods.flags == filter->action.mods.flags &&
- action->mods.mask == filter->action.mods.mask) {
+ action->mods.mods.mask == filter->action.mods.mods.mask) {
filter->action = *action;
if (filter->action.mods.flags & XkbSA_LatchToLock) {
filter->action.type = XkbSA_LockMods;
filter->func = xkb_filter_mod_lock_func;
filter->action = *action;
if (filter->action.mods.flags & XkbSA_LatchToLock) {
filter->action.type = XkbSA_LockMods;
filter->func = xkb_filter_mod_lock_func;
- filter->state->locked_mods |= filter->action.mods.mask;
+ filter->state->locked_mods |= filter->action.mods.mods.mask;
}
else {
filter->action.type = XkbSA_SetMods;
filter->func = xkb_filter_mod_set_func;
}
else {
filter->action.type = XkbSA_SetMods;
filter->func = xkb_filter_mod_set_func;
- filter->state->set_mods = filter->action.mods.mask;
+ filter->state->set_mods = filter->action.mods.mods.mask;
- filter->state->latched_mods &= ~filter->action.mods.mask;
+ filter->state->latched_mods &= ~filter->action.mods.mods.mask;
/* XXX beep beep! */
return 0;
}
else if (((1 << action->type) & XkbSA_BreakLatch)) {
/* XXX: This may be totally broken, we might need to break the
* latch in the next run after this press? */
/* XXX beep beep! */
return 0;
}
else if (((1 << action->type) & XkbSA_BreakLatch)) {
/* XXX: This may be totally broken, we might need to break the
* latch in the next run after this press? */
- filter->state->latched_mods &= ~filter->action.mods.mask;
+ filter->state->latched_mods &= ~filter->action.mods.mods.mask;
filter->func = NULL;
return 1;
}
filter->func = NULL;
return 1;
}
* latched. */
if (latch == NO_LATCH ||
((filter->action.mods.flags & XkbSA_ClearLocks) &&
* latched. */
if (latch == NO_LATCH ||
((filter->action.mods.flags & XkbSA_ClearLocks) &&
- (filter->state->locked_mods & filter->action.mods.mask) ==
- filter->action.mods.mask)) {
+ (filter->state->locked_mods & filter->action.mods.mods.mask) ==
+ filter->action.mods.mods.mask)) {
/* XXX: We might be a bit overenthusiastic about clearing
* mods other filters have set here? */
if (latch == LATCH_PENDING)
/* XXX: We might be a bit overenthusiastic about clearing
* mods other filters have set here? */
if (latch == LATCH_PENDING)
- filter->state->latched_mods &= ~filter->action.mods.mask;
+ filter->state->latched_mods &= ~filter->action.mods.mods.mask;
- filter->state->clear_mods = filter->action.mods.mask;
- filter->state->locked_mods &= ~filter->action.mods.mask;
+ filter->state->clear_mods = filter->action.mods.mods.mask;
+ filter->state->locked_mods &= ~filter->action.mods.mods.mask;
filter->func = NULL;
}
else {
latch = LATCH_PENDING;
filter->func = NULL;
}
else {
latch = LATCH_PENDING;
- filter->state->clear_mods = filter->action.mods.mask;
- filter->state->latched_mods |= filter->action.mods.mask;
+ filter->state->clear_mods = filter->action.mods.mods.mask;
+ filter->state->latched_mods |= filter->action.mods.mods.mask;
filter->func = xkb_filter_mod_latch_func;
filter->action = *action;
filter->func = xkb_filter_mod_latch_func;
filter->action = *action;
- filter->state->set_mods = action->mods.mask;
+ filter->state->set_mods = action->mods.mods.mask;
+/*
+ * Get a vmod name's text, where the vmod index is zero based
+ * (0..XkbNumVirtualMods-1).
+ */
static const char *
VModIndexText(struct xkb_keymap *keymap, xkb_mod_index_t ndx)
{
static const char *
VModIndexText(struct xkb_keymap *keymap, xkb_mod_index_t ndx)
{
+/* Get a mod mask's text, where the mask is in rmods+vmods format. */
-VModMaskText(struct xkb_keymap *keymap, xkb_mod_mask_t modMask,
- xkb_mod_mask_t mask)
+VModMaskText(struct xkb_keymap *keymap, xkb_mod_mask_t cmask)
{
xkb_mod_index_t i;
xkb_mod_mask_t bit;
{
xkb_mod_index_t i;
xkb_mod_mask_t bit;
+ xkb_mod_mask_t rmask, vmask;
int len, rem;
const char *mm = NULL;
char *rtrn, *str;
char buf[BUFFER_SIZE];
int len, rem;
const char *mm = NULL;
char *rtrn, *str;
char buf[BUFFER_SIZE];
- if (modMask == 0 && mask == 0)
+ rmask = cmask & 0xff;
+ vmask = cmask >> XkbNumModifiers;
+
+ if (rmask == 0 && vmask == 0)
- if (modMask != 0)
- mm = ModMaskText(modMask, false);
+ if (rmask != 0)
+ mm = ModMaskText(rmask);
str = buf;
buf[0] = '\0';
rem = BUFFER_SIZE;
str = buf;
buf[0] = '\0';
rem = BUFFER_SIZE;
for (i = 0, bit = 1; i < XkbNumVirtualMods && rem > 1; i++, bit <<=
1) {
for (i = 0, bit = 1; i < XkbNumVirtualMods && rem > 1; i++, bit <<=
1) {
continue;
len = snprintf(str, rem, "%s%s",
continue;
len = snprintf(str, rem, "%s%s",
+/* Gets the text for the real modifiers only. */
-ModMaskText(xkb_mod_mask_t mask, bool cFormat)
+ModMaskText(xkb_mod_mask_t mask)
{
int i, rem;
xkb_mod_index_t bit;
char *str, *buf;
if ((mask & 0xff) == 0xff)
{
int i, rem;
xkb_mod_index_t bit;
char *str, *buf;
if ((mask & 0xff) == 0xff)
- return (cFormat ? "0xff" : "all");
- return (cFormat ? "0" : "none");
rem = 64;
buf = GetBuffer(rem);
rem = 64;
buf = GetBuffer(rem);
if (!(mask & bit))
continue;
if (!(mask & bit))
continue;
- len = snprintf(str, rem, "%s%s%s",
- (str != buf) ? (cFormat ? "|" : "+") : "",
- modNames[i],
- cFormat ? "Mask" : "");
+ len = snprintf(str, rem, "%s%s",
+ (str != buf ? "+" : ""), modNames[i]);
rem -= len;
str += len;
}
rem -= len;
str += len;
}
#include "xkb-priv.h"
const char *
#include "xkb-priv.h"
const char *
-VModMaskText(struct xkb_keymap *keymap, xkb_mod_mask_t modMask,
- xkb_mod_mask_t mask);
+VModMaskText(struct xkb_keymap *keymap, xkb_mod_mask_t cmask);
xkb_mod_index_t
ModNameToIndex(const char *name);
xkb_mod_index_t
ModNameToIndex(const char *name);
ModIndexText(xkb_mod_index_t ndx);
const char *
ModIndexText(xkb_mod_index_t ndx);
const char *
-ModMaskText(xkb_mod_mask_t mask, bool cFormat);
+ModMaskText(xkb_mod_mask_t mask);
const char *
FileTypeText(enum xkb_file_type type);
const char *
FileTypeText(enum xkb_file_type type);
+struct xkb_mods {
+ xkb_mod_mask_t mods; /* original real+virtual mods in definition */
+ xkb_mod_mask_t mask; /* computed effective mask */
+};
+
struct xkb_any_action {
uint8_t type;
uint8_t data[7];
struct xkb_any_action {
uint8_t type;
uint8_t data[7];
struct xkb_mod_action {
uint8_t type;
uint8_t flags;
struct xkb_mod_action {
uint8_t type;
uint8_t flags;
- uint8_t mask;
- uint8_t real_mods;
- uint16_t vmods;
};
struct xkb_group_action {
};
struct xkb_group_action {
struct xkb_iso_action {
uint8_t type;
uint8_t flags;
struct xkb_iso_action {
uint8_t type;
uint8_t flags;
- uint8_t mask;
- uint8_t real_mods;
int32_t group;
uint8_t affect;
int32_t group;
uint8_t affect;
};
struct xkb_controls_action {
};
struct xkb_controls_action {
-struct xkb_mods {
- xkb_mod_mask_t mask; /* effective mods */
- xkb_mod_mask_t vmods;
- uint8_t real_mods;
-};
-
struct xkb_kt_map_entry {
xkb_level_index_t level;
struct xkb_mods mods;
struct xkb_kt_map_entry {
xkb_level_index_t level;
struct xkb_mods mods;
t1 = act->flags;
if (CheckModifierField(keymap, action->type, value, &t1, &t2)) {
act->flags = t1;
t1 = act->flags;
if (CheckModifierField(keymap, action->type, value, &t1, &t2)) {
act->flags = t1;
- act->real_mods = act->mask = (t2 & 0xff);
- act->vmods = (t2 >> XkbNumModifiers) & 0xffff;
return true;
}
return false;
return true;
}
return false;
t1 = act->flags;
if (CheckModifierField(keymap, action->type, value, &t1, &t2)) {
act->flags = t1;
t1 = act->flags;
if (CheckModifierField(keymap, action->type, value, &t1, &t2)) {
act->flags = t1;
- act->real_mods = act->mask = (t2 & 0xff);
- act->vmods = (t2 >> XkbNumModifiers) & 0xffff;
return true;
}
return false;
return true;
}
return false;
return false;
act->flags = flags & (~XkbSA_ISODfltIsGroup);
return false;
act->flags = flags & (~XkbSA_ISODfltIsGroup);
- act->real_mods = mods & 0xff;
- act->vmods = (mods >> XkbNumModifiers) & 0xffff;
return true;
}
else if (field == F_Group) {
return true;
}
else if (field == F_Group) {
action->dflt.value = 1;
}
else if (action->type == XkbSA_ISOLock) {
action->dflt.value = 1;
}
else if (action->type == XkbSA_ISOLock) {
- action->iso.real_mods = ModNameToIndex(XKB_MOD_NAME_CAPS);
+ action->iso.mods.mods = (1 << ModNameToIndex(XKB_MOD_NAME_CAPS));
xkb_led_index_t indicator;
unsigned char flags;
unsigned char which_mods;
xkb_led_index_t indicator;
unsigned char flags;
unsigned char which_mods;
- unsigned char real_mods;
- xkb_mod_mask_t vmods;
unsigned char which_groups;
uint32_t groups;
unsigned int ctrls;
unsigned char which_groups;
uint32_t groups;
unsigned int ctrls;
unsigned file_id;
enum merge_mode merge;
bool defined;
unsigned file_id;
enum merge_mode merge;
bool defined;
- unsigned char real_mods;
- xkb_atom_t vmods;
} GroupCompatInfo;
typedef struct _CompatInfo {
} GroupCompatInfo;
typedef struct _CompatInfo {
snprintf(buf, sizeof(buf), "%s+%s(%s)",
KeysymText(si->interp.sym),
SIMatchText(si->interp.match),
snprintf(buf, sizeof(buf), "%s+%s(%s)",
KeysymText(si->interp.sym),
SIMatchText(si->interp.match),
- ModMaskText(si->interp.mods, false));
+ ModMaskText(si->interp.mods));
{
info->name = xkb_atom_intern(ctx, "default");
info->indicator = XKB_LED_INVALID;
{
info->name = xkb_atom_intern(ctx, "default");
info->indicator = XKB_LED_INVALID;
- info->flags = info->which_mods = info->real_mods = 0;
- info->vmods = 0;
+ info->flags = 0;
+ info->which_mods = 0;
+ info->mods = 0;
info->which_groups = info->groups = 0;
info->ctrls = 0;
}
info->which_groups = info->groups = 0;
info->ctrls = 0;
}
int verbosity = xkb_get_log_verbosity(info->keymap->ctx);
gc = &info->groupCompat[group];
int verbosity = xkb_get_log_verbosity(info->keymap->ctx);
gc = &info->groupCompat[group];
- if (gc->real_mods == new->real_mods && gc->vmods == new->vmods)
+ if (gc->mods == new->mods)
return true;
if ((gc->file_id == new->file_id && verbosity > 0) || verbosity > 9)
return true;
if ((gc->file_id == new->file_id && verbosity > 0) || verbosity > 9)
list_foreach(old, &info->leds, entry) {
if (old->name == new->name) {
list_foreach(old, &info->leds, entry) {
if (old->name == new->name) {
- if ((old->real_mods == new->real_mods) &&
- (old->vmods == new->vmods) &&
+ if ((old->mods == new->mods) &&
(old->groups == new->groups) &&
(old->ctrls == new->ctrls) &&
(old->which_mods == new->which_mods) &&
(old->groups == new->groups) &&
(old->ctrls == new->ctrls) &&
(old->which_mods == new->which_mods) &&
if (UseNewLEDField(LED_FIELD_MODS, old, new, verbosity,
&collide)) {
old->which_mods = new->which_mods;
if (UseNewLEDField(LED_FIELD_MODS, old, new, verbosity,
&collide)) {
old->which_mods = new->which_mods;
- old->real_mods = new->real_mods;
- old->vmods = new->vmods;
old->defined |= LED_FIELD_MODS;
}
if (UseNewLEDField(LED_FIELD_GROUPS, old, new, verbosity,
old->defined |= LED_FIELD_MODS;
}
if (UseNewLEDField(LED_FIELD_GROUPS, old, new, verbosity,
struct xkb_keymap *keymap = info->keymap;
if (istreq(field, "modifiers") || istreq(field, "mods")) {
struct xkb_keymap *keymap = info->keymap;
if (istreq(field, "modifiers") || istreq(field, "mods")) {
if (arrayNdx)
return ReportIndicatorNotArray(info, led, field);
if (arrayNdx)
return ReportIndicatorNotArray(info, led, field);
- if (!ExprResolveVModMask(keymap, value, &mask))
+ if (!ExprResolveVModMask(keymap, value, &led->mods))
return ReportIndicatorBadType(info, led, field, "modifier mask");
return ReportIndicatorBadType(info, led, field, "modifier mask");
- led->real_mods = mask & 0xff;
- led->vmods = (mask >> XkbNumModifiers) & 0xffff;
led->defined |= LED_FIELD_MODS;
}
else if (istreq(field, "groups")) {
led->defined |= LED_FIELD_MODS;
}
else if (istreq(field, "groups")) {
HandleGroupCompatDef(CompatInfo *info, GroupCompatDef *def,
enum merge_mode merge)
{
HandleGroupCompatDef(CompatInfo *info, GroupCompatDef *def,
enum merge_mode merge)
{
GroupCompatInfo tmp;
merge = (def->merge == MERGE_DEFAULT ? merge : def->merge);
GroupCompatInfo tmp;
merge = (def->merge == MERGE_DEFAULT ? merge : def->merge);
tmp.file_id = info->file_id;
tmp.merge = merge;
tmp.file_id = info->file_id;
tmp.merge = merge;
- if (!ExprResolveVModMask(info->keymap, def->def, &mask)) {
+ if (!ExprResolveVModMask(info->keymap, def->def, &tmp.mods)) {
log_err(info->keymap->ctx,
"Expected a modifier mask in group compatibility definition; "
"Ignoring illegal compatibility map for group %u\n",
log_err(info->keymap->ctx,
"Expected a modifier mask in group compatibility definition; "
"Ignoring illegal compatibility map for group %u\n",
- tmp.real_mods = mask & 0xff;
- tmp.vmods = (mask >> XkbNumModifiers) & 0xffff;
tmp.defined = true;
return AddGroupCompat(info, def->group - 1, &tmp);
}
tmp.defined = true;
return AddGroupCompat(info, def->group - 1, &tmp);
}
map->which_groups = led->which_groups;
map->groups = led->groups;
map->which_mods = led->which_mods;
map->which_groups = led->which_groups;
map->groups = led->groups;
map->which_mods = led->which_mods;
- map->mods.mask = led->real_mods;
- map->mods.real_mods = led->real_mods;
- map->mods.vmods = led->vmods;
+ map->mods.mods = led->mods;
map->ctrls = led->ctrls;
free(led);
}
map->ctrls = led->ctrls;
free(led);
}
if (led->groups != 0 && led->which_groups == 0)
led->which_groups = XkbIM_UseEffective;
if (led->groups != 0 && led->which_groups == 0)
led->which_groups = XkbIM_UseEffective;
- if (led->which_mods == 0 && (led->real_mods || led->vmods))
+ if (led->which_mods == 0 && led->mods)
led->which_mods = XkbIM_UseEffective;
if (led->indicator == XKB_LED_INVALID) {
led->which_mods = XkbIM_UseEffective;
if (led->indicator == XKB_LED_INVALID) {
im->which_groups = led->which_groups;
im->groups = led->groups;
im->which_mods = led->which_mods;
im->which_groups = led->which_groups;
im->groups = led->groups;
im->which_mods = led->which_mods;
- im->mods.mask = led->real_mods;
- im->mods.real_mods = led->real_mods;
- im->mods.vmods = led->vmods;
+ im->mods.mods = led->mods;
im->ctrls = led->ctrls;
keymap->indicator_names[led->indicator - 1] =
xkb_atom_text(keymap->ctx, led->name);
im->ctrls = led->ctrls;
keymap->indicator_names[led->indicator - 1] =
xkb_atom_text(keymap->ctx, led->name);
for (i = 0, gcm = &info.groupCompat[0]; i < XkbNumKbdGroups;
i++, gcm++) {
for (i = 0, gcm = &info.groupCompat[0]; i < XkbNumKbdGroups;
i++, gcm++) {
- if (gcm->file_id != 0 || gcm->real_mods != 0 || gcm->vmods != 0) {
- keymap->groups[i].mask = gcm->real_mods;
- keymap->groups[i].real_mods = gcm->real_mods;
- keymap->groups[i].vmods = gcm->vmods;
- }
+ if (gcm->file_id != 0 || gcm->mods != 0)
+ keymap->groups[i].mods = gcm->mods;
}
if (!CopyIndicatorMapDefs(&info))
}
if (!CopyIndicatorMapDefs(&info))
-xkb_mod_mask_t
-VModsToReal(struct xkb_keymap *keymap, xkb_mod_mask_t vmodmask)
+static void
+ComputeEffectiveMask(struct xkb_keymap *keymap, struct xkb_mods *mods)
- xkb_mod_mask_t ret = 0;
+ xkb_mod_mask_t vmask = mods->mods >> XkbNumModifiers;
- if (!vmodmask)
- return 0;
+ /* The effective mask is only real mods for now. */
+ mods->mask = mods->mods & 0xff;
for (i = 0; i < XkbNumVirtualMods; i++) {
for (i = 0; i < XkbNumVirtualMods; i++) {
- if (!(vmodmask & (1 << i)))
+ if (!(vmask & (1 << i)))
- ret |= keymap->vmods[i];
+ mods->mask |= keymap->vmods[i];
}
static void
UpdateActionMods(struct xkb_keymap *keymap, union xkb_action *act,
xkb_mod_mask_t rmodmask)
{
}
static void
UpdateActionMods(struct xkb_keymap *keymap, union xkb_action *act,
xkb_mod_mask_t rmodmask)
{
+ unsigned int flags;
+ struct xkb_mods *mods;
+
switch (act->type) {
case XkbSA_SetMods:
case XkbSA_LatchMods:
case XkbSA_LockMods:
switch (act->type) {
case XkbSA_SetMods:
case XkbSA_LatchMods:
case XkbSA_LockMods:
- if (act->mods.flags & XkbSA_UseModMapMods)
- act->mods.real_mods = rmodmask;
- act->mods.mask = act->mods.real_mods;
- act->mods.mask |= VModsToReal(keymap, act->mods.vmods);
+ flags = act->mods.flags;
+ mods = &act->mods.mods;
break;
case XkbSA_ISOLock:
break;
case XkbSA_ISOLock:
- if (act->iso.flags & XkbSA_UseModMapMods)
- act->iso.real_mods = rmodmask;
- act->iso.mask = act->iso.real_mods;
- act->iso.mask |= VModsToReal(keymap, act->iso.vmods);
+ flags = act->iso.flags;
+ mods = &act->iso.mods;
+
+ if (flags & XkbSA_UseModMapMods) {
+ /* XXX: what's that. */
+ mods->mods &= 0xff;
+ mods->mods |= rmodmask;
+ }
+ ComputeEffectiveMask(keymap, mods);
xkb_led_index_t led;
unsigned int i, j;
struct xkb_key *key;
xkb_led_index_t led;
unsigned int i, j;
struct xkb_key *key;
- struct xkb_key_type *type;
/* Find all the interprets for the key and bind them to actions,
* which will also update the vmodmap. */
/* 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->num_types; i++) {
/* Now update the level masks for all the types to reflect the vmods. */
for (i = 0; i < keymap->num_types; i++) {
- type = &keymap->types[i];
- type->mods.mask = type->mods.real_mods;
- type->mods.mask |= VModsToReal(keymap, type->mods.vmods);
-
- for (j = 0; j < type->num_entries; j++) {
- struct xkb_kt_map_entry *entry = &type->map[j];
-
- entry->mods.mask = entry->mods.real_mods;
- entry->mods.mask |= VModsToReal(keymap, entry->mods.vmods);
+ ComputeEffectiveMask(keymap, &keymap->types[i].mods);
- entry->preserve.mask = entry->preserve.real_mods;
- entry->preserve.mask |= VModsToReal(keymap, entry->preserve.vmods);
+ 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);
}
}
/* Update action modifiers. */
xkb_foreach_key(key, keymap) {
union xkb_action *acts = XkbKeyActionsPtr(keymap, key);
}
}
/* Update action modifiers. */
xkb_foreach_key(key, keymap) {
union xkb_action *acts = XkbKeyActionsPtr(keymap, key);
- for (i = 0; i < XkbKeyNumActions(key); i++) {
- if (acts[i].any.type == XkbSA_NoAction)
- continue;
+ for (i = 0; i < XkbKeyNumActions(key); i++)
UpdateActionMods(keymap, &acts[i], key->modmap);
UpdateActionMods(keymap, &acts[i], key->modmap);
}
/* Update group modifiers. */
}
/* Update group modifiers. */
- for (grp = 0; grp < XkbNumKbdGroups; grp++) {
- struct xkb_mods *group = &keymap->groups[grp];
- group->mask = group->real_mods | VModsToReal(keymap, group->vmods);
- }
+ for (grp = 0; grp < XkbNumKbdGroups; grp++)
+ ComputeEffectiveMask(keymap, &keymap->groups[grp]);
/* Update vmod -> indicator maps. */
/* Update vmod -> indicator maps. */
- for (led = 0; led < XkbNumIndicators; led++) {
- struct xkb_mods *mods = &keymap->indicators[led].mods;
- mods->mask = mods->real_mods | VModsToReal(keymap, mods->vmods);
- }
+ for (led = 0; led < XkbNumIndicators; led++)
+ ComputeEffectiveMask(keymap, &keymap->indicators[led].mods);
struct list entry;
xkb_atom_t name;
struct list entry;
xkb_atom_t name;
- xkb_mod_mask_t mask;
- xkb_mod_mask_t vmask;
xkb_level_index_t num_levels;
darray(struct xkb_kt_map_entry) entries;
darray(xkb_atom_t) level_names;
xkb_level_index_t num_levels;
darray(struct xkb_kt_map_entry) entries;
darray(xkb_atom_t) level_names;
static inline const char *
MapEntryTxt(KeyTypesInfo *info, struct xkb_kt_map_entry *entry)
{
static inline const char *
MapEntryTxt(KeyTypesInfo *info, struct xkb_kt_map_entry *entry)
{
- return VModMaskText(info->keymap, entry->mods.real_mods,
- entry->mods.vmods);
+ return VModMaskText(info->keymap, entry->mods.mods);
}
static inline const char *
}
static inline const char *
static inline const char *
TypeMaskTxt(KeyTypesInfo *info, KeyTypeInfo *type)
{
static inline const char *
TypeMaskTxt(KeyTypesInfo *info, KeyTypeInfo *type)
{
- return VModMaskText(info->keymap, type->mask, type->vmask);
+ return VModMaskText(info->keymap, type->mods);
SetModifiers(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
ExprDef *value)
{
SetModifiers(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
ExprDef *value)
{
- xkb_mod_mask_t mask, mods, vmods;
if (arrayNdx)
log_warn(info->keymap->ctx,
if (arrayNdx)
log_warn(info->keymap->ctx,
"Illegal array subscript ignored\n");
/* get modifier mask for current type */
"Illegal array subscript ignored\n");
/* get modifier mask for current type */
- if (!ExprResolveVModMask(info->keymap, value, &mask)) {
+ if (!ExprResolveVModMask(info->keymap, value, &mods)) {
log_err(info->keymap->ctx,
"Key type mask field must be a modifier mask; "
"Key type definition ignored\n");
return false;
}
log_err(info->keymap->ctx,
"Key type mask field must be a modifier mask; "
"Key type definition ignored\n");
return false;
}
- mods = mask & 0xff; /* core mods */
- vmods = (mask >> XkbNumModifiers) & 0xffff; /* xkb virtual mods */
-
if (type->defined & TYPE_FIELD_MASK) {
log_warn(info->keymap->ctx,
"Multiple modifier mask definitions for key type %s; "
"Using %s, ignoring %s\n",
xkb_atom_text(info->keymap->ctx, type->name),
TypeMaskTxt(info, type),
if (type->defined & TYPE_FIELD_MASK) {
log_warn(info->keymap->ctx,
"Multiple modifier mask definitions for key type %s; "
"Using %s, ignoring %s\n",
xkb_atom_text(info->keymap->ctx, type->name),
TypeMaskTxt(info, type),
- VModMaskText(info->keymap, mods, vmods));
+ VModMaskText(info->keymap, mods));
- type->mask = mods;
- type->vmask = vmods;
return true;
}
/***====================================================================***/
static struct xkb_kt_map_entry *
return true;
}
/***====================================================================***/
static struct xkb_kt_map_entry *
-FindMatchingMapEntry(KeyTypeInfo * type, unsigned mask, unsigned vmask)
+FindMatchingMapEntry(KeyTypeInfo *type, xkb_mod_mask_t mods)
{
struct xkb_kt_map_entry *entry;
darray_foreach(entry, type->entries)
{
struct xkb_kt_map_entry *entry;
darray_foreach(entry, type->entries)
- if (entry->mods.real_mods == mask && entry->mods.vmods == vmask)
+ if (entry->mods.mods == mods)
return entry;
return NULL;
return entry;
return NULL;
{
struct xkb_kt_map_entry * old;
{
struct xkb_kt_map_entry * old;
- old = FindMatchingMapEntry(type, new->mods.real_mods, new->mods.vmods);
+ old = FindMatchingMapEntry(type, new->mods.mods);
if (old) {
if (report && old->level != new->level) {
log_warn(info->keymap->ctx,
if (old) {
if (report && old->level != new->level) {
log_warn(info->keymap->ctx,
ExprDef *value)
{
struct xkb_kt_map_entry entry;
ExprDef *value)
{
struct xkb_kt_map_entry entry;
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "map entry");
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "map entry");
- if (!ExprResolveVModMask(info->keymap, arrayNdx, &mask))
+ if (!ExprResolveVModMask(info->keymap, arrayNdx, &entry.mods.mods))
return ReportTypeBadType(info, type, "map entry", "modifier mask");
return ReportTypeBadType(info, type, "map entry", "modifier mask");
- entry.mods.real_mods = mask & 0xff;
- entry.mods.vmods = (mask >> XkbNumModifiers) & 0xffff;
-
- if ((entry.mods.real_mods & (~type->mask)) ||
- (entry.mods.vmods & (~type->vmask))) {
+ if (entry.mods.mods & (~type->mods)) {
log_lvl(info->keymap->ctx, 1,
"Map entry for unused modifiers in %s; "
"Using %s instead of %s\n",
TypeTxt(info, type),
log_lvl(info->keymap->ctx, 1,
"Map entry for unused modifiers in %s; "
"Using %s instead of %s\n",
TypeTxt(info, type),
- VModMaskText(info->keymap,
- entry.mods.real_mods & type->mask,
- entry.mods.vmods & type->vmask),
+ VModMaskText(info->keymap, entry.mods.mods & type->mods),
MapEntryTxt(info, &entry));
MapEntryTxt(info, &entry));
- entry.mods.real_mods &= type->mask;
- entry.mods.vmods &= type->vmask;
+ entry.mods.mods &= type->mods;
}
if (!ExprResolveLevel(info->keymap->ctx, value, &entry.level)) {
}
if (!ExprResolveLevel(info->keymap->ctx, value, &entry.level)) {
- entry.preserve.real_mods = 0;
- entry.preserve.vmods = 0;
+ entry.preserve.mods = 0;
return AddMapEntry(info, type, &entry, true, true);
}
return AddMapEntry(info, type, &entry, true, true);
}
static bool
AddPreserve(KeyTypesInfo *info, KeyTypeInfo *type,
static bool
AddPreserve(KeyTypesInfo *info, KeyTypeInfo *type,
- xkb_mod_mask_t rmods, xkb_mod_mask_t vmods,
- xkb_mod_mask_t preserve_rmods, xkb_mod_mask_t preserve_vmods)
+ xkb_mod_mask_t mods, xkb_mod_mask_t preserve_mods)
{
struct xkb_kt_map_entry *entry;
{
struct xkb_kt_map_entry *entry;
- struct xkb_mods mods = {
- .real_mods = rmods,
- .vmods = vmods,
- };
- struct xkb_mods preserve = {
- .real_mods = preserve_rmods,
- .vmods = preserve_vmods,
- };
struct xkb_kt_map_entry new;
darray_foreach(entry, type->entries) {
struct xkb_kt_map_entry new;
darray_foreach(entry, type->entries) {
- if (entry->mods.real_mods != mods.real_mods ||
- entry->mods.vmods != mods.vmods)
+ if (entry->mods.mods != mods)
continue;
/* Map exists without previous preserve (or "None"); override. */
continue;
/* Map exists without previous preserve (or "None"); override. */
- if (entry->preserve.real_mods == 0 && entry->preserve.vmods == 0) {
- entry->preserve = preserve;
+ if (entry->preserve.mods == 0) {
+ entry->preserve.mods = preserve_mods;
return true;
}
/* Map exists with same preserve; do nothing. */
return true;
}
/* Map exists with same preserve; do nothing. */
- if (entry->preserve.real_mods == preserve.real_mods &&
- entry->preserve.vmods == preserve.vmods) {
+ if (entry->preserve.mods == preserve_mods) {
log_lvl(info->keymap->ctx, 10,
"Identical definitions for preserve[%s] in %s; "
"Ignored\n",
log_lvl(info->keymap->ctx, 10,
"Identical definitions for preserve[%s] in %s; "
"Ignored\n",
- VModMaskText(info->keymap, rmods, vmods),
+ VModMaskText(info->keymap, mods),
TypeTxt(info, type));
return true;
}
TypeTxt(info, type));
return true;
}
log_lvl(info->keymap->ctx, 1,
"Multiple definitions for preserve[%s] in %s; "
"Using %s, ignoring %s\n",
log_lvl(info->keymap->ctx, 1,
"Multiple definitions for preserve[%s] in %s; "
"Using %s, ignoring %s\n",
- VModMaskText(info->keymap, mods.real_mods, mods.vmods),
+ VModMaskText(info->keymap, mods),
- VModMaskText(info->keymap,
- preserve.real_mods,
- preserve.vmods),
- VModMaskText(info->keymap,
- entry->preserve.real_mods,
- entry->preserve.vmods));
-
- entry->preserve = preserve;
+ VModMaskText(info->keymap, preserve_mods),
+ VModMaskText(info->keymap, entry->preserve.mods));
+
+ entry->preserve.mods = preserve_mods;
* may be overriden later with an explicit map[] statement.
*/
new.level = 0;
* may be overriden later with an explicit map[] statement.
*/
new.level = 0;
- new.mods = mods;
- new.preserve = preserve;
+ new.mods.mods = mods;
+ new.preserve.mods = preserve_mods;
darray_append(type->entries, new);
return true;
}
darray_append(type->entries, new);
return true;
}
SetPreserve(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
ExprDef *value)
{
SetPreserve(KeyTypesInfo *info, KeyTypeInfo *type, ExprDef *arrayNdx,
ExprDef *value)
{
- xkb_mod_mask_t mask;
- xkb_mod_mask_t rmods, vmods, preserve_rmods, preserve_vmods;
+ xkb_mod_mask_t mods, preserve_mods;
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "preserve entry");
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(info, type, "preserve entry");
- if (!ExprResolveVModMask(info->keymap, arrayNdx, &mask))
+ if (!ExprResolveVModMask(info->keymap, arrayNdx, &mods))
return ReportTypeBadType(info, type, "preserve entry",
"modifier mask");
return ReportTypeBadType(info, type, "preserve entry",
"modifier mask");
- rmods = mask & 0xff;
- vmods = (mask >> XkbNumModifiers) & 0xffff;
-
- if ((rmods & (~type->mask)) || (vmods & (~type->vmask))) {
+ if (mods & ~type->mods) {
const char *before, *after;
const char *before, *after;
- before = VModMaskText(info->keymap, rmods, vmods);
- rmods &= type->mask;
- vmods &= type->vmask;
- after = VModMaskText(info->keymap, rmods, vmods);
+ before = VModMaskText(info->keymap, mods);
+ mods &= type->mods;
+ after = VModMaskText(info->keymap, mods);
log_lvl(info->keymap->ctx, 1,
"Preserve for modifiers not used by the %s type; "
log_lvl(info->keymap->ctx, 1,
"Preserve for modifiers not used by the %s type; "
TypeTxt(info, type), before, after);
}
TypeTxt(info, type), before, after);
}
- if (!ExprResolveVModMask(info->keymap, value, &mask)) {
+ if (!ExprResolveVModMask(info->keymap, value, &preserve_mods)) {
log_err(info->keymap->ctx,
"Preserve value in a key type is not a modifier mask; "
"Ignoring preserve[%s] in type %s\n",
log_err(info->keymap->ctx,
"Preserve value in a key type is not a modifier mask; "
"Ignoring preserve[%s] in type %s\n",
- VModMaskText(info->keymap, rmods, vmods),
+ VModMaskText(info->keymap, mods),
TypeTxt(info, type));
return false;
}
TypeTxt(info, type));
return false;
}
- preserve_rmods = mask & 0xff;
- preserve_vmods = (mask >> XkbNumModifiers) & 0xffff;
-
- if ((preserve_rmods & ~rmods) || (preserve_vmods & ~vmods)) {
+ if (preserve_mods & ~mods) {
const char *before, *after;
const char *before, *after;
- before = VModMaskText(info->keymap, preserve_rmods, preserve_vmods);
- preserve_rmods &= rmods;
- preserve_vmods &= vmods;
- after = VModMaskText(info->keymap, preserve_rmods, preserve_vmods);
+ before = VModMaskText(info->keymap, preserve_mods);
+ preserve_mods &= mods;
+ after = VModMaskText(info->keymap, preserve_mods);
log_lvl(info->keymap->ctx, 1,
"Illegal value for preserve[%s] in type %s; "
"Converted %s to %s\n",
log_lvl(info->keymap->ctx, 1,
"Illegal value for preserve[%s] in type %s; "
"Converted %s to %s\n",
- VModMaskText(info->keymap, rmods, vmods),
+ VModMaskText(info->keymap, mods),
TypeTxt(info, type), before, after);
}
TypeTxt(info, type), before, after);
}
- return AddPreserve(info, type, rmods, vmods,
- preserve_rmods, preserve_vmods);
+ return AddPreserve(info, type, mods, preserve_mods);
}
/***====================================================================***/
}
/***====================================================================***/
.file_id = info->file_id,
.merge = (def->merge == MERGE_DEFAULT ? merge : def->merge),
.name = def->name,
.file_id = info->file_id,
.merge = (def->merge == MERGE_DEFAULT ? merge : def->merge),
.name = def->name,
.num_levels = 1,
.entries = darray_new(),
.level_names = darray_new(),
.num_levels = 1,
.entries = darray_new(),
.level_names = darray_new(),
CopyDefToKeyType(KeyTypesInfo *info, KeyTypeInfo *def,
struct xkb_key_type *type)
{
CopyDefToKeyType(KeyTypesInfo *info, KeyTypeInfo *def,
struct xkb_key_type *type)
{
- type->mods.real_mods = def->mask;
- type->mods.vmods = def->vmask;
+ type->mods.mods = def->mods;
type->num_levels = def->num_levels;
type->map = darray_mem(def->entries, 0);
type->num_entries = darray_size(def->entries);
type->num_levels = def->num_levels;
type->map = darray_mem(def->entries, 0);
type->num_entries = darray_size(def->entries);
if (info.num_types == 0) {
KeyTypeInfo dflt = {
.name = xkb_atom_intern(keymap->ctx, "default"),
if (info.num_types == 0) {
KeyTypeInfo dflt = {
.name = xkb_atom_intern(keymap->ctx, "default"),
.num_levels = 1,
.entries = darray_new(),
.level_names = darray_new(),
.num_levels = 1,
.entries = darray_new(),
.level_names = darray_new(),
if (mask == keymap->vmods[i])
return true;
if (mask == keymap->vmods[i])
return true;
- str1 = ModMaskText(keymap->vmods[i], true);
+ str1 = ModMaskText(keymap->vmods[i]);
if (mergeMode == MERGE_OVERRIDE) {
str2 = str1;
if (mergeMode == MERGE_OVERRIDE) {
str2 = str1;
- str1 = ModMaskText(mask, true);
+ str1 = ModMaskText(mask);
extern bool
UpdateModifiersFromCompat(struct xkb_keymap *keymap);
extern bool
UpdateModifiersFromCompat(struct xkb_keymap *keymap);
-xkb_mod_mask_t
-VModsToReal(struct xkb_keymap *keymap, xkb_mod_mask_t vmodmask);
-
const char *
StmtTypeToString(enum stmt_type type);
const char *
StmtTypeToString(enum stmt_type type);