void EglFSWaylandInput::keymapChanged(int fd, quint32 size)
{
// Load keymap
char *map = static_cast<char *>(::mmap(Q_NULLPTR, size, PROT_READ, MAP_SHARED, fd, 0));
if (map == MAP_FAILED) {
::close(fd);
return;
}
// Release the old keymap
releaseKeymap();
m_xkbContext = xkb_context_new(xkb_context_flags(0));
m_xkbKeymap = xkb_map_new_from_string(m_xkbContext, map, XKB_KEYMAP_FORMAT_TEXT_V1,
XKB_KEYMAP_COMPILE_NO_FLAGS);
::munmap(map, size);
::close(fd);
m_xkbState = xkb_state_new(m_xkbKeymap);
}
int uxkb_dev_init(struct uterm_input_dev *dev)
{
int ret;
ret = ev_eloop_new_timer(dev->input->eloop, &dev->repeat_timer, NULL,
timer_event, dev);
if (ret)
return ret;
dev->state = xkb_state_new(dev->input->keymap);
if (!dev->state) {
log_error("cannot create XKB state");
ret = -ENOMEM;
goto err_timer;
}
return 0;
err_timer:
ev_eloop_rm_timer(dev->repeat_timer);
return ret;
}
int
main(void)
{
struct xkb_context *ctx;
struct xkb_keymap *keymap;
struct xkb_state *state;
struct bench bench;
char *elapsed;
ctx = test_get_context(0);
assert(ctx);
keymap = test_compile_rules(ctx, "evdev", "pc104", "us,ru,il,de",
",,,neo", "grp:menu_toggle");
assert(keymap);
state = xkb_state_new(keymap);
assert(state);
xkb_context_set_log_level(ctx, XKB_LOG_LEVEL_CRITICAL);
xkb_context_set_log_verbosity(ctx, 0);
srand(time(NULL));
bench_start(&bench);
bench_key_proc(state);
bench_stop(&bench);
elapsed = bench_elapsed_str(&bench);
fprintf(stderr, "ran %d iterations in %ss\n",
BENCHMARK_ITERATIONS, elapsed);
free(elapsed);
xkb_state_unref(state);
xkb_keymap_unref(keymap);
xkb_context_unref(ctx);
return 0;
}
int main()
{
xkb_rule_names names;
names.rules = strdup("evdev");
names.model = strdup("pc105");
names.layout = strdup("us");
names.variant = strdup("");
names.options = strdup("");
xkb_context *context = xkb_context_new(xkb_context_flags(0));
if (context) {
xkb_keymap * keymap = xkb_map_new_from_names(context, &names, xkb_map_compile_flags(0));
if (keymap) {
xkb_state *state = xkb_state_new(keymap);
if (state)
xkb_state_unref(state);
xkb_map_unref(keymap);
}
xkb_context_unref(context);
}
return 0;
}
int init_xkb(void)
{
settings_t *settings = config_get_ptr();
mod_map_idx = (xkb_mod_index_t *)calloc(MOD_MAP_SIZE, sizeof(xkb_mod_index_t));
if (!mod_map_idx)
goto error;
mod_map_bit = (uint16_t*)calloc(MOD_MAP_SIZE, sizeof(uint16_t));
if (!mod_map_bit)
goto error;
xkb_ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
if (xkb_ctx)
{
struct string_list *list = NULL;
struct xkb_rule_names rule = {0};
rule.rules = "evdev";
if (*settings->input.keyboard_layout)
{
list = string_split(settings->input.keyboard_layout, ":");
if (list && list->size >= 2)
rule.variant = list->elems[1].data;
if (list && list->size >= 1)
rule.layout = list->elems[0].data;
}
xkb_map = xkb_keymap_new_from_names(xkb_ctx, &rule, XKB_MAP_COMPILE_NO_FLAGS);
if (list)
string_list_free(list);
}
if (xkb_map)
{
xkb_mod_index_t *map_idx = (xkb_mod_index_t*)&mod_map_idx[0];
uint16_t *map_bit = (uint16_t*)&mod_map_bit[0];
xkb_state = xkb_state_new(xkb_map);
*map_idx = xkb_keymap_mod_get_index(xkb_map, XKB_MOD_NAME_CAPS);
map_idx++;
*map_bit = RETROKMOD_CAPSLOCK;
map_bit++;
*map_idx = xkb_keymap_mod_get_index(xkb_map, XKB_MOD_NAME_SHIFT);
map_idx++;
*map_bit = RETROKMOD_SHIFT;
map_bit++;
*map_idx = xkb_keymap_mod_get_index(xkb_map, XKB_MOD_NAME_CTRL);
map_idx++;
*map_bit = RETROKMOD_CTRL;
map_bit++;
*map_idx = xkb_keymap_mod_get_index(xkb_map, XKB_MOD_NAME_ALT);
map_idx++;
*map_bit = RETROKMOD_ALT;
map_bit++;
*map_idx = xkb_keymap_mod_get_index(xkb_map, XKB_MOD_NAME_LOGO);
*map_bit = RETROKMOD_META;
}
return 0;
error:
free_xkb();
return -1;
}
static void *udev_input_init(void)
{
settings_t *settings = config_get_ptr();
udev_input_t *udev = (udev_input_t*)calloc(1, sizeof(*udev));
if (!udev)
return NULL;
udev->udev = udev_new();
if (!udev->udev)
{
RARCH_ERR("Failed to create udev handle.\n");
goto error;
}
udev->monitor = udev_monitor_new_from_netlink(udev->udev, "udev");
if (udev->monitor)
{
udev_monitor_filter_add_match_subsystem_devtype(udev->monitor, "input", NULL);
udev_monitor_enable_receiving(udev->monitor);
}
#ifdef HAVE_XKBCOMMON
udev->mod_map_idx = (xkb_mod_index_t *)calloc(MOD_MAP_SIZE, sizeof(xkb_mod_index_t));
if (!udev->mod_map_idx)
goto error;
udev->mod_map_bit = (uint16_t*)calloc(MOD_MAP_SIZE, sizeof(uint16_t));
if (!udev->mod_map_bit)
goto error;
udev->xkb_ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
if (udev->xkb_ctx)
{
struct string_list *list = NULL;
struct xkb_rule_names rule = {0};
rule.rules = "evdev";
if (*settings->input.keyboard_layout)
{
list = string_split(settings->input.keyboard_layout, ":");
if (list && list->size >= 2)
rule.variant = list->elems[1].data;
if (list && list->size >= 1)
rule.layout = list->elems[0].data;
}
udev->xkb_map = xkb_keymap_new_from_names(udev->xkb_ctx, &rule, XKB_MAP_COMPILE_NO_FLAGS);
if (list)
string_list_free(list);
}
if (udev->xkb_map)
{
xkb_mod_index_t *map_idx = (xkb_mod_index_t*)&udev->mod_map_idx[0];
uint16_t *map_bit = (uint16_t*)&udev->mod_map_bit[0];
udev->xkb_state = xkb_state_new(udev->xkb_map);
*map_idx = xkb_keymap_mod_get_index(udev->xkb_map, XKB_MOD_NAME_CAPS);
map_idx++;
*map_bit = RETROKMOD_CAPSLOCK;
map_bit++;
*map_idx = xkb_keymap_mod_get_index(udev->xkb_map, XKB_MOD_NAME_SHIFT);
map_idx++;
*map_bit = RETROKMOD_SHIFT;
map_bit++;
*map_idx = xkb_keymap_mod_get_index(udev->xkb_map, XKB_MOD_NAME_CTRL);
map_idx++;
*map_bit = RETROKMOD_CTRL;
map_bit++;
*map_idx = xkb_keymap_mod_get_index(udev->xkb_map, XKB_MOD_NAME_ALT);
map_idx++;
*map_bit = RETROKMOD_ALT;
map_bit++;
*map_idx = xkb_keymap_mod_get_index(udev->xkb_map, XKB_MOD_NAME_LOGO);
*map_bit = RETROKMOD_META;
}
#endif
udev->epfd = epoll_create(32);
if (udev->epfd < 0)
{
RARCH_ERR("Failed to create epoll FD.\n");
goto error;
}
if (!open_devices(udev, "ID_INPUT_KEYBOARD", udev_handle_keyboard))
{
RARCH_ERR("Failed to open keyboard.\n");
goto error;
}
if (!open_devices(udev, "ID_INPUT_MOUSE", udev_handle_mouse))
{
RARCH_ERR("Failed to open mouse.\n");
goto error;
}
if (!open_devices(udev, "ID_INPUT_TOUCHPAD", udev_handle_touchpad))
{
RARCH_ERR("Failed to open touchpads.\n");
goto error;
}
/* If using KMS and we forgot this,
* we could lock ourselves out completely. */
if (!udev->num_devices)
RARCH_WARN("[udev]: Couldn't open any keyboard, mouse or touchpad. Are permissions set correctly for /dev/input/event*?\n");
udev->joypad = input_joypad_init_driver(settings->input.joypad_driver, udev);
input_keymaps_init_keyboard_lut(rarch_key_map_linux);
disable_terminal_input();
return udev;
error:
udev_input_free(udev);
return NULL;
}
void fill_keycodes() {
struct xkb_keymap *keymap;
struct xkb_context *context;
const struct xkb_rule_names rules={
.rules=xkb_names[0],
.model=xkb_names[1],
.layout=xkb_names[2],
.variant=xkb_names[3],
.options=xkb_names[4]
};
struct xkb_state *state;
enum xkb_state_component current_state;
int counter;
int i,j,k;
char mods[256];
char keysym_asc[256];
char file_path[256];
char command[15];
uint32_t max_keys;
int w,h,retval;
int jumpto;
context=xkb_context_new(0);
keymap=xkb_keymap_new_from_names(context,&rules,0);
state=NULL;
// Get all the modifier keys
for(i=8;i<256;i++) {
state=xkb_state_new(keymap);
current_state=xkb_state_update_key(state, i,XKB_KEY_DOWN);
if (current_state!=0) {
mods[i]=1;
} else {
mods[i]=0;
}
xkb_state_unref(state);
}
mods[7]=1; // fake mod, used for "no mod"
// Read the keyboard definition files
sprintf(file_path,"%s/%s.keymap",BASE_CONFIG_DIR,lang_onscreen);
FILE *keyboard_file=fopen(file_path,"r");
if (keyboard_file==NULL) {
printf("Can't open keyboard definition file %s. Trying with US file\n",file_path);
sprintf(file_path,"%s/us.keymap",BASE_CONFIG_DIR);
keyboard_file=fopen(file_path,"r");
if (keyboard_file==NULL) {
printf("Also failed to open the US keymap file. Aborting.\n");
exit(-1);
}
}
retval=fscanf(keyboard_file,"%s %d",command,&keyboard_blocks);
if (retval!=2) {
printf("Can't read the number of blocks\n");
} else {
max_keys=keyboard_blocks*4*KEYS_PER_ROW;
keyboard_lowercase=(struct key_element *)malloc(max_keys*sizeof(struct key_element));
memset(keyboard_lowercase,0,max_keys*sizeof(struct key_element));
for(counter=0;(!feof(keyboard_file))&&(counter<max_keys);counter++) {
retval=fscanf(keyboard_file,"%s %d %d",command,&w,&h);
if(retval!=3) {
break;
}
keyboard_lowercase[counter].size=KEYS_FONT_SIZE;
keyboard_lowercase[counter].g_element[0]=0;
keyboard_lowercase[counter].w=w;
keyboard_lowercase[counter].h=h;
keyboard_lowercase[counter].keycode=0;
keyboard_lowercase[counter].modifier=0;
if (!strcmp(command,"BLANK")) {
keyboard_lowercase[counter].type=KEY_BLANK;
keyboard_lowercase[counter].keysym=0;
} else if (!strcmp(command,"KEY")) {
keyboard_lowercase[counter].type=KEY_PH;
retval=fscanf(keyboard_file,"%s",keyboard_lowercase[counter].g_element);
keyboard_lowercase[counter].keysym=init_utf8_to_keysym(keyboard_lowercase[counter].g_element);
if (keyboard_lowercase[counter].keysym==0) {
keyboard_lowercase[counter].type=KEY_BLANK;
}
} else if ((!strcmp(command,"KEYSYM"))||(!strcmp(command,"KEYSYMTEXT"))) {
keyboard_lowercase[counter].type=KEY_PH;
retval=fscanf(keyboard_file,"%s",keysym_asc);
keyboard_lowercase[counter].keysym=xkb_keysym_from_name(keysym_asc,0);
if (keyboard_lowercase[counter].keysym==0) {
printf("Unknown keysym %s\n",keysym_asc);
keyboard_lowercase[counter].type=KEY_BLANK;
} else {
if (!strcmp(command,"KEYSYMTEXT")) {
retval=fscanf(keyboard_file,"%s",keyboard_lowercase[counter].g_element);
keyboard_lowercase[counter].size=KEYS_TEXT_FONT_SIZE;
} else {
retval=xkb_keysym_to_utf8(keyboard_lowercase[counter].keysym,keyboard_lowercase[counter].g_element,7);
if (retval==-1) {
retval++;
}
keyboard_lowercase[counter].g_element[retval]=0;// terminate string
}
}
} else if (!strcmp(command,"TAB")) {
keyboard_lowercase[counter].type=KEY_TAB;
keyboard_lowercase[counter].keysym=XK_Tab;
} else if (!strcmp(command,"SPACE")) {
keyboard_lowercase[counter].type=KEY_SPACE;
keyboard_lowercase[counter].keysym=XK_space;
} else if (!strcmp(command,"RETURN")) {
keyboard_lowercase[counter].type=KEY_RETURN;
keyboard_lowercase[counter].keysym=XK_Return;
} else if (!strcmp(command,"DELETE")) {
keyboard_lowercase[counter].type=KEY_DELETE;
keyboard_lowercase[counter].keysym=XK_BackSpace;
} else if (!strcmp(command,"JUMPTO")) {
retval=fscanf(keyboard_file,"%d %s",&jumpto,command);
keyboard_lowercase[counter].type=KEY_JUMPTO;
keyboard_lowercase[counter].keycode=jumpto;
keyboard_lowercase[counter].keysym=0;
if (!strcmp(command,"GEN")) {
keyboard_lowercase[counter].modifier=0;
} else if (!strcmp(command,"SHIFT")) {
keyboard_lowercase[counter].modifier=1;
} else if (!strcmp(command,"SYMBOLS")) {
keyboard_lowercase[counter].modifier=2;
} else if (!strcmp(command,"LETTERS")) {
keyboard_lowercase[counter].modifier=3;
}
if (jumpto>=keyboard_blocks) {
printf("Ilegal jump to block %d (max. is %d)\n",jumpto,keyboard_blocks);
keyboard_lowercase[counter].type=KEY_BLANK;
}
} else if (!strcmp(command,"UP")) {
keyboard_lowercase[counter].type=KEY_UP;
keyboard_lowercase[counter].keysym=XK_Up;
} else if (!strcmp(command,"DOWN")) {
keyboard_lowercase[counter].type=KEY_DOWN;
keyboard_lowercase[counter].keysym=XK_Down;
} else if (!strcmp(command,"LEFT")) {
keyboard_lowercase[counter].type=KEY_LEFT;
keyboard_lowercase[counter].keysym=XK_Left;
} else if (!strcmp(command,"RIGHT")) {
keyboard_lowercase[counter].type=KEY_RIGHT;
keyboard_lowercase[counter].keysym=XK_Right;
} else {
printf("Unknown command %s\n",command);
keyboard_lowercase[counter].type=KEY_BLANK;
keyboard_lowercase[counter].keysym=0;
}
}
xkb_keysym_t keysym;
xkb_keycode_t keycode_mod;
for(i=7;i<256;i++) { // do a loop on every modifier
if (!mods[i]) {
continue; // In this loop we test each modifier with each keycode
}
state=xkb_state_new(keymap);
if (i!=7) {
xkb_state_update_key(state, i,XKB_KEY_DOWN); // press the modifier key
keycode_mod=i;
} else {
keycode_mod=0;
}
for(j=8;j<256;j++) {
if (mods[j]) {
continue; // Don't test modifiers; we want "normal" keys
}
keysym=xkb_state_key_get_one_sym(state, j);
if (keysym==XKB_KEY_NoSymbol) {
continue;
}
for(k=0;k<counter;k++) { // and now we check each desired key with the keysymbol obtained
if ((keyboard_lowercase[k].keycode==0)&&(keyboard_lowercase[k].type!=KEY_BLANK)&&(keyboard_lowercase[k].keysym==keysym)) {
keyboard_lowercase[k].keycode=j;
keyboard_lowercase[k].modifier=keycode_mod;
}
}
}
xkb_state_unref(state);
}
/*for(k=0;k<counter;k++) { // and now we check each desired key with the keysymbol obtained
printf("Texto: %s, Keysym: %d, mod: %d\n",keyboard_lowercase[k].g_element,keyboard_lowercase[k].keycode,keyboard_lowercase[k].modifier);
}*/
// Now assign new keysyms to keycodes not used, to allow other keysyms not available in US keyboards
xcb_key_symbols_t *symbols;
symbols=xcb_key_symbols_alloc(conn);
xcb_flush(conn);
xcb_keycode_t keycode=8;
xcb_keycode_t keycode_found;
xcb_keysym_t keysyms[4];
xcb_keycode_t keycode_shift;
struct lower_upper_t {xcb_keysym_t upper_first;
xcb_keysym_t upper_last;
xcb_keysym_t lower_first;
xcb_keysym_t lower_last;
};
struct lower_upper_t lower_upper[] = {
{XKB_KEY_Agrave,XKB_KEY_Odiaeresis,XKB_KEY_agrave,XKB_KEY_odiaeresis},
{XKB_KEY_Oslash,XKB_KEY_THORN,XKB_KEY_oslash,XKB_KEY_thorn},
{0,0,0,0}
};
struct lower_upper_t *iter_lu;
keycode_shift=*xcb_key_symbols_get_keycode(symbols,XKB_KEY_Shift_L);
for(k=0;k<max_keys;k++) { // and now we check each desired key with the keysymbol obtained
if ((keyboard_lowercase[k].keycode==0)&&(keyboard_lowercase[k].type!=KEY_BLANK)&&(keyboard_lowercase[k].type!=KEY_JUMPTO)) {
// this key is not available in US keyboards; let's redefine a keycode for it
keycode_found=0;
while(keycode<256) {
if ((0==xcb_key_symbols_get_keysym(symbols,keycode,0))&&
(0==xcb_key_symbols_get_keysym(symbols,keycode,1))&&
(0==xcb_key_symbols_get_keysym(symbols,keycode,2))&&
(0==xcb_key_symbols_get_keysym(symbols,keycode,3))) {
keycode_found=keycode;
break;
}
keycode++;
}
if (keycode_found==0) {
printf("No more codes available\n");
break; // there are no more free keycodes available
}
keycode=keycode_found;
keysyms[0]=keyboard_lowercase[k].keysym;
keysyms[1]=0;
keysyms[2]=keyboard_lowercase[k].keysym;
keysyms[3]=0;
for(iter_lu=lower_upper;iter_lu->upper_first;iter_lu++) {
if ((keysyms[0]>=iter_lu->upper_first)&&(keysyms[0]<=iter_lu->upper_last)) { // it's an uppercase special character
keysyms[0]|=0x20; // first character as lowercase
break;
}
if ((keysyms[0]>=iter_lu->lower_first)&&(keysyms[0]<=iter_lu->lower_last)) { // it's a lowercase special character
keysyms[2]&=0xDF; // second character as uppercase
break;
}
}
xcb_change_keyboard_mapping(conn,1,keycode,4,keysyms); // insert the new keysym
for(j=k;j<max_keys;j++) { // set the keycode and the shift modifier, if needed, to all keys with that keysyms
if (keyboard_lowercase[j].keysym==keysyms[0]) {
keyboard_lowercase[j].keycode=keycode;
keyboard_lowercase[j].modifier=0;
continue;
}
if (keyboard_lowercase[j].keysym==keysyms[2]) {
keyboard_lowercase[j].keycode=keycode;
keyboard_lowercase[j].modifier=keycode_shift;
continue;
}
}
keycode++;
}
}
xcb_key_symbols_free(symbols);
}
fclose(keyboard_file);
keyboard_current_block=0;
xkb_keymap_unref(keymap);
xkb_context_unref(context);
}
static int uxkb_desc_init(struct kbd_desc **out,
const char *layout,
const char *variant,
const char *options)
{
int ret;
struct kbd_desc *desc;
struct xkb_rule_names rmlvo = {
.rules = "evdev",
.model = "evdev",
.layout = layout,
.variant = variant,
.options = options,
};
if (!out)
return -EINVAL;
desc = malloc(sizeof(*desc));
if (!desc)
return -ENOMEM;
memset(desc, 0, sizeof(*desc));
desc->ref = 1;
desc->ops = &uxkb_desc_ops;
desc->uxkb.ctx = xkb_context_new(0);
if (!desc->uxkb.ctx) {
ret = -ENOMEM;
goto err_desc;
}
desc->uxkb.keymap = xkb_map_new_from_names(desc->uxkb.ctx, &rmlvo, 0);
if (!desc->uxkb.keymap) {
log_warn("failed to create keymap (%s, %s, %s), "
"reverting to default US keymap",
layout, variant, options);
rmlvo.layout = "us";
rmlvo.variant = "";
rmlvo.options = "";
desc->uxkb.keymap = xkb_map_new_from_names(desc->uxkb.ctx,
&rmlvo, 0);
if (!desc->uxkb.keymap) {
log_warn("failed to create keymap");
ret = -EFAULT;
goto err_ctx;
}
}
log_debug("new keyboard description (%s, %s, %s)",
layout, variant, options);
*out = desc;
return 0;
err_ctx:
xkb_context_unref(desc->uxkb.ctx);
err_desc:
free(desc);
return ret;
}
static void uxkb_desc_ref(struct kbd_desc *desc)
{
if (!desc || !desc->ref)
return;
++desc->ref;
}
static void uxkb_desc_unref(struct kbd_desc *desc)
{
if (!desc || !desc->ref || --desc->ref)
return;
log_debug("destroying keyboard description");
xkb_map_unref(desc->uxkb.keymap);
xkb_context_unref(desc->uxkb.ctx);
free(desc);
}
static int uxkb_desc_alloc(struct kbd_desc *desc, struct kbd_dev **out)
{
struct kbd_dev *kbd;
kbd = malloc(sizeof(*kbd));
if (!kbd)
return -ENOMEM;
memset(kbd, 0, sizeof(*kbd));
kbd->ref = 1;
kbd->desc = desc;
kbd->ops = &uxkb_dev_ops;
kbd->uxkb.state = xkb_state_new(desc->uxkb.keymap);
if (!kbd->uxkb.state) {
free(kbd);
return -ENOMEM;
}
kbd_desc_ref(desc);
*out = kbd;
return 0;
}
static void uxkb_keysym_to_string(uint32_t keysym, char *str, size_t size)
{
xkb_keysym_get_name(keysym, str, size);
}
int init_xkb(int fd, size_t size)
{
char *map_str = NULL;
mod_map_idx = (xkb_mod_index_t *)calloc(
MOD_MAP_SIZE, sizeof(xkb_mod_index_t));
if (!mod_map_idx)
goto error;
mod_map_bit = (uint16_t*)
calloc(MOD_MAP_SIZE, sizeof(uint16_t));
if (!mod_map_bit)
goto error;
xkb_ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
if (xkb_ctx)
{
if (fd >= 0)
{
map_str = (char*)mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
if (map_str == MAP_FAILED)
goto error;
xkb_map = xkb_keymap_new_from_string(xkb_ctx, map_str,
XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
munmap(map_str, size);
}
else
{
struct string_list *list = NULL;
struct xkb_rule_names rule = {0};
settings_t *settings = config_get_ptr();
rule.rules = "evdev";
if (*settings->arrays.input_keyboard_layout)
{
list = string_split(settings->arrays.input_keyboard_layout, ":");
if (list && list->size >= 2)
rule.variant = list->elems[1].data;
if (list && list->size >= 1)
rule.layout = list->elems[0].data;
}
xkb_map = xkb_keymap_new_from_names(xkb_ctx,
&rule, XKB_MAP_COMPILE_NO_FLAGS);
if (list)
string_list_free(list);
}
}
if (xkb_map)
{
xkb_mod_index_t *map_idx = (xkb_mod_index_t*)&mod_map_idx[0];
uint16_t *map_bit = (uint16_t*)&mod_map_bit[0];
xkb_state = xkb_state_new(xkb_map);
*map_idx = xkb_keymap_mod_get_index(xkb_map, XKB_MOD_NAME_CAPS);
map_idx++;
*map_bit = RETROKMOD_CAPSLOCK;
map_bit++;
*map_idx = xkb_keymap_mod_get_index(xkb_map, XKB_MOD_NAME_SHIFT);
map_idx++;
*map_bit = RETROKMOD_SHIFT;
map_bit++;
*map_idx = xkb_keymap_mod_get_index(xkb_map, XKB_MOD_NAME_CTRL);
map_idx++;
*map_bit = RETROKMOD_CTRL;
map_bit++;
*map_idx = xkb_keymap_mod_get_index(xkb_map, XKB_MOD_NAME_ALT);
map_idx++;
*map_bit = RETROKMOD_ALT;
map_bit++;
*map_idx = xkb_keymap_mod_get_index(xkb_map, XKB_MOD_NAME_LOGO);
*map_bit = RETROKMOD_META;
}
return 0;
error:
free_xkb();
return -1;
}
static void keyboardHandleKeymap(void* data,
struct wl_keyboard* keyboard,
uint32_t format,
int fd,
uint32_t size)
{
struct xkb_keymap* keymap;
struct xkb_state* state;
#ifdef HAVE_XKBCOMMON_COMPOSE_H
struct xkb_compose_table* composeTable;
struct xkb_compose_state* composeState;
#endif
char* mapStr;
const char* locale;
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1)
{
close(fd);
return;
}
mapStr = mmap(NULL, size, PROT_READ, MAP_SHARED, fd, 0);
if (mapStr == MAP_FAILED) {
close(fd);
return;
}
keymap = xkb_keymap_new_from_string(_glfw.wl.xkb.context,
mapStr,
XKB_KEYMAP_FORMAT_TEXT_V1,
0);
munmap(mapStr, size);
close(fd);
if (!keymap)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to compile keymap");
return;
}
state = xkb_state_new(keymap);
if (!state)
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to create XKB state");
xkb_keymap_unref(keymap);
return;
}
// Look up the preferred locale, falling back to "C" as default.
locale = getenv("LC_ALL");
if (!locale)
locale = getenv("LC_CTYPE");
if (!locale)
locale = getenv("LANG");
if (!locale)
locale = "C";
#ifdef HAVE_XKBCOMMON_COMPOSE_H
composeTable =
xkb_compose_table_new_from_locale(_glfw.wl.xkb.context, locale,
XKB_COMPOSE_COMPILE_NO_FLAGS);
if (composeTable)
{
composeState =
xkb_compose_state_new(composeTable, XKB_COMPOSE_STATE_NO_FLAGS);
xkb_compose_table_unref(composeTable);
if (composeState)
_glfw.wl.xkb.composeState = composeState;
else
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to create XKB compose state");
}
else
{
_glfwInputError(GLFW_PLATFORM_ERROR,
"Wayland: Failed to create XKB compose table");
}
#endif
xkb_keymap_unref(_glfw.wl.xkb.keymap);
xkb_state_unref(_glfw.wl.xkb.state);
_glfw.wl.xkb.keymap = keymap;
_glfw.wl.xkb.state = state;
_glfw.wl.xkb.controlMask =
1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Control");
_glfw.wl.xkb.altMask =
1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod1");
_glfw.wl.xkb.shiftMask =
1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Shift");
_glfw.wl.xkb.superMask =
1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod4");
_glfw.wl.xkb.capsLockMask =
1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Lock");
_glfw.wl.xkb.numLockMask =
1 << xkb_keymap_mod_get_index(_glfw.wl.xkb.keymap, "Mod2");
}
namespace ViewBackend {
class EventSource {
public:
static GSourceFuncs sourceFuncs;
GSource source;
GPollFD pfd;
struct wl_display* display;
};
GSourceFuncs EventSource::sourceFuncs = {
// prepare
[](GSource* base, gint* timeout) -> gboolean
{
auto* source = reinterpret_cast<EventSource*>(base);
struct wl_display* display = source->display;
*timeout = -1;
wl_display_flush(display);
wl_display_dispatch_pending(display);
return FALSE;
},
// check
[](GSource* base) -> gboolean
{
auto* source = reinterpret_cast<EventSource*>(base);
return !!source->pfd.revents;
},
// dispatch
[](GSource* base, GSourceFunc, gpointer) -> gboolean
{
auto* source = reinterpret_cast<EventSource*>(base);
struct wl_display* display = source->display;
if (source->pfd.revents & G_IO_IN)
wl_display_dispatch(display);
if (source->pfd.revents & (G_IO_ERR | G_IO_HUP))
return FALSE;
source->pfd.revents = 0;
return TRUE;
},
nullptr, // finalize
nullptr, // closure_callback
nullptr, // closure_marshall
};
const struct wl_registry_listener g_registryListener = {
// global
[](void* data, struct wl_registry* registry, uint32_t name, const char* interface, uint32_t)
{
auto& interfaces = *static_cast<WaylandDisplay::Interfaces*>(data);
if (!std::strcmp(interface, "wl_compositor"))
interfaces.compositor = static_cast<struct wl_compositor*>(wl_registry_bind(registry, name, &wl_compositor_interface, 1));
if (!std::strcmp(interface, "wl_data_device_manager"))
interfaces.data_device_manager = static_cast<struct wl_data_device_manager*>(wl_registry_bind(registry, name, &wl_data_device_manager_interface, 2));
if (!std::strcmp(interface, "wl_drm"))
interfaces.drm = static_cast<struct wl_drm*>(wl_registry_bind(registry, name, &wl_drm_interface, 2));
if (!std::strcmp(interface, "wl_seat"))
interfaces.seat = static_cast<struct wl_seat*>(wl_registry_bind(registry, name, &wl_seat_interface, 4));
if (!std::strcmp(interface, "xdg_shell"))
interfaces.xdg = static_cast<struct xdg_shell*>(wl_registry_bind(registry, name, &xdg_shell_interface, 1));
if (!std::strcmp(interface, "ivi_application"))
interfaces.ivi_application = static_cast<struct ivi_application*>(wl_registry_bind(registry, name, &ivi_application_interface, 1));
},
// global_remove
[](void*, struct wl_registry*, uint32_t) { },
};
static const struct xdg_shell_listener g_xdgShellListener = {
// ping
[](void*, struct xdg_shell* shell, uint32_t serial)
{
xdg_shell_pong(shell, serial);
},
};
static const struct wl_pointer_listener g_pointerListener = {
// enter
[](void* data, struct wl_pointer*, uint32_t serial, struct wl_surface* surface, wl_fixed_t, wl_fixed_t)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
auto it = seatData.inputClients.find(surface);
if (it != seatData.inputClients.end())
seatData.pointer.target = *it;
},
// leave
[](void* data, struct wl_pointer*, uint32_t serial, struct wl_surface* surface)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
auto it = seatData.inputClients.find(surface);
if (it != seatData.inputClients.end() && seatData.pointer.target.first == it->first)
seatData.pointer.target = { };
},
// motion
[](void* data, struct wl_pointer*, uint32_t time, wl_fixed_t fixedX, wl_fixed_t fixedY)
{
auto x = wl_fixed_to_int(fixedX);
auto y = wl_fixed_to_int(fixedY);
auto& pointer = static_cast<WaylandDisplay::SeatData*>(data)->pointer;
pointer.coords = { x, y };
if (pointer.target.first)
pointer.target.second->handlePointerEvent({ Input::PointerEvent::Motion, time, x, y, 0, 0 });
},
// button
[](void* data, struct wl_pointer*, uint32_t serial, uint32_t time, uint32_t button, uint32_t state)
{
static_cast<WaylandDisplay::SeatData*>(data)->serial = serial;
if (button >= BTN_MOUSE)
button = button - BTN_MOUSE + 1;
else
button = 0;
auto& pointer = static_cast<WaylandDisplay::SeatData*>(data)->pointer;
auto& coords = pointer.coords;
if (pointer.target.first)
pointer.target.second->handlePointerEvent(
{ Input::PointerEvent::Button, time, coords.first, coords.second, button, state });
},
// axis
[](void* data, struct wl_pointer*, uint32_t time, uint32_t axis, wl_fixed_t value)
{
auto& pointer = static_cast<WaylandDisplay::SeatData*>(data)->pointer;
auto& coords = pointer.coords;
if (pointer.target.first)
pointer.target.second->handleAxisEvent(
{ Input::AxisEvent::Motion, time, coords.first, coords.second, axis, -wl_fixed_to_int(value) });
},
};
static void
handleKeyEvent(WaylandDisplay::SeatData& seatData, uint32_t key, uint32_t state, uint32_t time)
{
auto& xkb = seatData.xkb;
uint32_t keysym = xkb_state_key_get_one_sym(xkb.state, key);
uint32_t unicode = xkb_state_key_get_utf32(xkb.state, key);
if (state == WL_KEYBOARD_KEY_STATE_PRESSED
&& xkb_compose_state_feed(xkb.composeState, keysym) == XKB_COMPOSE_FEED_ACCEPTED
&& xkb_compose_state_get_status(xkb.composeState) == XKB_COMPOSE_COMPOSED)
{
keysym = xkb_compose_state_get_one_sym(xkb.composeState);
unicode = xkb_keysym_to_utf32(keysym);
}
if (seatData.keyboard.target.first)
seatData.keyboard.target.second->handleKeyboardEvent({ time, keysym, unicode, !!state, xkb.modifiers });
}
static gboolean
repeatRateTimeout(void* data)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
handleKeyEvent(seatData, seatData.repeatData.key, seatData.repeatData.state, seatData.repeatData.time);
return G_SOURCE_CONTINUE;
}
static gboolean
repeatDelayTimeout(void* data)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
handleKeyEvent(seatData, seatData.repeatData.key, seatData.repeatData.state, seatData.repeatData.time);
seatData.repeatData.eventSource = g_timeout_add(seatData.repeatInfo.rate, static_cast<GSourceFunc>(repeatRateTimeout), data);
return G_SOURCE_REMOVE;
}
static const struct wl_keyboard_listener g_keyboardListener = {
// keymap
[](void* data, struct wl_keyboard*, uint32_t format, int fd, uint32_t size)
{
if (format != WL_KEYBOARD_KEYMAP_FORMAT_XKB_V1) {
close(fd);
return;
}
void* mapping = mmap(nullptr, size, PROT_READ, MAP_SHARED, fd, 0);
if (mapping == MAP_FAILED) {
close(fd);
return;
}
auto& xkb = static_cast<WaylandDisplay::SeatData*>(data)->xkb;
xkb.keymap = xkb_keymap_new_from_string(xkb.context, static_cast<char*>(mapping),
XKB_KEYMAP_FORMAT_TEXT_V1, XKB_KEYMAP_COMPILE_NO_FLAGS);
munmap(mapping, size);
close(fd);
if (!xkb.keymap)
return;
xkb.state = xkb_state_new(xkb.keymap);
if (!xkb.state)
return;
xkb.indexes.control = xkb_keymap_mod_get_index(xkb.keymap, XKB_MOD_NAME_CTRL);
xkb.indexes.alt = xkb_keymap_mod_get_index(xkb.keymap, XKB_MOD_NAME_ALT);
xkb.indexes.shift = xkb_keymap_mod_get_index(xkb.keymap, XKB_MOD_NAME_SHIFT);
},
// enter
[](void* data, struct wl_keyboard*, uint32_t serial, struct wl_surface* surface, struct wl_array*)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
auto it = seatData.inputClients.find(surface);
if (it != seatData.inputClients.end())
seatData.keyboard.target = *it;
},
// leave
[](void* data, struct wl_keyboard*, uint32_t serial, struct wl_surface* surface)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
auto it = seatData.inputClients.find(surface);
if (it != seatData.inputClients.end() && seatData.keyboard.target.first == it->first)
seatData.keyboard.target = { };
},
// key
[](void* data, struct wl_keyboard*, uint32_t serial, uint32_t time, uint32_t key, uint32_t state)
{
// IDK.
key += 8;
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
handleKeyEvent(seatData, key, state, time);
if (!seatData.repeatInfo.rate)
return;
if (state == WL_KEYBOARD_KEY_STATE_RELEASED
&& seatData.repeatData.key == key) {
if (seatData.repeatData.eventSource)
g_source_remove(seatData.repeatData.eventSource);
seatData.repeatData = { 0, 0, 0, 0 };
} else if (state == WL_KEYBOARD_KEY_STATE_PRESSED
&& xkb_keymap_key_repeats(seatData.xkb.keymap, key)) {
if (seatData.repeatData.eventSource)
g_source_remove(seatData.repeatData.eventSource);
seatData.repeatData = { key, time, state, g_timeout_add(seatData.repeatInfo.delay, static_cast<GSourceFunc>(repeatDelayTimeout), data) };
}
},
// modifiers
[](void* data, struct wl_keyboard*, uint32_t serial, uint32_t depressedMods, uint32_t latchedMods, uint32_t lockedMods, uint32_t group)
{
static_cast<WaylandDisplay::SeatData*>(data)->serial = serial;
auto& xkb = static_cast<WaylandDisplay::SeatData*>(data)->xkb;
xkb_state_update_mask(xkb.state, depressedMods, latchedMods, lockedMods, 0, 0, group);
auto& modifiers = xkb.modifiers;
modifiers = 0;
auto component = static_cast<xkb_state_component>(XKB_STATE_MODS_DEPRESSED | XKB_STATE_MODS_LATCHED);
if (xkb_state_mod_index_is_active(xkb.state, xkb.indexes.control, component))
modifiers |= Input::KeyboardEvent::Control;
if (xkb_state_mod_index_is_active(xkb.state, xkb.indexes.alt, component))
modifiers |= Input::KeyboardEvent::Alt;
if (xkb_state_mod_index_is_active(xkb.state, xkb.indexes.shift, component))
modifiers |= Input::KeyboardEvent::Shift;
},
// repeat_info
[](void* data, struct wl_keyboard*, int32_t rate, int32_t delay)
{
auto& repeatInfo = static_cast<WaylandDisplay::SeatData*>(data)->repeatInfo;
repeatInfo = { rate, delay };
// A rate of zero disables any repeating.
if (!rate) {
auto& repeatData = static_cast<WaylandDisplay::SeatData*>(data)->repeatData;
if (repeatData.eventSource) {
g_source_remove(repeatData.eventSource);
repeatData = { 0, 0, 0, 0 };
}
}
},
};
static const struct wl_touch_listener g_touchListener = {
// down
[](void* data, struct wl_touch*, uint32_t serial, uint32_t time, struct wl_surface* surface, int32_t id, wl_fixed_t x, wl_fixed_t y)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
int32_t arraySize = std::tuple_size<decltype(seatData.touch.targets)>::value;
if (id < 0 || id >= arraySize)
return;
auto& target = seatData.touch.targets[id];
assert(!target.first && !target.second);
auto it = seatData.inputClients.find(surface);
if (it == seatData.inputClients.end())
return;
target = { surface, it->second };
auto& touchPoints = seatData.touch.touchPoints;
touchPoints[id] = { Input::TouchEvent::Down, time, id, wl_fixed_to_int(x), wl_fixed_to_int(y) };
target.second->handleTouchEvent({ touchPoints, Input::TouchEvent::Down, id, time });
},
// up
[](void* data, struct wl_touch*, uint32_t serial, uint32_t time, int32_t id)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
seatData.serial = serial;
int32_t arraySize = std::tuple_size<decltype(seatData.touch.targets)>::value;
if (id < 0 || id >= arraySize)
return;
auto& target = seatData.touch.targets[id];
assert(target.first && target.second);
auto& touchPoints = seatData.touch.touchPoints;
auto& point = touchPoints[id];
point = { Input::TouchEvent::Up, time, id, point.x, point.y };
target.second->handleTouchEvent({ touchPoints, Input::TouchEvent::Up, id, time });
point = { Input::TouchEvent::Null, 0, 0, 0, 0 };
target = { nullptr, nullptr };
},
// motion
[](void* data, struct wl_touch*, uint32_t time, int32_t id, wl_fixed_t x, wl_fixed_t y)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
int32_t arraySize = std::tuple_size<decltype(seatData.touch.targets)>::value;
if (id < 0 || id >= arraySize)
return;
auto& target = seatData.touch.targets[id];
assert(target.first && target.second);
auto& touchPoints = seatData.touch.touchPoints;
touchPoints[id] = { Input::TouchEvent::Motion, time, id, wl_fixed_to_int(x), wl_fixed_to_int(y) };
target.second->handleTouchEvent({ touchPoints, Input::TouchEvent::Motion, id, time });
},
// frame
[](void*, struct wl_touch*)
{
// FIXME: Dispatching events via frame() would avoid dispatching events
// for every single event that's encapsulated in a frame with multiple
// other events.
},
// cancel
[](void*, struct wl_touch*) { },
};
static const struct wl_seat_listener g_seatListener = {
// capabilities
[](void* data, struct wl_seat* seat, uint32_t capabilities)
{
auto& seatData = *static_cast<WaylandDisplay::SeatData*>(data);
// WL_SEAT_CAPABILITY_POINTER
const bool hasPointerCap = capabilities & WL_SEAT_CAPABILITY_POINTER;
if (hasPointerCap && !seatData.pointer.object) {
seatData.pointer.object = wl_seat_get_pointer(seat);
wl_pointer_add_listener(seatData.pointer.object, &g_pointerListener, &seatData);
}
if (!hasPointerCap && seatData.pointer.object) {
wl_pointer_destroy(seatData.pointer.object);
seatData.pointer.object = nullptr;
}
// WL_SEAT_CAPABILITY_KEYBOARD
const bool hasKeyboardCap = capabilities & WL_SEAT_CAPABILITY_KEYBOARD;
if (hasKeyboardCap && !seatData.keyboard.object) {
seatData.keyboard.object = wl_seat_get_keyboard(seat);
wl_keyboard_add_listener(seatData.keyboard.object, &g_keyboardListener, &seatData);
}
if (!hasKeyboardCap && seatData.keyboard.object) {
wl_keyboard_destroy(seatData.keyboard.object);
seatData.keyboard.object = nullptr;
}
// WL_SEAT_CAPABILITY_TOUCH
const bool hasTouchCap = capabilities & WL_SEAT_CAPABILITY_TOUCH;
if (hasTouchCap && !seatData.touch.object) {
seatData.touch.object = wl_seat_get_touch(seat);
wl_touch_add_listener(seatData.touch.object, &g_touchListener, &seatData);
}
if (!hasTouchCap && seatData.touch.object) {
wl_touch_destroy(seatData.touch.object);
seatData.touch.object = nullptr;
}
},
// name
[](void*, struct wl_seat*, const char*) { }
};
WaylandDisplay& WaylandDisplay::singleton()
{
static WaylandDisplay display;
return display;
}
WaylandDisplay::WaylandDisplay()
{
m_display = wl_display_connect(nullptr);
m_registry = wl_display_get_registry(m_display);
wl_registry_add_listener(m_registry, &g_registryListener, &m_interfaces);
wl_display_roundtrip(m_display);
m_eventSource = g_source_new(&EventSource::sourceFuncs, sizeof(EventSource));
auto* source = reinterpret_cast<EventSource*>(m_eventSource);
source->display = m_display;
source->pfd.fd = wl_display_get_fd(m_display);
source->pfd.events = G_IO_IN | G_IO_ERR | G_IO_HUP;
source->pfd.revents = 0;
g_source_add_poll(m_eventSource, &source->pfd);
g_source_set_name(m_eventSource, "[WPE] WaylandDisplay");
g_source_set_priority(m_eventSource, G_PRIORITY_HIGH + 30);
g_source_set_can_recurse(m_eventSource, TRUE);
g_source_attach(m_eventSource, g_main_context_get_thread_default());
if (m_interfaces.xdg) {
xdg_shell_add_listener(m_interfaces.xdg, &g_xdgShellListener, nullptr);
xdg_shell_use_unstable_version(m_interfaces.xdg, 5);
}
wl_seat_add_listener(m_interfaces.seat, &g_seatListener, &m_seatData);
m_seatData.xkb.context = xkb_context_new(XKB_CONTEXT_NO_FLAGS);
m_seatData.xkb.composeTable = xkb_compose_table_new_from_locale(m_seatData.xkb.context, setlocale(LC_CTYPE, nullptr), XKB_COMPOSE_COMPILE_NO_FLAGS);
if (m_seatData.xkb.composeTable)
m_seatData.xkb.composeState = xkb_compose_state_new(m_seatData.xkb.composeTable, XKB_COMPOSE_STATE_NO_FLAGS);
}
WaylandDisplay::~WaylandDisplay()
{
if (m_eventSource)
g_source_unref(m_eventSource);
m_eventSource = nullptr;
if (m_interfaces.compositor)
wl_compositor_destroy(m_interfaces.compositor);
if (m_interfaces.data_device_manager)
wl_data_device_manager_destroy(m_interfaces.data_device_manager);
if (m_interfaces.drm)
wl_drm_destroy(m_interfaces.drm);
if (m_interfaces.seat)
wl_seat_destroy(m_interfaces.seat);
if (m_interfaces.xdg)
xdg_shell_destroy(m_interfaces.xdg);
if (m_interfaces.ivi_application)
ivi_application_destroy(m_interfaces.ivi_application);
m_interfaces = { nullptr, nullptr, nullptr, nullptr, nullptr, nullptr };
if (m_registry)
wl_registry_destroy(m_registry);
m_registry = nullptr;
if (m_display)
wl_display_disconnect(m_display);
m_display = nullptr;
if (m_seatData.pointer.object)
wl_pointer_destroy(m_seatData.pointer.object);
if (m_seatData.keyboard.object)
wl_keyboard_destroy(m_seatData.keyboard.object);
if (m_seatData.touch.object)
wl_touch_destroy(m_seatData.touch.object);
if (m_seatData.xkb.context)
xkb_context_unref(m_seatData.xkb.context);
if (m_seatData.xkb.keymap)
xkb_keymap_unref(m_seatData.xkb.keymap);
if (m_seatData.xkb.state)
xkb_state_unref(m_seatData.xkb.state);
if (m_seatData.xkb.composeTable)
xkb_compose_table_unref(m_seatData.xkb.composeTable);
if (m_seatData.xkb.composeState)
xkb_compose_state_unref(m_seatData.xkb.composeState);
if (m_seatData.repeatData.eventSource)
g_source_remove(m_seatData.repeatData.eventSource);
m_seatData = SeatData{ };
}
void WaylandDisplay::registerInputClient(struct wl_surface* surface, Input::Client* client)
{
#ifndef NDEBUG
auto result =
#endif
m_seatData.inputClients.insert({ surface, client });
assert(result.second);
}
void WaylandDisplay::unregisterInputClient(struct wl_surface* surface)
{
auto it = m_seatData.inputClients.find(surface);
assert(it != m_seatData.inputClients.end());
if (m_seatData.pointer.target.first == it->first)
m_seatData.pointer.target = { };
if (m_seatData.keyboard.target.first == it->first)
m_seatData.keyboard.target = { };
m_seatData.inputClients.erase(it);
}
} // namespace ViewBackend
/*
* Test a sequence of keysyms, resulting from a sequence of key presses,
* against the keysyms they're supposed to generate.
*
* - Each test runs with a clean state.
* - Each line in the test is made up of:
* + A keycode, given as a KEY_* from linux/input.h.
* + A direction - DOWN for press, UP for release, BOTH for
* immediate press + release, REPEAT to just get the syms.
* + A sequence of keysyms that should result from this keypress.
*
* The vararg format is:
* <KEY_*> <DOWN | UP | BOTH> <XKB_KEY_* (zero or more)> <NEXT | FINISH>
*
* See below for examples.
*/
int
test_key_seq_va(struct xkb_keymap *keymap, va_list ap)
{
struct xkb_state *state;
xkb_keycode_t kc;
int op;
xkb_keysym_t keysym;
const xkb_keysym_t *syms;
xkb_keysym_t sym;
unsigned int nsyms, i;
char ksbuf[64];
fprintf(stderr, "----\n");
state = xkb_state_new(keymap);
assert(state);
for (;;) {
kc = va_arg(ap, int) + EVDEV_OFFSET;
op = va_arg(ap, int);
nsyms = xkb_state_key_get_syms(state, kc, &syms);
if (nsyms == 1) {
sym = xkb_state_key_get_one_sym(state, kc);
syms = &sym;
}
fprintf(stderr, "got %u syms for keycode %u: [", nsyms, kc);
if (op == DOWN || op == BOTH)
xkb_state_update_key(state, kc, XKB_KEY_DOWN);
if (op == UP || op == BOTH)
xkb_state_update_key(state, kc, XKB_KEY_UP);
for (i = 0; i < nsyms; i++) {
keysym = va_arg(ap, int);
xkb_keysym_get_name(syms[i], ksbuf, sizeof(ksbuf));
fprintf(stderr, "%s%s", (i != 0) ? ", " : "", ksbuf);
if (keysym == FINISH || keysym == NEXT) {
xkb_keysym_get_name(syms[i], ksbuf, sizeof(ksbuf));
fprintf(stderr, "Did not expect keysym: %s.\n", ksbuf);
goto fail;
}
if (keysym != syms[i]) {
xkb_keysym_get_name(keysym, ksbuf, sizeof(ksbuf));
fprintf(stderr, "Expected keysym: %s. ", ksbuf);;
xkb_keysym_get_name(syms[i], ksbuf, sizeof(ksbuf));
fprintf(stderr, "Got keysym: %s.\n", ksbuf);;
goto fail;
}
}
if (nsyms == 0) {
keysym = va_arg(ap, int);
if (keysym != XKB_KEY_NoSymbol) {
xkb_keysym_get_name(keysym, ksbuf, sizeof(ksbuf));
fprintf(stderr, "Expected %s, but got no keysyms.\n", ksbuf);
goto fail;
}
}
fprintf(stderr, "]\n");
keysym = va_arg(ap, int);
if (keysym == NEXT)
continue;
if (keysym == FINISH)
break;
xkb_keysym_get_name(keysym, ksbuf, sizeof(ksbuf));
fprintf(stderr, "Expected keysym: %s. Didn't get it.\n", ksbuf);
goto fail;
}
static void
test_get_utf8_utf32(struct xkb_keymap *keymap)
{
char buf[256];
struct xkb_state *state = xkb_state_new(keymap);
assert(state);
#define TEST_KEY(key, expected_utf8, expected_utf32) do { \
assert(xkb_state_key_get_utf8(state, key + 8, NULL, 0) == strlen(expected_utf8)); \
assert(xkb_state_key_get_utf8(state, key + 8, buf, sizeof(buf)) == strlen(expected_utf8)); \
assert(memcmp(buf, expected_utf8, sizeof(expected_utf8)) == 0); \
assert(xkb_state_key_get_utf32(state, key + 8) == expected_utf32); \
} while (0)
/* Simple ASCII. */
TEST_KEY(KEY_A, "a", 0x61);
TEST_KEY(KEY_ESC, "\x1B", 0x1B);
TEST_KEY(KEY_1, "1", 0x31);
/* Invalid. */
TEST_KEY(XKB_KEYCODE_INVALID - 8, "", 0);
TEST_KEY(300, "", 0);
/* No string. */
TEST_KEY(KEY_LEFTCTRL, "", 0);
TEST_KEY(KEY_NUMLOCK, "", 0);
/* Multiple keysyms. */
TEST_KEY(KEY_6, "HELLO", 0);
TEST_KEY(KEY_7, "YES THIS IS DOG", 0);
/* Check truncation. */
memset(buf, 'X', sizeof(buf));
assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 0) == strlen("HELLO"));
assert(memcmp(buf, "X", 1) == 0);
assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 1) == strlen("HELLO"));
assert(memcmp(buf, "", 1) == 0);
assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 2) == strlen("HELLO"));
assert(memcmp(buf, "H", 2) == 0);
assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 3) == strlen("HELLO"));
assert(memcmp(buf, "HE", 3) == 0);
assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 5) == strlen("HELLO"));
assert(memcmp(buf, "HELL", 5) == 0);
assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 6) == strlen("HELLO"));
assert(memcmp(buf, "HELLO", 6) == 0);
assert(xkb_state_key_get_utf8(state, KEY_6 + 8, buf, 7) == strlen("HELLO"));
assert(memcmp(buf, "HELLO\0X", 7) == 0);
/* Switch to ru layout */
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
assert(xkb_state_key_get_layout(state, KEY_A + 8) == 1);
/* Non ASCII. */
TEST_KEY(KEY_ESC, "\x1B", 0x1B);
TEST_KEY(KEY_A, "ф", 0x0444);
TEST_KEY(KEY_Z, "я", 0x044F);
/* Switch back to us layout */
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
assert(xkb_state_key_get_layout(state, KEY_A + 8) == 0);
xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
TEST_KEY(KEY_A, "A", 0x41);
TEST_KEY(KEY_ESC, "\x1B", 0x1B);
TEST_KEY(KEY_1, "!", 0x21);
xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_UP);
TEST_KEY(KEY_6, "HELLO", 0);
TEST_KEY(KEY_7, "YES THIS IS DOG", 0);
xkb_state_unref(state);
}
static void
test_caps_keysym_transformation(struct xkb_keymap *keymap)
{
struct xkb_state *state = xkb_state_new(keymap);
xkb_mod_index_t caps, shift;
int nsyms;
xkb_keysym_t sym;
const xkb_keysym_t *syms;
assert(state);
/* See xkb_state_key_get_one_sym() for what's this all about. */
caps = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
assert(caps != XKB_MOD_INVALID && shift != XKB_MOD_INVALID);
assert(xkb_state_key_get_layout(state, KEY_A + 8) == 0);
assert(xkb_state_key_get_layout(state, KEY_SEMICOLON + 8) == 0);
/* Without caps, no transformation. */
assert(xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) == 0);
assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
assert(xkb_state_key_get_level(state, KEY_A + 8, 0) == 0);
sym = xkb_state_key_get_one_sym(state, KEY_A + 8);
assert(sym == XKB_KEY_a);
assert(xkb_state_key_get_level(state, KEY_SEMICOLON + 8, 0) == 0);
sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + 8);
assert(sym == XKB_KEY_eacute);
nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + 8, &syms);
assert(nsyms == 1 && syms[0] == XKB_KEY_eacute);
/* With shift, no transformation (only different level). */
xkb_state_update_key(state, KEY_LEFTSHIFT + 8, XKB_KEY_DOWN);
assert(xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) == 0);
assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) > 0);
assert(xkb_state_key_get_level(state, KEY_A + 8, 0) == 1);
sym = xkb_state_key_get_one_sym(state, KEY_A + 8);
assert(sym == XKB_KEY_A);
sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + 8);
assert(sym == XKB_KEY_odiaeresis);
nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + 8, &syms);
assert(nsyms == 1 && syms[0] == XKB_KEY_odiaeresis);
xkb_state_update_key(state, KEY_LEFTSHIFT + 8, XKB_KEY_UP);
assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
/* With caps, transform in same level, only with _get_one_sym(). */
xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_UP);
assert(xkb_state_mod_index_is_active(state, caps, XKB_STATE_MODS_EFFECTIVE) > 0);
assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
assert(xkb_state_key_get_level(state, KEY_A + 8, 0) == 1);
sym = xkb_state_key_get_one_sym(state, KEY_A + 8);
assert(sym == XKB_KEY_A);
assert(xkb_state_key_get_level(state, KEY_SEMICOLON + 8, 0) == 0);
sym = xkb_state_key_get_one_sym(state, KEY_SEMICOLON + 8);
assert(sym == XKB_KEY_Eacute);
nsyms = xkb_state_key_get_syms(state, KEY_SEMICOLON + 8, &syms);
assert(nsyms == 1 && syms[0] == XKB_KEY_eacute);
xkb_state_update_key(state, KEY_LEFTSHIFT + 8, XKB_KEY_UP);
assert(xkb_state_mod_index_is_active(state, shift, XKB_STATE_MODS_EFFECTIVE) == 0);
xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_CAPSLOCK + 8, XKB_KEY_UP);
xkb_state_unref(state);
}
static void
test_consume(struct xkb_keymap *keymap)
{
struct xkb_state *state;
xkb_mod_index_t alt, shift, caps, ctrl, mod5;
xkb_mod_mask_t mask;
state = xkb_state_new(keymap);
assert(state);
alt = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_ALT);
assert(alt != XKB_MOD_INVALID);
shift = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_SHIFT);
assert(shift != XKB_MOD_INVALID);
caps = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CAPS);
assert(caps != XKB_MOD_INVALID);
ctrl = xkb_keymap_mod_get_index(keymap, XKB_MOD_NAME_CTRL);
assert(ctrl != XKB_MOD_INVALID);
mod5 = xkb_keymap_mod_get_index(keymap, "Mod5");
assert(mod5 != XKB_MOD_INVALID);
/* Test remove_consumed() */
xkb_state_update_key(state, KEY_LEFTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_EQUAL + EVDEV_OFFSET, XKB_KEY_DOWN);
fprintf(stderr, "dumping state for Alt-Shift-+\n");
print_state(state);
mask = xkb_state_serialize_mods(state, XKB_STATE_MODS_EFFECTIVE);
assert(mask == ((1U << alt) | (1U << shift)));
mask = xkb_state_mod_mask_remove_consumed(state, KEY_EQUAL + EVDEV_OFFSET,
mask);
assert(mask == (1U << alt));
/* Test get_consumed_mods() */
mask = xkb_state_key_get_consumed_mods(state, KEY_EQUAL + EVDEV_OFFSET);
assert(mask == (1U << shift));
mask = xkb_state_key_get_consumed_mods(state, KEY_ESC + EVDEV_OFFSET);
assert(mask == 0);
xkb_state_unref(state);
/* Test is_consumed() - simple ALPHABETIC type. */
state = xkb_state_new(keymap);
assert(state);
mask = xkb_state_key_get_consumed_mods(state, KEY_A + EVDEV_OFFSET);
assert(mask == ((1U << shift) | (1U << caps)));
assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, caps) > 0);
assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, shift) > 0);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, caps) > 0);
assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, shift) > 0);
xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, caps) > 0);
assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, shift) > 0);
xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_UP);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, caps) > 0);
assert(xkb_state_mod_index_is_consumed(state, KEY_A + EVDEV_OFFSET, shift) > 0);
xkb_state_unref(state);
/* More complicated - CTRL+ALT */
state = xkb_state_new(keymap);
mask = xkb_state_key_get_consumed_mods(state, KEY_F1 + EVDEV_OFFSET);
assert(mask == ((1U << shift) | (1U << alt) | (1U << ctrl) | (1U << mod5)));
/* Shift is preserved. */
xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_DOWN);
mask = xkb_state_key_get_consumed_mods(state, KEY_F1 + EVDEV_OFFSET);
assert(mask == ((1U << alt) | (1U << ctrl) | (1U << mod5)));
xkb_state_update_key(state, KEY_LEFTSHIFT + EVDEV_OFFSET, XKB_KEY_UP);
mask = xkb_state_key_get_consumed_mods(state, KEY_F1 + EVDEV_OFFSET);
assert(mask == ((1U << shift) | (1U << alt) | (1U << ctrl) | (1U << mod5)));
assert(state);
xkb_state_unref(state);
}
static void
test_update_key(struct xkb_keymap *keymap)
{
struct xkb_state *state = xkb_state_new(keymap);
const xkb_keysym_t *syms;
xkb_keysym_t one_sym;
int num_syms;
assert(state);
/* LCtrl down */
xkb_state_update_key(state, KEY_LEFTCTRL + EVDEV_OFFSET, XKB_KEY_DOWN);
fprintf(stderr, "dumping state for LCtrl down:\n");
print_state(state);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
XKB_STATE_MODS_DEPRESSED) > 0);
/* LCtrl + RAlt down */
xkb_state_update_key(state, KEY_RIGHTALT + EVDEV_OFFSET, XKB_KEY_DOWN);
fprintf(stderr, "dumping state for LCtrl + RAlt down:\n");
print_state(state);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
XKB_STATE_MODS_DEPRESSED) > 0);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
XKB_STATE_MODS_DEPRESSED) > 0);
assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_DEPRESSED,
XKB_STATE_MATCH_ALL,
XKB_MOD_NAME_CTRL,
XKB_MOD_NAME_ALT,
NULL) > 0);
assert(xkb_state_mod_indices_are_active(state, XKB_STATE_MODS_DEPRESSED,
XKB_STATE_MATCH_ALL,
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_MODS_DEPRESSED,
XKB_STATE_MATCH_ALL,
XKB_MOD_NAME_ALT,
NULL) == 0);
assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_DEPRESSED,
XKB_STATE_MATCH_ALL |
XKB_STATE_MATCH_NON_EXCLUSIVE,
XKB_MOD_NAME_ALT,
NULL) > 0);
assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_DEPRESSED,
(XKB_STATE_MATCH_ANY |
XKB_STATE_MATCH_NON_EXCLUSIVE),
XKB_MOD_NAME_ALT,
NULL) > 0);
/* RAlt down */
xkb_state_update_key(state, KEY_LEFTCTRL + EVDEV_OFFSET, XKB_KEY_UP);
fprintf(stderr, "dumping state for RAlt down:\n");
print_state(state);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CTRL,
XKB_STATE_MODS_EFFECTIVE) == 0);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
XKB_STATE_MODS_DEPRESSED) > 0);
assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_DEPRESSED,
XKB_STATE_MATCH_ANY,
XKB_MOD_NAME_CTRL,
XKB_MOD_NAME_ALT,
NULL) > 0);
assert(xkb_state_mod_names_are_active(state, XKB_STATE_MODS_LATCHED,
XKB_STATE_MATCH_ANY,
XKB_MOD_NAME_CTRL,
XKB_MOD_NAME_ALT,
NULL) == 0);
/* none down */
xkb_state_update_key(state, KEY_RIGHTALT + EVDEV_OFFSET, XKB_KEY_UP);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_ALT,
XKB_STATE_MODS_EFFECTIVE) == 0);
/* Caps locked */
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
XKB_STATE_MODS_DEPRESSED) > 0);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
fprintf(stderr, "dumping state for Caps Lock:\n");
print_state(state);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
XKB_STATE_MODS_DEPRESSED) == 0);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
XKB_STATE_MODS_LOCKED) > 0);
assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) > 0);
num_syms = xkb_state_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
assert(num_syms == 1 && syms[0] == XKB_KEY_Q);
/* Num Lock locked */
xkb_state_update_key(state, KEY_NUMLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_NUMLOCK + EVDEV_OFFSET, XKB_KEY_UP);
fprintf(stderr, "dumping state for Caps Lock + Num Lock:\n");
print_state(state);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
XKB_STATE_MODS_LOCKED) > 0);
assert(xkb_state_mod_name_is_active(state, "Mod2",
XKB_STATE_MODS_LOCKED) > 0);
num_syms = xkb_state_key_get_syms(state, KEY_KP1 + EVDEV_OFFSET, &syms);
assert(num_syms == 1 && syms[0] == XKB_KEY_KP_1);
assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_NUM) > 0);
/* Num Lock unlocked */
xkb_state_update_key(state, KEY_NUMLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_NUMLOCK + EVDEV_OFFSET, XKB_KEY_UP);
/* Switch to group 2 */
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
assert(xkb_state_led_name_is_active(state, "Group 2") > 0);
assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_NUM) == 0);
/* Switch back to group 1. */
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_COMPOSE + EVDEV_OFFSET, XKB_KEY_UP);
/* Caps unlocked */
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_CAPSLOCK + EVDEV_OFFSET, XKB_KEY_UP);
assert(xkb_state_mod_name_is_active(state, XKB_MOD_NAME_CAPS,
XKB_STATE_MODS_EFFECTIVE) == 0);
assert(xkb_state_led_name_is_active(state, XKB_LED_NAME_CAPS) == 0);
num_syms = xkb_state_key_get_syms(state, KEY_Q + EVDEV_OFFSET, &syms);
assert(num_syms == 1 && syms[0] == XKB_KEY_q);
/* Multiple symbols */
num_syms = xkb_state_key_get_syms(state, KEY_6 + EVDEV_OFFSET, &syms);
assert(num_syms == 5 &&
syms[0] == XKB_KEY_H && syms[1] == XKB_KEY_E &&
syms[2] == XKB_KEY_L && syms[3] == XKB_KEY_L &&
syms[4] == XKB_KEY_O);
one_sym = xkb_state_key_get_one_sym(state, KEY_6 + EVDEV_OFFSET);
assert(one_sym == XKB_KEY_NoSymbol);
xkb_state_update_key(state, KEY_6 + EVDEV_OFFSET, XKB_KEY_DOWN);
xkb_state_update_key(state, KEY_6 + EVDEV_OFFSET, XKB_KEY_UP);
one_sym = xkb_state_key_get_one_sym(state, KEY_5 + EVDEV_OFFSET);
assert(one_sym == XKB_KEY_5);
xkb_state_unref(state);
}
