Signed-off-by: Ran Benita <ran234@gmail.com>
21 files changed:
static bool
write_keysyms(struct xkb_keymap *keymap, struct buf *buf,
static bool
write_keysyms(struct xkb_keymap *keymap, struct buf *buf,
- struct xkb_key *key, xkb_group_index_t group)
+ struct xkb_key *key, xkb_layout_index_t group)
{
const xkb_keysym_t *syms;
int num_syms;
{
const xkb_keysym_t *syms;
int num_syms;
write_symbols(struct xkb_keymap *keymap, struct buf *buf)
{
struct xkb_key *key;
write_symbols(struct xkb_keymap *keymap, struct buf *buf)
{
struct xkb_key *key;
- xkb_group_index_t group, tmp;
+ xkb_layout_index_t group, tmp;
bool showActions;
if (keymap->symbols_section_name)
bool showActions;
if (keymap->symbols_section_name)
-xkb_map_get_as_string(struct xkb_keymap *keymap)
+xkb_keymap_get_as_string(struct xkb_keymap *keymap)
{
bool ok;
struct buf buf = { NULL, 0, 0 };
{
bool ok;
struct buf buf = { NULL, 0, 0 };
- if (idx >= xkb_map_num_mods(keymap))
+ if (idx >= xkb_keymap_num_mods(keymap))
return NULL;
/* First try to find a legacy modifier name. If that fails, try to
return NULL;
/* First try to find a legacy modifier name. If that fails, try to
xkb_layout_index_t i;
if (atom == XKB_ATOM_NONE)
xkb_layout_index_t i;
if (atom == XKB_ATOM_NONE)
- return XKB_GROUP_INVALID;
+ return XKB_LAYOUT_INVALID;
for (i = 0; i < num_groups; i++)
if (keymap->group_names[i] == atom)
return i;
for (i = 0; i < num_groups; i++)
if (keymap->group_names[i] == atom)
return i;
- return XKB_GROUP_INVALID;
+ return XKB_LAYOUT_INVALID;
XKB_EXPORT const char *
xkb_keymap_led_get_name(struct xkb_keymap *keymap, xkb_led_index_t idx)
{
XKB_EXPORT const char *
xkb_keymap_led_get_name(struct xkb_keymap *keymap, xkb_led_index_t idx)
{
- if (idx >= xkb_map_num_leds(keymap))
+ if (idx >= xkb_keymap_num_leds(keymap))
return NULL;
return xkb_atom_text(keymap->ctx, keymap->indicators[idx].name);
return NULL;
return xkb_atom_text(keymap->ctx, keymap->indicators[idx].name);
/**
* Returns the index for a named group.
*/
/**
* Returns the index for a named group.
*/
-XKB_EXPORT xkb_group_index_t
+XKB_EXPORT xkb_layout_index_t
xkb_keymap_led_get_index(struct xkb_keymap *keymap, const char *name)
{
xkb_keymap_led_get_index(struct xkb_keymap *keymap, const char *name)
{
- xkb_led_index_t num_leds = xkb_map_num_leds(keymap);
+ xkb_led_index_t num_leds = xkb_keymap_num_leds(keymap);
xkb_atom_t atom = xkb_atom_lookup(keymap->ctx, name);
xkb_led_index_t i;
xkb_atom_t atom = xkb_atom_lookup(keymap->ctx, name);
xkb_led_index_t i;
static struct xkb_kt_map_entry *
get_entry_for_key_state(struct xkb_state *state, const struct xkb_key *key,
static struct xkb_kt_map_entry *
get_entry_for_key_state(struct xkb_state *state, const struct xkb_key *key,
- xkb_group_index_t group)
+ xkb_layout_index_t group)
{
struct xkb_key_type *type;
xkb_mod_mask_t active_mods;
unsigned int i;
{
struct xkb_key_type *type;
xkb_mod_mask_t active_mods;
unsigned int i;
- type = XkbKeyType(xkb_state_get_map(state), key, group);
+ type = XkbKeyType(xkb_state_get_keymap(state), key, group);
active_mods = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
active_mods &= type->mods.mask;
active_mods = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
active_mods &= type->mods.mask;
xkb_state_key_get_syms(struct xkb_state *state, xkb_keycode_t kc,
const xkb_keysym_t **syms_out)
{
xkb_state_key_get_syms(struct xkb_state *state, xkb_keycode_t kc,
const xkb_keysym_t **syms_out)
{
- struct xkb_keymap *keymap = xkb_state_get_map(state);
+ struct xkb_keymap *keymap = xkb_state_get_keymap(state);
xkb_layout_index_t layout;
xkb_level_index_t level;
const struct xkb_key *key = XkbKey(keymap, kc);
xkb_layout_index_t layout;
xkb_level_index_t level;
const struct xkb_key *key = XkbKey(keymap, kc);
key_get_consumed(struct xkb_state *state, const struct xkb_key *key)
{
struct xkb_kt_map_entry *entry;
key_get_consumed(struct xkb_state *state, const struct xkb_key *key)
{
struct xkb_kt_map_entry *entry;
- xkb_group_index_t group;
+ xkb_layout_index_t group;
group = xkb_state_key_get_layout(state, key->keycode);
group = xkb_state_key_get_layout(state, key->keycode);
- if (group == XKB_GROUP_INVALID)
+ if (group == XKB_LAYOUT_INVALID)
return 0;
entry = get_entry_for_key_state(state, key, group);
return 0;
entry = get_entry_for_key_state(state, key, group);
xkb_state_mod_index_is_consumed(struct xkb_state *state, xkb_keycode_t kc,
xkb_mod_index_t idx)
{
xkb_state_mod_index_is_consumed(struct xkb_state *state, xkb_keycode_t kc,
xkb_mod_index_t idx)
{
- const struct xkb_key *key = XkbKey(xkb_state_get_map(state), kc);
+ const struct xkb_key *key = XkbKey(xkb_state_get_keymap(state), kc);
xkb_state_mod_mask_remove_consumed(struct xkb_state *state, xkb_keycode_t kc,
xkb_mod_mask_t mask)
{
xkb_state_mod_mask_remove_consumed(struct xkb_state *state, xkb_keycode_t kc,
xkb_mod_mask_t mask)
{
- const struct xkb_key *key = XkbKey(xkb_state_get_map(state), kc);
+ const struct xkb_key *key = XkbKey(xkb_state_get_keymap(state), kc);
#ifndef MAP_H
#define MAP_H
#ifndef MAP_H
#define MAP_H
+ /* Don't use compat names in internal code. */
+#define _XKBCOMMON_COMPAT_H
#include "xkbcommon/xkbcommon.h"
#include "xkbcommon/xkbcommon.h"
#include "utils.h"
#include "context.h"
#include "utils.h"
#include "context.h"
- xkb_group_index_t base_group; /**< depressed */
- xkb_group_index_t latched_group;
- xkb_group_index_t locked_group;
- xkb_group_index_t group; /**< effective */
+ xkb_layout_index_t base_group; /**< depressed */
+ xkb_layout_index_t latched_group;
+ xkb_layout_index_t locked_group;
+ xkb_layout_index_t group; /**< effective */
xkb_mod_mask_t base_mods; /**< depressed */
xkb_mod_mask_t latched_mods;
xkb_mod_mask_t base_mods; /**< depressed */
xkb_mod_mask_t latched_mods;
return NULL;
ret->refcnt = 1;
return NULL;
ret->refcnt = 1;
- ret->keymap = xkb_map_ref(keymap);
+ ret->keymap = xkb_keymap_ref(keymap);
if (--state->refcnt > 0)
return;
if (--state->refcnt > 0)
return;
- xkb_map_unref(state->keymap);
+ xkb_keymap_unref(state->keymap);
darray_free(state->filters);
free(state);
}
XKB_EXPORT struct xkb_keymap *
darray_free(state->filters);
free(state);
}
XKB_EXPORT struct xkb_keymap *
-xkb_state_get_map(struct xkb_state *state)
+xkb_state_get_keymap(struct xkb_state *state)
{
return state->keymap;
}
{
return state->keymap;
}
xkb_mod_mask_t base_mods,
xkb_mod_mask_t latched_mods,
xkb_mod_mask_t locked_mods,
xkb_mod_mask_t base_mods,
xkb_mod_mask_t latched_mods,
xkb_mod_mask_t locked_mods,
- xkb_group_index_t base_group,
- xkb_group_index_t latched_group,
- xkb_group_index_t locked_group)
+ xkb_layout_index_t base_group,
+ xkb_layout_index_t latched_group,
+ xkb_layout_index_t locked_group)
{
xkb_mod_index_t num_mods;
xkb_mod_index_t idx;
{
xkb_mod_index_t num_mods;
xkb_mod_index_t idx;
state->base_mods = 0;
state->latched_mods = 0;
state->locked_mods = 0;
state->base_mods = 0;
state->latched_mods = 0;
state->locked_mods = 0;
- num_mods = xkb_map_num_mods(state->keymap);
+ num_mods = xkb_keymap_num_mods(state->keymap);
for (idx = 0; idx < num_mods; idx++) {
xkb_mod_mask_t mod = (1 << idx);
for (idx = 0; idx < num_mods; idx++) {
xkb_mod_mask_t mod = (1 << idx);
* Serialises the requested group state, with all the same disclaimers as
* in xkb_state_update_mask.
*/
* Serialises the requested group state, with all the same disclaimers as
* in xkb_state_update_mask.
*/
-XKB_EXPORT xkb_group_index_t
-xkb_state_serialize_group(struct xkb_state *state,
- enum xkb_state_component type)
+XKB_EXPORT xkb_layout_index_t
+xkb_state_serialize_layout(struct xkb_state *state,
+ enum xkb_state_component type)
- xkb_group_index_t ret = 0;
+ xkb_layout_index_t ret = 0;
if (type == XKB_STATE_EFFECTIVE)
return state->group;
if (type == XKB_STATE_EFFECTIVE)
return state->group;
- if (idx >= xkb_map_num_mods(state->keymap))
+ if (idx >= xkb_keymap_num_mods(state->keymap))
return -1;
if (type & XKB_STATE_DEPRESSED)
return -1;
if (type & XKB_STATE_DEPRESSED)
xkb_mod_index_t idx = 0;
uint32_t wanted = 0;
int ret = 0;
xkb_mod_index_t idx = 0;
uint32_t wanted = 0;
int ret = 0;
- xkb_mod_index_t num_mods = xkb_map_num_mods(state->keymap);
+ xkb_mod_index_t num_mods = xkb_keymap_num_mods(state->keymap);
va_start(ap, match);
while (1) {
va_start(ap, match);
while (1) {
xkb_state_mod_name_is_active(struct xkb_state *state, const char *name,
enum xkb_state_component type)
{
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->keymap, name);
+ xkb_mod_index_t idx = xkb_keymap_mod_get_index(state->keymap, name);
if (idx == XKB_MOD_INVALID)
return -1;
if (idx == XKB_MOD_INVALID)
return -1;
str = va_arg(ap, const char *);
if (str == NULL)
break;
str = va_arg(ap, const char *);
if (str == NULL)
break;
- idx = xkb_map_mod_get_index(state->keymap, str);
+ idx = xkb_keymap_mod_get_index(state->keymap, str);
if (idx == XKB_MOD_INVALID) {
ret = -1;
break;
if (idx == XKB_MOD_INVALID) {
ret = -1;
break;
* not, or -1 if the group is invalid.
*/
XKB_EXPORT int
* not, or -1 if the group is invalid.
*/
XKB_EXPORT int
-xkb_state_group_index_is_active(struct xkb_state *state,
- xkb_group_index_t idx,
+xkb_state_layout_index_is_active(struct xkb_state *state,
+ xkb_layout_index_t idx,
enum xkb_state_component type)
{
int ret = 0;
enum xkb_state_component type)
{
int ret = 0;
- if (idx >= xkb_map_num_groups(state->keymap))
+ if (idx >= xkb_keymap_num_layouts(state->keymap))
return -1;
if (type & XKB_STATE_DEPRESSED)
return -1;
if (type & XKB_STATE_DEPRESSED)
* not, or -1 if the modifier is invalid.
*/
XKB_EXPORT int
* not, or -1 if the modifier is invalid.
*/
XKB_EXPORT int
-xkb_state_group_name_is_active(struct xkb_state *state, const char *name,
- enum xkb_state_component type)
+xkb_state_layout_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->keymap, name);
+ xkb_layout_index_t idx = xkb_keymap_layout_get_index(state->keymap, name);
- if (idx == XKB_GROUP_INVALID)
+ if (idx == XKB_LAYOUT_INVALID)
- return xkb_state_group_index_is_active(state, idx, type);
+ return xkb_state_layout_index_is_active(state, idx, type);
XKB_EXPORT int
xkb_state_led_index_is_active(struct xkb_state *state, xkb_led_index_t idx)
{
XKB_EXPORT int
xkb_state_led_index_is_active(struct xkb_state *state, xkb_led_index_t idx)
{
- if (idx >= xkb_map_num_leds(state->keymap))
+ if (idx >= xkb_keymap_num_leds(state->keymap))
return -1;
return !!(state->leds & (1 << idx));
return -1;
return !!(state->leds & (1 << idx));
XKB_EXPORT int
xkb_state_led_name_is_active(struct xkb_state *state, const char *name)
{
XKB_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->keymap, name);
+ xkb_led_index_t idx = xkb_keymap_led_get_index(state->keymap, name);
if (idx == XKB_LED_INVALID)
return -1;
if (idx == XKB_LED_INVALID)
return -1;
static bool
CheckGroupField(struct xkb_keymap *keymap, unsigned action,
const ExprDef *value, enum xkb_action_flags *flags_inout,
static bool
CheckGroupField(struct xkb_keymap *keymap, unsigned action,
const ExprDef *value, enum xkb_action_flags *flags_inout,
- xkb_group_index_t *grp_rtrn)
+ xkb_layout_index_t *grp_rtrn)
{
struct xkb_group_action *act = &action->group;
enum xkb_action_flags rtrn, t1;
{
struct xkb_group_action *act = &action->group;
enum xkb_action_flags rtrn, t1;
if (array_ndx != NULL) {
switch (field) {
if (array_ndx != NULL) {
switch (field) {
{
struct xkb_group_action *act = &action->group;
enum xkb_action_flags t1;
{
struct xkb_group_action *act = &action->group;
enum xkb_action_flags t1;
if ((array_ndx != NULL) && (field == ACTION_FIELD_GROUP))
return ReportActionNotArray(keymap, action->type, field);
if ((array_ndx != NULL) && (field == ACTION_FIELD_GROUP))
return ReportActionNotArray(keymap, action->type, field);
bool
ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
bool
ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
- xkb_group_index_t *group_rtrn)
+ xkb_layout_index_t *group_rtrn)
- *group_rtrn = (xkb_group_index_t) result;
+ *group_rtrn = (xkb_layout_index_t) result;
bool
ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
bool
ExprResolveGroup(struct xkb_context *ctx, const ExprDef *expr,
- xkb_group_index_t *group_rtrn);
+ xkb_layout_index_t *group_rtrn);
bool
ExprResolveButton(struct xkb_context *ctx, const ExprDef *expr,
bool
ExprResolveButton(struct xkb_context *ctx, const ExprDef *expr,
*/
static struct xkb_sym_interpret *
FindInterpForKey(struct xkb_keymap *keymap, struct xkb_key *key,
*/
static struct xkb_sym_interpret *
FindInterpForKey(struct xkb_keymap *keymap, struct xkb_key *key,
- xkb_group_index_t group, xkb_level_index_t level)
+ xkb_layout_index_t group, xkb_level_index_t level)
{
struct xkb_sym_interpret *interp;
const xkb_keysym_t *syms;
{
struct xkb_sym_interpret *interp;
const xkb_keysym_t *syms;
ApplyInterpsToKey(struct xkb_keymap *keymap, struct xkb_key *key)
{
xkb_mod_mask_t vmodmask = 0;
ApplyInterpsToKey(struct xkb_keymap *keymap, struct xkb_key *key)
{
xkb_mod_mask_t vmodmask = 0;
- xkb_group_index_t group;
+ xkb_layout_index_t group;
xkb_level_index_t width, level;
/* If we've been told not to bind interps to this key, then don't. */
xkb_level_index_t width, level;
/* If we've been told not to bind interps to this key, then don't. */
int mlvo_at_pos[_MLVO_NUM_ENTRIES];
unsigned int num_mlvo;
unsigned int defined_mlvo_mask;
int mlvo_at_pos[_MLVO_NUM_ENTRIES];
unsigned int num_mlvo;
unsigned int defined_mlvo_mask;
- xkb_group_index_t layout_idx, variant_idx;
+ xkb_layout_index_t layout_idx, variant_idx;
int kccgst_at_pos[_KCCGST_NUM_ENTRIES];
unsigned int num_kccgst;
unsigned int defined_kccgst_mask;
int kccgst_at_pos[_KCCGST_NUM_ENTRIES];
unsigned int num_kccgst;
unsigned int defined_kccgst_mask;
m->mapping.mlvo_at_pos[i] = -1;
for (i = 0; i < _KCCGST_NUM_ENTRIES; i++)
m->mapping.kccgst_at_pos[i] = -1;
m->mapping.mlvo_at_pos[i] = -1;
for (i = 0; i < _KCCGST_NUM_ENTRIES; i++)
m->mapping.kccgst_at_pos[i] = -1;
- m->mapping.layout_idx = m->mapping.variant_idx = XKB_GROUP_INVALID;
+ m->mapping.layout_idx = m->mapping.variant_idx = XKB_LAYOUT_INVALID;
m->mapping.num_mlvo = m->mapping.num_kccgst = 0;
m->mapping.defined_mlvo_mask = 0;
m->mapping.defined_kccgst_mask = 0;
m->mapping.num_mlvo = m->mapping.num_kccgst = 0;
m->mapping.defined_mlvo_mask = 0;
m->mapping.defined_kccgst_mask = 0;
-extract_group_index(const char *s, size_t max_len, xkb_group_index_t *out)
+extract_layout_index(const char *s, size_t max_len, xkb_layout_index_t *out)
{
/* This function is pretty stupid, but works for now. */
if (max_len < 3)
{
/* This function is pretty stupid, but works for now. */
if (max_len < 3)
{
enum rules_mlvo mlvo;
struct sval mlvo_sval;
{
enum rules_mlvo mlvo;
struct sval mlvo_sval;
+ xkb_layout_index_t idx;
int consumed;
for (mlvo = 0; mlvo < _MLVO_NUM_ENTRIES; mlvo++) {
int consumed;
for (mlvo = 0; mlvo < _MLVO_NUM_ENTRIES; mlvo++) {
/* If there are leftovers still, it must be an index. */
if (mlvo_sval.len < ident.len) {
/* If there are leftovers still, it must be an index. */
if (mlvo_sval.len < ident.len) {
- consumed = extract_group_index(ident.start + mlvo_sval.len,
+ consumed = extract_layout_index(ident.start + mlvo_sval.len,
ident.len - mlvo_sval.len, &idx);
if ((int) (ident.len - mlvo_sval.len) != consumed) {
matcher_error(m,
ident.len - mlvo_sval.len, &idx);
if ((int) (ident.len - mlvo_sval.len) != consumed) {
matcher_error(m,
*/
if (m->mapping.defined_mlvo_mask & (1 << MLVO_LAYOUT)) {
*/
if (m->mapping.defined_mlvo_mask & (1 << MLVO_LAYOUT)) {
- if (m->mapping.layout_idx == XKB_GROUP_INVALID) {
+ if (m->mapping.layout_idx == XKB_LAYOUT_INVALID) {
if (darray_size(m->rmlvo.layouts) > 1)
goto skip;
}
if (darray_size(m->rmlvo.layouts) > 1)
goto skip;
}
}
if (m->mapping.defined_mlvo_mask & (1 << MLVO_VARIANT)) {
}
if (m->mapping.defined_mlvo_mask & (1 << MLVO_VARIANT)) {
- if (m->mapping.variant_idx == XKB_GROUP_INVALID) {
+ if (m->mapping.variant_idx == XKB_LAYOUT_INVALID) {
if (darray_size(m->rmlvo.variants) > 1)
goto skip;
}
if (darray_size(m->rmlvo.variants) > 1)
goto skip;
}
unsigned int i;
size_t original_size = darray_size(*to);
const char *s = value.start;
unsigned int i;
size_t original_size = darray_size(*to);
const char *s = value.start;
+ xkb_layout_index_t idx;
int consumed;
enum rules_mlvo mlv;
struct sval expanded;
int consumed;
enum rules_mlvo mlv;
struct sval expanded;
- consumed = extract_group_index(s + i, value.len - i, &idx);
+ consumed = extract_layout_index(s + i, value.len - i, &idx);
if (consumed == -1) goto error;
i += consumed;
}
else {
if (consumed == -1) goto error;
i += consumed;
}
else {
- idx = XKB_GROUP_INVALID;
+ idx = XKB_LAYOUT_INVALID;
expanded.len = 0;
if (mlv == MLVO_LAYOUT) {
expanded.len = 0;
if (mlv == MLVO_LAYOUT) {
- if (idx != XKB_GROUP_INVALID &&
+ if (idx != XKB_LAYOUT_INVALID &&
idx < darray_size(m->rmlvo.layouts) &&
darray_size(m->rmlvo.layouts) > 1)
expanded = darray_item(m->rmlvo.layouts, idx);
idx < darray_size(m->rmlvo.layouts) &&
darray_size(m->rmlvo.layouts) > 1)
expanded = darray_item(m->rmlvo.layouts, idx);
- else if (idx == XKB_GROUP_INVALID &&
+ else if (idx == XKB_LAYOUT_INVALID &&
darray_size(m->rmlvo.layouts) == 1)
expanded = darray_item(m->rmlvo.layouts, 0);
}
else if (mlv == MLVO_VARIANT) {
darray_size(m->rmlvo.layouts) == 1)
expanded = darray_item(m->rmlvo.layouts, 0);
}
else if (mlv == MLVO_VARIANT) {
- if (idx != XKB_GROUP_INVALID &&
+ if (idx != XKB_LAYOUT_INVALID &&
idx < darray_size(m->rmlvo.variants) &&
darray_size(m->rmlvo.variants) > 1)
expanded = darray_item(m->rmlvo.variants, idx);
idx < darray_size(m->rmlvo.variants) &&
darray_size(m->rmlvo.variants) > 1)
expanded = darray_item(m->rmlvo.variants, idx);
- else if (idx == XKB_GROUP_INVALID &&
+ else if (idx == XKB_LAYOUT_INVALID &&
darray_size(m->rmlvo.variants) == 1)
expanded = darray_item(m->rmlvo.variants, 0);
}
darray_size(m->rmlvo.variants) == 1)
expanded = darray_item(m->rmlvo.variants, 0);
}
struct sval value, *option;
enum mlvo_match_type match_type;
bool matched = false;
struct sval value, *option;
enum mlvo_match_type match_type;
bool matched = false;
+ xkb_layout_index_t idx;
for (i = 0; i < m->mapping.num_mlvo; i++) {
mlvo = m->mapping.mlvo_at_pos[i];
for (i = 0; i < m->mapping.num_mlvo; i++) {
mlvo = m->mapping.mlvo_at_pos[i];
}
else if (mlvo == MLVO_LAYOUT) {
idx = m->mapping.layout_idx;
}
else if (mlvo == MLVO_LAYOUT) {
idx = m->mapping.layout_idx;
- idx = (idx == XKB_GROUP_INVALID ? 0 : idx);
+ idx = (idx == XKB_LAYOUT_INVALID ? 0 : idx);
matched = match_value(m, value,
darray_item(m->rmlvo.layouts, idx),
match_type);
}
else if (mlvo == MLVO_VARIANT) {
idx = m->mapping.layout_idx;
matched = match_value(m, value,
darray_item(m->rmlvo.layouts, idx),
match_type);
}
else if (mlvo == MLVO_VARIANT) {
idx = m->mapping.layout_idx;
- idx = (idx == XKB_GROUP_INVALID ? 0 : idx);
+ idx = (idx == XKB_LAYOUT_INVALID ? 0 : idx);
matched = match_value(m, value,
darray_item(m->rmlvo.variants, idx),
match_type);
matched = match_value(m, value,
darray_item(m->rmlvo.variants, idx),
match_type);
xkb_atom_t dfltType;
enum xkb_range_exceed_type out_of_range_group_action;
xkb_atom_t dfltType;
enum xkb_range_exceed_type out_of_range_group_action;
- xkb_group_index_t out_of_range_group_number;
+ xkb_layout_index_t out_of_range_group_number;
static void
ClearKeyInfo(KeyInfo *keyi)
{
static void
ClearKeyInfo(KeyInfo *keyi)
{
for (i = 0; i < XKB_NUM_GROUPS; i++)
ClearGroupInfo(&keyi->groups[i]);
}
for (i = 0; i < XKB_NUM_GROUPS; i++)
ClearGroupInfo(&keyi->groups[i]);
}
int errorCount;
unsigned file_id;
enum merge_mode merge;
int errorCount;
unsigned file_id;
enum merge_mode merge;
- xkb_group_index_t explicit_group;
+ xkb_layout_index_t explicit_group;
darray(KeyInfo) keys;
KeyInfo dflt;
VModInfo vmods;
darray(KeyInfo) keys;
KeyInfo dflt;
VModInfo vmods;
static bool
MergeGroups(SymbolsInfo *info, GroupInfo *into, GroupInfo *from, bool clobber,
static bool
MergeGroups(SymbolsInfo *info, GroupInfo *into, GroupInfo *from, bool clobber,
- bool report, xkb_group_index_t group, unsigned long key_name)
+ bool report, xkb_layout_index_t group, unsigned long key_name)
{
xkb_level_index_t i, numLevels;
enum { INTO = (1 << 0), FROM = (1 << 1) } using;
{
xkb_level_index_t i, numLevels;
enum { INTO = (1 << 0), FROM = (1 << 1) } using;
static bool
MergeKeys(SymbolsInfo *info, KeyInfo *into, KeyInfo *from)
{
static bool
MergeKeys(SymbolsInfo *info, KeyInfo *into, KeyInfo *from)
{
enum key_field collide = 0;
bool clobber, report;
int verbosity = xkb_get_log_verbosity(info->keymap->ctx);
enum key_field collide = 0;
bool clobber, report;
int verbosity = xkb_get_log_verbosity(info->keymap->ctx);
static bool
GetGroupIndex(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
static bool
GetGroupIndex(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
- unsigned what, xkb_group_index_t *ndx_rtrn)
+ unsigned what, xkb_layout_index_t *ndx_rtrn)
{
const char *name = (what == SYMBOLS ? "symbols" : "actions");
if (arrayNdx == NULL) {
{
const char *name = (what == SYMBOLS ? "symbols" : "actions");
if (arrayNdx == NULL) {
enum group_field field = (what == SYMBOLS ?
GROUP_FIELD_SYMS : GROUP_FIELD_ACTS);
enum group_field field = (what == SYMBOLS ?
GROUP_FIELD_SYMS : GROUP_FIELD_ACTS);
AddSymbolsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
ExprDef *value)
{
AddSymbolsToKey(SymbolsInfo *info, KeyInfo *keyi, ExprDef *arrayNdx,
ExprDef *value)
{
+ xkb_layout_index_t ndx;
GroupInfo *groupi;
unsigned int nSyms;
xkb_level_index_t nLevels;
GroupInfo *groupi;
unsigned int nSyms;
xkb_level_index_t nLevels;
ExprDef *value)
{
unsigned int i;
ExprDef *value)
{
unsigned int i;
+ xkb_layout_index_t ndx;
GroupInfo *groupi;
unsigned int nActs;
ExprDef *act;
GroupInfo *groupi;
unsigned int nActs;
ExprDef *act;
struct xkb_context *ctx = info->keymap->ctx;
if (istreq(field, "type")) {
struct xkb_context *ctx = info->keymap->ctx;
if (istreq(field, "type")) {
+ xkb_layout_index_t ndx;
xkb_atom_t val;
if (!ExprResolveString(ctx, value, &val))
xkb_atom_t val;
if (!ExprResolveString(ctx, value, &val))
}
else if (istreq(field, "groupsredirect") ||
istreq(field, "redirectgroups")) {
}
else if (istreq(field, "groupsredirect") ||
istreq(field, "redirectgroups")) {
+ xkb_layout_index_t grp;
if (!ExprResolveGroup(ctx, value, &grp)) {
log_err(info->keymap->ctx,
if (!ExprResolveGroup(ctx, value, &grp)) {
log_err(info->keymap->ctx,
static int
SetGroupName(SymbolsInfo *info, ExprDef *arrayNdx, ExprDef *value)
{
static int
SetGroupName(SymbolsInfo *info, ExprDef *arrayNdx, ExprDef *value)
{
+ xkb_layout_index_t grp;
xkb_atom_t name;
if (!arrayNdx) {
xkb_atom_t name;
if (!arrayNdx) {
static bool
SetExplicitGroup(SymbolsInfo *info, KeyInfo *keyi)
{
static bool
SetExplicitGroup(SymbolsInfo *info, KeyInfo *keyi)
{
if (info->explicit_group == 0)
return true;
if (info->explicit_group == 0)
return true;
HandleSymbolsDef(SymbolsInfo *info, SymbolsDef *stmt)
{
KeyInfo keyi;
HandleSymbolsDef(SymbolsInfo *info, SymbolsDef *stmt)
{
KeyInfo keyi;
keyi = info->dflt;
for (i = 0; i < XKB_NUM_GROUPS; i++) {
keyi = info->dflt;
for (i = 0; i < XKB_NUM_GROUPS; i++) {
FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym)
{
struct xkb_key *key, *ret = NULL;
FindKeyForSymbol(struct xkb_keymap *keymap, xkb_keysym_t sym)
{
struct xkb_key *key, *ret = NULL;
- xkb_group_index_t group, min_group = UINT32_MAX;
+ xkb_layout_index_t group, min_group = UINT32_MAX;
xkb_level_index_t level, min_level = UINT16_MAX;
xkb_foreach_key(key, keymap) {
xkb_level_index_t level, min_level = UINT16_MAX;
xkb_foreach_key(key, keymap) {
static void
PrepareKeyDef(KeyInfo *keyi)
{
static void
PrepareKeyDef(KeyInfo *keyi)
{
- xkb_group_index_t i, lastGroup;
+ xkb_layout_index_t i, lastGroup;
const GroupInfo *group0;
bool identical;
const GroupInfo *group0;
bool identical;
{
struct xkb_keymap *keymap = info->keymap;
struct xkb_key *key;
{
struct xkb_keymap *keymap = info->keymap;
struct xkb_key *key;
bool haveActions;
unsigned int sizeSyms;
unsigned int symIndex;
bool haveActions;
unsigned int sizeSyms;
unsigned int symIndex;
{
KeyInfo *keyi;
ModMapEntry *mm;
{
KeyInfo *keyi;
ModMapEntry *mm;
struct xkb_key *key;
keymap->symbols_section_name = strdup_safe(info->name);
struct xkb_key *key;
keymap->symbols_section_name = strdup_safe(info->name);
void
InitVModInfo(VModInfo *info, struct xkb_keymap *keymap)
{
void
InitVModInfo(VModInfo *info, struct xkb_keymap *keymap)
{
memset(info, 0, sizeof(*info));
for (i = 0; i < XKB_NUM_VIRTUAL_MODS; i++)
memset(info, 0, sizeof(*info));
for (i = 0; i < XKB_NUM_VIRTUAL_MODS; i++)
+ xkb_keymap_unref(keymap);
return NULL;
}
XKB_EXPORT struct xkb_keymap *
return NULL;
}
XKB_EXPORT struct xkb_keymap *
-xkb_map_new_from_names(struct xkb_context *ctx,
- const struct xkb_rule_names *rmlvo_in,
- enum xkb_map_compile_flags flags)
+xkb_keymap_new_from_names(struct xkb_context *ctx,
+ const struct xkb_rule_names *rmlvo_in,
+ enum xkb_keymap_compile_flags flags)
{
bool ok;
struct xkb_component_names kccgst;
{
bool ok;
struct xkb_component_names kccgst;
}
XKB_EXPORT struct xkb_keymap *
}
XKB_EXPORT struct xkb_keymap *
-xkb_map_new_from_string(struct xkb_context *ctx,
- const char *string,
- enum xkb_keymap_format format,
- enum xkb_map_compile_flags flags)
+xkb_keymap_new_from_string(struct xkb_context *ctx,
+ const char *string,
+ enum xkb_keymap_format format,
+ enum xkb_keymap_compile_flags flags)
{
bool ok;
XkbFile *file;
{
bool ok;
XkbFile *file;
}
XKB_EXPORT struct xkb_keymap *
}
XKB_EXPORT struct xkb_keymap *
-xkb_map_new_from_file(struct xkb_context *ctx,
- FILE *file,
- enum xkb_keymap_format format,
- enum xkb_map_compile_flags flags)
+xkb_keymap_new_from_file(struct xkb_context *ctx,
+ FILE *file,
+ enum xkb_keymap_format format,
+ enum xkb_keymap_compile_flags flags)
{
bool ok;
XkbFile *xkb_file;
{
bool ok;
XkbFile *xkb_file;
- keymap = xkb_map_new_from_file(context, file,
- XKB_KEYMAP_FORMAT_TEXT_V1, 0);
+ keymap = xkb_keymap_new_from_file(context, file,
+ XKB_KEYMAP_FORMAT_TEXT_V1, 0);
fclose(file);
if (!keymap) {
fclose(file);
if (!keymap) {
{
struct xkb_keymap *keymap;
{
struct xkb_keymap *keymap;
- keymap = xkb_map_new_from_string(context, string,
- XKB_KEYMAP_FORMAT_TEXT_V1, 0);
+ keymap = xkb_keymap_new_from_string(context, string,
+ XKB_KEYMAP_FORMAT_TEXT_V1, 0);
if (!keymap) {
fprintf(stderr, "Failed to compile string\n");
return NULL;
if (!keymap) {
fprintf(stderr, "Failed to compile string\n");
return NULL;
- keymap = xkb_map_new_from_names(context, &rmlvo, 0);
+ keymap = xkb_keymap_new_from_names(context, &rmlvo, 0);
if (!keymap) {
fprintf(stderr,
"Failed to compile RMLVO: '%s', '%s', '%s', '%s', '%s'\n",
if (!keymap) {
fprintf(stderr,
"Failed to compile RMLVO: '%s', '%s', '%s', '%s', '%s'\n",
+ xkb_keymap_unref(keymap);
unsigned int nsyms;
char s[16];
uint32_t unicode;
unsigned int nsyms;
char s[16];
uint32_t unicode;
- xkb_group_index_t group;
+ xkb_layout_index_t group;
xkb_mod_index_t mod;
xkb_led_index_t led;
state = kbd->state;
xkb_mod_index_t mod;
xkb_led_index_t led;
state = kbd->state;
- keymap = xkb_state_get_map(state);
+ keymap = xkb_state_get_keymap(state);
- nsyms = xkb_key_get_syms(state, keycode, &syms);
+ nsyms = xkb_state_key_get_syms(state, keycode, &syms);
#endif
printf("groups [ ");
#endif
printf("groups [ ");
- for (group = 0; group < xkb_map_num_groups(keymap); group++) {
- if (!xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE))
+ for (group = 0; group < xkb_keymap_num_layouts(keymap); group++) {
+ if (!xkb_state_layout_index_is_active(state, group, XKB_STATE_EFFECTIVE))
- printf("%s (%d) ", xkb_map_group_get_name(keymap, group), group);
+ printf("%s (%d) ", xkb_keymap_layout_get_name(keymap, group), group);
}
printf("] ");
printf("mods [ ");
}
printf("] ");
printf("mods [ ");
- for (mod = 0; mod < xkb_map_num_mods(keymap); mod++) {
+ for (mod = 0; mod < xkb_keymap_num_mods(keymap); mod++) {
if (!xkb_state_mod_index_is_active(state, mod, XKB_STATE_EFFECTIVE))
continue;
if (!xkb_state_mod_index_is_active(state, mod, XKB_STATE_EFFECTIVE))
continue;
- if (xkb_key_mod_index_is_consumed(state, keycode, mod))
- printf("-%s ", xkb_map_mod_get_name(keymap, mod));
+ if (xkb_state_mod_index_is_consumed(state, keycode, mod))
+ printf("-%s ", xkb_keymap_mod_get_name(keymap, mod));
- printf("%s ", xkb_map_mod_get_name(keymap, mod));
+ printf("%s ", xkb_keymap_mod_get_name(keymap, mod));
}
printf("] ");
printf("leds [ ");
}
printf("] ");
printf("leds [ ");
- for (led = 0; led < xkb_map_num_leds(keymap); led++) {
+ for (led = 0; led < xkb_keymap_num_leds(keymap); led++) {
if (!xkb_state_led_index_is_active(state, led))
continue;
if (!xkb_state_led_index_is_active(state, led))
continue;
- printf("%s ", xkb_map_led_get_name(keymap, led));
+ printf("%s ", xkb_keymap_led_get_name(keymap, led));
return;
keycode = EVDEV_OFFSET + code;
return;
keycode = EVDEV_OFFSET + code;
- keymap = xkb_state_get_map(kbd->state);
+ keymap = xkb_state_get_keymap(kbd->state);
- if (value == KEY_STATE_REPEAT && !xkb_key_repeats(keymap, keycode))
+ if (value == KEY_STATE_REPEAT && !xkb_keymap_key_repeats(keymap, keycode))
return;
if (value != KEY_STATE_RELEASE)
return;
if (value != KEY_STATE_RELEASE)
system("stty echo");
free_keyboards(kbds);
err_xkb:
system("stty echo");
free_keyboards(kbds);
err_xkb:
+ xkb_keymap_unref(keymap);
err_ctx:
xkb_context_unref(ctx);
err_out:
err_ctx:
xkb_context_unref(ctx);
err_out:
kc = va_arg(ap, int) + EVDEV_OFFSET;
op = va_arg(ap, int);
kc = va_arg(ap, int) + EVDEV_OFFSET;
op = va_arg(ap, int);
- nsyms = xkb_key_get_syms(state, kc, &syms);
+ nsyms = xkb_state_key_get_syms(state, kc, &syms);
fprintf(stderr, "got %d syms for key 0x%x: [", nsyms, kc);
if (op == DOWN || op == BOTH)
fprintf(stderr, "got %d syms for key 0x%x: [", nsyms, kc);
if (op == DOWN || op == BOTH)
KEY_V, BOTH, XKB_KEY_p, FINISH));
KEY_V, BOTH, XKB_KEY_p, FINISH));
+ xkb_keymap_unref(keymap);
xkb_context_unref(ctx);
return 0;
}
xkb_context_unref(ctx);
return 0;
}
- dump = xkb_map_get_as_string(keymap);
+ dump = xkb_keymap_get_as_string(keymap);
if (!dump) {
fprintf(stderr, "Couldn't get the keymap string\n");
goto err_map;
if (!dump) {
fprintf(stderr, "Couldn't get the keymap string\n");
goto err_map;
ret = EXIT_SUCCESS;
free(dump);
err_map:
ret = EXIT_SUCCESS;
free(dump);
err_map:
+ xkb_keymap_unref(keymap);
err_ctx:
xkb_context_unref(ctx);
err_out:
err_ctx:
xkb_context_unref(ctx);
err_out:
fprintf(stderr, "Compiled '%s' '%s' '%s' '%s' '%s'\n",
strnull(rules), strnull(model), strnull(layout),
strnull(variant), strnull(options));
fprintf(stderr, "Compiled '%s' '%s' '%s' '%s' '%s'\n",
strnull(rules), strnull(model), strnull(layout),
strnull(variant), strnull(options));
+ xkb_keymap_unref(keymap);
keymap = test_compile_rules(context, rules, model, layout, variant,
options);
if (keymap)
keymap = test_compile_rules(context, rules, model, layout, variant,
options);
if (keymap)
+ xkb_keymap_unref(keymap);
#include <stdlib.h>
#include <linux/input.h>
#include <stdlib.h>
#include <linux/input.h>
-#include "xkbcommon/xkbcommon.h"
#include "test.h"
/* Offset between evdev keycodes (where KEY_ESCAPE is 1), and the evdev XKB
#include "test.h"
/* Offset between evdev keycodes (where KEY_ESCAPE is 1), and the evdev XKB
print_state(struct xkb_state *state)
{
struct xkb_keymap *keymap;
print_state(struct xkb_state *state)
{
struct xkb_keymap *keymap;
- xkb_group_index_t group;
+ xkb_layout_index_t group;
xkb_mod_index_t mod;
xkb_led_index_t led;
xkb_mod_index_t mod;
xkb_led_index_t led;
- group = xkb_state_serialize_group(state, XKB_STATE_EFFECTIVE);
+ group = xkb_state_serialize_layout(state, XKB_STATE_EFFECTIVE);
mod = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
/* led = xkb_state_serialize_leds(state, XKB_STATE_EFFECTIVE); */
if (!group && !mod /* && !led */) {
mod = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
/* led = xkb_state_serialize_leds(state, XKB_STATE_EFFECTIVE); */
if (!group && !mod /* && !led */) {
- keymap = xkb_state_get_map(state);
+ keymap = xkb_state_get_keymap(state);
- for (group = 0; group < xkb_map_num_groups(keymap); group++) {
- if (xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE) != 1)
+ for (group = 0; group < xkb_keymap_num_layouts(keymap); group++) {
+ if (xkb_state_layout_index_is_active(state, group, XKB_STATE_EFFECTIVE) != 1)
continue;
fprintf(stderr, "\tgroup %s (%d): %s%s%s%s\n",
continue;
fprintf(stderr, "\tgroup %s (%d): %s%s%s%s\n",
- xkb_map_group_get_name(keymap, group),
+ xkb_keymap_layout_get_name(keymap, group),
- xkb_state_group_index_is_active(state, group, XKB_STATE_EFFECTIVE) > 0 ?
+ xkb_state_layout_index_is_active(state, group, XKB_STATE_EFFECTIVE) > 0 ?
- xkb_state_group_index_is_active(state, group, XKB_STATE_DEPRESSED) > 0 ?
+ xkb_state_layout_index_is_active(state, group, XKB_STATE_DEPRESSED) > 0 ?
- xkb_state_group_index_is_active(state, group, XKB_STATE_LATCHED) > 0 ?
+ xkb_state_layout_index_is_active(state, group, XKB_STATE_LATCHED) > 0 ?
- xkb_state_group_index_is_active(state, group, XKB_STATE_LOCKED) > 0 ?
+ xkb_state_layout_index_is_active(state, group, XKB_STATE_LOCKED) > 0 ?
- for (mod = 0; mod < xkb_map_num_mods(keymap); mod++) {
+ for (mod = 0; mod < xkb_keymap_num_mods(keymap); mod++) {
if (!xkb_state_mod_index_is_active(state, mod, XKB_STATE_EFFECTIVE))
continue;
fprintf(stderr, "\tmod %s (%d): %s%s%s\n",
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(keymap, mod),
+ xkb_keymap_mod_get_name(keymap, mod),
mod,
xkb_state_mod_index_is_active(state, mod, XKB_STATE_DEPRESSED) > 0 ?
"depressed " : "",
mod,
xkb_state_mod_index_is_active(state, mod, XKB_STATE_DEPRESSED) > 0 ?
"depressed " : "",
- for (led = 0; led < xkb_map_num_leds(keymap); led++) {
+ for (led = 0; led < xkb_keymap_num_leds(keymap); led++) {
if (!xkb_state_led_index_is_active(state, led))
continue;
fprintf(stderr, "\tled %s (%d): active\n",
if (!xkb_state_led_index_is_active(state, led))
continue;
fprintf(stderr, "\tled %s (%d): active\n",
- xkb_map_led_get_name(keymap, led),
+ xkb_keymap_led_get_name(keymap, led),
NULL) > 0);
assert(xkb_state_mod_indices_are_active(state, XKB_STATE_DEPRESSED,
XKB_STATE_MATCH_ALL,
NULL) > 0);
assert(xkb_state_mod_indices_are_active(state, XKB_STATE_DEPRESSED,
XKB_STATE_MATCH_ALL,
- xkb_map_mod_get_index(keymap, XKB_MOD_NAME_CTRL),
- xkb_map_mod_get_index(keymap, XKB_MOD_NAME_ALT),
+ xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL),
+ xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_ALT),
XKB_MOD_INVALID) > 0);
assert(!xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
XKB_STATE_MATCH_ALL,
XKB_MOD_INVALID) > 0);
assert(!xkb_state_mod_names_are_active(state, XKB_STATE_DEPRESSED,
XKB_STATE_MATCH_ALL,
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
XKB_STATE_LOCKED) > 0);
assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) > 0);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
XKB_STATE_LOCKED) > 0);
assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) > 0);
- num_syms = xkb_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
+ num_syms = xkb_state_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
assert(num_syms == 1 && syms[0] == XKB_KEY_Q);
/* Caps unlocked */
assert(num_syms == 1 && syms[0] == XKB_KEY_Q);
/* Caps unlocked */
assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
XKB_STATE_EFFECTIVE) > 0);
assert(!xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) > 0);
assert(!xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
XKB_STATE_EFFECTIVE) > 0);
assert(!xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) > 0);
- num_syms = xkb_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
+ num_syms = xkb_state_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
assert(num_syms == 1 && syms[0] == XKB_KEY_q);
xkb_state_unref(state);
assert(num_syms == 1 && syms[0] == XKB_KEY_q);
xkb_state_unref(state);
xkb_mod_mask_t locked_mods;
xkb_mod_mask_t effective_mods;
xkb_mod_index_t caps, shift, ctrl;
xkb_mod_mask_t locked_mods;
xkb_mod_mask_t effective_mods;
xkb_mod_index_t caps, shift, ctrl;
- xkb_group_index_t base_group = 0;
- xkb_group_index_t latched_group = 0;
- xkb_group_index_t locked_group = 0;
+ xkb_layout_index_t base_group = 0;
+ xkb_layout_index_t latched_group = 0;
+ xkb_layout_index_t locked_group = 0;
- caps = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
+ caps = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
assert(caps != XKB_MOD_INVALID);
assert(caps != XKB_MOD_INVALID);
- shift = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
+ shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
assert(shift != XKB_MOD_INVALID);
assert(shift != XKB_MOD_INVALID);
- ctrl = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
+ ctrl = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
assert(ctrl != XKB_MOD_INVALID);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
assert(ctrl != XKB_MOD_INVALID);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
static void
test_repeat(struct xkb_keymap *keymap)
{
static void
test_repeat(struct xkb_keymap *keymap)
{
- assert(!xkb_key_repeats(keymap, KEY_LEFTSHIFT + 8));
- assert(xkb_key_repeats(keymap, KEY_A + 8));
- assert(xkb_key_repeats(keymap, KEY_8 + 8));
- assert(xkb_key_repeats(keymap, KEY_DOWN + 8));
- assert(xkb_key_repeats(keymap, KEY_KBDILLUMDOWN + 8));
+ assert(!xkb_keymap_key_repeats(keymap, KEY_LEFTSHIFT + 8));
+ assert(xkb_keymap_key_repeats(keymap, KEY_A + 8));
+ assert(xkb_keymap_key_repeats(keymap, KEY_8 + 8));
+ assert(xkb_keymap_key_repeats(keymap, KEY_DOWN + 8));
+ assert(xkb_keymap_key_repeats(keymap, KEY_KBDILLUMDOWN + 8));
- alt = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_ALT);
+ alt = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_ALT);
assert(alt != XKB_MOD_INVALID);
assert(alt != XKB_MOD_INVALID);
- shift = xkb_map_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
+ shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
assert(shift != XKB_MOD_INVALID);
xkb_state_update_key(state, KEY_LEFTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
assert(shift != XKB_MOD_INVALID);
xkb_state_update_key(state, KEY_LEFTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
mask = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
assert(mask == ((1 << alt) | (1 << shift)));
mask = xkb_state_serialize_mods(state, XKB_STATE_EFFECTIVE);
assert(mask == ((1 << alt) | (1 << shift)));
- mask = xkb_key_mod_mask_remove_consumed(state, KEY_EQUAL + EVDEV_OFFSET,
- mask);
+ mask = xkb_state_mod_mask_remove_consumed(state, KEY_EQUAL + EVDEV_OFFSET,
+ mask);
assert(mask == (1 << alt));
xkb_state_unref(state);
assert(mask == (1 << alt));
xkb_state_unref(state);
test_repeat(keymap);
test_consume(keymap);
test_repeat(keymap);
test_consume(keymap);
+ xkb_keymap_unref(keymap);
xkb_context_unref(context);
}
xkb_context_unref(context);
}
#include <stdio.h>
#include <stdlib.h>
#include <stdio.h>
#include <stdlib.h>
-#include "xkbcommon/xkbcommon.h"
#include "test.h"
#define DATA_PATH "keymaps/stringcomp.data"
#include "test.h"
#define DATA_PATH "keymaps/stringcomp.data"
keymap = test_compile_string(ctx, original);
assert(keymap);
keymap = test_compile_string(ctx, original);
assert(keymap);
- dump = xkb_map_get_as_string(keymap);
+ dump = xkb_keymap_get_as_string(keymap);
assert(dump);
if (!streq(original, dump)) {
assert(dump);
if (!streq(original, dump)) {
free(original);
free(dump);
free(original);
free(dump);
+ xkb_keymap_unref(keymap);
/* Make sure we can't (falsely claim to) compile an empty string. */
keymap = test_compile_string(ctx, "");
/* Make sure we can't (falsely claim to) compile an empty string. */
keymap = test_compile_string(ctx, "");
+ /* Don't use compat names in internal code. */
+#define _XKBCOMMON_COMPAT_H
#include "xkbcommon/xkbcommon.h"
#include "utils.h"
#include "xkbcommon/xkbcommon.h"
#include "utils.h"