#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;
XETC *XECreateTC(Display *dpy, CARD32 valuemask, XETCValues *value)
{
static Bool firsttime = True;
register XETC *tc = &TC;
register XETC *last_tc;
XETrapGetAvailRep rep;
if (firsttime == True)
{
firsttime = False;
(void)memset(tc,0L,sizeof(tc));
tc->eventBase = 0x7FFFFFFFL;
tc->errorBase = 0x7FFFFFFFL;
tc->values.v.max_pkt_size = 0x7FFFL;
}
for (;tc->next != NULL; tc = tc->next);
last_tc = tc;
if ((tc = (tc->next = (XETC *)XtMalloc(sizeof(*tc)))) == NULL)
{
return(NULL);
}
(void)memcpy(tc,&TC,sizeof(TC));
tc->next = NULL;
tc->dpy = dpy;
tc->xmax_size = XMaxRequestSize(tc->dpy);
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;
return(NULL);
}
if ((tc->xbuff = (BYTE *)XtMalloc(tc->xmax_size * sizeof(CARD32) +
SIZEOF(XETrapHeader))) == NULL)
{
(void)XtFree((XtPointer)tc);
last_tc->next = NULL;
return(NULL);
}
if (XEGetAvailableRequest(tc,&rep) == True)
{
switch (rep.xtrap_protocol)
{
case 31:
case XETrapProtocol:
tc->protocol = rep.xtrap_protocol;
break;
default:
tc->protocol = 31;
break;
}
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
{
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);
(void)XtFree((XtPointer)tc);
last_tc->next = NULL;
return(NULL);
}
(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);
}
int XEChangeTC(XETC *tc, CARD32 mask, XETCValues *values)
{
int status = True;
register XETCValues *tval = &(tc->values);
register int i;
if (mask & TCStatistics)
{
if(CheckChangeBits(&(tval->v.flags), &(values->v.flags),
XETrapStatistics))
{
tc->dirty |= TCStatistics;
}
}
if (mask & TCRequests)
{
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)
{
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)
{
CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapMaxPacket);
XETrapSetCfgMaxPktSize(tval, values->v.max_pkt_size);
tc->dirty |= TCMaxPacket;
}
if (mask & TCCmdKey)
{
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)
{
if (CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapTimestamp))
{
tc->dirty |= TCTimeStamps;
}
BitCopy(tval->tc_flags, values->tc_flags, XETCDeltaTimes);
}
if (mask & TCWinXY)
{
if (CheckChangeBits(&(tval->v.flags), &(values->v.flags), XETrapWinXY))
{
tc->dirty |= TCWinXY;
}
}
if (mask & TCCursor)
{
if (CheckChangeBits(&(tval->v.flags), &(values->v.flags),XETrapCursor))
{
tc->dirty |= TCCursor;
}
}
if (mask & TCXInput)
{
if (CheckChangeBits(&(tval->v.flags), &(values->v.flags),XETrapXInput))
{
tc->dirty |= TCXInput;
}
}
if (mask & TCColorReplies)
{
if (CheckChangeBits(&(tval->v.flags), &(values->v.flags),
XETrapColorReplies))
{
tc->dirty |= TCColorReplies;
}
}
if (mask & TCGrabServer )
{
if (CheckChangeBits(&(tval->v.flags), &(values->v.flags),
XETrapGrabServer ))
{
tc->dirty |= TCGrabServer;
}
}
if (XETrapGetTCFlagTrapActive(tc))
{
status = XEFlushConfig(tc);
}
#ifdef VMS
sys$setast(True);
#endif
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;
else
list = list->next;
}
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;
}
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
{
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
{
*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;
}
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);
}