/*ARGSUSED*/
static Bool
DefaultParser( FILE * file,
XkbConfigFieldsPtr fields,
XkbConfigFieldPtr field,
XkbDescPtr xkb,
XkbConfigRtrnPtr rtrn)
{
int tok;
XkbCFScanResultRec val;
char ** str;
int merge;
unsigned long * ctrls, ctrls_mask;
unsigned short * opts, opts_mask;
int * pival, sign;
int onoff;
XkbConfigUnboundModPtr last;
unsigned what;
tok= XkbCFScan(file,&val,rtrn);
str= NULL;
onoff= 0;
pival= NULL;
switch (field->field_id) {
case _XkbCF_RulesFile: if (!str) str= &rtrn->rules_file;
case _XkbCF_Model: if (!str) str= &rtrn->model;
case _XkbCF_Layout: if (!str) str= &rtrn->layout;
case _XkbCF_Variant: if (!str) str= &rtrn->variant;
case _XkbCF_Options: if (!str) str= &rtrn->options;
case _XkbCF_Keymap: if (!str) str= &rtrn->keymap;
case _XkbCF_Keycodes: if (!str) str= &rtrn->keycodes;
case _XkbCF_Geometry: if (!str) str= &rtrn->geometry;
case _XkbCF_PhysSymbols:if (!str) str= &rtrn->phys_symbols;
case _XkbCF_Symbols: if (!str) str= &rtrn->symbols;
case _XkbCF_Types: if (!str) str= &rtrn->types;
case _XkbCF_CompatMap: if (!str) str= &rtrn->compat;
if (tok!=XkbCF_Equals) {
rtrn->error= XkbCF_MissingEquals;
goto BAILOUT;
}
tok= XkbCFScan(file,&val,rtrn);
if ((tok!=XkbCF_String)&&(tok!=XkbCF_Ident)) {
rtrn->error= XkbCF_ExpectedString;
return False;
}
tok= XkbCFScan(file,&val,rtrn);
if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) {
rtrn->error= XkbCF_ExpectedEOS;
return False;
}
if (*str!=NULL)
_XkbFree(*str);
*str= _XkbDupString(val.str);
break;
case _XkbCF_InitialMods:
case _XkbCF_IgnoreLockMods:
case _XkbCF_InternalMods:
what= XkbCF_InitialMods;
if (field->field_id==_XkbCF_InitialMods)
rtrn->defined|= (what=XkbCF_InitialMods);
else if (field->field_id==_XkbCF_InternalMods)
rtrn->defined|= (what=XkbCF_InternalMods);
else if (field->field_id==_XkbCF_IgnoreLockMods)
rtrn->defined|= (what=XkbCF_IgnoreLockMods);
if (tok==XkbCF_Equals) merge= XkbCF_MergeSet;
else if (tok==XkbCF_MinusEquals) merge= XkbCF_MergeRemove;
else if (tok==XkbCF_PlusEquals) merge= XkbCF_MergeAdd;
else {
rtrn->error= XkbCF_MissingEquals;
goto BAILOUT;
}
tok= XkbCFScan(file,&val,rtrn);
if ((tok==XkbCF_EOL)||(tok==XkbCF_Semi)||(tok==XkbCF_EOF)) {
rtrn->error= XkbCF_ExpectedModifier;
return False;
}
last= NULL;
while ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) {
if ((tok!=XkbCF_Ident)&&(tok!=XkbCF_String)) {
rtrn->error= XkbCF_ExpectedModifier;
return False;
}
last=XkbCFAddModByName(rtrn,what,val.str,merge,last);
if (last==NULL)
return False;
if (merge==XkbCF_MergeSet)
merge= XkbCF_MergeAdd;
tok= XkbCFScan(file,&val,rtrn);
if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_EOF)&&(tok!=XkbCF_Semi)) {
if (tok!=XkbCF_Plus) {
rtrn->error= XkbCF_ExpectedOperator;
return False;
}
tok= XkbCFScan(file,&val,rtrn);
}
}
break;
case _XkbCF_InitialCtrls:
rtrn->defined|= XkbCF_InitialCtrls;
ctrls= NULL;
if (tok==XkbCF_PlusEquals)
ctrls= &rtrn->initial_ctrls;
else if (tok==XkbCF_MinusEquals)
ctrls= &rtrn->initial_ctrls_clear;
else if (tok==XkbCF_Equals) {
ctrls= &rtrn->initial_ctrls;
rtrn->replace_initial_ctrls= True;
*ctrls= 0;
}
else {
rtrn->error= XkbCF_MissingEquals;
goto BAILOUT;
}
tok= XkbCFScan(file,&val,rtrn);
if ((tok==XkbCF_EOL)||(tok==XkbCF_Semi)||(tok==XkbCF_EOF)) {
rtrn->error= XkbCF_ExpectedControl;
return False;
}
while ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) {
if ((tok!=XkbCF_Ident)&&(tok!=XkbCF_String)) {
rtrn->error= XkbCF_ExpectedControl;
return False;
}
if (!AddCtrlByName(rtrn,val.str,&ctrls_mask)) {
return False;
}
*ctrls |= ctrls_mask;
tok= XkbCFScan(file,&val,rtrn);
if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_EOF)&&(tok!=XkbCF_Semi)) {
if (tok!=XkbCF_Plus) {
rtrn->error= XkbCF_ExpectedOperator;
return False;
}
tok= XkbCFScan(file,&val,rtrn);
}
}
break;
case _XkbCF_AccessXTimeoutCtrlsOn:
case _XkbCF_AccessXTimeoutCtrlsOff:
opts= NULL;
if (tok==XkbCF_MinusEquals) {
ctrls= &rtrn->axt_ctrls_ignore;
opts= &rtrn->axt_opts_ignore;
}
else if ((tok==XkbCF_PlusEquals)||(tok==XkbCF_Equals)) {
if (field->field_id==_XkbCF_AccessXTimeoutCtrlsOff) {
ctrls= &rtrn->axt_ctrls_off;
opts= &rtrn->axt_opts_off;
if (tok==XkbCF_Equals)
rtrn->replace_axt_ctrls_off= True;
}
else {
ctrls= &rtrn->axt_ctrls_on;
opts= &rtrn->axt_opts_on;
if (tok==XkbCF_Equals)
rtrn->replace_axt_ctrls_on= True;
}
*ctrls= 0;
}
else {
rtrn->error= XkbCF_MissingEquals;
goto BAILOUT;
}
tok= XkbCFScan(file,&val,rtrn);
if ((tok==XkbCF_EOL)||(tok==XkbCF_Semi)||(tok==XkbCF_EOF)) {
rtrn->error= XkbCF_ExpectedControl;
return False;
}
while ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) {
if ((tok!=XkbCF_Ident)&&(tok!=XkbCF_String)) {
rtrn->error= XkbCF_ExpectedControl;
return False;
}
if (!AddCtrlByName(rtrn,val.str,&ctrls_mask)) {
if (!AddAXTimeoutOptByName(rtrn,val.str,&opts_mask))
return False;
*opts |= opts_mask;
if (field->field_id==_XkbCF_AccessXTimeoutCtrlsOff) {
rtrn->defined|= XkbCF_AccessXTimeoutOptsOff;
if (rtrn->replace_axt_ctrls_off)
rtrn->replace_axt_opts_off= True;
}
else {
rtrn->defined|= XkbCF_AccessXTimeoutOptsOn;
if (rtrn->replace_axt_ctrls_on)
rtrn->replace_axt_opts_on= True;
}
}
else
*ctrls |= ctrls_mask;
tok= XkbCFScan(file,&val,rtrn);
if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_EOF)&&(tok!=XkbCF_Semi)) {
if (tok!=XkbCF_Plus) {
rtrn->error= XkbCF_ExpectedOperator;
return False;
}
tok= XkbCFScan(file,&val,rtrn);
}
}
break;
case _XkbCF_InitialFeedback:
rtrn->defined|= XkbCF_InitialOpts;
opts= NULL;
if (tok==XkbCF_PlusEquals)
opts= &rtrn->initial_opts;
else if (tok==XkbCF_MinusEquals)
opts= &rtrn->initial_opts_clear;
else if (tok==XkbCF_Equals) {
opts= &rtrn->initial_opts;
rtrn->replace_initial_opts= True;
*opts= 0;
}
else {
rtrn->error= XkbCF_MissingEquals;
goto BAILOUT;
}
tok= XkbCFScan(file,&val,rtrn);
if ((tok==XkbCF_EOL)||(tok==XkbCF_Semi)||(tok==XkbCF_EOF)) {
rtrn->error= XkbCF_ExpectedAXOption;
return False;
}
while ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) {
if ((tok!=XkbCF_Ident)&&(tok!=XkbCF_String)) {
rtrn->error= XkbCF_ExpectedAXOption;
return False;
}
if (!AddAXTimeoutOptByName(rtrn,val.str,&opts_mask)) {
return False;
}
*opts |= opts_mask;
tok= XkbCFScan(file,&val,rtrn);
if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_EOF)&&(tok!=XkbCF_Semi)) {
if (tok!=XkbCF_Plus) {
rtrn->error= XkbCF_ExpectedOperator;
return False;
}
tok= XkbCFScan(file,&val,rtrn);
}
}
break;
case _XkbCF_AccessXTimeoutOptsOff:
case _XkbCF_AccessXTimeoutOptsOn:
opts= NULL;
if (tok==XkbCF_MinusEquals)
opts= &rtrn->axt_opts_ignore;
else if ((tok==XkbCF_PlusEquals)||(tok==XkbCF_Equals)) {
if (field->field_id==_XkbCF_AccessXTimeoutOptsOff) {
opts= &rtrn->axt_opts_off;
if (tok==XkbCF_Equals)
rtrn->replace_axt_opts_off= True;
}
else {
opts= &rtrn->axt_opts_on;
if (tok==XkbCF_Equals)
rtrn->replace_axt_opts_on= True;
}
*opts = 0;
}
else {
rtrn->error= XkbCF_MissingEquals;
goto BAILOUT;
}
tok= XkbCFScan(file,&val,rtrn);
if ((tok==XkbCF_EOL)||(tok==XkbCF_Semi)||(tok==XkbCF_EOF)) {
rtrn->error= XkbCF_ExpectedControl;
return False;
}
while ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) {
if ((tok!=XkbCF_Ident)&&(tok!=XkbCF_String)) {
rtrn->error= XkbCF_ExpectedControl;
return False;
}
if (!AddAXTimeoutOptByName(rtrn,val.str,&opts_mask))
return False;
*opts |= opts_mask;
tok= XkbCFScan(file,&val,rtrn);
if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_EOF)&&(tok!=XkbCF_Semi)) {
if (tok!=XkbCF_Plus) {
rtrn->error= XkbCF_ExpectedOperator;
return False;
}
tok= XkbCFScan(file,&val,rtrn);
}
}
break;
case _XkbCF_ClickVolume:
if (!pival) {
pival= &rtrn->click_volume;
onoff= 100;
}
case _XkbCF_BellVolume:
if (!pival) {
pival= &rtrn->bell_volume;
onoff= 100;
}
case _XkbCF_BellPitch:
if (!pival)
pival= &rtrn->bell_pitch;
case _XkbCF_BellDuration:
if (!pival)
pival= &rtrn->bell_duration;
case _XkbCF_RepeatDelay:
if (!pival)
pival= &rtrn->repeat_delay;
case _XkbCF_RepeatInterval:
if (!pival)
pival= &rtrn->repeat_interval;
case _XkbCF_SlowKeysDelay:
if (!pival)
pival= &rtrn->slow_keys_delay;
case _XkbCF_DebounceDelay:
if (!pival)
pival= &rtrn->debounce_delay;
case _XkbCF_MouseKeysDelay:
if (!pival)
pival= &rtrn->mk_delay;
case _XkbCF_MouseKeysInterval:
if (!pival)
pival= &rtrn->mk_interval;
case _XkbCF_MouseKeysTimeToMax:
if (!pival)
pival= &rtrn->mk_time_to_max;
case _XkbCF_MouseKeysMaxSpeed:
if (!pival)
pival= &rtrn->mk_max_speed;
case _XkbCF_MouseKeysCurve:
if (!pival)
pival= &rtrn->mk_curve;
case _XkbCF_AccessXTimeout:
if (!pival)
pival= &rtrn->ax_timeout;
if (tok!=XkbCF_Equals) {
rtrn->error= XkbCF_MissingEquals;
goto BAILOUT;
}
tok= XkbCFScan(file,&val,rtrn);
if (tok == XkbCF_Minus && field->field_id == _XkbCF_MouseKeysCurve) {
/* This can be a negative value */
tok = XkbCFScan(file,&val,rtrn);
sign = -1;
}
else
sign = 1;
if (tok!=XkbCF_Integer) {
Bool ok= False;
if ((onoff)&&(tok==XkbCF_Ident)&&(val.str!=NULL)) {
if (_XkbStrCaseCmp(val.str,"on")) {
val.ival= onoff;
ok= True;
}
else if (_XkbStrCaseCmp(val.str,"off")) {
val.ival= 0;
ok= True;
}
}
if (!ok) {
rtrn->error= XkbCF_ExpectedInteger;
goto BAILOUT;
}
}
*pival= val.ival * sign;
if (field->field_id == _XkbCF_AccessXTimeout)
rtrn->defined|=XkbCF_AccessXTimeout;
tok= XkbCFScan(file,&val,rtrn);
if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) {
rtrn->error= XkbCF_ExpectedEOS;
return False;
}
break;
case _XkbCF_GroupsWrap:
if (tok!=XkbCF_Equals) {
rtrn->error= XkbCF_MissingEquals;
goto BAILOUT;
}
tok= XkbCFScan(file,&val,rtrn);
if (tok==XkbCF_Ident) {
if (_XkbStrCaseCmp(val.str,"wrap")==0) {
rtrn->groups_wrap= XkbSetGroupInfo(0,XkbWrapIntoRange,0);
}
else if (_XkbStrCaseCmp(val.str,"clamp")==0) {
rtrn->groups_wrap= XkbSetGroupInfo(0,XkbClampIntoRange,0);
}
else {
rtrn->error= XkbCF_ExpectedOORGroupBehavior;
return False;
}
}
else if ((tok==XkbCF_Integer)&&(XkbIsLegalGroup(val.ival-1))) {
rtrn->groups_wrap= XkbSetGroupInfo(0,XkbRedirectIntoRange,
val.ival-1);
}
else {
rtrn->error= XkbCF_ExpectedOORGroupBehavior;
return False;
}
rtrn->defined|= XkbCF_GroupsWrap;
tok= XkbCFScan(file,&val,rtrn);
if ((tok!=XkbCF_EOL)&&(tok!=XkbCF_Semi)&&(tok!=XkbCF_EOF)) {
rtrn->error= XkbCF_ExpectedEOS;
return False;
}
break;
default:
rtrn->error= XkbCF_ExpectedInteger;
goto BAILOUT;
}
return True;
BAILOUT:
return False;
}
int
XRefreshKeyboardMapping(register XMappingEvent *event)
{
XkbEvent *xkbevent = (XkbEvent *)event;
Display *dpy = event->display;
XkbMapChangesRec changes;
XkbInfoPtr xkbi;
/* always do this for input methods, which still use the old keymap */
(void) _XRefreshKeyboardMapping(event);
if (_XkbUnavailable(dpy))
return 1;
xkbi = dpy->xkb_info;
if (((event->type&0x7f)-xkbi->codes->first_event)==XkbEventCode)
return XkbRefreshKeyboardMapping(&xkbevent->map);
if (xkbi->flags&XkbXlibNewKeyboard) {
_XkbReloadDpy(dpy);
return 1;
}
if ((xkbi->flags&XkbMapPending)||(event->request==MappingKeyboard)) {
if (xkbi->flags&XkbMapPending) {
changes= xkbi->changes;
_XkbNoteCoreMapChanges(&changes,event,XKB_XLIB_MAP_MASK);
}
else {
bzero(&changes,sizeof(changes));
changes.changed= XkbKeySymsMask;
if (xkbi->desc->min_key_code<xkbi->desc->max_key_code) {
changes.first_key_sym= xkbi->desc->min_key_code;
changes.num_key_syms= xkbi->desc->max_key_code-
xkbi->desc->min_key_code+1;
}
else {
changes.first_key_sym= event->first_keycode;
changes.num_key_syms= event->count;
}
}
if (XkbGetMapChanges(dpy,xkbi->desc, &changes)!=Success) {
#ifdef DEBUG
fprintf(stderr,"Internal Error! XkbGetMapChanges failed:\n");
if (changes.changed&XkbKeyTypesMask) {
int first= changes.first_type;
int last= changes.first_type+changes.num_types-1;
fprintf(stderr," types: %d..%d\n",first,last);
}
if (changes.changed&XkbKeySymsMask) {
int first= changes.first_key_sym;
int last= changes.first_key_sym+changes.num_key_syms-1;
fprintf(stderr," symbols: %d..%d\n",first,last);
}
if (changes.changed&XkbKeyActionsMask) {
int last,first= changes.first_key_act;
last= changes.first_key_act+changes.num_key_acts-1;
fprintf(stderr," acts: %d..%d\n",first,last);
}
if (changes.changed&XkbKeyBehaviorsMask) {
int last,first= changes.first_key_behavior;
last= first+changes.num_key_behaviors-1;
fprintf(stderr," behaviors: %d..%d\n",first,last);
}
if (changes.changed&XkbVirtualModsMask) {
fprintf(stderr,"virtual mods: 0x%04x\n",
changes.vmods);
}
if (changes.changed&XkbExplicitComponentsMask) {
int last,first= changes.first_key_explicit;
last= first+changes.num_key_explicit-1;
fprintf(stderr," explicit: %d..%d\n",first,last);
}
#endif
}
LockDisplay(dpy);
if (xkbi->flags&XkbMapPending) {
xkbi->flags&= ~XkbMapPending;
bzero(&xkbi->changes,sizeof(XkbMapChangesRec));
}
UnlockDisplay(dpy);
}
if (event->request==MappingModifier) {
LockDisplay(dpy);
if (xkbi->desc->map->modmap) {
_XkbFree(xkbi->desc->map->modmap);
xkbi->desc->map->modmap= NULL;
}
if (dpy->key_bindings) {
register struct _XKeytrans *p;
for (p = dpy->key_bindings; p; p = p->next) {
register int i;
p->state= 0;
if (p->mlen>0) {
for (i = 0; i < p->mlen; i++) {
p->state|= XkbKeysymToModifiers(dpy,p->modifiers[i]);
}
if (p->state) p->state &= AllMods;
else p->state = AnyModifier;
}
}
}
UnlockDisplay(dpy);
}
return 1;
}
static char *
XkbRF_SubstituteVars(char *name, XkbRF_MultiDefsPtr mdefs)
{
char *str, *outstr, *orig, *var;
int len, ndx;
orig= name;
str= index(name,'%');
if (str==NULL)
return name;
len= strlen(name);
while (str!=NULL) {
char pfx= str[1];
int extra_len= 0;
if ((pfx=='+')||(pfx=='|')||(pfx=='_')||(pfx=='-')) {
extra_len= 1;
str++;
}
else if (pfx=='(') {
extra_len= 2;
str++;
}
var = str + 1;
str = get_index(var + 1, &ndx);
if (ndx == -1) {
str = index(str,'%');
continue;
}
if ((*var=='l') && mdefs->layout[ndx] && *mdefs->layout[ndx])
len+= strlen(mdefs->layout[ndx])+extra_len;
else if ((*var=='m')&&mdefs->model)
len+= strlen(mdefs->model)+extra_len;
else if ((*var=='v') && mdefs->variant[ndx] && *mdefs->variant[ndx])
len+= strlen(mdefs->variant[ndx])+extra_len;
if ((pfx=='(')&&(*str==')')) {
str++;
}
str= index(&str[0],'%');
}
name= (char *)_XkbAlloc(len+1);
str= orig;
outstr= name;
while (*str!='\0') {
if (str[0]=='%') {
char pfx,sfx;
str++;
pfx= str[0];
sfx= '\0';
if ((pfx=='+')||(pfx=='|')||(pfx=='_')||(pfx=='-')) {
str++;
}
else if (pfx=='(') {
sfx= ')';
str++;
}
else pfx= '\0';
var = str;
str = get_index(var + 1, &ndx);
if (ndx == -1) {
continue;
}
if ((*var=='l') && mdefs->layout[ndx] && *mdefs->layout[ndx]) {
if (pfx) *outstr++= pfx;
strcpy(outstr,mdefs->layout[ndx]);
outstr+= strlen(mdefs->layout[ndx]);
if (sfx) *outstr++= sfx;
}
else if ((*var=='m')&&(mdefs->model)) {
if (pfx) *outstr++= pfx;
strcpy(outstr,mdefs->model);
outstr+= strlen(mdefs->model);
if (sfx) *outstr++= sfx;
}
else if ((*var=='v') && mdefs->variant[ndx] && *mdefs->variant[ndx]) {
if (pfx) *outstr++= pfx;
strcpy(outstr,mdefs->variant[ndx]);
outstr+= strlen(mdefs->variant[ndx]);
if (sfx) *outstr++= sfx;
}
if ((pfx=='(')&&(*str==')'))
str++;
}
else {
*outstr++= *str++;
}
}
*outstr++= '\0';
if (orig!=name)
_XkbFree(orig);
return name;
}
_X_EXPORT 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;
XkbRF_VarDefsRec defs;
if ((dev->key!=NULL)||(dev->kbdfeed!=NULL))
return False;
pSyms= pSymsIn;
pMods= pModsIn;
bzero(&defs,sizeof(XkbRF_VarDefsRec));
rules= XkbGetRulesDflts(&defs);
/*
* 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 (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);
_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;
}
}
