home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / evbl0627.zip / everblue_20010627.zip / x11 / XKB.c < prev    next >
C/C++ Source or Header  |  1999-11-02  |  24KB  |  877 lines
  1. /* $XConsortium: XKB.c /main/22 1996/02/02 16:43:37 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. XkbInternAtomFunc    _XkbInternAtomFunc= XInternAtom;
  36. XkbGetAtomNameFunc    _XkbGetAtomNameFunc= XGetAtomName;
  37.  
  38. Bool 
  39. #if NeedFunctionPrototypes
  40. XkbQueryExtension(    Display *dpy,
  41.             int *    opcodeReturn,
  42.             int *    eventBaseReturn,
  43.             int *    errorBaseReturn,
  44.             int *    majorReturn,
  45.             int *    minorReturn)
  46. #else
  47. XkbQueryExtension(dpy,opcodeReturn,eventBaseReturn,errorBaseReturn,
  48.                         majorReturn,minorReturn)
  49.     Display *dpy;
  50.     int *opcodeReturn;
  51.     int *eventBaseReturn;
  52.     int *errorBaseReturn;
  53.     int *majorReturn;
  54.     int *minorReturn;
  55. #endif
  56. {
  57.     DBUG_ENTER("XkbQueryExtension")
  58.     if (!XkbUseExtension(dpy,majorReturn,minorReturn))
  59.     DBUG_RETURN(False);
  60.     if (opcodeReturn)
  61.     *opcodeReturn = dpy->xkb_info->codes->major_opcode;
  62.     if (eventBaseReturn)
  63.     *eventBaseReturn = dpy->xkb_info->codes->first_event;
  64.     if (errorBaseReturn)
  65.     *errorBaseReturn = dpy->xkb_info->codes->first_error;
  66.     if (majorReturn)
  67.     *majorReturn = dpy->xkb_info->srv_major;
  68.     if (minorReturn)
  69.     *minorReturn = dpy->xkb_info->srv_minor;
  70.     DBUG_RETURN(True);
  71. }
  72.  
  73. Bool 
  74. #if NeedFunctionPrototypes
  75. XkbLibraryVersion(int *libMajorRtrn,int *libMinorRtrn)
  76. #else
  77. XkbLibraryVersion(libMajorRtrn,libMinorRtrn)
  78.     int *libMajorRtrn;
  79.     int *libMinorRtrn;
  80. #endif
  81. {
  82.     DBUG_ENTER("XkbLibraryVersion")
  83.     int supported;
  84.  
  85.     if (*libMajorRtrn != XkbMajorVersion) {
  86.     /* version 0.65 is (almost) compatible with 1.00 */
  87.     if ((XkbMajorVersion==1)&&(((*libMajorRtrn)==0)&&((*libMinorRtrn)==65)))
  88.          supported= True;
  89.     else supported= False;
  90.     }
  91.     else { 
  92.     supported = True;
  93.     }
  94.  
  95.     *libMajorRtrn = XkbMajorVersion;
  96.     *libMinorRtrn = XkbMinorVersion;
  97.     DBUG_RETURN(supported);
  98. }
  99.  
  100. #if 0
  101. Bool
  102. #if NeedFunctionPrototypes
  103. XkbSelectEvents(    Display *    dpy,
  104.             unsigned int     deviceSpec,
  105.             unsigned int     affect,
  106.             unsigned int     selectAll)
  107. #else
  108. XkbSelectEvents(dpy,deviceSpec,affect,selectAll)
  109.     Display *dpy;
  110.     unsigned int deviceSpec;
  111.     unsigned int affect;
  112.     unsigned int selectAll;
  113. #endif
  114. {
  115.     DBUG_ENTER("XkbSelectEvents")
  116.     register xkbSelectEventsReq *req;
  117.     XkbInfoPtr xkbi;
  118.  
  119.     if ((dpy->flags & XlibDisplayNoXkb) ||
  120.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  121.     DBUG_RETURN(False);
  122.     LockDisplay(dpy);
  123.     xkbi = dpy->xkb_info;
  124.     xkbi->selected_events&= ~affect;
  125.     xkbi->selected_events|= (affect&selectAll);
  126.     GetReq(kbSelectEvents, req);
  127.     req->reqType = xkbi->codes->major_opcode;
  128.     req->xkbReqType = X_kbSelectEvents;
  129.     req->deviceSpec = deviceSpec;
  130.     req->affectWhich = (CARD16)affect;
  131.     req->clear = affect&(~selectAll);
  132.     req->selectAll = affect&selectAll;
  133.     if (affect&XkbMapNotifyMask) {
  134.     req->affectMap= XkbAllMapComponentsMask;
  135.     /* the implicit support needs the client info */
  136.     /* even if the client itself doesn't want it */
  137.     if (selectAll&XkbMapNotifyMask)
  138.          req->map= XkbAllMapEventsMask;
  139.     else req->map= XkbAllClientInfoMask;
  140.     if (selectAll&XkbMapNotifyMask)
  141.          xkbi->selected_map_details= XkbAllMapEventsMask;
  142.     else xkbi->selected_map_details= 0;
  143.     }
  144.     if (affect&XkbNewKeyboardNotifyMask) {
  145.     if (selectAll&XkbNewKeyboardNotifyMask) 
  146.          xkbi->selected_nkn_details= XkbAllNewKeyboardEventsMask;
  147.     else xkbi->selected_nkn_details= 0;
  148.     if (!(xkbi->xlib_ctrls&XkbLC_IgnoreNewKeyboards)) {
  149.         /* we want it, even if the client doesn't.  Don't mess */
  150.         /* around with details -- ask for all of them and throw */
  151.         /* away the ones we don't need */
  152.         req->selectAll|= XkbNewKeyboardNotifyMask;
  153.     }
  154.     }
  155.     UnlockDisplay(dpy);
  156.     SyncHandle();
  157.     DBUG_RETURN(True);
  158. }
  159.  
  160. Bool
  161. #if NeedFunctionPrototypes
  162. XkbSelectEventDetails(    Display *        dpy,
  163.             unsigned         deviceSpec,
  164.             unsigned         eventType,
  165.             unsigned long int     affect,
  166.             unsigned long int     details)
  167. #else
  168. XkbSelectEventDetails(dpy,deviceSpec,eventType,affect,details)
  169.     Display *dpy;
  170.     unsigned deviceSpec;
  171.     unsigned eventType;
  172.     unsigned long int affect;
  173.     unsigned long int details;
  174. #endif
  175. {
  176.     DBUG_ENTER("XkbSelectEventDetails")
  177.     register xkbSelectEventsReq *req;
  178.     XkbInfoPtr xkbi;
  179.     int         size;
  180.     char     *out;
  181.     union {
  182.     CARD8    *c8;
  183.     CARD16    *c16;
  184.     CARD32    *c32;
  185.     } u;
  186.     if ((dpy->flags & XlibDisplayNoXkb) ||
  187.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  188.     DBUG_RETURN(False);
  189.     LockDisplay(dpy);
  190.     xkbi = dpy->xkb_info;
  191.     if (affect&details)    xkbi->selected_events|= (1<<eventType);
  192.     else        xkbi->selected_events&= ~(1<<eventType);
  193.     GetReq(kbSelectEvents, req);
  194.     req->reqType = xkbi->codes->major_opcode;
  195.     req->xkbReqType = X_kbSelectEvents;
  196.     req->deviceSpec = deviceSpec;
  197.     req->clear= req->selectAll= 0;
  198.     if (eventType==XkbMapNotify) {
  199.     /* we need all of the client info, even if the application */
  200.     /* doesn't.   Make sure that we always request the stuff */
  201.     /* that the implicit support needs, and just filter out anything */
  202.     /* the client doesn't want later */
  203.     req->affectWhich = 0;
  204.     req->selectAll = 0;
  205.     req->clear = 0;
  206.     req->affectMap = (CARD16)affect;
  207.     req->map = (CARD16)details|(XkbAllClientInfoMask&affect);
  208.     req->affectWhich = XkbMapNotifyMask;
  209.     xkbi->selected_map_details&= ~affect;
  210.     xkbi->selected_map_details|=  (details&affect);
  211.     }
  212.     else {
  213.     req->affectMap = req->map = 0;
  214.     req->affectWhich= (1<<eventType);
  215.     switch (eventType) {
  216.         case XkbNewKeyboardNotify:
  217.         xkbi->selected_nkn_details&= ~affect;
  218.         xkbi->selected_nkn_details|= (details&affect);
  219.         if (!(xkbi->xlib_ctrls&XkbLC_IgnoreNewKeyboards))
  220.             details= (affect&XkbAllNewKeyboardEventsMask);
  221.         case XkbStateNotify:
  222.         case XkbNamesNotify:
  223.         case XkbAccessXNotify:
  224.         case XkbExtensionDeviceNotify:
  225.         size= 2;
  226.         req->length+= 1;
  227.         break;
  228.         case XkbControlsNotify:
  229.         case XkbIndicatorStateNotify:
  230.         case XkbIndicatorMapNotify:
  231.         size= 4;
  232.         req->length+= 2;
  233.         break;
  234.         case XkbBellNotify:
  235.         case XkbActionMessage:
  236.         case XkbCompatMapNotify:
  237.         size= 1;
  238.         req->length+= 1;
  239.         break;
  240.     }
  241.     BufAlloc(char *,out,(((size*2)+(unsigned)3)/4)*4);
  242.     u.c8= (CARD8 *)out;
  243.     if (size==2) {
  244.         u.c16[0]= (CARD16)affect;
  245.         u.c16[1]= (CARD16)details;
  246.     }
  247.     else if (size==4) {
  248.         u.c32[0]= (CARD32)affect;
  249.         u.c32[1]= (CARD32)details;
  250.     }
  251.     else {
  252.         u.c8[0]= (CARD8)affect;
  253.         u.c8[1]= (CARD8)details;
  254.     }
  255.     }
  256.     UnlockDisplay(dpy);
  257.     SyncHandle();
  258.     DBUG_RETURN(True);
  259. }
  260.  
  261. Bool
  262. #if NeedFunctionPrototypes
  263. XkbLockModifiers(    Display *    dpy,
  264.             unsigned int     deviceSpec,
  265.             unsigned int     affect,
  266.             unsigned int     values)
  267. #else
  268. XkbLockModifiers(dpy,deviceSpec,affect,values)
  269.     Display *dpy;
  270.     unsigned int deviceSpec;
  271.     unsigned int affect;
  272.     unsigned int values;
  273. #endif
  274. {
  275.     DBUG_ENTER("XkbLockModifiers")
  276.     register xkbLatchLockStateReq *req;
  277.     XkbInfoPtr xkbi;
  278.     if ((dpy->flags & XlibDisplayNoXkb) ||
  279.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  280.     DBUG_RETURN(False);
  281.     LockDisplay(dpy);
  282.     xkbi = dpy->xkb_info;
  283.     GetReq(kbLatchLockState, req);
  284.     req->reqType = xkbi->codes->major_opcode;
  285.     req->xkbReqType = X_kbLatchLockState;
  286.     req->deviceSpec = deviceSpec;
  287.     req->affectModLocks= affect;
  288.     req->modLocks = values;
  289.     req->lockGroup = False;
  290.     req->groupLock = 0;
  291.  
  292.     req->affectModLatches = req->modLatches = 0;
  293.     req->latchGroup = False;
  294.     req->groupLatch = 0;
  295.     UnlockDisplay(dpy);
  296.     SyncHandle();
  297.     DBUG_RETURN(True);
  298. }
  299.  
  300. Bool
  301. #if NeedFunctionPrototypes
  302. XkbLatchModifiers(    Display *    dpy,
  303.             unsigned int    deviceSpec,
  304.             unsigned int    affect,
  305.             unsigned int    values)
  306. #else
  307. XkbLatchModifiers(dpy,deviceSpec,affect,values)
  308.     Display *dpy;
  309.     unsigned int deviceSpec;
  310.     unsigned int affect;
  311.     unsigned int values;
  312. #endif
  313. {
  314.     DBUG_ENTER("XkbLatchModifiers")
  315.     register xkbLatchLockStateReq *req;
  316.     XkbInfoPtr xkbi;
  317.  
  318.     if ((dpy->flags & XlibDisplayNoXkb) ||
  319.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  320.     DBUG_RETURN(False);
  321.     LockDisplay(dpy);
  322.     xkbi = dpy->xkb_info;
  323.     GetReq(kbLatchLockState, req);
  324.     req->reqType = xkbi->codes->major_opcode;
  325.     req->xkbReqType = X_kbLatchLockState;
  326.     req->deviceSpec = deviceSpec;
  327.  
  328.     req->affectModLatches= affect;
  329.     req->modLatches = values;
  330.     req->latchGroup = False;
  331.     req->groupLatch = 0;
  332.  
  333.     req->affectModLocks = req->modLocks = 0;
  334.     req->lockGroup = False;
  335.     req->groupLock = 0;
  336.  
  337.     UnlockDisplay(dpy);
  338.     SyncHandle();
  339.     DBUG_RETURN(True);
  340. }
  341.  
  342. Bool
  343. #if NeedFunctionPrototypes
  344. XkbLockGroup(Display *dpy,unsigned int deviceSpec,unsigned int group)
  345. #else
  346. XkbLockGroup(dpy,deviceSpec,group)
  347.     Display *dpy;
  348.     unsigned int deviceSpec;
  349.     unsigned int group;
  350. #endif
  351. {
  352.     DBUG_ENTER("XkbLockGroup")
  353.     register xkbLatchLockStateReq *req;
  354.     XkbInfoPtr xkbi;
  355.  
  356.     if ((dpy->flags & XlibDisplayNoXkb) ||
  357.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  358.     DBUG_RETURN(False);
  359.     LockDisplay(dpy);
  360.     xkbi = dpy->xkb_info;
  361.     GetReq(kbLatchLockState, req);
  362.     req->reqType = xkbi->codes->major_opcode;
  363.     req->xkbReqType = X_kbLatchLockState;
  364.     req->deviceSpec = deviceSpec;
  365.     req->affectModLocks= 0;
  366.     req->modLocks = 0;
  367.     req->lockGroup = True;
  368.     req->groupLock = group;
  369.  
  370.     req->affectModLatches = req->modLatches = 0;
  371.     req->latchGroup = False;
  372.     req->groupLatch = 0;
  373.     UnlockDisplay(dpy);
  374.     SyncHandle();
  375.     DBUG_RETURN(True);
  376. }
  377.  
  378. Bool
  379. #if NeedFunctionPrototypes
  380. XkbLatchGroup(Display *dpy,unsigned int deviceSpec,unsigned int group)
  381. #else
  382. XkbLatchGroup(dpy,deviceSpec,group)
  383.     Display *dpy;
  384.     unsigned int deviceSpec;
  385.     unsigned int group;
  386. #endif
  387. {
  388.     DBUG_ENTER("XkbLatchGroup")
  389.     register xkbLatchLockStateReq *req;
  390.     XkbInfoPtr xkbi;
  391.  
  392.     if ((dpy->flags & XlibDisplayNoXkb) ||
  393.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  394.     DBUG_RETURN(False);
  395.     LockDisplay(dpy);
  396.     xkbi = dpy->xkb_info;
  397.     GetReq(kbLatchLockState, req);
  398.     req->reqType = xkbi->codes->major_opcode;
  399.     req->xkbReqType = X_kbLatchLockState;
  400.     req->deviceSpec = deviceSpec;
  401.  
  402.     req->affectModLatches= 0;
  403.     req->modLatches = 0;
  404.     req->latchGroup = True;
  405.     req->groupLatch = group;
  406.  
  407.     req->affectModLocks = req->modLocks = 0;
  408.     req->lockGroup = False;
  409.     req->groupLock = 0;
  410.  
  411.     UnlockDisplay(dpy);
  412.     SyncHandle();
  413.     DBUG_RETURN(True);
  414. }
  415. #endif
  416.  
  417. unsigned
  418. #if NeedFunctionPrototypes
  419. XkbSetXlibControls(Display *dpy,unsigned affect,unsigned values)
  420. #else
  421. XkbSetXlibControls(dpy,affect,values)
  422.     Display *    dpy;
  423.     unsigned    affect;
  424.     unsigned    values;
  425. #endif
  426. {
  427.     DBUG_ENTER("XkbSetXlibControls")
  428.     unsigned result;
  429.     if ((dpy->flags & XlibDisplayNoXkb) ||
  430.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  431.     DBUG_RETURN(False);
  432.     affect&= XkbLC_AllControls;
  433.     dpy->xkb_info->xlib_ctrls&= ~affect;
  434.     dpy->xkb_info->xlib_ctrls|= (affect&values);
  435.     result = dpy->xkb_info->xlib_ctrls;
  436.     DBUG_RETURN(result);
  437. }
  438.  
  439. unsigned
  440. #if NeedFunctionPrototypes
  441. XkbGetXlibControls(Display *dpy)
  442. #else
  443. XkbGetXlibControls(dpy)
  444.     Display *    dpy;
  445. #endif
  446. {
  447.     DBUG_ENTER("XkbGetXlibControls")
  448.     unsigned result;
  449.     if ((dpy->flags & XlibDisplayNoXkb) ||
  450.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  451.     DBUG_RETURN(0);
  452.     result = dpy->xkb_info->xlib_ctrls;
  453.     DBUG_RETURN(result);
  454. }
  455.  
  456. unsigned int
  457. #if NeedFunctionPrototypes
  458. XkbXlibControlsImplemented(void)
  459. #else
  460. XkbXlibControlsImplemented()
  461. #endif
  462. {
  463. #ifdef __sgi
  464.     return XkbLC_AllControls;
  465. #else
  466.     return XkbLC_AllControls&~XkbLC_AllComposeControls;
  467. #endif
  468. }
  469.  
  470. #if 0
  471. Bool
  472. #if NeedFunctionPrototypes
  473. XkbSetDebuggingFlags(    Display *    dpy,
  474.             unsigned int     mask,
  475.             unsigned int     flags,
  476.             char *        msg,
  477.             unsigned int    ctrls_mask,
  478.             unsigned int    ctrls,
  479.             unsigned int *    rtrn_flags,
  480.             unsigned int *    rtrn_ctrls)
  481. #else
  482. XkbSetDebuggingFlags(dpy,mask,flags,msg,ctrls_mask,ctrls,rtrn_flags,rtrn_ctrls)
  483.     Display *        dpy;
  484.     unsigned int     mask;
  485.     unsigned int     flags;
  486.     char *        msg;
  487.     unsigned int     ctrls_mask;
  488.     unsigned int     ctrls;
  489.     unsigned int *    rtrn_flags;
  490.     unsigned int *    rtrn_ctrls;
  491. #endif
  492. {
  493.     DBUG_ENTER("XkbSetDebuggingFlags")
  494.     register xkbSetDebuggingFlagsReq *req;
  495.     xkbSetDebuggingFlagsReply rep;
  496.     XkbInfoPtr xkbi;
  497.  
  498.     if ((dpy->flags & XlibDisplayNoXkb) ||
  499.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  500.     DBUG_RETURN(False);
  501.     LockDisplay(dpy);
  502.     xkbi = dpy->xkb_info;
  503.     GetReq(kbSetDebuggingFlags, req);
  504.     req->reqType=     xkbi->codes->major_opcode;
  505.     req->xkbReqType=    X_kbSetDebuggingFlags;
  506.     req->affectFlags=    mask;
  507.     req->flags=     flags;
  508.     req->affectCtrls=    ctrls_mask;
  509.     req->ctrls=     ctrls;
  510.  
  511.     if (msg) {
  512.     char *out;
  513.     req->msgLength= (unsigned short)strlen(msg)+1;
  514.     req->length+= (req->msgLength+(unsigned)3)>>2;
  515.     BufAlloc(char *,out,((req->msgLength+(unsigned)3)/4)*4);
  516.     memcpy(out,msg,req->msgLength);
  517.     }
  518.     else req->msgLength= 0;
  519.     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  520.     UnlockDisplay(dpy);
  521.     SyncHandle();
  522.     DBUG_RETURN(False);
  523.     }
  524.     if (rtrn_flags)
  525.     *rtrn_flags= rep.currentFlags;
  526.     if (rtrn_ctrls)
  527.     *rtrn_ctrls= rep.currentCtrls;
  528.     UnlockDisplay(dpy);
  529.     SyncHandle();
  530.     DBUG_RETURN(True);
  531. }
  532. #endif
  533.  
  534. Bool
  535. #if NeedFunctionPrototypes
  536. XkbComputeEffectiveMap(    XkbDescPtr     xkb,
  537.             XkbKeyTypePtr     type,
  538.             unsigned char *    map_rtrn)
  539. #else
  540. XkbComputeEffectiveMap(xkb,type,map_rtrn)
  541.     XkbDescPtr        xkb;
  542.     XkbKeyTypePtr    type;
  543.     unsigned char *    map_rtrn;
  544. #endif
  545. {
  546.     DBUG_ENTER("XkbComputeEffectiveMap")
  547.     register int         i;
  548.     unsigned             tmp;
  549.     XkbKTMapEntryPtr    entry;
  550.  
  551.     if ((!xkb)||(!type)||(!xkb->server))
  552.     DBUG_RETURN(False);
  553.  
  554.     if (type->mods.vmods!=0) {
  555.     if (!XkbVirtualModsToReal(xkb,type->mods.vmods,&tmp))
  556.         DBUG_RETURN(False);
  557.  
  558.     type->mods.mask= tmp|type->mods.real_mods;
  559.     entry= type->map;
  560.     for (i=0;i<type->map_count;i++,entry++) {
  561.         tmp= 0;
  562.         if (entry->mods.vmods!=0) {
  563.         if (!XkbVirtualModsToReal(xkb,entry->mods.vmods,&tmp))
  564.             DBUG_RETURN(False);
  565.         if (tmp==0) {
  566.             entry->active= False;
  567.             continue;
  568.         }
  569.         }
  570.         entry->active= True;
  571.         entry->mods.mask= (entry->mods.real_mods|tmp)&type->mods.mask;
  572.     }
  573.     }
  574.     else {
  575.     type->mods.mask= type->mods.real_mods;
  576.     }
  577.     if (map_rtrn!=NULL) {
  578.     bzero(map_rtrn,type->mods.mask+1);
  579.     for (i=0;i<type->map_count;i++) {
  580.         if (entry->active) {
  581.         map_rtrn[type->map[i].mods.mask]= type->map[i].level;
  582.         }
  583.     }
  584.     }
  585.     DBUG_RETURN(True);
  586. }
  587.  
  588. #if 0
  589. Status
  590. #if NeedFunctionPrototypes
  591. XkbGetState(Display *dpy,unsigned deviceSpec,XkbStatePtr rtrn)
  592. #else
  593. XkbGetState(dpy,deviceSpec,rtrn)
  594.     Display *    dpy;
  595.     unsigned     deviceSpec;
  596.     XkbStatePtr    rtrn;
  597. #endif
  598. {
  599.     DBUG_ENTER("XkbGetState")
  600.     register xkbGetStateReq    *req;
  601.     xkbGetStateReply rep;
  602.     XkbInfoPtr xkbi;
  603.  
  604.     if ((dpy->flags & XlibDisplayNoXkb) ||
  605.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  606.     DBUG_RETURN(BadAccess);
  607.     LockDisplay(dpy);
  608.     xkbi = dpy->xkb_info;
  609.     GetReq(kbGetState, req);
  610.     req->reqType = xkbi->codes->major_opcode;
  611.     req->xkbReqType = X_kbGetState;
  612.     req->deviceSpec = deviceSpec;
  613.     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  614.     UnlockDisplay(dpy);
  615.     SyncHandle();
  616.     DBUG_RETURN(BadImplementation);
  617.     }
  618.     rtrn->mods=         rep.mods;
  619.     rtrn->base_mods=         rep.baseMods;
  620.     rtrn->latched_mods=     rep.latchedMods;
  621.     rtrn->locked_mods=         rep.lockedMods;
  622.     rtrn->group=         rep.group;
  623.     rtrn->base_group=         rep.baseGroup;
  624.     rtrn->latched_group=     rep.latchedGroup;
  625.     rtrn->locked_group=     rep.lockedGroup;
  626.     rtrn->compat_state=     rep.compatState;
  627.     rtrn->grab_mods=        rep.grabMods;
  628.     rtrn->compat_grab_mods=    rep.compatGrabMods;
  629.     rtrn->lookup_mods=        rep.lookupMods;
  630.     rtrn->compat_lookup_mods=    rep.compatLookupMods;
  631.     rtrn->ptr_buttons=        rep.ptrBtnState;
  632.     UnlockDisplay(dpy);
  633.     SyncHandle();
  634.     DBUG_RETURN(Success);
  635. }
  636.  
  637. Bool
  638. #if NeedFunctionPrototypes
  639. XkbSetDetectableAutoRepeat(Display *dpy,Bool detectable,Bool *supported)
  640. #else
  641. XkbSetDetectableAutoRepeat(dpy,detectable,supported)
  642.     Display *        dpy;
  643.     Bool        detectable;
  644.     Bool *        supported;
  645. #endif
  646. {
  647.     DBUG_ENTER("XkbSetDetectableAutoRepeat")
  648.     register xkbPerClientFlagsReq *    req;
  649.     xkbPerClientFlagsReply         rep;
  650.     XkbInfoPtr             xkbi;
  651.     Bool result;
  652.  
  653.     if ((dpy->flags & XlibDisplayNoXkb) ||
  654.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  655.     DBUG_RETURN(False);
  656.     LockDisplay(dpy);
  657.     xkbi = dpy->xkb_info;
  658.     GetReq(kbPerClientFlags, req);
  659.     req->reqType = xkbi->codes->major_opcode;
  660.     req->xkbReqType = X_kbPerClientFlags;
  661.     req->deviceSpec = XkbUseCoreKbd;
  662.     req->change = XkbPCF_DetectableAutoRepeatMask;
  663.     if (detectable)
  664.      req->value = XkbPCF_DetectableAutoRepeatMask;
  665.     else req->value = 0;
  666.     req->ctrlsToChange = req->autoCtrls= req->autoCtrlValues= 0;
  667.     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  668.     UnlockDisplay(dpy);
  669.     SyncHandle();
  670.     DBUG_RETURN(False);
  671.     }
  672.     UnlockDisplay(dpy);
  673.     SyncHandle();
  674.     if (supported!=NULL)
  675.     *supported= ((rep.supported&XkbPCF_DetectableAutoRepeatMask)!=0);
  676.     result = (rep.value&XkbPCF_DetectableAutoRepeatMask)!=0;
  677.     DBUG_RETURN(result);
  678. }
  679.  
  680. Bool
  681. #if NeedFunctionPrototypes
  682. XkbGetDetectableAutoRepeat(Display *dpy,Bool *supported)
  683. #else
  684. XkbGetDetectableAutoRepeat(dpy,supported)
  685.     Display *        dpy;
  686.     Bool *        supported;
  687. #endif
  688. {
  689.     DBUG_ENTER("XkbGetDetectableAutoRepeat")
  690.     register xkbPerClientFlagsReq *    req;
  691.     xkbPerClientFlagsReply         rep;
  692.     XkbInfoPtr             xkbi;
  693.     Bool result;
  694.  
  695.     if ((dpy->flags & XlibDisplayNoXkb) ||
  696.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  697.     DBUG_RETURN(False);
  698.     LockDisplay(dpy);
  699.     xkbi = dpy->xkb_info;
  700.     GetReq(kbPerClientFlags, req);
  701.     req->reqType = xkbi->codes->major_opcode;
  702.     req->xkbReqType = X_kbPerClientFlags;
  703.     req->deviceSpec = XkbUseCoreKbd;
  704.     req->change = 0;
  705.     req->value = 0;
  706.     req->ctrlsToChange = req->autoCtrls= req->autoCtrlValues= 0;
  707.     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  708.     UnlockDisplay(dpy);
  709.     SyncHandle();
  710.     DBUG_RETURN(False);
  711.     }
  712.     UnlockDisplay(dpy);
  713.     SyncHandle();
  714.     if (supported!=NULL)
  715.     *supported= ((rep.supported&XkbPCF_DetectableAutoRepeatMask)!=0);
  716.     result = (rep.value&XkbPCF_DetectableAutoRepeatMask)!=0;
  717.     DBUG_RETURN(result);
  718. }
  719.  
  720. Bool
  721. #if NeedFunctionPrototypes
  722. XkbSetAutoResetControls(    Display *    dpy,
  723.                 unsigned     changes,
  724.                 unsigned *    auto_ctrls,
  725.                 unsigned *    auto_values)
  726. #else
  727. XkbSetAutoResetControls(dpy,changes,auto_ctrls,auto_values)
  728.     Display *        dpy;
  729.     unsigned         changes;
  730.     unsigned *        auto_ctrls;
  731.     unsigned *        auto_values;
  732. #endif
  733. {
  734.     DBUG_ENTER("XkbSetAutoResetControls")
  735.     register xkbPerClientFlagsReq *    req;
  736.     xkbPerClientFlagsReply         rep;
  737.     XkbInfoPtr             xkbi;
  738.  
  739.     if ((dpy->flags & XlibDisplayNoXkb) ||
  740.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  741.     DBUG_RETURN(False);
  742.     LockDisplay(dpy);
  743.     xkbi = dpy->xkb_info;
  744.     GetReq(kbPerClientFlags, req);
  745.     req->reqType = xkbi->codes->major_opcode;
  746.     req->xkbReqType = X_kbPerClientFlags;
  747.     req->change = XkbPCF_AutoResetControlsMask;
  748.     req->deviceSpec = XkbUseCoreKbd;
  749.     req->value = XkbPCF_AutoResetControlsMask;
  750.     req->ctrlsToChange= changes;
  751.     req->autoCtrls= *auto_ctrls;
  752.     req->autoCtrlValues= *auto_values;
  753.     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  754.     UnlockDisplay(dpy);
  755.     SyncHandle();
  756.     DBUG_RETURN(False);
  757.     }
  758.     UnlockDisplay(dpy);
  759.     SyncHandle();
  760.     *auto_ctrls= rep.autoCtrls;
  761.     *auto_values= rep.autoCtrlValues;
  762.     DBUG_RETURN((rep.value&XkbPCF_AutoResetControlsMask)!=0);
  763. }
  764.  
  765. Bool
  766. #if NeedFunctionPrototypes
  767. XkbGetAutoResetControls(    Display *    dpy,
  768.                 unsigned *    auto_ctrls,
  769.                 unsigned *    auto_ctrl_values)
  770. #else
  771. XkbGetAutoResetControls(dpy,auto_ctrls,auto_ctrl_values)
  772.     Display *        dpy;
  773.     unsigned *        auto_ctrls;
  774.     unsigned *        auto_ctrl_values;
  775. #endif
  776. {
  777.     DBUG_ENTER("XkbGetAutoResetControls")
  778.     register xkbPerClientFlagsReq *    req;
  779.     xkbPerClientFlagsReply         rep;
  780.     XkbInfoPtr             xkbi;
  781.  
  782.     if ((dpy->flags & XlibDisplayNoXkb) ||
  783.     (!dpy->xkb_info && !XkbUseExtension(dpy,NULL,NULL)))
  784.     DBUG_RETURN(False);
  785.     LockDisplay(dpy);
  786.     xkbi = dpy->xkb_info;
  787.     GetReq(kbPerClientFlags, req);
  788.     req->reqType = xkbi->codes->major_opcode;
  789.     req->xkbReqType = X_kbPerClientFlags;
  790.     req->deviceSpec = XkbUseCoreKbd;
  791.     req->change = 0;
  792.     req->value = 0;
  793.     req->ctrlsToChange = req->autoCtrls= req->autoCtrlValues= 0;
  794.     if (!_XReply(dpy, (xReply *)&rep, 0, xFalse)) {
  795.     UnlockDisplay(dpy);
  796.     SyncHandle();
  797.     DBUG_RETURN(False);
  798.     }
  799.     UnlockDisplay(dpy);
  800.     SyncHandle();
  801.     if (auto_ctrls)
  802.     *auto_ctrls= rep.autoCtrls;
  803.     if (auto_ctrl_values)
  804.     *auto_ctrl_values= rep.autoCtrlValues;
  805.     DBUG_RETURN((rep.value&XkbPCF_AutoResetControlsMask)!=0);
  806. }
  807. #endif
  808.  
  809. Display *
  810. #if NeedFunctionPrototypes
  811. XkbOpenDisplay(    char *    name,
  812.         int *    ev_rtrn,
  813.         int *    err_rtrn,
  814.         int *    major_rtrn,
  815.         int *    minor_rtrn,
  816.         int *    reason)
  817. #else
  818. XkbOpenDisplay(name,ev_rtrn,err_rtrn,major_rtrn,minor_rtrn,reason)
  819.     char *    name;
  820.     int *    ev_rtrn;
  821.     int *    err_rtrn;
  822.     int *    major_rtrn;
  823.     int *    minor_rtrn;
  824.     int *    reason;
  825. #endif
  826. {
  827.     DBUG_ENTER("XkbOpenDisplay")
  828.     Display* dpy;
  829.     int     major_num,minor_num;
  830.  
  831.     if ((major_rtrn!=NULL) && (minor_rtrn!=NULL)) {
  832.     if (!XkbLibraryVersion(major_rtrn,minor_rtrn)) {
  833.         if (reason!=NULL)
  834.         *reason= XkbOD_BadLibraryVersion;
  835.         DBUG_RETURN(NULL);
  836.     }
  837.     }
  838.     else {
  839.     major_num= XkbMajorVersion;
  840.     minor_num= XkbMinorVersion;
  841.     major_rtrn= &major_num;
  842.     minor_rtrn= &minor_num;
  843.     }
  844.     dpy= XOpenDisplay(name);
  845.     if (dpy==NULL) {
  846.     if (reason!=NULL)
  847.         *reason= XkbOD_ConnectionRefused;
  848.     return NULL;
  849.     }
  850.     if (!XkbQueryExtension(dpy,NULL,ev_rtrn,err_rtrn,major_rtrn,minor_rtrn)) {
  851.     if (reason!=NULL) {
  852.         if ((*major_rtrn!=0)||(*minor_rtrn!=0))
  853.          *reason= XkbOD_BadServerVersion;
  854.         else *reason= XkbOD_NonXkbServer;
  855.     }
  856.     XCloseDisplay(dpy);
  857.     DBUG_RETURN(NULL);
  858.     }
  859.     if (reason!=NULL)
  860.     *reason= XkbOD_Success;
  861.     DBUG_RETURN(dpy);
  862. }
  863.  
  864. void
  865. #if NeedFunctionPrototypes
  866. XkbSetAtomFuncs(XkbInternAtomFunc getAtom,XkbGetAtomNameFunc getName)
  867. #else
  868. XkbSetAtomFuncs(getAtom,getName)
  869.     XkbInternAtomFunc    getAtom;
  870.     XkbGetAtomNameFunc    getName;
  871. #endif
  872. {
  873.     _XkbInternAtomFunc= (getAtom?getAtom:XInternAtom);
  874.     _XkbGetAtomNameFunc= (getName?getName:XGetAtomName);
  875.     return;
  876. }
  877.