aboutsummaryrefslogtreecommitdiff
path: root/nx-X11/lib/XTrap
diff options
context:
space:
mode:
Diffstat (limited to 'nx-X11/lib/XTrap')
-rw-r--r--nx-X11/lib/XTrap/Imakefile30
-rw-r--r--nx-X11/lib/XTrap/XECallBcks.c175
-rw-r--r--nx-X11/lib/XTrap/XEConTxt.c589
-rw-r--r--nx-X11/lib/XTrap/XEDsptch.c111
-rw-r--r--nx-X11/lib/XTrap/XEPrInfo.c274
-rw-r--r--nx-X11/lib/XTrap/XERqsts.c412
-rw-r--r--nx-X11/lib/XTrap/XEStrMap.c284
-rw-r--r--nx-X11/lib/XTrap/XETrapInit.c218
-rw-r--r--nx-X11/lib/XTrap/XEWrappers.c325
-rw-r--r--nx-X11/lib/XTrap/XTrap-def.cpp76
10 files changed, 2494 insertions, 0 deletions
diff --git a/nx-X11/lib/XTrap/Imakefile b/nx-X11/lib/XTrap/Imakefile
new file mode 100644
index 000000000..54bfdd6dd
--- /dev/null
+++ b/nx-X11/lib/XTrap/Imakefile
@@ -0,0 +1,30 @@
+XCOMM $XFree86$
+
+#define DoNormalLib NormalLibXTrap
+#define DoSharedLib SharedLibXTrap
+#define DoDebugLib DebugLibXTrap
+#define DoProfileLib ProfileLibXTrap
+#define LibName XTrap
+#define SoRev SOXTRAPREV
+#define LibHeaders NO
+
+#include <Threads.tmpl>
+
+#ifdef SharedXmuReqs
+REQUIREDLIBS = SharedXmuReqs
+#endif
+
+XCOMM wish this weren't necessary, but need xlib and xt internals...
+INCLUDES=-I$(TOP)/include -I$(TOOLKITSRC)
+
+
+ SRCS = XECallBcks.c XEConTxt.c XEDsptch.c XEPrInfo.c \
+ XERqsts.c XEStrMap.c XETrapInit.c XEWrappers.c
+ OBJS = XECallBcks.o XEConTxt.o XEDsptch.o XEPrInfo.o \
+ XERqsts.o XEStrMap.o XETrapInit.o XEWrappers.o
+
+LINTLIBS = $(LINTXLIB)
+
+#include <Library.tmpl>
+
+DependTarget()
diff --git a/nx-X11/lib/XTrap/XECallBcks.c b/nx-X11/lib/XTrap/XECallBcks.c
new file mode 100644
index 000000000..fb1e0893e
--- /dev/null
+++ b/nx-X11/lib/XTrap/XECallBcks.c
@@ -0,0 +1,175 @@
+/* $XFree86$ */
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991 by Digital Equipment Corp., Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+/*
+ *
+ * CONTRIBUTORS:
+ *
+ * Dick Annicchiarico
+ * Robert Chesler
+ * Dan Coutu
+ * Gene Durso
+ * Marc Evans
+ * Alan Jamison
+ * Mark Henry
+ * Ken Miller
+ *
+ */
+/*
+ * This file contains XETrap Callback initilization routines.
+ * The callback data hang off of the TC and are freed as part of the
+ * XEFreeTC routine.
+ */
+
+#include <X11/Xos.h>
+#include <X11/extensions/xtraplib.h>
+#include <X11/extensions/xtraplibp.h>
+
+int XEAddRequestCB(XETC *tc, CARD8 req, void_function func, BYTE *data)
+{
+ if (!tc->values.req_cb)
+ { /* This is the first time for this particular TC, need to malloc */
+ if ((tc->values.req_cb =
+ (XETrapCB *)XtCalloc(256L,sizeof(XETrapCB))) == NULL)
+ {
+ /* XtCalloc already reported the error */
+ return(False);
+ }
+ }
+ tc->values.req_cb[req].func = func;
+ tc->values.req_cb[req].data = data;
+
+ return(True);
+}
+
+int XEAddRequestCBs(XETC *tc, ReqFlags req_flags, void_function func,
+ BYTE *data)
+{
+ int i;
+ int status = True;
+
+ for (i=0; i<=255L; i++)
+ {
+ if (BitIsTrue(req_flags, i))
+ {
+ status = XEAddRequestCB(tc, (CARD8)i, func, data);
+ }
+ }
+ return(status);
+}
+
+int XEAddEventCB(XETC *tc, CARD8 evt, void_function func, BYTE *data)
+{
+ if (!tc->values.evt_cb)
+ { /* This is the first time for this particular TC, need to malloc */
+ if ((tc->values.evt_cb =
+ (XETrapCB *)XtCalloc(XETrapCoreEvents,sizeof(XETrapCB))) == NULL)
+ {
+ /* XtCalloc already reported the error */
+ return(False);
+ }
+ }
+ tc->values.evt_cb[evt].func = func;
+ tc->values.evt_cb[evt].data = data;
+
+ return(True);
+}
+
+int XEAddEventCBs(XETC *tc, EventFlags evt_flags, void_function func,
+ BYTE *data)
+{
+ int i;
+ int status = True;
+
+ for (i=KeyPress; i<=MotionNotify; i++)
+ {
+ if (BitIsTrue(evt_flags, i))
+ {
+ status = XEAddEventCB(tc, (CARD8)i, func, data);
+ }
+ }
+ return(status);
+}
+
+void XERemoveRequestCB(XETC *tc, CARD8 req)
+{
+ if (!tc->values.req_cb)
+ { /* We gotta problem! CB struct not allocated! */
+ return;
+ }
+ tc->values.req_cb[req].func = (void_function)NULL;
+ tc->values.req_cb[req].data = (BYTE *)NULL;
+ return;
+}
+void XERemoveRequestCBs(XETC *tc, ReqFlags req_flags)
+{
+ int i;
+
+ for (i=0; i<=255L; i++)
+ {
+ if (BitIsTrue(req_flags, i))
+ {
+ XERemoveRequestCB(tc, (CARD8)i);
+ }
+ }
+}
+
+void XERemoveAllRequestCBs(XETC *tc)
+{
+ if (!tc->values.req_cb)
+ { /* We gotta problem! CB struct not allocated! */
+ return;
+ }
+ XtFree((XtPointer)tc->values.req_cb);
+}
+
+void XERemoveEventCB(XETC *tc, CARD8 evt)
+{
+ if (!tc->values.evt_cb)
+ { /* We gotta problem! CB struct not allocated! */
+ return;
+ }
+ tc->values.evt_cb[evt].func = (void_function)NULL;
+ tc->values.evt_cb[evt].data = (BYTE *)NULL;
+ return;
+}
+
+void XERemoveEventCBs(XETC *tc, EventFlags evt_flags)
+{
+ int i;
+
+ for (i=KeyPress; i<=MotionNotify; i++)
+ {
+ if (BitIsTrue(evt_flags, i))
+ {
+ XERemoveEventCB(tc, (CARD8)i);
+ }
+ }
+}
+
+void XERemoveAllEventCBs(XETC *tc)
+{
+ if (!tc->values.evt_cb)
+ { /* We gotta problem! CB struct not allocated! */
+ return;
+ }
+ XtFree((XtPointer)tc->values.evt_cb);
+}
diff --git a/nx-X11/lib/XTrap/XEConTxt.c b/nx-X11/lib/XTrap/XEConTxt.c
new file mode 100644
index 000000000..7da96894b
--- /dev/null
+++ b/nx-X11/lib/XTrap/XEConTxt.c
@@ -0,0 +1,589 @@
+/* $XFree86: xc/lib/XTrap/XEConTxt.c,v 1.1 2001/11/02 23:29:27 dawes Exp $ */
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991, 1994 by Digital Equipment Corp.,
+Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+/*
+ *
+ * CONTRIBUTORS:
+ *
+ * Dick Annicchiarico
+ * Robert Chesler
+ * Dan Coutu
+ * Gene Durso
+ * Marc Evans
+ * Alan Jamison
+ * Mark Henry
+ * Ken Miller
+ *
+ */
+
+#define NEED_REPLIES
+#define NEED_EVENTS
+
+
+#include <X11/extensions/xtraplib.h>
+#include <X11/extensions/xtraplibp.h>
+
+#ifndef TRUE
+# define TRUE 1L
+#endif
+#ifndef FALSE
+# define FALSE 0L
+#endif
+
+extern char *extensionData;
+
+static XETC TC;
+
+/*
+ * This function is used to create a new XTrap context structure. The new
+ * context is initialized to a hard coded default, then modified by the
+ * valuemask and values passed in by the caller.
+ */
+
+XETC *XECreateTC(Display *dpy, CARD32 valuemask, XETCValues *value)
+{
+ static Bool firsttime = True;
+ register XETC *tc = &TC;
+ register XETC *last_tc;
+ XETrapGetAvailRep rep;
+
+ /* If this is the first time here, then initialize the default TC */
+ if (firsttime == True)
+ {
+ firsttime = False;
+ /* The first Trap Context is the Template (default) TC */
+ (void)memset(tc,0L,sizeof(tc));
+ tc->eventBase = 0x7FFFFFFFL;
+ tc->errorBase = 0x7FFFFFFFL;
+ tc->values.v.max_pkt_size = 0x7FFFL;
+ }
+
+ /* Position to the end of the list */
+ for (;tc->next != NULL; tc = tc->next);
+
+ /* Allocate memory for the new context */
+ last_tc = tc; /* save the address of the last on the list */
+ if ((tc = (tc->next = (XETC *)XtMalloc(sizeof(*tc)))) == NULL)
+ { /* No memory to build TC, XtMalloc has already reported the error */
+ return(NULL);
+ }
+
+ /* Use the original TC as the template to start from */
+ (void)memcpy(tc,&TC,sizeof(TC));
+ tc->next = NULL;
+ tc->dpy = dpy;
+ tc->xmax_size = XMaxRequestSize(tc->dpy);
+
+ /* Initialize Extension */
+ if (!XETrapQueryExtension(dpy,&(tc->eventBase),&(tc->errorBase),
+ &(tc->extOpcode)))
+ {
+ char *params = XTrapExtName;
+ unsigned int num_params = 1L;
+ XtWarningMsg("CantLoadExt", "XECreateTC", "XTrapToolkitError",
+ "Can't load %s extension", &params, &num_params);
+ (void)XtFree((XtPointer)tc);
+ last_tc->next = NULL; /* Clear now nonexistant forward pointer */
+ return(NULL);
+ }
+
+ /* Allocate memory for the XLIB transport */
+ if ((tc->xbuff = (BYTE *)XtMalloc(tc->xmax_size * sizeof(CARD32) +
+ SIZEOF(XETrapHeader))) == NULL)
+ { /* No memory to build TC, XtMalloc has already reported the error */
+ (void)XtFree((XtPointer)tc); /* free the allocated TC */
+ last_tc->next = NULL; /* Clear now nonexistant forward pointer */
+ return(NULL);
+ }
+
+ /* Decide on a protocol version to communicate with */
+ /* would *like* to use XEGetVersionRequest() but it's broken in V3.1 */
+ if (XEGetAvailableRequest(tc,&rep) == True)
+ {
+ /* stow the protocol number */
+ switch (rep.xtrap_protocol)
+ {
+ /* known acceptable protocols */
+ case 31:
+ case XETrapProtocol:
+ tc->protocol = rep.xtrap_protocol;
+ break;
+ /* all else */
+ default: /* stay backwards compatible */
+ tc->protocol = 31;
+ break;
+ }
+ /* TC to contain *oldest* release/version/revision */
+ if (XETrapGetAvailRelease(&rep) <= XETrapRelease)
+ {
+ tc->release = XETrapGetAvailRelease(&rep);
+ if (XETrapGetAvailVersion(&rep) <= XETrapVersion)
+ {
+ tc->version = XETrapGetAvailVersion(&rep);
+ tc->revision = (XETrapGetAvailRevision(&rep) <= XETrapRevision ?
+ XETrapGetAvailRevision(&rep) : XETrapRevision);
+ }
+ else
+ {
+ tc->version = XETrapVersion;
+ tc->revision = XETrapRevision;
+ }
+ }
+ else
+ {
+ tc->release = XETrapRelease;
+ tc->version = XETrapVersion;
+ tc->revision = XETrapRevision;
+ }
+ }
+ else
+ { /* We can't seem to communicate with the extension! */
+ char *params = XTrapExtName;
+ unsigned int num_params = 1L;
+ XtWarningMsg("CantComm", "XECreateTC", "XTrapToolkitError",
+ "Can't communicate with extension %s", &params, &num_params);
+ (void)XtFree((XtPointer)tc->xbuff);/* de-allocate memory just alloc'd */
+ (void)XtFree((XtPointer)tc); /* free the allocated TC */
+ last_tc->next = NULL; /* Clear now nonexistant forward pointer */
+ return(NULL);
+ }
+
+ /* Assign the context values the caller provided */
+ (void)XEChangeTC(tc, valuemask, value);
+
+ return (tc);
+}
+
+
+static int CheckChangeBits(XETrapFlags *dest, XETrapFlags *src, INT32 bit)
+{
+ int chg_flag = False;
+
+ if (!(BitIsFalse(dest->valid,bit) && BitIsFalse(src->valid,bit)) ||
+ !(BitIsTrue(dest->valid,bit) && BitIsTrue(src->valid,bit)))
+ {
+ BitCopy(dest->valid, src->valid, bit);
+ chg_flag = True;
+ }
+ if (!(BitIsFalse(dest->data,bit) && BitIsFalse(src->data,bit)) ||
+ !(BitIsTrue(dest->data,bit) && BitIsTrue(src->data,bit)))
+ {
+ BitCopy(dest->data, src->data, bit);
+ chg_flag = True;
+ }
+ return(chg_flag);
+}
+
+/*
+ * This function is called to change one or more parameters used to define
+ * a context in which XTrap is or will be running.
+ */
+int XEChangeTC(XETC *tc, CARD32 mask, XETCValues *values)
+{
+ int status = True;
+ register XETCValues *tval = &(tc->values);
+ register int i;
+
+ if (mask & TCStatistics)
+ { /* Statistics need changing */
+ if(CheckChangeBits(&(tval->v.flags), &(values->v.flags),
+ XETrapStatistics))
+ {
+ tc->dirty |= TCStatistics;
+ }
+ }
+ if (mask & TCRequests)
+ { /* Requests need changing */
+ CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapRequest);
+ for (i=0; i<256L; i++)
+ {
+ XETrapSetCfgFlagReq(tval, i, BitValue(values->v.flags.req,i));
+ }
+ tc->dirty |= TCRequests;
+ }
+ if (mask & TCEvents)
+ { /* Events need changing */
+ CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapEvent);
+ for (i=KeyPress; i<=MotionNotify; i++)
+ {
+ XETrapSetCfgFlagEvt(tval, i, BitValue(values->v.flags.event,i));
+ }
+ tc->dirty |= TCEvents;
+ }
+ if (mask & TCMaxPacket)
+ { /* MaxPacket needs changing */
+ CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapMaxPacket);
+ XETrapSetCfgMaxPktSize(tval, values->v.max_pkt_size);
+ tc->dirty |= TCMaxPacket;
+ }
+ if (mask & TCCmdKey)
+ { /* CmdKey needs changing */
+ CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapCmd);
+ tval->v.cmd_key = values->v.cmd_key;
+ CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapCmdKeyMod);
+ tc->dirty |= TCCmdKey;
+ }
+ if (mask & TCTimeStamps)
+ { /* TimeStamps needs changing */
+ if (CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapTimestamp))
+ {
+ tc->dirty |= TCTimeStamps;
+ }
+ BitCopy(tval->tc_flags, values->tc_flags, XETCDeltaTimes);
+ }
+ if (mask & TCWinXY)
+ { /* Window XY's need changing */
+ if (CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapWinXY))
+ {
+ tc->dirty |= TCWinXY;
+ }
+ }
+ if (mask & TCCursor)
+ { /* Window XY's need changing */
+ if (CheckChangeBits(&(tval->v.flags), &(values->v.flags),XETrapCursor))
+ {
+ tc->dirty |= TCCursor;
+ }
+ }
+ if (mask & TCXInput)
+ { /* XInput flag needs changing */
+ if (CheckChangeBits(&(tval->v.flags), &(values->v.flags),XETrapXInput))
+ {
+ tc->dirty |= TCXInput;
+ }
+ }
+ if (mask & TCColorReplies)
+ { /* ColorReplies flag needs changing */
+ if (CheckChangeBits(&(tval->v.flags), &(values->v.flags),
+ XETrapColorReplies))
+ {
+ tc->dirty |= TCColorReplies;
+ }
+ }
+ if (mask & TCGrabServer )
+ { /* GrabServer flag needs changing */
+ if (CheckChangeBits(&(tval->v.flags), &(values->v.flags),
+ XETrapGrabServer ))
+ {
+ tc->dirty |= TCGrabServer;
+ }
+ }
+ if (XETrapGetTCFlagTrapActive(tc))
+ {
+ status = XEFlushConfig(tc);
+ }
+#ifdef VMS
+ sys$setast(True); /* Make sure AST's are enabled */
+#endif /* VMS */
+ return(status);
+}
+
+
+void XEFreeTC(XETC *tc)
+{
+ register XETC *list = &TC;
+
+ if (tc)
+ {
+ while(list->next != NULL)
+ {
+ if (list->next == tc)
+ list->next = list->next->next; /* Got it, remove from list */
+ else
+ list = list->next; /* Update the list pointer */
+ }
+ if (tc->values.req_cb)
+ {
+ XtFree((XtPointer)tc->values.req_cb);
+ }
+ if (tc->values.evt_cb)
+ {
+ XtFree((XtPointer)tc->values.evt_cb);
+ }
+ if (tc->xbuff != NULL)
+ {
+ XtFree((XtPointer)tc->xbuff);
+ }
+
+ XtFree((XtPointer)tc);
+ if (extensionData)
+ {
+ XtFree(extensionData);
+ }
+ }
+ return;
+}
+
+/* The following are Convenience routines for setting values within
+ * the Trap Context. These are analogous to the GC's Convenience
+ * Functions such as XSetState & XSetForeground
+ */
+int XETrapSetMaxPacket(XETC *tc, Bool set_flag, CARD16 size)
+{
+ XETCValues tcv;
+ int status = True;
+
+ (void)memset((char *)&tcv,0L,sizeof(tcv));
+ XETrapSetCfgFlagMaxPacket(&tcv, valid, True);
+ XETrapSetCfgFlagMaxPacket(&tcv, data, set_flag);
+ XETrapSetCfgMaxPktSize(&tcv, size);
+ status = XEChangeTC(tc, TCMaxPacket, &tcv);
+ return(status);
+}
+int XETrapSetCommandKey(XETC *tc, Bool set_flag, KeySym cmd_key, Bool mod_flag)
+{
+ XETCValues tcv;
+ int status = True;
+ KeyCode cmd_keycode;
+
+ (void)memset((char *)&tcv,0L,sizeof(tcv));
+ XETrapSetCfgFlagCmd(&tcv, valid, True);
+ XETrapSetCfgFlagCmd(&tcv, data, set_flag);
+ if (set_flag == True)
+ {
+ XETrapSetCfgFlagCmdKeyMod(&tcv, valid, True);
+ XETrapSetCfgFlagCmdKeyMod(&tcv, data, mod_flag);
+ if (!(cmd_keycode = XKeysymToKeycode(XETrapGetDpy(tc), cmd_key)))
+ {
+ status = False;
+ }
+ else
+ {
+ XETrapSetCfgCmdKey(&tcv, cmd_keycode);
+ }
+ }
+ else
+ { /* Clear command key */
+ XETrapSetCfgFlagCmdKeyMod(&tcv, valid, True);
+ XETrapSetCfgFlagCmdKeyMod(&tcv, data, False);
+ XETrapSetCfgCmdKey(&tcv, 0);
+ }
+ if (status == True)
+ {
+ status = XEChangeTC(tc, TCCmdKey, &tcv);
+ }
+ return(status);
+}
+
+int XETrapSetTimestamps(XETC *tc, Bool set_flag, Bool delta_flag)
+{
+ XETCValues tcv;
+ int status = True;
+
+ (void)memset((char *)&tcv,0L,sizeof(tcv));
+ XETrapSetCfgFlagTimestamp(&tcv, valid, True);
+ XETrapSetCfgFlagTimestamp(&tcv, data, set_flag);
+ XETrapSetValFlagDeltaTimes(&tcv, delta_flag);
+ status = XEChangeTC(tc, TCTimeStamps, &tcv);
+ return(status);
+}
+
+int XETrapSetWinXY(XETC *tc, Bool set_flag)
+{
+ XETCValues tcv;
+ int status = True;
+
+ (void)memset((char *)&tcv,0L,sizeof(tcv));
+ XETrapSetCfgFlagWinXY(&tcv, valid, True);
+ XETrapSetCfgFlagWinXY(&tcv, data, set_flag);
+ status = XEChangeTC(tc, TCWinXY, &tcv);
+ return(status);
+}
+
+int XETrapSetCursor(XETC *tc, Bool set_flag)
+{
+ XETCValues tcv;
+ int status = True;
+
+ (void)memset((char *)&tcv,0L,sizeof(tcv));
+ XETrapSetCfgFlagCursor(&tcv, valid, True);
+ XETrapSetCfgFlagCursor(&tcv, data, set_flag);
+ status = XEChangeTC(tc, TCCursor, &tcv);
+ return(status);
+}
+
+int XETrapSetXInput(XETC *tc, Bool set_flag)
+{
+ XETCValues tcv;
+ int status = True;
+
+ (void)memset((char *)&tcv,0L,sizeof(tcv));
+ XETrapSetCfgFlagXInput(&tcv, valid, True);
+ XETrapSetCfgFlagXInput(&tcv, data, set_flag);
+ status = XEChangeTC(tc, TCXInput, &tcv);
+ return(status);
+}
+
+int XETrapSetColorReplies(XETC *tc, Bool set_flag)
+{
+ XETCValues tcv;
+ int status = True;
+
+ (void)memset((char *)&tcv,0L,sizeof(tcv));
+ XETrapSetCfgFlagColorReplies(&tcv, valid, True);
+ XETrapSetCfgFlagColorReplies(&tcv, data, set_flag);
+ status = XEChangeTC(tc, TCColorReplies, &tcv);
+ return(status);
+}
+
+int XETrapSetGrabServer(XETC *tc, Bool set_flag)
+{
+ XETCValues tcv;
+ int status = True;
+
+ (void)memset((char *)&tcv,0L,sizeof(tcv));
+ XETrapSetCfgFlagGrabServer(&tcv, valid, True);
+ XETrapSetCfgFlagGrabServer(&tcv, data, set_flag);
+ status = XEChangeTC(tc, TCGrabServer, &tcv);
+ return(status);
+}
+
+int XETrapSetStatistics(XETC *tc, Bool set_flag)
+{
+ XETCValues tcv;
+ int status = True;
+
+ (void)memset((char *)&tcv,0L,sizeof(tcv));
+ XETrapSetCfgFlagStatistics(&tcv, valid, True);
+ XETrapSetCfgFlagStatistics(&tcv, data, set_flag);
+ status = XEChangeTC(tc, TCStatistics, &tcv);
+ return(status);
+}
+
+int XETrapSetRequests(XETC *tc, Bool set_flag, ReqFlags requests)
+{
+ XETCValues tcv;
+ int status = True;
+ int i;
+
+ (void)memset((char *)&tcv,0L,sizeof(tcv));
+ XETrapSetCfgFlagRequest(&tcv, valid, True);
+ XETrapSetCfgFlagRequest(&tcv, data, set_flag);
+ for (i=0; i<256L; i++)
+ {
+ XETrapSetCfgFlagReq(&tcv, i, BitValue(requests, i));
+ }
+ status = XEChangeTC(tc, TCRequests, &tcv);
+ return(status);
+}
+
+int XETrapSetEvents(XETC *tc, Bool set_flag, EventFlags events)
+{
+ XETCValues tcv;
+ int status = True;
+ int i;
+
+ (void)memset((char *)&tcv,0L,sizeof(tcv));
+ XETrapSetCfgFlagEvent(&tcv, valid, True);
+ XETrapSetCfgFlagEvent(&tcv, data, set_flag);
+ for (i=KeyPress; i<=MotionNotify; i++)
+ {
+ XETrapSetCfgFlagEvt(&tcv, i, BitValue(events, i));
+ }
+ status = XEChangeTC(tc, (CARD32)TCEvents, &tcv);
+ return(status);
+}
+
+Bool XESetCmdGateState(XETC *tc, CARD8 type, Bool *gate_closed,
+ CARD8 *next_key, Bool *key_ignore)
+{
+
+ *key_ignore = False;
+ if (XETrapGetTCFlagCmdKeyMod(tc,data) == True)
+ {
+ switch (type)
+ {
+ case KeyPress:
+ if (*next_key == XEKeyIsEcho)
+ {
+ break;
+ }
+ *gate_closed = True;
+ *next_key = XEKeyIsClear;
+ break;
+
+ case KeyRelease:
+ if (*next_key == XEKeyIsEcho)
+ {
+ *next_key = XEKeyIsClear;
+ break;
+ }
+ if (*next_key == XEKeyIsClear)
+ {
+ *next_key = XEKeyIsEcho;
+ }
+ else
+ { /* it's XEKeyIsOther, so Clear it */
+ *next_key = XEKeyIsClear;
+ }
+ *gate_closed = False;
+ *key_ignore = True;
+ break;
+
+ default: break;
+ }
+ }
+ else
+ {
+ switch (type)
+ {
+ case KeyPress:
+ if (*next_key == XEKeyIsEcho)
+ {
+ *gate_closed = False;
+ break;
+ }
+ /* Open gate on cmd key release */
+ if ((*next_key == XEKeyIsOther) &&
+ *gate_closed == True)
+ {
+ break;
+ }
+ *gate_closed = True;
+ *next_key = XEKeyIsClear;
+ break;
+
+ case KeyRelease:
+ if (*next_key == XEKeyIsClear)
+ {
+ *next_key = XEKeyIsEcho;
+ break;
+ }
+
+ if (*next_key == XEKeyIsEcho)
+ {
+ *next_key = XEKeyIsClear;
+ break;
+ }
+
+ *gate_closed = False;
+ *key_ignore = True;
+ *next_key = XEKeyIsClear;
+ break;
+
+ default:
+ break;
+ }
+ }
+
+ return(*gate_closed);
+}
diff --git a/nx-X11/lib/XTrap/XEDsptch.c b/nx-X11/lib/XTrap/XEDsptch.c
new file mode 100644
index 000000000..b50392638
--- /dev/null
+++ b/nx-X11/lib/XTrap/XEDsptch.c
@@ -0,0 +1,111 @@
+/* $XFree86$ */
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991 by Digital Equipment Corp., Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+/*
+ *
+ * CONTRIBUTORS:
+ *
+ * Dick Annicchiarico
+ * Robert Chesler
+ * Dan Coutu
+ * Gene Durso
+ * Marc Evans
+ * Alan Jamison
+ * Mark Henry
+ * Ken Miller
+ *
+ */
+
+#include <stdio.h>
+#include <errno.h>
+#include <X11/extensions/xtraplib.h>
+#include <X11/extensions/xtraplibp.h>
+
+static void XETrapDispatchCB(XETC *tc, XETrapDatum *pdatum)
+{
+ void_function pfunc = NULL;
+ BYTE *userp = NULL;
+
+ /* Need to deal with Delta Timestamps here before calling client CB */
+ if (XETrapGetTCFlagDeltaTimes(tc))
+ {
+ CARD32 last_time = XETrapGetTCTime(tc);
+ if (XETrapHeaderIsEvent(&pdatum->hdr))
+ { /* then we can play with the timestamps */
+ pdatum->hdr.timestamp =
+ pdatum->u.event.u.keyButtonPointer.time;
+ }
+ else
+ { /*
+ * the current one from GetTimeInMillis is worthless
+ * as it's only updated during event instances (e.g. not
+ * wall clock).
+ */
+ pdatum->hdr.timestamp = last_time;
+ }
+ if (!pdatum->hdr.timestamp)
+ { /* for dual monitor bug */
+ pdatum->hdr.timestamp = last_time;
+ }
+ if (!last_time)
+ { /* first one! Prime it! */
+ last_time = pdatum->hdr.timestamp;
+ }
+ tc->values.last_time = pdatum->hdr.timestamp; /* no macro! */
+ if (pdatum->hdr.timestamp < last_time)
+ { /* for clock rollover */
+ pdatum->hdr.timestamp = 0;
+ }
+ else
+ { /* the real delta */
+ pdatum->hdr.timestamp = pdatum->hdr.timestamp - last_time;
+ }
+ }
+ /* Get the user supplied callback function */
+ if (XETrapHeaderIsEvent(&pdatum->hdr))
+ {
+ pfunc = tc->values.evt_cb[pdatum->u.event.u.u.type].func;
+ userp = tc->values.evt_cb[pdatum->u.event.u.u.type].data;
+ }
+ else if (XETrapHeaderIsRequest(&pdatum->hdr) ||
+ XETrapHeaderIsReply(&pdatum->hdr))
+ {
+ pfunc = tc->values.req_cb[pdatum->u.req.reqType].func;
+ userp = tc->values.req_cb[pdatum->u.req.reqType].data;
+ }
+
+ /* If there is a callback then call it with the data */
+ if (pfunc != NULL)
+ {
+ (*pfunc)(tc,pdatum,userp);
+ }
+}
+
+Boolean XETrapDispatchXLib(XETrapDataEvent *event, XETC *tc)
+{
+ memcpy(&tc->xbuff[event->idx*sz_EventData], event->data, sz_EventData);
+
+ if (event->detail == XETrapDataLast)
+ {
+ XETrapDispatchCB(tc, (XETrapDatum *)tc->xbuff);
+ }
+ return True;
+}
diff --git a/nx-X11/lib/XTrap/XEPrInfo.c b/nx-X11/lib/XTrap/XEPrInfo.c
new file mode 100644
index 000000000..908ca3ad9
--- /dev/null
+++ b/nx-X11/lib/XTrap/XEPrInfo.c
@@ -0,0 +1,274 @@
+/* $XFree86$ */
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991, 1994 by Digital Equipment Corp.,
+Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+#include <X11/Xos.h>
+#include <X11/Xlib.h>
+#include <X11/extensions/xtraplib.h>
+#include <X11/extensions/xtraplibp.h>
+
+#ifndef TRUE
+# define TRUE 1L
+#endif
+#ifndef FALSE
+# define FALSE 0L
+#endif
+
+void XEPrintRelease( FILE *ofp, XETrapGetAvailRep *pavail)
+{
+
+ fprintf(ofp,"\tRelease: %d.%d-%d\n", XETrapGetAvailRelease(pavail),
+ XETrapGetAvailVersion(pavail), XETrapGetAvailRevision(pavail));
+}
+void XEPrintTkRelease( FILE *ofp, XETC *tc)
+{
+ fprintf(ofp,"\tRelease: %d.%d-%d\n", XEGetRelease(tc), XEGetVersion(tc),
+ XEGetRevision(tc));
+}
+
+void XEPrintPlatform( FILE *ofp, XETrapGetAvailRep *pavail)
+{
+ fprintf(ofp,"\tPlatform: %s (0x%02x)\n",
+ XEPlatformIDToString(XETrapGetAvailPFIdent(pavail)),
+ (int)XETrapGetAvailPFIdent(pavail));
+}
+
+void XEPrintAvailFlags( FILE *ofp, XETrapGetAvailRep *pavail)
+{
+
+ CARD8 f[4L];
+
+ XETrapGetAvailFlags(pavail,f);
+ fprintf(ofp,"\tFlags: ");
+ if (XETrapGetAvailFlagTimestamp(pavail)) fputs("Timestamps ", ofp);
+ if (XETrapGetAvailFlagCmd(pavail)) fputs("CmdKey ", ofp);
+ if (XETrapGetAvailFlagCmdKeyMod(pavail)) fputs("CmdKeyMod ", ofp);
+ if (XETrapGetAvailFlagRequest(pavail)) fputs("Requests ", ofp);
+ if (XETrapGetAvailFlagEvent(pavail)) fputs("Events ", ofp);
+ if (XETrapGetAvailFlagMaxPacket(pavail)) fputs("MaxPkt ", ofp);
+ if (XETrapGetAvailFlagStatistics(pavail)) fputs("Statistics ", ofp);
+ if (XETrapGetAvailFlagWinXY(pavail)) fputs("WinXY ", ofp);
+ if (XETrapGetAvailFlagCursor(pavail)) fputs("Cursor ", ofp);
+ if (XETrapGetAvailFlagXInput(pavail)) fputs("XInput ", ofp);
+ if (XETrapGetAvailFlagVecEvt(pavail)) fputs("Vect_Evnts ", ofp);
+ if (XETrapGetAvailFlagColorReplies(pavail)) fputs("ColorRep ", ofp);
+ if (XETrapGetAvailFlagGrabServer(pavail)) fputs("GrabServer ", ofp);
+ fprintf(ofp," (0x%02x%02x%02x%02x)\n", f[0], f[1], f[2], f[3]);
+}
+
+void XEPrintAvailPktSz( FILE *ofp, XETrapGetAvailRep *pavail)
+{
+
+ fprintf(ofp,"\tMax Packet Size: %d\n", XETrapGetAvailMaxPktSize(pavail));
+}
+void XEPrintStateFlags( FILE *ofp, XETrapGetCurRep *pcur)
+{
+
+ CARD8 f[2];
+ XETrapGetCurSFlags(pcur, f);
+ fputs("\tFlags: ",ofp);
+ if (BitIsTrue(f,XETrapTrapActive)) fputs("I/O Active ", ofp);
+ fprintf(ofp," (0x%02x%02x)\n", f[0], f[1]);
+}
+
+void XEPrintMajOpcode( FILE *ofp, XETrapGetAvailRep *pavail)
+{
+
+ fprintf(ofp,"\tMajor Opcode: %d\n", (int)XETrapGetAvailOpCode(pavail));
+}
+void XEPrintCurXY( FILE *ofp, XETrapGetAvailRep *pavail)
+{
+
+ fprintf(ofp,"\tCurrent (x,y): (%d,%d)\n", XETrapGetCurX(pavail),
+ XETrapGetCurY(pavail));
+}
+
+void XEPrintTkFlags( FILE *ofp, XETC *tc)
+{
+
+ CARD8 f[2];
+ XETrapGetTCLFlags(tc, f);
+ fputs("\tFlags: ",ofp);
+ if (XETrapGetTCFlagDeltaTimes(tc)) fputs("Delta Times ", ofp);
+ if (XETrapGetTCFlagTrapActive(tc)) fputs("Trap Active ", ofp);
+ fprintf(ofp," (0x%02x%02x)\n", f[0], f[1]);
+}
+
+void XEPrintLastTime( FILE *ofp, XETC *tc)
+{
+
+ fprintf(ofp,"\tLast Relative Time: %d\n", (int)XETrapGetTCTime(tc));
+}
+
+void XEPrintCfgFlags( FILE *ofp, XETrapGetCurRep *pcur)
+{
+
+ CARD8 f[4L];
+
+ XETrapGetCurCFlags(pcur,data,f);
+ fprintf(ofp,"\tFlags: ");
+ if (XETrapGetCurFlagTimestamp(pcur,data)) fputs("Timestamps ", ofp);
+ if (XETrapGetCurFlagCmd(pcur,data)) fputs("CmdKey ", ofp);
+ if (XETrapGetCurFlagCmdKeyMod(pcur,data)) fputs("CmdKeyMod ", ofp);
+ if (XETrapGetCurFlagRequest(pcur,data)) fputs("Requests ", ofp);
+ if (XETrapGetCurFlagEvent(pcur,data)) fputs("Events ", ofp);
+ if (XETrapGetCurFlagMaxPacket(pcur,data)) fputs("MaxPkt ", ofp);
+ if (XETrapGetCurFlagStatistics(pcur,data)) fputs("Statistics ", ofp);
+ if (XETrapGetCurFlagWinXY(pcur,data)) fputs("WinXY ", ofp);
+ if (XETrapGetCurFlagCursor(pcur,data)) fputs("Cursor ", ofp);
+ if (XETrapGetCurFlagXInput(pcur,data)) fputs("XInput ", ofp);
+ if (XETrapGetCurFlagColorReplies(pcur,data)) fputs("ColorReplies ", ofp);
+ if (XETrapGetCurFlagGrabServer(pcur,data)) fputs("GrabServer ", ofp);
+ fprintf(ofp," (0x%02x%02x%02x%02x)\n", f[0], f[1], f[2], f[3]);
+}
+
+void XEPrintRequests( FILE *ofp, XETrapGetCurRep *pcur)
+{
+
+ long i;
+ fprintf(ofp,"\tX Requests: ");
+ for (i=0L; i<=XETrapMaxRequest-1; i++)
+ { /* Not using the macro cause we're doing things
+ * a byte at a time rather than a bit.
+ */
+ fprintf(ofp,"%02x ", pcur->config.flags.req[i]);
+ if ((i+1L)%4L == 0L)
+ {
+ fprintf(ofp," ");
+ }
+ if ((i+1L)%16L == 0L)
+ {
+ fprintf(ofp,"\n\t\t ");
+ }
+ }
+ fprintf(ofp,"\n");
+}
+
+void XEPrintEvents( FILE *ofp, XETrapGetCurRep *pcur)
+{
+
+ int i;
+ fprintf(ofp,"\tX Events: ");
+ for (i=0L; i<XETrapMaxEvent; i++)
+ { /* Not using the macro cause we're doing things
+ * a byte at a time rather than a bit.
+ */
+ fprintf(ofp,"%02x ", pcur->config.flags.event[i]);
+ if ((i+1L)%4L == 0L)
+ {
+ fprintf(ofp," ");
+ }
+ if ((i+1L)%16L == 0L)
+ {
+ fprintf(ofp,"\n\t\t ");
+ }
+ }
+ fprintf(ofp,"\n");
+}
+
+void XEPrintCurPktSz( FILE *ofp, XETrapGetCurRep *pcur)
+{
+
+ fprintf(ofp,"\tMax Packet Size: %d\n", XETrapGetCurMaxPktSize(pcur));
+}
+
+void XEPrintCmdKey( FILE *ofp, XETrapGetCurRep *pcur)
+{
+
+ fprintf(ofp,"\tcmd_key: 0x%02x\n", XETrapGetCurCmdKey(pcur));
+}
+
+void XEPrintEvtStats( FILE *ofp, XETrapGetStatsRep *pstats, XETC *tc)
+{
+
+ int i;
+ fprintf(ofp,"\tX Events:\n");
+ for (i=0; i<XETrapCoreEvents; i++)
+ {
+ if (XETrapGetStatsEvt(pstats,i))
+ {
+ fprintf(ofp,"\t %-20s : %d\n", XEEventIDToString(i,tc),
+ (int)XETrapGetStatsEvt(pstats,i));
+ }
+ }
+ fprintf(ofp,"\n");
+}
+
+void XEPrintReqStats( FILE *ofp, XETrapGetStatsRep *pstats, XETC *tc)
+{
+
+ int i;
+ fprintf(ofp,"\tX Requests:\n");
+ for (i=0L; i<256L; i++)
+ {
+ if (XETrapGetStatsReq(pstats,i))
+ {
+ fprintf(ofp,"\t %-20s : %d\n", XERequestIDToString(i,tc),
+ (int)XETrapGetStatsReq(pstats,i));
+ }
+ }
+ fprintf(ofp,"\n");
+}
+
+
+void XEPrintAvail( FILE *ofp, XETrapGetAvailRep *pavail)
+{
+
+ fprintf(ofp,"Available Information:\n");
+ XEPrintRelease(ofp, pavail);
+ XEPrintPlatform(ofp, pavail);
+ XEPrintMajOpcode(ofp, pavail);
+ XEPrintAvailFlags(ofp, pavail);
+ XEPrintAvailPktSz(ofp, pavail);
+ XEPrintCurXY(ofp, pavail);
+ return;
+}
+
+void XEPrintTkState( FILE *ofp, XETC *tc)
+{
+
+ fprintf(ofp,"Toolkit State:\n");
+ XEPrintTkFlags(ofp, tc);
+ XEPrintLastTime(ofp, tc);
+ XEPrintTkRelease(ofp, tc);
+}
+
+void XEPrintCurrent( FILE *ofp, XETrapGetCurRep *pcur)
+{
+
+ fprintf(ofp,"Current State:\n");
+ XEPrintStateFlags(ofp, pcur);
+ fprintf(ofp,"Current Config:\n");
+ XEPrintCfgFlags(ofp, pcur);
+ XEPrintRequests(ofp, pcur);
+ XEPrintEvents(ofp, pcur);
+ XEPrintCurPktSz(ofp, pcur);
+ XEPrintCmdKey(ofp, pcur);
+}
+
+void XEPrintStatistics( FILE *ofp, XETrapGetStatsRep *pstats, XETC *tc)
+{
+
+ fprintf(ofp,"Statistics:\n");
+ XEPrintEvtStats(ofp, pstats, tc);
+ XEPrintReqStats(ofp, pstats, tc);
+}
+
diff --git a/nx-X11/lib/XTrap/XERqsts.c b/nx-X11/lib/XTrap/XERqsts.c
new file mode 100644
index 000000000..dbecea33a
--- /dev/null
+++ b/nx-X11/lib/XTrap/XERqsts.c
@@ -0,0 +1,412 @@
+/* $XFree86$ */
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991 by Digital Equipment Corp., Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+#ifndef NO_DEC_ADDED_VALUE
+#ifdef SMT
+#define NEED_EVENTS
+#define NEED_REPLIES
+#endif
+#include <X11/Xlib.h>
+#define NEED_REPLIES
+#define NEED_EVENTS
+#include <X11/Xproto.h>
+#else /* NO_DEC_BUG_FIX */
+#include <X11/Xlib.h>
+#define NEED_REPLIES
+#define NEED_EVENTS
+#include <X11/Xproto.h>
+#endif /* NO_DEC_BUG_FIX */
+/* the following's a hack to support V3.1 protocol */
+#if defined(__STDC__) && !defined(UNIXCPP)
+#define GetOldReq(name, req, old_length) \
+ WORD64ALIGN\
+ if ((dpy->bufptr + SIZEOF(x##name##Req)) > dpy->bufmax)\
+ _XFlush(dpy);\
+ req = (x##name##Req *)(dpy->last_req = dpy->bufptr);\
+ req->reqType = X_##name;\
+ req->length = old_length>>2;\
+ dpy->bufptr += old_length;\
+ dpy->request++
+
+#else /* non-ANSI C uses empty comment instead of "##" for token concat */
+#define GetOldReq(name, req, old_length) \
+ WORD64ALIGN\
+ if ((dpy->bufptr + SIZEOF(x/**/name/**/Req)) > dpy->bufmax)\
+ _XFlush(dpy);\
+ req = (x/**/name/**/Req *)(dpy->last_req = dpy->bufptr);\
+ req->reqType = X_/**/name;\
+ req->length = old_length>>2;\
+ dpy->bufptr += old_length;\
+ dpy->request++
+#endif
+
+#ifndef vms
+#include <X11/Xlibint.h>
+#else /* vms */
+#define SyncHandle() \
+ if (dpy->synchandler) (*dpy->synchandler)(dpy)
+/*
+ * LockDisplay uses an undocumented feature in V5 of VMS that allows
+ * disabling ASTs without calling $SETAST. A bit is set in P1 space
+ * that disables a user mode AST from being delivered to this process.
+ *
+ */
+#define LockDisplay(dis) \
+{ globalref char ctl$gb_soft_ast_disable; \
+ globalref char ctl$gb_lib_lock; \
+ globalref short ctl$gw_soft_ast_lock_depth; \
+ if ( ctl$gb_soft_ast_disable == 0 ) { \
+ ctl$gb_soft_ast_disable = 1; \
+ ctl$gb_lib_lock = 1; \
+ ctl$gw_soft_ast_lock_depth = 1; \
+ } \
+ else ctl$gw_soft_ast_lock_depth++; \
+}
+
+/*
+ * UnlockDisplay clears the AST disable bit, then checks to see if an
+ * AST delivery attempt was made during the critical section. If so,
+ * reenable_ASTs is set, and $SETAST must be called to turn AST delivery
+ * back on.
+ *
+ * Note that it assumed that LockDisplay and UnlockDisplay appear in
+ * matched sets within a single routine.
+ */
+#define UnlockDisplay(dis) \
+{ globalref char ctl$gb_reenable_asts; \
+ globalref char ctl$gb_soft_ast_disable; \
+ globalref char ctl$gb_lib_lock; \
+ globalref short ctl$gw_soft_ast_lock_depth; \
+ if (!--ctl$gw_soft_ast_lock_depth) \
+ if ( ctl$gb_lib_lock ) { \
+ ctl$gb_lib_lock = 0; \
+ ctl$gb_soft_ast_disable = 0; \
+ if (ctl$gb_reenable_asts != 0) \
+ sys$setast(1); \
+ } \
+}
+
+#define WORD64ALIGN
+#if defined(__STDC__) && !defined(UNIXCPP)
+#define GetReq(name, req) \
+ WORD64ALIGN\
+ if ((dpy->bufptr + SIZEOF(x##name##Req)) > dpy->bufmax)\
+ _XFlush(dpy);\
+ req = (x##name##Req *)(dpy->last_req = dpy->bufptr);\
+ req->reqType = X_##name;\
+ req->length = (SIZEOF(x##name##Req))>>2;\
+ dpy->bufptr += SIZEOF(x##name##Req);\
+ dpy->request++
+
+#else /* non-ANSI C uses empty comment instead of "##" for token concat */
+#define GetReq(name, req) \
+ WORD64ALIGN\
+ if ((dpy->bufptr + SIZEOF(x/**/name/**/Req)) > dpy->bufmax)\
+ _XFlush(dpy);\
+ req = (x/**/name/**/Req *)(dpy->last_req = dpy->bufptr);\
+ req->reqType = X_/**/name;\
+ req->length = (SIZEOF(x/**/name/**/Req))>>2;\
+ dpy->bufptr += SIZEOF(x/**/name/**/Req);\
+ dpy->request++
+#endif
+#endif /* vms */
+
+#include <X11/extensions/xtraplib.h>
+#include <X11/extensions/xtraplibp.h>
+
+/* Returns the all important protocol number to be used.
+ * The only request guaranteed to be of the same request/reply
+ * size is XEGetVersionRequest. All others need the protocol
+ * number to determine how to communicate.
+ * Unfortunately, this was broken for V3.1 so GetAvailable will
+ * have to be used to determine the protocol version.
+ */
+int XEGetVersionRequest(XETC *tc, XETrapGetVersRep *ret)
+{
+ int status = True;
+ Display *dpy = tc->dpy;
+ CARD32 X_XTrapGet = tc->extOpcode;
+ xXTrapGetReq *reqptr;
+ xXTrapGetVersReply rep;
+ int numlongs = (SIZEOF(xXTrapGetVersReply) -
+ SIZEOF(xReply) + SIZEOF(CARD32) -1 ) / SIZEOF(CARD32);
+ LockDisplay(dpy);
+ GetReq(XTrapGet,reqptr);
+ reqptr->minor_opcode = XETrap_GetVersion;
+ reqptr->protocol = XETrapProtocol;
+ status = _XReply(dpy,(xReply *)&rep,numlongs,xTrue);
+ SyncHandle();
+ UnlockDisplay(dpy);
+ memcpy((char *)ret,&(rep.data),sizeof(XETrapGetVersRep));
+ return(status);
+}
+
+int XEGetAvailableRequest(XETC *tc, XETrapGetAvailRep *ret)
+{
+ int status = True;
+ Display *dpy = tc->dpy;
+ CARD32 X_XTrapGet = tc->extOpcode;
+ xXTrapGetReq *reqptr;
+ xXTrapGetAvailReply rep;
+ int numlongs = (SIZEOF(xXTrapGetAvailReply) -
+ SIZEOF(xReply) + SIZEOF(CARD32) -1 ) / SIZEOF(CARD32);
+ LockDisplay(dpy);
+ GetReq(XTrapGet,reqptr);
+ reqptr->minor_opcode = XETrap_GetAvailable;
+ reqptr->protocol = XETrapProtocol;
+ status = _XReply(dpy,(xReply *)&rep,numlongs,xTrue);
+ SyncHandle();
+ UnlockDisplay(dpy);
+ memcpy((char *)ret,&(rep.data),sizeof(XETrapGetAvailRep));
+ return(status);
+}
+
+/* should not be called directly by clients */
+static int XEConfigRequest(XETC *tc)
+{ /* protocol changed between V3.1 and V3.2! */
+ int status = True;
+ Display *dpy = tc->dpy;
+ CARD32 X_XTrapConfig = tc->extOpcode;
+ xXTrapConfigReq *reqptr;
+ if (tc->protocol == 31)
+ { /* hack to allocate the old request length */
+ GetOldReq(XTrapConfig,reqptr,276);
+ }
+ else
+ {
+ GetReq(XTrapConfig,reqptr);
+ }
+ reqptr->minor_opcode = XETrap_Config;
+
+ memcpy((char *)reqptr->config_flags_valid,
+ (char *)tc->values.v.flags.valid,4);
+ memcpy((char *)reqptr->config_flags_data,
+ (char *)tc->values.v.flags.data,4);
+ memcpy((char *)reqptr->config_flags_req,
+ (char *)tc->values.v.flags.req,XETrapMaxRequest);
+ memcpy((char *)reqptr->config_flags_event,
+ (char *)tc->values.v.flags.event,XETrapMaxEvent);
+ reqptr->config_max_pkt_size=tc->values.v.max_pkt_size;
+ reqptr->config_cmd_key=tc->values.v.cmd_key;
+
+ XFlush(dpy);
+ SyncHandle();
+ tc->dirty = 0L; /* Configuration is no longer dirty */
+ return(status);
+}
+
+/* Flush out any pending configuration */
+int XEFlushConfig(XETC *tc)
+{
+ return((tc->dirty) ? XEConfigRequest(tc) : True);
+}
+int XEResetRequest(XETC *tc)
+{
+ int status = True;
+ Display *dpy = tc->dpy;
+ CARD32 X_XTrap = tc->extOpcode;
+ xXTrapReq *reqptr;
+ status = XEFlushConfig(tc); /* Flushout any pending configuration first */
+ if (status == True)
+ {
+ GetReq(XTrap,reqptr);
+ reqptr->minor_opcode = XETrap_Reset;
+ XFlush(dpy);
+ SyncHandle();
+ }
+ return(status);
+}
+
+
+int XEGetLastInpTimeRequest(XETC *tc, XETrapGetLastInpTimeRep *ret)
+{ /* this was broken in V3.1! */
+ int status = True;
+ Display *dpy = tc->dpy;
+ CARD32 X_XTrap = tc->extOpcode;
+ xXTrapReq *reqptr;
+ xXTrapGetLITimReply rep;
+ int numlongs = (SIZEOF(xXTrapGetLITimReply) -
+ SIZEOF(xReply) + SIZEOF(CARD32) - 1) / SIZEOF(CARD32);
+ LockDisplay(dpy);
+ GetReq(XTrap,reqptr);
+ reqptr->minor_opcode = XETrap_GetLastInpTime;
+ status = _XReply(dpy,(xReply *)&rep,numlongs,xTrue);
+ SyncHandle();
+ UnlockDisplay(dpy);
+
+ ret->last_time=rep.data_last_time;
+
+ return(status);
+}
+
+int XEStartTrapRequest(XETC *tc)
+{
+ int status = True;
+ Display *dpy = tc->dpy;
+ CARD32 X_XTrap = tc->extOpcode;
+ xXTrapReq *reqptr;
+ status = XEFlushConfig(tc); /* Flushout any pending configuration first */
+ if (status == True)
+ {
+ /* Add our event handler for the XLib transport */
+ XETrapSetEventHandler(tc, XETrapData, XETrapDispatchXLib);
+ GetReq(XTrap,reqptr);
+ reqptr->minor_opcode = XETrap_StartTrap;
+ XFlush(dpy);
+ SyncHandle();
+ BitTrue(tc->values.tc_flags, XETCTrapActive);
+ }
+ return(status);
+}
+int XEStopTrapRequest(XETC *tc)
+{
+ int status = True;
+ Display *dpy = tc->dpy;
+ CARD32 X_XTrap = tc->extOpcode;
+ xXTrapReq *reqptr;
+ status = XEFlushConfig(tc); /* Flushout any pending configuration first */
+ if (status == True)
+ {
+ GetReq(XTrap,reqptr);
+ reqptr->minor_opcode = XETrap_StopTrap;
+ XFlush(dpy);
+ SyncHandle();
+ BitFalse(tc->values.tc_flags, XETCTrapActive);
+ /* Remove our event handler for the XLib transport */
+ XETrapSetEventHandler(tc, XETrapData, NULL);
+ }
+
+ return(status);
+}
+
+#ifndef _XINPUT
+int XESimulateXEventRequest(XETC *tc, CARD8 type, CARD8 detail,
+ CARD16 x, CARD16 y, CARD8 screen)
+{
+ int status = True;
+ Display *dpy = tc->dpy;
+ CARD32 X_XTrapInput = tc->extOpcode;
+ xXTrapInputReq *reqptr;
+ status = XEFlushConfig(tc); /* Flushout any pending configuration first */
+ if (status == True)
+ { /* write out the input event */
+ GetReq(XTrapInput,reqptr);
+ reqptr->minor_opcode = XETrap_SimulateXEvent;
+ reqptr->input.type = type;
+ reqptr->input.detail = detail;
+ reqptr->input.x = x;
+ reqptr->input.y = y;
+ reqptr->input.screen = screen;
+ XFlush(dpy);
+ }
+ return(status);
+}
+#endif
+int XEGetCurrentRequest(XETC *tc, XETrapGetCurRep *ret)
+{
+ int status = True;
+ Display *dpy = tc->dpy;
+ CARD32 X_XTrap = tc->extOpcode;
+ xXTrapReq *reqptr;
+ xXTrapGetCurReply rep;
+ int numlongs = (SIZEOF(xXTrapGetCurReply) -
+ SIZEOF(xReply) + SIZEOF(CARD32) -1 ) / SIZEOF(CARD32);
+ status = XEFlushConfig(tc); /* Flushout any pending configuration first */
+ if (status == True)
+ {
+ LockDisplay(dpy);
+ GetReq(XTrap,reqptr);
+ reqptr->minor_opcode = XETrap_GetCurrent;
+ /* to support comm. w/ V3.1 extensions */
+ if (tc->protocol == 31)
+ {
+ char tmp[284]; /* need space for the big *old* reply */
+ numlongs = (284-sizeof(xReply)+sizeof(long)-1)/sizeof(long);
+ status = _XReply(dpy,(xReply *)tmp,numlongs,xTrue);
+ memcpy(&rep,tmp,sizeof(rep)); /* move just what's needed */
+ }
+ else
+ {
+ status = _XReply(dpy,(xReply *)&rep,numlongs,xTrue);
+ }
+ SyncHandle();
+ UnlockDisplay(dpy);
+
+ memcpy((char *)ret->state_flags,rep.data_state_flags,2);
+ memcpy((char *)ret->config.flags.valid,rep.data_config_flags_valid,4);
+ memcpy((char *)ret->config.flags.data,rep.data_config_flags_data,4);
+ memcpy((char *)ret->config.flags.req,rep.data_config_flags_req,
+ XETrapMaxRequest);
+ memcpy((char *)ret->config.flags.event,rep.data_config_flags_event,
+ XETrapMaxEvent);
+ ret->config.max_pkt_size=rep.data_config_max_pkt_size;
+ ret->config.cmd_key=rep.data_config_cmd_key;
+
+ }
+ return(status);
+}
+
+int XEGetStatisticsRequest(XETC *tc, XETrapGetStatsRep *ret)
+{
+ int status = True;
+ Display *dpy = tc->dpy;
+ CARD32 X_XTrap = tc->extOpcode;
+ xXTrapReq *reqptr;
+ xXTrapGetStatsReply rep;
+ status = XEFlushConfig(tc); /* Flushout any pending configuration first */
+ if (status == True)
+ {
+ LockDisplay(dpy);
+ GetReq(XTrap,reqptr);
+ reqptr->minor_opcode = XETrap_GetStatistics;
+ /* to support comm. w/ V3.1 extensions */
+#ifndef CRAY
+ if (tc->protocol == 31)
+ { /* this is the way we used to do it which breaks Cray's */
+#ifndef VECTORED_EVENTS
+ int numlongs = (1060-sizeof(xReply)+sizeof(long)-1)/sizeof(long);
+#else
+ int numlongs = (1544-sizeof(xReply)+sizeof(long)-1)/sizeof(long);
+#endif
+ status = _XReply(dpy,(xReply *)&rep,numlongs,xTrue);
+ if (status == True)
+ { /* need to shift it back into the data struct */
+ xXTrapGetStatsReply tmp;
+ tmp = rep;
+ memcpy(&(rep.data),&(tmp.pad0), sizeof(rep.data));
+ }
+ }
+ else
+#endif /* CRAY */
+ { /* this is the way we do it for V3.2 */
+ int numbytes = SIZEOF(xXTrapGetStatsReply) - SIZEOF(xReply);
+ status = _XReply(dpy, (xReply *)&rep, 0, xFalse);
+ if (status == True)
+ {
+ status = _XRead(dpy, (char *)&rep.data, numbytes);
+ }
+ }
+ SyncHandle();
+ UnlockDisplay(dpy);
+ memcpy(ret,&(rep.data),sizeof(XETrapGetStatsRep));
+ }
+ return(status);
+}
diff --git a/nx-X11/lib/XTrap/XEStrMap.c b/nx-X11/lib/XTrap/XEStrMap.c
new file mode 100644
index 000000000..2a97f13f4
--- /dev/null
+++ b/nx-X11/lib/XTrap/XEStrMap.c
@@ -0,0 +1,284 @@
+/* $XFree86: xc/lib/XTrap/XEStrMap.c,v 1.1 2001/11/02 23:29:27 dawes Exp $ */
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991, 1992, 1994 by Digital Equipment Corp.,
+Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+#include <stdio.h>
+#include <X11/Xlib.h>
+#include <X11/extensions/xtraplib.h>
+#include <X11/extensions/xtraplibp.h>
+
+static char *eventName[] = {
+ "", "",
+ "KeyPress", "KeyRelease", "ButtonPress",
+ "ButtonRelease", "MotionNotify", "EnterNotify",
+ "LeaveNotify", "FocusIn", "FocusOut",
+ "KeymapNotify", "Expose", "GraphicsExpose",
+ "NoExpose", "VisibilityNotify", "CreateNotify",
+ "DestroyNotify", "UnmapNotify", "MapNotify",
+ "MapRequest", "ReparentNotify", "ConfigureNotify",
+ "ConfigureRequest", "GravityNotify", "ResizeRequest",
+ "CirculateNotify", "CirculateRequest", "PropertyNotify",
+ "SelectionClear", "SelectionRequest", "SelectionNotify",
+ "ColormapNotify", "ClientMessage", "MappingNotify",
+ "LASTEvent",
+};
+
+static char *requestName[] = {
+ "Invalid",
+ "X_CreateWindow", "X_ChangeWindowAttributes",
+ "X_GetWindowAttributes", "X_DestroyWindow",
+ "X_DestroySubwindows", "X_ChangeSaveSet",
+ "X_ReparentWindow", "X_MapWindow",
+ "X_MapSubwindows", "X_UnmapWindow",
+ "X_UnmapSubwindows", "X_ConfigureWindow",
+ "X_CirculateWindow", "X_GetGeometry",
+ "X_QueryTree", "X_InternAtom",
+ "X_GetAtomName", "X_ChangeProperty",
+ "X_DeleteProperty", "X_GetProperty",
+ "X_ListProperties", "X_SetSelectionOwner",
+ "X_GetSelectionOwner", "X_ConvertSelection",
+ "X_SendEvent", "X_GrabPointer",
+ "X_UngrabPointer", "X_GrabButton",
+ "X_UngrabButton", "X_ChangeActivePointerGrab",
+ "X_GrabKeyboard", "X_UngrabKeyboard",
+ "X_GrabKey", "X_UngrabKey",
+ "X_AllowEvents", "X_GrabServer",
+ "X_UngrabServer", "X_QueryPointer",
+ "X_GetMotionEvents", "X_TranslateCoords",
+ "X_WarpPointer", "X_SetInputFocus",
+ "X_GetInputFocus", "X_QueryKeymap",
+ "X_OpenFont", "X_CloseFont",
+ "X_QueryFont", "X_QueryTextExtents",
+ "X_ListFonts", "X_ListFontsWithInfo",
+ "X_SetFontPath", "X_GetFontPath",
+ "X_CreatePixmap", "X_FreePixmap",
+ "X_CreateGC", "X_ChangeGC",
+ "X_CopyGC", "X_SetDashes",
+ "X_SetClipRectangles", "X_FreeGC",
+ "X_ClearArea", "X_CopyArea",
+ "X_CopyPlane", "X_PolyPoint",
+ "X_PolyLine", "X_PolySegment",
+ "X_PolyRectangle", "X_PolyArc",
+ "X_FillPoly", "X_PolyFillRectangle",
+ "X_PolyFillArc", "X_PutImage",
+ "X_GetImage", "X_PolyText8",
+ "X_PolyText16", "X_ImageText8",
+ "X_ImageText16", "X_CreateColormap",
+ "X_FreeColormap", "X_CopyColormapAndFree",
+ "X_InstallColormap", "X_UninstallColormap",
+ "X_ListInstalledColormaps", "X_AllocColor",
+ "X_AllocNamedColor", "X_AllocColorCells",
+ "X_AllocColorPlanes", "X_FreeColors",
+ "X_StoreColors", "X_StoreNamedColor",
+ "X_QueryColors", "X_LookupColor",
+ "X_CreateCursor", "X_CreateGlyphCursor",
+ "X_FreeCursor", "X_RecolorCursorSize",
+ "X_QueryBestSize", "X_QueryExtension",
+ "X_ListExtensions", "X_ChangeKeyboardMapping",
+ "X_GetKeyboardMapping", "X_ChangeKeyboardControl",
+ "X_GetKeyboardControl", "X_Bell",
+ "X_ChangePointerControl", "X_GetPointerControl",
+ "X_SetScreenSaver", "X_GetScreenSaver",
+ "X_ChangeHosts", "X_ListHosts",
+ "X_SetAccessControl", "X_SetCloseDownMode",
+ "X_KillClient", "X_RotateProperties",
+ "X_ForceScreenSaver", "X_SetPointerMapping",
+ "X_GetPointerMapping", "X_SetModifierMapping",
+ "X_GetModifierMapping", "Invalid",
+ "Invalid", "Invalid",
+ "Invalid", "Invalid",
+ "Invalid", "Invalid",
+ "X_NoOperation",
+};
+
+typedef struct
+{
+ char *extName;
+ int extEvent;
+} _extensionData;
+_extensionData *extensionData;
+int numExtension = -1;
+
+static struct _pf_tbl {CARD32 id; char *str;} pf_tbl[] =
+{
+ {PF_Apollo, "Apollo"},
+ {PF_ATT, "ATT"},
+ {PF_Cray1, "Cray1"},
+ {PF_Cray2, "Cray2"},
+ {PF_DECUltrix, "DECUltrix"},
+ {PF_DECVMS, "DECVMS"},
+ {PF_DECELN, "DECELN"},
+ {PF_DECOSF1, "DECOSF1"},
+ {PF_DECVT1000, "DECVT1000"},
+ {PF_DECXTerm, "DECXTerm"},
+ {PF_HP9000s800, "HP9000s800"},
+ {PF_HP9000s300, "HP9000s300"},
+ {PF_IBMAT, "IBMAT"},
+ {PF_IBMRT, "IBMRT"},
+ {PF_IBMPS2, "IBMPS2"},
+ {PF_IBMRS, "IBMRS"},
+ {PF_MacII, "MacII"},
+ {PF_Pegasus, "Pegasus"},
+ {PF_SGI, "SGI"},
+ {PF_Sony, "Sony"},
+ {PF_Sun3, "Sun3"},
+ {PF_Sun386i, "Sun386i"},
+ {PF_SunSparc, "SunSparc"},
+ {PF_Other, "Other"} /* always the last one! */
+};
+
+static char unknown[] = "unknown";
+
+#define ASize(array) (sizeof(array)/sizeof((array)[0]))
+
+static INT16 _StringToID(register char *match, register char **strings,
+ INT16 nstrings)
+{
+ register INT16 id = nstrings;
+
+ if (match && *match)
+ { while ((--id >= 0L) && (strcmp(match,strings[id]) != 0L)); }
+ else
+ { id = -1L; }
+
+ return(id);
+}
+static void loadExtStrings(XETC *tc)
+{
+ char **extensionName=XListExtensions(tc->dpy,&numExtension);
+ if (numExtension)
+ {
+ int i;
+ extensionData = (_extensionData *)XtCalloc(numExtension,
+ sizeof(_extensionData));
+ for (i = 0; i < numExtension; i++)
+ { /* Arrange extensions in opcode order */
+ int opcode,event,error;
+ if (XQueryExtension(tc->dpy,extensionName[i],&opcode,&event,
+ &error))
+ {
+ extensionData[opcode-128].extName = extensionName[i];
+ extensionData[opcode-128].extEvent = event;
+ }
+ else
+ { /* This extension didn't load! Error! */
+ extensionData[opcode-128].extName = "Invalid_Extension";
+ }
+ }
+ XFreeExtensionList(extensionName);
+ }
+}
+
+INT16 XEEventStringToID(register char *string)
+{
+ return(_StringToID(string,eventName,ASize(eventName)));
+}
+
+INT16 XERequestStringToID(register char *string)
+{
+ return(_StringToID(string,requestName,ASize(requestName)));
+}
+
+CARD32 XEPlatformStringToID(register char *string)
+{
+ struct _pf_tbl *ptr = &(pf_tbl[0]);
+ while(ptr->id != PF_Other)
+ {
+ if (!strncmp(ptr->str, string, strlen(ptr->str)))
+ {
+ return(ptr->id);
+ }
+ ptr++;
+ }
+ return((!strncmp(ptr->str,string,strlen(ptr->str))) ? ptr->id : -1L);
+}
+
+char *XEEventIDToString(register CARD8 id, XETC *tc)
+{
+ int i;
+ if (id < ASize(eventName))
+ return(eventName[id]);
+ /* either erroneous or an extension event */
+ if (numExtension < 0)
+ { /*
+ * This is unfortunate, but necessary. The client
+ * program has requested the string identifier for
+ * an extension request/event. Since there's no Xlib
+ * equivalent for this, we have to query *all* the
+ * extensions looking for a match. Chances are
+ * if a client wants one, it'll want them all,
+ * so just go through and initialize the extension
+ * list once.
+ */
+ loadExtStrings(tc);
+ }
+ /* Find id within extensionData */
+ for (i=0; i<numExtension; i++)
+ {
+ if (extensionData[i].extEvent == id)
+ return(extensionData[i].extName);
+ }
+ return(unknown);
+}
+
+char *XERequestIDToExtString(register CARD8 id, XETC *tc)
+{
+ int extid;
+
+ extid = id - ASize(requestName);
+
+ if (numExtension < 0)
+ { /*
+ * This is unfortunate, but necessary. The client
+ * program has requested the string identifier for
+ * an extension request/event. Since there's no Xlib
+ * equivalent for this, we have to query *all* the
+ * extensions looking for a match. Chances are
+ * if a client wants one, it'll want them all,
+ * so just go through and initialize the extension
+ * list once.
+ */
+ loadExtStrings(tc);
+ }
+ return((extid >=0 && extid < numExtension) ?
+ extensionData[extid].extName : unknown);
+}
+
+
+char *XERequestIDToString(register CARD8 id, XETC *tc)
+{
+ return((id < ASize(requestName)) ? requestName[id] :
+ XERequestIDToExtString(id,tc));
+}
+
+char *XEPlatformIDToString(register CARD32 id)
+{
+ struct _pf_tbl *ptr = &(pf_tbl[0]);
+ while((ptr->id != PF_Other) || (id == ptr->id))
+ {
+ if (id == ptr->id)
+ {
+ return(ptr->str);
+ }
+ ptr++;
+ }
+ return(unknown);
+}
diff --git a/nx-X11/lib/XTrap/XETrapInit.c b/nx-X11/lib/XTrap/XETrapInit.c
new file mode 100644
index 000000000..a4a04310f
--- /dev/null
+++ b/nx-X11/lib/XTrap/XETrapInit.c
@@ -0,0 +1,218 @@
+/* $XFree86: xc/lib/XTrap/XETrapInit.c,v 1.2 2001/11/08 04:00:12 tsi Exp $ */
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991, 1992 by Digital Equipment Corp.,
+Maynard, MA
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
+ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
+DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
+ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
+WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
+ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
+SOFTWARE.
+
+*****************************************************************************/
+#define NEED_EVENTS
+#define NEED_REPLIES
+
+#include <stdio.h>
+#include <X11/extensions/xtraplib.h>
+#include <X11/extensions/xtraplibp.h>
+#include <X11/extensions/Xext.h>
+#include <X11/extensions/extutil.h>
+
+#ifndef XETrapNumberErrors
+#define XETrapNumberErrors 0
+#endif
+
+#ifdef UWS40
+#define _XSetLastRequestRead _SetLastRequestRead
+#endif
+#ifndef vms
+extern unsigned long _XSetLastRequestRead(Display *dpy, xGenericReply *rep);
+#else
+static unsigned long _XSetLastRequestRead(Display *dpy, xGenericReply *rep);
+#endif
+
+static XExtensionInfo *xtrap_info = NULL;
+static /* const */ char *xtrap_extension_name = XTrapExtName;
+
+#define XTrapCheckExtension(dpy,i,val) \
+ XextCheckExtension(dpy, i, xtrap_extension_name, val)
+#define XTrapSimpleCheckExtension(dpy,i) \
+ XextSimpleCheckExtension(dpy, i, xtrap_extension_name)
+
+static XEXT_CLOSE_DISPLAY_PROTO(close_display);
+static Bool wire_to_event(Display *dpy, XEvent *event, xEvent *wire_ev);
+static Status event_to_wire(Display *dpy, XEvent *event, xEvent *wire_ev);
+
+#ifdef X11R3
+static int error_string();
+#else
+static XEXT_ERROR_STRING_PROTO(error_string);
+#endif
+static /* const */ XExtensionHooks xtrap_extension_hooks = {
+ NULL, /* create_gc */
+ NULL, /* copy_gc */
+ NULL, /* flush_gc */
+ NULL, /* free_gc */
+ NULL, /* create_font */
+ NULL, /* free_font */
+ close_display, /* close_display */
+ wire_to_event, /* wire_to_event */
+ event_to_wire, /* event_to_wire */
+ NULL, /* error */
+ error_string /* error_string */
+};
+
+static /* const */ char *xtrap_error_list[] = {
+ "BadTransport (I/O transport not available)",
+ "BadMailbox (Cannot connect/disconnect to mailbox)",
+ "BadIO (I/O error while reading/writing in extension)",
+ "BadHostname (Cannot locate requested host)",
+ "BadStatistics (Statistics not configured/available)",
+ "BadDevices (Devices not properly vectored)",
+ "BadSocket (Cannot connect to INTERNET socket)",
+ "BadScreen (Cannot send event to given screen)",
+ "BadSwapReq (Cannot trap extension requests for swapped client)",
+};
+
+static XEXT_GENERATE_FIND_DISPLAY (find_display, xtrap_info,
+ xtrap_extension_name,
+ &xtrap_extension_hooks,
+ XETrapNumberEvents, NULL)
+
+static XEXT_GENERATE_CLOSE_DISPLAY (close_display, xtrap_info)
+
+static XEXT_GENERATE_ERROR_STRING (error_string, xtrap_extension_name,
+ XETrapNumErrors, xtrap_error_list)
+
+static Bool event_to_wire(Display *dpy, XEvent *libevent, xEvent *netevent)
+{
+ Bool status = False;
+ XExtDisplayInfo *info = find_display(dpy);
+
+ XTrapCheckExtension(dpy,info,False);
+
+ /* If we had more then one event */
+#if XETrapNumberErrors > 1
+ switch((netevent->u.u.type & 0x7f) - info->codes->first_event)
+ { case XETrapData:
+#endif
+ {
+ XETrapDataEvent *ev = (XETrapDataEvent *) libevent;
+ xETrapDataEvent *event = (xETrapDataEvent *) netevent;
+
+ event->type = ev->type;
+ event->detail = ev->detail;
+ event->sequenceNumber = (ev->serial & 0xFFFF);
+ event->idx = ev->idx;
+ (void)memcpy(event->data,ev->data,sizeof(event->data));
+ status = True;
+ }
+#if XETrapNumberErrors > 1
+ }
+#endif
+ return(status);
+}
+
+static Bool wire_to_event(Display *dpy, XEvent *libevent, xEvent *netevent)
+{
+ Bool status = False;
+ XExtDisplayInfo *info = find_display(dpy);
+
+ XTrapCheckExtension(dpy,info,False);
+
+ /* If we had more then one event */
+#if XETrapNumberErrors > 1
+ switch((netevent->u.u.type & 0x7f) - info->codes->first_event)
+ { case XETrapData:
+#endif
+ {
+ XETrapDataEvent *ev = (XETrapDataEvent *) libevent;
+ xETrapDataEvent *event = (xETrapDataEvent *) netevent;
+
+ ev->type = event->type & 0x7F;
+ ev->detail = event->detail;
+ ev->serial = _XSetLastRequestRead(dpy,(xGenericReply *)netevent);
+ ev->synthetic = ((event->type & 0x80) != 0);
+ ev->display = dpy;
+ ev->idx = event->idx;
+ (void)memcpy(ev->data,event->data,sizeof(ev->data));
+ status = True;
+ }
+#if XETrapNumberErrors > 1
+ }
+#endif
+ return(status);
+}
+
+/*
+ * XETrapQueryExtension -
+ * Returns True if the DEC-XTRAP extension is available
+ * on the given display. If the extension exists, the value of the
+ * first event code is stored into event_base and the value of the first
+ * error code is stored into error_base.
+ */
+Bool XETrapQueryExtension(Display *dpy,INT32 *event_base_return,
+ INT32 *error_base_return, INT32 *opcode_return)
+{
+ Bool status = True;
+ XExtDisplayInfo *info = find_display (dpy);
+
+ if (XextHasExtension (info))
+ {
+ *event_base_return = (INT32)(info->codes->first_event);
+ *error_base_return = (INT32)(info->codes->first_error);
+ *opcode_return = (INT32)(info->codes->major_opcode);
+ }
+ else
+ {
+ status = False;
+ }
+ return(status);
+}
+
+#ifdef vms
+/* Hard-coded since this didn't make it into XLibShr's xfer vector */
+/* From [.XLIBEL.SRC]XLibInt.c in VMS Source Pool */
+unsigned long _XSetLastRequestRead(Display *dpy, xGenericReply *rep)
+{
+ register unsigned long newseq, lastseq;
+
+ /*
+ * KeymapNotify has no sequence number, but is always guaranteed
+ * to immediately follow another event, except when generated via
+ * SendEvent (hmmm).
+ */
+ if ((rep->type & 0x7f) == KeymapNotify)
+ return(dpy->last_request_read);
+
+ newseq = (dpy->last_request_read & ~((unsigned long)0xffff)) |
+ rep->sequenceNumber;
+ lastseq = dpy->last_request_read;
+ while (newseq < lastseq) {
+ newseq += 0x10000;
+ if (newseq > dpy->request) {
+ (void) fprintf (stderr,
+ "Xlib: sequence lost (0x%lx > 0x%lx) in reply type 0x%x!\n",
+ newseq, dpy->request,
+ (unsigned int) rep->type);
+ newseq -= 0x10000;
+ break;
+ }
+ }
+
+ dpy->last_request_read = newseq;
+ return(newseq);
+}
+#endif
+
diff --git a/nx-X11/lib/XTrap/XEWrappers.c b/nx-X11/lib/XTrap/XEWrappers.c
new file mode 100644
index 000000000..40b7e211e
--- /dev/null
+++ b/nx-X11/lib/XTrap/XEWrappers.c
@@ -0,0 +1,325 @@
+/* $XFree86$ */
+/*****************************************************************************
+Copyright 1987, 1988, 1989, 1990, 1991, 1994 by Digital Equipment Corp.,
+Maynard, MA
+X11R6 Changes Copyright (c) 1994 by Robert Chesler of Absol-Puter, Hudson, NH.
+
+Permission to use, copy, modify, and distribute this software and its
+documentation for any purpose and without fee is hereby granted,
+provided that the above copyright notice appear in all copies and that
+both that copyright notice and this permission notice appear in
+supporting documentation, and that the name of Digital not be
+used in advertising or publicity pertaining to distribution of the
+software without specific, written prior permission.
+
+DIGITAL AND ABSOL-PUTER DISCLAIM ALL WARRANTIES WITH REGARD TO THIS
+SOFTWARE, INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
+FITNESS, IN NO EVENT SHALL DIGITAL OR ABSOL-PUTER BE LIABLE FOR ANY
+SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER
+RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF
+CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN
+CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+
+*****************************************************************************/
+#include <stdio.h>
+#include <X11/extensions/xtraplib.h>
+#include <X11/extensions/xtraplibp.h>
+#ifdef vms
+#define IS_AT_OR_AFTER(t1, t2) (((t2).high > (t1).high) \
+ || (((t2).high == (t1).high)&& ((t2).low >= (t1).low)))
+typedef struct _vms_time {
+ unsigned long low;
+ unsigned long high;
+}vms_time; /* from IntrinsicP.h */
+#ifdef VMSDW_V3
+typedef struct _ModToKeysymTable {
+ Modifiers mask;
+ int count;
+ int index;
+} ModToKeysymTable; /* from TranslateI.h */
+typedef struct _ConverterRec **ConverterTable; /* from ConvertI.h */
+#include "libdef.h"
+typedef struct _CallbackRec *CallbackList; /* from CallbackI.h */
+typedef struct _XtGrabRec *XtGrabList; /* from EventI.h */
+#include <X11/PassivGraI.h>
+#include <X11/InitialI.h>
+#else /* VMSDW_V3 */
+typedef struct _ModToKeysymTable {
+ Modifiers mask;
+ int count;
+ int index;
+} ModToKeysymTable; /* from TranslateI.h */
+typedef struct _ConverterRec **ConverterTable; /* from ConvertI.h */
+#include "libdef.h"
+#define NFDBITS (sizeof(fd_mask) * 8)
+typedef long fd_mask;
+#ifndef howmany
+#define howmany(x, y) (((x)+((y)-1))/(y))
+#endif /* howmany */
+typedef struct Fd_set {
+ fd_mask fds_bits[howmany(256, NFDBITS)];
+} Fd_set; /* from fd.h */
+#include <X11/InitializeI.h>
+#endif /* VMSDW_V3 */
+#else /* !vms */
+#include <X11/IntrinsicI.h>
+#define IS_AT_OR_AFTER(t1, t2) (((t2).tv_sec > (t1).tv_sec) \
+ || (((t2).tv_sec == (t1).tv_sec)&& ((t2).tv_usec >= (t1).tv_usec)))
+#endif /* vms */
+
+/* The following has been lifted from NextEvent.c in X11R4 */
+
+#ifndef NEEDS_NTPD_FIXUP
+# ifdef sun
+# define NEEDS_NTPD_FIXUP 1
+# else
+# define NEEDS_NTPD_FIXUP 0
+# endif
+#endif
+
+#if NEEDS_NTPD_FIXUP
+#define FIXUP_TIMEVAL(t) { \
+ while ((t).tv_usec >= 1000000) { \
+ (t).tv_usec -= 1000000; \
+ (t).tv_sec++; \
+ } \
+ while ((t).tv_usec < 0) { \
+ if ((t).tv_sec > 0) { \
+ (t).tv_usec += 1000000; \
+ (t).tv_sec--; \
+ } else { \
+ (t).tv_usec = 0; \
+ break; \
+ } \
+ }}
+#else
+#define FIXUP_TIMEVAL(t)
+#endif /*NEEDS_NTPD_FIXUP*/
+
+
+/* The following code is required for the use of the XLIB transport of XTrap
+ * events. This is in line with what MIT wants to see proper extension
+ * implementations do, as compared to using one of the core input event masks.
+ */
+
+Boolean (*XETrapGetEventHandler(XETC *tc, CARD32 id))(XETrapDataEvent *event, XETC *tc)
+{
+ return((id < XETrapNumberEvents) ? tc->eventFunc[id] : NULL);
+}
+
+Boolean (*XETrapSetEventHandler(XETC *tc, CARD32 id,
+ Boolean (*pfunc)(XETrapDataEvent *event, XETC *tc)))(XETrapDataEvent *event, XETC *tc)
+{
+ register Boolean (*rfunc)(XETrapDataEvent *event, XETC *tc) = NULL;
+
+ if (id < XETrapNumberEvents)
+ {
+ rfunc = XETrapGetEventHandler(tc,id);
+ tc->eventFunc[id] = pfunc;
+ }
+ return(rfunc);
+}
+
+Boolean XETrapDispatchEvent(XEvent *pevent, XETC *tc)
+{
+ Boolean status = False;
+ register CARD32 id = pevent->type;
+ register CARD32 firstEvent = tc->eventBase;
+ register CARD32 lastEvent = tc->eventBase + XETrapNumberEvents - 1L;
+
+ /* If it is our extension event, handle it specially, otherwise, pass
+ * it off to Xt.
+ */
+ if (firstEvent != 0 && id >= firstEvent && id <= lastEvent)
+ {
+ /* We may be ignoring the event */
+ if (tc->eventFunc[id - firstEvent] != NULL)
+ {
+ status = (*tc->eventFunc[id - firstEvent])((XETrapDataEvent*)pevent,tc);
+ }
+ }
+ else
+ {
+ status = XtDispatchEvent(pevent);
+ }
+ return(status);
+}
+
+XtInputMask XETrapAppPending(XtAppContext app)
+{
+ TimerEventRec *te_ptr;
+#ifndef VMS
+ struct timeval cur_time;
+#else /* vms */
+ vms_time cur_time;
+ long efnMask = 0L;
+ int status;
+#endif /* vms */
+ XtInputMask retmask = XtAppPending(app); /* Prime XtIMEvent */
+
+ retmask &= ~(XtIMTimer | XtIMAlternateInput); /* clear timer & input */
+ /* Now test for timer */
+ te_ptr = app->timerQueue;
+ while (te_ptr != NULL)
+ {
+#ifndef vms
+ (void)gettimeofday(&cur_time, NULL);
+ FIXUP_TIMEVAL(cur_time);
+#else
+ sys$gettim(&cur_time);
+#endif /* vms */
+ if (IS_AT_OR_AFTER(te_ptr->te_timer_value, cur_time))
+ { /* this timer is due to fire */
+ retmask |= XtIMTimer;
+ break;
+ }
+ te_ptr = te_ptr->te_next;
+ }
+
+ /* Now test for alternate input */
+#ifndef vms
+ if (app->outstandingQueue != NULL)
+ {
+ retmask |= XtIMAlternateInput;
+ }
+#else /* vms */
+ if ((app->Input_EF_Mask != 0L) && ((status=SYS$READEF(1,&efnMask)) == 1))
+ { /* we have input configured & retrieved the efn cluster 0 */
+ efnMask &= app->Input_EF_Mask; /* mask out non-input */
+ if (efnMask) /* any left? */
+ { /* yes, an alt-input efn is set */
+ retmask |= XtIMAlternateInput;
+ }
+ }
+#endif /* vms */
+ return(retmask);
+}
+
+void XETrapAppMainLoop(XtAppContext app, XETC *tc)
+{
+ XEvent event;
+ XtInputMask imask;
+
+ while (1)
+ {
+ imask = XETrapAppPending(app);
+ /* Check to see what's going on so that we don't block
+ * in either NextEvent or ProcessEvent since neither
+ * of these routines can correctly deal with XTrap Events
+ */
+ if (imask & XtIMXEvent)
+ {
+ (void)XtAppNextEvent(app,&event);
+ (void)XETrapDispatchEvent(&event,tc);
+ }
+ else if (imask & (XtIMTimer | XtIMAlternateInput))
+ {
+ XtAppProcessEvent(app, (XtIMTimer | XtIMAlternateInput));
+ }
+ else
+ { /* Nothing going on, so we need to block */
+ (void)XETrapWaitForSomething(app);
+ }
+ }
+}
+
+int XETrapAppWhileLoop(XtAppContext app, XETC *tc, Bool *done)
+{
+ XEvent event;
+ XtInputMask imask;
+ int status = True;
+
+ if(done)
+ {
+ while (!(*done))
+ {
+ imask = XETrapAppPending(app);
+ /* Check to see what's going on so that we don't block
+ * in either NextEvent or ProcessEvent since neither
+ * of these routines can correctly deal with XTrap Events
+ */
+ if (imask & XtIMXEvent)
+ {
+ (void)XtAppNextEvent(app, &event);
+ (void)XETrapDispatchEvent(&event,tc);
+ }
+ else if (imask & (XtIMTimer | XtIMAlternateInput))
+ {
+ XtAppProcessEvent(app, (XtIMTimer | XtIMAlternateInput));
+ }
+ else
+ { /* Nothing going on, so we need to block */
+ (void)XETrapWaitForSomething(app);
+ }
+ }
+ }
+ else
+ {
+ status = False;
+ }
+ return(status);
+}
+
+/* Wait for either Timer, Alternate Input, or an X Event to arrive */
+int XETrapWaitForSomething(XtAppContext app)
+{
+#ifndef vms
+ return(_XtWaitForSomething(app, FALSE, FALSE, FALSE, FALSE, TRUE
+#ifdef XTHREADS
+ , FALSE
+#endif /* XTHREADS */
+ , 0L));
+#else /* vms */
+#define IS_AFTER(t1,t2) (((t2).high > (t1).high) \
+ ||(((t2).high == (t1).high)&& ((t2).low > (t1).low)))
+ long retval = 0L;
+ TimerEventRec *te_ptr;
+ vms_time cur_time,result_time;
+ int status = 0;
+ long quotient, remainder = 0;
+ int d;
+
+ if (app->timerQueue!= NULL)
+ { /* check timeout queue */
+ cur_time.low = cur_time.high = result_time.low = result_time.high = 0;
+ te_ptr = app->timerQueue;
+ sys$gettim(&cur_time);
+ if ((IS_AFTER(app->timerQueue->te_timer_value, cur_time)) &&
+ (app->timerQueue->te_proc != 0))
+ { /* it's fired! return! */
+ return(0);
+ }
+ /* Jump through hoops to get the time specified in the queue into
+ * milliseconds
+ */
+ status = lib$sub_times (&(te_ptr->te_timer_value.low), &cur_time,
+ &result_time);
+ /*
+ * See if this timer has expired. A timer is considered expired
+ * if it's value in the past (the NEGTIM case) or if there is
+ * less than one integral milli second before it would go off.
+ */
+
+ if (status == LIB$_NEGTIM ||
+ (result_time.high == -1 && result_time.low > -10000))
+ { /* We've got a timer and it's ready to fire! */
+ return(0);
+ }
+ else if ((status & 1) == 1)
+ {
+ lib$ediv (&(10000), &result_time, &quotient, &remainder);
+ quotient *= -1; /* flip the sign bit */
+
+ return(XMultiplexInput(app->count, &(app->list[0L]),
+ app->Input_EF_Mask, quotient, 0L, &retval));
+ }
+ else
+ {
+ status = -1;
+ }
+ }
+
+ return((status == -1 ? -1 : XMultiplexInput(app->count, &(app->list[0L]),
+ app->Input_EF_Mask, 0L, 0L, &retval)));
+#endif /* vms */
+}
diff --git a/nx-X11/lib/XTrap/XTrap-def.cpp b/nx-X11/lib/XTrap/XTrap-def.cpp
new file mode 100644
index 000000000..dc8a65a1a
--- /dev/null
+++ b/nx-X11/lib/XTrap/XTrap-def.cpp
@@ -0,0 +1,76 @@
+/* $XFree86$ */
+LIBRARY XTrap
+VERSION LIBRARY_VERSION
+EXPORTS
+ XEAddEventCB
+ XEAddEventCBs
+ XEAddRequestCB
+ XEAddRequestCBs
+ XERemoveAllEventCBs
+ XERemoveAllRequestCBs
+ XERemoveEventCB
+ XERemoveEventCBs
+ XERemoveRequestCB
+ XERemoveRequestCBs
+ XEChangeTC
+ XECreateTC
+ XEFreeTC
+ XESetCmdGateState
+ XETrapSetColorReplies
+ XETrapSetCommandKey
+ XETrapSetCursor
+ XETrapSetEvents
+ XETrapSetGrabServer
+ XETrapSetMaxPacket
+ XETrapSetRequests
+ XETrapSetStatistics
+ XETrapSetTimestamps
+ XETrapSetWinXY
+ XETrapSetXInput
+ XETrapDispatchXLib
+ XEPrintAvail
+ XEPrintAvailFlags
+ XEPrintAvailPktSz
+ XEPrintCfgFlags
+ XEPrintCmdKey
+ XEPrintCurPktSz
+ XEPrintCurXY
+ XEPrintCurrent
+ XEPrintEvents
+ XEPrintEvtStats
+ XEPrintLastTime
+ XEPrintMajOpcode
+ XEPrintPlatform
+ XEPrintRelease
+ XEPrintReqStats
+ XEPrintRequests
+ XEPrintStateFlags
+ XEPrintStatistics
+ XEPrintTkFlags
+ XEPrintTkRelease
+ XEPrintTkState
+ XEFlushConfig
+ XEGetAvailableRequest
+ XEGetCurrentRequest
+ XEGetLastInpTimeRequest
+ XEGetStatisticsRequest
+ XEGetVersionRequest
+ XEResetRequest
+ XESimulateXEventRequest
+ XEStartTrapRequest
+ XEStopTrapRequest
+ XEEventIDToString
+ XEEventStringToID
+ XEPlatformIDToString
+ XEPlatformStringToID
+ XERequestIDToExtString
+ XERequestIDToString
+ XERequestStringToID
+ XETrapQueryExtension
+ XETrapAppMainLoop
+ XETrapAppPending
+ XETrapAppWhileLoop
+ XETrapDispatchEvent
+ XETrapGetEventHandler
+ XETrapSetEventHandler
+ XETrapWaitForSomething