static int vfbKeybdProc(DeviceIntPtr pDevice, int onoff) { KeySymsRec keySyms; CARD8 modMap[MAP_LENGTH]; DevicePtr pDev = (DevicePtr)pDevice; switch (onoff) { case DEVICE_INIT: GetLK201Mappings(&keySyms, modMap); InitKeyboardDeviceStruct(pDev, &keySyms, modMap, (BellProcPtr)NoopDDA, (KbdCtrlProcPtr)NoopDDA); break; case DEVICE_ON: pDev->on = TRUE; break; case DEVICE_OFF: pDev->on = FALSE; break; case DEVICE_CLOSE: break; } return Success; }
static int KeyboardProc( DevicePtr pKbd, int what, int argc, char *argv[]) { KeySymsRec keySyms; keySyms.minKeyCode = 8; keySyms.maxKeyCode = 8; keySyms.mapWidth = 1; keySyms.map = printKeyMap; switch(what) { case DEVICE_INIT: InitKeyboardDeviceStruct(pKbd, &keySyms, printModMap, (BellProcPtr)BellProc, KeyControlProc); break; case DEVICE_ON: break; case DEVICE_OFF: break; case DEVICE_CLOSE: break; } return Success; }
static int KdKeybdProc(DeviceIntPtr pDevice, int onoff) { Bool ret; DevicePtr pDev = (DevicePtr)pDevice; #ifdef XKB XkbComponentNamesRec names; #endif if (!pDev) return BadImplementation; switch (onoff) { case DEVICE_INIT: if (pDev != LookupKeyboardDevice()) { return !Success; } #ifndef XKB ret = InitKeyboardDeviceStruct(pDev, &kdKeySyms, kdModMap, KdBell, KdKbdCtrl); #else memset(&names, 0, sizeof(XkbComponentNamesRec)); if (XkbInitialMap) names.keymap = XkbInitialMap; XkbSetRulesDflts ("base", "pc101", "us", NULL, NULL); ret = XkbInitKeyboardDeviceStruct ((DeviceIntPtr) pDev, &names, &kdKeySyms, kdModMap, KdBell, KdKbdCtrl); #endif if (!ret) return BadImplementation; break; case DEVICE_ON: pDev->on = TRUE; pKdKeyboard = pDevice; if (kdKeyboardFuncs) (*kdKeyboardFuncs->Init) (); break; case DEVICE_OFF: case DEVICE_CLOSE: pKdKeyboard = 0; if (pDev->on) { pDev->on = FALSE; if (kdKeyboardFuncs) (*kdKeyboardFuncs->Fini) (); } break; } return Success; }
int winKeybdProc (DeviceIntPtr pDeviceInt, int iState) { DevicePtr pDevice = (DevicePtr) pDeviceInt; XkbSrvInfoPtr xkbi; XkbControlsPtr ctrl; switch (iState) { case DEVICE_INIT: winConfigKeyboard (pDeviceInt); /* FIXME: Maybe we should use winGetKbdLeds () here? */ defaultKeyboardControl.leds = g_winInfo.keyboard.leds; winErrorFVerb(2, "Rules = \"%s\" Model = \"%s\" Layout = \"%s\"" " Variant = \"%s\" Options = \"%s\"\n", g_winInfo.xkb.rules ? g_winInfo.xkb.rules : "none", g_winInfo.xkb.model ? g_winInfo.xkb.model : "none", g_winInfo.xkb.layout ? g_winInfo.xkb.layout : "none", g_winInfo.xkb.variant ? g_winInfo.xkb.variant : "none", g_winInfo.xkb.options ? g_winInfo.xkb.options : "none"); InitKeyboardDeviceStruct (pDeviceInt, &g_winInfo.xkb, winKeybdBell, winKeybdCtrl); xkbi = pDeviceInt->key->xkbInfo; if ((xkbi != NULL) && (xkbi->desc != NULL)) { ctrl = xkbi->desc->ctrls; ctrl->repeat_delay = g_winInfo.keyboard.delay; ctrl->repeat_interval = 1000/g_winInfo.keyboard.rate; } else { winErrorFVerb (1, "winKeybdProc - Error initializing keyboard AutoRepeat\n"); } break; case DEVICE_ON: pDevice->on = TRUE; // immediately copy the state of this keyboard device to the VCK // (which otherwise happens lazily after the first keypress) CopyKeyClass(pDeviceInt, inputInfo.keyboard); break; case DEVICE_CLOSE: case DEVICE_OFF: pDevice->on = FALSE; break; } return Success; }
/* Get the Darwin keyboard map and compute an equivalent X keyboard map and modifier map. Set the new keyboard device structure. */ void DarwinKeyboardInit (DeviceIntPtr pDev) { KeySymsRec keysyms; BellProcPtr bellProc; load_keyboard_mapping (&keysyms); /* Initialize the seed, so we don't reload the keymap unnecessarily (and possibly overwrite xinitrc changes) */ DarwinSystemKeymapSeed (); bellProc = QuartzBell; InitKeyboardDeviceStruct ((DevicePtr) pDev, &keysyms, info.mod_map, bellProc, DarwinChangeKeyboardControl); }
static int vfbKeybdProc(DeviceIntPtr pDevice, int onoff) { DevicePtr pDev = (DevicePtr) pDevice; switch (onoff) { case DEVICE_INIT: InitKeyboardDeviceStruct(pDevice, NULL, NULL, NULL); break; case DEVICE_ON: pDev->on = TRUE; break; case DEVICE_OFF: pDev->on = FALSE; break; case DEVICE_CLOSE: break; } return Success; }
Bool XkbInitKeyboardDeviceStruct( DeviceIntPtr dev, XkbComponentNamesPtr names, KeySymsPtr pSymsIn, CARD8 pModsIn[], void (*bellProc)( int /*percent*/, DeviceIntPtr /*device*/, pointer /*ctrl*/, int), void (*ctrlProc)( DeviceIntPtr /*device*/, KeybdCtrl * /*ctrl*/)) { XkbFileInfo finfo; KeySymsRec tmpSyms,*pSyms; CARD8 tmpMods[XkbMaxLegalKeyCode+1],*pMods; char name[PATH_MAX],*rules; Bool ok=False; XPointer config; XkbComponentNamesRec cfgNames; XkbRF_VarDefsRec defs; if ((dev->key!=NULL)||(dev->kbdfeed!=NULL)) return False; pSyms= pSymsIn; pMods= pModsIn; bzero(&defs,sizeof(XkbRF_VarDefsRec)); bzero(&cfgNames,sizeof(XkbComponentNamesRec)); rules= XkbGetRulesDflts(&defs); config= XkbDDXPreloadConfig(&rules,&defs,&cfgNames,dev); /* * The strings are duplicated because it is not guaranteed that * they are allocated, or that they are allocated for every server * generation. Eventually they will be freed at the end of this * function. */ if (names->keymap) names->keymap = _XkbDupString(names->keymap); if (names->keycodes) names->keycodes = _XkbDupString(names->keycodes); if (names->types) names->types = _XkbDupString(names->types); if (names->compat) names->compat = _XkbDupString(names->compat); if (names->geometry) names->geometry = _XkbDupString(names->geometry); if (names->symbols) names->symbols = _XkbDupString(names->symbols); if (defs.model && defs.layout && rules) { XkbComponentNamesRec rNames; bzero(&rNames,sizeof(XkbComponentNamesRec)); if (XkbDDXNamesFromRules(dev,rules,&defs,&rNames)) { if (rNames.keymap) { if (!names->keymap) names->keymap = rNames.keymap; else _XkbFree(rNames.keymap); } if (rNames.keycodes) { if (!names->keycodes) names->keycodes = rNames.keycodes; else _XkbFree(rNames.keycodes); } if (rNames.types) { if (!names->types) names->types = rNames.types; else _XkbFree(rNames.types); } if (rNames.compat) { if (!names->compat) names->compat = rNames.compat; else _XkbFree(rNames.compat); } if (rNames.symbols) { if (!names->symbols) names->symbols = rNames.symbols; else _XkbFree(rNames.symbols); } if (rNames.geometry) { if (!names->geometry) names->geometry = rNames.geometry; else _XkbFree(rNames.geometry); } XkbSetRulesUsed(&defs); } } if (cfgNames.keymap){ if (names->keymap) _XkbFree(names->keymap); names->keymap= cfgNames.keymap; } if (cfgNames.keycodes){ if (names->keycodes) _XkbFree(names->keycodes); names->keycodes= cfgNames.keycodes; } if (cfgNames.types) { if (names->types) _XkbFree(names->types); names->types= cfgNames.types; } if (cfgNames.compat) { if (names->compat) _XkbFree(names->compat); names->compat= cfgNames.compat; } if (cfgNames.symbols){ if (names->symbols) _XkbFree(names->symbols); names->symbols= cfgNames.symbols; } if (cfgNames.geometry) { if (names->geometry) _XkbFree(names->geometry); names->geometry= cfgNames.geometry; } if (names->keymap) { XkbComponentNamesRec tmpNames; bzero(&tmpNames,sizeof(XkbComponentNamesRec)); tmpNames.keymap = names->keymap; ok = (Bool) XkbDDXLoadKeymapByNames(dev,&tmpNames,XkmAllIndicesMask,0, &finfo,name,PATH_MAX); } if (!(ok && (finfo.xkb!=NULL))) ok = (Bool) XkbDDXLoadKeymapByNames(dev,names,XkmAllIndicesMask,0, &finfo,name,PATH_MAX); if (ok && (finfo.xkb!=NULL)) { XkbDescPtr xkb; KeyCode minKC,maxKC; xkb= finfo.xkb; minKC= xkb->min_key_code; maxKC= xkb->max_key_code; if (XkbIsLegalKeycode(minKC)&&XkbIsLegalKeycode(maxKC)&&(minKC<=maxKC)&& ((minKC!=pSyms->minKeyCode)||(maxKC!=pSyms->maxKeyCode))) { if (xkb->map!=NULL) { KeySym *inSym,*outSym; int width= pSymsIn->mapWidth; tmpSyms.minKeyCode= minKC; tmpSyms.maxKeyCode= maxKC; if (minKC<pSymsIn->minKeyCode) minKC= pSymsIn->minKeyCode; if (maxKC>pSymsIn->maxKeyCode) maxKC= pSymsIn->maxKeyCode; tmpSyms.mapWidth= width; tmpSyms.map= _XkbTypedCalloc(width*XkbNumKeys(xkb),KeySym); inSym= &pSymsIn->map[(minKC-pSymsIn->minKeyCode)*width]; outSym= &tmpSyms.map[(minKC-tmpSyms.minKeyCode)*width]; memcpy(outSym,inSym,((maxKC-minKC+1)*width)*sizeof(KeySym)); pSyms= &tmpSyms; } if ((xkb->map!=NULL)&&(xkb->map->modmap!=NULL)) { bzero(tmpMods,XkbMaxKeyCount); memcpy(tmpMods,xkb->map->modmap,maxKC+1); pMods= tmpMods; } } _XkbInitFileInfo= &finfo; } else { LogMessage(X_WARNING, "Couldn't load XKB keymap, falling back to pre-XKB keymap\n"); } ok= InitKeyboardDeviceStruct((DevicePtr)dev,pSyms,pMods,bellProc,ctrlProc); if ((config!=NULL)&&(dev && dev->key && dev->key->xkbInfo)) XkbDDXApplyConfig(config,dev->key->xkbInfo); _XkbInitFileInfo= NULL; if ((pSyms==&tmpSyms)&&(pSyms->map!=NULL)) { _XkbFree(pSyms->map); pSyms->map= NULL; } if (names->keymap) _XkbFree(names->keymap); names->keymap = NULL; if (names->keycodes) _XkbFree(names->keycodes); names->keycodes = NULL; if (names->types) _XkbFree(names->types); names->types = NULL; if (names->compat) _XkbFree(names->compat); names->compat = NULL; if (names->geometry) _XkbFree(names->geometry); names->geometry = NULL; if (names->symbols) _XkbFree(names->symbols); names->symbols = NULL; return ok; }
int winKeybdProc (DeviceIntPtr pDeviceInt, int iState) { KeySymsRec keySyms; CARD8 modMap[MAP_LENGTH]; DevicePtr pDevice = (DevicePtr) pDeviceInt; #ifdef XKB XkbComponentNamesRec names; XkbSrvInfoPtr xkbi; XkbControlsPtr ctrl; #endif switch (iState) { case DEVICE_INIT: winConfigKeyboard (pDeviceInt); winGetKeyMappings (&keySyms, modMap); #ifdef XKB /* FIXME: Maybe we should use winGetKbdLeds () here? */ defaultKeyboardControl.leds = g_winInfo.keyboard.leds; #else defaultKeyboardControl.leds = g_winInfo.keyboard.leds; #endif #ifdef XKB if (g_winInfo.xkb.disable) { #endif InitKeyboardDeviceStruct (pDevice, &keySyms, modMap, winKeybdBell, winKeybdCtrl); #ifdef XKB } else { if (XkbInitialMap) { names.keymap = XkbInitialMap; names.keycodes = NULL; names.types = NULL; names.compat = NULL; names.symbols = NULL; names.geometry = NULL; } else { names.keymap = g_winInfo.xkb.keymap; names.keycodes = g_winInfo.xkb.keycodes; names.types = g_winInfo.xkb.types; names.compat = g_winInfo.xkb.compat; names.symbols = g_winInfo.xkb.symbols; names.geometry = g_winInfo.xkb.geometry; } winErrorFVerb(2, "Rules = \"%s\" Model = \"%s\" Layout = \"%s\"" " Variant = \"%s\" Options = \"%s\"\n", g_winInfo.xkb.rules, g_winInfo.xkb.model, g_winInfo.xkb.layout, g_winInfo.xkb.variant, g_winInfo.xkb.options); XkbSetRulesDflts (g_winInfo.xkb.rules, g_winInfo.xkb.model, g_winInfo.xkb.layout, g_winInfo.xkb.variant, g_winInfo.xkb.options); XkbInitKeyboardDeviceStruct (pDeviceInt, &names, &keySyms, modMap, winKeybdBell, winKeybdCtrl); } #endif #ifdef XKB if (!g_winInfo.xkb.disable) { xkbi = pDeviceInt->key->xkbInfo; if (xkbi != NULL) { ctrl = xkbi->desc->ctrls; ctrl->repeat_delay = g_winInfo.keyboard.delay; ctrl->repeat_interval = 1000/g_winInfo.keyboard.rate; } else { winErrorFVerb (1, "winKeybdProc - Error initializing keyboard AutoRepeat (No XKB)\n"); } } #endif g_winInternalModeKeyStatesPtr = &(pDeviceInt->key->state); break; case DEVICE_ON: pDevice->on = TRUE; g_winInternalModeKeyStatesPtr = &(pDeviceInt->key->state); break; case DEVICE_CLOSE: case DEVICE_OFF: pDevice->on = FALSE; g_winInternalModeKeyStatesPtr = NULL; break; } return Success; }
int xnestKeyboardProc(DeviceIntPtr pDev, int onoff) { XModifierKeymap *modifier_keymap; KeySym *keymap; int mapWidth; int min_keycode, max_keycode; KeySymsRec keySyms; CARD8 modmap[MAP_LENGTH]; int i, j; XKeyboardState values; XkbDescPtr xkb; int op, event, error, major, minor; switch (onoff) { case DEVICE_INIT: XDisplayKeycodes(xnestDisplay, &min_keycode, &max_keycode); #ifdef _XSERVER64 { KeySym64 *keymap64; int len; keymap64 = XGetKeyboardMapping(xnestDisplay, min_keycode, max_keycode - min_keycode + 1, &mapWidth); len = (max_keycode - min_keycode + 1) * mapWidth; keymap = xallocarray(len, sizeof(KeySym)); for (i = 0; i < len; ++i) keymap[i] = keymap64[i]; XFree(keymap64); } #else keymap = XGetKeyboardMapping(xnestDisplay, min_keycode, max_keycode - min_keycode + 1, &mapWidth); #endif memset(modmap, 0, sizeof(modmap)); modifier_keymap = XGetModifierMapping(xnestDisplay); for (j = 0; j < 8; j++) for (i = 0; i < modifier_keymap->max_keypermod; i++) { CARD8 keycode; if ((keycode = modifier_keymap->modifiermap[j * modifier_keymap-> max_keypermod + i])) modmap[keycode] |= 1 << j; } XFreeModifiermap(modifier_keymap); keySyms.minKeyCode = min_keycode; keySyms.maxKeyCode = max_keycode; keySyms.mapWidth = mapWidth; keySyms.map = keymap; if (XkbQueryExtension(xnestDisplay, &op, &event, &error, &major, &minor) == 0) { ErrorF("Unable to initialize XKEYBOARD extension.\n"); goto XkbError; } xkb = XkbGetKeyboard(xnestDisplay, XkbGBN_AllComponentsMask, XkbUseCoreKbd); if (xkb == NULL || xkb->geom == NULL) { ErrorF("Couldn't get keyboard.\n"); goto XkbError; } XkbGetControls(xnestDisplay, XkbAllControlsMask, xkb); InitKeyboardDeviceStruct(pDev, NULL, xnestBell, xnestChangeKeyboardControl); XkbApplyMappingChange(pDev, &keySyms, keySyms.minKeyCode, keySyms.maxKeyCode - keySyms.minKeyCode + 1, modmap, serverClient); XkbDDXChangeControls(pDev, xkb->ctrls, xkb->ctrls); XkbFreeKeyboard(xkb, 0, False); free(keymap); break; case DEVICE_ON: xnestEventMask |= XNEST_KEYBOARD_EVENT_MASK; for (i = 0; i < xnestNumScreens; i++) XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask); break; case DEVICE_OFF: xnestEventMask &= ~XNEST_KEYBOARD_EVENT_MASK; for (i = 0; i < xnestNumScreens; i++) XSelectInput(xnestDisplay, xnestDefaultWindows[i], xnestEventMask); break; case DEVICE_CLOSE: break; } return Success; XkbError: XGetKeyboardControl(xnestDisplay, &values); memmove((char *) defaultKeyboardControl.autoRepeats, (char *) values.auto_repeats, sizeof(values.auto_repeats)); InitKeyboardDeviceStruct(pDev, NULL, xnestBell, xnestChangeKeyboardControl); free(keymap); return Success; }