diff options
| -rw-r--r-- | src/XECallBcks.c | 175 | ||||
| -rw-r--r-- | src/XEConTxt.c | 589 | ||||
| -rw-r--r-- | src/XEDsptch.c | 111 | ||||
| -rw-r--r-- | src/XEPrInfo.c | 274 | ||||
| -rw-r--r-- | src/XERqsts.c | 412 | ||||
| -rw-r--r-- | src/XEStrMap.c | 284 | ||||
| -rw-r--r-- | src/XETrapInit.c | 218 | ||||
| -rw-r--r-- | src/XEWrappers.c | 329 |
8 files changed, 2392 insertions, 0 deletions
diff --git a/src/XECallBcks.c b/src/XECallBcks.c new file mode 100644 index 0000000..e04f1e4 --- /dev/null +++ b/src/XECallBcks.c @@ -0,0 +1,175 @@ +/* $XFree86: xc/lib/XTrap/XECallBcks.c,v 1.1 2001/11/02 23:29:27 dawes Exp $ */ +/***************************************************************************** +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/src/XEConTxt.c b/src/XEConTxt.c new file mode 100644 index 0000000..28498c3 --- /dev/null +++ b/src/XEConTxt.c @@ -0,0 +1,589 @@ +/* $XFree86: xc/lib/XTrap/XEConTxt.c,v 1.2 2001/11/19 15:33:39 tsi 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", ¶ms, &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", ¶ms, &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/src/XEDsptch.c b/src/XEDsptch.c new file mode 100644 index 0000000..858df22 --- /dev/null +++ b/src/XEDsptch.c @@ -0,0 +1,111 @@ +/* $XFree86: xc/lib/XTrap/XEDsptch.c,v 1.1 2001/11/02 23:29:27 dawes Exp $ */ +/***************************************************************************** +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/src/XEPrInfo.c b/src/XEPrInfo.c new file mode 100644 index 0000000..5829e2e --- /dev/null +++ b/src/XEPrInfo.c @@ -0,0 +1,274 @@ +/* $XFree86: xc/lib/XTrap/XEPrInfo.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. + +*****************************************************************************/ +#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/src/XERqsts.c b/src/XERqsts.c new file mode 100644 index 0000000..02f0c97 --- /dev/null +++ b/src/XERqsts.c @@ -0,0 +1,412 @@ +/* $XFree86: xc/lib/XTrap/XERqsts.c,v 1.1 2001/11/02 23:29:27 dawes Exp $ */ +/***************************************************************************** +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/src/XEStrMap.c b/src/XEStrMap.c new file mode 100644 index 0000000..411fce9 --- /dev/null +++ b/src/XEStrMap.c @@ -0,0 +1,284 @@ +/* $XFree86: xc/lib/XTrap/XEStrMap.c,v 1.2 2001/11/08 04:00:12 tsi 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/src/XETrapInit.c b/src/XETrapInit.c new file mode 100644 index 0000000..3a76d0e --- /dev/null +++ b/src/XETrapInit.c @@ -0,0 +1,218 @@ +/* $XFree86: xc/lib/XTrap/XETrapInit.c,v 1.3 2002/10/16 00:37:27 dawes 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/src/XEWrappers.c b/src/XEWrappers.c new file mode 100644 index 0000000..b857c75 --- /dev/null +++ b/src/XEWrappers.c @@ -0,0 +1,329 @@ +/* $XFree86: xc/lib/XTrap/XEWrappers.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 +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 "PassivGraI.h" +#include "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 "InitializeI.h" +#endif /* VMSDW_V3 */ +#else /* !vms */ +#include "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 +#ifndef X11R5 + return(_XtWaitForSomething(app, FALSE, FALSE, FALSE, FALSE, TRUE +#ifdef XTHREADS + , FALSE +#endif /* XTHREADS */ + , 0L)); +#else /* X11R5 */ + return(_XtwaitForSomething(FALSE, FALSE, FALSE, TRUE, 0L, app)); +#endif /* X11R5 */ +#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, "ient, &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 */ +} |