/* $Xorg: XKBMisc.c,v 1.4 2000/08/17 19:45:02 cpqbld Exp $ */ /************************************************************ Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc. Permission to use, copy, modify, and distribute this software and its documentation for any purpose and without fee is hereby granted, provided that the above copyright notice appear in all copies and that both that copyright notice and this permission notice appear in supporting documentation, and that the name of Silicon Graphics not be used in advertising or publicity pertaining to distribution of the software without specific prior written permission. Silicon Graphics makes no representation about the suitability of this software for any purpose. It is provided "as is" without any express or implied warranty. SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE. ********************************************************/ /* $XFree86: xc/lib/X11/XKBMisc.c,v 3.5 2001/10/28 03:32:33 tsi Exp $ */ #ifdef HAVE_DIX_CONFIG_H #include <dix-config.h> #elif defined(HAVE_CONFIG_H) #include <config.h> #endif #ifndef XKB_IN_SERVER #include <stdio.h> #define NEED_REPLIES #define NEED_EVENTS #include "Xlibint.h" #include <X11/extensions/XKBproto.h> #include <X11/keysym.h> #include "XKBlibint.h" #else #include <stdio.h> #include <X11/X.h> #define NEED_EVENTS #define NEED_REPLIES #define XkbVirtualModsToReal SrvXkbVirtualModsToReal #include <X11/Xproto.h> #include "misc.h" #include "inputstr.h" #include <X11/keysym.h> #define XKBSRV_NEED_FILE_FUNCS #include <X11/extensions/XKBsrv.h> #endif /* XKB_IN_SERVER */ /***====================================================================***/ #define mapSize(m) (sizeof(m)/sizeof(XkbKTMapEntryRec)) static XkbKTMapEntryRec map2Level[]= { { True, ShiftMask, {1, ShiftMask, 0} } }; static XkbKTMapEntryRec mapAlpha[]= { { True, ShiftMask, { 1, ShiftMask, 0 } }, { True, LockMask, { 0, LockMask, 0 } } }; static XkbModsRec preAlpha[]= { { 0, 0, 0 }, { LockMask, LockMask, 0 } }; #define NL_VMOD_MASK 0 static XkbKTMapEntryRec mapKeypad[]= { { True, ShiftMask, { 1, ShiftMask, 0 } }, { False, 0, { 1, 0, NL_VMOD_MASK } } }; static XkbKeyTypeRec canonicalTypes[XkbNumRequiredTypes] = { { { 0, 0, 0 }, 1, /* num_levels */ 0, /* map_count */ NULL, NULL, None, NULL }, { { ShiftMask, ShiftMask, 0 }, 2, /* num_levels */ mapSize(map2Level), /* map_count */ map2Level, NULL, None, NULL }, { { ShiftMask|LockMask, ShiftMask|LockMask, 0 }, 2, /* num_levels */ mapSize(mapAlpha), /* map_count */ mapAlpha, preAlpha, None, NULL }, { { ShiftMask, ShiftMask, NL_VMOD_MASK }, 2, /* num_levels */ mapSize(mapKeypad), /* map_count */ mapKeypad, NULL, None, NULL } }; Status XkbInitCanonicalKeyTypes(XkbDescPtr xkb,unsigned which,int keypadVMod) { XkbClientMapPtr map; XkbKeyTypePtr from,to; Status rtrn; if (!xkb) return BadMatch; rtrn= XkbAllocClientMap(xkb,XkbKeyTypesMask,XkbNumRequiredTypes); if (rtrn!=Success) return rtrn; map= xkb->map; if ((which&XkbAllRequiredTypes)==0) return Success; rtrn= Success; from= canonicalTypes; to= map->types; if (which&XkbOneLevelMask) rtrn= XkbCopyKeyType(&from[XkbOneLevelIndex],&to[XkbOneLevelIndex]); if ((which&XkbTwoLevelMask)&&(rtrn==Success)) rtrn= XkbCopyKeyType(&from[XkbTwoLevelIndex],&to[XkbTwoLevelIndex]); if ((which&XkbAlphabeticMask)&&(rtrn==Success)) rtrn= XkbCopyKeyType(&from[XkbAlphabeticIndex],&to[XkbAlphabeticIndex]); if ((which&XkbKeypadMask)&&(rtrn==Success)) { XkbKeyTypePtr type; rtrn= XkbCopyKeyType(&from[XkbKeypadIndex],&to[XkbKeypadIndex]); type= &to[XkbKeypadIndex]; if ((keypadVMod>=0)&&(keypadVMod<XkbNumVirtualMods)&&(rtrn==Success)) { type->mods.vmods= (1<<keypadVMod); type->map[0].active= True; type->map[0].mods.mask= ShiftMask; type->map[0].mods.real_mods= ShiftMask; type->map[0].mods.vmods= 0; type->map[0].level= 1; type->map[1].active= False; type->map[1].mods.mask= 0; type->map[1].mods.real_mods= 0; type->map[1].mods.vmods= (1<<keypadVMod); type->map[1].level= 1; } } return Success; } /***====================================================================***/ #define CORE_SYM(i) (i<map_width?core_syms[i]:NoSymbol) #define XKB_OFFSET(g,l) (((g)*groupsWidth)+(l)) int XkbKeyTypesForCoreSymbols( XkbDescPtr xkb, int map_width, KeySym * core_syms, unsigned int protected, int * types_inout, KeySym * xkb_syms_rtrn) { register int i; unsigned int empty; int nSyms[XkbNumKbdGroups]; int nGroups,tmp,groupsWidth; /* Section 12.2 of the protocol describes this process in more detail */ /* Step 1: find the # of symbols in the core mapping per group */ groupsWidth= 2; for (i=0;i<XkbNumKbdGroups;i++) { if ((protected&(1<<i))&&(types_inout[i]<xkb->map->num_types)) { nSyms[i]= xkb->map->types[types_inout[i]].num_levels; if (nSyms[i]>groupsWidth) groupsWidth= nSyms[i]; } else { types_inout[i]= XkbTwoLevelIndex; /* don't really know, yet */ nSyms[i]= 2; } } if (nSyms[XkbGroup1Index]<2) nSyms[XkbGroup1Index]= 2; if (nSyms[XkbGroup2Index]<2) nSyms[XkbGroup2Index]= 2; /* Step 2: Copy the symbols from the core ordering to XKB ordering */ /* symbols in the core are in the order: */ /* G1L1 G1L2 G2L1 G2L2 [G1L[3-n]] [G2L[3-n]] [G3L*] [G3L*] */ xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,0)]= CORE_SYM(0); xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,1)]= CORE_SYM(1); for (i=2;i<nSyms[XkbGroup1Index];i++) { xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,i)]= CORE_SYM(2+i); } xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,0)]= CORE_SYM(2); xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,1)]= CORE_SYM(3); tmp= 2+(nSyms[XkbGroup1Index]-2); /* offset to extra group2 syms */ for (i=2;i<nSyms[XkbGroup2Index];i++) { xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,i)]= CORE_SYM(tmp+i); } tmp= nSyms[XkbGroup1Index]+nSyms[XkbGroup2Index]; if ((tmp>=map_width)&& ((protected&(XkbExplicitKeyType3Mask|XkbExplicitKeyType4Mask))==0)) { nSyms[XkbGroup3Index]= 0; nSyms[XkbGroup4Index]= 0; nGroups= 2; } else { nGroups= 3; for (i=0;i<nSyms[XkbGroup3Index];i++,tmp++) { xkb_syms_rtrn[XKB_OFFSET(XkbGroup3Index,i)]= CORE_SYM(tmp); } if ((tmp<map_width)||(protected&XkbExplicitKeyType4Mask)) { nGroups= 4; for (i=0;i<nSyms[XkbGroup4Index];i++,tmp++) { xkb_syms_rtrn[XKB_OFFSET(XkbGroup4Index,i)]= CORE_SYM(tmp); } } else { nSyms[XkbGroup4Index]= 0; } } /* steps 3&4: alphanumeric expansion, assign canonical types */ empty= 0; for (i=0;i<nGroups;i++) { KeySym *syms; syms= &xkb_syms_rtrn[XKB_OFFSET(i,0)]; if ((nSyms[i]>1)&&(syms[1]==NoSymbol)&&(syms[0]!=NoSymbol)) { KeySym upper,lower; XConvertCase(syms[0],&lower,&upper); if (upper!=lower) { xkb_syms_rtrn[XKB_OFFSET(i,0)]= lower; xkb_syms_rtrn[XKB_OFFSET(i,1)]= upper; if ((protected&(1<<i))==0) types_inout[i]= XkbAlphabeticIndex; } else if ((protected&(1<<i))==0) { types_inout[i]= XkbOneLevelIndex; /* nSyms[i]= 1;*/ } } if (((protected&(1<<i))==0)&&(types_inout[i]==XkbTwoLevelIndex)) { if (IsKeypadKey(syms[0])||IsKeypadKey(syms[1])) types_inout[i]= XkbKeypadIndex; else { KeySym upper,lower; XConvertCase(syms[0],&lower,&upper); if ((syms[0]==lower)&&(syms[1]==upper)) types_inout[i]= XkbAlphabeticIndex; } } if (syms[0]==NoSymbol) { register int n; Bool found; for (n=1,found=False;(!found)&&(n<nSyms[i]);n++) { found= (syms[n]!=NoSymbol); } if (!found) empty|= (1<<i); } } /* step 5: squoosh out empty groups */ if (empty) { for (i=nGroups-1;i>=0;i--) { if (((empty&(1<<i))==0)||(protected&(1<<i))) break; nGroups--; } } if (nGroups<1) return 0; /* step 6: replicate group 1 into group two, if necessary */ if ((nGroups>1)&&((empty&(XkbGroup1Mask|XkbGroup2Mask))==XkbGroup2Mask)) { if ((protected&(XkbExplicitKeyType1Mask|XkbExplicitKeyType2Mask))==0) { nSyms[XkbGroup2Index]= nSyms[XkbGroup1Index]; types_inout[XkbGroup2Index]= types_inout[XkbGroup1Index]; memcpy((char *)&xkb_syms_rtrn[2],(char *)xkb_syms_rtrn, 2*sizeof(KeySym)); } else if (types_inout[XkbGroup1Index]==types_inout[XkbGroup2Index]) { memcpy((char *)&xkb_syms_rtrn[nSyms[XkbGroup1Index]], (char *)xkb_syms_rtrn, nSyms[XkbGroup1Index]*sizeof(KeySym)); } } /* step 7: check for all groups identical or all width 1 */ if (nGroups>1) { Bool sameType,allOneLevel; allOneLevel= (xkb->map->types[types_inout[0]].num_levels==1); for (i=1,sameType=True;(allOneLevel||sameType)&&(i<nGroups);i++) { sameType=(sameType&&(types_inout[i]==types_inout[XkbGroup1Index])); if (allOneLevel) allOneLevel= (xkb->map->types[types_inout[i]].num_levels==1); } if ((sameType)&& (!(protected&(XkbExplicitKeyTypesMask&~XkbExplicitKeyType1Mask)))){ register int s; Bool identical; for (i=1,identical=True;identical&&(i<nGroups);i++) { KeySym *syms; syms= &xkb_syms_rtrn[XKB_OFFSET(i,0)]; for (s=0;identical&&(s<nSyms[i]);s++) { if (syms[s]!=xkb_syms_rtrn[s]) identical= False; } } if (identical) nGroups= 1; } if (allOneLevel && (nGroups>1)) { KeySym *syms; syms= &xkb_syms_rtrn[nSyms[XkbGroup1Index]]; nSyms[XkbGroup1Index]= 1; for (i=1;i<nGroups;i++) { xkb_syms_rtrn[i]= syms[0]; syms+= nSyms[i]; nSyms[i]= 1; } } } return nGroups; } static XkbSymInterpretPtr _XkbFindMatchingInterp( XkbDescPtr xkb, KeySym sym, unsigned int real_mods, unsigned int level) { register unsigned i; XkbSymInterpretPtr interp,rtrn; CARD8 mods; rtrn= NULL; interp= xkb->compat->sym_interpret; for (i=0;i<xkb->compat->num_si;i++,interp++) { if ((interp->sym==NoSymbol)||(sym==interp->sym)) { int match; if ((level==0)||((interp->match&XkbSI_LevelOneOnly)==0)) mods= real_mods; else mods= 0; switch (interp->match&XkbSI_OpMask) { case XkbSI_NoneOf: match= ((interp->mods&mods)==0); break; case XkbSI_AnyOfOrNone: match= ((mods==0)||((interp->mods&mods)!=0)); break; case XkbSI_AnyOf: match= ((interp->mods&mods)!=0); break; case XkbSI_AllOf: match= ((interp->mods&mods)==interp->mods); break; case XkbSI_Exactly: match= (interp->mods==mods); break; default: match= 0; break; } if (match) { if (interp->sym!=NoSymbol) { return interp; } else if (rtrn==NULL) { rtrn= interp; } } } } return rtrn; } static void _XkbAddKeyChange(KeyCode *pFirst,unsigned char *pNum,KeyCode newKey) { KeyCode last; last= (*pFirst)+(*pNum); if (newKey<*pFirst) { *pFirst= newKey; *pNum= (last-newKey)+1; } else if (newKey>last) { *pNum= (last-*pFirst)+1; } return; } static void _XkbSetActionKeyMods(XkbDescPtr xkb,XkbAction *act,unsigned mods) { unsigned tmp; switch (act->type) { case XkbSA_SetMods: case XkbSA_LatchMods: case XkbSA_LockMods: if (act->mods.flags&XkbSA_UseModMapMods) act->mods.real_mods= act->mods.mask= mods; if ((tmp= XkbModActionVMods(&act->mods))!=0) { XkbVirtualModsToReal(xkb,tmp,&tmp); act->mods.mask|= tmp; } break; case XkbSA_ISOLock: if (act->iso.flags&XkbSA_UseModMapMods) act->iso.real_mods= act->iso.mask= mods; if ((tmp= XkbModActionVMods(&act->iso))!=0) { XkbVirtualModsToReal(xkb,tmp,&tmp); act->iso.mask|= tmp; } break; } return; } #define IBUF_SIZE 8 Bool XkbApplyCompatMapToKey(XkbDescPtr xkb,KeyCode key,XkbChangesPtr changes) { KeySym * syms; unsigned char explicit,mods; XkbSymInterpretPtr *interps,ibuf[IBUF_SIZE]; int n,nSyms,found; unsigned changed,tmp; if ((!xkb)||(!xkb->map)||(!xkb->map->key_sym_map)|| (!xkb->compat)||(!xkb->compat->sym_interpret)|| (key<xkb->min_key_code)||(key>xkb->max_key_code)) { return False; } if (((!xkb->server)||(!xkb->server->key_acts))&& (XkbAllocServerMap(xkb,XkbAllServerInfoMask,0)!=Success)) { return False; } changed= 0; /* keeps track of what has changed in _this_ call */ explicit= xkb->server->explicit[key]; if (explicit&XkbExplicitInterpretMask) /* nothing to do */ return True; mods= (xkb->map->modmap?xkb->map->modmap[key]:0); nSyms= XkbKeyNumSyms(xkb,key); syms= XkbKeySymsPtr(xkb,key); if (nSyms>IBUF_SIZE) { interps= _XkbTypedCalloc(nSyms,XkbSymInterpretPtr); if (interps==NULL) { interps= ibuf; nSyms= IBUF_SIZE; } } else { interps= ibuf; } found= 0; for (n=0;n<nSyms;n++) { unsigned level= (n%XkbKeyGroupsWidth(xkb,key)); interps[n]= NULL; if (syms[n]!=NoSymbol) { interps[n]= _XkbFindMatchingInterp(xkb,syms[n],mods,level); if (interps[n]&&interps[n]->act.type!=XkbSA_NoAction) found++; else interps[n]= NULL; } } /* 1/28/96 (ef) -- XXX! WORKING HERE */ if (!found) { if (xkb->server->key_acts[key]!=0) { xkb->server->key_acts[key]= 0; changed|= XkbKeyActionsMask; } } else { XkbAction *pActs; unsigned int new_vmodmask; changed|= XkbKeyActionsMask; pActs= XkbResizeKeyActions(xkb,key,nSyms); if (!pActs) { if (nSyms > IBUF_SIZE) Xfree(interps); return False; } new_vmodmask= 0; for (n=0;n<nSyms;n++) { if (interps[n]) { unsigned effMods; pActs[n]= *((XkbAction *)&interps[n]->act); if ((n==0)||((interps[n]->match&XkbSI_LevelOneOnly)==0)) { effMods= mods; if (interps[n]->virtual_mod!=XkbNoModifier) new_vmodmask|= (1<<interps[n]->virtual_mod); } else effMods= 0; _XkbSetActionKeyMods(xkb,&pActs[n],effMods); } else pActs[n].type= XkbSA_NoAction; } if (((explicit&XkbExplicitVModMapMask)==0)&& (xkb->server->vmodmap[key]!=new_vmodmask)) { changed|= XkbVirtualModMapMask; xkb->server->vmodmap[key]= new_vmodmask; } if (interps[0]) { if ((interps[0]->flags&XkbSI_LockingKey)&& ((explicit&XkbExplicitBehaviorMask)==0)) { xkb->server->behaviors[key].type= XkbKB_Lock; changed|= XkbKeyBehaviorsMask; } if (((explicit&XkbExplicitAutoRepeatMask)==0)&&(xkb->ctrls)) { CARD8 old; old= xkb->ctrls->per_key_repeat[key/8]; if (interps[0]->flags&XkbSI_AutoRepeat) xkb->ctrls->per_key_repeat[key/8]|= (1<<(key%8)); else xkb->ctrls->per_key_repeat[key/8]&= ~(1<<(key%8)); if (changes && (old!=xkb->ctrls->per_key_repeat[key/8])) changes->ctrls.changed_ctrls|= XkbPerKeyRepeatMask; } } } if ((!found)||(interps[0]==NULL)) { if (((explicit&XkbExplicitAutoRepeatMask)==0)&&(xkb->ctrls)) { CARD8 old; old= xkb->ctrls->per_key_repeat[key/8]; #ifdef RETURN_SHOULD_REPEAT if (*XkbKeySymsPtr(xkb,key) != XK_Return) #endif xkb->ctrls->per_key_repeat[key/8]|= (1<<(key%8)); if (changes && (old!=xkb->ctrls->per_key_repeat[key/8])) changes->ctrls.changed_ctrls|= XkbPerKeyRepeatMask; } if (((explicit&XkbExplicitBehaviorMask)==0)&& (xkb->server->behaviors[key].type==XkbKB_Lock)) { xkb->server->behaviors[key].type= XkbKB_Default; changed|= XkbKeyBehaviorsMask; } } if (changes) { XkbMapChangesPtr mc; mc= &changes->map; tmp= (changed&mc->changed); if (tmp&XkbKeyActionsMask) _XkbAddKeyChange(&mc->first_key_act,&mc->num_key_acts,key); else if (changed&XkbKeyActionsMask) { mc->changed|= XkbKeyActionsMask; mc->first_key_act= key; mc->num_key_acts= 1; } if (tmp&XkbKeyBehaviorsMask) { _XkbAddKeyChange(&mc->first_key_behavior,&mc->num_key_behaviors, key); } else if (changed&XkbKeyBehaviorsMask) { mc->changed|= XkbKeyBehaviorsMask; mc->first_key_behavior= key; mc->num_key_behaviors= 1; } if (tmp&XkbVirtualModMapMask) _XkbAddKeyChange(&mc->first_vmodmap_key,&mc->num_vmodmap_keys,key); else if (changed&XkbVirtualModMapMask) { mc->changed|= XkbVirtualModMapMask; mc->first_vmodmap_key= key; mc->num_vmodmap_keys= 1; } mc->changed|= changed; } if (interps!=ibuf) _XkbFree(interps); return True; } Bool XkbUpdateMapFromCore( XkbDescPtr xkb, KeyCode first_key, int num_keys, int map_width, KeySym * core_keysyms, XkbChangesPtr changes) { register int key,last_key; KeySym * syms; syms= &core_keysyms[(first_key-xkb->min_key_code)*map_width]; if (changes) { if (changes->map.changed&XkbKeySymsMask) { _XkbAddKeyChange(&changes->map.first_key_sym, &changes->map.num_key_syms,first_key); if (num_keys>1) { _XkbAddKeyChange(&changes->map.first_key_sym, &changes->map.num_key_syms, first_key+num_keys-1); } } else { changes->map.changed|= XkbKeySymsMask; changes->map.first_key_sym= first_key; changes->map.num_key_syms= num_keys; } } last_key= first_key+num_keys-1; for (key=first_key;key<=last_key;key++,syms+= map_width) { XkbMapChangesPtr mc; unsigned explicit; KeySym tsyms[XkbMaxSymsPerKey]; int types[XkbNumKbdGroups]; int nG; explicit= xkb->server->explicit[key]&XkbExplicitKeyTypesMask; types[XkbGroup1Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup1Index); types[XkbGroup2Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup2Index); types[XkbGroup3Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup3Index); types[XkbGroup4Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup4Index); nG= XkbKeyTypesForCoreSymbols(xkb,map_width,syms,explicit,types,tsyms); if (changes) mc= &changes->map; else mc= NULL; XkbChangeTypesOfKey(xkb,key,nG,XkbAllGroupsMask,types,mc); memcpy((char *)XkbKeySymsPtr(xkb,key),(char *)tsyms, XkbKeyNumSyms(xkb,key)*sizeof(KeySym)); XkbApplyCompatMapToKey(xkb,key,changes); } if ((xkb->server->vmods!=NULL)&&(xkb->map->modmap!=NULL)&&(changes)&& (changes->map.changed&(XkbVirtualModMapMask|XkbModifierMapMask))) { unsigned char newVMods[XkbNumVirtualMods]; register unsigned bit,i; unsigned present; bzero(newVMods,XkbNumVirtualMods); present= 0; for (key=xkb->min_key_code;key<=xkb->max_key_code;key++) { if (xkb->server->vmodmap[key]==0) continue; for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) { if (bit&xkb->server->vmodmap[key]) { present|= bit; newVMods[i]|= xkb->map->modmap[key]; } } } for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) { if ((bit&present)&&(newVMods[i]!=xkb->server->vmods[i])) { changes->map.changed|= XkbVirtualModsMask; changes->map.vmods|= bit; xkb->server->vmods[i]= newVMods[i]; } } } if (changes && (changes->map.changed&XkbVirtualModsMask)) XkbApplyVirtualModChanges(xkb,changes->map.vmods,changes); return True; } Status XkbChangeTypesOfKey( XkbDescPtr xkb, int key, int nGroups, unsigned groups, int * newTypesIn, XkbMapChangesPtr changes) { XkbKeyTypePtr pOldType,pNewType; register int i; int width,nOldGroups,oldWidth,newTypes[XkbNumKbdGroups]; if ((!xkb) || (!XkbKeycodeInRange(xkb,key)) || (!xkb->map) || (!xkb->map->types)||((groups&XkbAllGroupsMask)==0)|| (nGroups>XkbNumKbdGroups)) { return BadMatch; } if (nGroups==0) { for (i=0;i<XkbNumKbdGroups;i++) { xkb->map->key_sym_map[key].kt_index[i]= XkbOneLevelIndex; } i= xkb->map->key_sym_map[key].group_info; i= XkbSetNumGroups(i,0); xkb->map->key_sym_map[key].group_info= i; XkbResizeKeySyms(xkb,key,0); return Success; } nOldGroups= XkbKeyNumGroups(xkb,key); oldWidth= XkbKeyGroupsWidth(xkb,key); for (width=i=0;i<nGroups;i++) { if (groups&(1<<i)) newTypes[i]= newTypesIn[i]; else if (i<nOldGroups) newTypes[i]= XkbKeyKeyTypeIndex(xkb,key,i); else if (nOldGroups>0) newTypes[i]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup1Index); else newTypes[i]= XkbTwoLevelIndex; if (newTypes[i]>xkb->map->num_types) return BadMatch; pNewType= &xkb->map->types[newTypes[i]]; if (pNewType->num_levels>width) width= pNewType->num_levels; } if ((xkb->ctrls)&&(nGroups>xkb->ctrls->num_groups)) xkb->ctrls->num_groups= nGroups; if ((width!=oldWidth)||(nGroups!=nOldGroups)) { KeySym oldSyms[XkbMaxSymsPerKey],*pSyms; int nCopy; if (nOldGroups==0) { pSyms= XkbResizeKeySyms(xkb,key,width*nGroups); if (pSyms!=NULL) { i= xkb->map->key_sym_map[key].group_info; i= XkbSetNumGroups(i,nGroups); xkb->map->key_sym_map[key].group_info= i; xkb->map->key_sym_map[key].width= width; for (i=0;i<nGroups;i++) { xkb->map->key_sym_map[key].kt_index[i]= newTypes[i]; } return Success; } return BadAlloc; } pSyms= XkbKeySymsPtr(xkb,key); memcpy(oldSyms,pSyms,XkbKeyNumSyms(xkb,key)*sizeof(KeySym)); pSyms= XkbResizeKeySyms(xkb,key,width*nGroups); if (pSyms==NULL) return BadAlloc; bzero(pSyms,width*nGroups*sizeof(KeySym)); for (i=0;(i<nGroups)&&(i<nOldGroups);i++) { pOldType= XkbKeyKeyType(xkb,key,i); pNewType= &xkb->map->types[newTypes[i]]; if (pNewType->num_levels>pOldType->num_levels) nCopy= pOldType->num_levels; else nCopy= pNewType->num_levels; memcpy(&pSyms[i*width],&oldSyms[i*oldWidth],nCopy*sizeof(KeySym)); } if (XkbKeyHasActions(xkb,key)) { XkbAction oldActs[XkbMaxSymsPerKey],*pActs; pActs= XkbKeyActionsPtr(xkb,key); memcpy(oldActs,pActs,XkbKeyNumSyms(xkb,key)*sizeof(XkbAction)); pActs= XkbResizeKeyActions(xkb,key,width*nGroups); if (pActs==NULL) return BadAlloc; bzero(pActs,width*nGroups*sizeof(XkbAction)); for (i=0;(i<nGroups)&&(i<nOldGroups);i++) { pOldType= XkbKeyKeyType(xkb,key,i); pNewType= &xkb->map->types[newTypes[i]]; if (pNewType->num_levels>pOldType->num_levels) nCopy= pOldType->num_levels; else nCopy= pNewType->num_levels; memcpy(&pActs[i*width],&oldActs[i*oldWidth], nCopy*sizeof(XkbAction)); } } i= xkb->map->key_sym_map[key].group_info; i= XkbSetNumGroups(i,nGroups); xkb->map->key_sym_map[key].group_info= i; xkb->map->key_sym_map[key].width= width; } width= 0; for (i=0;i<nGroups;i++) { xkb->map->key_sym_map[key].kt_index[i]= newTypes[i]; if (xkb->map->types[newTypes[i]].num_levels>width) width= xkb->map->types[newTypes[i]].num_levels; } xkb->map->key_sym_map[key].width= width; if (changes!=NULL) { if (changes->changed&XkbKeySymsMask) { _XkbAddKeyChange(&changes->first_key_sym,&changes->num_key_syms, key); } else { changes->changed|= XkbKeySymsMask; changes->first_key_sym= key; changes->num_key_syms= 1; } } return Success; } /***====================================================================***/ Bool XkbVirtualModsToReal(XkbDescPtr xkb,unsigned virtual_mask,unsigned *mask_rtrn) { register int i,bit; register unsigned mask; if (xkb==NULL) return False; if (virtual_mask==0) { *mask_rtrn= 0; return True; } if (xkb->server==NULL) return False; for (i=mask=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) { if (virtual_mask&bit) mask|= xkb->server->vmods[i]; } *mask_rtrn= mask; return True; } /***====================================================================***/ Bool XkbUpdateActionVirtualMods(XkbDescPtr xkb,XkbAction *act,unsigned changed) { unsigned int tmp; switch (act->type) { case XkbSA_SetMods: case XkbSA_LatchMods: case XkbSA_LockMods: if (((tmp= XkbModActionVMods(&act->mods))&changed)!=0) { XkbVirtualModsToReal(xkb,tmp,&tmp); act->mods.mask= act->mods.real_mods; act->mods.mask|= tmp; return True; } break; case XkbSA_ISOLock: if ((((tmp= XkbModActionVMods(&act->iso))!=0)&changed)!=0) { XkbVirtualModsToReal(xkb,tmp,&tmp); act->iso.mask= act->iso.real_mods; act->iso.mask|= tmp; return True; } break; } return False; } void XkbUpdateKeyTypeVirtualMods( XkbDescPtr xkb, XkbKeyTypePtr type, unsigned int changed, XkbChangesPtr changes) { register unsigned int i; unsigned int mask; XkbVirtualModsToReal(xkb,type->mods.vmods,&mask); type->mods.mask= type->mods.real_mods|mask; if ((type->map_count>0)&&(type->mods.vmods!=0)) { XkbKTMapEntryPtr entry; for (i=0,entry=type->map;i<type->map_count;i++,entry++) { if (entry->mods.vmods!=0) { XkbVirtualModsToReal(xkb,entry->mods.vmods,&mask); entry->mods.mask=entry->mods.real_mods|mask; /* entry is active if vmods are bound*/ entry->active= (mask!=0); } else entry->active= 1; } } if (changes) { int type_ndx; type_ndx= type-xkb->map->types; if ((type_ndx<0)||(type_ndx>xkb->map->num_types)) return; if (changes->map.changed&XkbKeyTypesMask) { int last; last= changes->map.first_type+changes->map.num_types-1; if (type_ndx<changes->map.first_type) { changes->map.first_type= type_ndx; changes->map.num_types= (last-type_ndx)+1; } else if (type_ndx>last) { changes->map.num_types= (type_ndx-changes->map.first_type)+1; } } else { changes->map.changed|= XkbKeyTypesMask; changes->map.first_type= type_ndx; changes->map.num_types= 1; } } return; } Bool XkbApplyVirtualModChanges(XkbDescPtr xkb,unsigned changed,XkbChangesPtr changes) { register int i; unsigned int checkState = 0; if ((!xkb) || (!xkb->map) || (changed==0)) return False; for (i=0;i<xkb->map->num_types;i++) { if (xkb->map->types[i].mods.vmods & changed) XkbUpdateKeyTypeVirtualMods(xkb,&xkb->map->types[i],changed,changes); } if (changed&xkb->ctrls->internal.vmods) { unsigned int newMask; XkbVirtualModsToReal(xkb,xkb->ctrls->internal.vmods,&newMask); newMask|= xkb->ctrls->internal.real_mods; if (xkb->ctrls->internal.mask!=newMask) { xkb->ctrls->internal.mask= newMask; if (changes) { changes->ctrls.changed_ctrls|= XkbInternalModsMask; checkState= True; } } } if (changed&xkb->ctrls->ignore_lock.vmods) { unsigned int newMask; XkbVirtualModsToReal(xkb,xkb->ctrls->ignore_lock.vmods,&newMask); newMask|= xkb->ctrls->ignore_lock.real_mods; if (xkb->ctrls->ignore_lock.mask!=newMask) { xkb->ctrls->ignore_lock.mask= newMask; if (changes) { changes->ctrls.changed_ctrls|= XkbIgnoreLockModsMask; checkState= True; } } } if (xkb->indicators!=NULL) { XkbIndicatorMapPtr map; map= &xkb->indicators->maps[0]; for (i=0;i<XkbNumIndicators;i++,map++) { if (map->mods.vmods&changed) { unsigned int newMask; XkbVirtualModsToReal(xkb,map->mods.vmods,&newMask); newMask|= map->mods.real_mods; if (newMask!=map->mods.mask) { map->mods.mask= newMask; if (changes) { changes->indicators.map_changes|= (1<<i); checkState= True; } } } } } if (xkb->compat!=NULL) { XkbCompatMapPtr compat; compat= xkb->compat; for (i=0;i<XkbNumKbdGroups;i++) { unsigned int newMask; XkbVirtualModsToReal(xkb,compat->groups[i].vmods,&newMask); newMask|= compat->groups[i].real_mods; if (compat->groups[i].mask!=newMask) { compat->groups[i].mask= newMask; if (changes) { changes->compat.changed_groups|= (1<<i); checkState= True; } } } } if (xkb->map && xkb->server) { int highChange = 0, lowChange = -1; for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) { if (XkbKeyHasActions(xkb,i)) { register XkbAction *pAct; register int n; pAct= XkbKeyActionsPtr(xkb,i); for (n=XkbKeyNumActions(xkb,i);n>0;n--,pAct++) { if ((pAct->type!=XkbSA_NoAction)&& XkbUpdateActionVirtualMods(xkb,pAct,changed)) { if (lowChange<0) lowChange= i; highChange= i; } } } } if (changes && (lowChange>0)) { /* something changed */ if (changes->map.changed&XkbKeyActionsMask) { int last; if (changes->map.first_key_act<lowChange) lowChange= changes->map.first_key_act; last= changes->map.first_key_act+changes->map.num_key_acts-1; if (last>highChange) highChange= last; } changes->map.changed|= XkbKeyActionsMask; changes->map.first_key_act= lowChange; changes->map.num_key_acts= (highChange-lowChange)+1; } } return checkState; }