home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / XKBMisc.c < prev    next >
C/C++ Source or Header  |  1999-11-02  |  32KB  |  1,084 lines
  1. /* $XConsortium: XKBMisc.c /main/3 1996/03/01 14:29:50 kaleb $ */
  2. /************************************************************
  3. Copyright (c) 1993 by Silicon Graphics Computer Systems, Inc.
  4.  
  5. Permission to use, copy, modify, and distribute this
  6. software and its documentation for any purpose and without
  7. fee is hereby granted, provided that the above copyright
  8. notice appear in all copies and that both that copyright
  9. notice and this permission notice appear in supporting
  10. documentation, and that the name of Silicon Graphics not be 
  11. used in advertising or publicity pertaining to distribution 
  12. of the software without specific prior written permission.
  13. Silicon Graphics makes no representation about the suitability 
  14. of this software for any purpose. It is provided "as is"
  15. without any express or implied warranty.
  16.  
  17. SILICON GRAPHICS DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS 
  18. SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY 
  19. AND FITNESS FOR A PARTICULAR PURPOSE. IN NO EVENT SHALL SILICON
  20. GRAPHICS BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL 
  21. DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, 
  22. DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE 
  23. OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION  WITH
  24. THE USE OR PERFORMANCE OF THIS SOFTWARE.
  25.  
  26. ********************************************************/
  27.  
  28. #ifndef XKB_IN_SERVER
  29.  
  30. #include <stdio.h>
  31. #define NEED_REPLIES
  32. #define NEED_EVENTS
  33. #include "Xlib_private.h"
  34. #include <X11/extensions/XKBproto.h>
  35. #include <X11/keysym.h>
  36. #include "XKBlibint.h"
  37.  
  38. #else 
  39.  
  40. #include <stdio.h>
  41. #include "X.h"
  42. #define    NEED_EVENTS
  43. #define    NEED_REPLIES
  44. #include "Xproto.h"
  45. #include "misc.h"
  46. #include "inputstr.h"
  47. #include <X11/keysym.h>
  48. #define    XKBSRV_NEED_FILE_FUNCS
  49. #include "XKBsrv.h"
  50.  
  51. #endif /* XKB_IN_SERVER */
  52.  
  53. /***====================================================================***/
  54.  
  55. #define    mapSize(m)    (sizeof(m)/sizeof(XkbKTMapEntryRec))
  56. static  XkbKTMapEntryRec map2Level[]= { 
  57.     { True, ShiftMask, 1, ShiftMask, 0 }
  58. };
  59.  
  60. static  XkbKTMapEntryRec mapAlpha[]= { 
  61.     { True, ShiftMask, 1, ShiftMask, 0 },
  62.     { True,    LockMask,  0,  LockMask, 0 }
  63. };
  64.  
  65. static    XkbModsRec preAlpha[]= {
  66.     {        0,        0, 0 },
  67.     { LockMask, LockMask, 0 }
  68. };
  69.  
  70. #define    NL_VMOD_MASK    0
  71. static  XkbKTMapEntryRec mapKeypad[]= { 
  72.     { True,    ShiftMask, 1, ShiftMask,            0 },
  73.     { False,        0, 1,         0, NL_VMOD_MASK }
  74. };
  75.  
  76. static    XkbKeyTypeRec    canonicalTypes[XkbNumRequiredTypes] = {
  77.     { { 0, 0, 0 }, 
  78.       1,    /* num_levels */
  79.       0,    /* map_count */
  80.       NULL,        NULL,
  81.       None,        NULL
  82.     },
  83.     { { ShiftMask, ShiftMask, 0 }, 
  84.       2,    /* num_levels */
  85.       mapSize(map2Level),    /* map_count */
  86.       map2Level,    NULL,
  87.       None,        NULL
  88.     },
  89.     { { ShiftMask|LockMask, ShiftMask|LockMask, 0 }, 
  90.       2,                /* num_levels */
  91.       mapSize(mapAlpha),        /* map_count */
  92.       mapAlpha,    preAlpha,
  93.       None,        NULL
  94.     },
  95.     { { ShiftMask, ShiftMask, NL_VMOD_MASK },
  96.       2,                /* num_levels */
  97.       mapSize(mapKeypad),        /* map_count */
  98.       mapKeypad,    NULL,
  99.       None,        NULL
  100.     }
  101. };
  102.  
  103. Status
  104. #if NeedFunctionPrototypes
  105. XkbInitCanonicalKeyTypes(XkbDescPtr xkb,unsigned which,int keypadVMod)
  106. #else
  107. XkbInitCanonicalKeyTypes(xkb,which,keypadVMod)
  108.     XkbDescPtr        xkb;
  109.     unsigned        which;
  110.     int            keypadVMod;
  111. #endif
  112. {
  113.     DBUG_ENTER("XkbInitCanonicalKeyTypes")
  114.     XkbClientMapPtr    map;
  115.     XkbKeyTypePtr    from,to;
  116.     Status        rtrn;
  117.  
  118.     if (!xkb)
  119.     DBUG_RETURN(BadMatch);
  120.     rtrn= XkbAllocClientMap(xkb,XkbKeyTypesMask,XkbNumRequiredTypes);
  121.     if (rtrn!=Success)
  122.     DBUG_RETURN(rtrn);
  123.     map= xkb->map;
  124.     if ((which&XkbAllRequiredTypes)==0)
  125.     DBUG_RETURN(Success);
  126.     rtrn= Success;
  127.     from= canonicalTypes;
  128.     to= map->types;
  129.     if (which&XkbOneLevelMask)
  130.     rtrn= XkbCopyKeyType(&from[XkbOneLevelIndex],&to[XkbOneLevelIndex]);
  131.     if ((which&XkbTwoLevelMask)&&(rtrn==Success))
  132.     rtrn= XkbCopyKeyType(&from[XkbTwoLevelIndex],&to[XkbTwoLevelIndex]);
  133.     if ((which&XkbAlphabeticMask)&&(rtrn==Success))
  134.     rtrn= XkbCopyKeyType(&from[XkbAlphabeticIndex],&to[XkbAlphabeticIndex]);
  135.     if ((which&XkbKeypadMask)&&(rtrn==Success)) {
  136.     XkbKeyTypePtr type;
  137.     rtrn= XkbCopyKeyType(&from[XkbKeypadIndex],&to[XkbKeypadIndex]);
  138.     type= &to[XkbKeypadIndex];
  139.     if ((keypadVMod>=0)&&(keypadVMod<XkbNumVirtualMods)&&(rtrn==Success)) {
  140.         type->mods.vmods= (1<<keypadVMod);
  141.         type->map[0].active= True;
  142.         type->map[0].mods.mask= ShiftMask;
  143.         type->map[0].mods.real_mods= ShiftMask;
  144.         type->map[0].mods.vmods= 0;
  145.         type->map[0].level= 1;
  146.         type->map[1].active= False;
  147.         type->map[1].mods.mask= 0;
  148.         type->map[1].mods.real_mods= 0;
  149.         type->map[1].mods.vmods= (1<<keypadVMod);
  150.         type->map[1].level= 1;
  151.     }
  152.     }
  153.     DBUG_RETURN(Success);
  154. }
  155.  
  156. /***====================================================================***/
  157.  
  158. #define    CORE_SYM(i)    (i<map_width?core_syms[i]:NoSymbol)
  159. #define    XKB_OFFSET(g,l)    (((g)*groupsWidth)+(l))
  160.  
  161. int
  162. #if NeedFunctionPrototypes
  163. XkbKeyTypesForCoreSymbols(    XkbDescPtr    xkb,
  164.                 int        map_width,
  165.                 KeySym *    core_syms,
  166.                 unsigned int     protected,
  167.                     int *        types_inout,
  168.                 KeySym *    xkb_syms_rtrn)
  169. #else
  170. XkbKeyTypesForCoreSymbols(xkb,map_width,core_syms,protected,types_inout,
  171.                                 xkb_syms_rtrn)
  172.     XkbDescPtr        xkb;
  173.     int            map_width;
  174.     KeySym *        core_syms;
  175.     unsigned int     protected;
  176.     int *        types_inout;
  177.     KeySym *         xkb_syms_rtrn;
  178. #endif
  179. {
  180.     DBUG_ENTER("XkbKeyTypesForCoreSymbols")
  181.     register int    i;
  182.     unsigned int    empty;
  183.     int        nSyms[XkbNumKbdGroups];
  184.     int        nGroups,tmp,groupsWidth;
  185.  
  186.     /* Section 12.2 of the protocol describes this process in more detail */
  187.     /* Step 1:  find the # of symbols in the core mapping per group */
  188.     groupsWidth= 2;
  189.     for (i=0;i<XkbNumKbdGroups;i++) {
  190.     if ((protected&(1<<i))&&(types_inout[i]<xkb->map->num_types)) {
  191.         nSyms[i]= xkb->map->types[types_inout[i]].num_levels;
  192.         if (nSyms[i]>groupsWidth)
  193.         groupsWidth= nSyms[i];
  194.     }
  195.     else {
  196.         types_inout[i]= XkbTwoLevelIndex;    /* don't really know, yet */
  197.         nSyms[i]= 2;
  198.     }
  199.     }
  200.     if (nSyms[XkbGroup1Index]<2)
  201.     nSyms[XkbGroup1Index]= 2;
  202.     if (nSyms[XkbGroup2Index]<2)
  203.     nSyms[XkbGroup2Index]= 2;
  204.     /* Step 2:    Copy the symbols from the core ordering to XKB ordering    */
  205.     /*        symbols in the core are in the order:            */
  206.     /*        G1L1 G1L2 G2L1 G2L2 [G1L[3-n]] [G2L[3-n]] [G3L*] [G3L*]    */
  207.     xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,0)]= CORE_SYM(0);
  208.     xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,1)]= CORE_SYM(1);
  209.     for (i=2;i<nSyms[XkbGroup1Index];i++) {
  210.     xkb_syms_rtrn[XKB_OFFSET(XkbGroup1Index,i)]= CORE_SYM(2+i);
  211.     }
  212.     xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,0)]= CORE_SYM(2);
  213.     xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,1)]= CORE_SYM(3);
  214.     tmp= 2+(nSyms[XkbGroup1Index]-2); /* offset to extra group2 syms */
  215.     for (i=2;i<nSyms[XkbGroup2Index];i++) {
  216.     xkb_syms_rtrn[XKB_OFFSET(XkbGroup2Index,i)]= CORE_SYM(tmp+i);
  217.     }
  218.     tmp= nSyms[XkbGroup1Index]+nSyms[XkbGroup2Index];
  219.     if ((tmp>=map_width)&&
  220.      ((protected&(XkbExplicitKeyType3Mask|XkbExplicitKeyType4Mask))==0)) {
  221.     nSyms[XkbGroup3Index]= 0;
  222.     nSyms[XkbGroup4Index]= 0;
  223.     nGroups= 2;
  224.     }
  225.     else {
  226.         nGroups= 3;
  227.     for (i=0;i<nSyms[XkbGroup3Index];i++,tmp++) {
  228.         xkb_syms_rtrn[XKB_OFFSET(XkbGroup3Index,i)]= CORE_SYM(tmp);
  229.     }
  230.     if ((tmp<map_width)||(protected&XkbExplicitKeyType4Mask)) {
  231.         nGroups= 4;
  232.         for (i=0;i<nSyms[XkbGroup4Index];i++,tmp++) {
  233.         xkb_syms_rtrn[XKB_OFFSET(XkbGroup4Index,i)]= CORE_SYM(tmp);
  234.         }
  235.     }
  236.     else {
  237.         nSyms[XkbGroup4Index]= 0;
  238.     }
  239.     }
  240.     /* steps 3&4: alphanumeric expansion,  assign canonical types */
  241.     empty= 0;
  242.     for (i=0;i<nGroups;i++) {
  243.     KeySym *syms;
  244.     syms= &xkb_syms_rtrn[XKB_OFFSET(i,0)];
  245.     if ((nSyms[i]>1)&&(syms[1]==NoSymbol)&&(syms[0]!=NoSymbol)) {
  246.         KeySym upper,lower;
  247.         XConvertCase(syms[0],&lower,&upper);
  248.         if (upper!=lower) {
  249.         xkb_syms_rtrn[XKB_OFFSET(i,0)]= lower;
  250.         xkb_syms_rtrn[XKB_OFFSET(i,1)]= upper;
  251.         if ((protected&(1<<i))==0)
  252.             types_inout[i]= XkbAlphabeticIndex;
  253.         }
  254.         else if ((protected&(1<<i))==0) {
  255.         types_inout[i]= XkbOneLevelIndex;
  256.     /*    nSyms[i]=    1;*/
  257.         }
  258.     }
  259.     if (((protected&(1<<i))==0)&&(types_inout[i]==XkbTwoLevelIndex)) {
  260.         if (IsKeypadKey(syms[0])||IsKeypadKey(syms[1]))
  261.         types_inout[i]= XkbKeypadIndex;
  262.         else {
  263.         KeySym upper,lower;
  264.         XConvertCase(syms[0],&lower,&upper);
  265.         if ((syms[0]==lower)&&(syms[1]==upper))
  266.             types_inout[i]= XkbAlphabeticIndex;
  267.         }
  268.     }
  269.     if (syms[0]==NoSymbol) {
  270.         register int n;
  271.         Bool    found;
  272.         for (n=1,found=False;(!found)&&(n<nSyms[i]);n++) {
  273.         found= (syms[n]!=NoSymbol);
  274.         }
  275.         if (!found)
  276.         empty|= (1<<i);
  277.     }
  278.     }
  279.     /* step 5: squoosh out empty groups */
  280.     if (empty) {
  281.     for (i=nGroups-1;i>=0;i--) {
  282.         if (((empty&(1<<i))==0)||(protected&(1<<i)))
  283.         break;
  284.         nGroups--;
  285.     }
  286.     }
  287.     if (nGroups<1)
  288.     DBUG_RETURN(0);
  289.  
  290.     /* step 6: replicate group 1 into group two, if necessary */
  291.     if ((nGroups>1)&&((empty&(XkbGroup1Mask|XkbGroup2Mask))==XkbGroup2Mask)) {
  292.     if ((protected&(XkbExplicitKeyType1Mask|XkbExplicitKeyType2Mask))==0) {
  293.         nSyms[XkbGroup2Index]= nSyms[XkbGroup1Index];
  294.         types_inout[XkbGroup2Index]= types_inout[XkbGroup1Index];
  295.         memcpy((char *)&xkb_syms_rtrn[2],(char *)xkb_syms_rtrn,
  296.                             2*sizeof(KeySym));
  297.     }
  298.     else if (types_inout[XkbGroup1Index]==types_inout[XkbGroup2Index]) {
  299.         memcpy((char *)&xkb_syms_rtrn[nSyms[XkbGroup1Index]],
  300.                         (char *)xkb_syms_rtrn,
  301.                     nSyms[XkbGroup1Index]*sizeof(KeySym));
  302.     }
  303.     }
  304.  
  305.     /* step 7: check for all groups identical or all width 1 */
  306.     if (nGroups>1) {
  307.     Bool sameType,allOneLevel;
  308.     allOneLevel= (xkb->map->types[types_inout[0]].num_levels==1);
  309.     for (i=1,sameType=True;(allOneLevel||sameType)&&(i<nGroups);i++) {
  310.         sameType=(sameType&&(types_inout[i]==types_inout[XkbGroup1Index]));
  311.         if (allOneLevel)
  312.         allOneLevel= (xkb->map->types[types_inout[i]].num_levels==1);
  313.     }
  314.     if ((sameType)&&
  315.         (!(protected&(XkbExplicitKeyTypesMask&~XkbExplicitKeyType1Mask)))){
  316.         register int s;
  317.         Bool    identical;
  318.         for (i=1,identical=True;identical&&(i<nGroups);i++) {
  319.         KeySym *syms;
  320.         syms= &xkb_syms_rtrn[XKB_OFFSET(i,0)];
  321.         for (s=0;identical&&(s<nSyms[i]);s++) {
  322.             if (syms[s]!=xkb_syms_rtrn[s])
  323.             identical= False;
  324.         }
  325.         }
  326.         if (identical)
  327.         nGroups= 1;
  328.     }
  329.     if (allOneLevel && (nGroups>1)) {
  330.         KeySym *syms;
  331.         syms= &xkb_syms_rtrn[nSyms[XkbGroup1Index]];
  332.         nSyms[XkbGroup1Index]= 1;
  333.         for (i=1;i<nGroups;i++) {
  334.         xkb_syms_rtrn[i]= syms[0];
  335.         syms+= nSyms[i];
  336.         nSyms[i]= 1;
  337.         }
  338.     }
  339.     }
  340.     DBUG_RETURN(nGroups);
  341. }
  342.  
  343. static XkbSymInterpretPtr
  344. #if NeedFunctionPrototypes
  345. _XkbFindMatchingInterp(    XkbDescPtr    xkb,
  346.             KeySym         sym,
  347.             unsigned int    real_mods,
  348.             unsigned int    level)
  349. #else
  350. _XkbFindMatchingInterp(xkb,sym,real_mods,level)
  351.     XkbDescPtr        xkb;
  352.     KeySym        sym;
  353.     unsigned int    real_mods;
  354.     unsigned int    level;
  355. #endif
  356. {
  357.     DBUG_ENTER("_XkbFindMatchingInterp")
  358.     register unsigned     i;
  359.     XkbSymInterpretPtr     interp,rtrn;
  360.     CARD8             mods;
  361.  
  362.     rtrn= NULL;
  363.     interp= xkb->compat->sym_interpret;
  364.     for (i=0;i<xkb->compat->num_si;i++,interp++) {
  365.     if ((interp->sym==NoSymbol)||(sym==interp->sym)) {
  366.         int match;
  367.         if ((level==0)||((interp->match&XkbSI_LevelOneOnly)==0))
  368.          mods= real_mods;
  369.         else mods= 0;
  370.         switch (interp->match&XkbSI_OpMask) {
  371.         case XkbSI_NoneOf:
  372.             match= ((interp->mods&mods)==0);
  373.             break;
  374.         case XkbSI_AnyOfOrNone:
  375.             match= ((mods==0)||((interp->mods&mods)!=0));
  376.             break;
  377.         case XkbSI_AnyOf:
  378.             match= ((interp->mods&mods)!=0);
  379.             break;
  380.         case XkbSI_AllOf:
  381.             match= ((interp->mods&mods)==interp->mods);
  382.             break;
  383.         case XkbSI_Exactly:
  384.             match= (interp->mods==mods);
  385.             break;
  386.         default:
  387.             match= 0;
  388.             break;
  389.         }
  390.         if (match) {
  391.         if (interp->sym!=NoSymbol) {
  392.             DBUG_RETURN(interp);
  393.         }
  394.         else if (rtrn==NULL) {
  395.             rtrn= interp;
  396.         }
  397.         }
  398.     }
  399.     }
  400.     DBUG_RETURN(rtrn);
  401. }
  402.  
  403. static void
  404. #if NeedFunctionPrototypes
  405. _XkbAddKeyChange(KeyCode *pFirst,unsigned char *pNum,KeyCode newKey)
  406. #else
  407. _XkbAddKeyChange(pFirst,pNum,newKey)
  408.     KeyCode *        pFirst;
  409.     unsigned char *    pNum;
  410.     KeyCode        newKey;
  411. #endif
  412. {
  413.     DBUG_ENTER("_XkbAddKeyChange")
  414.     KeyCode    last;
  415.  
  416.     last= (*pFirst)+(*pNum);
  417.     if (newKey<*pFirst) {
  418.     *pFirst= newKey;
  419.     *pNum= (last-newKey)+1;
  420.     }
  421.     else if (newKey>last) {
  422.     *pNum= (last-*pFirst)+1;
  423.     }
  424.     DBUG_VOID_RETURN;
  425. }
  426.  
  427. static void
  428. #if NeedFunctionPrototypes
  429. _XkbSetActionKeyMods(XkbDescPtr xkb,XkbAction *act,unsigned mods)
  430. #else
  431. _XkbSetActionKeyMods(xkb,act,mods)
  432.     XkbDescPtr    xkb;
  433.     XkbAction *    act;
  434.     unsigned    mods;
  435. #endif
  436. {
  437.     DBUG_ENTER("_XkbSetActionKeyMods")
  438.     unsigned    tmp;
  439.  
  440.     switch (act->type) {
  441.     case XkbSA_SetMods: case XkbSA_LatchMods: case XkbSA_LockMods:
  442.         if (act->mods.flags&XkbSA_UseModMapMods)
  443.         act->mods.real_mods= act->mods.mask= mods;
  444.         if ((tmp= XkbModActionVMods(&act->mods))!=0) {
  445.         XkbVirtualModsToReal(xkb,tmp,&tmp);
  446.         act->mods.mask|= tmp;
  447.         }
  448.         break;
  449.     case XkbSA_ISOLock:
  450.         if (act->iso.flags&XkbSA_UseModMapMods)
  451.         act->iso.real_mods= act->iso.mask= mods;
  452.         if ((tmp= XkbModActionVMods(&act->iso))!=0) {
  453.         XkbVirtualModsToReal(xkb,tmp,&tmp);
  454.         act->iso.mask|= tmp;
  455.         }
  456.         break;
  457.     }
  458.     DBUG_VOID_RETURN;
  459. }
  460.  
  461. #define    IBUF_SIZE    8
  462.  
  463. Bool
  464. #if NeedFunctionPrototypes
  465. XkbApplyCompatMapToKey(XkbDescPtr xkb,KeyCode key,XkbChangesPtr changes)
  466. #else
  467. XkbApplyCompatMapToKey(xkb,key,changes)
  468.     XkbDescPtr        xkb;
  469.     KeyCode        key;
  470.     XkbChangesPtr    changes;
  471. #endif
  472. {
  473.     DBUG_ENTER("XkbApplyCompatMapToKey")
  474.     KeySym *        syms;
  475.     unsigned char         explicit,mods;
  476.     XkbSymInterpretPtr    *interps,ibuf[IBUF_SIZE]; 
  477.     int            n,nSyms,found;
  478.     unsigned        changed,changedVMods,tmp;
  479.  
  480.     if ((!xkb)||(!xkb->map)||(!xkb->map->key_sym_map)||
  481.                 (!xkb->compat)||(!xkb->compat->sym_interpret)||
  482.             (key<xkb->min_key_code)||(key>xkb->max_key_code)) {
  483.     DBUG_RETURN(False);
  484.     }
  485.     if (((!xkb->server)||(!xkb->server->key_acts))&&
  486.         (XkbAllocServerMap(xkb,XkbAllServerInfoMask,0)!=Success)) {
  487.     DBUG_RETURN(False);
  488.     }
  489.     changed= 0;    /* keeps track of what has changed in _this_ call */
  490.     explicit= xkb->server->explicit[key];
  491.     if (explicit&XkbExplicitInterpretMask) /* nothing to do */
  492.     DBUG_RETURN(True);
  493.     mods= (xkb->map->modmap?xkb->map->modmap[key]:0);
  494.     nSyms= XkbKeyNumSyms(xkb,key);
  495.     syms= XkbKeySymsPtr(xkb,key);
  496.     if (nSyms>IBUF_SIZE) {
  497.     interps= _XkbTypedCalloc(nSyms,XkbSymInterpretPtr);
  498.     if (interps==NULL) {
  499.         interps= ibuf;
  500.         nSyms= IBUF_SIZE;
  501.     }
  502.     }
  503.     else {
  504.     interps= ibuf;
  505.     }
  506.     found= 0;
  507.     for (n=0;n<nSyms;n++) {
  508.     unsigned level= (n%XkbKeyGroupsWidth(xkb,key));
  509.     interps[n]= NULL;
  510.     if (syms[n]!=NoSymbol) {
  511.         interps[n]= _XkbFindMatchingInterp(xkb,syms[n],mods,level);
  512.         if (interps[n]&&interps[n]->act.type!=XkbSA_NoAction)
  513.         found++;
  514.         else interps[n]= NULL;
  515.     }
  516.     }
  517.     /* 1/28/96 (ef) -- XXX! WORKING HERE */
  518.     if (!found) {
  519.     if (xkb->server->key_acts[key]!=0) {
  520.         xkb->server->key_acts[key]= 0;
  521.         changed|= XkbKeyActionsMask;
  522.     }
  523.     }
  524.     else {
  525.     XkbAction *pActs;
  526.     unsigned int    new_vmodmask;
  527.     changed|= XkbKeyActionsMask;
  528.     pActs= XkbResizeKeyActions(xkb,key,nSyms);
  529.     if (!pActs)
  530.         DBUG_RETURN(False);
  531.     new_vmodmask= 0;
  532.     for (n=0;n<nSyms;n++) {
  533.         if (interps[n]) {
  534.         unsigned effMods;
  535.  
  536.         pActs[n]= *((XkbAction *)&interps[n]->act);
  537.         if ((n==0)||((interps[n]->match&XkbSI_LevelOneOnly)==0)) {
  538.              effMods= mods;
  539.              if (interps[n]->virtual_mod!=XkbNoModifier)
  540.             new_vmodmask|= (1<<interps[n]->virtual_mod);
  541.         }
  542.         else effMods= 0;
  543.         _XkbSetActionKeyMods(xkb,&pActs[n],effMods);
  544.         }
  545.         else pActs[n].type= XkbSA_NoAction;
  546.     }
  547.     if (((explicit&XkbExplicitVModMapMask)==0)&&
  548.                 (xkb->server->vmodmap[key]!=new_vmodmask)) {
  549.         changed|= XkbVirtualModMapMask;
  550.         xkb->server->vmodmap[key]= new_vmodmask;
  551.     }
  552.     if (interps[0]) {
  553.         if ((interps[0]->flags&XkbSI_LockingKey)&&
  554.                 ((explicit&XkbExplicitBehaviorMask)==0)) {
  555.         xkb->server->behaviors[key].type= XkbKB_Lock;
  556.         changed|= XkbKeyBehaviorsMask;
  557.         }
  558.         if (((explicit&XkbExplicitAutoRepeatMask)==0)&&(xkb->ctrls)) {
  559.         CARD8 old;
  560.         old= xkb->ctrls->per_key_repeat[key/8];
  561.         if (interps[0]->flags&XkbSI_AutoRepeat)
  562.              xkb->ctrls->per_key_repeat[key/8]|= (1<<(key%8));
  563.         else xkb->ctrls->per_key_repeat[key/8]&= ~(1<<(key%8));
  564.         if (changes && (old!=xkb->ctrls->per_key_repeat[key/8]))
  565.             changes->ctrls.changed_ctrls|= XkbPerKeyRepeatMask;
  566.         }
  567.     }
  568.     }
  569.     if ((!found)||(interps[0]==NULL)) {
  570.     if (((explicit&XkbExplicitAutoRepeatMask)==0)&&(xkb->ctrls)) {
  571.         CARD8 old;
  572.         old= xkb->ctrls->per_key_repeat[key/8];
  573. #if RETURN_SHOULD_REPEAT
  574.         if (*XkbKeySymsPtr(xkb,key) != XK_Return)
  575. #endif
  576.         xkb->ctrls->per_key_repeat[key/8]|= (1<<(key%8));
  577.         if (changes && (old!=xkb->ctrls->per_key_repeat[key/8]))
  578.         changes->ctrls.changed_ctrls|= XkbPerKeyRepeatMask;
  579.     }
  580.     if (((explicit&XkbExplicitBehaviorMask)==0)&&
  581.         (xkb->server->behaviors[key].type==XkbKB_Lock)) {
  582.         xkb->server->behaviors[key].type= XkbKB_Default;
  583.         changed|= XkbKeyBehaviorsMask;
  584.     }
  585.     }
  586.     if (changes) {
  587.     XkbMapChangesPtr    mc;
  588.     mc= &changes->map;
  589.     tmp= (changed&mc->changed);
  590.     if (tmp&XkbKeyActionsMask)
  591.         _XkbAddKeyChange(&mc->first_key_act,&mc->num_key_acts,key);
  592.     else if (changed&XkbKeyActionsMask) {
  593.         mc->changed|= XkbKeyActionsMask;
  594.         mc->first_key_act= key;
  595.         mc->num_key_acts= 1;
  596.     }
  597.     if (tmp&XkbKeyBehaviorsMask) {
  598.         _XkbAddKeyChange(&mc->first_key_behavior,&mc->num_key_behaviors,
  599.                                         key);
  600.     }
  601.     else if (changed&XkbKeyBehaviorsMask) {
  602.         mc->changed|= XkbKeyBehaviorsMask;
  603.         mc->first_key_behavior= key;
  604.         mc->num_key_behaviors= 1;
  605.     }
  606.     if (tmp&XkbVirtualModMapMask)
  607.         _XkbAddKeyChange(&mc->first_vmodmap_key,&mc->num_vmodmap_keys,key);
  608.     else if (changed&XkbVirtualModMapMask) {
  609.         mc->changed|= XkbVirtualModMapMask;
  610.         mc->first_vmodmap_key= key;
  611.         mc->num_vmodmap_keys= 1;
  612.     }
  613.     mc->changed|= changed;
  614.     }
  615.     if (interps!=ibuf)
  616.     _XkbFree(interps);
  617.     DBUG_RETURN(True);
  618. }
  619.  
  620. Bool
  621. #if NeedFunctionPrototypes
  622. XkbUpdateMapFromCore(    XkbDescPtr    xkb,
  623.             KeyCode        first_key,
  624.             int        num_keys,
  625.             int        map_width,
  626.             KeySym *    core_keysyms,
  627.             XkbChangesPtr    changes)
  628. #else
  629. XkbUpdateMapFromCore(xkb,first_key,num_keys,map_width,core_keysyms,changes)
  630.     XkbDescPtr        xkb;
  631.     KeyCode        first_key;
  632.     int            num_keys;
  633.     int            map_width;
  634.     KeySym *        core_keysyms;
  635.     XkbChangesPtr    changes;
  636. #endif
  637. {
  638.     DBUG_ENTER("XkbUpdateMapFromCore")
  639.     register int    key,last_key;
  640.     KeySym *    syms;
  641.  
  642.     syms= &core_keysyms[(first_key-xkb->min_key_code)*map_width];
  643.     if (changes) {
  644.     if (changes->map.changed&XkbKeySymsMask) {
  645.         _XkbAddKeyChange(&changes->map.first_key_sym,
  646.                     &changes->map.num_key_syms,first_key);
  647.         if (num_keys>1) {
  648.         _XkbAddKeyChange(&changes->map.first_key_sym,
  649.                         &changes->map.num_key_syms,
  650.                         first_key+num_keys-1);
  651.         }
  652.     }
  653.     else {
  654.         changes->map.changed|= XkbKeySymsMask;
  655.         changes->map.first_key_sym= first_key;
  656.         changes->map.num_key_syms= num_keys;
  657.     }
  658.     }
  659.     last_key= first_key+num_keys-1;
  660.     for (key=first_key;key<=last_key;key++,syms+= map_width) {
  661.     XkbMapChangesPtr    mc;
  662.     unsigned        explicit;
  663.     KeySym            tsyms[XkbMaxSymsPerKey];
  664.     int             types[XkbNumKbdGroups];
  665.     int            nG;
  666.  
  667.     explicit= xkb->server->explicit[key]&XkbExplicitKeyTypesMask;
  668.     types[XkbGroup1Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup1Index);
  669.     types[XkbGroup2Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup2Index);
  670.     types[XkbGroup3Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup3Index);
  671.     types[XkbGroup4Index]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup4Index);
  672.     nG= XkbKeyTypesForCoreSymbols(xkb,map_width,syms,explicit,types,tsyms);
  673.     if (changes)
  674.          mc= &changes->map;
  675.     else mc= NULL;
  676.     XkbChangeTypesOfKey(xkb,key,nG,XkbAllGroupsMask,types,mc);
  677.     memcpy((char *)XkbKeySymsPtr(xkb,key),(char *)tsyms,
  678.                     XkbKeyNumSyms(xkb,key)*sizeof(KeySym));
  679.     XkbApplyCompatMapToKey(xkb,key,changes);
  680.     }
  681.  
  682.     if ((xkb->server->vmods!=NULL)&&(xkb->map->modmap!=NULL)&&(changes)&&
  683.     (changes->map.changed&(XkbVirtualModMapMask|XkbModifierMapMask))) {
  684.     unsigned char        newVMods[XkbNumVirtualMods];
  685.     register  unsigned     bit,i;
  686.     unsigned        present;
  687.  
  688.     bzero(newVMods,XkbNumVirtualMods);
  689.     present= 0;
  690.     for (key=xkb->min_key_code;key<=xkb->max_key_code;key++) {
  691.         if (xkb->server->vmodmap[key]==0)
  692.         continue;
  693.         for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
  694.         if (bit&xkb->server->vmodmap[key]) {
  695.             present|= bit;
  696.             newVMods[i]|= xkb->map->modmap[key];
  697.         }
  698.         }
  699.     }
  700.     for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
  701.         if ((bit&present)&&(newVMods[i]!=xkb->server->vmods[i])) {
  702.         changes->map.changed|= XkbVirtualModsMask;
  703.         changes->map.vmods|= bit;
  704.         xkb->server->vmods[i]= newVMods[i];
  705.         }
  706.     }
  707.     }
  708.     if (changes && (changes->map.changed&XkbVirtualModsMask))
  709.     XkbApplyVirtualModChanges(xkb,changes->map.vmods,changes);
  710.     DBUG_RETURN(True);
  711. }
  712.  
  713. Status
  714. #if NeedFunctionPrototypes
  715. XkbChangeTypesOfKey(    XkbDescPtr         xkb,
  716.             int              key,
  717.             int             nGroups,
  718.             unsigned          groups,
  719.             int    *           newTypesIn,
  720.             XkbMapChangesPtr     changes)
  721. #else
  722. XkbChangeTypesOfKey(xkb,key,nGroups,groups,newTypesIn,changes)
  723.     XkbDescPtr         xkb;
  724.     int              key;
  725.     int             nGroups;
  726.     unsigned          groups;
  727.     int    *           newTypesIn;
  728.     XkbMapChangesPtr     changes;
  729. #endif
  730. {
  731.     DBUG_ENTER("XkbChangeTypesOfKey")
  732.     XkbKeyTypePtr    pOldType,pNewType;
  733.     register int    i;
  734.     int        width,nOldGroups,oldWidth,newTypes[XkbNumKbdGroups];
  735.  
  736.     if ((!xkb) || (!XkbKeycodeInRange(xkb,key)) || (!xkb->map) ||
  737.     (!xkb->map->types)||(!newTypes)||((groups&XkbAllGroupsMask)==0)||
  738.     (nGroups>XkbNumKbdGroups)) {
  739.     DBUG_RETURN(BadMatch);
  740.     }
  741.     if (nGroups==0) {
  742.     for (i=0;i<XkbNumKbdGroups;i++) {
  743.         xkb->map->key_sym_map[key].kt_index[i]= XkbOneLevelIndex;
  744.     }
  745.     i= xkb->map->key_sym_map[key].group_info;
  746.     i= XkbSetNumGroups(i,0);
  747.     xkb->map->key_sym_map[key].group_info= i;
  748.     XkbResizeKeySyms(xkb,key,0);
  749.     DBUG_RETURN(Success);
  750.     }
  751.  
  752.     nOldGroups= XkbKeyNumGroups(xkb,key);
  753.     oldWidth= XkbKeyGroupsWidth(xkb,key);
  754.     for (width=i=0;i<nGroups;i++) {
  755.     if (groups&(1<<i))
  756.          newTypes[i]=  newTypesIn[i];
  757.     else if (i<nOldGroups)
  758.          newTypes[i]= XkbKeyKeyTypeIndex(xkb,key,i);
  759.     else if (nOldGroups>0)
  760.          newTypes[i]= XkbKeyKeyTypeIndex(xkb,key,XkbGroup1Index);
  761.     else newTypes[i]= XkbTwoLevelIndex;
  762.     if (newTypes[i]>xkb->map->num_types)
  763.         return BadMatch;
  764.     pNewType= &xkb->map->types[newTypes[i]];
  765.     if (pNewType->num_levels>width)
  766.         width= pNewType->num_levels;
  767.     }
  768.     if ((xkb->ctrls)&&(nGroups>xkb->ctrls->num_groups))
  769.     xkb->ctrls->num_groups= nGroups;
  770.     if ((width!=oldWidth)||(nGroups!=nOldGroups)) {
  771.     KeySym        oldSyms[XkbMaxSymsPerKey],*pSyms;
  772.     int        nCopy;
  773.  
  774.     if (nOldGroups==0) {
  775.         pSyms= XkbResizeKeySyms(xkb,key,width*nGroups);
  776.         if (pSyms!=NULL) {
  777.         i= xkb->map->key_sym_map[key].group_info;
  778.         i= XkbSetNumGroups(i,nGroups);
  779.         xkb->map->key_sym_map[key].group_info= i;
  780.         xkb->map->key_sym_map[key].width= width;
  781.         for (i=0;i<nGroups;i++) {
  782.             xkb->map->key_sym_map[key].kt_index[i]= newTypes[i];
  783.         }
  784.         DBUG_RETURN(Success);
  785.         }
  786.         DBUG_RETURN(BadAlloc);
  787.     }
  788.     pSyms= XkbKeySymsPtr(xkb,key);
  789.     memcpy(oldSyms,pSyms,XkbKeyNumSyms(xkb,key)*sizeof(KeySym));
  790.     pSyms= XkbResizeKeySyms(xkb,key,width*nGroups);
  791.     if (pSyms==NULL)
  792.         DBUG_RETURN(BadAlloc);
  793.     bzero(pSyms,width*nGroups*sizeof(KeySym));
  794.     for (i=0;(i<nGroups)&&(i<nOldGroups);i++) {
  795.         pOldType= XkbKeyKeyType(xkb,key,i);
  796.         pNewType= &xkb->map->types[newTypes[i]];
  797.         if (pNewType->num_levels>pOldType->num_levels)
  798.          nCopy= pOldType->num_levels;
  799.         else nCopy= pNewType->num_levels;
  800.         memcpy(&pSyms[i*width],&oldSyms[i*oldWidth],nCopy*sizeof(KeySym));
  801.     }
  802.     if (XkbKeyHasActions(xkb,key)) {
  803.         XkbAction    oldActs[XkbMaxSymsPerKey],*pActs;
  804.         pActs= XkbKeyActionsPtr(xkb,key);
  805.         memcpy(oldActs,pActs,XkbKeyNumSyms(xkb,key)*sizeof(XkbAction));
  806.         pActs= XkbResizeKeyActions(xkb,key,width*nGroups);
  807.         if (pActs==NULL)
  808.         DBUG_RETURN(BadAlloc);
  809.         bzero(pActs,width*nGroups*sizeof(XkbAction));
  810.         for (i=0;(i<nGroups)&&(i<nOldGroups);i++) {
  811.         pOldType= XkbKeyKeyType(xkb,key,i);
  812.         pNewType= &xkb->map->types[newTypes[i]];
  813.         if (pNewType->num_levels>pOldType->num_levels)
  814.              nCopy= pOldType->num_levels;
  815.         else nCopy= pNewType->num_levels;
  816.         memcpy(&pActs[i*width],&oldActs[i*oldWidth],
  817.                         nCopy*sizeof(XkbAction));
  818.         }
  819.     }
  820.     i= xkb->map->key_sym_map[key].group_info;
  821.     i= XkbSetNumGroups(i,nGroups);
  822.     xkb->map->key_sym_map[key].group_info= i;
  823.     xkb->map->key_sym_map[key].width= width;
  824.     }
  825.     width= 0;
  826.     for (i=0;i<nGroups;i++) {
  827.     xkb->map->key_sym_map[key].kt_index[i]= newTypes[i];
  828.     if (xkb->map->types[newTypes[i]].num_levels>width)
  829.         width= xkb->map->types[newTypes[i]].num_levels;
  830.     }
  831.     xkb->map->key_sym_map[key].width= width;
  832.     if (changes!=NULL) {
  833.     if (changes->changed&XkbKeySymsMask) {
  834.         _XkbAddKeyChange(&changes->first_key_sym,&changes->num_key_syms,
  835.                                         key);
  836.     }
  837.     else {
  838.         changes->changed|= XkbKeySymsMask;
  839.         changes->first_key_sym= key;
  840.         changes->num_key_syms= 1;
  841.     }
  842.     }
  843.     DBUG_RETURN(Success);
  844. }
  845.  
  846. /***====================================================================***/
  847.  
  848. Bool
  849. #if NeedFunctionPrototypes
  850. XkbVirtualModsToReal(XkbDescPtr xkb,unsigned virtual_mask,unsigned *mask_rtrn)
  851. #else
  852. XkbVirtualModsToReal(xkb,virtual_mask,mask_rtrn)
  853.     XkbDescPtr    xkb;
  854.     unsigned    virtual_mask;
  855.     unsigned *    mask_rtrn;
  856. #endif
  857. {
  858.     DBUG_ENTER("XkbVirtualModsToReal")
  859.     register int i,bit;
  860.     register unsigned mask;
  861.  
  862.     if (xkb==NULL)
  863.     DBUG_RETURN(False);
  864.     if (virtual_mask==0) {
  865.     *mask_rtrn= 0;
  866.     DBUG_RETURN(True);
  867.     }
  868.     if (xkb->server==NULL)
  869.     DBUG_RETURN(False);
  870.     for (i=mask=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
  871.     if (virtual_mask&bit)
  872.         mask|= xkb->server->vmods[i];
  873.     }
  874.     *mask_rtrn= mask;
  875.     DBUG_RETURN(True);
  876. }
  877.  
  878. /***====================================================================***/
  879.  
  880. Bool
  881. #if NeedFunctionPrototypes
  882. XkbUpdateActionVirtualMods(XkbDescPtr xkb,XkbAction *act,unsigned changed)
  883. #else
  884. XkbUpdateActionVirtualMods(xkb,act,changed)
  885.     XkbDescPtr    xkb;
  886.     XkbAction *    act;
  887.     unsigned    changed;
  888. #endif
  889. {
  890.     DBUG_ENTER("XkbUpdateActionVirtualMods")
  891.     unsigned int    tmp;
  892.  
  893.     switch (act->type) {
  894.     case XkbSA_SetMods: case XkbSA_LatchMods: case XkbSA_LockMods:
  895.         if (((tmp= XkbModActionVMods(&act->mods))&changed)!=0) {
  896.         XkbVirtualModsToReal(xkb,tmp,&tmp);
  897.         act->mods.mask= act->mods.real_mods;
  898.         act->mods.mask|= tmp;
  899.         DBUG_RETURN(True);
  900.         }
  901.         break;
  902.     case XkbSA_ISOLock:
  903.         if ((((tmp= XkbModActionVMods(&act->iso))!=0)&changed)!=0) {
  904.         XkbVirtualModsToReal(xkb,tmp,&tmp);
  905.         act->iso.mask= act->iso.real_mods;
  906.         act->iso.mask|= tmp;
  907.         DBUG_RETURN(True);
  908.         }
  909.         break;
  910.     }
  911.     DBUG_RETURN(False);
  912. }
  913.  
  914. void
  915. #if NeedFunctionPrototypes
  916. XkbUpdateKeyTypeVirtualMods(    XkbDescPtr    xkb,
  917.                 XkbKeyTypePtr    type,
  918.                 unsigned int    changed,
  919.                 XkbChangesPtr     changes)
  920. #else
  921. XkbUpdateKeyTypeVirtualMods(xkb,type,changed,changes)
  922.     XkbDescPtr        xkb;
  923.     XkbKeyTypePtr    type;
  924.     unsigned int    changed;
  925.     XkbChangesPtr    changes;
  926. #endif
  927. {
  928.     DBUG_ENTER("XkbUpdateKeyTypeVirtualMods")
  929.     register unsigned int    i;
  930.     unsigned int        mask;
  931.  
  932.     XkbVirtualModsToReal(xkb,type->mods.vmods,&mask);
  933.     type->mods.mask= type->mods.real_mods|mask;
  934.     if ((type->map_count>0)&&(type->mods.vmods!=0)) {
  935.     XkbKTMapEntryPtr entry;
  936.     for (i=0,entry=type->map;i<type->map_count;i++,entry++) {
  937.         if (entry->mods.vmods!=0) {
  938.         XkbVirtualModsToReal(xkb,entry->mods.vmods,&mask);
  939.         entry->mods.mask=entry->mods.real_mods|mask;
  940.         /* entry is active if vmods are bound*/
  941.             entry->active= (mask!=0);
  942.         }
  943.         else entry->active= 1;
  944.     }
  945.     }
  946.     if (changes) {
  947.     int    type_ndx;
  948.     type_ndx= type-xkb->map->types;
  949.     if ((type_ndx<0)||(type_ndx>xkb->map->num_types))
  950.         DBUG_VOID_RETURN;
  951.     if (changes->map.changed&XkbKeyTypesMask) {
  952.         int last;
  953.         last= changes->map.first_type+changes->map.num_types-1;
  954.         if (type_ndx<changes->map.first_type) {
  955.         changes->map.first_type= type_ndx;
  956.         changes->map.num_types= (last-type_ndx)+1;
  957.         }
  958.         else if (type_ndx>last) {
  959.         changes->map.num_types= (type_ndx-changes->map.first_type)+1;
  960.         }
  961.     }
  962.     else {
  963.         changes->map.changed|= XkbKeyTypesMask;
  964.         changes->map.first_type= type_ndx;
  965.         changes->map.num_types= 1;
  966.     }
  967.     }
  968.     DBUG_VOID_RETURN;
  969. }
  970.  
  971. Bool
  972. #if NeedFunctionPrototypes
  973. XkbApplyVirtualModChanges(XkbDescPtr xkb,unsigned changed,XkbChangesPtr changes)
  974. #else
  975. XkbApplyVirtualModChanges(xkb,changed,changes)
  976.     XkbDescPtr        xkb;
  977.     unsigned        changed;
  978.     XkbChangesPtr    changes;
  979. #endif
  980. {
  981.     DBUG_ENTER("XkbApplyVirtualModChanges")
  982.     register int    i;
  983.     unsigned    checkState;
  984.  
  985.     if ((!xkb) || (!xkb->map) || (changed==0))
  986.     DBUG_RETURN(False);
  987.     for (i=0;i<xkb->map->num_types;i++) {
  988.     if (xkb->map->types[i].mods.vmods & changed)
  989.     XkbUpdateKeyTypeVirtualMods(xkb,&xkb->map->types[i],changed,changes);
  990.     }
  991.     if (changed&xkb->ctrls->internal.vmods) {
  992.     unsigned int    newMask;
  993.     XkbVirtualModsToReal(xkb,xkb->ctrls->internal.vmods,&newMask);
  994.     newMask|= xkb->ctrls->internal.real_mods;
  995.     if (xkb->ctrls->internal.mask!=newMask) {
  996.         xkb->ctrls->internal.mask= newMask;
  997.         if (changes) {
  998.         changes->ctrls.changed_ctrls|= XkbInternalModsMask;
  999.         checkState= True;
  1000.         }
  1001.     }
  1002.     }
  1003.     if (changed&xkb->ctrls->ignore_lock.vmods) {
  1004.     unsigned int    newMask;
  1005.     XkbVirtualModsToReal(xkb,xkb->ctrls->ignore_lock.vmods,&newMask);
  1006.     newMask|= xkb->ctrls->ignore_lock.real_mods;
  1007.     if (xkb->ctrls->ignore_lock.mask!=newMask) {
  1008.         xkb->ctrls->ignore_lock.mask= newMask;
  1009.         if (changes) {
  1010.         changes->ctrls.changed_ctrls|= XkbIgnoreLockModsMask;
  1011.         checkState= True;
  1012.         }
  1013.     }
  1014.     }
  1015.     if (xkb->indicators!=NULL) {
  1016.     XkbIndicatorMapPtr map;
  1017.     map= &xkb->indicators->maps[0];
  1018.     for (i=0;i<XkbNumIndicators;i++,map++) {
  1019.         if (map->mods.vmods&changed) {
  1020.         unsigned int newMask;
  1021.         XkbVirtualModsToReal(xkb,map->mods.vmods,&newMask);
  1022.         newMask|= map->mods.real_mods;
  1023.         if (newMask!=map->mods.mask) {
  1024.             map->mods.mask= newMask;
  1025.             if (changes) {
  1026.             changes->indicators.map_changes|= (1<<i);
  1027.             checkState= True;
  1028.             }
  1029.         }
  1030.         }
  1031.     }
  1032.     }
  1033.     if (xkb->compat!=NULL) {
  1034.     XkbCompatMapPtr    compat;
  1035.     compat= xkb->compat;
  1036.     for (i=0;i<XkbNumKbdGroups;i++) {
  1037.         unsigned int newMask;
  1038.         XkbVirtualModsToReal(xkb,compat->groups[i].vmods,&newMask);
  1039.         newMask|= compat->groups[i].real_mods;
  1040.         if (compat->groups[i].mask!=newMask) {
  1041.         compat->groups[i].mask= newMask;
  1042.         if (changes) {
  1043.             changes->compat.changed_groups|= (1<<i);
  1044.             checkState= True;
  1045.         }
  1046.         }
  1047.     }
  1048.     }
  1049.     if (xkb->map && xkb->server) {
  1050.     int    highChange,lowChange;
  1051.     lowChange= -1;
  1052.     for (i=xkb->min_key_code;i<=xkb->max_key_code;i++) {
  1053.         if (XkbKeyHasActions(xkb,i)) {
  1054.         register XkbAction *pAct;
  1055.         register int n;
  1056.  
  1057.         pAct= XkbKeyActionsPtr(xkb,i);
  1058.         for (n=XkbKeyNumActions(xkb,i);n>0;n--,pAct++) {
  1059.             if ((pAct->type!=XkbSA_NoAction)&&
  1060.             XkbUpdateActionVirtualMods(xkb,pAct,changed)) {
  1061.             if (lowChange<0)
  1062.                 lowChange= i;
  1063.             highChange= i;
  1064.             }
  1065.         }
  1066.         }
  1067.     }
  1068.     if (changes && (lowChange>0)) { /* something changed */
  1069.         if (changes->map.changed&XkbKeyActionsMask) {
  1070.         int last;
  1071.         if (changes->map.first_key_act<lowChange)
  1072.             lowChange= changes->map.first_key_act;
  1073.         last= changes->map.first_key_act+changes->map.num_key_acts-1;
  1074.         if (last>highChange)
  1075.             highChange= last;
  1076.         }
  1077.         changes->map.changed|=     XkbKeyActionsMask;
  1078.         changes->map.first_key_act=    lowChange;
  1079.         changes->map.num_key_acts=    (highChange-lowChange)+1;
  1080.     }
  1081.     }
  1082.     DBUG_RETURN(checkState);
  1083. }
  1084.