int uxkb_desc_init(struct uterm_input *input, const char *model, const char *layout, const char *variant, const char *options) { int ret; struct xkb_rule_names rmlvo = { .rules = "evdev", .model = model, .layout = layout, .variant = variant, .options = options, }; input->ctx = xkb_context_new(0); if (!input->ctx) { log_error("cannot create XKB context"); return -ENOMEM; } input->keymap = xkb_keymap_new_from_names(input->ctx, &rmlvo, 0); if (!input->keymap) { log_warn("failed to create keymap (%s, %s, %s, %s), " "reverting to default system keymap", model, layout, variant, options); rmlvo.model = ""; rmlvo.layout = ""; rmlvo.variant = ""; rmlvo.options = ""; input->keymap = xkb_keymap_new_from_names(input->ctx, &rmlvo, 0); if (!input->keymap) { log_warn("failed to create XKB keymap"); ret = -EFAULT; goto err_ctx; } } log_debug("new keyboard description (%s, %s, %s, %s)", model, layout, variant, options); return 0; err_ctx: xkb_context_unref(input->ctx); return ret; } void uxkb_desc_destroy(struct uterm_input *input) { xkb_keymap_unref(input->keymap); xkb_context_unref(input->ctx); }
QLibInputKeyboard::QLibInputKeyboard() #ifndef QT_NO_XKBCOMMON_EVDEV : m_ctx(0), m_keymap(0), m_state(0) #endif { #ifndef QT_NO_XKBCOMMON_EVDEV qCDebug(qLcLibInput) << "Using xkbcommon for key mapping"; m_ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS); if (!m_ctx) { qWarning("Failed to create xkb context"); return; } m_keymap = xkb_keymap_new_from_names(m_ctx, Q_NULLPTR, XKB_KEYMAP_COMPILE_NO_FLAGS); if (!m_keymap) { qWarning("Failed to compile keymap"); return; } m_state = xkb_state_new(m_keymap); if (!m_state) { qWarning("Failed to create xkb state"); return; } m_modindex[0] = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_CTRL); m_modindex[1] = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_ALT); m_modindex[2] = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_SHIFT); m_modindex[3] = xkb_keymap_mod_get_index(m_keymap, XKB_MOD_NAME_LOGO); m_repeatTimer.setSingleShot(true); connect(&m_repeatTimer, &QTimer::timeout, this, &QLibInputKeyboard::handleRepeat); #else qCWarning(qLcLibInput) << "X-less xkbcommon not available, not performing key mapping"; #endif }
static int kbdmap_new_from_names(kbdmap **out, kbdctx *kc, const char *model, const char *layout, const char *variant, const char *options) { _cleanup_(kbdmap_unrefp) kbdmap *km = NULL; struct xkb_rule_names rmlvo = { }; unsigned int i; assert_return(out, -EINVAL); km = new0(kbdmap, 1); if (!km) return -ENOMEM; km->ref = 1; rmlvo.rules = "evdev"; rmlvo.model = model; rmlvo.layout = layout; rmlvo.variant = variant; rmlvo.options = options; errno = 0; km->xkb_keymap = xkb_keymap_new_from_names(kc->xkb_context, &rmlvo, 0); if (!km->xkb_keymap) return errno > 0 ? -errno : -EFAULT; for (i = 0; i < IDEV_KBDMOD_CNT; ++i) { const char *t = kbdmap_modmap[i]; if (t) km->modmap[i] = xkb_keymap_mod_get_index(km->xkb_keymap, t); else km->modmap[i] = XKB_MOD_INVALID; } for (i = 0; i < IDEV_KBDLED_CNT; ++i) { const char *t = kbdmap_ledmap[i]; if (t) km->ledmap[i] = xkb_keymap_led_get_index(km->xkb_keymap, t); else km->ledmap[i] = XKB_LED_INVALID; } *out = km; km = NULL; return 0; }
static struct xkb_keymap * meta_backend_x11_get_keymap (MetaBackend *backend) { MetaBackendX11 *x11 = META_BACKEND_X11 (backend); MetaBackendX11Private *priv = meta_backend_x11_get_instance_private (x11); if (priv->keymap == NULL) { struct xkb_context *context = xkb_context_new (XKB_CONTEXT_NO_FLAGS); priv->keymap = xkb_x11_keymap_new_from_device (context, priv->xcb, xkb_x11_get_core_keyboard_device_id (priv->xcb), XKB_KEYMAP_COMPILE_NO_FLAGS); if (priv->keymap == NULL) priv->keymap = xkb_keymap_new_from_names (context, NULL, XKB_KEYMAP_COMPILE_NO_FLAGS); xkb_context_unref (context); } return priv->keymap; }
int main(int argc, char **argv) { struct xkb_context *ctx; struct xkb_keymap *keymap; struct xkb_rule_names names = { .rules = NULL, .model = NULL, .layout = NULL, .variant = NULL, .options = NULL, }; int rc; if (argc <= 1) { usage(); return 1; } if (!parse_options(argc, argv, &names)) return 1; ctx = xkb_context_new(XKB_CONTEXT_NO_FLAGS); assert(ctx); keymap = xkb_keymap_new_from_names(ctx, &names, XKB_KEYMAP_COMPILE_NO_FLAGS); rc = (keymap == NULL); if (rc == 0 && print) printf("%s\n", xkb_keymap_get_as_string(keymap, XKB_KEYMAP_FORMAT_TEXT_V1)); xkb_keymap_unref(keymap); xkb_context_unref(ctx); return rc; }
int uxkb_desc_init(struct uterm_input *input, const char *model, const char *layout, const char *variant, const char *options, const char *keymap) { int ret; struct xkb_rule_names rmlvo = { .rules = "evdev", .model = model, .layout = layout, .variant = variant, .options = options, }; input->ctx = xkb_context_new(0); if (!input->ctx) { log_error("cannot create XKB context"); return -ENOMEM; } /* If a complete keymap file was given, first try that. */ if (keymap && *keymap) { input->keymap = xkb_keymap_new_from_string(input->ctx, keymap, XKB_KEYMAP_FORMAT_TEXT_V1, 0); if (input->keymap) { log_debug("new keyboard description from memory"); return 0; } log_warn("cannot parse keymap, reverting to rmlvo"); } input->keymap = xkb_keymap_new_from_names(input->ctx, &rmlvo, 0); if (!input->keymap) { log_warn("failed to create keymap (%s, %s, %s, %s), " "reverting to default system keymap", model, layout, variant, options); rmlvo.model = ""; rmlvo.layout = ""; rmlvo.variant = ""; rmlvo.options = ""; input->keymap = xkb_keymap_new_from_names(input->ctx, &rmlvo, 0); if (!input->keymap) { log_warn("failed to create XKB keymap"); ret = -EFAULT; goto err_ctx; } } log_debug("new keyboard description (%s, %s, %s, %s)", model, layout, variant, options); return 0; err_ctx: xkb_context_unref(input->ctx); return ret; } void uxkb_desc_destroy(struct uterm_input *input) { xkb_keymap_unref(input->keymap); xkb_context_unref(input->ctx); }
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); }
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; }