static XkbDescPtr get_xkb (ClutterKeymapX11 *keymap_x11) { ClutterBackendX11 *backend_x11 = CLUTTER_BACKEND_X11 (keymap_x11->backend); if (keymap_x11->max_keycode == 0) XDisplayKeycodes (backend_x11->xdpy, &keymap_x11->min_keycode, &keymap_x11->max_keycode); if (keymap_x11->xkb_desc == NULL) { int flags = XkbKeySymsMask | XkbKeyTypesMask | XkbModifierMapMask | XkbVirtualModsMask; keymap_x11->xkb_desc = XkbGetMap (backend_x11->xdpy, flags, XkbUseCoreKbd); if (G_UNLIKELY (keymap_x11->xkb_desc == NULL)) { g_error ("Failed to get the keymap from XKB"); return NULL; } flags = XkbGroupNamesMask | XkbVirtualModNamesMask; XkbGetNames (backend_x11->xdpy, flags, keymap_x11->xkb_desc); update_modmap (backend_x11->xdpy, keymap_x11); } else if (keymap_x11->xkb_map_serial != backend_x11->keymap_serial) { int flags = XkbKeySymsMask | XkbKeyTypesMask | XkbModifierMapMask | XkbVirtualModsMask; CLUTTER_NOTE (BACKEND, "Updating XKB keymap"); XkbGetUpdatedMap (backend_x11->xdpy, flags, keymap_x11->xkb_desc); flags = XkbGroupNamesMask | XkbVirtualModNamesMask; XkbGetNames (backend_x11->xdpy, flags, keymap_x11->xkb_desc); update_modmap (backend_x11->xdpy, keymap_x11); keymap_x11->xkb_map_serial = backend_x11->keymap_serial; } if (keymap_x11->num_lock_mask == 0) keymap_x11->num_lock_mask = XkbKeysymToModifiers (backend_x11->xdpy, XK_Num_Lock); if (keymap_x11->scroll_lock_mask == 0) keymap_x11->scroll_lock_mask = XkbKeysymToModifiers (backend_x11->xdpy, XK_Scroll_Lock); return keymap_x11->xkb_desc; }
int main(void) { int evCode, errRet, rsnRet; int maj = XkbMajorVersion; int min = XkbMinorVersion; Display* disp = XkbOpenDisplay("", &evCode, &errRet, &maj, &min, &rsnRet); // State XkbStatePtr state = calloc(1, sizeof(XkbStateRec)); XkbGetState(disp, 0x100, state); // Names XkbDescPtr desc = XkbAllocKeyboard(); XkbGetNames(disp, XkbSymbolsNameMask, desc); Atom symNameAtom = desc->names->symbols; char* layouts = XGetAtomName(disp, symNameAtom); printf("%s\n", getActiveLayout(layouts, state->group)); unsigned int mask = XkbStateNotifyMask; XkbSelectEvents(disp, XkbUseCoreKbd, mask, mask); XkbEvent event; while (1) { XNextEvent(disp, &event.core); if (event.state.changed & 0x90) printf("%s\n", getActiveLayout(layouts, event.state.group)); } }
void KeyboardLayoutWidget::setKeyboard(XkbComponentNamesPtr names) { release(); if (xkb) XkbFreeKeyboard(xkb, 0, TRUE); if (names) { xkb = XkbGetKeyboardByName (QX11Info::display(), XkbUseCoreKbd, names, 0, XkbGBN_GeometryMask | XkbGBN_KeyNamesMask | XkbGBN_OtherNamesMask | XkbGBN_ClientSymbolsMask | XkbGBN_IndicatorMapMask, FALSE); xkbOnDisplay = FALSE; } else { xkb = XkbGetKeyboard (QX11Info::display(), XkbGBN_GeometryMask | XkbGBN_KeyNamesMask | XkbGBN_OtherNamesMask | XkbGBN_SymbolsMask | XkbGBN_IndicatorMapMask, XkbUseCoreKbd); XkbGetNames (QX11Info::display(), XkbAllNamesMask, xkb); xkbOnDisplay = TRUE; } if (xkb == NULL) return; alloc (); init(); initColors(); generatePixmap(true); repaint(); }
/* FIXME: add more languages, then copy to x11kbd.c */ int kbd_arch_get_host_mapping(void) { int n; int maps[KBD_MAPPING_NUM] = { KBD_MAPPING_US, KBD_MAPPING_UK, KBD_MAPPING_DE, KBD_MAPPING_DA, KBD_MAPPING_NO, KBD_MAPPING_FI, KBD_MAPPING_IT }; char str[KBD_MAPPING_NUM][3] = { "us", "uk", "de", "da", "no", "fi", "it"}; Display* _display; char* displayName = ""; _display = XOpenDisplay(displayName); XkbDescRec* _kbdDescPtr = XkbAllocKeyboard(); XkbGetNames(_display, XkbSymbolsNameMask, _kbdDescPtr); Atom symName = _kbdDescPtr -> names -> symbols; char* layoutString = XGetAtomName(_display, symName); XCloseDisplay(_display); char *p = layoutString; if (memcmp(p, "pc+", 3) == 0) { p += 3; if (p && (strlen(p) > 1)) { for (n = 1; n < KBD_MAPPING_NUM; n++) { if (memcmp(p, str[n], 2) == 0) { return maps[n]; } } } } return KBD_MAPPING_US; }
static XkbFileInfo * input_pad_xkb_get_file_info (InputPadGtkWindow *window) { Display *xdisplay = GDK_WINDOW_XDISPLAY (gtk_widget_get_window (GTK_WIDGET (window))); XkbFileInfo *xkb_info; xkb_info = g_new0 (XkbFileInfo, 1); xkb_info->type = XkmKeymapFile; xkb_info->xkb = XkbGetMap (xdisplay, XkbAllMapComponentsMask, XkbUseCoreKbd); if (xkb_info->xkb == NULL) { g_warning ("Could not get XKB map"); } if (XkbGetNames (xdisplay, XkbAllNamesMask, xkb_info->xkb) !=Success) { g_warning ("Could not get XKB names"); } if (XkbGetGeometry (xdisplay, xkb_info->xkb) !=Success) { g_warning ("Could not get geometry"); return NULL; } if (XkbChangeKbdDisplay (xdisplay, xkb_info) !=Success) { g_warning ("Could not get display"); return NULL; } return xkb_info; }
// 0 - Success int xkbleds_init() { KeyCode keys[NUM_LEDS]; XkbDescPtr xkb; char *ind_name = NULL; int j, mask; int idx[NUM_LEDS];/* NUM, CAPS, SCROLL: indicator index, for XKB */ // open X display d = XOpenDisplay(NULL); if (!d) return 1; // get keycodes for(i = 0; i < NUM_LEDS; i++) keys[i] = XKeysymToKeycode(d, key_syms[i]); // get the keyboard xkb = XkbAllocKeyboard(); if(!xkb){ XCloseDisplay(d); return 1; } if(XkbGetNames(d, XkbIndicatorNamesMask, xkb) != Success){ XkbFreeKeyboard(xkb, 0, True); XCloseDisplay(d); return 1; } // get masks and indexes of indicators for(i = 0; i < XkbNumIndicators; i++) { if(xkb->names->indicators[i]) ind_name = XGetAtomName(d, xkb->names->indicators[i]); for(j = 0; j < NUM_LEDS; j++){ if(ind_name && !strcmp(lock_names[j], ind_name)){ if(XkbGetNamedIndicator(d, xkb->names->indicators[i], &mask, NULL, NULL, NULL) == True){ masks[j] = 1 << mask; idx[j] = mask; } else { XkbFreeKeyboard(xkb, 0, True); XCloseDisplay(d); return 1; } } } if(ind_name){ free(ind_name); ind_name = NULL; } } // cleanup XkbFreeKeyboard(xkb, 0, True); XCloseDisplay(d); return 0; }
KeyboardLayoutWidget::KeyboardLayoutWidget(QWidget* parent): QWidget(parent), ratio(1.0), trackModifiers(false ) { uint i = 0; for (i = 0; i < sizeof(deadMapData) / sizeof(deadMapData[0]); i ++) deadMap[deadMapData[i].dead] = deadMapData[i].nondead; xkb = XkbGetKeyboard (QX11Info::display(), XkbGBN_GeometryMask | XkbGBN_KeyNamesMask | XkbGBN_OtherNamesMask | XkbGBN_SymbolsMask | XkbGBN_IndicatorMapMask, XkbUseCoreKbd); if (!xkb) return; groupLevels = pGroupsLevels; XkbGetNames (QX11Info::display(), XkbAllNamesMask, xkb); l3mod = XkbKeysymToModifiers (QX11Info::display(), XK_ISO_Level3_Shift); XkbSelectEventDetails (QX11Info::display(), XkbUseCoreKbd, XkbIndicatorStateNotify, xkb->indicators->phys_indicators, xkb->indicators->phys_indicators); xkbOnDisplay = true; int mask = (XkbStateNotifyMask | XkbNamesNotifyMask | XkbControlsNotifyMask | XkbIndicatorMapNotifyMask | XkbNewKeyboardNotifyMask); XkbSelectEvents (QX11Info::display(), XkbUseCoreKbd, mask, mask); mask = XkbGroupStateMask | XkbModifierStateMask; XkbSelectEventDetails (QX11Info::display(), XkbUseCoreKbd, XkbStateNotify, mask, mask); mask = (XkbGroupNamesMask | XkbIndicatorNamesMask); XkbSelectEventDetails (QX11Info::display(), XkbUseCoreKbd, XkbNamesNotify, mask, mask); alloc (); init(); initColors(); setFocusPolicy(Qt::StrongFocus); }
int freerdp_keyboard_load_map_from_xkbfile(void* display, RDP_SCANCODE x11_keycode_to_rdp_scancode[256]) { int i, j; boolean found; XkbDescPtr xkb; boolean status = false; if (display && (xkb = XkbGetMap(display, 0, XkbUseCoreKbd))) { if (XkbGetNames(display, XkbKeyNamesMask, xkb) == Success) { char xkb_keyname[5] = { 42, 42, 42, 42, 0 }; /* end-of-string at index 5 */ for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) { found = false; memcpy(xkb_keyname, xkb->names->keys[i].name, 4); if (strlen(xkb_keyname) < 1) continue; for (j = 0; j < ARRAY_SIZE(XKB_KEY_NAME_SCANCODE_TABLE); j++) { if (!strcmp(xkb_keyname, XKB_KEY_NAME_SCANCODE_TABLE[j].xkb_keyname)) { DEBUG_KBD("%4s: keycode: 0x%02X -> rdp scancode: 0x%04X", xkb_keyname, i, XKB_KEY_NAME_SCANCODE_TABLE[j].rdp_scancode); if (found) { DEBUG_KBD("Internal error! duplicate key %s!", xkb_keyname); } x11_keycode_to_rdp_scancode[i] = XKB_KEY_NAME_SCANCODE_TABLE[j].rdp_scancode; found = true; } } if (!found) { DEBUG_KBD("%4s: keycode: 0x%02X -> no RDP scancode found", xkb_keyname, i); } } status = true; } XkbFreeKeyboard(xkb, 0, 1); } return status; }
char* xkbGetGroup(char* buf, int len) { int xkbEventType, xkbError, reason_rtrn, mjr, mnr; char *display_name; XkbStateRec xkbstate; static Display *dpy = NULL; static XkbDescPtr xkbdesc = NULL; /* Lets begin */ if (!dpy) { display_name = NULL; mjr = XkbMajorVersion; mnr = XkbMinorVersion; dpy = XkbOpenDisplay(display_name, &xkbEventType, &xkbError, &mjr, &mnr, &reason_rtrn); } if (dpy == NULL) { strcpy(buf, "?"); return buf; } if ( Success != XkbGetState(dpy, XkbUseCoreKbd, &xkbstate) ) { strcpy(buf, "?"); return buf; } if (!xkbdesc) xkbdesc = XkbAllocKeyboard(); if (!xkbdesc) { strcpy(buf, "?"); return buf; } /* get the names of the layout */ if ( Success == XkbGetNames(dpy, 1<<12, xkbdesc)) { Atom iatoms[4]; char *iatomnames[4]; int i, j; for (i = 0, j = 0; i < 4; i++) if (xkbdesc->names->groups[i] != None) iatoms[j++] = xkbdesc->names->groups[i]; if (XGetAtomNames(dpy, iatoms, j, iatomnames)) buf = strndup(iatomnames[xkbstate.locked_group], len); } return buf; }
//Need to handle errors here properly. void getKbd(virtkey * cvirt){ if (cvirt->kbd) XkbFreeKeyboard (cvirt->kbd, XkbAllComponentsMask, True); cvirt->kbd = XkbGetKeyboard (cvirt->display, XkbCompatMapMask | XkbNamesMask | XkbGeometryMask, XkbUseCoreKbd); #if 0 /* test missing keyboard (LP: 526791) keyboard on/off every 10 seconds */ if (getenv ("VIRTKEY_DEBUG")) { if (cvirt->kbd && time(NULL) % 20 < 10) { XkbFreeKeyboard (cvirt->kbd, XkbAllComponentsMask, True); cvirt->kbd = NULL; } } #endif if (cvirt->kbd == NULL){ PyErr_SetString(virtkey_error, "XkbGetKeyboard failed to get keyboard from x server"); return; } /* Status stat = XkbGetGeometry (cvirt->display, cvirt->kbd); if (stat == BadValue) PyErr_SetString(virtkey_error, "Error getting keyboard geometry info, Bad Value.\n"); if (stat == BadImplementation) PyErr_SetString(virtkey_error, "Error getting keyboard geometry info, Bad Implementation.\n"); if (stat == BadName) PyErr_SetString(virtkey_error, "Error getting keyboard geometry info, Bad Name.\n"); if (stat == BadAlloc) PyErr_SetString(virtkey_error, "Error getting keyboard geometry info, Bad Alloc.\n"); */ if (XkbGetNames (cvirt->display, XkbAllNamesMask, cvirt->kbd) != Success) PyErr_SetString(virtkey_error, "Error getting key name info.\n"); return; }
/* looks up corrsct flag image for every language group and replaces * default_flag image when it is found. * Flag is derived from xkb symbolic name, that looks something like that * pc(pc105)+us+ru(phonetic):2+il(phonetic):3+group(shifts_toggle)+group(switch) * * Run 'xlsatoms | grep pc' to see your value. */ static void get_group_flags(XkbDescRec *kbd_desc_ptr) { char *symbols, *tmp, *tok; GdkPixbuf *flag; int no; ENTER; if (XkbGetNames(dpy, XkbSymbolsNameMask, kbd_desc_ptr) != Success) { ERR("XkbGetNames failed.\n"); RET(); } if (kbd_desc_ptr->names->symbols == None || (symbols = XGetAtomName(dpy, kbd_desc_ptr->names->symbols)) == NULL) { ERR("Can't get group symbol names\n"); RET(); } DBG("symbols=%s\n", symbols); for (tok = strtok(symbols, "+"); tok; tok = strtok(NULL, "+")) { DBG("tok=%s\n", tok); /* find group symbolic name (like en, us or ru) and group number */ tmp = strchr(tok, ':'); if (tmp) { if (sscanf(tmp+1, "%d", &no) != 1) { ERR("can't read group number in <%s> token\n", tok); goto out; } no--; } else { no = 0; } if (no < 0 || no >= ngroups) { ERR("Group number %d is out of range 1..%d in token <%s>\n", no, ngroups, tok); goto out; } for (tmp = tok; isalpha(*tmp); tmp++); *tmp = 0; /* if we have flag with same name, then replace default image. * otherwise do nothing */ if ((flag = get_flag(tok))) group[no].flag = flag; DBG("sym %s flag %sfound \n", tok, flag ? "" : "NOT "); } out: XFree(symbols); }
/* gets vital info to switch xkb language groups */ static void get_group_info() { XkbDescRec *kbd_desc_ptr; XkbStateRec xkb_state; int i; ENTER; kbd_desc_ptr = XkbAllocKeyboard(); if (!kbd_desc_ptr) { ERR("can't alloc kbd info\n"); exit(1); } //kbd_desc_ptr->dpy = GDK_DISPLAY(); if (XkbGetControls(dpy, XkbAllControlsMask, kbd_desc_ptr) != Success) { ERR("can't get Xkb controls\n"); goto out; } ngroups = kbd_desc_ptr->ctrls->num_groups; if (ngroups < 1) { ERR("No keyboard group found\n"); goto out; } if (XkbGetState(dpy, XkbUseCoreKbd, &xkb_state) != Success) { ERR("can't get Xkb state\n"); goto out; } cur_group = xkb_state.group; DBG("cur_group = %d ngroups = %d\n", cur_group, ngroups); if (XkbGetNames(dpy, XkbGroupNamesMask, kbd_desc_ptr) != Success) { ERR("Can't get group names\n"); goto out; } for (i = 0; i < ngroups; i++) { if (!(group[i].name = XGetAtomName(dpy, kbd_desc_ptr->names->groups[i]))) { ERR("Can't get name of group #%d\n", i); goto out; } group[i].flag = default_flag; DBG("group[%d].name=%s\n", i, group[i].name); } get_group_flags(kbd_desc_ptr); out: XkbFreeKeyboard(kbd_desc_ptr, 0, True); }
int init_keycodes_from_xkb(void *dpy, RdpKeycodes x_keycode_to_rdp_keycode) { int ret = 0; XkbDescPtr xkb; if (dpy && (xkb = XkbGetMap(dpy, 0, XkbUseCoreKbd))) { if (XkbGetNames(dpy, XkbKeyNamesMask, xkb) == Success) { char buf[5] = {42, 42, 42, 42, 0}; /* end-of-string at pos 5 */ int i, j; memset(x_keycode_to_rdp_keycode, 0, sizeof(x_keycode_to_rdp_keycode)); for (i = xkb->min_key_code; i <= xkb->max_key_code; i++) { memcpy(buf, xkb->names->keys[i].name, 4); /* TODO: Use more efficient search ... but it is so fast that it doesn't matter */ j = sizeof(virtualKeyboard) / sizeof(virtualKeyboard[0]) - 1; while (j >= 0) { if (virtualKeyboard[j].x_keyname && !strcmp(buf, virtualKeyboard[j].x_keyname)) break; j--; } if (j >= 0) { DEBUG_KBD("X key code %3d has keyname %-4s -> RDP keycode %d/%d", i, buf, virtualKeyboard[j].extended, virtualKeyboard[j].scancode); x_keycode_to_rdp_keycode[i].extended = virtualKeyboard[j].extended; x_keycode_to_rdp_keycode[i].keycode = virtualKeyboard[j].scancode; #ifdef WITH_DEBUG_KBD x_keycode_to_rdp_keycode[i].keyname = virtualKeyboard[j].x_keyname; #endif } else DEBUG_KBD("X key code %3d has keyname %-4s -> ??? - not found", i, buf); } ret = 1; } XkbFreeKeyboard(xkb, 0, 1); } return ret; }
char * getKeyboardLayout() { //Layout names are two char codes char activeLayout[3] = { '\0', '\0', '\0' }; // At the moment, my system will only switch between four layouts max char *layoutColors[4] = { colgreen, colred, colyellow, colblack }; // Grab name info XkbGetNames(dpy, XkbSymbolsNameMask, kbdDescPtr); // Get the actual symbol string, which looks like // pc+us+ru:2+fr:3+de:4+..... // where us, ru, fr, and de would be the available layouts, so we need to // copy the two-letter layout code that is currently active // Layout 0 is at 0+3 // Layout 1 is at 0+3+3 // Layout 2 is at 0+3+3+5 // Layout 3 is at 0+3+3+5+5 // Alloc layoutSymbols char *layoutSymbols = strdup(XGetAtomName(dpy, kbdDescPtr->names->symbols)); // Figure out which one is active and print it XkbStateRec xkbState; XkbGetState(dpy, XkbUseCoreKbd, &xkbState); int layoutOffset = xkbState.group*3 + 3; if(xkbState.group >= 2) { layoutOffset += (xkbState.group-1)*2; } // Copy the two-char code strncpy(activeLayout, &(layoutSymbols[layoutOffset]), 2); // print it //printf("%s\n", activeLayout); // clean up free(layoutSymbols); XkbFreeNames(kbdDescPtr, 0, True); return smprintf("%s[%s %s %s]", colcyan, layoutColors[(xkbState.group > 4 ? 4 : xkbState.group)], activeLayout, colcyan); }
std::string XKeyboard::get_kb_string() { XkbGetControls(_display, XkbAllControlsMask, _kbdDescPtr); XkbGetNames(_display, XkbSymbolsNameMask, _kbdDescPtr); Atom symNameAtom = _kbdDescPtr->names->symbols; CHECK(symNameAtom != None); char* kbsC = XGetAtomName(_display, symNameAtom); std::string kbs(kbsC); XFree(kbsC); CHECK(!kbs.empty()); return kbs; /* StringVector symNames; */ /* XkbSymbolParser symParser; */ /* symParser.parse(symName, symNames); */ /* return symNames; */ }
unsigned XkbReadFromServer(Display *dpy,unsigned need,unsigned want,XkbFileInfo *result) { unsigned which= need|want; unsigned tmp = 0; if ((result==NULL)||(dpy==NULL)) return which; if (which&XkmSymbolsMask) tmp= XkbAllMapComponentsMask; else if (which&XkmTypesMask) tmp= XkbKeyTypesMask; if (result->xkb==NULL) { result->xkb= XkbGetMap(dpy,tmp,XkbUseCoreKbd); if (!result->xkb) return which; else which&= ~(XkmSymbolsMask|XkmTypesMask|XkmVirtualModsMask); } else if ((tmp)&&(XkbGetUpdatedMap(dpy,tmp,result->xkb)==Success)) which&= ~(XkmSymbolsMask|XkmTypesMask|XkmVirtualModsMask); if (which&XkmIndicatorsMask) { if (XkbGetIndicatorMap(dpy,XkbAllIndicatorsMask,result->xkb)==Success) which&= ~XkmIndicatorsMask; } if (which&XkmCompatMapMask) { if (XkbGetCompatMap(dpy,XkbAllCompatMask,result->xkb)==Success) which&= ~XkmCompatMapMask; } if (which&XkmGeometryMask) { if (XkbGetGeometry(dpy,result->xkb)==Success) which&= ~XkmGeometryMask; } XkbGetNames(dpy,XkbAllNamesMask,result->xkb); return which; }
static int check_for_evdev(void) { SDL_SysWMinfo info; XkbDescPtr desc = NULL; int has_evdev = 0; char *keycodes = NULL; SDL_VERSION(&info.version); if (!SDL_GetWMInfo(&info)) { return 0; } desc = XkbGetMap(info.info.x11.display, XkbGBN_AllComponentsMask, XkbUseCoreKbd); if (desc && (XkbGetNames(info.info.x11.display, XkbKeycodesNameMask, desc) == Success)) { keycodes = XGetAtomName(info.info.x11.display, desc->names->keycodes); if (keycodes == NULL) { fprintf(stderr, "could not lookup keycode name\n"); } else if (strstart(keycodes, "evdev", NULL)) { has_evdev = 1; } else if (!strstart(keycodes, "xfree86", NULL)) { fprintf(stderr, "unknown keycodes `%s', please report to " "[email protected]\n", keycodes); } } if (desc) { XkbFreeKeyboard(desc, XkbGBN_AllComponentsMask, True); } if (keycodes) { XFree(keycodes); } return has_evdev; }
Boolean InitXkb(Display *theDisplay) { int i,opcode,errorBase,major,minor; XkbDescPtr xkb; unsigned int bit; unsigned int real,virtual,named,explicit,automatic; char *name; if (!XkbQueryExtension(theDisplay, &opcode, &xkbEventBase, &errorBase, &major, &minor)) return False; if (!XkbUseExtension(theDisplay,&major,&minor)) return False; XkbSelectEvents(theDisplay, XkbUseCoreKbd, XkbIndicatorStateNotifyMask|XkbIndicatorMapNotifyMask, XkbIndicatorStateNotifyMask|XkbIndicatorMapNotifyMask); XtSetEventDispatcher(theDisplay, xkbEventBase+XkbEventCode, XkbEventHandler); xkb=XkbGetMap(theDisplay,0,XkbUseCoreKbd); real=virtual=named=explicit=automatic=0; if (!xkb) { fprintf(stderr,"Couldn't get keymap\n"); return False; } if (XkbGetIndicatorMap(theDisplay,XkbAllIndicatorsMask,xkb)!=Success) { fprintf(stderr,"Couldn't read indicator map\n"); XkbFreeKeyboard(xkb,XkbAllComponentsMask,True); return False; } real=virtual=named=explicit=automatic=0; if (XkbGetNames(theDisplay,XkbIndicatorNamesMask,xkb)!=Success) { fprintf(stderr,"Couldn't read indicator names\n"); XkbFreeKeyboard(xkb,XkbAllComponentsMask,True); return False; } real=virtual=named=explicit=automatic=0; for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) { XkbIndicatorMapPtr map= &xkb->indicators->maps[i]; name = NULL; if (xkb->names->indicators[i]!=None) { named|= bit; name = XGetAtomName(theDisplay,xkb->names->indicators[i]); } if (name != NULL) { ledAtoms[i] = xkb->names->indicators[i]; ledNames[i] = XmStringCreate(name,XmSTRING_DEFAULT_CHARSET); } else { char temp[12]; sprintf(temp,"led%d\0",i+1); ledAtoms[i] = None; ledNames[i] = XmStringCreate(temp,XmSTRING_DEFAULT_CHARSET); } if (xkb->indicators->phys_indicators&bit) real|= bit; if ((((map->which_groups!=0)&&(map->groups!=0))|| ((map->which_mods!=0)&& ((map->mods.real_mods!=0)||(map->mods.vmods!=0)))|| (map->ctrls!=0))&& ((map->flags&XkbIM_NoAutomatic)==0)) { automatic|= bit; } else explicit|= bit; } virtual = ~real; if (options.useUnion) { if ((options.wantReal==NO) || (options.wantReal==DONT_CARE)) real = 0; if ((options.wantVirtual==NO) || (options.wantVirtual==DONT_CARE)) virtual = 0; if ((options.wantNamed==NO) || (options.wantNamed==DONT_CARE)) named = 0; if ((options.wantAutomatic==NO) || (options.wantAutomatic==DONT_CARE)) automatic = 0; if ((options.wantExplicit==NO) || (options.wantExplicit==DONT_CARE)) explicit = 0; options.wanted |= real|virtual|named|automatic|explicit; } else { if (options.wanted == DONT_CARE)
// Create key code translation tables // static void createKeyTables(void) { int scancode, key; memset(_glfw.x11.publicKeys, -1, sizeof(_glfw.x11.publicKeys)); if (_glfw.x11.xkb.available) { // Use XKB to determine physical key locations independently of the current // keyboard layout char name[XkbKeyNameLength + 1]; XkbDescPtr desc = XkbGetMap(_glfw.x11.display, 0, XkbUseCoreKbd); XkbGetNames(_glfw.x11.display, XkbKeyNamesMask, desc); // Find the X11 key code -> GLFW key code mapping for (scancode = desc->min_key_code; scancode <= desc->max_key_code; scancode++) { memcpy(name, desc->names->keys[scancode].name, XkbKeyNameLength); name[XkbKeyNameLength] = '\0'; // Map the key name to a GLFW key code. Note: We only map printable // keys here, and we use the US keyboard layout. The rest of the // keys (function keys) are mapped using traditional KeySym // translations. if (strcmp(name, "TLDE") == 0) key = GLFW_KEY_GRAVE_ACCENT; else if (strcmp(name, "AE01") == 0) key = GLFW_KEY_1; else if (strcmp(name, "AE02") == 0) key = GLFW_KEY_2; else if (strcmp(name, "AE03") == 0) key = GLFW_KEY_3; else if (strcmp(name, "AE04") == 0) key = GLFW_KEY_4; else if (strcmp(name, "AE05") == 0) key = GLFW_KEY_5; else if (strcmp(name, "AE06") == 0) key = GLFW_KEY_6; else if (strcmp(name, "AE07") == 0) key = GLFW_KEY_7; else if (strcmp(name, "AE08") == 0) key = GLFW_KEY_8; else if (strcmp(name, "AE09") == 0) key = GLFW_KEY_9; else if (strcmp(name, "AE10") == 0) key = GLFW_KEY_0; else if (strcmp(name, "AE11") == 0) key = GLFW_KEY_MINUS; else if (strcmp(name, "AE12") == 0) key = GLFW_KEY_EQUAL; else if (strcmp(name, "AD01") == 0) key = GLFW_KEY_Q; else if (strcmp(name, "AD02") == 0) key = GLFW_KEY_W; else if (strcmp(name, "AD03") == 0) key = GLFW_KEY_E; else if (strcmp(name, "AD04") == 0) key = GLFW_KEY_R; else if (strcmp(name, "AD05") == 0) key = GLFW_KEY_T; else if (strcmp(name, "AD06") == 0) key = GLFW_KEY_Y; else if (strcmp(name, "AD07") == 0) key = GLFW_KEY_U; else if (strcmp(name, "AD08") == 0) key = GLFW_KEY_I; else if (strcmp(name, "AD09") == 0) key = GLFW_KEY_O; else if (strcmp(name, "AD10") == 0) key = GLFW_KEY_P; else if (strcmp(name, "AD11") == 0) key = GLFW_KEY_LEFT_BRACKET; else if (strcmp(name, "AD12") == 0) key = GLFW_KEY_RIGHT_BRACKET; else if (strcmp(name, "AC01") == 0) key = GLFW_KEY_A; else if (strcmp(name, "AC02") == 0) key = GLFW_KEY_S; else if (strcmp(name, "AC03") == 0) key = GLFW_KEY_D; else if (strcmp(name, "AC04") == 0) key = GLFW_KEY_F; else if (strcmp(name, "AC05") == 0) key = GLFW_KEY_G; else if (strcmp(name, "AC06") == 0) key = GLFW_KEY_H; else if (strcmp(name, "AC07") == 0) key = GLFW_KEY_J; else if (strcmp(name, "AC08") == 0) key = GLFW_KEY_K; else if (strcmp(name, "AC09") == 0) key = GLFW_KEY_L; else if (strcmp(name, "AC10") == 0) key = GLFW_KEY_SEMICOLON; else if (strcmp(name, "AC11") == 0) key = GLFW_KEY_APOSTROPHE; else if (strcmp(name, "AB01") == 0) key = GLFW_KEY_Z; else if (strcmp(name, "AB02") == 0) key = GLFW_KEY_X; else if (strcmp(name, "AB03") == 0) key = GLFW_KEY_C; else if (strcmp(name, "AB04") == 0) key = GLFW_KEY_V; else if (strcmp(name, "AB05") == 0) key = GLFW_KEY_B; else if (strcmp(name, "AB06") == 0) key = GLFW_KEY_N; else if (strcmp(name, "AB07") == 0) key = GLFW_KEY_M; else if (strcmp(name, "AB08") == 0) key = GLFW_KEY_COMMA; else if (strcmp(name, "AB09") == 0) key = GLFW_KEY_PERIOD; else if (strcmp(name, "AB10") == 0) key = GLFW_KEY_SLASH; else if (strcmp(name, "BKSL") == 0) key = GLFW_KEY_BACKSLASH; else if (strcmp(name, "LSGT") == 0) key = GLFW_KEY_WORLD_1; else key = GLFW_KEY_UNKNOWN; if ((scancode >= 0) && (scancode < 256)) _glfw.x11.publicKeys[scancode] = key; } XkbFreeNames(desc, XkbKeyNamesMask, True); XkbFreeClientMap(desc, 0, True); } // Translate the un-translated key codes using traditional X11 KeySym // lookups for (scancode = 0; scancode < 256; scancode++) { if (_glfw.x11.publicKeys[scancode] < 0) _glfw.x11.publicKeys[scancode] = translateKeyCode(scancode); } }
int main(int argc, char *argv[]) { Widget toplevel; XtAppContext app_con; Widget panel; Widget leds[XkbNumIndicators]; register int i; unsigned bit; unsigned n; XkbDescPtr xkb; XkbEvent ev; static Arg boxArgs[]= {{ XtNorientation, (XtArgVal)XtorientHorizontal }}; static Arg onArgs[]= {{ XtNon, (XtArgVal)True }}; static Arg offArgs[]= {{ XtNon, (XtArgVal)False }}; static char * fallback_resources[] = { "*Box*background: grey40", NULL }; uSetEntryFile(NullString); uSetDebugFile(NullString); uSetErrorFile(NullString); bzero(leds,XkbNumIndicators*sizeof(Widget)); toplevel = XtOpenApplication(&app_con, "XkbLEDPanel", NULL, 0, &argc, argv, fallback_resources, sessionShellWidgetClass, NULL, ZERO); if (toplevel==NULL) { uFatalError("Couldn't create application top level\n"); return 1; } if ((argc>1)&&(!parseArgs(argc,argv))) { usage(argv[0]); return 1; } if ((wanted==0)&&(wantNamed==DONT_CARE)&&(wantExplicit==DONT_CARE)&& (wantAutomatic==DONT_CARE)&&(wantReal==DONT_CARE)) { wantNamed= YES; wantReal= YES; wantAutomatic= YES; } outDpy= XtDisplay(toplevel); if (inDpyName!=NULL) { inDpy= GetDisplay(argv[0],inDpyName); if (!inDpy) return 1; } else { inDpy= outDpy; } if (inDpy) { int i1,mn,mj; mj= XkbMajorVersion; mn= XkbMinorVersion; if (!XkbLibraryVersion(&mj,&mn)) { uInformation("%s was compiled with XKB version %d.%02d\n", argv[0],XkbMajorVersion,XkbMinorVersion); uError("X library supports incompatible version %d.%02d\n", mj,mn); } if (!XkbQueryExtension(inDpy,&i1,&evBase,&errBase,&mj,&mn)) { uFatalError("Server doesn't support a compatible XKB\n"); return 1; } } else { uFatalError("No input display\n"); return 1; } panel= XtCreateManagedWidget("xkbleds",boxWidgetClass,toplevel,boxArgs,1); if (panel==NULL) { uFatalError("Couldn't create list of leds\n"); return 1; } real= virtual= named= explicit= automatic= 0; if (wantReal || wantNamed || wantAutomatic || wantExplicit || wantVirtual) { register int i,bit; xkb= XkbGetMap(inDpy,0,XkbUseCoreKbd); if (!xkb) { uFatalError("Couldn't read keymap\n"); return 1; } if (XkbGetIndicatorMap(inDpy,XkbAllIndicatorsMask,xkb)!=Success) { uFatalError("Couldn't read indicator map\n"); return 1; } if (XkbGetNames(inDpy,XkbAllNamesMask,xkb)!=Success) { uFatalError("Couldn't read indicator names\n"); return 1; } for (i=0,bit=1;i<XkbNumIndicators;i++,bit<<=1) { XkbIndicatorMapPtr map= &xkb->indicators->maps[i]; if (xkb->names->indicators[i]!=None) named|= bit; if (xkb->indicators->phys_indicators&bit) real|= bit; if ((((map->which_groups!=0)&&(map->groups!=0))|| ((map->which_mods!=0)&& ((map->mods.real_mods!=0)||(map->mods.vmods!=0)))|| (map->ctrls!=0))&& ((map->flags&XkbIM_NoAutomatic)==0)) { automatic|= bit; } else explicit|= bit; } virtual= ~real; if (wantReal==NO) real= ~real; else if (wantReal==DONT_CARE) real= (useUnion?0:~0); if (wantVirtual==NO) virtual= ~virtual; else if (wantVirtual==DONT_CARE) virtual= (useUnion?0:~0); if (wantNamed==NO) named= ~named; else if (wantNamed==DONT_CARE) named= (useUnion?0:~0); if (wantAutomatic==NO) automatic= ~automatic; else if (wantAutomatic==DONT_CARE) automatic= (useUnion?0:~0); if (wantExplicit==NO) explicit= ~explicit; else if (wantExplicit==DONT_CARE) explicit= (useUnion?0:~0);