_X_EXPORT Bool
InitKeyboardDeviceStruct(DeviceIntPtr dev, XkbRMLVOSet *rmlvo,
BellProcPtr bell_func, KbdCtrlProcPtr ctrl_func)
{
int i;
unsigned int check;
XkbSrvInfoPtr xkbi;
XkbDescPtr xkb;
XkbSrvLedInfoPtr sli;
XkbChangesRec changes;
XkbEventCauseRec cause;
XkbRMLVOSet rmlvo_dflts = { NULL };
if (dev->key || dev->kbdfeed)
return FALSE;
if (!rmlvo)
{
rmlvo = &rmlvo_dflts;
XkbGetRulesDflts(rmlvo);
}
memset(&changes, 0, sizeof(changes));
XkbSetCauseUnknown(&cause);
dev->key = calloc(1, sizeof(*dev->key));
if (!dev->key) {
ErrorF("XKB: Failed to allocate key class\n");
return FALSE;
}
dev->key->sourceid = dev->id;
dev->kbdfeed = calloc(1, sizeof(*dev->kbdfeed));
if (!dev->kbdfeed) {
ErrorF("XKB: Failed to allocate key feedback class\n");
goto unwind_key;
}
xkbi = calloc(1, sizeof(*xkbi));
if (!xkbi) {
ErrorF("XKB: Failed to allocate XKB info\n");
goto unwind_kbdfeed;
}
dev->key->xkbInfo = xkbi;
if (xkb_cached_map && !XkbCompareUsedRMLVO(rmlvo)) {
XkbFreeKeyboard(xkb_cached_map, XkbAllComponentsMask, TRUE);
xkb_cached_map = NULL;
}
if (xkb_cached_map)
LogMessageVerb(X_INFO, 4, "XKB: Reusing cached keymap\n");
else {
xkb_cached_map = XkbCompileKeymap(dev, rmlvo);
if (!xkb_cached_map) {
ErrorF("XKB: Failed to compile keymap\n");
goto unwind_info;
}
}
xkb = XkbAllocKeyboard();
if (!xkb) {
ErrorF("XKB: Failed to allocate keyboard description\n");
goto unwind_info;
}
if (!XkbCopyKeymap(xkb, xkb_cached_map)) {
ErrorF("XKB: Failed to copy keymap\n");
goto unwind_desc;
}
xkb->defined = xkb_cached_map->defined;
xkb->flags = xkb_cached_map->flags;
xkb->device_spec = xkb_cached_map->device_spec;
xkbi->desc = xkb;
if (xkb->min_key_code == 0)
xkb->min_key_code = 8;
if (xkb->max_key_code == 0)
xkb->max_key_code = 255;
i = XkbNumKeys(xkb) / 3 + 1;
if (XkbAllocClientMap(xkb, XkbAllClientInfoMask, 0) != Success)
goto unwind_desc;
if (XkbAllocServerMap(xkb, XkbAllServerInfoMask, i) != Success)
goto unwind_desc;
xkbi->dfltPtrDelta = 1;
xkbi->device = dev;
XkbInitSemantics(xkb);
XkbInitNames(xkbi);
XkbInitRadioGroups(xkbi);
XkbInitControls(dev, xkbi);
XkbInitIndicatorMap(xkbi);
XkbUpdateActions(dev, xkb->min_key_code, XkbNumKeys(xkb), &changes,
&check, &cause);
InitFocusClassDeviceStruct(dev);
xkbi->kbdProc = ctrl_func;
dev->kbdfeed->BellProc = bell_func;
dev->kbdfeed->CtrlProc = XkbDDXKeybdCtrlProc;
dev->kbdfeed->ctrl = defaultKeyboardControl;
if (dev->kbdfeed->ctrl.autoRepeat)
xkb->ctrls->enabled_ctrls |= XkbRepeatKeysMask;
memcpy(dev->kbdfeed->ctrl.autoRepeats, xkb->ctrls->per_key_repeat,
XkbPerKeyBitArraySize);
sli = XkbFindSrvLedInfo(dev, XkbDfltXIClass, XkbDfltXIId, 0);
if (sli)
XkbCheckIndicatorMaps(dev, sli, XkbAllIndicatorsMask);
else
DebugF("XKB: No indicator feedback in XkbFinishInit!\n");
dev->kbdfeed->CtrlProc(dev,&dev->kbdfeed->ctrl);
XkbSetRulesDflts(rmlvo);
XkbSetRulesUsed(rmlvo);
XkbFreeRMLVOSet(&rmlvo_dflts, FALSE);
return TRUE;
unwind_desc:
XkbFreeKeyboard(xkb, 0, TRUE);
unwind_info:
free(xkbi);
dev->key->xkbInfo = NULL;
unwind_kbdfeed:
free(dev->kbdfeed);
dev->kbdfeed = NULL;
unwind_key:
free(dev->key);
dev->key = NULL;
return FALSE;
}
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;
}
Status
XkbAllocClientMap(XkbDescPtr xkb,unsigned which,unsigned nTotalTypes)
{
register int i;
XkbClientMapPtr map;
if ((xkb==NULL)||((nTotalTypes>0)&&(nTotalTypes<XkbNumRequiredTypes)))
return BadValue;
if ((which&XkbKeySymsMask)&&
((!XkbIsLegalKeycode(xkb->min_key_code))||
(!XkbIsLegalKeycode(xkb->max_key_code))||
(xkb->max_key_code<xkb->min_key_code))) {
#ifdef DEBUG
fprintf(stderr,"bad keycode (%d,%d) in XkbAllocClientMap\n",
xkb->min_key_code,xkb->max_key_code);
#endif
return BadValue;
}
if (xkb->map==NULL) {
map= _XkbTypedCalloc(1,XkbClientMapRec);
if (map==NULL)
return BadAlloc;
xkb->map= map;
}
else map= xkb->map;
if ((which&XkbKeyTypesMask)&&(nTotalTypes>0)) {
if (map->types==NULL) {
map->types= _XkbTypedCalloc(nTotalTypes,XkbKeyTypeRec);
if (map->types==NULL)
return BadAlloc;
map->num_types= 0;
map->size_types= nTotalTypes;
}
else if (map->size_types<nTotalTypes) {
XkbKeyTypeRec *prev_types = map->types;
map->types= _XkbTypedRealloc(map->types,nTotalTypes,XkbKeyTypeRec);
if (map->types==NULL) {
_XkbFree(prev_types);
map->num_types= map->size_types= 0;
return BadAlloc;
}
map->size_types= nTotalTypes;
bzero(&map->types[map->num_types],
((map->size_types-map->num_types)*sizeof(XkbKeyTypeRec)));
}
}
if (which&XkbKeySymsMask) {
int nKeys= XkbNumKeys(xkb);
if (map->syms==NULL) {
map->size_syms= (nKeys*15)/10;
map->syms= _XkbTypedCalloc(map->size_syms,KeySym);
if (!map->syms) {
map->size_syms= 0;
return BadAlloc;
}
map->num_syms= 1;
map->syms[0]= NoSymbol;
}
if (map->key_sym_map==NULL) {
i= xkb->max_key_code+1;
map->key_sym_map= _XkbTypedCalloc(i,XkbSymMapRec);
if (map->key_sym_map==NULL)
return BadAlloc;
}
}
if (which&XkbModifierMapMask) {
if ((!XkbIsLegalKeycode(xkb->min_key_code))||
(!XkbIsLegalKeycode(xkb->max_key_code))||
(xkb->max_key_code<xkb->min_key_code))
return BadMatch;
if (map->modmap==NULL) {
i= xkb->max_key_code+1;
map->modmap= _XkbTypedCalloc(i,unsigned char);
if (map->modmap==NULL)
return BadAlloc;
}
}
void
XkbInitDevice(DeviceIntPtr pXDev)
{
int i;
XkbSrvInfoPtr xkbi;
XkbChangesRec changes;
SrvXkmInfo file;
unsigned check;
XkbEventCauseRec cause;
file.dev= pXDev;
file.file=NULL;
bzero(&file.xkbinfo,sizeof(XkbFileInfo));
bzero(&changes,sizeof(XkbChangesRec));
if (XkbAutoLoad && (XkbInitialMap!=NULL)) {
if ((file.file=XkbDDXOpenConfigFile(XkbInitialMap,NULL,0))!=NULL) {
XkmReadFile(file.file,0,XkmKeymapLegal,&file.xkbinfo);
if (file.xkbinfo.xkb==NULL) {
LogMessage(X_ERROR,
"Error loading keymap file %s (%s in %s)\n"
"\treverting to defaults\n",
XkbInitialMap, _XkbErrMessages[_XkbErrCode],
(_XkbErrLocation?_XkbErrLocation:"unknown"));
fclose(file.file);
file.file= NULL;
bzero(&file.xkbinfo,sizeof(XkbFileInfo));
}
else {
if (_XkbInitFileInfo!=NULL) {
XkbDescPtr tmp;
if ((tmp=_XkbInitFileInfo->xkb)!=NULL) {
XkbFreeKeyboard(tmp,XkbAllComponentsMask,True);
_XkbInitFileInfo->xkb= NULL;
}
}
_XkbInitFileInfo= &file.xkbinfo;
}
}
else {
LogMessage(X_ERROR, "Error opening keymap file %s, reverting to defaults\n",
XkbInitialMap);
}
}
pXDev->key->xkbInfo= xkbi= _XkbTypedCalloc(1,XkbSrvInfoRec);
if ( xkbi ) {
XkbDescPtr xkb;
if ((_XkbInitFileInfo!=NULL)&&(_XkbInitFileInfo->xkb!=NULL)) {
file.xkbinfo= *_XkbInitFileInfo;
xkbi->desc= _XkbInitFileInfo->xkb;
_XkbInitFileInfo= NULL;
}
else {
xkbi->desc= XkbAllocKeyboard();
if (!xkbi->desc)
FatalError("Couldn't allocate keyboard description\n");
xkbi->desc->min_key_code = pXDev->key->curKeySyms.minKeyCode;
xkbi->desc->max_key_code = pXDev->key->curKeySyms.maxKeyCode;
}
xkb= xkbi->desc;
if (xkb->min_key_code == 0)
xkb->min_key_code = pXDev->key->curKeySyms.minKeyCode;
if (xkb->max_key_code == 0)
xkb->max_key_code = pXDev->key->curKeySyms.maxKeyCode;
if ((pXDev->key->curKeySyms.minKeyCode!=xkbi->desc->min_key_code)||
(pXDev->key->curKeySyms.maxKeyCode!=xkbi->desc->max_key_code)) {
/* 12/9/95 (ef) -- XXX! Maybe we should try to fix up one or */
/* the other here, but for now just complain */
/* can't just update the core range without */
/* reallocating the KeySymsRec (pain) */
ErrorF("Internal Error!! XKB and core keymap have different range\n");
}
if (XkbAllocClientMap(xkb,XkbAllClientInfoMask,0)!=Success)
FatalError("Couldn't allocate client map in XkbInitDevice\n");
i= XkbNumKeys(xkb)/3+1;
if (XkbAllocServerMap(xkb,XkbAllServerInfoMask,i)!=Success)
FatalError("Couldn't allocate server map in XkbInitDevice\n");
xkbi->dfltPtrDelta=1;
xkbi->device = pXDev;
file.xkbinfo.xkb= xkb;
XkbInitSemantics(xkb,&file);
XkbInitNames(xkbi,&file);
XkbInitRadioGroups(xkbi,&file);
/* 12/31/94 (ef) -- XXX! Should check if state loaded from file */
bzero(&xkbi->state,sizeof(XkbStateRec));
XkbInitControls(pXDev,xkbi,&file);
if (file.xkbinfo.defined&XkmSymbolsMask)
memcpy(pXDev->key->modifierMap,xkb->map->modmap,xkb->max_key_code+1);
else
memcpy(xkb->map->modmap,pXDev->key->modifierMap,xkb->max_key_code+1);
XkbInitIndicatorMap(xkbi,&file);
XkbDDXInitDevice(pXDev);
if (!(file.xkbinfo.defined&XkmSymbolsMask)) {
XkbUpdateKeyTypesFromCore(pXDev,xkb->min_key_code,XkbNumKeys(xkb),
&changes);
}
else {
XkbUpdateCoreDescription(pXDev,True);
}
XkbSetCauseUnknown(&cause);
XkbUpdateActions(pXDev,xkb->min_key_code, XkbNumKeys(xkb),&changes,
&check,&cause);
/* For sanity. The first time the connection
* is opened, the client side min and max are set
* using QueryMinMaxKeyCodes() which grabs them
* from pXDev.
*/
pXDev->key->curKeySyms.minKeyCode = xkb->min_key_code;
pXDev->key->curKeySyms.maxKeyCode = xkb->max_key_code;
}
if (file.file!=NULL)
fclose(file.file);
return;
}
