diff options
Diffstat (limited to 'nx-X11/lib/XTrap/XEWrappers.c')
| -rw-r--r-- | nx-X11/lib/XTrap/XEWrappers.c | 325 |
1 files changed, 325 insertions, 0 deletions
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, "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 */ +} |