home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / XKBSetMap.c < prev    next >
C/C++ Source or Header  |  1999-11-02  |  21KB  |  742 lines
  1. /* $XConsortium: XKBSetMap.c /main/8 1996/03/01 14:30:01 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. #include <stdio.h>
  29. #define NEED_REPLIES
  30. #define NEED_EVENTS
  31. #include "Xlib_private.h"
  32. #include <X11/extensions/XKBproto.h>
  33. #include "XKBlibint.h"
  34.  
  35. #if 0
  36. static int
  37. #if NeedFunctionPrototypes
  38. _XkbSizeKeyTypes(XkbDescPtr xkb,xkbSetMapReq *req)
  39. #else
  40. _XkbSizeKeyTypes(xkb,req)
  41.     XkbDescPtr        xkb;
  42.     xkbSetMapReq *    req;
  43. #endif
  44. {
  45.     DBUG_ENTER("_XkbSizeKeyTypes")
  46.     XkbKeyTypePtr    map;
  47.     int            i,len;
  48.  
  49.     if (((req->present&XkbKeyTypesMask)==0)||(req->nTypes==0)) {
  50.     req->present&= ~XkbKeyTypesMask;
  51.     req->firstType= req->nTypes= 0;
  52.     DBUG_RETURN(0);
  53.     }
  54.     len= 0;
  55.     map= &xkb->map->types[req->firstType];
  56.     for (i=0;i<req->nTypes;i++,map++){
  57.     len+= SIZEOF(xkbKeyTypeWireDesc);
  58.     len+= map->map_count*SIZEOF(xkbKTSetMapEntryWireDesc);
  59.     if (map->preserve)
  60.         len+= map->map_count*SIZEOF(xkbModsWireDesc);
  61.     }
  62.     DBUG_RETURN(len);
  63. }
  64.  
  65. static void
  66. #if NeedFunctionPrototypes
  67. _XkbWriteKeyTypes(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
  68. #else
  69. _XkbWriteKeyTypes(dpy,xkb,req)
  70.     Display    *    dpy;
  71.     XkbDescPtr        xkb;
  72.     xkbSetMapReq *    req;
  73. #endif
  74. {
  75.     DBUG_ENTER("_XkbWriteKeyTypes")
  76.     char *        buf;
  77.     XkbKeyTypePtr     type;
  78.     int            i,n,sz;
  79.     xkbKeyTypeWireDesc *desc;
  80.  
  81.     if ((req->present&XkbKeyTypesMask)==0)
  82.     DBUG_VOID_RETURN;
  83.     type= &xkb->map->types[req->firstType];
  84.     for (i=0;i<req->nTypes;i++,type++) {
  85.     sz= SIZEOF(xkbKeyTypeWireDesc);
  86.     sz+= type->map_count*SIZEOF(xkbKTSetMapEntryWireDesc);
  87.     if (type->preserve)
  88.         sz+= type->map_count*SIZEOF(xkbModsWireDesc);
  89.     BufAlloc(xkbKeyTypeWireDesc *,desc,sz);
  90.     desc->mask = type->mods.mask;
  91.     desc->realMods = type->mods.real_mods;
  92.     desc->virtualMods = type->mods.vmods;
  93.     desc->numLevels = type->num_levels;
  94.     desc->nMapEntries = type->map_count;
  95.     desc->preserve = (type->preserve!=NULL);
  96.     buf= (char *)&desc[1];
  97.     if (desc->nMapEntries>0) {
  98.         xkbKTSetMapEntryWireDesc *wire;
  99.         wire= (xkbKTSetMapEntryWireDesc *)buf;
  100.         for (n=0;n<type->map_count;n++,wire++) {
  101.         wire->level= type->map[n].level;
  102.         wire->realMods= type->map[n].mods.real_mods;
  103.         wire->virtualMods= type->map[n].mods.vmods;
  104.         }
  105.         buf= (char *)wire;
  106.         if (type->preserve) {
  107.         xkbModsWireDesc *pwire;
  108.         pwire= (xkbModsWireDesc *)buf;
  109.         for (n=0;n<type->map_count;n++,pwire++) {
  110.             pwire->realMods= type->preserve[n].real_mods;
  111.             pwire->virtualMods= type->preserve[n].vmods;
  112.         }
  113.         }
  114.     }
  115.     }
  116.     DBUG_VOID_RETURN;
  117. }
  118.  
  119. static int
  120. #if NeedFunctionPrototypes
  121. _XkbSizeKeySyms(XkbDescPtr xkb,xkbSetMapReq *req)
  122. #else
  123. _XkbSizeKeySyms(xkb,req)
  124.     XkbDescPtr        xkb;
  125.     xkbSetMapReq *    req;
  126. #endif
  127. {
  128.     DBUG_ENTER("_XkbSizeKeySyms")
  129.     int            i,len;
  130.     unsigned        nSyms;
  131.  
  132.     if (((req->present&XkbKeySymsMask)==0)||(req->nKeySyms==0)) {
  133.     req->present&= ~XkbKeySymsMask;
  134.     req->firstKeySym= req->nKeySyms= 0;
  135.     req->totalSyms= 0;
  136.     DBUG_RETURN(0);
  137.     }
  138.     len= (int)(req->nKeySyms*sizeof(XkbSymMapRec));
  139.     for (i=nSyms=0;i<req->nKeySyms;i++) {
  140.     nSyms+= XkbKeyNumSyms(xkb,i+req->firstKeySym);
  141.     }
  142.     len+= nSyms*sizeof(CARD32);
  143.     req->totalSyms= nSyms;
  144.     DBUG_RETURN(len);
  145. }
  146.  
  147. static void
  148. #if NeedFunctionPrototypes
  149. _XkbWriteKeySyms(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
  150. #else
  151. _XkbWriteKeySyms(dpy,xkb,req)
  152.     Display *        dpy;
  153.     XkbDescPtr        xkb;
  154.     xkbSetMapReq *    req;
  155. #endif
  156. {
  157.     DBUG_ENTER("_XkbWriteKeySyms")
  158.     register KeySym *    pSym;
  159.     CARD32 *        outSym;
  160.     XkbSymMapPtr        symMap;
  161.     xkbSymMapWireDesc *desc;
  162.     register int    i;
  163.  
  164.     if ((req->present&XkbKeySymsMask)==0)
  165.     DBUG_VOID_RETURN;
  166.     symMap = &xkb->map->key_sym_map[req->firstKeySym];
  167.     for (i=0;i<req->nKeySyms;i++,symMap++) {
  168.     BufAlloc(xkbSymMapWireDesc *,desc,
  169.          SIZEOF(xkbSymMapWireDesc)+
  170.          (XkbKeyNumSyms(xkb,i+req->firstKeySym)*sizeof(CARD32)));
  171.     desc->ktIndex[0] = symMap->kt_index[0];
  172.     desc->ktIndex[1] = symMap->kt_index[1];
  173.     desc->ktIndex[2] = symMap->kt_index[2];
  174.     desc->ktIndex[3] = symMap->kt_index[3];
  175.     desc->groupInfo = symMap->group_info;
  176.     desc->width = symMap->width;
  177.     desc->nSyms = XkbKeyNumSyms(xkb,i+req->firstKeySym);
  178.     outSym = (CARD32 *)&desc[1];
  179.     if (desc->nSyms>0) {
  180.          pSym = XkbKeySymsPtr(xkb,i+req->firstKeySym);
  181.         _XkbWriteCopyKeySyms(pSym,outSym,desc->nSyms);
  182.     }
  183.     }
  184.     DBUG_VOID_RETURN;
  185. }
  186.  
  187. static int
  188. #if NeedFunctionPrototypes
  189. _XkbSizeKeyActions(XkbDescPtr xkb,xkbSetMapReq *req)
  190. #else
  191. _XkbSizeKeyActions(xkb,req)
  192.     XkbDescPtr        xkb;
  193.     xkbSetMapReq *    req;
  194. #endif
  195. {
  196.     DBUG_ENTER("_XkbSizeKeyActions")
  197.     int            i,len,nActs;
  198.  
  199.     if (((req->present&XkbKeyActionsMask)==0)||(req->nKeyActs==0)) {
  200.     req->present&= ~XkbKeyActionsMask;
  201.     req->firstKeyAct= req->nKeyActs= 0;
  202.     req->totalActs= 0;
  203.     DBUG_RETURN(0);
  204.     }
  205.     for (nActs=i=0;i<req->nKeyActs;i++) {
  206.     if (xkb->server->key_acts[i+req->firstKeyAct]!=0)
  207.         nActs+= XkbKeyNumActions(xkb,i+req->firstKeyAct);
  208.     }
  209.     len= XkbPaddedSize(req->nKeyActs)+(nActs*SIZEOF(xkbActionWireDesc));
  210.     req->totalActs= nActs;
  211.     DBUG_RETURN(len);
  212. }
  213.  
  214. static void
  215. #if NeedFunctionPrototypes
  216. _XkbWriteKeyActions(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
  217. #else
  218. _XkbWriteKeyActions(dpy,xkb,req)
  219.     Display *        dpy;
  220.     XkbDescPtr        xkb;
  221.     xkbSetMapReq *    req;
  222. #endif
  223. {
  224.     DBUG_ENTER("_XkbWriteKeyActions")
  225.     register int     i;
  226.     int              n;
  227.     CARD8        *numDesc;
  228.     XkbAction        *actDesc;
  229.  
  230.     if ((req->present&XkbKeyActionsMask)==0)
  231.     DBUG_VOID_RETURN;
  232.     n = XkbPaddedSize(req->nKeyActs);
  233.     n+= (req->totalActs*SIZEOF(xkbActionWireDesc));
  234.  
  235.     BufAlloc(CARD8 *,numDesc,n);
  236.     for (i=0;i<req->nKeyActs;i++) {
  237.     if (xkb->server->key_acts[i+req->firstKeyAct]==0)
  238.          numDesc[i] = 0;
  239.     else numDesc[i] = XkbKeyNumActions(xkb,(i+req->firstKeyAct));
  240.     }
  241.     actDesc = (XkbAction *)&numDesc[XkbPaddedSize(req->nKeyActs)];
  242.     for (i=0;i<req->nKeyActs;i++) {
  243.     if (xkb->server->key_acts[i+req->firstKeyAct]!=0) {
  244.         n = XkbKeyNumActions(xkb,(i+req->firstKeyAct));
  245.         memcpy(actDesc,XkbKeyActionsPtr(xkb,(i+req->firstKeyAct)),
  246.                                                    n*SIZEOF(xkbActionWireDesc));
  247.         actDesc+= n;
  248.     }
  249.     }
  250.     DBUG_VOID_RETURN;
  251. }
  252.  
  253. static int
  254. #if NeedFunctionPrototypes
  255. _XkbSizeKeyBehaviors(XkbDescPtr    xkb,xkbSetMapReq *req)
  256. #else
  257. _XkbSizeKeyBehaviors(xkb,req)
  258.     XkbDescPtr        xkb;
  259.     xkbSetMapReq *    req;
  260. #endif
  261. {
  262.     DBUG_ENTER("_XkbSizeKeyBehaviors")
  263.     register int i,first,last,nFound;
  264.  
  265.     if (((req->present&XkbKeyBehaviorsMask)==0)||(req->nKeyBehaviors<1)) {
  266.     req->present&= ~XkbKeyBehaviorsMask;
  267.     req->firstKeyBehavior= req->nKeyBehaviors= 0;
  268.     req->totalKeyBehaviors= 0;
  269.     DBUG_RETURN(0);
  270.     }
  271.     first= req->firstKeyBehavior;
  272.     last= first+req->nKeyBehaviors-1;
  273.     for (i=first,nFound=0;i<=last;i++) {
  274.     if (xkb->server->behaviors[i].type!=XkbKB_Default)
  275.         nFound++;
  276.     }
  277.     req->totalKeyBehaviors= nFound;
  278.     DBUG_RETURN(nFound*SIZEOF(xkbBehaviorWireDesc));
  279. }
  280.  
  281. static void
  282. #if NeedFunctionPrototypes
  283. _XkbWriteKeyBehaviors(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
  284. #else
  285. _XkbWriteKeyBehaviors(dpy,xkb,req)
  286.     Display *        dpy;
  287.     XkbDescPtr        xkb;
  288.     xkbSetMapReq *    req;
  289. #endif
  290. {
  291.     DBUG_ENTER("_XkbWriteKeyBehaviors")
  292.     register int         i,first,last;
  293.     xkbBehaviorWireDesc *    wire;
  294.     char *            buf;
  295.  
  296.     if ((req->present&XkbKeyBehaviorsMask)==0)
  297.     DBUG_VOID_RETURN;
  298.     first= req->firstKeyBehavior;
  299.     last= first+req->nKeyBehaviors-1;
  300.  
  301.     i= req->totalKeyBehaviors*SIZEOF(xkbBehaviorWireDesc);
  302.     BufAlloc(char *,buf,i);
  303.     wire= (xkbBehaviorWireDesc *)buf;
  304.     for (i=first;i<=last;i++) {
  305.     if (xkb->server->behaviors[i].type!=XkbKB_Default) {
  306.         wire->key= i;
  307.         wire->type= xkb->server->behaviors[i].type;
  308.         wire->data= xkb->server->behaviors[i].data;
  309.         buf+= SIZEOF(xkbBehaviorWireDesc);
  310.         wire= (xkbBehaviorWireDesc *)buf;
  311.     }
  312.     }
  313.     DBUG_VOID_RETURN;
  314. }
  315.  
  316. static unsigned
  317. #if NeedFunctionPrototypes
  318. _XkbSizeVirtualMods(xkbSetMapReq *req)
  319. #else
  320. _XkbSizeVirtualMods(req)
  321.     xkbSetMapReq *    req;
  322. #endif
  323. {
  324.     DBUG_ENTER("_XkbSizeVirtualMods")
  325.     register int i,bit,nMods;
  326.     unsigned result;
  327.  
  328.    if (((req->present&XkbVirtualModsMask)==0)||(req->virtualMods==0)) {
  329.     req->present&= ~XkbVirtualModsMask;
  330.     req->virtualMods= 0;
  331.     DBUG_RETURN(0);
  332.    }
  333.    for (i=nMods=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
  334.     if (req->virtualMods&bit)
  335.         nMods++;
  336.    }
  337.    result = XkbPaddedSize(nMods);
  338.    DBUG_RETURN(result);
  339. }
  340.  
  341. static void
  342. #if NeedFunctionPrototypes
  343. _XkbWriteVirtualMods(    Display *    dpy,
  344.             XkbDescPtr     xkb,
  345.             xkbSetMapReq *    req,
  346.             unsigned     size)
  347. #else
  348. _XkbWriteVirtualMods(dpy,xkb,req,size)
  349.     Display *        dpy;
  350.     XkbDescPtr        xkb;
  351.     xkbSetMapReq *    req;
  352.     unsigned         size;
  353. #endif
  354. {
  355.     DBUG_ENTER("_XkbWriteVirtualMods")
  356.     register int     i,bit;
  357.     CARD8        *vmods;
  358.  
  359.     if ((req->present&XkbVirtualModsMask==0)||(size<1))
  360.     DBUG_VOID_RETURN;
  361.     BufAlloc(CARD8 *,vmods,size);
  362.     for (i=0,bit=1;i<XkbNumVirtualMods;i++,bit<<=1) {
  363.     if (req->virtualMods&bit)
  364.         *vmods++= xkb->server->vmods[i];
  365.     }
  366.     DBUG_VOID_RETURN;
  367. }
  368.  
  369. static int
  370. #if NeedFunctionPrototypes
  371. _XkbSizeKeyExplicit(XkbDescPtr xkb,xkbSetMapReq *req)
  372. #else
  373. _XkbSizeKeyExplicit(xkb,req)
  374.     XkbDescPtr        xkb;
  375.     xkbSetMapReq *    req;
  376. #endif
  377. {
  378.     DBUG_ENTER("_XkbSizeKeyExplicit")
  379.     register int i,first,last,nFound;
  380.     int result;
  381.  
  382.     if (((req->present&XkbExplicitComponentsMask)==0)||(req->nKeyExplicit==0)) {
  383.     req->present&= ~XkbExplicitComponentsMask;
  384.     req->firstKeyExplicit= req->nKeyExplicit= 0;
  385.     req->totalKeyExplicit= 0;
  386.     DBUG_RETURN(0);
  387.     }
  388.     first= req->firstKeyExplicit;
  389.     last= first+req->nKeyExplicit-1;
  390.  
  391.     for (i=first,nFound=0;i<=last;i++) {
  392.     if (xkb->server->explicit[i]!=0)
  393.         nFound++;
  394.     }
  395.     req->totalKeyExplicit= nFound;
  396.     result = XkbPaddedSize((nFound*2));
  397.     DBUG_RETURN(result);
  398. }
  399.  
  400. static void
  401. #if NeedFunctionPrototypes
  402. _XkbWriteKeyExplicit(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
  403. #else
  404. _XkbWriteKeyExplicit(dpy,xkb,req)
  405.     Display *        dpy;
  406.     XkbDescPtr        xkb;
  407.     xkbSetMapReq *    req;
  408. #endif
  409. {
  410.     DBUG_ENTER("_XkbWriteKeyExplicit")
  411.     register int    i,first,last;
  412.     CARD8 *        wire;
  413.  
  414.     if ((req->present&XkbExplicitComponentsMask)==0)
  415.     DBUG_VOID_RETURN;
  416.     first= req->firstKeyExplicit;
  417.     last= first+req->nKeyExplicit;
  418.     i= XkbPaddedSize((req->totalKeyExplicit*2));
  419.     BufAlloc(CARD8 *,wire,i);
  420.     for (i=first;i<=last;i++) {
  421.     if (xkb->server->explicit[i]!=0) {
  422.         wire[0]= i;
  423.         wire[1]= xkb->server->explicit[i];
  424.         wire+= 2;
  425.     }
  426.     }
  427.     DBUG_VOID_RETURN;
  428. }
  429.  
  430. static int
  431. #if NeedFunctionPrototypes
  432. _XkbSizeModifierMap(XkbDescPtr xkb,xkbSetMapReq *req)
  433. #else
  434. _XkbSizeModifierMap(xkb,req)
  435.     XkbDescPtr        xkb;
  436.     xkbSetMapReq *    req;
  437. #endif
  438. {
  439.     DBUG_ENTER("_XkbSizeModifierMap")
  440.     register int i,first,last,nFound;
  441.     int result;
  442.  
  443.     if (((req->present&XkbModifierMapMask)==0)||(req->nModMapKeys==0)) {
  444.     req->present&= ~XkbModifierMapMask;
  445.     req->firstModMapKey= req->nModMapKeys= 0;
  446.     req->totalModMapKeys= 0;
  447.     DBUG_RETURN(0);
  448.     }
  449.     first= req->firstModMapKey;
  450.     last= first+req->nModMapKeys-1;
  451.  
  452.     for (i=first,nFound=0;i<=last;i++) {
  453.     if (xkb->map->modmap[i]!=0)
  454.         nFound++;
  455.     }
  456.     req->totalModMapKeys= nFound;
  457.     result = XkbPaddedSize((nFound*2));
  458.     DBUG_RETURN(result);
  459. }
  460.  
  461. static void
  462. #if NeedFunctionPrototypes
  463. _XkbWriteModifierMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
  464. #else
  465. _XkbWriteModifierMap(dpy,xkb,req)
  466.     Display *        dpy;
  467.     XkbDescPtr        xkb;
  468.     xkbSetMapReq *    req;
  469. #endif
  470. {
  471.     DBUG_ENTER("_XkbWriteModifierMap")
  472.     register int    i,first,last;
  473.     CARD8 *        wire;
  474.  
  475.     if ((req->present&XkbModifierMapMask)==0)
  476.     DBUG_VOID_RETURN;
  477.     first= req->firstModMapKey;
  478.     last= first+req->nModMapKeys-1;
  479.     if (req->totalModMapKeys>0) {
  480.     i= XkbPaddedSize((req->totalModMapKeys*2));
  481.     BufAlloc(CARD8 *,wire,i);
  482.     for (i=first;i<=last;i++) {
  483.         if (xkb->map->modmap[i]!=0) {
  484.         wire[0]= i;
  485.         wire[1]= xkb->map->modmap[i];
  486.         wire+= 2;
  487.         }
  488.     }
  489.     }
  490.     DBUG_VOID_RETURN;
  491. }
  492.  
  493. static int
  494. #if NeedFunctionPrototypes
  495. _XkbSizeVirtualModMap(XkbDescPtr xkb,xkbSetMapReq *req)
  496. #else
  497. _XkbSizeVirtualModMap(xkb,req)
  498.     XkbDescPtr        xkb;
  499.     xkbSetMapReq *    req;
  500. #endif
  501. {
  502.     DBUG_ENTER("_XkbSizeVirtualModMap")
  503.     register int i,first,last,nFound;
  504.  
  505.     if (((req->present&XkbVirtualModMapMask)==0)||(req->nVModMapKeys==0)) {
  506.     req->present&= ~XkbVirtualModMapMask;
  507.     req->firstVModMapKey= req->nVModMapKeys= 0;
  508.     req->totalVModMapKeys= 0;
  509.     return 0;
  510.     }
  511.     first= req->firstVModMapKey;
  512.     last= first+req->nVModMapKeys-1;
  513.  
  514.     for (i=first,nFound=0;i<=last;i++) {
  515.     if (xkb->server->vmodmap[i]!=0)
  516.         nFound++;
  517.     }
  518.     req->totalVModMapKeys= nFound;
  519.     DBUG_RETURN(nFound*SIZEOF(xkbVModMapWireDesc));
  520. }
  521.  
  522. static void
  523. #if NeedFunctionPrototypes
  524. _XkbWriteVirtualModMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
  525. #else
  526. _XkbWriteVirtualModMap(dpy,xkb,req)
  527.     Display *        dpy;
  528.     XkbDescPtr        xkb;
  529.     xkbSetMapReq *    req;
  530. #endif
  531. {
  532.     DBUG_ENTER("_XkbWriteVirtualModMap")
  533.     register int        i,first,last;
  534.     xkbVModMapWireDesc *    wire;
  535.  
  536.     if ((req->present&XkbVirtualModMapMask)==0)
  537.     DBUG_VOID_RETURN;
  538.     first= req->firstVModMapKey;
  539.     last= first+req->nVModMapKeys-1;
  540.     if (req->totalVModMapKeys>0) {
  541.     i= req->totalVModMapKeys*SIZEOF(xkbVModMapWireDesc);
  542.     BufAlloc(xkbVModMapWireDesc *,wire,i);
  543.     for (i=first;i<=last;i++) {
  544.         if (xkb->server->vmodmap[i]!=0) {
  545.         wire->key= i;
  546.         wire->vmods= xkb->server->vmodmap[i];
  547.         wire++;
  548.         }
  549.     }
  550.     }
  551.     DBUG_VOID_RETURN;
  552. }
  553.  
  554. static void
  555. #if NeedFunctionPrototypes
  556. SendSetMap(Display *dpy,XkbDescPtr xkb,xkbSetMapReq *req)
  557. #else
  558. SendSetMap(dpy,xkb,req)
  559.     Display *        dpy;
  560.     XkbDescPtr         xkb;
  561.     xkbSetMapReq *    req;
  562. #endif
  563. {
  564.     DBUG_ENTER("SendSetMap")
  565.     xkbSetMapReq tmp;
  566.     unsigned szMods;
  567.  
  568.     req->length+= _XkbSizeKeyTypes(xkb,req)/4;
  569.     req->length+= _XkbSizeKeySyms(xkb,req)/4;
  570.     req->length+= _XkbSizeKeyActions(xkb,req)/4;
  571.     req->length+= _XkbSizeKeyBehaviors(xkb,req)/4;
  572.     szMods= _XkbSizeVirtualMods(req);
  573.     req->length+= szMods/4;
  574.     req->length+= _XkbSizeKeyExplicit(xkb,req)/4;
  575.     req->length+= _XkbSizeModifierMap(xkb,req)/4;
  576.     req->length+= _XkbSizeVirtualModMap(xkb,req)/4;
  577.  
  578.     tmp= *req;
  579.     if ( tmp.nTypes>0 )
  580.     _XkbWriteKeyTypes(dpy,xkb,&tmp);
  581.     if ( tmp.nKeySyms>0 )
  582.     _XkbWriteKeySyms(dpy,xkb,&tmp);
  583.     if ( tmp.nKeyActs )
  584.     _XkbWriteKeyActions(dpy,xkb,&tmp);
  585.     if ( tmp.totalKeyBehaviors>0 )
  586.     _XkbWriteKeyBehaviors(dpy,xkb,&tmp);
  587.     if ( tmp.virtualMods )
  588.     _XkbWriteVirtualMods(dpy,xkb,&tmp,szMods);
  589.     if ( tmp.totalKeyExplicit>0)
  590.     _XkbWriteKeyExplicit(dpy,xkb,&tmp);
  591.     if ( tmp.totalModMapKeys>0)
  592.     _XkbWriteModifierMap(dpy,xkb,&tmp);
  593.     if ( tmp.totalVModMapKeys>0)
  594.     _XkbWriteVirtualModMap(dpy,xkb,&tmp);
  595.     DBUG_VOID_RETURN;
  596. }
  597.  
  598. Bool
  599. #if NeedFunctionPrototypes
  600. XkbSetMap(Display *dpy,unsigned which,XkbDescPtr xkb)
  601. #else
  602. XkbSetMap(dpy,which,xkb)
  603.     Display *    dpy;
  604.     unsigned     which;
  605.     XkbDescPtr    xkb;
  606. #endif
  607. {
  608.     DBUG_ENTER("XkbSetMap")
  609.     register xkbSetMapReq *    req;
  610.     XkbInfoPtr         xkbi;
  611.     XkbServerMapPtr        srv;
  612.     XkbClientMapPtr        map;
  613.  
  614.     if ((dpy->flags & XlibDisplayNoXkb) ||
  615.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||
  616.     (!xkb))
  617.     DBUG_RETURN(False);
  618.     map= xkb->map;
  619.     srv= xkb->server;
  620.  
  621.     if (((which&XkbKeyTypesMask)&&((!map)||(!map->types)))||
  622.     ((which&XkbKeySymsMask)&&((!map)||(!map->syms)||(!map->key_sym_map)))||
  623.     ((which&XkbKeyActionsMask)&&((!srv)||(!srv->key_acts)))||
  624.     ((which&XkbKeyBehaviorsMask)&&((!srv)||(!srv->behaviors)))||
  625.     ((which&XkbVirtualModsMask)&&(!srv))||
  626.     ((which&XkbExplicitComponentsMask)&&((!srv)||(!srv->explicit)))||
  627.     ((which&XkbModifierMapMask)&&((!map)||(!map->modmap)))||
  628.     ((which&XkbVirtualModMapMask)&&((!srv)||(!srv->vmodmap))))
  629.     DBUG_RETURN(False);
  630.  
  631.     LockDisplay(dpy);
  632.     xkbi = dpy->xkb_info;
  633.     GetReq(kbSetMap, req);
  634.     req->reqType = xkbi->codes->major_opcode;
  635.     req->xkbReqType = X_kbSetMap;
  636.     req->deviceSpec = xkb->device_spec;
  637.     req->present = which;
  638.     req->flags = XkbSetMapAllFlags;
  639.     req->minKeyCode= xkb->min_key_code;
  640.     req->maxKeyCode= xkb->max_key_code;
  641.     req->firstType = 0;
  642.     if (which&XkbKeyTypesMask)    req->nTypes = map->num_types;
  643.     else            req->nTypes = 0;
  644.     if (which&XkbKeySymsMask) {
  645.     req->firstKeySym = xkb->min_key_code;
  646.     req->nKeySyms = XkbNumKeys(xkb);
  647.     }
  648.     if (which&XkbKeyActionsMask) {
  649.     req->firstKeyAct = xkb->min_key_code;
  650.     req->nKeyActs = XkbNumKeys(xkb);
  651.     }
  652.     if (which&XkbKeyBehaviorsMask) {
  653.     req->firstKeyBehavior = xkb->min_key_code;
  654.     req->nKeyBehaviors = XkbNumKeys(xkb);
  655.     }
  656.     if (which&XkbVirtualModsMask)
  657.     req->virtualMods= ~0;
  658.     if (which&XkbExplicitComponentsMask) {
  659.     req->firstKeyExplicit= xkb->min_key_code;
  660.     req->nKeyExplicit = XkbNumKeys(xkb);
  661.     }
  662.     if (which&XkbModifierMapMask) {
  663.     req->firstModMapKey= xkb->min_key_code;
  664.     req->nModMapKeys = XkbNumKeys(xkb);
  665.     }
  666.     if (which&XkbVirtualModMapMask) {
  667.     req->firstVModMapKey= xkb->min_key_code;
  668.     req->nVModMapKeys = XkbNumKeys(xkb);
  669.     }
  670.     SendSetMap(dpy,xkb,req);
  671.     UnlockDisplay(dpy);
  672.     SyncHandle();
  673.     DBUG_RETURN(True);
  674. }
  675.  
  676. Bool
  677. #if NeedFunctionPrototypes
  678. XkbChangeMap(Display *dpy,XkbDescPtr xkb,XkbMapChangesPtr changes)
  679. #else
  680. XkbChangeMap(dpy,xkb,changes)
  681.     Display *        dpy;
  682.     XkbDescPtr        xkb;
  683.     XkbMapChangesPtr    changes;
  684. #endif
  685. {
  686.     DBUG_ENTER("XkbChangeMap")
  687.     register xkbSetMapReq *    req;
  688.     XkbInfoPtr         xkbi;
  689.     XkbServerMapPtr        srv;
  690.     XkbClientMapPtr        map;
  691.  
  692.     if ((dpy->flags & XlibDisplayNoXkb) ||
  693.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL))||
  694.     (!xkb)||(!changes))
  695.     DBUG_RETURN(False);
  696.     srv= xkb->server;
  697.     map= xkb->map;
  698.  
  699.     if (((changes->changed&XkbKeyTypesMask)&&((!map)||(!map->types)))||
  700.     ((changes->changed&XkbKeySymsMask)&&((!map)||(!map->syms)||
  701.                 (!map->key_sym_map)))||
  702.     ((changes->changed&XkbKeyActionsMask)&&((!srv)||(!srv->key_acts)))||
  703.     ((changes->changed&XkbKeyBehaviorsMask)&&((!srv)||(!srv->behaviors)))||
  704.     ((changes->changed&XkbVirtualModsMask)&&(!srv))||
  705.     ((changes->changed&XkbExplicitComponentsMask)&&
  706.                 ((!srv)||(!srv->explicit)))||
  707.     ((changes->changed&XkbModifierMapMask)&&((!map)||(!map->modmap)))||
  708.     ((changes->changed&XkbVirtualModMapMask)&&((!srv)||(!srv->vmodmap))))
  709.     DBUG_RETURN(False);
  710.  
  711.     LockDisplay(dpy);
  712.     xkbi = dpy->xkb_info;
  713.     GetReq(kbSetMap, req);
  714.     req->reqType = xkbi->codes->major_opcode;
  715.     req->xkbReqType = X_kbSetMap;
  716.     req->deviceSpec = xkb->device_spec;
  717.     req->present = changes->changed;
  718.     req->flags = XkbSetMapRecomputeActions;
  719.     req->minKeyCode= xkb->min_key_code;
  720.     req->maxKeyCode= xkb->max_key_code;
  721.     req->firstType = changes->first_type;
  722.     req->nTypes = changes->num_types;
  723.     req->firstKeySym = changes->first_key_sym;
  724.     req->nKeySyms = changes->num_key_syms;
  725.     req->firstKeyAct = changes->first_key_act;
  726.     req->nKeyActs = changes->num_key_acts;
  727.     req->firstKeyBehavior = changes->first_key_behavior;
  728.     req->nKeyBehaviors = changes->num_key_behaviors;
  729.     req->virtualMods = changes->vmods;
  730.     req->firstKeyExplicit = changes->first_key_explicit;
  731.     req->nKeyExplicit = changes->num_key_explicit;
  732.     req->firstModMapKey = changes->first_modmap_key;
  733.     req->nModMapKeys = changes->num_modmap_keys;
  734.     req->firstVModMapKey = changes->first_vmodmap_key;
  735.     req->nVModMapKeys = changes->num_vmodmap_keys;
  736.     SendSetMap(dpy,xkb,req);
  737.     UnlockDisplay(dpy);
  738.     SyncHandle();
  739.     DBUG_RETURN(True);
  740. }
  741. #endif
  742.