home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / XKBCompat.c < prev    next >
C/C++ Source or Header  |  1999-11-02  |  8KB  |  284 lines
  1. /* $XConsortium: XKBCompat.c /main/8 1996/03/01 14:29:32 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. #define    NEED_MAP_READERS
  32. #include "Xlib_private.h"
  33. #include <X11/extensions/XKBproto.h>
  34. #include "XKBlibint.h"
  35.  
  36. Status
  37. #if NeedFunctionPrototypes
  38. _XkbReadGetCompatMapReply(    Display *        dpy,
  39.                 xkbGetCompatMapReply *    rep,
  40.                 XkbDescPtr        xkb,
  41.                 int    *        nread_rtrn)
  42. #else
  43. _XkbReadGetCompatMapReply(dpy,rep,xkb,nread_rtrn)
  44.     Display *            dpy;
  45.     xkbGetCompatMapReply *    rep;
  46.     XkbDescPtr            xkb;
  47.     int    *            nread_rtrn;
  48. #endif
  49. {
  50.     DBUG_ENTER("_XkbReadGetCompatMapReply")
  51.     register int         i;
  52.     XkbReadBufferRec    buf;
  53.  
  54.     if (!_XkbInitReadBuffer(dpy,&buf,(int)rep->length*4)) 
  55.     DBUG_RETURN(BadAlloc);
  56.  
  57.     if (nread_rtrn)
  58.     *nread_rtrn= (int)rep->length*4;
  59.  
  60.     i= rep->firstSI+rep->nSI;
  61.     if ((!xkb->compat)&&
  62.     (XkbAllocCompatMap(xkb,XkbAllCompatMask,i)!=Success))
  63.     DBUG_RETURN(BadAlloc);
  64.  
  65.     if (rep->nSI!=0) {
  66.     XkbSymInterpretRec *syms;
  67.     xkbSymInterpretWireDesc *wire;
  68.  
  69.     wire= (xkbSymInterpretWireDesc *)_XkbGetReadBufferPtr(&buf,
  70.                    rep->nSI*SIZEOF(xkbSymInterpretWireDesc));
  71.     if (wire==NULL)
  72.         goto BAILOUT;
  73.     syms= &xkb->compat->sym_interpret[rep->firstSI];
  74.  
  75.     for (i=0;i<rep->nSI;i++,syms++,wire++) {
  76.         syms->sym= wire->sym;
  77.         syms->mods= wire->mods;
  78.         syms->match= wire->match;
  79.         syms->virtual_mod= wire->virtualMod;
  80.         syms->flags= wire->flags;
  81.         syms->act= *((XkbAnyAction *)&wire->act);
  82.     }
  83.     xkb->compat->num_si+= rep->nSI;
  84.     }
  85.  
  86.     if (rep->groups&XkbAllGroupsMask) {
  87.     register unsigned    bit,nGroups;
  88.     xkbModsWireDesc *     wire;
  89.     for (i=0,nGroups=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
  90.         if (rep->groups&bit)
  91.         nGroups++;
  92.     }
  93.     wire= (xkbModsWireDesc *)_XkbGetReadBufferPtr(&buf,
  94.                   nGroups*SIZEOF(xkbModsWireDesc));
  95.     if (wire==NULL)
  96.         goto BAILOUT;
  97.     for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
  98.         if ((rep->groups&bit)==0)
  99.         continue;
  100.         xkb->compat->groups[i].mask= wire->mask;
  101.         xkb->compat->groups[i].real_mods= wire->realMods;
  102.         xkb->compat->groups[i].vmods= wire->virtualMods;
  103.         wire++;
  104.     }
  105.     }
  106.     i= _XkbFreeReadBuffer(&buf);
  107.     if (i) 
  108.     fprintf(stderr,"CompatMapReply! Bad length (%d extra bytes)\n",i);
  109.     if (i || buf.error)
  110.     DBUG_RETURN(BadLength);
  111.     DBUG_RETURN(Success);
  112. BAILOUT:
  113.     _XkbFreeReadBuffer(&buf);
  114.     DBUG_RETURN(BadLength);
  115. }
  116.  
  117. #if 0
  118. Status
  119. #if NeedFunctionPrototypes
  120. XkbGetCompatMap(Display *dpy,unsigned which,XkbDescPtr xkb)
  121. #else
  122. XkbGetCompatMap(dpy,which,xkb)
  123.     Display *    dpy;
  124.     unsigned     which;
  125.     XkbDescPtr    xkb;
  126. #endif
  127. {
  128.     DBUG_RETURN("XkbGetCompatMap");
  129.     register xkbGetCompatMapReq *req;
  130.     xkbGetCompatMapReply     rep;
  131.     Status            status;
  132.     XkbInfoPtr xkbi;
  133.  
  134.     if ( (!dpy) || (!xkb) || (dpy->flags & XlibDisplayNoXkb) ||
  135.     ((xkb->dpy!=NULL)&&(xkb->dpy!=dpy)) ||
  136.     (!dpy->xkb_info && (!XkbUseExtension(dpy,NULL,NULL))))
  137.     DBUG_RETURN(BadAccess);
  138.     LockDisplay(dpy);
  139.     xkbi = dpy->xkb_info;
  140.     GetReq(kbGetCompatMap, req);
  141.     req->reqType = xkbi->codes->major_opcode;
  142.     req->xkbReqType = X_kbGetCompatMap;
  143.     req->deviceSpec = xkb->device_spec;
  144.     if (which&XkbSymInterpMask)
  145.      req->getAllSI= True;
  146.     else req->getAllSI= False;
  147.     req->firstSI= req->nSI= 0;
  148.  
  149.     if (which&XkbGroupCompatMask)
  150.      req->groups= XkbAllGroupsMask;
  151.     else req->groups=  0;
  152.  
  153.     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  154.     UnlockDisplay(dpy);
  155.     SyncHandle();
  156.     DBUG_RETURN(BadLength);
  157.     }
  158.     if (xkb->dpy==NULL)
  159.     xkb->dpy= dpy;
  160.     if (xkb->device_spec==XkbUseCoreKbd)
  161.     xkb->device_spec= rep.deviceID;
  162.  
  163.     status = _XkbReadGetCompatMapReply(dpy,&rep,xkb,NULL);
  164.     UnlockDisplay(dpy);
  165.     SyncHandle();
  166.     DBUG_RETURN(status);
  167. }
  168.  
  169. static Bool
  170. #if NeedFunctionPrototypes
  171. _XkbWriteSetCompatMap(Display *dpy,xkbSetCompatMapReq *req,XkbDescPtr xkb)
  172. #else
  173. _XkbWriteSetCompatMap(dpy,req,xkb)
  174.     Display *        dpy;
  175.     xkbSetCompatMapReq    *req;
  176.     XkbDescPtr        xkb;
  177. #endif
  178. {
  179.     DBUG_ENTER("_XkbWriteSetCompatMap")
  180.     CARD16            firstSI;
  181.     CARD16            nSI;
  182.     int            size;
  183.     register int         i,nGroups;
  184.     register unsigned    bit;
  185.     unsigned        groups;
  186.     char *            buf;
  187.  
  188.     firstSI = req->firstSI;
  189.     nSI = req->nSI;
  190.     size= nSI*SIZEOF(xkbSymInterpretWireDesc);
  191.     nGroups= 0;
  192.     groups= req->groups;
  193.     if (groups&XkbAllGroupsMask) {
  194.     for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
  195.         if (groups&bit)
  196.         nGroups++;
  197.     }
  198.     size+= SIZEOF(xkbModsWireDesc)*nGroups;
  199.     }
  200.     req->length+= size/4;
  201.     BufAlloc(char *,buf,size);
  202.     if (!buf)
  203.     DBUG_RETURN(False);
  204.  
  205.     if (nSI) {
  206.     XkbSymInterpretPtr sym= &xkb->compat->sym_interpret[firstSI];
  207.     xkbSymInterpretWireDesc *wire= (xkbSymInterpretWireDesc *)buf;
  208.     for (i=0;i<nSI;i++,wire++,sym++) {
  209.         wire->sym= (CARD32)sym->sym;
  210.         wire->mods= sym->mods;
  211.         wire->match= sym->match;
  212.         wire->flags= sym->flags;
  213.         wire->virtualMod= sym->virtual_mod;
  214.         memcpy(&wire->act,&sym->act,sz_xkbActionWireDesc);
  215.     }
  216.     buf+= nSI*SIZEOF(xkbSymInterpretWireDesc);
  217.     }
  218.     if (groups&XkbAllGroupsMask) {
  219.     xkbModsWireDesc *    out;
  220.  
  221.     out= (xkbModsWireDesc *)buf;
  222.     for (i=0,bit=1;i<XkbNumKbdGroups;i++,bit<<=1) {
  223.         if ((groups&bit)!=0) {
  224.         out->mask= xkb->compat->groups[i].mask;
  225.         out->realMods= xkb->compat->groups[i].real_mods;
  226.         out->virtualMods=  xkb->compat->groups[i].vmods;
  227.         out++;
  228.         }
  229.     }
  230.     buf+= nGroups*SIZEOF(xkbModsWireDesc);
  231.     }
  232.     DBUG_RETURN(True);
  233. }
  234.  
  235. Bool
  236. #if NeedFunctionPrototypes
  237. XkbSetCompatMap(Display *dpy,unsigned which,XkbDescPtr xkb,Bool updateActions)
  238. #else
  239. XkbSetCompatMap(dpy,which,xkb,updateActions)
  240.     Display *        dpy;
  241.     unsigned         which;
  242.     XkbDescPtr        xkb;
  243.     Bool        updateActions;
  244. #endif
  245. {
  246.     DBUG_ENTER("XkbSetCompatMap")
  247.     register xkbSetCompatMapReq *req;
  248.     Status             ok;
  249.     XkbInfoPtr xkbi;
  250.  
  251.     if ((dpy->flags & XlibDisplayNoXkb) || (dpy!=xkb->dpy) ||
  252.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  253.     DBUG_RETURN(False);
  254.     if ((!xkb->compat) ||
  255.     ((which&XkbSymInterpMask)&&(!xkb->compat->sym_interpret)))
  256.     DBUG_RETURN(False);
  257.     LockDisplay(dpy);
  258.     xkbi = dpy->xkb_info;
  259.     GetReq(kbSetCompatMap, req);
  260.     req->reqType = xkbi->codes->major_opcode;
  261.     req->xkbReqType = X_kbSetCompatMap;
  262.     req->deviceSpec = xkb->device_spec;
  263.     req->recomputeActions = updateActions;
  264.     if (which&XkbSymInterpMask) {
  265.     req->truncateSI = True;
  266.     req->firstSI= 0;
  267.     req->nSI= xkb->compat->num_si;
  268.     }
  269.     else {
  270.     req->truncateSI = False;
  271.     req->firstSI= 0;
  272.     req->nSI= 0;
  273.     }
  274.     if (which&XkbGroupCompatMask)
  275.      req->groups= XkbAllGroupsMask;
  276.     else req->groups=  0;
  277.     ok= _XkbWriteSetCompatMap(dpy,req,xkb);
  278.     UnlockDisplay(dpy);
  279.     SyncHandle();
  280.     DBUG_RETURN(ok);
  281. }
  282. #endif
  283.  
  284.