To make it a bit more clear what it actually is.
Signed-off-by: Daniel Stone <daniel@fooishbar.org>
* Takes a new reference on a keymap.
*/
struct xkb_keymap *
-xkb_map_ref(struct xkb_keymap *xkb);
+xkb_map_ref(struct xkb_keymap *keymap);
/**
* Releases a reference on a keymap.
*/
void
-xkb_map_unref(struct xkb_keymap *xkb);
+xkb_map_unref(struct xkb_keymap *keymap);
/** @} */
* Returns the number of modifiers active in the keymap.
*/
xkb_mod_index_t
-xkb_map_num_mods(struct xkb_keymap *xkb);
+xkb_map_num_mods(struct xkb_keymap *keymap);
/**
* Returns the name of the modifier specified by 'idx', or NULL if invalid.
*/
const char *
-xkb_map_mod_get_name(struct xkb_keymap *xkb, xkb_mod_index_t idx);
+xkb_map_mod_get_name(struct xkb_keymap *keymap, xkb_mod_index_t idx);
/**
* Returns the index of the modifier specified by 'name', or XKB_MOD_INVALID.
*/
xkb_mod_index_t
-xkb_map_mod_get_index(struct xkb_keymap *xkb, const char *name);
+xkb_map_mod_get_index(struct xkb_keymap *keymap, const char *name);
/**
* Returns the number of groups active in the keymap.
*/
xkb_group_index_t
-xkb_map_num_groups(struct xkb_keymap *xkb);
+xkb_map_num_groups(struct xkb_keymap *keymap);
/**
* Returns the name of the group specified by 'idx', or NULL if invalid.
*/
const char *
-xkb_map_group_get_name(struct xkb_keymap *xkb, xkb_group_index_t idx);
+xkb_map_group_get_name(struct xkb_keymap *keymap, xkb_group_index_t idx);
/**
* Returns the index of the group specified by 'name', or XKB_GROUP_INVALID.
*/
xkb_group_index_t
-xkb_map_group_get_index(struct xkb_keymap *xkb, const char *name);
+xkb_map_group_get_index(struct xkb_keymap *keymap, const char *name);
/**
* Returns the number of groups active for the specified key.
*/
xkb_group_index_t
-xkb_key_num_groups(struct xkb_keymap *xkb, xkb_keycode_t key);
+xkb_key_num_groups(struct xkb_keymap *keymap, xkb_keycode_t key);
/**
* Returns the number of LEDs in the given map.
*/
xkb_led_index_t
-xkb_map_num_leds(struct xkb_keymap *xkb);
+xkb_map_num_leds(struct xkb_keymap *keymap);
/**
* Returns the name of the LED specified by 'idx', or NULL if invalid.
*/
const char *
-xkb_map_led_get_name(struct xkb_keymap *xkb, xkb_led_index_t idx);
+xkb_map_led_get_name(struct xkb_keymap *keymap, xkb_led_index_t idx);
/**
* Returns the index of the LED specified by 'name', or XKB_LED_INVALID.
*/
xkb_led_index_t
-xkb_map_led_get_index(struct xkb_keymap *xkb, const char *name);
+xkb_map_led_get_index(struct xkb_keymap *keymap, const char *name);
/** @} */
* failure.
*/
struct xkb_state *
-xkb_state_new(struct xkb_keymap *xkb);
+xkb_state_new(struct xkb_keymap *keymap);
/**
* Takes a new reference on a state object.
#include "alloc.h"
int
-XkbcAllocClientMap(struct xkb_keymap * xkb, unsigned which, unsigned nTotalTypes)
+XkbcAllocClientMap(struct xkb_keymap *keymap, unsigned which,
+ unsigned nTotalTypes)
{
struct xkb_client_map * map;
- if (!xkb || ((nTotalTypes > 0) && (nTotalTypes < XkbNumRequiredTypes)))
+ if (!keymap || ((nTotalTypes > 0) && (nTotalTypes < XkbNumRequiredTypes)))
return BadValue;
- if ((which & XkbKeySymsMask) && !xkb_keymap_keycode_range_is_legal(xkb)) {
+ if ((which & XkbKeySymsMask) &&
+ !xkb_keymap_keycode_range_is_legal(keymap)) {
#ifdef DEBUG
fprintf(stderr, "bad keycode (%d,%d) in XkbAllocClientMap\n",
- xkb->min_key_code, xkb->max_key_code);
+ keymap->min_key_code, keymap->max_key_code);
#endif
return BadValue;
}
- if (!xkb->map) {
+ if (!keymap->map) {
map = uTypedCalloc(1, struct xkb_client_map);
if (!map)
return BadAlloc;
- xkb->map = map;
+ keymap->map = map;
}
else
- map = xkb->map;
+ map = keymap->map;
if ((which & XkbKeyTypesMask) && (nTotalTypes > 0)) {
if (!map->types) {
if (which & XkbKeySymsMask) {
if (!map->key_sym_map) {
- map->key_sym_map = uTypedCalloc(xkb->max_key_code + 1,
+ map->key_sym_map = uTypedCalloc(keymap->max_key_code + 1,
struct xkb_sym_map);
if (!map->key_sym_map)
return BadAlloc;
if (which & XkbModifierMapMask) {
if (!map->modmap) {
- map->modmap = uTypedCalloc(xkb->max_key_code + 1, unsigned char);
+ map->modmap = uTypedCalloc(keymap->max_key_code + 1,
+ unsigned char);
if (!map->modmap)
return BadAlloc;
}
}
int
-XkbcAllocServerMap(struct xkb_keymap * xkb, unsigned which, unsigned nNewActions)
+XkbcAllocServerMap(struct xkb_keymap *keymap, unsigned which,
+ unsigned nNewActions)
{
unsigned i;
struct xkb_server_map * map;
- if (!xkb)
+ if (!keymap)
return BadMatch;
- if (!xkb->server) {
+ if (!keymap->server) {
map = uTypedCalloc(1, struct xkb_server_map);
if (!map)
return BadAlloc;
for (i = 0; i < XkbNumVirtualMods; i++)
map->vmods[i] = XkbNoModifierMask;
- xkb->server = map;
+ keymap->server = map;
}
else
- map = xkb->server;
+ map = keymap->server;
if (!which)
return Success;
- if (!xkb_keymap_keycode_range_is_legal(xkb))
+ if (!xkb_keymap_keycode_range_is_legal(keymap))
return BadMatch;
if (!map->explicit) {
- i = xkb->max_key_code + 1;
+ i = keymap->max_key_code + 1;
map->explicit = uTypedCalloc(i, unsigned char);
if (!map->explicit)
return BadAlloc;
}
if (!map->key_acts) {
- i = xkb->max_key_code + 1;
+ i = keymap->max_key_code + 1;
map->key_acts = uTypedCalloc(i, unsigned short);
if (!map->key_acts)
return BadAlloc;
}
if (!map->behaviors) {
- i = xkb->max_key_code + 1;
+ i = keymap->max_key_code + 1;
map->behaviors = uTypedCalloc(i, struct xkb_behavior);
if (!map->behaviors)
return BadAlloc;
}
if (!map->vmodmap) {
- i = xkb->max_key_code + 1;
+ i = keymap->max_key_code + 1;
map->vmodmap = uTypedCalloc(i, uint32_t);
if (!map->vmodmap)
return BadAlloc;
}
bool
-XkbcResizeKeySyms(struct xkb_keymap * xkb, xkb_keycode_t key,
+XkbcResizeKeySyms(struct xkb_keymap *keymap, xkb_keycode_t key,
unsigned int needed)
{
- if (xkb->map->key_sym_map[key].size_syms >= needed)
+ if (keymap->map->key_sym_map[key].size_syms >= needed)
return true;
- xkb->map->key_sym_map[key].syms =
- uTypedRecalloc(xkb->map->key_sym_map[key].syms,
- xkb->map->key_sym_map[key].size_syms,
+ keymap->map->key_sym_map[key].syms =
+ uTypedRecalloc(keymap->map->key_sym_map[key].syms,
+ keymap->map->key_sym_map[key].size_syms,
needed,
xkb_keysym_t);
- if (!xkb->map->key_sym_map[key].syms) {
- xkb->map->key_sym_map[key].size_syms = 0;
+ if (!keymap->map->key_sym_map[key].syms) {
+ keymap->map->key_sym_map[key].size_syms = 0;
return false;
}
- xkb->map->key_sym_map[key].size_syms = needed;
+ keymap->map->key_sym_map[key].size_syms = needed;
return true;
}
union xkb_action *
-XkbcResizeKeyActions(struct xkb_keymap * xkb, xkb_keycode_t key, uint32_t needed)
+XkbcResizeKeyActions(struct xkb_keymap *keymap, xkb_keycode_t key,
+ uint32_t needed)
{
xkb_keycode_t i, nActs;
union xkb_action *newActs;
if (needed == 0) {
- xkb->server->key_acts[key] = 0;
+ keymap->server->key_acts[key] = 0;
return NULL;
}
- if (XkbKeyHasActions(xkb, key) &&
- (XkbKeyGroupsWidth(xkb, key) >= needed))
- return XkbKeyActionsPtr(xkb, key);
+ if (XkbKeyHasActions(keymap, key) &&
+ (XkbKeyGroupsWidth(keymap, key) >= needed))
+ return XkbKeyActionsPtr(keymap, key);
- if (xkb->server->size_acts - xkb->server->num_acts >= (int)needed) {
- xkb->server->key_acts[key] = xkb->server->num_acts;
- xkb->server->num_acts += needed;
+ if (keymap->server->size_acts - keymap->server->num_acts >= (int)needed) {
+ keymap->server->key_acts[key] = keymap->server->num_acts;
+ keymap->server->num_acts += needed;
- return &xkb->server->acts[xkb->server->key_acts[key]];
+ return &keymap->server->acts[keymap->server->key_acts[key]];
}
- xkb->server->size_acts = xkb->server->num_acts + needed + 8;
- newActs = uTypedCalloc(xkb->server->size_acts, union xkb_action);
+ keymap->server->size_acts = keymap->server->num_acts + needed + 8;
+ newActs = uTypedCalloc(keymap->server->size_acts, union xkb_action);
if (!newActs)
return NULL;
newActs[0].type = XkbSA_NoAction;
nActs = 1;
- for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
+ for (i = keymap->min_key_code; i <= keymap->max_key_code; i++) {
xkb_keycode_t nKeyActs, nCopy;
- if ((xkb->server->key_acts[i] == 0) && (i != key))
+ if ((keymap->server->key_acts[i] == 0) && (i != key))
continue;
- nCopy = nKeyActs = XkbKeyNumActions(xkb, i);
+ nCopy = nKeyActs = XkbKeyNumActions(keymap, i);
if (i == key) {
nKeyActs= needed;
if (needed < nCopy)
}
if (nCopy > 0)
- memcpy(&newActs[nActs], XkbKeyActionsPtr(xkb, i),
+ memcpy(&newActs[nActs], XkbKeyActionsPtr(keymap, i),
nCopy * sizeof(union xkb_action));
if (nCopy < nKeyActs)
memset(&newActs[nActs + nCopy], 0,
(nKeyActs - nCopy) * sizeof(union xkb_action));
- xkb->server->key_acts[i] = nActs;
+ keymap->server->key_acts[i] = nActs;
nActs += nKeyActs;
}
- free(xkb->server->acts);
- xkb->server->acts = newActs;
- xkb->server->num_acts = nActs;
+ free(keymap->server->acts);
+ keymap->server->acts = newActs;
+ keymap->server->num_acts = nActs;
- return &xkb->server->acts[xkb->server->key_acts[key]];
+ return &keymap->server->acts[keymap->server->key_acts[key]];
}
void
-XkbcFreeClientMap(struct xkb_keymap * xkb)
+XkbcFreeClientMap(struct xkb_keymap *keymap)
{
struct xkb_client_map * map;
struct xkb_key_type * type;
xkb_keycode_t key;
int i;
- if (!xkb || !xkb->map)
+ if (!keymap || !keymap->map)
return;
- map = xkb->map;
+ map = keymap->map;
for (i = 0, type = map->types; i < map->num_types && type; i++, type++) {
int j;
free(map->types);
if (map->key_sym_map) {
- for (key = xkb->min_key_code; key < xkb->max_key_code; key++) {
+ for (key = keymap->min_key_code; key < keymap->max_key_code; key++) {
free(map->key_sym_map[key].sym_index);
free(map->key_sym_map[key].num_syms);
free(map->key_sym_map[key].syms);
free(map->key_sym_map);
free(map->modmap);
- free(xkb->map);
- xkb->map = NULL;
+ free(keymap->map);
+ keymap->map = NULL;
}
void
-XkbcFreeServerMap(struct xkb_keymap * xkb)
+XkbcFreeServerMap(struct xkb_keymap *keymap)
{
struct xkb_server_map * map;
- if (!xkb || !xkb->server)
+ if (keymap || keymap->server)
return;
- map = xkb->server;
+ map = keymap->server;
free(map->explicit);
free(map->key_acts);
free(map->acts);
free(map->behaviors);
free(map->vmodmap);
- free(xkb->server);
- xkb->server = NULL;
+ free(keymap->server);
+ keymap->server = NULL;
}
int
-XkbcAllocCompatMap(struct xkb_keymap *xkb, unsigned nSI)
+XkbcAllocCompatMap(struct xkb_keymap *keymap, unsigned nSI)
{
struct xkb_compat_map * compat;
struct xkb_sym_interpret *prev_interpret;
- if (!xkb)
+ if (!keymap)
return BadMatch;
- if (xkb->compat) {
- if (xkb->compat->size_si >= nSI)
+ if (keymap->compat) {
+ if (keymap->compat->size_si >= nSI)
return Success;
- compat = xkb->compat;
+ compat = keymap->compat;
compat->size_si = nSI;
if (!compat->sym_interpret)
compat->num_si = 0;
compat->size_si = nSI;
compat->num_si = 0;
memset(&compat->groups[0], 0, XkbNumKbdGroups * sizeof(struct xkb_mods));
- xkb->compat = compat;
+ keymap->compat = compat;
return Success;
}
static void
-XkbcFreeCompatMap(struct xkb_keymap * xkb)
+XkbcFreeCompatMap(struct xkb_keymap *keymap)
{
struct xkb_compat_map * compat;
- if (!xkb || !xkb->compat)
+ if (!keymap || !keymap->compat)
return;
- compat = xkb->compat;
+ compat = keymap->compat;
free(compat->sym_interpret);
free(compat);
- xkb->compat = NULL;
+ keymap->compat = NULL;
}
int
-XkbcAllocNames(struct xkb_keymap * xkb, unsigned which, unsigned nTotalAliases)
+XkbcAllocNames(struct xkb_keymap *keymap, unsigned which,
+ unsigned nTotalAliases)
{
struct xkb_names * names;
- if (!xkb)
+ if (!keymap)
return BadMatch;
- if (!xkb->names) {
- xkb->names = uTypedCalloc(1, struct xkb_names);
- if (!xkb->names)
+ if (!keymap->names) {
+ keymap->names = uTypedCalloc(1, struct xkb_names);
+ if (!keymap->names)
return BadAlloc;
}
- names = xkb->names;
+ names = keymap->names;
- if ((which & XkbKTLevelNamesMask) && xkb->map && xkb->map->types) {
+ if ((which & XkbKTLevelNamesMask) && keymap->map && keymap->map->types) {
int i;
struct xkb_key_type * type;
- type = xkb->map->types;
- for (i = 0; i < xkb->map->num_types; i++, type++) {
+ type = keymap->map->types;
+ for (i = 0; i < keymap->map->num_types; i++, type++) {
if (!type->level_names) {
type->level_names = uTypedCalloc(type->num_levels, const char *);
if (!type->level_names)
}
if ((which & XkbKeyNamesMask) && !names->keys) {
- if (!xkb_keymap_keycode_range_is_legal(xkb))
+ if (!xkb_keymap_keycode_range_is_legal(keymap))
return BadMatch;
- names->keys = uTypedCalloc(xkb->max_key_code + 1, struct xkb_key_name);
+ names->keys = uTypedCalloc(keymap->max_key_code + 1,
+ struct xkb_key_name);
if (!names->keys)
return BadAlloc;
}
}
static void
-XkbcFreeNames(struct xkb_keymap * xkb)
+XkbcFreeNames(struct xkb_keymap *keymap)
{
struct xkb_names * names;
struct xkb_client_map * map;
int i;
- if (!xkb || !xkb->names)
+ if (!keymap || !keymap->names)
return;
- names = xkb->names;
- map = xkb->map;
+ names = keymap->names;
+ map = keymap->map;
if (map && map->types) {
struct xkb_key_type * type = map->types;
free(names->keys);
free(names->key_aliases);
free(names);
- xkb->names = NULL;
+ keymap->names = NULL;
}
int
-XkbcAllocControls(struct xkb_keymap * xkb)
+XkbcAllocControls(struct xkb_keymap *keymap)
{
- if (!xkb)
+ if (!keymap)
return BadMatch;
- if (!xkb->ctrls) {
- xkb->ctrls = uTypedCalloc(1, struct xkb_controls);
- if (!xkb->ctrls)
+ if (!keymap->ctrls) {
+ keymap->ctrls = uTypedCalloc(1, struct xkb_controls);
+ if (!keymap->ctrls)
return BadAlloc;
}
- xkb->ctrls->per_key_repeat = uTypedCalloc(xkb->max_key_code << 3,
- unsigned char);
- if (!xkb->ctrls->per_key_repeat)
+ keymap->ctrls->per_key_repeat = uTypedCalloc(keymap->max_key_code >> 3,
+ unsigned char);
+ if (!keymap->ctrls->per_key_repeat)
return BadAlloc;
return Success;
}
static void
-XkbcFreeControls(struct xkb_keymap * xkb)
+XkbcFreeControls(struct xkb_keymap *keymap)
{
- if (xkb && xkb->ctrls) {
- free(xkb->ctrls->per_key_repeat);
- free(xkb->ctrls);
- xkb->ctrls = NULL;
+ if (keymap && keymap->ctrls) {
+ free(keymap->ctrls->per_key_repeat);
+ free(keymap->ctrls);
+ keymap->ctrls = NULL;
}
}
int
-XkbcAllocIndicatorMaps(struct xkb_keymap * xkb)
+XkbcAllocIndicatorMaps(struct xkb_keymap *keymap)
{
- if (!xkb)
+ if (!keymap)
return BadMatch;
- if (!xkb->indicators) {
- xkb->indicators = uTypedCalloc(1, struct xkb_indicator);
- if (!xkb->indicators)
+ if (!keymap->indicators) {
+ keymap->indicators = uTypedCalloc(1, struct xkb_indicator);
+ if (!keymap->indicators)
return BadAlloc;
}
}
static void
-XkbcFreeIndicatorMaps(struct xkb_keymap * xkb)
+XkbcFreeIndicatorMaps(struct xkb_keymap *keymap)
{
- if (xkb) {
- free(xkb->indicators);
- xkb->indicators = NULL;
+ if (keymap) {
+ free(keymap->indicators);
+ keymap->indicators = NULL;
}
}
struct xkb_keymap *
XkbcAllocKeyboard(struct xkb_context *context)
{
- struct xkb_keymap *xkb;
+ struct xkb_keymap *keymap;
- xkb = uTypedCalloc(1, struct xkb_keymap);
- if (!xkb)
+ keymap = uTypedCalloc(1, struct xkb_keymap);
+ if (!keymap)
return NULL;
- xkb->refcnt = 1;
- xkb->context = xkb_context_ref(context);
+ keymap->refcnt = 1;
+ keymap->context = xkb_context_ref(context);
- return xkb;
+ return keymap;
}
void
-XkbcFreeKeyboard(struct xkb_keymap * xkb)
+XkbcFreeKeyboard(struct xkb_keymap *keymap)
{
- if (!xkb)
+ if (!keymap)
return;
- XkbcFreeClientMap(xkb);
- XkbcFreeServerMap(xkb);
- XkbcFreeCompatMap(xkb);
- XkbcFreeIndicatorMaps(xkb);
- XkbcFreeNames(xkb);
- XkbcFreeControls(xkb);
- xkb_context_unref(xkb->context);
- free(xkb);
+ XkbcFreeClientMap(keymap);
+ XkbcFreeServerMap(keymap);
+ XkbcFreeCompatMap(keymap);
+ XkbcFreeIndicatorMaps(keymap);
+ XkbcFreeNames(keymap);
+ XkbcFreeControls(keymap);
+ xkb_context_unref(keymap->context);
+ free(keymap);
}
#include "xkb-priv.h"
extern int
-XkbcAllocCompatMap(struct xkb_keymap *xkb, unsigned nSI);
+XkbcAllocCompatMap(struct xkb_keymap *keymap, unsigned nSI);
extern int
-XkbcAllocNames(struct xkb_keymap * xkb, unsigned which, unsigned nTotalAliases);
+XkbcAllocNames(struct xkb_keymap *keymap, unsigned which,
+ unsigned nTotalAliases);
extern int
-XkbcAllocControls(struct xkb_keymap *xkb);
+XkbcAllocControls(struct xkb_keymap *keymap);
extern int
-XkbcAllocIndicatorMaps(struct xkb_keymap * xkb);
+XkbcAllocIndicatorMaps(struct xkb_keymap *keymap);
extern struct xkb_keymap *
XkbcAllocKeyboard(struct xkb_context *context);
extern void
-XkbcFreeKeyboard(struct xkb_keymap * xkb);
+XkbcFreeKeyboard(struct xkb_keymap *keymap);
extern int
-XkbcAllocClientMap(struct xkb_keymap * xkb, unsigned which, unsigned nTotalTypes);
+XkbcAllocClientMap(struct xkb_keymap *keymap, unsigned which,
+ unsigned nTotalTypes);
extern int
-XkbcAllocServerMap(struct xkb_keymap * xkb, unsigned which, unsigned nNewActions);
+XkbcAllocServerMap(struct xkb_keymap *keymap, unsigned which,
+ unsigned nNewActions);
extern int
-XkbcCopyKeyType(struct xkb_key_type * from, struct xkb_key_type *into);
+XkbcCopyKeyType(struct xkb_key_type *from, struct xkb_key_type *into);
extern bool
-XkbcResizeKeySyms(struct xkb_keymap * xkb, xkb_keycode_t key, uint32_t needed);
+XkbcResizeKeySyms(struct xkb_keymap *keymap, xkb_keycode_t key,
+ uint32_t needed);
extern union xkb_action *
-XkbcResizeKeyActions(struct xkb_keymap * xkb, xkb_keycode_t key, uint32_t needed);
+XkbcResizeKeyActions(struct xkb_keymap *keymap, xkb_keycode_t key,
+ uint32_t needed);
extern void
-XkbcFreeClientMap(struct xkb_keymap * xkb);
+XkbcFreeClientMap(struct xkb_keymap *keymap);
extern void
-XkbcFreeServerMap(struct xkb_keymap * xkb);
+XkbcFreeServerMap(struct xkb_keymap *keymap);
#endif /* ALLOC_H */
* Returns the total number of modifiers active in the keymap.
*/
_X_EXPORT xkb_mod_index_t
-xkb_map_num_mods(struct xkb_keymap *xkb)
+xkb_map_num_mods(struct xkb_keymap *keymap)
{
xkb_mod_index_t i;
for (i = 0; i < XkbNumVirtualMods; i++)
- if (!xkb->names->vmods[i])
+ if (!keymap->names->vmods[i])
break;
/* We always have all the core modifiers (for now), plus any virtual
* Return the name for a given modifier.
*/
_X_EXPORT const char *
-xkb_map_mod_get_name(struct xkb_keymap *xkb, xkb_mod_index_t idx)
+xkb_map_mod_get_name(struct xkb_keymap *keymap, xkb_mod_index_t idx)
{
- if (idx >= xkb_map_num_mods(xkb))
+ if (idx >= xkb_map_num_mods(keymap))
return NULL;
/* First try to find a legacy modifier name. */
}
/* If that fails, try to find a virtual mod name. */
- return xkb->names->vmods[idx - Mod5MapIndex];
+ return keymap->names->vmods[idx - Mod5MapIndex];
}
/**
* Returns the index for a named modifier.
*/
_X_EXPORT xkb_mod_index_t
-xkb_map_mod_get_index(struct xkb_keymap *xkb, const char *name)
+xkb_map_mod_get_index(struct xkb_keymap *keymap, const char *name)
{
xkb_mod_index_t i;
if (strcasecmp(name, "Mod5") == 0)
return Mod5MapIndex;
- for (i = 0; i < XkbNumVirtualMods && xkb->names->vmods[i]; i++) {
- if (strcasecmp(name, xkb->names->vmods[i]) == 0)
+ for (i = 0; i < XkbNumVirtualMods && keymap->names->vmods[i]; i++) {
+ if (strcasecmp(name, keymap->names->vmods[i]) == 0)
return i + Mod5MapIndex;
}
* Return the total number of active groups in the keymap.
*/
_X_EXPORT xkb_group_index_t
-xkb_map_num_groups(struct xkb_keymap *xkb)
+xkb_map_num_groups(struct xkb_keymap *keymap)
{
xkb_group_index_t ret = 0;
xkb_group_index_t i;
for (i = 0; i < XkbNumKbdGroups; i++)
- if (xkb->compat->groups[i].mask)
+ if (keymap->compat->groups[i].mask)
ret++;
return ret;
* Returns the name for a given group.
*/
_X_EXPORT const char *
-xkb_map_group_get_name(struct xkb_keymap *xkb, xkb_group_index_t idx)
+xkb_map_group_get_name(struct xkb_keymap *keymap, xkb_group_index_t idx)
{
- if (idx >= xkb_map_num_groups(xkb))
+ if (idx >= xkb_map_num_groups(keymap))
return NULL;
- return xkb->names->groups[idx];
+ return keymap->names->groups[idx];
}
/**
* Returns the index for a named group.
*/
_X_EXPORT xkb_group_index_t
-xkb_map_group_get_index(struct xkb_keymap *xkb, const char *name)
+xkb_map_group_get_index(struct xkb_keymap *keymap, const char *name)
{
- xkb_group_index_t num_groups = xkb_map_num_groups(xkb);
+ xkb_group_index_t num_groups = xkb_map_num_groups(keymap);
xkb_group_index_t i;
for (i = 0; i < num_groups; i++) {
- if (strcasecmp(xkb->names->groups[i], name) == 0)
+ if (strcasecmp(keymap->names->groups[i], name) == 0)
return i;
}
* Returns the number of groups active for a particular key.
*/
_X_EXPORT xkb_group_index_t
-xkb_key_num_groups(struct xkb_keymap *xkb, xkb_keycode_t key)
+xkb_key_num_groups(struct xkb_keymap *keymap, xkb_keycode_t key)
{
- return XkbKeyNumGroups(xkb, key);
+ return XkbKeyNumGroups(keymap, key);
}
/**
* Return the total number of active LEDs in the keymap.
*/
_X_EXPORT xkb_led_index_t
-xkb_map_num_leds(struct xkb_keymap *xkb)
+xkb_map_num_leds(struct xkb_keymap *keymap)
{
xkb_led_index_t ret = 0;
xkb_led_index_t i;
for (i = 0; i < XkbNumIndicators; i++)
- if (xkb->indicators->maps[i].which_groups ||
- xkb->indicators->maps[i].which_mods ||
- xkb->indicators->maps[i].ctrls)
+ if (keymap->indicators->maps[i].which_groups ||
+ keymap->indicators->maps[i].which_mods ||
+ keymap->indicators->maps[i].ctrls)
ret++;
return ret;
* Returns the name for a given group.
*/
_X_EXPORT const char *
-xkb_map_led_get_name(struct xkb_keymap *xkb, xkb_led_index_t idx)
+xkb_map_led_get_name(struct xkb_keymap *keymap, xkb_led_index_t idx)
{
- if (idx >= xkb_map_num_leds(xkb))
+ if (idx >= xkb_map_num_leds(keymap))
return NULL;
- return xkb->names->indicators[idx];
+ return keymap->names->indicators[idx];
}
/**
* Returns the index for a named group.
*/
_X_EXPORT xkb_group_index_t
-xkb_map_led_get_index(struct xkb_keymap *xkb, const char *name)
+xkb_map_led_get_index(struct xkb_keymap *keymap, const char *name)
{
- xkb_led_index_t num_leds = xkb_map_num_leds(xkb);
+ xkb_led_index_t num_leds = xkb_map_num_leds(keymap);
xkb_led_index_t i;
for (i = 0; i < num_leds; i++) {
- if (strcasecmp(xkb->names->indicators[i], name) == 0)
+ if (strcasecmp(keymap->names->indicators[i], name) == 0)
return i;
}
xkb_key_get_level(struct xkb_state *state, xkb_keycode_t key,
unsigned int group)
{
- struct xkb_key_type *type = XkbKeyType(state->xkb, key, group);
+ struct xkb_keymap *keymap = state->keymap;
+ struct xkb_key_type *type = XkbKeyType(keymap, key, group);
unsigned int active_mods = state->mods & type->mods.mask;
int i;
_X_EXPORT unsigned int
xkb_key_get_group(struct xkb_state *state, xkb_keycode_t key)
{
- unsigned int info = XkbKeyGroupInfo(state->xkb, key);
- unsigned int num_groups = XkbKeyNumGroups(state->xkb, key);
+ struct xkb_keymap *keymap = state->keymap;
+ unsigned int info = XkbKeyGroupInfo(keymap, key);
+ unsigned int num_groups = XkbKeyNumGroups(keymap, key);
unsigned int ret = state->group;
- if (ret < XkbKeyNumGroups(state->xkb, key))
+ if (ret < XkbKeyNumGroups(keymap, key))
return ret;
switch (XkbOutOfRangeGroupAction(info)) {
* As below, but takes an explicit group/level rather than state.
*/
unsigned int
-xkb_key_get_syms_by_level(struct xkb_keymap *xkb, xkb_keycode_t key, unsigned int group,
- unsigned int level, const xkb_keysym_t **syms_out)
+xkb_key_get_syms_by_level(struct xkb_keymap *keymap, xkb_keycode_t key,
+ unsigned int group, unsigned int level,
+ const xkb_keysym_t **syms_out)
{
int num_syms;
- if (group >= XkbKeyNumGroups(xkb, key))
+ if (group >= XkbKeyNumGroups(keymap, key))
goto err;
- if (level >= XkbKeyGroupWidth(xkb, key, group))
+ if (level >= XkbKeyGroupWidth(keymap, key, group))
goto err;
- num_syms = XkbKeyNumSyms(xkb, key, group, level);
+ num_syms = XkbKeyNumSyms(keymap, key, group, level);
if (num_syms == 0)
goto err;
- *syms_out = XkbKeySymEntry(xkb, key, group, level);
+ *syms_out = XkbKeySymEntry(keymap, key, group, level);
return num_syms;
err:
xkb_key_get_syms(struct xkb_state *state, xkb_keycode_t key,
const xkb_keysym_t **syms_out)
{
- struct xkb_keymap *xkb = state->xkb;
+ struct xkb_keymap *keymap = state->keymap;
int group;
int level;
- if (!state || key < xkb->min_key_code || key > xkb->max_key_code)
+ if (!state || key < keymap->min_key_code || key > keymap->max_key_code)
return -1;
group = xkb_key_get_group(state, key);
if (level == -1)
goto err;
- return xkb_key_get_syms_by_level(xkb, key, group, level, syms_out);
+ return xkb_key_get_syms_by_level(keymap, key, group, level, syms_out);
err:
*syms_out = NULL;
};
int
-XkbcInitCanonicalKeyTypes(struct xkb_keymap * xkb, unsigned which, int keypadVMod)
+XkbcInitCanonicalKeyTypes(struct xkb_keymap *keymap, unsigned which,
+ int keypadVMod)
{
struct xkb_client_map * map;
struct xkb_key_type *from, *to;
int rtrn;
- if (!xkb)
+ if (!keymap)
return BadMatch;
- rtrn= XkbcAllocClientMap(xkb, XkbKeyTypesMask, XkbNumRequiredTypes);
+ rtrn = XkbcAllocClientMap(keymap, XkbKeyTypesMask, XkbNumRequiredTypes);
if (rtrn != Success)
return rtrn;
- map= xkb->map;
+ map = keymap->map;
if ((which & XkbAllRequiredTypes) == 0)
return Success;
{
int group, level;
- if (!XkbKeyHasActions(state->xkb, key) ||
- !XkbKeycodeInRange(state->xkb, key)) {
+ if (!XkbKeyHasActions(state->keymap, key) ||
+ !XkbKeycodeInRange(state->keymap, key)) {
static union xkb_action fake;
memset(&fake, 0, sizeof(fake));
fake.type = XkbSA_NoAction;
group = xkb_key_get_group(state, key);
level = xkb_key_get_level(state, key, group);
- return XkbKeyActionEntry(state->xkb, key, level, group);
+ return XkbKeyActionEntry(state->keymap, key, level, group);
}
static struct xkb_filter *
}
_X_EXPORT struct xkb_state *
-xkb_state_new(struct xkb_keymap *xkb)
+xkb_state_new(struct xkb_keymap *keymap)
{
struct xkb_state *ret;
- if (!xkb)
+ if (!keymap)
return NULL;
ret = calloc(sizeof(*ret), 1);
return NULL;
ret->refcnt = 1;
- ret->xkb = xkb_map_ref(xkb);
+ ret->keymap = xkb_map_ref(keymap);
return ret;
}
if (state->refcnt > 0)
return;
- xkb_map_unref(state->xkb);
+ xkb_map_unref(state->keymap);
free(state->filters);
free(state);
}
_X_EXPORT struct xkb_keymap *
xkb_state_get_map(struct xkb_state *state)
{
- return state->xkb;
+ return state->keymap;
}
/**
state->leds = 0;
for (led = 0; led < XkbNumIndicators; led++) {
- struct xkb_indicator_map *map = &state->xkb->indicators->maps[led];
+ struct xkb_indicator_map *map = &state->keymap->indicators->maps[led];
uint32_t mod_mask = 0;
uint32_t group_mask = 0;
state->leds |= (1 << led);
}
else if (map->ctrls) {
- if ((map->ctrls & state->xkb->ctrls->enabled_ctrls))
+ if ((map->ctrls & state->keymap->ctrls->enabled_ctrls))
state->leds |= (1 << led);
}
}
state->base_mods = 0;
state->latched_mods = 0;
state->locked_mods = 0;
- for (mod = 0; mod < xkb_map_num_mods(state->xkb); mod++) {
+ for (mod = 0; mod < xkb_map_num_mods(state->keymap); mod++) {
xkb_mod_mask_t idx = (1 << mod);
if (base_mods & idx)
state->base_mods |= idx;
{
int ret = 0;
- if (idx >= xkb_map_num_mods(state->xkb))
+ if (idx >= xkb_map_num_mods(state->keymap))
return -1;
if (type & XKB_STATE_DEPRESSED)
va_start(ap, match);
while (1) {
idx = va_arg(ap, xkb_mod_index_t);
- if (idx == XKB_MOD_INVALID || idx >= xkb_map_num_mods(state->xkb)) {
+ if (idx == XKB_MOD_INVALID ||
+ idx >= xkb_map_num_mods(state->keymap)) {
ret = -1;
break;
}
xkb_state_mod_name_is_active(struct xkb_state *state, const char *name,
enum xkb_state_component type)
{
- xkb_mod_index_t idx = xkb_map_mod_get_index(state->xkb, name);
+ xkb_mod_index_t idx = xkb_map_mod_get_index(state->keymap, name);
if (idx == XKB_MOD_INVALID)
return -1;
str = va_arg(ap, const char *);
if (str == NULL)
break;
- idx = xkb_map_mod_get_index(state->xkb, str);
+ idx = xkb_map_mod_get_index(state->keymap, str);
if (idx == XKB_MOD_INVALID) {
ret = -1;
break;
{
int ret = 0;
- if (idx >= xkb_map_num_groups(state->xkb))
+ if (idx >= xkb_map_num_groups(state->keymap))
return -1;
if (type & XKB_STATE_DEPRESSED)
xkb_state_group_name_is_active(struct xkb_state *state, const char *name,
enum xkb_state_component type)
{
- xkb_group_index_t idx = xkb_map_group_get_index(state->xkb, name);
+ xkb_group_index_t idx = xkb_map_group_get_index(state->keymap, name);
if (idx == XKB_GROUP_INVALID)
return -1;
_X_EXPORT int
xkb_state_led_index_is_active(struct xkb_state *state, xkb_led_index_t idx)
{
- if (idx >= xkb_map_num_leds(state->xkb))
+ if (idx >= xkb_map_num_leds(state->keymap))
return -1;
return !!(state->leds & (1 << idx));
_X_EXPORT int
xkb_state_led_name_is_active(struct xkb_state *state, const char *name)
{
- xkb_led_index_t idx = xkb_map_led_get_index(state->xkb, name);
+ xkb_led_index_t idx = xkb_map_led_get_index(state->keymap, name);
if (idx == XKB_LED_INVALID)
return -1;
}
static const char *
-XkbcVModIndexText(struct xkb_keymap * xkb, unsigned ndx)
+XkbcVModIndexText(struct xkb_keymap *keymap, unsigned ndx)
{
int len;
char *rtrn;
if (ndx >= XkbNumVirtualMods)
tmp = "illegal";
- else if (xkb && xkb->names)
- tmp = xkb->names->vmods[ndx];
+ else if (keymap && keymap->names)
+ tmp = keymap->names->vmods[ndx];
if (!tmp) {
snprintf(buf, sizeof(buf) - 1, "%d", ndx);
}
const char *
-XkbcVModMaskText(struct xkb_keymap * xkb, unsigned modMask, unsigned mask)
+XkbcVModMaskText(struct xkb_keymap *keymap, unsigned modMask, unsigned mask)
{
int i, bit, len, rem;
const char *mm = NULL;
len = snprintf(str, rem, "%s%s",
(str != buf) ? "+" : "",
- XkbcVModIndexText(xkb, i));
+ XkbcVModIndexText(keymap, i));
rem -= len;
str += len;
}
#include "xkb-priv.h"
extern const char *
-XkbcVModMaskText(struct xkb_keymap * xkb, unsigned modMask, unsigned mask);
+XkbcVModMaskText(struct xkb_keymap *keymap, unsigned modMask, unsigned mask);
extern const char *
XkbcModIndexText(unsigned ndx);
int refcnt;
void *filters;
int num_filters;
- struct xkb_keymap *xkb;
+ struct xkb_keymap *keymap;
};
extern unsigned int
unsigned int group);
extern unsigned int
-xkb_key_get_syms_by_level(struct xkb_keymap *xkb, xkb_keycode_t key,
+xkb_key_get_syms_by_level(struct xkb_keymap *keymap, xkb_keycode_t key,
unsigned int group, unsigned int level,
const xkb_keysym_t **syms_out);
extern bool
-XkbcComputeEffectiveMap(struct xkb_keymap * xkb, struct xkb_key_type * type,
+XkbcComputeEffectiveMap(struct xkb_keymap *keymap, struct xkb_key_type *type,
unsigned char *map_rtrn);
extern int
-XkbcInitCanonicalKeyTypes(struct xkb_keymap * xkb, unsigned which,
+XkbcInitCanonicalKeyTypes(struct xkb_keymap *keymap, unsigned which,
int keypadVMod);
extern unsigned
_X_EXPORT void
xkb_canonicalise_components(struct xkb_component_names * names,
- const struct xkb_component_names * old)
+ const struct xkb_component_names * old)
{
names->keycodes = XkbcCanonicaliseComponent(names->keycodes,
old ? old->keycodes : NULL);
}
static bool
-VirtualModsToReal(struct xkb_keymap *xkb, unsigned virtual_mask,
+VirtualModsToReal(struct xkb_keymap *keymap, unsigned virtual_mask,
unsigned *mask_rtrn)
{
int i, bit;
unsigned mask;
- if (!xkb)
+ if (!keymap)
return false;
if (virtual_mask == 0) {
*mask_rtrn = 0;
return true;
}
- if (!xkb->server)
+ if (!keymap->server)
return false;
for (i = mask = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1) {
if (virtual_mask & bit)
- mask |= xkb->server->vmods[i];
+ mask |= keymap->server->vmods[i];
}
*mask_rtrn = mask;
}
bool
-XkbcComputeEffectiveMap(struct xkb_keymap * xkb, struct xkb_key_type * type,
+XkbcComputeEffectiveMap(struct xkb_keymap *keymap, struct xkb_key_type *type,
unsigned char *map_rtrn)
{
int i;
unsigned tmp;
struct xkb_kt_map_entry * entry = NULL;
- if (!xkb || !type || !xkb->server)
+ if (!keymap || !type || !keymap->server)
return false;
if (type->mods.vmods != 0) {
- if (!VirtualModsToReal(xkb, type->mods.vmods, &tmp))
+ if (!VirtualModsToReal(keymap, type->mods.vmods, &tmp))
return false;
type->mods.mask = tmp | type->mods.real_mods;
for (i = 0; i < type->map_count; i++, entry++) {
tmp = 0;
if (entry->mods.vmods != 0) {
- if (!VirtualModsToReal(xkb, entry->mods.vmods, &tmp))
+ if (!VirtualModsToReal(keymap, entry->mods.vmods, &tmp))
return false;
if (tmp == 0) {
entry->active = false;
}
static bool
-HandleNoAction(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleNoAction(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
return ReportIllegal(action->type, field);
}
}
static bool
-CheckModifierField(struct xkb_keymap * xkb,
- unsigned action,
- ExprDef * value,
+CheckModifierField(struct xkb_keymap *keymap, unsigned action, ExprDef *value,
unsigned *flags_inout, unsigned *mods_rtrn)
{
ExprResult rtrn;
return true;
}
}
- if (!ExprResolveVModMask(value, &rtrn, xkb))
+ if (!ExprResolveVModMask(value, &rtrn, keymap))
return ReportMismatch(action, F_Modifiers, "modifier mask");
*mods_rtrn = rtrn.uval;
*flags_inout &= ~XkbSA_UseModMapMods;
}
static bool
-HandleSetLatchMods(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleSetLatchMods(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
struct xkb_mod_action *act;
unsigned rtrn;
return false;
case F_Modifiers:
t1 = act->flags;
- if (CheckModifierField(xkb, action->type, value, &t1, &t2))
+ if (CheckModifierField(keymap, action->type, value, &t1, &t2))
{
act->flags = t1;
act->real_mods = act->mask = (t2 & 0xff);
}
static bool
-HandleLockMods(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleLockMods(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
struct xkb_mod_action *act;
unsigned t1, t2;
{
case F_Modifiers:
t1 = act->flags;
- if (CheckModifierField(xkb, action->type, value, &t1, &t2))
+ if (CheckModifierField(keymap, action->type, value, &t1, &t2))
{
act->flags = t1;
act->real_mods = act->mask = (t2 & 0xff);
}
static bool
-HandleSetLatchGroup(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleSetLatchGroup(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
struct xkb_group_action *act;
unsigned rtrn;
}
static bool
-HandleLockGroup(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleLockGroup(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
struct xkb_group_action *act;
unsigned t1;
}
static bool
-HandleMovePtr(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleMovePtr(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
struct xkb_pointer_action *act;
};
static bool
-HandlePtrBtn(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandlePtrBtn(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
struct xkb_pointer_button_action *act;
};
static bool
-HandleSetPtrDflt(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleSetPtrDflt(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
struct xkb_pointer_default_action *act;
};
static bool
-HandleISOLock(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleISOLock(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
struct xkb_iso_action *act;
if (array_ndx != NULL)
return ReportActionNotArray(action->type, field);
flags = act->flags;
- if (CheckModifierField(xkb, action->type, value, &flags, &mods))
+ if (CheckModifierField(keymap, action->type, value, &flags, &mods))
{
act->flags = flags & (~XkbSA_ISODfltIsGroup);
act->real_mods = mods & 0xff;
}
static bool
-HandleSwitchScreen(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleSwitchScreen(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
struct xkb_switch_screen_action *act;
};
static bool
-HandleSetLockControls(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleSetLockControls(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
struct xkb_controls_action *act;
};
static bool
-HandleActionMessage(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleActionMessage(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
struct xkb_message_action *act;
}
static bool
-HandleRedirectKey(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleRedirectKey(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
struct xkb_redirect_key_action *act;
if (!ExprResolveKeyName(value, &rtrn))
return ReportMismatch(action->type, field, "key name");
tmp = KeyNameToLong(rtrn.keyName.name);
- if (!FindNamedKey(xkb, tmp, &kc, true, CreateKeyNames(xkb), 0))
+ if (!FindNamedKey(keymap, tmp, &kc, true, CreateKeyNames(keymap), 0))
{
return ReportNotFound(action->type, field, "Key",
XkbcKeyNameText(rtrn.keyName.name));
case F_ModsToClear:
case F_Modifiers:
t1 = 0;
- if (CheckModifierField(xkb, action->type, value, &t1, &t2))
+ if (CheckModifierField(keymap, action->type, value, &t1, &t2))
{
act->mods_mask |= (t2 & 0xff);
if (field == F_Modifiers)
}
static bool
-HandleDeviceBtn(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleDeviceBtn(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
struct xkb_device_button_action *act;
}
static bool
-HandleDeviceValuator(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandleDeviceValuator(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
#if 0
ExprResult rtrn;
}
static bool
-HandlePrivate(struct xkb_keymap * xkb,
- struct xkb_any_action * action,
- unsigned field, ExprDef * array_ndx, ExprDef * value)
+HandlePrivate(struct xkb_keymap *keymap, struct xkb_any_action *action,
+ unsigned field, ExprDef *array_ndx, ExprDef *value)
{
ExprResult rtrn;
return ReportIllegal(PrivateAction, field);
}
-typedef bool (*actionHandler) (struct xkb_keymap *xkb,
+typedef bool (*actionHandler) (struct xkb_keymap *keymap,
struct xkb_any_action *action, unsigned field,
ExprDef *array_ndx, ExprDef *value);
int
HandleActionDef(ExprDef * def,
- struct xkb_keymap * xkb,
- struct xkb_any_action * action, ActionInfo * info)
+ struct xkb_keymap *keymap,
+ struct xkb_any_action *action, ActionInfo *info)
{
ExprDef *arg;
const char *str;
if ((info->action == XkbSA_NoAction)
|| (info->action == hndlrType))
{
- if (!(*handleAction[hndlrType]) (xkb, action,
+ if (!(*handleAction[hndlrType]) (keymap, action,
info->field,
info->array_ndx,
info->value))
}
free(elemRtrn.str);
free(fieldRtrn.str);
- if (!(*handleAction[hndlrType])
- (xkb, action, fieldNdx, arrayRtrn, value))
- {
+ if (!(*handleAction[hndlrType])(keymap, action, fieldNdx, arrayRtrn,
+ value))
return false;
- }
}
return true;
}
/***====================================================================***/
int
-SetActionField(struct xkb_keymap * xkb,
+SetActionField(struct xkb_keymap *keymap,
char *elem,
char *field,
ExprDef * array_ndx, ExprDef * value, ActionInfo ** info_rtrn)
} ActionInfo;
extern int
-HandleActionDef(ExprDef *def, struct xkb_keymap *xkb,
+HandleActionDef(ExprDef *def, struct xkb_keymap *keymap,
struct xkb_any_action *action, ActionInfo *info);
extern int
-SetActionField(struct xkb_keymap *xkb, char *elem, char *field,
+SetActionField(struct xkb_keymap *keymap, char *elem, char *field,
ExprDef *index, ExprDef *value, ActionInfo **info_rtrn);
extern const LookupEntry ctrlNames[];
}
int
-ApplyAliases(struct xkb_keymap * xkb, AliasInfo ** info_in)
+ApplyAliases(struct xkb_keymap *keymap, AliasInfo ** info_in)
{
int i;
struct xkb_key_alias *old, *a;
if (*info_in == NULL)
return true;
- nOld = (xkb->names ? xkb->names->num_key_aliases : 0);
- old = (xkb->names ? xkb->names->key_aliases : NULL);
+ nOld = (keymap->names ? keymap->names->num_key_aliases : 0);
+ old = (keymap->names ? keymap->names->key_aliases : NULL);
for (nNew = 0, info = *info_in; info != NULL;
info = (AliasInfo *) info->def.next)
{
xkb_keycode_t kc;
lname = KeyNameToLong(info->real);
- if (!FindNamedKey(xkb, lname, &kc, false, CreateKeyNames(xkb), 0))
+ if (!FindNamedKey(keymap, lname, &kc, false, CreateKeyNames(keymap), 0))
{
if (warningLevel > 4)
{
continue;
}
lname = KeyNameToLong(info->alias);
- if (FindNamedKey(xkb, lname, &kc, false, false, 0))
+ if (FindNamedKey(keymap, lname, &kc, false, false, 0))
{
if (warningLevel > 4)
{
*info_in = NULL;
return true;
}
- status = XkbcAllocNames(xkb, XkbKeyAliasesMask, nOld + nNew);
- if (xkb->names)
- old = xkb->names->key_aliases;
+ status = XkbcAllocNames(keymap, XkbKeyAliasesMask, nOld + nNew);
+ if (keymap->names)
+ old = keymap->names->key_aliases;
if (status != Success)
{
WSGO("Allocation failure in ApplyAliases\n");
return false;
}
- a = xkb->names ? &xkb->names->key_aliases[nOld] : NULL;
+ a = keymap->names ? &keymap->names->key_aliases[nOld] : NULL;
for (info = *info_in; info != NULL; info = (AliasInfo *) info->def.next)
{
if (info->alias[0] != '\0')
MergeAliases(AliasInfo **into, AliasInfo **merge, unsigned how_merge);
extern int
-ApplyAliases(struct xkb_keymap *xkb, AliasInfo **info);
+ApplyAliases(struct xkb_keymap *keymap, AliasInfo **info);
#endif /* ALIAS_H */
LEDInfo *leds;
VModInfo vmods;
ActionInfo *act;
- struct xkb_keymap * xkb;
+ struct xkb_keymap *keymap;
} CompatInfo;
/***====================================================================***/
}
static void
-InitCompatInfo(CompatInfo * info, struct xkb_keymap * xkb)
+InitCompatInfo(CompatInfo *info, struct xkb_keymap *keymap)
{
unsigned int i;
- info->xkb = xkb;
+ info->keymap = keymap;
info->name = NULL;
info->fileID = 0;
info->errorCount = 0;
memset(&info->groupCompat[0], 0,
XkbNumKbdGroups * sizeof(GroupCompatInfo));
info->leds = NULL;
- InitVModInfo(&info->vmods, xkb);
+ InitVModInfo(&info->vmods, keymap);
}
static void
-ClearCompatInfo(CompatInfo * info, struct xkb_keymap * xkb)
+ClearCompatInfo(CompatInfo *info, struct xkb_keymap *keymap)
{
unsigned int i;
ActionInfo *next;
free(info->act);
info->act = next;
}
- ClearVModInfo(&info->vmods, xkb);
+ ClearVModInfo(&info->vmods, keymap);
}
static SymInterpInfo *
}
}
-typedef void (*FileHandler) (XkbFile *rtrn, struct xkb_keymap *xkb,
+typedef void (*FileHandler) (XkbFile *rtrn, struct xkb_keymap *keymap,
unsigned merge, CompatInfo *info);
static bool
-HandleIncludeCompatMap(IncludeStmt * stmt,
- struct xkb_keymap * xkb, CompatInfo * info, FileHandler hndlr)
+HandleIncludeCompatMap(IncludeStmt *stmt, struct xkb_keymap *keymap,
+ CompatInfo *info, FileHandler hndlr)
{
unsigned newMerge;
XkbFile *rtrn;
included = *info;
memset(info, 0, sizeof(CompatInfo));
}
- else if (ProcessIncludeFile(xkb->context, stmt, XkmCompatMapIndex, &rtrn,
- &newMerge))
+ else if (ProcessIncludeFile(keymap->context, stmt, XkmCompatMapIndex,
+ &rtrn, &newMerge))
{
- InitCompatInfo(&included, xkb);
+ InitCompatInfo(&included, keymap);
included.fileID = rtrn->id;
included.dflt = info->dflt;
included.dflt.defs.fileID = rtrn->id;
included.ledDflt.defs.fileID = rtrn->id;
included.ledDflt.defs.merge = newMerge;
included.act = info->act;
- (*hndlr) (rtrn, xkb, MergeOverride, &included);
+ (*hndlr) (rtrn, keymap, MergeOverride, &included);
if (stmt->stmt != NULL)
{
free(included.name);
{
haveSelf = true;
MergeIncludedCompatMaps(&included, info, next->merge);
- ClearCompatInfo(info, xkb);
+ ClearCompatInfo(info, keymap);
}
- else if (ProcessIncludeFile(xkb->context, next, XkmCompatMapIndex,
- &rtrn, &op))
+ else if (ProcessIncludeFile(keymap->context, next,
+ XkmCompatMapIndex, &rtrn, &op))
{
- InitCompatInfo(&next_incl, xkb);
+ InitCompatInfo(&next_incl, keymap);
next_incl.fileID = rtrn->id;
next_incl.dflt = info->dflt;
next_incl.dflt.defs.fileID = rtrn->id;
next_incl.ledDflt.defs.fileID = rtrn->id;
next_incl.ledDflt.defs.merge = op;
next_incl.act = info->act;
- (*hndlr) (rtrn, xkb, MergeOverride, &next_incl);
+ (*hndlr) (rtrn, keymap, MergeOverride, &next_incl);
MergeIncludedCompatMaps(&included, &next_incl, op);
if (info->act != NULL)
next_incl.act = NULL;
- ClearCompatInfo(&next_incl, xkb);
+ ClearCompatInfo(&next_incl, keymap);
FreeXKBFile(rtrn);
}
else
else
{
MergeIncludedCompatMaps(info, &included, newMerge);
- ClearCompatInfo(&included, xkb);
+ ClearCompatInfo(&included, keymap);
}
return (info->errorCount == 0);
}
};
static int
-SetInterpField(SymInterpInfo * si,
- struct xkb_keymap * xkb,
- char *field,
- ExprDef * arrayNdx, ExprDef * value, CompatInfo * info)
+SetInterpField(SymInterpInfo *si, struct xkb_keymap *keymap, char *field,
+ ExprDef *arrayNdx, ExprDef *value, CompatInfo *info)
{
int ok = 1;
ExprResult tmp;
{
if (arrayNdx != NULL)
return ReportSINotArray(si, field, info);
- ok = HandleActionDef(value, xkb, &si->interp.act.any, info->act);
+ ok = HandleActionDef(value, keymap, &si->interp.act.any, info->act);
if (ok)
si->defs.defined |= _SI_Action;
}
{
if (arrayNdx != NULL)
return ReportSINotArray(si, field, info);
- ok = ResolveVirtualModifier(value, xkb, &tmp, &info->vmods);
+ ok = ResolveVirtualModifier(value, keymap, &tmp, &info->vmods);
if (ok)
{
si->interp.virtual_mod = tmp.uval;
}
static int
-HandleInterpVar(VarDef * stmt, struct xkb_keymap * xkb, CompatInfo * info)
+HandleInterpVar(VarDef * stmt, struct xkb_keymap *keymap, CompatInfo * info)
{
ExprResult elem, field;
ExprDef *ndx;
if (ExprResolveLhs(stmt->name, &elem, &field, &ndx) == 0)
ret = 0; /* internal error, already reported */
else if (elem.str && (strcasecmp(elem.str, "interpret") == 0))
- ret = SetInterpField(&info->dflt, xkb, field.str, ndx, stmt->value,
+ ret = SetInterpField(&info->dflt, keymap, field.str, ndx, stmt->value,
info);
else if (elem.str && (strcasecmp(elem.str, "indicator") == 0))
- ret = SetIndicatorMapField(&info->ledDflt, xkb, field.str, ndx,
+ ret = SetIndicatorMapField(&info->ledDflt, keymap, field.str, ndx,
stmt->value);
else
- ret = SetActionField(xkb, elem.str, field.str, ndx, stmt->value,
+ ret = SetActionField(keymap, elem.str, field.str, ndx, stmt->value,
&info->act);
free(elem.str);
free(field.str);
}
static int
-HandleInterpBody(VarDef * def, struct xkb_keymap * xkb, SymInterpInfo * si,
- CompatInfo * info)
+HandleInterpBody(VarDef *def, struct xkb_keymap *keymap, SymInterpInfo *si,
+ CompatInfo *info)
{
int ok = 1;
ExprResult tmp, field;
{
if ((def->name) && (def->name->type == ExprFieldRef))
{
- ok = HandleInterpVar(def, xkb, info);
+ ok = HandleInterpVar(def, keymap, info);
continue;
}
ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);
if (ok) {
- ok = SetInterpField(si, xkb, field.str, arrayNdx, def->value,
+ ok = SetInterpField(si, keymap, field.str, arrayNdx, def->value,
info);
free(field.str);
}
}
static int
-HandleInterpDef(InterpDef * def, struct xkb_keymap * xkb, unsigned merge,
- CompatInfo * info)
+HandleInterpDef(InterpDef *def, struct xkb_keymap *keymap, unsigned merge,
+ CompatInfo *info)
{
unsigned pred, mods;
SymInterpInfo si;
}
si.interp.match = pred & XkbSI_OpMask;
si.interp.mods = mods;
- if (!HandleInterpBody(def->def, xkb, &si, info))
+ if (!HandleInterpBody(def->def, keymap, &si, info))
{
info->errorCount++;
return false;
}
static int
-HandleGroupCompatDef(GroupCompatDef * def,
- struct xkb_keymap * xkb, unsigned merge, CompatInfo * info)
+HandleGroupCompatDef(GroupCompatDef *def, struct xkb_keymap *keymap,
+ unsigned merge, CompatInfo *info)
{
ExprResult val;
GroupCompatInfo tmp;
}
tmp.fileID = info->fileID;
tmp.merge = merge;
- if (!ExprResolveVModMask(def->def, &val, xkb))
+ if (!ExprResolveVModMask(def->def, &val, keymap))
{
ERROR("Expected a modifier mask in group compatibility definition\n");
ACTION("Ignoring illegal compatibility map for group %d\n",
}
static void
-HandleCompatMapFile(XkbFile * file,
- struct xkb_keymap * xkb, unsigned merge, CompatInfo * info)
+HandleCompatMapFile(XkbFile *file, struct xkb_keymap *keymap, unsigned merge,
+ CompatInfo *info)
{
ParseCommon *stmt;
switch (stmt->stmtType)
{
case StmtInclude:
- if (!HandleIncludeCompatMap((IncludeStmt *) stmt, xkb, info,
+ if (!HandleIncludeCompatMap((IncludeStmt *) stmt, keymap, info,
HandleCompatMapFile))
info->errorCount++;
break;
case StmtInterpDef:
- if (!HandleInterpDef((InterpDef *) stmt, xkb, merge, info))
+ if (!HandleInterpDef((InterpDef *) stmt, keymap, merge, info))
info->errorCount++;
break;
case StmtGroupCompatDef:
if (!HandleGroupCompatDef
- ((GroupCompatDef *) stmt, xkb, merge, info))
+ ((GroupCompatDef *) stmt, keymap, merge, info))
info->errorCount++;
break;
case StmtIndicatorMapDef:
{
LEDInfo *rtrn;
- rtrn = HandleIndicatorMapDef((IndicatorMapDef *) stmt, xkb,
+ rtrn = HandleIndicatorMapDef((IndicatorMapDef *) stmt, keymap,
&info->ledDflt, info->leds, merge);
if (rtrn != NULL)
info->leds = rtrn;
}
break;
case StmtVarDef:
- if (!HandleInterpVar((VarDef *) stmt, xkb, info))
+ if (!HandleInterpVar((VarDef *) stmt, keymap, info))
info->errorCount++;
break;
case StmtVModDef:
- if (!HandleVModDef((VModDef *) stmt, xkb, merge, &info->vmods))
+ if (!HandleVModDef((VModDef *) stmt, keymap, merge, &info->vmods))
info->errorCount++;
break;
case StmtKeycodeDef:
}
bool
-CompileCompatMap(XkbFile *file, struct xkb_keymap *xkb, unsigned merge,
+CompileCompatMap(XkbFile *file, struct xkb_keymap *keymap, unsigned merge,
LEDInfoPtr *unboundLEDs)
{
int i;
CompatInfo info;
GroupCompatInfo *gcm;
- InitCompatInfo(&info, xkb);
+ InitCompatInfo(&info, keymap);
info.dflt.defs.merge = merge;
info.ledDflt.defs.merge = merge;
- HandleCompatMapFile(file, xkb, merge, &info);
+ HandleCompatMapFile(file, keymap, merge, &info);
if (info.errorCount != 0)
goto err_info;
- if (XkbcAllocCompatMap(xkb, info.nInterps) != Success) {
+ if (XkbcAllocCompatMap(keymap, info.nInterps) != Success) {
WSGO("Couldn't allocate compatibility map\n");
goto err_info;
}
if (info.nInterps > 0) {
- CopyInterps(&info, xkb->compat, true, XkbSI_Exactly);
- CopyInterps(&info, xkb->compat, true, XkbSI_AllOf | XkbSI_NoneOf);
- CopyInterps(&info, xkb->compat, true, XkbSI_AnyOf);
- CopyInterps(&info, xkb->compat, true, XkbSI_AnyOfOrNone);
- CopyInterps(&info, xkb->compat, false, XkbSI_Exactly);
- CopyInterps(&info, xkb->compat, false, XkbSI_AllOf | XkbSI_NoneOf);
- CopyInterps(&info, xkb->compat, false, XkbSI_AnyOf);
- CopyInterps(&info, xkb->compat, false, XkbSI_AnyOfOrNone);
+ CopyInterps(&info, keymap->compat, true, XkbSI_Exactly);
+ CopyInterps(&info, keymap->compat, true, XkbSI_AllOf | XkbSI_NoneOf);
+ CopyInterps(&info, keymap->compat, true, XkbSI_AnyOf);
+ CopyInterps(&info, keymap->compat, true, XkbSI_AnyOfOrNone);
+ CopyInterps(&info, keymap->compat, false, XkbSI_Exactly);
+ CopyInterps(&info, keymap->compat, false, XkbSI_AllOf | XkbSI_NoneOf);
+ CopyInterps(&info, keymap->compat, false, XkbSI_AnyOf);
+ CopyInterps(&info, keymap->compat, false, XkbSI_AnyOfOrNone);
}
for (i = 0, gcm = &info.groupCompat[0]; i < XkbNumKbdGroups; i++, gcm++) {
if ((gcm->fileID != 0) || (gcm->real_mods != 0) || (gcm->vmods != 0)) {
- xkb->compat->groups[i].mask = gcm->real_mods;
- xkb->compat->groups[i].real_mods = gcm->real_mods;
- xkb->compat->groups[i].vmods = gcm->vmods;
+ keymap->compat->groups[i].mask = gcm->real_mods;
+ keymap->compat->groups[i].real_mods = gcm->real_mods;
+ keymap->compat->groups[i].vmods = gcm->vmods;
}
}
if (info.leds != NULL) {
- if (!CopyIndicatorMapDefs(xkb, info.leds, unboundLEDs))
+ if (!CopyIndicatorMapDefs(keymap, info.leds, unboundLEDs))
info.errorCount++;
info.leds = NULL;
}
- ClearCompatInfo(&info, xkb);
+ ClearCompatInfo(&info, keymap);
return true;
err_info:
- ClearCompatInfo(&info, xkb);
+ ClearCompatInfo(&info, keymap);
return false;
}
static uint32_t
-VModsToReal(struct xkb_keymap *xkb, uint32_t vmodmask)
+VModsToReal(struct xkb_keymap *keymap, uint32_t vmodmask)
{
uint32_t ret = 0;
int i;
for (i = 0; i < XkbNumVirtualMods; i++) {
if (!(vmodmask & (1 << i)))
continue;
- ret |= xkb->server->vmods[i];
+ ret |= keymap->server->vmods[i];
}
return ret;
}
static void
-UpdateActionMods(struct xkb_keymap *xkb, union xkb_action *act, uint32_t rmodmask)
+UpdateActionMods(struct xkb_keymap *keymap, union xkb_action *act,
+ uint32_t rmodmask)
{
switch (act->type) {
case XkbSA_SetMods:
if (act->mods.flags & XkbSA_UseModMapMods)
act->mods.real_mods = rmodmask;
act->mods.mask = act->mods.real_mods;
- act->mods.mask |= VModsToReal(xkb, act->mods.vmods);
+ act->mods.mask |= VModsToReal(keymap, act->mods.vmods);
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(xkb, act->iso.vmods);
+ act->iso.mask |= VModsToReal(keymap, act->iso.vmods);
break;
default:
break;
* generic XKB_KEYSYM_NO_SYMBOL match.
*/
static struct xkb_sym_interpret *
-FindInterpForKey(struct xkb_keymap *xkb, xkb_keycode_t key, uint32_t group, uint32_t level)
+FindInterpForKey(struct xkb_keymap *keymap, xkb_keycode_t key,
+ uint32_t group, uint32_t level)
{
struct xkb_sym_interpret *ret = NULL;
const xkb_keysym_t *syms;
int num_syms;
int i;
- num_syms = xkb_key_get_syms_by_level(xkb, key, group, level, &syms);
+ num_syms = xkb_key_get_syms_by_level(keymap, key, group, level, &syms);
if (num_syms == 0)
return NULL;
- for (i = 0; i < xkb->compat->num_si; i++) {
- struct xkb_sym_interpret *interp = &xkb->compat->sym_interpret[i];
+ for (i = 0; i < keymap->compat->num_si; i++) {
+ struct xkb_sym_interpret *interp = &keymap->compat->sym_interpret[i];
uint32_t mods;
bool found;
continue;
if (level == 0 || !(interp->match & XkbSI_LevelOneOnly))
- mods = xkb->map->modmap[key];
+ mods = keymap->map->modmap[key];
else
mods = 0;
/**
*/
static bool
-ApplyInterpsToKey(struct xkb_keymap *xkb, xkb_keycode_t key)
+ApplyInterpsToKey(struct xkb_keymap *keymap, xkb_keycode_t key)
{
#define INTERP_SIZE (8 * 4)
struct xkb_sym_interpret *interps[INTERP_SIZE];
uint32_t vmodmask = 0;
int num_acts = 0;
int group, level;
- int width = XkbKeyGroupsWidth(xkb, key);
+ int width = XkbKeyGroupsWidth(keymap, key);
int i;
/* If we've been told not to bind interps to this key, then don't. */
- if (xkb->server->explicit[key] & XkbExplicitInterpretMask)
+ if (keymap->server->explicit[key] & XkbExplicitInterpretMask)
return true;
for (i = 0; i < INTERP_SIZE; i++)
interps[i] = NULL;
- for (group = 0; group < XkbKeyNumGroups(xkb, key); group++) {
- for (level = 0; level < XkbKeyGroupWidth(xkb, key, group); level++) {
+ for (group = 0; group < XkbKeyNumGroups(keymap, key); group++) {
+ for (level = 0; level < XkbKeyGroupWidth(keymap, key, group); level++) {
i = (group * width) + level;
if (i >= INTERP_SIZE) /* XXX FIXME */
return false;
- interps[i] = FindInterpForKey(xkb, key, group, level);
+ interps[i] = FindInterpForKey(keymap, key, group, level);
if (interps[i])
num_acts++;
}
}
if (num_acts)
- num_acts = XkbKeyNumGroups(xkb, key) * width;
- acts = XkbcResizeKeyActions(xkb, key, num_acts);
+ num_acts = XkbKeyNumGroups(keymap, key) * width;
+ acts = XkbcResizeKeyActions(keymap, key, num_acts);
if (!num_acts)
return true;
else if (!acts)
return false;
- for (group = 0; group < XkbKeyNumGroups(xkb, key); group++) {
- for (level = 0; level < XkbKeyGroupWidth(xkb, key, group); level++) {
+ for (group = 0; group < XkbKeyNumGroups(keymap, key); group++) {
+ for (level = 0; level < XkbKeyGroupWidth(keymap, key, group); level++) {
struct xkb_sym_interpret *interp;
i = (group * width) + level;
/* Infer default key behaviours from the base level. */
if (group == 0 && level == 0) {
- if (!(xkb->server->explicit[key] & XkbExplicitAutoRepeatMask) &&
+ if (!(keymap->server->explicit[key] & XkbExplicitAutoRepeatMask) &&
(!interp || interp->flags & XkbSI_AutoRepeat))
- xkb->ctrls->per_key_repeat[key / 8] |= (1 << (key % 8));
- if (!(xkb->server->explicit[key] & XkbExplicitBehaviorMask) &&
+ keymap->ctrls->per_key_repeat[key / 8] |= (1 << (key % 8));
+ if (!(keymap->server->explicit[key] & XkbExplicitBehaviorMask) &&
interp && (interp->flags & XkbSI_LockingKey))
- xkb->server->behaviors[key].type = XkbKB_Lock;
+ keymap->server->behaviors[key].type = XkbKB_Lock;
}
if (!interp)
}
}
- if (!(xkb->server->explicit[key] & XkbExplicitVModMapMask))
- xkb->server->vmodmap[key] = vmodmask;
+ if (!(keymap->server->explicit[key] & XkbExplicitVModMapMask))
+ keymap->server->vmodmap[key] = vmodmask;
return true;
#undef INTERP_SIZE
* other than Shift actually do something ...
*/
bool
-UpdateModifiersFromCompat(struct xkb_keymap *xkb)
+UpdateModifiersFromCompat(struct xkb_keymap *keymap)
{
xkb_keycode_t key;
int i;
/* Find all the interprets for the key and bind them to actions,
* which will also update the vmodmap. */
- for (key = xkb->min_key_code; key <= xkb->max_key_code; key++)
- if (!ApplyInterpsToKey(xkb, key))
+ for (key = keymap->min_key_code; key <= keymap->max_key_code; key++)
+ if (!ApplyInterpsToKey(keymap, key))
return false;
- /* Update xkb->server->vmods, the virtual -> real mod mapping. */
+ /* Update keymap->server->vmods, the virtual -> real mod mapping. */
for (i = 0; i < XkbNumVirtualMods; i++)
- xkb->server->vmods[i] = 0;
- for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) {
- if (!xkb->server->vmodmap[key])
+ keymap->server->vmods[i] = 0;
+ for (key = keymap->min_key_code; key <= keymap->max_key_code; key++) {
+ if (!keymap->server->vmodmap[key])
continue;
for (i = 0; i < XkbNumVirtualMods; i++) {
- if (!(xkb->server->vmodmap[key] & (1 << i)))
+ if (!(keymap->server->vmodmap[key] & (1 << i)))
continue;
- xkb->server->vmods[i] |= xkb->map->modmap[key];
+ keymap->server->vmods[i] |= keymap->map->modmap[key];
}
}
/* Now update the level masks for all the types to reflect the vmods. */
- for (i = 0; i < xkb->map->num_types; i++) {
- struct xkb_key_type *type = &xkb->map->types[i];
+ for (i = 0; i < keymap->map->num_types; i++) {
+ struct xkb_key_type *type = &keymap->map->types[i];
uint32_t mask = 0;
int j;
type->mods.mask = type->mods.real_mods;
- type->mods.mask |= VModsToReal(xkb, type->mods.vmods);
+ type->mods.mask |= VModsToReal(keymap, type->mods.vmods);
for (j = 0; j < XkbNumVirtualMods; j++) {
if (!(type->mods.vmods & (1 << j)))
continue;
- mask |= xkb->server->vmods[j];
+ mask |= keymap->server->vmods[j];
}
for (j = 0; j < type->map_count; j++) {
struct xkb_mods *mods = &type->map[j].mods;
- mods->mask = mods->real_mods | VModsToReal(xkb, mods->vmods);
+ mods->mask = mods->real_mods | VModsToReal(keymap, mods->vmods);
}
}
/* Update action modifiers. */
- for (key = xkb->min_key_code; key <= xkb->max_key_code; key++) {
- union xkb_action *acts = XkbKeyActionsPtr(xkb, key);
- for (i = 0; i < XkbKeyNumActions(xkb, key); i++) {
+ for (key = keymap->min_key_code; key <= keymap->max_key_code; key++) {
+ union xkb_action *acts = XkbKeyActionsPtr(keymap, key);
+ for (i = 0; i < XkbKeyNumActions(keymap, key); i++) {
if (acts[i].any.type == XkbSA_NoAction)
continue;
- UpdateActionMods(xkb, &acts[i], xkb->map->modmap[key]);
+ UpdateActionMods(keymap, &acts[i], keymap->map->modmap[key]);
}
}
/* Update group modifiers. */
for (i = 0; i < XkbNumKbdGroups; i++) {
- struct xkb_mods *group = &xkb->compat->groups[i];
- group->mask = group->real_mods | VModsToReal(xkb, group->vmods);
+ struct xkb_mods *group = &keymap->compat->groups[i];
+ group->mask = group->real_mods | VModsToReal(keymap, group->vmods);
}
/* Update vmod -> indicator maps. */
for (i = 0; i < XkbNumIndicators; i++) {
- struct xkb_mods *led = &xkb->indicators->maps[i].mods;
- led->mask = led->real_mods | VModsToReal(xkb, led->vmods);
+ struct xkb_mods *led = &keymap->indicators->maps[i].mods;
+ led->mask = led->real_mods | VModsToReal(keymap, led->vmods);
}
return true;
}
int
-ExprResolveMask(ExprDef * expr,
- ExprResult * val_rtrn,
+ExprResolveMask(ExprDef *expr, ExprResult *val_rtrn,
const LookupEntry * values)
{
return ExprResolveMaskLookup(expr, val_rtrn, SimpleLookup, values);
}
int
-ExprResolveModMask(ExprDef * expr,
- ExprResult * val_rtrn)
+ExprResolveModMask(ExprDef *expr, ExprResult *val_rtrn)
{
return ExprResolveMaskLookup(expr, val_rtrn, LookupModMask, NULL);
}
int
-ExprResolveVModMask(ExprDef * expr,
- ExprResult * val_rtrn,
- struct xkb_keymap *xkb)
+ExprResolveVModMask(ExprDef *expr, ExprResult *val_rtrn,
+ struct xkb_keymap *keymap)
{
- return ExprResolveMaskLookup(expr, val_rtrn, LookupVModMask, xkb);
+ return ExprResolveMaskLookup(expr, val_rtrn, LookupVModMask, keymap);
}
int
-ExprResolveKeySym(ExprDef * expr,
- ExprResult * val_rtrn)
+ExprResolveKeySym(ExprDef *expr, ExprResult *val_rtrn)
{
int ok = 0;
xkb_keysym_t sym;
extern int
ExprResolveVModMask(ExprDef *expr, ExprResult *val_rtrn,
- struct xkb_keymap *xkb);
+ struct xkb_keymap *keymap);
extern int
ExprResolveBoolean(ExprDef *expr, ExprResult *val_rtrn);
};
int
-SetIndicatorMapField(LEDInfo * led,
- struct xkb_keymap * xkb,
- char *field, ExprDef * arrayNdx, ExprDef * value)
+SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap,
+ char *field, ExprDef *arrayNdx, ExprDef *value)
{
ExprResult rtrn;
bool ok;
{
if (arrayNdx != NULL)
return ReportIndicatorNotArray(led, field);
- if (!ExprResolveVModMask(value, &rtrn, xkb))
+ if (!ExprResolveVModMask(value, &rtrn, keymap))
return ReportIndicatorBadType(led, field, "modifier mask");
led->real_mods = rtrn.uval & 0xff;
led->vmods = (rtrn.uval >> 8) & 0xff;
}
LEDInfo *
-HandleIndicatorMapDef(IndicatorMapDef * def,
- struct xkb_keymap * xkb,
- LEDInfo * dflt, LEDInfo * oldLEDs, unsigned merge)
+HandleIndicatorMapDef(IndicatorMapDef *def, struct xkb_keymap *keymap,
+ LEDInfo *dflt, LEDInfo *oldLEDs, unsigned merge)
{
LEDInfo led, *rtrn;
VarDef *var;
}
else
{
- ok = SetIndicatorMapField(&led, xkb, field.str, arrayNdx,
+ ok = SetIndicatorMapField(&led, keymap, field.str, arrayNdx,
var->value) && ok;
}
free(elem.str);
}
bool
-CopyIndicatorMapDefs(struct xkb_keymap * xkb, LEDInfo *leds, LEDInfo **unboundRtrn)
+CopyIndicatorMapDefs(struct xkb_keymap *keymap, LEDInfo *leds,
+ LEDInfo **unboundRtrn)
{
LEDInfo *led, *next;
LEDInfo *unbound, *last;
- if (XkbcAllocNames(xkb, XkbIndicatorNamesMask, 0) != Success)
+ if (XkbcAllocNames(keymap, XkbIndicatorNamesMask, 0) != Success)
{
WSGO("Couldn't allocate names\n");
ACTION("Indicator names may be incorrect\n");
}
- if (XkbcAllocIndicatorMaps(xkb) != Success)
+ if (XkbcAllocIndicatorMaps(keymap) != Success)
{
WSGO("Can't allocate indicator maps\n");
ACTION("Indicator map definitions may be lost\n");
led->which_groups = XkbIM_UseEffective;
if ((led->which_mods == 0) && ((led->real_mods) || (led->vmods)))
led->which_mods = XkbIM_UseEffective;
- if ((led->indicator == _LED_NotBound) || (!xkb->indicators))
+ if ((led->indicator == _LED_NotBound) || (!keymap->indicators))
{
if (unboundRtrn != NULL)
{
else
{
struct xkb_indicator_map * im;
- im = &xkb->indicators->maps[led->indicator - 1];
+ im = &keymap->indicators->maps[led->indicator - 1];
im->flags = led->flags;
im->which_groups = led->which_groups;
im->groups = led->groups;
im->mods.real_mods = led->real_mods;
im->mods.vmods = led->vmods;
im->ctrls = led->ctrls;
- if (xkb->names != NULL)
+ if (keymap->names != NULL)
{
- free(UNCONSTIFY(xkb->names->indicators[led->indicator - 1]));
- xkb->names->indicators[led->indicator-1] = XkbcAtomGetString(led->name);
+ free(UNCONSTIFY(keymap->names->indicators[led->indicator - 1]));
+ keymap->names->indicators[led->indicator-1] =
+ XkbcAtomGetString(led->name);
}
free(led);
}
}
bool
-BindIndicators(struct xkb_keymap * xkb, bool force, LEDInfo *unbound,
+BindIndicators(struct xkb_keymap *keymap, bool force, LEDInfo *unbound,
LEDInfo **unboundRtrn)
{
int i;
LEDInfo *led, *next, *last;
- if (xkb->names != NULL)
+ if (keymap->names != NULL)
{
for (led = unbound; led != NULL; led = (LEDInfo *) led->defs.next)
{
{
for (i = 0; i < XkbNumIndicators; i++)
{
- if (xkb->names->indicators[i] &&
- strcmp(xkb->names->indicators[i],
+ if (keymap->names->indicators[i] &&
+ strcmp(keymap->names->indicators[i],
XkbcAtomText(led->name)) == 0)
{
led->indicator = i + 1;
{
for (i = 0; i < XkbNumIndicators; i++)
{
- if (xkb->names->indicators[i] == NULL)
+ if (keymap->names->indicators[i] == NULL)
{
- xkb->names->indicators[i] = XkbcAtomGetString(led->name);
+ keymap->names->indicators[i] =
+ XkbcAtomGetString(led->name);
led->indicator = i + 1;
break;
}
}
else
{
- if ((xkb->names != NULL) &&
- (strcmp(xkb->names->indicators[led->indicator - 1],
+ if ((keymap->names != NULL) &&
+ (strcmp(keymap->names->indicators[led->indicator - 1],
XkbcAtomText(led->name)) != 0))
{
- const char *old = xkb->names->indicators[led->indicator - 1];
+ const char *old = keymap->names->indicators[led->indicator - 1];
ERROR("Multiple names bound to indicator %d\n",
(unsigned int) led->indicator);
ACTION("Using %s, ignoring %s\n", old, XkbcAtomText(led->name));
else
{
struct xkb_indicator_map * map;
- map = &xkb->indicators->maps[led->indicator - 1];
+ map = &keymap->indicators->maps[led->indicator - 1];
map->flags = led->flags;
map->which_groups = led->which_groups;
map->groups = led->groups;
AddIndicatorMap(LEDInfo *oldLEDs, LEDInfo *newLED);
extern int
-SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *xkb, char *field,
+SetIndicatorMapField(LEDInfo *led, struct xkb_keymap *keymap, char *field,
ExprDef *arrayNdx, ExprDef *value);
extern LEDInfo *
-HandleIndicatorMapDef(IndicatorMapDef *stmt, struct xkb_keymap *xkb,
+HandleIndicatorMapDef(IndicatorMapDef *stmt, struct xkb_keymap *keymap,
LEDInfo *dflt, LEDInfo *oldLEDs, unsigned mergeMode);
extern bool
-CopyIndicatorMapDefs(struct xkb_keymap *xkb, LEDInfo *leds,
+CopyIndicatorMapDefs(struct xkb_keymap *keymap, LEDInfo *leds,
LEDInfo **unboundRtrn);
extern bool
-BindIndicators(struct xkb_keymap *xkb, bool force, LEDInfo *unbound,
+BindIndicators(struct xkb_keymap *keymap, bool force, LEDInfo *unbound,
LEDInfo **unboundRtrn);
#endif /* INDICATORS_H */
AliasInfo *aliases;
} KeyNamesInfo;
-static void HandleKeycodesFile(XkbFile * file,
- struct xkb_keymap * xkb,
- unsigned merge,
- KeyNamesInfo * info);
+static void HandleKeycodesFile(XkbFile *file, struct xkb_keymap *keymap,
+ unsigned merge, KeyNamesInfo *info);
static int
ResizeKeyNameArrays(KeyNamesInfo *info, int newMax)
* Handle the given include statement (e.g. "include "evdev+aliases(qwerty)").
*
* @param stmt The include statement from the keymap file.
- * @param xkb Unused for all but the xkb->flags.
+ * @param keymap Unused for all but the keymap->flags.
* @param info Struct to store the key info in.
*/
static bool
-HandleIncludeKeycodes(IncludeStmt * stmt, struct xkb_keymap * xkb, KeyNamesInfo * info)
+HandleIncludeKeycodes(IncludeStmt *stmt, struct xkb_keymap *keymap,
+ KeyNamesInfo *info)
{
unsigned newMerge;
XkbFile *rtrn;
}
else if (stmt->file && strcmp(stmt->file, "computed") == 0)
{
- xkb->flags |= AutoKeyNames;
+ keymap->flags |= AutoKeyNames;
info->explicitMin = 0;
info->explicitMax = XKB_KEYCODE_MAX;
return (info->errorCount == 0);
} /* parse file, store returned info in the xkb struct */
- else if (ProcessIncludeFile(xkb->context, stmt, XkmKeyNamesIndex, &rtrn,
- &newMerge))
+ else if (ProcessIncludeFile(keymap->context, stmt, XkmKeyNamesIndex,
+ &rtrn, &newMerge))
{
InitKeyNamesInfo(&included);
- HandleKeycodesFile(rtrn, xkb, MergeOverride, &included);
+ HandleKeycodesFile(rtrn, keymap, MergeOverride, &included);
if (stmt->stmt != NULL)
{
free(included.name);
MergeIncludedKeycodes(&included, info, next->merge);
ClearKeyNamesInfo(info);
}
- else if (ProcessIncludeFile(xkb->context, next, XkmKeyNamesIndex,
- &rtrn, &op))
+ else if (ProcessIncludeFile(keymap->context, next,
+ XkmKeyNamesIndex, &rtrn, &op))
{
InitKeyNamesInfo(&next_incl);
- HandleKeycodesFile(rtrn, xkb, MergeOverride, &next_incl);
+ HandleKeycodesFile(rtrn, keymap, MergeOverride, &next_incl);
MergeIncludedKeycodes(&included, &next_incl, op);
ClearKeyNamesInfo(&next_incl);
FreeXKBFile(rtrn);
* e.g. <ESC> = 9
*/
static int
-HandleKeycodeDef(KeycodeDef * stmt, unsigned merge, KeyNamesInfo * info)
+HandleKeycodeDef(KeycodeDef *stmt, unsigned merge, KeyNamesInfo *info)
{
if ((info->explicitMin != 0 && stmt->value < info->explicitMin) ||
(info->explicitMax != 0 && stmt->value > info->explicitMax))
* @return 1 on success, 0 otherwise.
*/
static int
-HandleKeyNameVar(VarDef * stmt, KeyNamesInfo * info)
+HandleKeyNameVar(VarDef *stmt, KeyNamesInfo *info)
{
ExprResult tmp, field;
ExprDef *arrayNdx;
* @param info Struct to contain the fully parsed key information.
*/
static void
-HandleKeycodesFile(XkbFile * file,
- struct xkb_keymap * xkb, unsigned merge, KeyNamesInfo * info)
+HandleKeycodesFile(XkbFile *file, struct xkb_keymap *keymap,
+ unsigned merge, KeyNamesInfo *info)
{
ParseCommon *stmt;
switch (stmt->stmtType)
{
case StmtInclude: /* e.g. include "evdev+aliases(qwerty)" */
- if (!HandleIncludeKeycodes((IncludeStmt *) stmt, xkb, info))
+ if (!HandleIncludeKeycodes((IncludeStmt *) stmt, keymap, info))
info->errorCount++;
break;
case StmtKeycodeDef: /* e.g. <ESC> = 9; */
info->errorCount++;
break;
case StmtKeyAliasDef: /* e.g. alias <MENU> = <COMP>; */
- if (!HandleAliasDef((KeyAliasDef *) stmt,
- merge, info->fileID, &info->aliases))
+ if (!HandleAliasDef((KeyAliasDef *) stmt, merge, info->fileID,
+ &info->aliases))
info->errorCount++;
break;
case StmtVarDef: /* e.g. minimum, maximum */
break;
case StmtIndicatorNameDef: /* e.g. indicator 1 = "Caps Lock"; */
if (!HandleIndicatorNameDef((IndicatorNameDef *) stmt, info))
- {
info->errorCount++;
- }
break;
case StmtInterpDef:
case StmtVModDef:
* @return true on success, false otherwise.
*/
bool
-CompileKeycodes(XkbFile *file, struct xkb_keymap *xkb, unsigned merge)
+CompileKeycodes(XkbFile *file, struct xkb_keymap *keymap, unsigned merge)
{
KeyNamesInfo info; /* contains all the info after parsing */
InitKeyNamesInfo(&info);
- HandleKeycodesFile(file, xkb, merge, &info);
+ HandleKeycodesFile(file, keymap, merge, &info);
/* all the keys are now stored in info */
goto err_info;
if (info.explicitMin > 0) /* if "minimum" statement was present */
- xkb->min_key_code = info.explicitMin;
+ keymap->min_key_code = info.explicitMin;
else
- xkb->min_key_code = info.computedMin;
+ keymap->min_key_code = info.computedMin;
if (info.explicitMax > 0) /* if "maximum" statement was present */
- xkb->max_key_code = info.explicitMax;
+ keymap->max_key_code = info.explicitMax;
else
- xkb->max_key_code = info.computedMax;
+ keymap->max_key_code = info.computedMax;
- if (XkbcAllocNames(xkb, XkbKeyNamesMask | XkbIndicatorNamesMask, 0)
+ if (XkbcAllocNames(keymap, XkbKeyNamesMask | XkbIndicatorNamesMask, 0)
== Success) {
uint64_t i;
for (i = info.computedMin; i <= info.computedMax; i++)
- LongToKeyName(info.names[i], xkb->names->keys[i].name);
+ LongToKeyName(info.names[i], keymap->names->keys[i].name);
} else {
WSGO("Cannot create struct xkb_names in CompileKeycodes\n");
goto err_info;
if (info.leds) {
IndicatorNameInfo *ii;
- if (XkbcAllocIndicatorMaps(xkb) != Success) {
+ if (XkbcAllocIndicatorMaps(keymap) != Success) {
WSGO("Couldn't allocate IndicatorRec in CompileKeycodes\n");
ACTION("Physical indicators not set\n");
}
for (ii = info.leds; ii; ii = (IndicatorNameInfo *)ii->defs.next) {
- free(UNCONSTIFY(xkb->names->indicators[ii->ndx - 1]));
- xkb->names->indicators[ii->ndx - 1] = XkbcAtomGetString(ii->name);
+ free(UNCONSTIFY(keymap->names->indicators[ii->ndx - 1]));
+ keymap->names->indicators[ii->ndx - 1] = XkbcAtomGetString(ii->name);
}
}
- ApplyAliases(xkb, &info.aliases);
+ ApplyAliases(keymap, &info.aliases);
ClearKeyNamesInfo(&info);
return true;
unsigned mainType;
const char *mainName;
LEDInfo *unbound = NULL, *next;
- struct xkb_keymap *xkb = XkbcAllocKeyboard(context);
+ struct xkb_keymap *keymap = XkbcAllocKeyboard(context);
struct {
XkbFile *keycodes;
XkbFile *types;
XkbFile *symbols;
} sections;
- if (!xkb)
+ if (!keymap)
return NULL;
memset(§ions, 0, sizeof(sections));
/* compile the sections we have in the file one-by-one, or fail. */
if (sections.keycodes == NULL ||
- !CompileKeycodes(sections.keycodes, xkb, MergeOverride))
+ !CompileKeycodes(sections.keycodes, keymap, MergeOverride))
{
ERROR("Failed to compile keycodes\n");
goto err;
}
if (sections.types == NULL ||
- !CompileKeyTypes(sections.types, xkb, MergeOverride))
+ !CompileKeyTypes(sections.types, keymap, MergeOverride))
{
ERROR("Failed to compile key types\n");
goto err;
}
if (sections.compat == NULL ||
- !CompileCompatMap(sections.compat, xkb, MergeOverride, &unbound))
+ !CompileCompatMap(sections.compat, keymap, MergeOverride, &unbound))
{
ERROR("Failed to compile compat map\n");
goto err;
}
if (sections.symbols == NULL ||
- !CompileSymbols(sections.symbols, xkb, MergeOverride))
+ !CompileSymbols(sections.symbols, keymap, MergeOverride))
{
ERROR("Failed to compile symbols\n");
goto err;
}
- ok = BindIndicators(xkb, true, unbound, NULL);
+ ok = BindIndicators(keymap, true, unbound, NULL);
if (!ok)
goto err;
- ok = UpdateModifiersFromCompat(xkb);
+ ok = UpdateModifiersFromCompat(keymap);
if (!ok)
goto err;
- return xkb;
+ return keymap;
err:
ACTION("Failed to compile keymap\n");
- xkb_map_unref(xkb);
+ xkb_map_unref(keymap);
while (unbound) {
next = (LEDInfo *) unbound->defs.next;
free(unbound);
/***====================================================================***/
static void
-InitKeyTypesInfo(KeyTypesInfo * info, struct xkb_keymap * xkb, KeyTypesInfo * from)
+InitKeyTypesInfo(KeyTypesInfo *info, struct xkb_keymap *keymap,
+ KeyTypesInfo *from)
{
tok_ONE_LEVEL = xkb_intern_atom("ONE_LEVEL");
tok_TWO_LEVEL = xkb_intern_atom("TWO_LEVEL");
info->dflt.szNames = 0;
info->dflt.lvlNames = NULL;
info->dflt.preserve = NULL;
- InitVModInfo(&info->vmods, xkb);
+ InitVModInfo(&info->vmods, keymap);
if (from != NULL)
{
info->dflt = from->dflt;
}
static bool
-AddKeyType(struct xkb_keymap * xkb, KeyTypesInfo * info, KeyTypeInfo * new)
+AddKeyType(struct xkb_keymap *keymap, KeyTypesInfo *info, KeyTypeInfo *new)
{
KeyTypeInfo *old;
/***====================================================================***/
static void
-MergeIncludedKeyTypes(KeyTypesInfo * into,
- KeyTypesInfo * from, unsigned merge, struct xkb_keymap * xkb)
+MergeIncludedKeyTypes(KeyTypesInfo *into, KeyTypesInfo *from,
+ unsigned merge, struct xkb_keymap *keymap)
{
KeyTypeInfo *type;
{
if (merge != MergeDefault)
type->defs.merge = merge;
- if (!AddKeyType(xkb, into, type))
+ if (!AddKeyType(keymap, into, type))
into->errorCount++;
}
into->stdPresent |= from->stdPresent;
}
-typedef void (*FileHandler) (XkbFile *file, struct xkb_keymap *xkb,
+typedef void (*FileHandler) (XkbFile *file, struct xkb_keymap *keymap,
unsigned merge, KeyTypesInfo *included);
static bool
-HandleIncludeKeyTypes(IncludeStmt * stmt,
- struct xkb_keymap * xkb, KeyTypesInfo * info, FileHandler hndlr)
+HandleIncludeKeyTypes(IncludeStmt *stmt, struct xkb_keymap *keymap,
+ KeyTypesInfo *info, FileHandler hndlr)
{
unsigned newMerge;
XkbFile *rtrn;
included = *info;
memset(info, 0, sizeof(KeyTypesInfo));
}
- else if (ProcessIncludeFile(xkb->context, stmt, XkmTypesIndex, &rtrn,
+ else if (ProcessIncludeFile(keymap->context, stmt, XkmTypesIndex, &rtrn,
&newMerge))
{
- InitKeyTypesInfo(&included, xkb, info);
+ InitKeyTypesInfo(&included, keymap, info);
included.fileID = included.dflt.defs.fileID = rtrn->id;
included.dflt.defs.merge = newMerge;
- (*hndlr) (rtrn, xkb, newMerge, &included);
+ (*hndlr) (rtrn, keymap, newMerge, &included);
if (stmt->stmt != NULL)
{
free(included.name);
if ((next->file == NULL) && (next->map == NULL))
{
haveSelf = true;
- MergeIncludedKeyTypes(&included, info, next->merge, xkb);
+ MergeIncludedKeyTypes(&included, info, next->merge, keymap);
FreeKeyTypesInfo(info);
}
- else if (ProcessIncludeFile(xkb->context, next, XkmTypesIndex,
+ else if (ProcessIncludeFile(keymap->context, next, XkmTypesIndex,
&rtrn, &op))
{
- InitKeyTypesInfo(&next_incl, xkb, &included);
+ InitKeyTypesInfo(&next_incl, keymap, &included);
next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id;
next_incl.dflt.defs.merge = op;
- (*hndlr) (rtrn, xkb, op, &next_incl);
- MergeIncludedKeyTypes(&included, &next_incl, op, xkb);
+ (*hndlr) (rtrn, keymap, op, &next_incl);
+ MergeIncludedKeyTypes(&included, &next_incl, op, keymap);
FreeKeyTypesInfo(&next_incl);
FreeXKBFile(rtrn);
}
*info = included;
else
{
- MergeIncludedKeyTypes(info, &included, newMerge, xkb);
+ MergeIncludedKeyTypes(info, &included, newMerge, keymap);
FreeKeyTypesInfo(&included);
}
return (info->errorCount == 0);
}
static bool
-AddPreserve(struct xkb_keymap * xkb,
- KeyTypeInfo * type, PreserveInfo * new, bool clobber, bool report)
+AddPreserve(struct xkb_keymap *keymap, KeyTypeInfo *type,
+ PreserveInfo *new, bool clobber, bool report)
{
PreserveInfo *old;
if (warningLevel > 9)
{
WARN("Identical definitions for preserve[%s] in %s\n",
- PreserveIndexTxt(xkb, old), TypeTxt(type));
+ PreserveIndexTxt(keymap, old), TypeTxt(type));
ACTION("Ignored\n");
}
return true;
{
const char *str;
WARN("Multiple definitions for preserve[%s] in %s\n",
- PreserveIndexTxt(xkb, old), TypeTxt(type));
+ PreserveIndexTxt(keymap, old), TypeTxt(type));
if (clobber)
- str = PreserveTxt(xkb, new);
+ str = PreserveTxt(keymap, new);
else
- str = PreserveTxt(xkb, old);
+ str = PreserveTxt(keymap, old);
ACTION("Using %s, ", str);
if (clobber)
- str = PreserveTxt(xkb, old);
+ str = PreserveTxt(keymap, old);
else
- str = PreserveTxt(xkb, new);
+ str = PreserveTxt(keymap, new);
INFO("ignoring %s\n", str);
}
if (clobber)
if (!old)
{
WSGO("Couldn't allocate preserve in %s\n", TypeTxt(type));
- ACTION("Preserve[%s] lost\n", PreserveIndexTxt(xkb, new));
+ ACTION("Preserve[%s] lost\n", PreserveIndexTxt(keymap, new));
return false;
}
*old = *new;
* @param report true if a warning is to be printed on.
*/
static bool
-AddMapEntry(struct xkb_keymap * xkb,
- KeyTypeInfo * type,
- struct xkb_kt_map_entry * new, bool clobber, bool report)
+AddMapEntry(struct xkb_keymap *keymap, KeyTypeInfo *type,
+ struct xkb_kt_map_entry *new, bool clobber, bool report)
{
struct xkb_kt_map_entry * old;
ignore = new->level + 1;
}
WARN("Multiple map entries for %s in %s\n",
- MapEntryTxt(xkb, new), TypeTxt(type));
+ MapEntryTxt(keymap, new), TypeTxt(type));
ACTION("Using %d, ignoring %d\n", use, ignore);
}
else if (warningLevel > 9)
{
WARN("Multiple occurences of map[%s]= %d in %s\n",
- MapEntryTxt(xkb, new), new->level + 1, TypeTxt(type));
+ MapEntryTxt(keymap, new), new->level + 1, TypeTxt(type));
ACTION("Ignored\n");
return true;
}
}
static bool
-SetMapEntry(KeyTypeInfo * type,
- struct xkb_keymap * xkb, ExprDef * arrayNdx, ExprDef * value)
+SetMapEntry(KeyTypeInfo *type, struct xkb_keymap *keymap, ExprDef *arrayNdx,
+ ExprDef *value)
{
ExprResult rtrn;
struct xkb_kt_map_entry entry;
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(type, "map entry");
- if (!ExprResolveVModMask(arrayNdx, &rtrn, xkb))
+ if (!ExprResolveVModMask(arrayNdx, &rtrn, keymap))
return ReportTypeBadType(type, "map entry", "modifier mask");
entry.mods.real_mods = rtrn.uval & 0xff; /* modifiers < 512 */
entry.mods.vmods = (rtrn.uval >> 8) & 0xffff; /* modifiers > 512 */
{
WARN("Map entry for unused modifiers in %s\n", TypeTxt(type));
ACTION("Using %s instead of ",
- XkbcVModMaskText(xkb,
+ XkbcVModMaskText(keymap,
entry.mods.real_mods & type->mask,
entry.mods.vmods & type->vmask));
- INFO("%s\n", MapEntryTxt(xkb, &entry));
+ INFO("%s\n", MapEntryTxt(keymap, &entry));
}
entry.mods.real_mods &= type->mask;
entry.mods.vmods &= type->vmask;
return false;
}
entry.level = rtrn.ival - 1;
- return AddMapEntry(xkb, type, &entry, true, true);
+ return AddMapEntry(keymap, type, &entry, true, true);
}
static bool
-SetPreserve(KeyTypeInfo * type,
- struct xkb_keymap * xkb, ExprDef * arrayNdx, ExprDef * value)
+SetPreserve(KeyTypeInfo *type, struct xkb_keymap *keymap,
+ ExprDef *arrayNdx, ExprDef *value)
{
ExprResult rtrn;
PreserveInfo new;
if (arrayNdx == NULL)
return ReportTypeShouldBeArray(type, "preserve entry");
- if (!ExprResolveVModMask(arrayNdx, &rtrn, xkb))
+ if (!ExprResolveVModMask(arrayNdx, &rtrn, keymap))
return ReportTypeBadType(type, "preserve entry", "modifier mask");
new.defs = type->defs;
new.defs.next = NULL;
{
WARN("Preserve for modifiers not used by the %s type\n",
TypeTxt(type));
- ACTION("Index %s converted to ", PreserveIndexTxt(xkb, &new));
+ ACTION("Index %s converted to ", PreserveIndexTxt(keymap, &new));
}
new.indexMods &= type->mask;
new.indexVMods &= type->vmask;
if (warningLevel > 0)
- INFO("%s\n", PreserveIndexTxt(xkb, &new));
+ INFO("%s\n", PreserveIndexTxt(keymap, &new));
}
- if (!ExprResolveVModMask(value, &rtrn, xkb))
+ if (!ExprResolveVModMask(value, &rtrn, keymap))
{
ERROR("Preserve value in a key type is not a modifier mask\n");
ACTION("Ignoring preserve[%s] in type %s\n",
- PreserveIndexTxt(xkb, &new), TypeTxt(type));
+ PreserveIndexTxt(keymap, &new), TypeTxt(type));
return false;
}
new.preMods = rtrn.uval & 0xff;
if (warningLevel > 0)
{
WARN("Illegal value for preserve[%s] in type %s\n",
- PreserveTxt(xkb, &new), TypeTxt(type));
- ACTION("Converted %s to ", PreserveIndexTxt(xkb, &new));
+ PreserveTxt(keymap, &new), TypeTxt(type));
+ ACTION("Converted %s to ", PreserveIndexTxt(keymap, &new));
}
new.preMods &= new.indexMods;
new.preVMods &= new.indexVMods;
if (warningLevel > 0)
{
- INFO("%s\n", PreserveIndexTxt(xkb, &new));
+ INFO("%s\n", PreserveIndexTxt(keymap, &new));
}
}
- return AddPreserve(xkb, type, &new, true, true);
+ return AddPreserve(keymap, type, &new, true, true);
}
/***====================================================================***/
static bool
-AddLevelName(KeyTypeInfo * type,
- unsigned level, xkb_atom_t name, bool clobber)
+AddLevelName(KeyTypeInfo *type, unsigned level, xkb_atom_t name, bool clobber)
{
if ((type->lvlNames == NULL) || (type->szNames <= level))
{
* @param field The field to parse (e.g. modifiers, map, level_name)
*/
static bool
-SetKeyTypeField(KeyTypeInfo * type,
- struct xkb_keymap * xkb,
- char *field,
- ExprDef * arrayNdx, ExprDef * value, KeyTypesInfo * info)
+SetKeyTypeField(KeyTypeInfo *type, struct xkb_keymap *keymap,
+ char *field, ExprDef *arrayNdx, ExprDef *value,
+ KeyTypesInfo *info)
{
ExprResult tmp;
ACTION("Illegal array subscript ignored\n");
}
/* get modifier mask for current type */
- if (!ExprResolveVModMask(value, &tmp, xkb))
+ if (!ExprResolveVModMask(value, &tmp, keymap))
{
ERROR("Key type mask field must be a modifier mask\n");
ACTION("Key type definition ignored\n");
{
WARN("Multiple modifier mask definitions for key type %s\n",
XkbcAtomText(type->name));
- ACTION("Using %s, ", TypeMaskTxt(type, xkb));
- INFO("ignoring %s\n", XkbcVModMaskText(xkb, mods, vmods));
+ ACTION("Using %s, ", TypeMaskTxt(type, keymap));
+ INFO("ignoring %s\n", XkbcVModMaskText(keymap, mods, vmods));
return false;
}
type->mask = mods;
else if (strcasecmp(field, "map") == 0)
{
type->defs.defined |= _KT_Map;
- return SetMapEntry(type, xkb, arrayNdx, value);
+ return SetMapEntry(type, keymap, arrayNdx, value);
}
else if (strcasecmp(field, "preserve") == 0)
{
type->defs.defined |= _KT_Preserve;
- return SetPreserve(type, xkb, arrayNdx, value);
+ return SetPreserve(type, keymap, arrayNdx, value);
}
else if ((strcasecmp(field, "levelname") == 0) ||
(strcasecmp(field, "level_name") == 0))
}
static bool
-HandleKeyTypeVar(VarDef * stmt, struct xkb_keymap * xkb, KeyTypesInfo * info)
+HandleKeyTypeVar(VarDef *stmt, struct xkb_keymap *keymap, KeyTypesInfo *info)
{
ExprResult elem, field;
ExprDef *arrayNdx;
if (!ExprResolveLhs(stmt->name, &elem, &field, &arrayNdx))
return false; /* internal error, already reported */
if (elem.str && (strcasecmp(elem.str, "type") == 0))
- return SetKeyTypeField(&info->dflt, xkb, field.str, arrayNdx,
+ return SetKeyTypeField(&info->dflt, keymap, field.str, arrayNdx,
stmt->value, info);
if (elem.str != NULL)
{
}
static int
-HandleKeyTypeBody(VarDef * def,
- struct xkb_keymap * xkb, KeyTypeInfo * type, KeyTypesInfo * info)
+HandleKeyTypeBody(VarDef *def, struct xkb_keymap *keymap,
+ KeyTypeInfo *type, KeyTypesInfo *info)
{
int ok = 1;
ExprResult tmp, field;
{
if ((def->name) && (def->name->type == ExprFieldRef))
{
- ok = HandleKeyTypeVar(def, xkb, info);
+ ok = HandleKeyTypeVar(def, keymap, info);
continue;
}
ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);
if (ok) {
- ok = SetKeyTypeField(type, xkb, field.str, arrayNdx, def->value,
- info);
+ ok = SetKeyTypeField(type, keymap, field.str, arrayNdx,
+ def->value, info);
free(field.str);
}
}
*
*/
static int
-HandleKeyTypeDef(KeyTypeDef * def,
- struct xkb_keymap * xkb, unsigned merge, KeyTypesInfo * info)
+HandleKeyTypeDef(KeyTypeDef *def, struct xkb_keymap *keymap,
+ unsigned merge, KeyTypesInfo *info)
{
unsigned int i;
KeyTypeInfo type;
type.preserve = NULL;
/* Parse the actual content. */
- if (!HandleKeyTypeBody(def->body, xkb, &type, info))
+ if (!HandleKeyTypeBody(def->body, keymap, &type, info))
{
info->errorCount++;
return false;
if (((dflt->mods.real_mods & type.mask) == dflt->mods.real_mods) &&
((dflt->mods.vmods & type.vmask) == dflt->mods.vmods))
{
- AddMapEntry(xkb, &type, dflt, false, false);
+ AddMapEntry(keymap, &type, dflt, false, false);
}
}
if (info->dflt.preserve)
if (((dflt->indexMods & type.mask) == dflt->indexMods) &&
((dflt->indexVMods & type.vmask) == dflt->indexVMods))
{
- AddPreserve(xkb, &type, dflt, false, false);
+ AddPreserve(keymap, &type, dflt, false, false);
}
dflt = (PreserveInfo *) dflt->defs.next;
}
}
}
/* Now add the new keytype to the info struct */
- if (!AddKeyType(xkb, info, &type))
+ if (!AddKeyType(keymap, info, &type))
{
info->errorCount++;
return false;
* @param info Pointer to memory where the outcome will be stored.
*/
static void
-HandleKeyTypesFile(XkbFile * file,
- struct xkb_keymap * xkb, unsigned merge, KeyTypesInfo * info)
+HandleKeyTypesFile(XkbFile *file, struct xkb_keymap *keymap,
+ unsigned merge, KeyTypesInfo *info)
{
ParseCommon *stmt;
switch (stmt->stmtType)
{
case StmtInclude:
- if (!HandleIncludeKeyTypes((IncludeStmt *) stmt, xkb, info,
+ if (!HandleIncludeKeyTypes((IncludeStmt *) stmt, keymap, info,
HandleKeyTypesFile))
info->errorCount++;
break;
case StmtKeyTypeDef: /* e.g. type "ONE_LEVEL" */
- if (!HandleKeyTypeDef((KeyTypeDef *) stmt, xkb, merge, info))
+ if (!HandleKeyTypeDef((KeyTypeDef *) stmt, keymap, merge, info))
info->errorCount++;
break;
case StmtVarDef:
- if (!HandleKeyTypeVar((VarDef *) stmt, xkb, info))
+ if (!HandleKeyTypeVar((VarDef *) stmt, keymap, info))
info->errorCount++;
break;
case StmtVModDef: /* virtual_modifiers NumLock, ... */
- if (!HandleVModDef((VModDef *) stmt, xkb, merge, &info->vmods))
+ if (!HandleVModDef((VModDef *) stmt, keymap, merge, &info->vmods))
info->errorCount++;
break;
case StmtKeyAliasDef:
}
static bool
-CopyDefToKeyType(struct xkb_keymap * xkb, struct xkb_key_type * type, KeyTypeInfo * def)
+CopyDefToKeyType(struct xkb_keymap *keymap, struct xkb_key_type *type,
+ KeyTypeInfo *def)
{
unsigned int i;
PreserveInfo *pre;
tmp.mods.real_mods = pre->indexMods;
tmp.mods.vmods = pre->indexVMods;
tmp.level = 0;
- AddMapEntry(xkb, def, &tmp, false, false);
+ AddMapEntry(keymap, def, &tmp, false, false);
match = FindMatchingMapEntry(def, pre->indexMods, pre->indexVMods);
if (!match)
{
def->nEntries = def->szEntries = 0;
def->entries = NULL;
- return XkbcComputeEffectiveMap(xkb, type, NULL);
+ return XkbcComputeEffectiveMap(keymap, type, NULL);
}
bool
-CompileKeyTypes(XkbFile *file, struct xkb_keymap * xkb, unsigned merge)
+CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap, unsigned merge)
{
unsigned int i;
struct xkb_key_type *type, *next;
KeyTypesInfo info;
KeyTypeInfo *def;
- InitKeyTypesInfo(&info, xkb, NULL);
+ InitKeyTypesInfo(&info, keymap, NULL);
info.fileID = file->id;
- HandleKeyTypesFile(file, xkb, merge, &info);
+ HandleKeyTypesFile(file, keymap, merge, &info);
if (info.errorCount != 0)
goto err_info;
if ((info.stdPresent & XkbAlphabeticMask) == 0)
i++;
- if (XkbcAllocClientMap(xkb, XkbKeyTypesMask, i) != Success) {
+ if (XkbcAllocClientMap(keymap, XkbKeyTypesMask, i) != Success) {
WSGO("Couldn't allocate client map\n");
goto err_info;
}
- xkb->map->num_types = i;
+ keymap->map->num_types = i;
if (XkbAllRequiredTypes & (~info.stdPresent)) {
unsigned missing, keypadVMod;
missing = XkbAllRequiredTypes & (~info.stdPresent);
- keypadVMod = FindKeypadVMod(xkb);
+ keypadVMod = FindKeypadVMod(keymap);
- if (XkbcInitCanonicalKeyTypes(xkb, missing, keypadVMod) != Success) {
+ if (XkbcInitCanonicalKeyTypes(keymap, missing, keypadVMod) != Success) {
WSGO("Couldn't initialize canonical key types\n");
goto err_info;
}
if (missing & XkbOneLevelMask)
- xkb->map->types[XkbOneLevelIndex].name =
+ keymap->map->types[XkbOneLevelIndex].name =
XkbcAtomGetString(tok_ONE_LEVEL);
if (missing & XkbTwoLevelMask)
- xkb->map->types[XkbTwoLevelIndex].name =
+ keymap->map->types[XkbTwoLevelIndex].name =
XkbcAtomGetString(tok_TWO_LEVEL);
if (missing & XkbAlphabeticMask)
- xkb->map->types[XkbAlphabeticIndex].name =
+ keymap->map->types[XkbAlphabeticIndex].name =
XkbcAtomGetString(tok_ALPHABETIC);
if (missing & XkbKeypadMask)
- xkb->map->types[XkbKeypadIndex].name =
+ keymap->map->types[XkbKeypadIndex].name =
XkbcAtomGetString(tok_KEYPAD);
}
- next = &xkb->map->types[XkbLastRequiredType + 1];
+ next = &keymap->map->types[XkbLastRequiredType + 1];
for (i = 0, def = info.types; i < info.nTypes; i++) {
if (def->name == tok_ONE_LEVEL)
- type = &xkb->map->types[XkbOneLevelIndex];
+ type = &keymap->map->types[XkbOneLevelIndex];
else if (def->name == tok_TWO_LEVEL)
- type = &xkb->map->types[XkbTwoLevelIndex];
+ type = &keymap->map->types[XkbTwoLevelIndex];
else if (def->name == tok_ALPHABETIC)
- type = &xkb->map->types[XkbAlphabeticIndex];
+ type = &keymap->map->types[XkbAlphabeticIndex];
else if (def->name == tok_KEYPAD)
- type = &xkb->map->types[XkbKeypadIndex];
+ type = &keymap->map->types[XkbKeypadIndex];
else
type = next++;
DeleteLevel1MapEntries(def);
- if (!CopyDefToKeyType(xkb, type, def))
+ if (!CopyDefToKeyType(keymap, type, def))
goto err_info;
def = (KeyTypeInfo *)def->defs.next;
/**
* Find the key with the given name and return its keycode in kc_rtrn.
*
+ * @param keymap The keymap to search in.
* @param name The 4-letter name of the key as a long.
* @param kc_rtrn Set to the keycode if the key was found, otherwise 0.
* @param use_aliases true if the key aliases should be searched too.
* @param create If true and the key is not found, it is added to the
- * xkb->names at the first free keycode.
+ * keymap->names at the first free keycode.
* @param start_from Keycode to start searching from.
*
* @return true if found, false otherwise.
*/
bool
-FindNamedKey(struct xkb_keymap * xkb,
- unsigned long name,
- xkb_keycode_t *kc_rtrn,
- bool use_aliases, bool create, xkb_keycode_t start_from)
+FindNamedKey(struct xkb_keymap *keymap, unsigned long name,
+ xkb_keycode_t *kc_rtrn, bool use_aliases, bool create,
+ xkb_keycode_t start_from)
{
unsigned n;
- if (start_from < xkb->min_key_code)
+ if (start_from < keymap->min_key_code)
{
- start_from = xkb->min_key_code;
+ start_from = keymap->min_key_code;
}
- else if (start_from > xkb->max_key_code)
+ else if (start_from > keymap->max_key_code)
{
return false;
}
*kc_rtrn = 0; /* some callers rely on this */
- if (xkb && xkb->names && xkb->names->keys)
+ if (keymap && keymap->names && keymap->names->keys)
{
- for (n = start_from; n <= xkb->max_key_code; n++)
+ for (n = start_from; n <= keymap->max_key_code; n++)
{
unsigned long tmp;
- tmp = KeyNameToLong(xkb->names->keys[n].name);
+ tmp = KeyNameToLong(keymap->names->keys[n].name);
if (tmp == name)
{
*kc_rtrn = n;
if (use_aliases)
{
unsigned long new_name;
- if (FindKeyNameForAlias(xkb, name, &new_name))
- return FindNamedKey(xkb, new_name, kc_rtrn, false, create, 0);
+ if (FindKeyNameForAlias(keymap, name, &new_name))
+ return FindNamedKey(keymap, new_name, kc_rtrn, false,
+ create, 0);
}
}
if (create)
{
- if ((!xkb->names) || (!xkb->names->keys))
+ if ((!keymap->names) || (!keymap->names->keys))
{
- if (XkbcAllocNames(xkb, XkbKeyNamesMask, 0) != Success)
+ if (XkbcAllocNames(keymap, XkbKeyNamesMask, 0) != Success)
{
if (warningLevel > 0)
{
}
}
/* Find first unused keycode and store our key here */
- for (n = xkb->min_key_code; n <= xkb->max_key_code; n++)
+ for (n = keymap->min_key_code; n <= keymap->max_key_code; n++)
{
- if (xkb->names->keys[n].name[0] == '\0')
+ if (keymap->names->keys[n].name[0] == '\0')
{
char buf[XkbKeyNameLength + 1];
LongToKeyName(name, buf);
- memcpy(xkb->names->keys[n].name, buf, XkbKeyNameLength);
+ memcpy(keymap->names->keys[n].name, buf, XkbKeyNameLength);
*kc_rtrn = n;
return true;
}
}
bool
-FindKeyNameForAlias(struct xkb_keymap * xkb, unsigned long lname,
+FindKeyNameForAlias(struct xkb_keymap *keymap, unsigned long lname,
unsigned long *real_name)
{
unsigned int i;
char name[XkbKeyNameLength + 1];
- if (xkb && xkb->names && xkb->names->key_aliases)
+ if (keymap && keymap->names && keymap->names->key_aliases)
{
struct xkb_key_alias * a;
- a = xkb->names->key_aliases;
+ a = keymap->names->key_aliases;
LongToKeyName(lname, name);
name[XkbKeyNameLength] = '\0';
- for (i = 0; i < xkb->names->num_key_aliases; i++, a++)
+ for (i = 0; i < keymap->names->num_key_aliases; i++, a++)
{
if (strncmp(name, a->alias, XkbKeyNameLength) == 0)
{
} SymbolsInfo;
static void
-InitSymbolsInfo(SymbolsInfo * info, struct xkb_keymap * xkb)
+InitSymbolsInfo(SymbolsInfo * info, struct xkb_keymap *keymap)
{
int i;
for (i = 0; i < XkbNumKbdGroups; i++)
info->groupNames[i] = XKB_ATOM_NONE;
InitKeyInfo(&info->dflt);
- InitVModInfo(&info->vmods, xkb);
+ InitVModInfo(&info->vmods, keymap);
info->action = NULL;
info->aliases = NULL;
}
}
static bool
-AddKeySymbols(SymbolsInfo * info, KeyInfo * key, struct xkb_keymap * xkb)
+AddKeySymbols(SymbolsInfo *info, KeyInfo *key, struct xkb_keymap *keymap)
{
unsigned int i;
unsigned long real_name;
if (info->keys[i].name == key->name)
return MergeKeys(info, &info->keys[i], key);
}
- if (FindKeyNameForAlias(xkb, key->name, &real_name))
+ if (FindKeyNameForAlias(keymap, key->name, &real_name))
{
for (i = 0; i < info->nKeys; i++)
{
/***====================================================================***/
static void
-MergeIncludedSymbols(SymbolsInfo * into, SymbolsInfo * from,
- unsigned merge, struct xkb_keymap * xkb)
+MergeIncludedSymbols(SymbolsInfo *into, SymbolsInfo *from,
+ unsigned merge, struct xkb_keymap *keymap)
{
unsigned int i;
KeyInfo *key;
{
if (merge != MergeDefault)
key->defs.merge = merge;
- if (!AddKeySymbols(into, key, xkb))
+ if (!AddKeySymbols(into, key, keymap))
into->errorCount++;
}
if (from->modMap != NULL)
into->errorCount++;
}
-typedef void (*FileHandler) (XkbFile *rtrn, struct xkb_keymap *xkb,
+typedef void (*FileHandler) (XkbFile *rtrn, struct xkb_keymap *keymap,
unsigned merge, SymbolsInfo *included);
static bool
-HandleIncludeSymbols(IncludeStmt * stmt,
- struct xkb_keymap * xkb, SymbolsInfo * info, FileHandler hndlr)
+HandleIncludeSymbols(IncludeStmt *stmt, struct xkb_keymap *keymap,
+ SymbolsInfo *info, FileHandler hndlr)
{
unsigned newMerge;
XkbFile *rtrn;
included = *info;
memset(info, 0, sizeof(SymbolsInfo));
}
- else if (ProcessIncludeFile(xkb->context, stmt, XkmSymbolsIndex, &rtrn,
- &newMerge))
+ else if (ProcessIncludeFile(keymap->context, stmt, XkmSymbolsIndex,
+ &rtrn, &newMerge))
{
- InitSymbolsInfo(&included, xkb);
+ InitSymbolsInfo(&included, keymap);
included.fileID = included.dflt.defs.fileID = rtrn->id;
included.merge = included.dflt.defs.merge = MergeOverride;
if (stmt->modifier)
{
included.explicit_group = info->explicit_group;
}
- (*hndlr) (rtrn, xkb, MergeOverride, &included);
+ (*hndlr) (rtrn, keymap, MergeOverride, &included);
if (stmt->stmt != NULL)
{
free(included.name);
if ((next->file == NULL) && (next->map == NULL))
{
haveSelf = true;
- MergeIncludedSymbols(&included, info, next->merge, xkb);
+ MergeIncludedSymbols(&included, info, next->merge, keymap);
FreeSymbolsInfo(info);
}
- else if (ProcessIncludeFile(xkb->context, next, XkmSymbolsIndex,
- &rtrn, &op))
+ else if (ProcessIncludeFile(keymap->context, next,
+ XkmSymbolsIndex, &rtrn, &op))
{
- InitSymbolsInfo(&next_incl, xkb);
+ InitSymbolsInfo(&next_incl, keymap);
next_incl.fileID = next_incl.dflt.defs.fileID = rtrn->id;
next_incl.merge = next_incl.dflt.defs.merge = MergeOverride;
if (next->modifier)
{
next_incl.explicit_group = info->explicit_group;
}
- (*hndlr) (rtrn, xkb, MergeOverride, &next_incl);
- MergeIncludedSymbols(&included, &next_incl, op, xkb);
+ (*hndlr) (rtrn, keymap, MergeOverride, &next_incl);
+ MergeIncludedSymbols(&included, &next_incl, op, keymap);
FreeSymbolsInfo(&next_incl);
FreeXKBFile(rtrn);
}
*info = included;
else
{
- MergeIncludedSymbols(info, &included, newMerge, xkb);
+ MergeIncludedSymbols(info, &included, newMerge, keymap);
FreeSymbolsInfo(&included);
}
return (info->errorCount == 0);
}
static bool
-AddSymbolsToKey(KeyInfo * key,
- struct xkb_keymap * xkb,
- ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
+AddSymbolsToKey(KeyInfo *key, struct xkb_keymap *keymap,
+ ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info)
{
unsigned ndx, nSyms, nLevels;
unsigned int i;
}
static bool
-AddActionsToKey(KeyInfo * key,
- struct xkb_keymap * xkb,
- ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
+AddActionsToKey(KeyInfo *key, struct xkb_keymap *keymap, ExprDef *arrayNdx,
+ ExprDef *value, SymbolsInfo *info)
{
unsigned int i;
unsigned ndx, nActs;
act = value->value.child;
for (i = 0; i < nActs; i++, toAct++)
{
- if (!HandleActionDef(act, xkb, toAct, info->action))
+ if (!HandleActionDef(act, keymap, toAct, info->action))
{
ERROR("Illegal action definition for %s\n",
longText(key->name));
};
static bool
-SetSymbolsField(KeyInfo * key,
- struct xkb_keymap * xkb,
- char *field,
- ExprDef * arrayNdx, ExprDef * value, SymbolsInfo * info)
+SetSymbolsField(KeyInfo *key, struct xkb_keymap *keymap, char *field,
+ ExprDef *arrayNdx, ExprDef *value, SymbolsInfo *info)
{
bool ok = true;
ExprResult tmp;
free(tmp.str);
}
else if (strcasecmp(field, "symbols") == 0)
- return AddSymbolsToKey(key, xkb, arrayNdx, value, info);
+ return AddSymbolsToKey(key, keymap, arrayNdx, value, info);
else if (strcasecmp(field, "actions") == 0)
- return AddActionsToKey(key, xkb, arrayNdx, value, info);
+ return AddActionsToKey(key, keymap, arrayNdx, value, info);
else if ((strcasecmp(field, "vmods") == 0) ||
(strcasecmp(field, "virtualmods") == 0) ||
(strcasecmp(field, "virtualmodifiers") == 0))
{
- ok = ExprResolveVModMask(value, &tmp, xkb);
+ ok = ExprResolveVModMask(value, &tmp, keymap);
if (ok)
{
key->vmodmap = (tmp.uval >> 8);
}
static int
-HandleSymbolsVar(VarDef * stmt, struct xkb_keymap * xkb, SymbolsInfo * info)
+HandleSymbolsVar(VarDef *stmt, struct xkb_keymap *keymap, SymbolsInfo *info)
{
ExprResult elem, field, tmp;
ExprDef *arrayNdx;
return 0; /* internal error, already reported */
if (elem.str && (strcasecmp(elem.str, "key") == 0))
{
- ret = SetSymbolsField(&info->dflt, xkb, field.str, arrayNdx,
+ ret = SetSymbolsField(&info->dflt, keymap, field.str, arrayNdx,
stmt->value, info);
}
else if ((elem.str == NULL) && ((strcasecmp(field.str, "name") == 0) ||
ret = false;
}
else {
- ret = SetActionField(xkb, elem.str, field.str, arrayNdx, stmt->value,
- &info->action);
+ ret = SetActionField(keymap, elem.str, field.str, arrayNdx,
+ stmt->value, &info->action);
}
free(elem.str);
}
static bool
-HandleSymbolsBody(VarDef * def,
- struct xkb_keymap * xkb, KeyInfo * key, SymbolsInfo * info)
+HandleSymbolsBody(VarDef *def, struct xkb_keymap *keymap, KeyInfo *key,
+ SymbolsInfo *info)
{
bool ok = true;
ExprResult tmp, field;
{
if ((def->name) && (def->name->type == ExprFieldRef))
{
- ok = HandleSymbolsVar(def, xkb, info);
+ ok = HandleSymbolsVar(def, keymap, info);
continue;
}
else
ok = ExprResolveLhs(def->name, &tmp, &field, &arrayNdx);
}
if (ok)
- ok = SetSymbolsField(key, xkb, field.str, arrayNdx,
+ ok = SetSymbolsField(key, keymap, field.str, arrayNdx,
def->value, info);
free(field.str);
}
}
static bool
-SetExplicitGroup(SymbolsInfo * info, KeyInfo * key)
+SetExplicitGroup(SymbolsInfo *info, KeyInfo *key)
{
unsigned group = info->explicit_group;
}
static int
-HandleSymbolsDef(SymbolsDef * stmt,
- struct xkb_keymap *xkb, SymbolsInfo *info)
+HandleSymbolsDef(SymbolsDef *stmt, struct xkb_keymap *keymap,
+ SymbolsInfo *info)
{
KeyInfo key;
CopyKeyInfo(&info->dflt, &key, false);
key.defs.merge = stmt->merge;
key.name = KeyNameToLong(stmt->keyName);
- if (!HandleSymbolsBody((VarDef *) stmt->symbols, xkb, &key, info))
+ if (!HandleSymbolsBody((VarDef *) stmt->symbols, keymap, &key, info))
{
info->errorCount++;
return false;
return false;
}
- if (!AddKeySymbols(info, &key, xkb))
+ if (!AddKeySymbols(info, &key, keymap))
{
info->errorCount++;
return false;
}
static bool
-HandleModMapDef(ModMapDef * def,
- struct xkb_keymap * xkb, SymbolsInfo * info)
+HandleModMapDef(ModMapDef *def, struct xkb_keymap *keymap, SymbolsInfo *info)
{
ExprDef *key;
ModMapEntry tmp;
}
static void
-HandleSymbolsFile(XkbFile * file,
- struct xkb_keymap * xkb, unsigned merge, SymbolsInfo * info)
+HandleSymbolsFile(XkbFile *file, struct xkb_keymap *keymap,
+ unsigned merge, SymbolsInfo *info)
{
ParseCommon *stmt;
switch (stmt->stmtType)
{
case StmtInclude:
- if (!HandleIncludeSymbols((IncludeStmt *) stmt, xkb, info,
+ if (!HandleIncludeSymbols((IncludeStmt *) stmt, keymap, info,
HandleSymbolsFile))
info->errorCount++;
break;
case StmtSymbolsDef:
- if (!HandleSymbolsDef((SymbolsDef *) stmt, xkb, info))
+ if (!HandleSymbolsDef((SymbolsDef *) stmt, keymap, info))
info->errorCount++;
break;
case StmtVarDef:
- if (!HandleSymbolsVar((VarDef *) stmt, xkb, info))
+ if (!HandleSymbolsVar((VarDef *) stmt, keymap, info))
info->errorCount++;
break;
case StmtVModDef:
- if (!HandleVModDef((VModDef *) stmt, xkb, merge, &info->vmods))
+ if (!HandleVModDef((VModDef *) stmt, keymap, merge, &info->vmods))
info->errorCount++;
break;
case StmtInterpDef:
info->errorCount++;
break;
case StmtModMapDef:
- if (!HandleModMapDef((ModMapDef *) stmt, xkb, info))
+ if (!HandleModMapDef((ModMapDef *) stmt, keymap, info))
info->errorCount++;
break;
default:
}
static bool
-FindKeyForSymbol(struct xkb_keymap * xkb, xkb_keysym_t sym, xkb_keycode_t *kc_rtrn)
+FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym,
+ xkb_keycode_t *kc_rtrn)
{
xkb_keycode_t key;
unsigned int group, level;
- for (key = xkb->min_key_code; key <= xkb->max_key_code; key++)
+ for (key = keymap->min_key_code; key <= keymap->max_key_code; key++)
{
- for (group = 0; group < XkbKeyNumGroups(xkb, key); group++)
+ for (group = 0; group < XkbKeyNumGroups(keymap, key); group++)
{
- for (level = 0; level < XkbKeyGroupWidth(xkb, key, group); level++)
+ for (level = 0; level < XkbKeyGroupWidth(keymap, key, group);
+ level++)
{
- if (XkbKeyNumSyms(xkb, key, group, level) != 1 ||
- (XkbKeySymEntry(xkb, key, group, level))[0] != sym)
+ if (XkbKeyNumSyms(keymap, key, group, level) != 1 ||
+ (XkbKeySymEntry(keymap, key, group, level))[0] != sym)
continue;
*kc_rtrn = key;
return true;
* @return true if found, false otherwise.
*/
static bool
-FindNamedType(struct xkb_keymap * xkb, xkb_atom_t atom, unsigned *type_rtrn)
+FindNamedType(struct xkb_keymap *keymap, xkb_atom_t atom, unsigned *type_rtrn)
{
unsigned n;
const char *name = XkbcAtomText(atom);
- if (xkb && xkb->map && xkb->map->types)
+ if (keymap && keymap->map && keymap->map->types)
{
- for (n = 0; n < xkb->map->num_types; n++)
+ for (n = 0; n < keymap->map->num_types; n++)
{
- if (strcmp(xkb->map->types[n].name, name) == 0)
+ if (strcmp(keymap->map->types[n].name, name) == 0)
{
*type_rtrn = n;
return true;
* This function recurses.
*/
static bool
-CopySymbolsDef(struct xkb_keymap * xkb, KeyInfo *key, int start_from)
+CopySymbolsDef(struct xkb_keymap *keymap, KeyInfo *key, int start_from)
{
unsigned int i;
xkb_keycode_t kc;
useAlias = (start_from == 0);
/* get the keycode for the key. */
- if (!FindNamedKey(xkb, key->name, &kc, useAlias, CreateKeyNames(xkb),
- start_from))
+ if (!FindNamedKey(keymap, key->name, &kc, useAlias,
+ CreateKeyNames(keymap), start_from))
{
if ((start_from == 0) && (warningLevel >= 5))
{
}
}
}
- if (FindNamedType(xkb, key->types[i], &types[i]))
+ if (FindNamedType(keymap, key->types[i], &types[i]))
{
if (!autoType || key->numLevels[i] > 2)
- xkb->server->explicit[kc] |= (1 << i);
+ keymap->server->explicit[kc] |= (1 << i);
}
else
{
types[i] = XkbTwoLevelIndex;
}
/* if the type specifies fewer levels than the key has, shrink the key */
- type = &xkb->map->types[types[i]];
+ type = &keymap->map->types[types[i]];
if (type->num_levels < key->numLevels[i])
{
if (warningLevel > 0)
sizeSyms += key->sizeSyms[i];
}
- if (!XkbcResizeKeySyms(xkb, kc, sizeSyms))
+ if (!XkbcResizeKeySyms(keymap, kc, sizeSyms))
{
WSGO("Could not enlarge symbols for %s (keycode %d)\n",
longText(key->name), kc);
}
if (haveActions)
{
- outActs = XkbcResizeKeyActions(xkb, kc, width * nGroups);
+ outActs = XkbcResizeKeyActions(keymap, kc, width * nGroups);
if (outActs == NULL)
{
WSGO("Could not enlarge actions for %s (key %d)\n",
longText(key->name), kc);
return false;
}
- xkb->server->explicit[kc] |= XkbExplicitInterpretMask;
+ keymap->server->explicit[kc] |= XkbExplicitInterpretMask;
}
else
outActs = NULL;
if (key->defs.defined & _Key_GroupInfo)
i = key->groupInfo;
else
- i = xkb->map->key_sym_map[kc].group_info;
-
- xkb->map->key_sym_map[kc].group_info = XkbSetNumGroups(i, nGroups);
- xkb->map->key_sym_map[kc].width = width;
- xkb->map->key_sym_map[kc].sym_index = uTypedCalloc(nGroups * width, int);
- xkb->map->key_sym_map[kc].num_syms = uTypedCalloc(nGroups * width,
- unsigned int);
+ i = keymap->map->key_sym_map[kc].group_info;
+
+ keymap->map->key_sym_map[kc].group_info = XkbSetNumGroups(i, nGroups);
+ keymap->map->key_sym_map[kc].width = width;
+ keymap->map->key_sym_map[kc].sym_index = uTypedCalloc(nGroups * width,
+ int);
+ keymap->map->key_sym_map[kc].num_syms = uTypedCalloc(nGroups * width,
+ unsigned int);
for (i = 0; i < nGroups; i++)
{
/* assign kt_index[i] to the index of the type in map->types.
* FIXME: There should be a better fix for this.
*/
if (key->numLevels[i])
- xkb->map->key_sym_map[kc].kt_index[i] = types[i];
+ keymap->map->key_sym_map[kc].kt_index[i] = types[i];
if (key->sizeSyms[i] != 0)
{
/* fill key to "width" symbols*/
{
if (tmp < key->numLevels[i] && key->symsMapNumEntries[i][tmp])
{
- memcpy(&xkb->map->key_sym_map[kc].syms[symIndex],
+ memcpy(&keymap->map->key_sym_map[kc].syms[symIndex],
&key->syms[i][key->symsMapIndex[i][tmp]],
key->symsMapNumEntries[i][tmp] *
sizeof(xkb_keysym_t));
- xkb->map->key_sym_map[kc].sym_index[(i * width) + tmp] =
+ keymap->map->key_sym_map[kc].sym_index[(i * width) + tmp] =
symIndex;
- xkb->map->key_sym_map[kc].num_syms[(i * width) + tmp] =
+ keymap->map->key_sym_map[kc].num_syms[(i * width) + tmp] =
key->symsMapNumEntries[i][tmp];
symIndex +=
- xkb->map->key_sym_map[kc].num_syms[(i * width) + tmp];
+ keymap->map->key_sym_map[kc].num_syms[(i * width) + tmp];
}
else
{
- xkb->map->key_sym_map[kc].sym_index[(i * width) + tmp] = -1;
- xkb->map->key_sym_map[kc].num_syms[(i * width) + tmp] = 0;
+ keymap->map->key_sym_map[kc].sym_index[(i * width) + tmp] = -1;
+ keymap->map->key_sym_map[kc].num_syms[(i * width) + tmp] = 0;
}
if ((outActs != NULL) && (key->acts[i] != NULL))
{
case XkbKB_Default:
break;
default:
- xkb->server->behaviors[kc] = key->behavior;
- xkb->server->explicit[kc] |= XkbExplicitBehaviorMask;
+ keymap->server->behaviors[kc] = key->behavior;
+ keymap->server->explicit[kc] |= XkbExplicitBehaviorMask;
break;
}
if (key->defs.defined & _Key_VModMap)
{
- xkb->server->vmodmap[kc] = key->vmodmap;
- xkb->server->explicit[kc] |= XkbExplicitVModMapMask;
+ keymap->server->vmodmap[kc] = key->vmodmap;
+ keymap->server->explicit[kc] |= XkbExplicitVModMapMask;
}
if (key->repeat != RepeatUndefined)
{
if (key->repeat == RepeatYes)
- xkb->ctrls->per_key_repeat[kc / 8] |= (1 << (kc % 8));
+ keymap->ctrls->per_key_repeat[kc / 8] |= (1 << (kc % 8));
else
- xkb->ctrls->per_key_repeat[kc / 8] &= ~(1 << (kc % 8));
- xkb->server->explicit[kc] |= XkbExplicitAutoRepeatMask;
+ keymap->ctrls->per_key_repeat[kc / 8] &= ~(1 << (kc % 8));
+ keymap->server->explicit[kc] |= XkbExplicitAutoRepeatMask;
}
- if (nGroups > xkb->ctrls->num_groups)
- xkb->ctrls->num_groups = nGroups;
+ if (nGroups > keymap->ctrls->num_groups)
+ keymap->ctrls->num_groups = nGroups;
/* do the same thing for the next key */
- CopySymbolsDef(xkb, key, kc + 1);
+ CopySymbolsDef(keymap, key, kc + 1);
return true;
}
static bool
-CopyModMapDef(struct xkb_keymap * xkb, ModMapEntry *entry)
+CopyModMapDef(struct xkb_keymap *keymap, ModMapEntry *entry)
{
xkb_keycode_t kc;
- if ((!entry->haveSymbol)
- &&
- (!FindNamedKey
- (xkb, entry->u.keyName, &kc, true, CreateKeyNames(xkb), 0)))
+ if (!entry->haveSymbol &&
+ !FindNamedKey(keymap, entry->u.keyName, &kc, true,
+ CreateKeyNames(keymap), 0))
{
if (warningLevel >= 5)
{
}
return false;
}
- else if (entry->haveSymbol
- && (!FindKeyForSymbol(xkb, entry->u.keySym, &kc)))
+ else if (entry->haveSymbol &&
+ !FindKeyForSymbol(keymap, entry->u.keySym, &kc))
{
if (warningLevel > 5)
{
}
return false;
}
- xkb->map->modmap[kc] |= (1 << entry->modifier);
+ keymap->map->modmap[kc] |= (1 << entry->modifier);
return true;
}
* Handle the xkb_symbols section of an xkb file.
*
* @param file The parsed xkb_symbols section of the xkb file.
- * @param xkb Handle to the keyboard description to store the symbols in.
+ * @param keymap Handle to the keyboard description to store the symbols in.
* @param merge Merge strategy (e.g. MergeOverride).
*/
bool
-CompileSymbols(XkbFile *file, struct xkb_keymap *xkb, unsigned merge)
+CompileSymbols(XkbFile *file, struct xkb_keymap *keymap, unsigned merge)
{
unsigned int i;
SymbolsInfo info;
KeyInfo *key;
- InitSymbolsInfo(&info, xkb);
+ InitSymbolsInfo(&info, keymap);
info.dflt.defs.fileID = file->id;
info.dflt.defs.merge = merge;
- HandleSymbolsFile(file, xkb, merge, &info);
+ HandleSymbolsFile(file, keymap, merge, &info);
if (info.nKeys == 0)
goto err_info;
goto err_info;
/* alloc memory in the xkb struct */
- if (XkbcAllocNames(xkb, XkbGroupNamesMask, 0) != Success) {
+ if (XkbcAllocNames(keymap, XkbGroupNamesMask, 0) != Success) {
WSGO("Can not allocate names in CompileSymbols\n");
ACTION("Symbols not added\n");
goto err_info;
}
- if (XkbcAllocClientMap(xkb, XkbKeySymsMask | XkbModifierMapMask, 0)
+ if (XkbcAllocClientMap(keymap, XkbKeySymsMask | XkbModifierMapMask, 0)
!= Success) {
WSGO("Could not allocate client map in CompileSymbols\n");
ACTION("Symbols not added\n");
goto err_info;
}
- if (XkbcAllocServerMap(xkb, XkbAllServerInfoMask, 32) != Success) {
+ if (XkbcAllocServerMap(keymap, XkbAllServerInfoMask, 32) != Success) {
WSGO("Could not allocate server map in CompileSymbols\n");
ACTION("Symbols not added\n");
goto err_info;
}
- if (XkbcAllocControls(xkb) != Success) {
+ if (XkbcAllocControls(keymap) != Success) {
WSGO("Could not allocate controls in CompileSymbols\n");
ACTION("Symbols not added\n");
goto err_info;
}
/* now copy info into xkb. */
- ApplyAliases(xkb, &info.aliases);
+ ApplyAliases(keymap, &info.aliases);
for (i = 0; i < XkbNumKbdGroups; i++) {
if (info.groupNames[i] != XKB_ATOM_NONE) {
- free(UNCONSTIFY(xkb->names->groups[i]));
- xkb->names->groups[i] = XkbcAtomGetString(info.groupNames[i]);
+ free(UNCONSTIFY(keymap->names->groups[i]));
+ keymap->names->groups[i] = XkbcAtomGetString(info.groupNames[i]);
}
}
/* copy! */
for (key = info.keys, i = 0; i < info.nKeys; i++, key++)
- if (!CopySymbolsDef(xkb, key, 0))
+ if (!CopySymbolsDef(keymap, key, 0))
info.errorCount++;
if (warningLevel > 3) {
- for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) {
- if (xkb->names->keys[i].name[0] == '\0')
+ for (i = keymap->min_key_code; i <= keymap->max_key_code; i++) {
+ if (keymap->names->keys[i].name[0] == '\0')
continue;
- if (XkbKeyNumGroups(xkb, i) < 1) {
+ if (XkbKeyNumGroups(keymap, i) < 1) {
char buf[5];
- memcpy(buf, xkb->names->keys[i].name, 4);
+ memcpy(buf, keymap->names->keys[i].name, 4);
buf[4] = '\0';
WARN("No symbols defined for <%s> (keycode %d)\n", buf, i);
}
if (info.modMap) {
ModMapEntry *mm, *next;
for (mm = info.modMap; mm != NULL; mm = next) {
- if (!CopyModMapDef(xkb, mm))
+ if (!CopyModMapDef(keymap, mm))
info.errorCount++;
- next = (ModMapEntry *)mm->defs.next;
+ next = (ModMapEntry *) mm->defs.next;
}
}
#include "vmod.h"
void
-InitVModInfo(VModInfo * info, struct xkb_keymap * xkb)
+InitVModInfo(VModInfo *info, struct xkb_keymap *keymap)
{
- ClearVModInfo(info, xkb);
+ ClearVModInfo(info, keymap);
info->errorCount = 0;
}
void
-ClearVModInfo(VModInfo * info, struct xkb_keymap * xkb)
+ClearVModInfo(VModInfo *info, struct xkb_keymap *keymap)
{
int i;
info->newlyDefined = info->defined = info->available = 0;
- if (XkbcAllocNames(xkb, 0, 0) != Success)
+ if (XkbcAllocNames(keymap, 0, 0) != Success)
return;
- if (XkbcAllocServerMap(xkb, 0, 0) != Success)
+ if (XkbcAllocServerMap(keymap, 0, 0) != Success)
return;
- info->xkb = xkb;
- if (xkb && xkb->names)
+ info->keymap = keymap;
+ if (keymap && keymap->names)
{
int bit;
for (i = 0, bit = 1; i < XkbNumVirtualMods; i++, bit <<= 1)
{
- if (xkb->names->vmods[i] != NULL)
+ if (keymap->names->vmods[i] != NULL)
info->defined |= bit;
}
}
* @param mergeMode Merge strategy (e.g. MergeOverride)
*/
bool
-HandleVModDef(VModDef * stmt, struct xkb_keymap *xkb, unsigned mergeMode,
- VModInfo * info)
+HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap, unsigned mergeMode,
+ VModInfo *info)
{
int i, bit, nextFree;
ExprResult mod;
- struct xkb_server_map * srv;
- struct xkb_names * names;
+ struct xkb_server_map *srv = keymap->server;
+ struct xkb_names *names = keymap->names;
- srv = xkb->server;
- names = xkb->names;
for (i = 0, bit = 1, nextFree = -1; i < XkbNumVirtualMods; i++, bit <<= 1)
{
if (info->defined & bit)
/**
* Returns the index of the given modifier in the xkb->names->vmods array.
*
- * @param priv Pointer to the xkb data structure.
+ * @param keymap Pointer to the xkb data structure.
* @param field The Atom of the modifier's name (e.g. Atom for LAlt)
* @param type Must be TypeInt, otherwise return false.
* @param val_rtrn Set to the index of the modifier that matches.
* undefined.
*/
static int
-LookupVModIndex(const struct xkb_keymap *xkb, xkb_atom_t field, unsigned type,
- ExprResult * val_rtrn)
+LookupVModIndex(const struct xkb_keymap *keymap, xkb_atom_t field,
+ unsigned type, ExprResult * val_rtrn)
{
int i;
const char *name = XkbcAtomText(field);
- if ((xkb == NULL) || (xkb->names == NULL) || (type != TypeInt))
+ if ((keymap == NULL) || (keymap->names == NULL) || (type != TypeInt))
{
return false;
}
*/
for (i = 0; i < XkbNumVirtualMods; i++)
{
- if (xkb->names->vmods[i] && strcmp(xkb->names->vmods[i], name) == 0)
+ if (keymap->names->vmods[i] &&
+ strcmp(keymap->names->vmods[i], name) == 0)
{
val_rtrn->uval = i;
return true;
}
int
-FindKeypadVMod(struct xkb_keymap * xkb)
+FindKeypadVMod(struct xkb_keymap *keymap)
{
xkb_atom_t name;
ExprResult rtrn;
name = xkb_intern_atom("NumLock");
- if ((xkb) && LookupVModIndex(xkb, name, TypeInt, &rtrn))
+ if (keymap && LookupVModIndex(keymap, name, TypeInt, &rtrn))
{
return rtrn.ival;
}
}
bool
-ResolveVirtualModifier(ExprDef * def, struct xkb_keymap *xkb,
- ExprResult * val_rtrn, VModInfo * info)
+ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
+ ExprResult *val_rtrn, VModInfo *info)
{
- struct xkb_names * names;
+ struct xkb_names *names = keymap->names;
- names = xkb->names;
if (def->op == ExprIdent)
{
int i, bit;
typedef struct _VModInfo
{
- struct xkb_keymap *xkb;
+ struct xkb_keymap *keymap;
unsigned defined;
unsigned available;
unsigned newlyDefined;
} VModInfo;
extern void
-InitVModInfo(VModInfo *info, struct xkb_keymap *xkb);
+InitVModInfo(VModInfo *info, struct xkb_keymap *keymap);
extern void
-ClearVModInfo(VModInfo *info, struct xkb_keymap *xkb);
+ClearVModInfo(VModInfo *info, struct xkb_keymap *keymap);
extern bool
-HandleVModDef(VModDef *stmt, struct xkb_keymap *xkb, unsigned mergeMode,
+HandleVModDef(VModDef *stmt, struct xkb_keymap *keymap, unsigned mergeMode,
VModInfo *info);
extern bool
-ApplyVModDefs(VModInfo *info, struct xkb_keymap *xkb);
+ApplyVModDefs(VModInfo *info, struct xkb_keymap *keymap);
extern int
-FindKeypadVMod(struct xkb_keymap *xkb);
+FindKeypadVMod(struct xkb_keymap *keymap);
extern bool
-ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *xkb,
+ResolveVirtualModifier(ExprDef *def, struct xkb_keymap *keymap,
ExprResult *value_rtrn, VModInfo *info);
#endif /* VMOD_H */
unsigned *merge_rtrn);
extern bool
-FindNamedKey(struct xkb_keymap *xkb, unsigned long name, xkb_keycode_t *kc_rtrn,
- bool use_aliases, bool create, xkb_keycode_t start_from);
+FindNamedKey(struct xkb_keymap *keymap, unsigned long name,
+ xkb_keycode_t *kc_rtrn, bool use_aliases, bool create,
+ xkb_keycode_t start_from);
extern bool
-FindKeyNameForAlias(struct xkb_keymap *xkb, unsigned long lname,
+FindKeyNameForAlias(struct xkb_keymap *keymap, unsigned long lname,
unsigned long *real_name);
extern bool
-UpdateModifiersFromCompat(struct xkb_keymap *xkb);
+UpdateModifiersFromCompat(struct xkb_keymap *keymap);
extern const char *
XkbDirectoryForInclude(unsigned type);
{
XkbRF_VarDefsRec defs;
struct xkb_component_names *names;
- struct xkb_keymap *xkb;
+ struct xkb_keymap *keymap;
if (!rmlvo || ISEMPTY(rmlvo->rules) || ISEMPTY(rmlvo->layout)) {
ERROR("rules and layout required to generate XKB keymap\n");
return NULL;
}
- xkb = xkb_map_new_from_kccgst(context, names, 0);
+ keymap = xkb_map_new_from_kccgst(context, names, 0);
free(names->keymap);
free(names->keycodes);
free(names->symbols);
free(names);
- return xkb;
+ return keymap;
}
static XkbFile *
compile_keymap(struct xkb_context *context, XkbFile *file)
{
XkbFile *mapToUse;
- struct xkb_keymap * xkb = NULL;
+ struct xkb_keymap *keymap = NULL;
/* Find map to use */
mapToUse = XkbChooseMap(file, NULL);
goto err;
}
- xkb = CompileKeymap(context, mapToUse);
- if (!xkb)
+ keymap = CompileKeymap(context, mapToUse);
+ if (!keymap)
goto err;
err:
FreeXKBFile(file);
XkbcFreeAllAtoms();
- return xkb;
+ return keymap;
}
_X_EXPORT struct xkb_keymap *
}
_X_EXPORT struct xkb_keymap *
-xkb_map_ref(struct xkb_keymap *xkb)
+xkb_map_ref(struct xkb_keymap *keymap)
{
- xkb->refcnt++;
- return xkb;
+ keymap->refcnt++;
+ return keymap;
}
_X_EXPORT void
-xkb_map_unref(struct xkb_keymap *xkb)
+xkb_map_unref(struct xkb_keymap *keymap)
{
- if (--xkb->refcnt > 0)
+ if (--keymap->refcnt > 0)
return;
- XkbcFreeKeyboard(xkb);
+ XkbcFreeKeyboard(keymap);
}
CompileKeymap(struct xkb_context *context, XkbFile *file);
extern bool
-CompileKeycodes(XkbFile *file, struct xkb_keymap * xkb, unsigned merge);
+CompileKeycodes(XkbFile *file, struct xkb_keymap *keymap, unsigned merge);
extern bool
-CompileKeyTypes(XkbFile *file, struct xkb_keymap * xkb, unsigned merge);
+CompileKeyTypes(XkbFile *file, struct xkb_keymap *keymap, unsigned merge);
typedef struct _LEDInfo *LEDInfoPtr;
extern bool
-CompileCompatMap(XkbFile *file, struct xkb_keymap * xkb, unsigned merge,
+CompileCompatMap(XkbFile *file, struct xkb_keymap *keymap, unsigned merge,
LEDInfoPtr *unboundLEDs);
extern bool
-CompileSymbols(XkbFile *file, struct xkb_keymap * xkb, unsigned merge);
+CompileSymbols(XkbFile *file, struct xkb_keymap *keymap, unsigned merge);
#endif /* XKBCOMP_H */
{
int fd;
struct xkb_context *context;
- struct xkb_keymap *xkb;
+ struct xkb_keymap *keymap;
fd = open(path, O_RDONLY);
assert(fd >= 0);
fprintf(stderr, "\nCompiling path: %s\n", path);
- xkb = xkb_map_new_from_fd(context, fd, XKB_KEYMAP_FORMAT_TEXT_V1, 0);
+ keymap = xkb_map_new_from_fd(context, fd, XKB_KEYMAP_FORMAT_TEXT_V1, 0);
close(fd);
- if (!xkb) {
+ if (!keymap) {
fprintf(stderr, "Failed to compile keymap\n");
xkb_context_unref(context);
return 0;
}
- xkb_map_unref(xkb);
+ xkb_map_unref(keymap);
xkb_context_unref(context);
return 1;
}
test_string(const char *string)
{
struct xkb_context *context;
- struct xkb_keymap *xkb;
+ struct xkb_keymap *keymap;
context = xkb_context_new(0);
assert(context);
fprintf(stderr, "\nCompiling string\n");
- xkb = xkb_map_new_from_string(context, string, XKB_KEYMAP_FORMAT_TEXT_V1, 0);
- if (!xkb) {
+ keymap = xkb_map_new_from_string(context, string,
+ XKB_KEYMAP_FORMAT_TEXT_V1, 0);
+ if (!keymap) {
xkb_context_unref(context);
return 0;
}
- xkb_map_unref(xkb);
+ xkb_map_unref(keymap);
xkb_context_unref(context);
return 1;
}
{
int ret = 1;
struct xkb_context *context;
- struct xkb_keymap *xkb;
+ struct xkb_keymap *keymap;
struct xkb_component_names kccgst = {
.keymap = NULL,
.keycodes = strdup(keycodes),
fprintf(stderr, "\nCompiling %s %s %s %s\n", kccgst.keycodes, kccgst.types,
kccgst.compat, kccgst.symbols);
- xkb = xkb_map_new_from_kccgst(context, &kccgst, 0);
- if (!xkb) {
+ keymap = xkb_map_new_from_kccgst(context, &kccgst, 0);
+ if (!keymap) {
ret = 0;
goto err_ctx;
}
- xkb_map_unref(xkb);
+ xkb_map_unref(keymap);
err_ctx:
xkb_context_unref(context);
free(kccgst.keycodes);
const char *variant, const char *options)
{
struct xkb_context *context;
- struct xkb_keymap *xkb;
+ struct xkb_keymap *keymap;
struct xkb_rule_names rmlvo = {
.rules = rules,
.model = model,
fprintf(stderr, "\nCompiling %s %s %s %s %s\n", rmlvo.rules, rmlvo.model,
rmlvo.layout, rmlvo.variant, rmlvo.options);
- xkb = xkb_map_new_from_names(context, &rmlvo, 0);
- if (!xkb) {
+ keymap = xkb_map_new_from_names(context, &rmlvo, 0);
+ if (!keymap) {
xkb_context_unref(context);
return 0;
}
- xkb_map_unref(xkb);
+ xkb_map_unref(keymap);
xkb_context_unref(context);
return 1;
}
return;
}
- for (group = 0; group < xkb_map_num_groups(state->xkb); group++) {
+ for (group = 0; group < xkb_map_num_groups(state->keymap); group++) {
if (!xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE))
continue;
fprintf(stderr, "\tgroup %s (%d): %s%s%s%s\n",
- xkb_map_group_get_name(state->xkb, group),
+ xkb_map_group_get_name(state->keymap, group),
group,
xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE) ?
"effective " : "",
"locked " : "");
}
- for (mod = 0; mod < xkb_map_num_mods(state->xkb); mod++) {
+ for (mod = 0; mod < xkb_map_num_mods(state->keymap); mod++) {
if (!xkb_state_mod_index_is_active(state, mod, XKB_STATE_EFFECTIVE))
continue;
fprintf(stderr, "\tmod %s (%d): %s%s%s\n",
- xkb_map_mod_get_name(state->xkb, mod),
+ xkb_map_mod_get_name(state->keymap, mod),
mod,
xkb_state_mod_index_is_active(state, mod, XKB_STATE_DEPRESSED) ?
"depressed " : "",
"locked " : "");
}
- for (led = 0; led < xkb_map_num_leds(state->xkb); led++) {
+ for (led = 0; led < xkb_map_num_leds(state->keymap); led++) {
if (!xkb_state_led_index_is_active(state, led))
continue;
fprintf(stderr, "\tled %s (%d): active\n",
- xkb_map_led_get_name(state->xkb, led),
+ xkb_map_led_get_name(state->keymap, led),
led);
}
}
static void
-test_update_key(struct xkb_keymap *xkb)
+test_update_key(struct xkb_keymap *keymap)
{
- struct xkb_state *state = xkb_state_new(xkb);
+ struct xkb_state *state = xkb_state_new(keymap);
const xkb_keysym_t *syms;
int num_syms;
}
static void
-test_serialisation(struct xkb_keymap *xkb)
+test_serialisation(struct xkb_keymap *keymap)
{
- struct xkb_state *state = xkb_state_new(xkb);
+ struct xkb_state *state = xkb_state_new(keymap);
xkb_mod_mask_t base_mods;
xkb_mod_mask_t latched_mods;
xkb_mod_mask_t locked_mods;
assert(state);
- caps = xkb_map_mod_get_index(state->xkb, XKB_MOD_NAME_CAPS);
+ caps = xkb_map_mod_get_index(state->keymap, XKB_MOD_NAME_CAPS);
assert(caps != XKB_MOD_INVALID);
- shift = xkb_map_mod_get_index(state->xkb, XKB_MOD_NAME_SHIFT);
+ shift = xkb_map_mod_get_index(state->keymap, XKB_MOD_NAME_SHIFT);
assert(shift != XKB_MOD_INVALID);
- ctrl = xkb_map_mod_get_index(state->xkb, XKB_MOD_NAME_CTRL);
+ ctrl = xkb_map_mod_get_index(state->keymap, XKB_MOD_NAME_CTRL);
assert(ctrl != XKB_MOD_INVALID);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
main(void)
{
struct xkb_context *context;
- struct xkb_keymap *xkb;
+ struct xkb_keymap *keymap;
struct xkb_rule_names rmlvo = {
.rules = "evdev",
.model = "pc104",
context = xkb_context_new(0);
assert(context);
- xkb = xkb_map_new_from_names(context, &rmlvo, 0);
- assert(xkb);
+ keymap = xkb_map_new_from_names(context, &rmlvo, 0);
+ assert(keymap);
- test_update_key(xkb);
- test_serialisation(xkb);
+ test_update_key(keymap);
+ test_serialisation(keymap);
- xkb_map_unref(xkb);
+ xkb_map_unref(keymap);
xkb_context_unref(context);
}
projects / platform / upstream / libxkbcommon.git / commitdiff