home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / x / xtrapv33.zip / extensions / lib / xtrap / XEConTxt.c < prev    next >
C/C++ Source or Header  |  1992-09-14  |  21KB  |  734 lines
  1. /*****************************************************************************
  2. Copyright 1987, 1988, 1989, 1990, 1991 by Digital Equipment Corp., Maynard, MA
  3.  
  4. Permission to use, copy, modify, and distribute this software and its 
  5. documentation for any purpose and without fee is hereby granted, 
  6. provided that the above copyright notice appear in all copies and that
  7. both that copyright notice and this permission notice appear in 
  8. supporting documentation, and that the name of Digital not be
  9. used in advertising or publicity pertaining to distribution of the
  10. software without specific, written prior permission.  
  11.  
  12. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  13. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  14. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  15. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  16. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  17. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  18. SOFTWARE.
  19.  
  20. *****************************************************************************/
  21. /*
  22.  *
  23.  *  CONTRIBUTORS:
  24.  *
  25.  *      Dick Annicchiarico
  26.  *      Robert Chesler
  27.  *      Dan Coutu
  28.  *      Gene Durso
  29.  *      Marc Evans
  30.  *      Alan Jamison
  31.  *      Mark Henry
  32.  *      Ken Miller
  33.  *
  34.  */
  35.  
  36. #define NEED_REPLIES
  37. #define NEED_EVENTS
  38.  
  39.  
  40. #include "xtraplib.h"
  41. #include "xtraplibp.h"
  42.  
  43. #ifndef lint
  44. static char RCSID[] = "$Header$";
  45. #endif
  46.  
  47. #ifndef TRUE
  48. # define TRUE 1L
  49. #endif
  50. #ifndef FALSE
  51. # define FALSE 0L
  52. #endif
  53.  
  54. extern char **extensionName;
  55. extern int numExtension;
  56. static XETC     TC;
  57.  
  58. /*
  59.  * This function is used to create a new XTrap context structure. The new
  60.  * context is initialized to a hard coded default, then modified by the
  61.  * valuemask and values passed in by the caller.
  62.  */
  63.  
  64. #ifdef FUNCTION_PROTOS
  65. XETC *XECreateTC(Display *dpy, CARD32 valuemask, XETCValues *value)
  66. #else
  67. XETC *XECreateTC(dpy, valuemask, value)  /* Returns Pointer to new TC */
  68.     Display *dpy;                         /* Ptr to opened display */
  69.     CARD32 valuemask;                     /* which ones to set initially */
  70.     XETCValues *value;                   /* the values themselves */
  71. #endif
  72. {
  73.     static Bool firsttime = True;
  74.     register XETC *tc     = &TC;
  75.     register XETC *last_tc;
  76.     XETrapGetAvailRep rep;
  77.     INT32 i, spass;
  78.     BOOL changed;
  79.  
  80.     /* If this is the first time here, then initialize the default TC */
  81.     if (firsttime == True)
  82.     {   
  83.         firsttime = False;
  84.         /* The first Trap Context is the Template (default) TC */
  85.         (void)memset(tc,0L,sizeof(tc));
  86.         tc->eventBase             = 0x7FFFFFFFL;
  87.         tc->errorBase             = 0x7FFFFFFFL;
  88.         tc->values.v.max_pkt_size = 0x7FFFL;
  89.     }
  90.  
  91.     /* Position to the end of the list */
  92.     for (;tc->next != NULL; tc = tc->next);
  93.  
  94.     /* Allocate memory for the new context */
  95.     last_tc = tc;   /* save the address of the last on the list */
  96.     if ((tc = (tc->next = (XETC *)XtMalloc(sizeof(*tc)))) == NULL)
  97.     {   /* No memory to build TC, XtMalloc has already reported the error */
  98.         return(NULL);
  99.     }
  100.  
  101.     /* Use the original TC as the template to start from */
  102.     (void)memcpy(tc,&TC,sizeof(TC));
  103.     tc->next      = NULL;
  104.     tc->dpy       = dpy;
  105.     tc->xmax_size = XMaxRequestSize(tc->dpy);
  106.  
  107.     /* Initialize Extension */
  108.     if (!XETrapQueryExtension(dpy,&(tc->eventBase),&(tc->errorBase),
  109.         &(tc->extOpcode)))
  110.     {
  111.         char *params = XTrapExtName;
  112.         int num_params = 1L;
  113.         XtWarningMsg("CantLoadExt", "XECreateTC", "XTrapToolkitError",
  114.             "Can't load %s extension", ¶ms, &num_params);
  115.         (void)XtFree(tc);
  116.         last_tc->next = NULL;    /* Clear now nonexistant forward pointer */
  117.         return(NULL);
  118.     }
  119.  
  120.     /* Allocate memory for the XLIB transport */
  121.     if ((tc->xbuff = (BYTE *)XtMalloc(tc->xmax_size * sizeof(CARD32) +
  122.         SIZEOF(XETrapHeader))) == NULL)
  123.     {   /* No memory to build TC, XtMalloc has already reported the error */
  124.         (void)XtFree(tc);        /* free the allocated TC */
  125.         last_tc->next = NULL;    /* Clear now nonexistant forward pointer */
  126.         return(NULL);
  127.     }
  128.  
  129.     /* Decide on a protocol version to communicate with */
  130.     /* would *like* to use XEGetVersionRequest() but it's broken in V3.1 */
  131.     if (XEGetAvailableRequest(tc,&rep) == True)
  132.     {
  133.         /* stow the protocol number */
  134.         switch (rep.xtrap_protocol)
  135.         {
  136.             /* known acceptable protocols */
  137.             case 31:
  138.             case XETrapProtocol:
  139.                 tc->protocol = rep.xtrap_protocol;
  140.                 break;
  141.             /* all else */
  142.             default:    /* stay backwards compatible */
  143.                 tc->protocol = 31;
  144.                 break;
  145.         }
  146.         /* TC to contain *oldest* release/version/revision */
  147.         if (XETrapGetAvailRelease(&rep) <= XETrapRelease)
  148.         {
  149.             tc->release = XETrapGetAvailRelease(&rep);
  150.             if (XETrapGetAvailVersion(&rep) <= XETrapVersion)
  151.             {
  152.                 tc->version = XETrapGetAvailVersion(&rep);
  153.                 tc->revision = (XETrapGetAvailRevision(&rep) < XETrapRevision ?
  154.                     XETrapGetAvailRevision(&rep) : XETrapRevision);
  155.             }
  156.             else
  157.             {
  158.                 tc->version  = XETrapVersion;
  159.                 tc->revision = XETrapRevision;
  160.             }
  161.         }
  162.         else
  163.         {
  164.                 tc->release = XETrapRelease;
  165.                 tc->version  = XETrapVersion;
  166.                 tc->revision = XETrapRevision;
  167.         }
  168.     }
  169.     else
  170.     {   /* We can't seem to communicate with the extension! */
  171.         char *params = XTrapExtName;
  172.         int num_params = 1L;
  173.         XtWarningMsg("CantComm", "XECreateTC", "XTrapToolkitError",
  174.             "Can't commuinicate with extension %s", ¶ms, &num_params);
  175.         (void)XtFree(tc->xbuff);    /* de-allocate memory just alloc'd */
  176.         (void)XtFree(tc);           /* free the allocated TC */
  177.         last_tc->next = NULL;       /* Clear now nonexistant forward pointer */
  178.         return(NULL);
  179.     }
  180.  
  181.     /* Assign the context values the caller provided */
  182.     (void)XEChangeTC(tc, valuemask, value);
  183.  
  184.     /* Initialize the Extension list */
  185.     extensionName=XListExtensions(dpy,&numExtension);
  186.     if (numExtension)
  187.     {
  188.         char *tmp[128L];
  189.         for (i = 0; i < numExtension; i++)
  190.         {   /* Null out the tmp array */
  191.             tmp[i] = NULL;
  192.         }
  193.         for (i = 0; i < numExtension; i++)
  194.         {   /* Arrange extensions in opcode order */
  195.             int opcode,event,error;
  196.             if (XQueryExtension(dpy,extensionName[i],&opcode,&event,&error))
  197.             {
  198.                 tmp[opcode-128] = extensionName[i];
  199.             }
  200.             else
  201.             {   /* This extension didn't load!  Error! */
  202.                 tmp[i] = "Invalid_Extension";
  203.             }
  204.         }
  205.         for (i = 0; i < numExtension; i++)
  206.         {   /* Now update the real array */
  207.             if (tmp[i])
  208.             {
  209.                 extensionName[i] = tmp[i];
  210.             }
  211.             else
  212.             {   /* null!  Must be invalid */
  213.                 extensionName[i] = "Invalid_Extension";
  214.             }
  215.         }
  216.     }
  217.     return (tc);
  218. }
  219.  
  220.  
  221. #ifdef FUNCTION_PROTOS
  222. static int CheckChangeBits(XETrapFlags *dest, XETrapFlags *src, INT32 bit)
  223. #else
  224. static int CheckChangeBits(dest,src,bit)
  225.     XETrapFlags *dest;
  226.     XETrapFlags *src;
  227.     INT32      bit;
  228. #endif
  229. {
  230.     int chg_flag = False;
  231.  
  232.     if (!(BitIsFalse(dest->valid,bit) && BitIsFalse(src->valid,bit)) ||
  233.         !(BitIsTrue(dest->valid,bit) && BitIsTrue(src->valid,bit)))
  234.     {
  235.         BitCopy(dest->valid, src->valid, bit);
  236.         chg_flag = True;
  237.     }
  238.     if (!(BitIsFalse(dest->data,bit) && BitIsFalse(src->data,bit)) ||
  239.         !(BitIsTrue(dest->data,bit) && BitIsTrue(src->data,bit)))
  240.     {
  241.         BitCopy(dest->data, src->data, bit);
  242.         chg_flag = True;
  243.     }
  244.     return(chg_flag);
  245. }
  246.  
  247. /*
  248.  * This function is called to change one or more parameters used to define
  249.  * a context in which XTrap is or will be running.
  250.  */
  251. #ifdef FUNCTION_PROTOS
  252. int XEChangeTC(XETC *tc, CARD32 mask, XETCValues *values)
  253. #else
  254. int XEChangeTC(tc, mask, values)
  255.     XETC *tc;
  256.     CARD32 mask;
  257.     XETCValues *values;
  258. #endif
  259. {
  260.     int status = True;
  261.     register XETCValues *tval = &(tc->values);
  262.     register int i;
  263.  
  264.     if (mask & TCStatistics)
  265.     {   /* Statistics need changing */
  266.         if(CheckChangeBits(&(tval->v.flags), &(values->v.flags), 
  267.             XETrapStatistics))
  268.         {
  269.             tc->dirty |= TCStatistics;
  270.         }
  271.     }
  272.     if (mask & TCRequests)
  273.     {   /* Requests need changing */
  274.         CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapRequest);
  275.         for (i=0; i<256L; i++)
  276.         {
  277.             XETrapSetCfgFlagReq(tval, i, BitValue(values->v.flags.req,i));
  278.         }
  279.         tc->dirty |= TCRequests;
  280.     }
  281.     if (mask & TCEvents)
  282.     {   /* Events need changing */
  283.         CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapEvent);
  284.         for (i=KeyPress; i<=MotionNotify; i++)
  285.         {
  286.             XETrapSetCfgFlagEvt(tval, i, BitValue(values->v.flags.event,i));
  287.         }
  288.         tc->dirty |= TCEvents;
  289.     }
  290.     if (mask & TCMaxPacket)
  291.     {   /* MaxPacket needs changing */
  292.         CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapMaxPacket);
  293.         XETrapSetCfgMaxPktSize(tval, values->v.max_pkt_size);
  294.         tc->dirty |= TCMaxPacket;
  295.     }
  296.     if (mask & TCCmdKey)
  297.     {   /* CmdKey needs changing */
  298.         CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapCmd);
  299.         tval->v.cmd_key = values->v.cmd_key;
  300.         CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapCmdKeyMod);
  301.         tc->dirty |= TCCmdKey;
  302.     }
  303.     if (mask & TCTimeStamps)
  304.     {   /* TimeStamps needs changing */
  305.         if (CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapTimestamp))
  306.         {
  307.             tc->dirty |= TCTimeStamps;
  308.         }
  309.         BitCopy(tval->tc_flags, values->tc_flags, XETCDeltaTimes);
  310.     }
  311.     if (mask & TCWinXY)
  312.     {   /* Window XY's need changing */
  313.         if (CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapWinXY))
  314.         {
  315.             tc->dirty |= TCWinXY;
  316.         }
  317.     }
  318.     if (mask & TCCursor)
  319.     {   /* Window XY's need changing */
  320.         if (CheckChangeBits(&(tval->v.flags), &(values->v.flags),XETrapCursor))
  321.         {
  322.             tc->dirty |= TCCursor;
  323.         }
  324.     }
  325.     if (mask & TCXInput)
  326.     {   /*  XInput flag needs changing */
  327.         if (CheckChangeBits(&(tval->v.flags), &(values->v.flags),XETrapXInput))
  328.         {
  329.             tc->dirty |= TCXInput;
  330.         }
  331.     }
  332.     if (mask & TCColorReplies)
  333.     {   /*  ColorReplies flag needs changing */
  334.         if (CheckChangeBits(&(tval->v.flags), &(values->v.flags),
  335.             XETrapColorReplies))
  336.         {
  337.             tc->dirty |= TCColorReplies;
  338.         }
  339.     }
  340.     if (mask & TCGrabServer )
  341.     {   /* GrabServer flag needs changing */
  342.         if (CheckChangeBits(&(tval->v.flags), &(values->v.flags),
  343.             XETrapGrabServer ))
  344.         {
  345.             tc->dirty |= TCGrabServer;
  346.         }
  347.     }
  348.     if (XETrapGetTCFlagTrapActive(tc))
  349.     {
  350.         status = XEFlushConfig(tc);
  351.     }
  352. #ifdef VMS
  353.     sys$setast(True);   /* Make sure AST's are enabled */
  354. #endif /* VMS */
  355.     return(status);
  356. }
  357.  
  358.  
  359. #ifdef FUNCTION_PROTOS
  360. void XEFreeTC(XETC *tc)
  361. #else
  362. void XEFreeTC(tc)
  363.     XETC *tc;
  364. #endif
  365. {
  366.     register XETC *list = &TC;
  367.  
  368.     if (tc)
  369.     {
  370.         while(list->next != NULL)
  371.         {
  372.             if (list->next == tc)
  373.                 list->next = list->next->next;  /* Got it, remove from list */
  374.             else
  375.                 list = list->next;              /* Update the list pointer */
  376.         }    
  377.         if (tc->values.req_cb)
  378.         {
  379.             XtFree(tc->values.req_cb);
  380.         }
  381.         if (tc->values.evt_cb)
  382.         {
  383.             XtFree(tc->values.evt_cb);
  384.         }
  385.         if (tc->xbuff != NULL)
  386.         {
  387.             XtFree(tc->xbuff);
  388.         }
  389.  
  390.         XtFree(tc);
  391.         if (extensionName)
  392.         {
  393.             XFreeExtensionList(extensionName);
  394.         }
  395.     }
  396.     return;
  397. }
  398.  
  399. /* The following are Convenience routines for setting values within
  400.  * the Trap Context.  These are analogous to the GC's Convenience
  401.  * Functions such as XSetState & XSetForeground
  402.  */
  403. #ifdef FUNCTION_PROTOS
  404. int XETrapSetMaxPacket(XETC *tc, Bool set_flag, CARD16 size)
  405. #else
  406. int XETrapSetMaxPacket(tc, set_flag, size)
  407.     XETC   *tc;
  408.     Bool   set_flag;
  409.     CARD16 size;
  410. #endif
  411. {
  412.     XETCValues tcv;
  413.     int status = True;
  414.     
  415.     (void)memset((char *)&tcv,0L,sizeof(tcv));
  416.     XETrapSetCfgFlagMaxPacket(&tcv, valid, True);
  417.     XETrapSetCfgFlagMaxPacket(&tcv, data, set_flag);
  418.     XETrapSetCfgMaxPktSize(&tcv, size);
  419.     status = XEChangeTC(tc, TCMaxPacket, &tcv);
  420.     return(status);
  421. }
  422. #ifdef FUNCTION_PROTOS
  423. int XETrapSetCommandKey(XETC *tc, Bool set_flag, KeySym cmd_key, Bool mod_flag)
  424. #else
  425. int XETrapSetCommandKey(tc, set_flag, cmd_key, mod_flag)
  426.     XETC    *tc;
  427.     Bool    set_flag;
  428.     KeySym  cmd_key;
  429.     Bool    mod_flag;
  430. #endif
  431. {
  432.     XETCValues tcv;
  433.     int status = True;
  434.     KeyCode cmd_keycode;
  435.  
  436.     (void)memset((char *)&tcv,0L,sizeof(tcv));
  437.     XETrapSetCfgFlagCmd(&tcv, valid, True);
  438.     XETrapSetCfgFlagCmd(&tcv, data, set_flag);
  439.     if (set_flag == True)
  440.     {
  441.         XETrapSetCfgFlagCmdKeyMod(&tcv, valid, True);
  442.         XETrapSetCfgFlagCmdKeyMod(&tcv, data, mod_flag);
  443.         if (!(cmd_keycode = XKeysymToKeycode(XETrapGetDpy(tc), cmd_key)))
  444.         {
  445.             status = False;
  446.         }
  447.         else
  448.         {
  449.             XETrapSetCfgCmdKey(&tcv, cmd_keycode);
  450.         }
  451.     }
  452.     else
  453.     {   /* Clear command key */
  454.         XETrapSetCfgFlagCmdKeyMod(&tcv, valid, True);
  455.         XETrapSetCfgFlagCmdKeyMod(&tcv, data, False);
  456.         XETrapSetCfgCmdKey(&tcv, 0);
  457.     }
  458.     if (status == True)
  459.     {
  460.         status = XEChangeTC(tc, TCCmdKey, &tcv);
  461.     }
  462.     return(status);
  463. }
  464.  
  465. #ifdef FUNCTION_PROTOS
  466. int XETrapSetTimestamps(XETC *tc, Bool set_flag, Bool delta_flag)
  467. #else
  468. int XETrapSetTimestamps(tc, set_flag, delta_flag)
  469.     XETC    *tc;
  470.     Bool    set_flag;
  471.     Bool    delta_flag;
  472. #endif
  473. {
  474.     XETCValues tcv;
  475.     int status = True;
  476.     
  477.     (void)memset((char *)&tcv,0L,sizeof(tcv));
  478.     XETrapSetCfgFlagTimestamp(&tcv, valid, True);
  479.     XETrapSetCfgFlagTimestamp(&tcv, data, set_flag);
  480.     XETrapSetValFlagDeltaTimes(&tcv, delta_flag);
  481.     status = XEChangeTC(tc, TCTimeStamps, &tcv);
  482.     return(status);
  483. }
  484.  
  485. #ifdef FUNCTION_PROTOS
  486. int XETrapSetWinXY(XETC *tc, Bool set_flag)
  487. #else
  488. int XETrapSetWinXY(tc, set_flag)
  489.     XETC    *tc;
  490.     Bool    set_flag;
  491. #endif
  492. {
  493.     XETCValues tcv;
  494.     int status = True;
  495.     
  496.     (void)memset((char *)&tcv,0L,sizeof(tcv));
  497.     XETrapSetCfgFlagWinXY(&tcv, valid, True);
  498.     XETrapSetCfgFlagWinXY(&tcv, data, set_flag);
  499.     status = XEChangeTC(tc, TCWinXY, &tcv);
  500.     return(status);
  501. }
  502.  
  503. #ifdef FUNCTION_PROTOS
  504. int XETrapSetCursor(XETC *tc, Bool set_flag)
  505. #else
  506. int XETrapSetCursor(tc, set_flag)
  507.     XETC    *tc;
  508.     Bool    set_flag;
  509. #endif
  510. {
  511.     XETCValues tcv;
  512.     int status = True;
  513.     
  514.     (void)memset((char *)&tcv,0L,sizeof(tcv));
  515.     XETrapSetCfgFlagCursor(&tcv, valid, True);
  516.     XETrapSetCfgFlagCursor(&tcv, data, set_flag);
  517.     status = XEChangeTC(tc, TCCursor, &tcv);
  518.     return(status);
  519. }
  520.  
  521. #ifdef FUNCTION_PROTOS
  522. int XETrapSetXInput(XETC *tc, Bool set_flag)
  523. #else
  524. int XETrapSetXInput(tc, set_flag)
  525.     XETC    *tc;
  526.     Bool    set_flag;
  527. #endif
  528. {
  529.     XETCValues tcv;
  530.     int status = True;
  531.     
  532.     (void)memset((char *)&tcv,0L,sizeof(tcv));
  533.     XETrapSetCfgFlagXInput(&tcv, valid, True);
  534.     XETrapSetCfgFlagXInput(&tcv, data, set_flag);
  535.     status = XEChangeTC(tc, TCXInput, &tcv);
  536.     return(status);
  537. }
  538.  
  539. #ifdef FUNCTION_PROTOS
  540. int XETrapSetColorReplies(XETC *tc, Bool set_flag)
  541. #else
  542. int XETrapSetColorReplies(tc, set_flag)
  543.     XETC    *tc;
  544.     Bool    set_flag;
  545. #endif
  546. {
  547.     XETCValues tcv;
  548.     int status = True;
  549.     
  550.     (void)memset((char *)&tcv,0L,sizeof(tcv));
  551.     XETrapSetCfgFlagColorReplies(&tcv, valid, True);
  552.     XETrapSetCfgFlagColorReplies(&tcv, data, set_flag);
  553.     status = XEChangeTC(tc, TCColorReplies, &tcv);
  554.     return(status);
  555. }
  556.  
  557. #ifdef FUNCTION_PROTOS
  558. int XETrapSetGrabServer(XETC *tc, Bool set_flag)
  559. #else
  560. int XETrapSetGrabServer(tc, set_flag)
  561.     XETC    *tc;
  562.     Bool    set_flag;
  563. #endif
  564. {
  565.     XETCValues tcv;
  566.     int status = True;
  567.     
  568.     (void)memset((char *)&tcv,0L,sizeof(tcv));
  569.     XETrapSetCfgFlagGrabServer(&tcv, valid, True);
  570.     XETrapSetCfgFlagGrabServer(&tcv, data, set_flag);
  571.     status = XEChangeTC(tc, TCGrabServer, &tcv);
  572.     return(status);
  573. }
  574.  
  575. #ifdef FUNCTION_PROTOS
  576. int XETrapSetStatistics(XETC *tc, Bool set_flag)
  577. #else
  578. int XETrapSetStatistics(tc, set_flag)
  579.     XETC    *tc;
  580.     Bool    set_flag;
  581. #endif
  582. {
  583.     XETCValues tcv;
  584.     int status = True;
  585.     
  586.     (void)memset((char *)&tcv,0L,sizeof(tcv));
  587.     XETrapSetCfgFlagStatistics(&tcv, valid, True);
  588.     XETrapSetCfgFlagStatistics(&tcv, data, set_flag);
  589.     status = XEChangeTC(tc, TCStatistics, &tcv);
  590.     return(status);
  591. }
  592.  
  593. #ifdef FUNCTION_PROTOS
  594. int XETrapSetRequests(XETC *tc, Bool set_flag, ReqFlags requests)
  595. #else
  596. int XETrapSetRequests(tc, set_flag, requests)
  597.     XETC     *tc;
  598.     Bool     set_flag;
  599.     ReqFlags requests;
  600. #endif
  601. {
  602.     XETCValues tcv;
  603.     int status = True;
  604.     int i;
  605.     
  606.     (void)memset((char *)&tcv,0L,sizeof(tcv));
  607.     XETrapSetCfgFlagRequest(&tcv, valid, True);
  608.     XETrapSetCfgFlagRequest(&tcv, data, set_flag);
  609.     for (i=0; i<256L; i++)
  610.     {
  611.         XETrapSetCfgFlagReq(&tcv, i, BitValue(requests, i));
  612.     }
  613.     status = XEChangeTC(tc, TCRequests, &tcv);
  614.     return(status);
  615. }
  616.  
  617. #ifdef FUNCTION_PROTOS
  618. int XETrapSetEvents(XETC *tc, Bool set_flag, EventFlags events)
  619. #else
  620. int XETrapSetEvents(tc, set_flag, events)
  621.     XETC       *tc;
  622.     Bool       set_flag;
  623.     EventFlags events;
  624. #endif
  625. {
  626.     XETCValues tcv;
  627.     int status = True;
  628.     int i;
  629.     
  630.     (void)memset((char *)&tcv,0L,sizeof(tcv));
  631.     XETrapSetCfgFlagEvent(&tcv, valid, True);
  632.     XETrapSetCfgFlagEvent(&tcv, data, set_flag);
  633.     for (i=KeyPress; i<=MotionNotify; i++)
  634.     {
  635.         XETrapSetCfgFlagEvt(&tcv, i, BitValue(events, i));
  636.     }
  637.     status = XEChangeTC(tc, (CARD32)TCEvents, &tcv);
  638.     return(status);
  639. }
  640.  
  641. #ifdef FUNCTION_PROTOS
  642. Bool XESetCmdGateState(XETC *tc, CARD8 type, Bool *gate_closed,
  643.     CARD8 *next_key, Bool *key_ignore)
  644. #else
  645. Bool XESetCmdGateState(tc, type, gate_closed, next_key, key_ignore)
  646.     XETC    *tc;
  647.     CARD8   type;
  648.     Bool    *gate_closed;
  649.     CARD8   *next_key;
  650.     Bool    *key_ignore;
  651. #endif
  652. {
  653.     
  654.     *key_ignore = False;
  655.     if (XETrapGetTCFlagCmdKeyMod(tc,data) == True)
  656.     {
  657.         switch (type) 
  658.         {
  659.             case KeyPress:
  660.                 if (*next_key == XEKeyIsEcho)
  661.                 {
  662.                     break;
  663.                 }
  664.                 *gate_closed = True;
  665.                 *next_key = XEKeyIsClear;
  666.                 break;
  667.     
  668.             case KeyRelease:
  669.                 if (*next_key == XEKeyIsEcho)
  670.                 {
  671.                     *next_key = XEKeyIsClear;
  672.                     break;
  673.                 }
  674.                 if (*next_key == XEKeyIsClear)
  675.                 {
  676.                     *next_key = XEKeyIsEcho;
  677.                 }
  678.                 else
  679.                 {   /* it's XEKeyIsOther, so Clear it */
  680.                     *next_key = XEKeyIsClear;
  681.                 }
  682.                 *gate_closed = False;
  683.                 *key_ignore = True;
  684.                 break;
  685.     
  686.             default: break;
  687.         }
  688.     }
  689.     else
  690.     {
  691.         switch (type)
  692.         {
  693.             case KeyPress:
  694.                 if (*next_key == XEKeyIsEcho)
  695.                 {
  696.                     *gate_closed = False;
  697.                     break;
  698.                 }
  699.                 /* Open gate on cmd key release */
  700.                 if ((*next_key == XEKeyIsOther) && 
  701.                     *gate_closed == True)
  702.                 {
  703.                     break;
  704.                 }
  705.                 *gate_closed = True;
  706.                 *next_key = XEKeyIsClear;
  707.                 break;
  708.  
  709.             case KeyRelease:
  710.                 if (*next_key == XEKeyIsClear)
  711.                 {
  712.                     *next_key = XEKeyIsEcho;
  713.                     break;
  714.                 }
  715.     
  716.                 if (*next_key == XEKeyIsEcho)
  717.                 {
  718.                     *next_key = XEKeyIsClear;
  719.                     break;
  720.                 }
  721.     
  722.                 *gate_closed = False;
  723.                 *key_ignore = True;
  724.                 *next_key = XEKeyIsClear;
  725.                 break;
  726.     
  727.             default: 
  728.                 break;
  729.         }
  730.     }
  731.  
  732.     return(*gate_closed);
  733. }
  734.