home *** CD-ROM | disk | FTP | other *** search
/ The World of Computer Software / World_Of_Computer_Software-02-385-Vol-1of3.iso / x / xtrapv33.zip / extensions / lib / xtrap / XEWrappers.c < prev   
C/C++ Source or Header  |  1992-09-14  |  13KB  |  448 lines
  1. /*****************************************************************************
  2. Copyright 1987, 1988, 1989, 1990, 1991, 1992 by Digital Equipment Corp., 
  3. Maynard, MA
  4.  
  5. Permission to use, copy, modify, and distribute this software and its 
  6. documentation for any purpose and without fee is hereby granted, 
  7. provided that the above copyright notice appear in all copies and that
  8. both that copyright notice and this permission notice appear in 
  9. supporting documentation, and that the name of Digital not be
  10. used in advertising or publicity pertaining to distribution of the
  11. software without specific, written prior permission.  
  12.  
  13. DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
  14. ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
  15. DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
  16. ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
  17. WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
  18. ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
  19. SOFTWARE.
  20.  
  21. *****************************************************************************/
  22. #include <stdio.h>
  23. #include "xtraplib.h"
  24. #include "xtraplibp.h"
  25. #ifdef vms
  26. #define IS_AT_OR_AFTER(t1, t2) (((t2).high > (t1).high) \
  27.         || (((t2).high == (t1).high)&& ((t2).low >= (t1).low)))
  28. typedef struct _vms_time {
  29.      unsigned long low;
  30.      unsigned long high;
  31. }vms_time;                                      /* from IntrinsicP.h */
  32. #ifdef VMSDW_V3
  33. typedef struct _ModToKeysymTable {
  34.     Modifiers mask;
  35.     int count;
  36.     int index;
  37. } ModToKeysymTable;                             /* from TranslateI.h */
  38. typedef struct _ConverterRec **ConverterTable;  /* from ConvertI.h */
  39. #include "libdef.h"
  40. typedef struct _CallbackRec *CallbackList;      /* from CallbackI.h */
  41. typedef struct _XtGrabRec  *XtGrabList;         /* from EventI.h */
  42. #include "PassivGraI.h"
  43. #include "InitialI.h"
  44. #else  /* VMSDW_V3 */
  45. typedef struct _ModToKeysymTable {
  46.     Modifiers mask;
  47.     int count;
  48.     int index;
  49. } ModToKeysymTable;                             /* from TranslateI.h */
  50. typedef struct _ConverterRec **ConverterTable;  /* from ConvertI.h */
  51. #include "libdef.h"
  52. #define NFDBITS    (sizeof(fd_mask) * 8)
  53. typedef long  fd_mask;
  54. #ifndef howmany
  55. #define    howmany(x, y)    (((x)+((y)-1))/(y))
  56. #endif /* howmany */
  57. typedef    struct Fd_set {
  58.     fd_mask    fds_bits[howmany(256, NFDBITS)];
  59. } Fd_set;                                       /* from fd.h */
  60. #include "InitializeI.h"
  61. #endif  /* VMSDW_V3 */
  62. #else  /* !vms */
  63. #include "fd.h"
  64. #include "IntrinsicI.h"
  65. #define IS_AT_OR_AFTER(t1, t2) (((t2).tv_sec > (t1).tv_sec) \
  66.         || (((t2).tv_sec == (t1).tv_sec)&& ((t2).tv_usec >= (t1).tv_usec)))
  67. #endif /* vms */
  68.  
  69. /* The following has been lifted from NextEvent.c  in X11R4 */
  70.  
  71. #ifndef NEEDS_NTPD_FIXUP
  72. # ifdef sun
  73. #  define NEEDS_NTPD_FIXUP 1
  74. # else
  75. #  define NEEDS_NTPD_FIXUP 0
  76. # endif
  77. #endif
  78.  
  79. #if NEEDS_NTPD_FIXUP
  80. #define FIXUP_TIMEVAL(t) { \
  81.         while ((t).tv_usec >= 1000000) { \
  82.             (t).tv_usec -= 1000000; \
  83.             (t).tv_sec++; \
  84.         } \
  85.         while ((t).tv_usec < 0) { \
  86.             if ((t).tv_sec > 0) { \
  87.                 (t).tv_usec += 1000000; \
  88.                 (t).tv_sec--; \
  89.             } else { \
  90.                 (t).tv_usec = 0; \
  91.                 break; \
  92.             } \
  93.         }}
  94. #else
  95. #define FIXUP_TIMEVAL(t)
  96. #endif /*NEEDS_NTPD_FIXUP*/
  97.  
  98.  
  99. /* The following code is required for the use of the XLIB transport of XTrap
  100.  * events. This is in line with what MIT wants to see proper extension
  101.  * implementations do, as compared to using one of the core input event masks.
  102.  */
  103.  
  104. #ifdef FUNCTION_PROTOS
  105. Boolean (*XETrapGetEventHandler(XETC *tc, CARD32 id))()
  106. #else
  107. Boolean (*XETrapGetEventHandler(tc,id))()
  108.     XETC *tc;
  109.     CARD32 id;
  110. #endif
  111. {
  112.     return((id < XETrapNumberEvents) ? tc->eventFunc[id] : NULL);
  113. }
  114.  
  115. #ifdef FUNCTION_PROTOS
  116. Boolean (*XETrapSetEventHandler(XETC *tc, CARD32 id, Boolean (*pfunc)()))()
  117. #else
  118. Boolean (*XETrapSetEventHandler(tc,id,pfunc))()
  119.     XETC *tc;
  120.     CARD32 id;
  121.     Boolean (*pfunc)();
  122. #endif
  123. {
  124.     register Boolean (*rfunc)() = NULL;
  125.  
  126.     if (id < XETrapNumberEvents)
  127.     {
  128.         rfunc = XETrapGetEventHandler(tc,id);
  129.         tc->eventFunc[id] = pfunc;
  130.     }
  131.     return(rfunc);
  132. }
  133.  
  134. #ifdef FUNCTION_PROTOS
  135. Boolean XETrapDispatchEvent(XEvent *pevent, XETC *tc)
  136. #else
  137. Boolean XETrapDispatchEvent(pevent,tc)
  138.     XEvent *pevent;
  139.     XETC *tc;
  140. #endif
  141. {
  142.     Boolean status = False;
  143.     register CARD32 id = pevent->type;
  144.     register CARD32 firstEvent = tc->eventBase;
  145.     register CARD32 lastEvent  = tc->eventBase + XETrapNumberEvents - 1L;
  146.  
  147.     /* If it is our extension event, handle it specially, otherwise, pass
  148.      * it off to Xt.
  149.      */
  150.     if (firstEvent != 0 && id >= firstEvent && id <= lastEvent)
  151.     {
  152.         /* We may be ignoring the event */
  153.         if (tc->eventFunc[id - firstEvent] != NULL)
  154.         {
  155.             status = (*tc->eventFunc[id - firstEvent])(pevent,tc);
  156.         }
  157.     }
  158.     else
  159.     {
  160. #ifndef X11R3
  161.         status = XtDispatchEvent(pevent);
  162. #else
  163.     XtDispatchEvent(pevent);
  164.     status = True;
  165. #endif
  166.     }
  167.     return(status);
  168. }
  169.  
  170. #ifdef FUNCTION_PROTOS
  171. XtInputMask XETrapAppPending(XtAppContext app)
  172. #else
  173. XtInputMask XETrapAppPending(app)
  174.     XtAppContext app;
  175. #endif
  176. {
  177.     TimerEventRec *te_ptr;
  178. #ifndef VMS
  179.     struct timeval cur_time;
  180. #else  /* vms */
  181.     vms_time cur_time;
  182.     long efnMask = 0L;
  183.     int status;
  184. #endif /* vms */
  185.     XtInputMask retmask = XtAppPending(app);        /* Prime XtIMEvent */
  186.  
  187.     retmask &= ~(XtIMTimer | XtIMAlternateInput);   /* clear timer & input */
  188.     /* Now test for timer */
  189.     te_ptr = app->timerQueue;
  190.     while (te_ptr != NULL)
  191.     {
  192. #ifndef vms
  193.         (void)gettimeofday(&cur_time, NULL);
  194.         FIXUP_TIMEVAL(cur_time);
  195. #else
  196.         sys$gettim(&cur_time);
  197. #endif /* vms */
  198.         if (IS_AT_OR_AFTER(te_ptr->te_timer_value, cur_time))
  199.         {   /* this timer is due to fire */
  200.             retmask |= XtIMTimer;
  201.             break;
  202.         }
  203.         te_ptr = te_ptr->te_next;
  204.     }
  205.  
  206.     /* Now test for alternate input */
  207. #ifndef vms
  208.     if (app->outstandingQueue != NULL)
  209.     {
  210.         retmask |= XtIMAlternateInput;
  211.     }
  212. #else /* vms */
  213.     if ((app->Input_EF_Mask != 0L) && ((status=SYS$READEF(1,&efnMask)) == 1))
  214.     {   /* we have input configured & retrieved the efn cluster 0 */
  215.         efnMask &= app->Input_EF_Mask;  /* mask out non-input */
  216.         if (efnMask)                    /* any left? */
  217.         {                               /* yes, an alt-input efn is set */
  218.             retmask |= XtIMAlternateInput;
  219.         }
  220.     }
  221. #endif  /* vms */
  222.     return(retmask);
  223. }
  224.  
  225. #ifdef FUNCTION_PROTOS
  226. void XETrapAppMainLoop(XtAppContext app, XETC *tc)
  227. #else
  228. void XETrapAppMainLoop(app,tc)
  229.     XtAppContext app;
  230.     XETC *tc;
  231. #endif
  232. {
  233.     XEvent event;
  234.     XtInputMask imask;
  235.  
  236.     while (1)
  237.     {
  238.         imask = XETrapAppPending(app);
  239.         /* Check to see what's going on so that we don't block
  240.          * in either NextEvent or ProcessEvent since neither
  241.          * of these routines can correctly deal with XTrap Events
  242.          */
  243.         if (imask & XtIMXEvent)
  244.         {
  245.             (void)XtAppNextEvent(app,&event);
  246.             (void)XETrapDispatchEvent(&event,tc);
  247.         }
  248.         else if (imask & (XtIMTimer | XtIMAlternateInput))
  249.         {
  250.             XtAppProcessEvent(app, (XtIMTimer | XtIMAlternateInput));
  251.         }
  252.         else
  253.         {   /* Nothing going on, so we need to block */
  254.             (void)XETrapWaitForSomething(app);
  255.         }
  256.     }
  257. }
  258.  
  259. #ifdef FUNCTION_PROTOS
  260. int XETrapAppWhileLoop(XtAppContext app, XETC *tc, Bool *done)
  261. #else
  262. int XETrapAppWhileLoop(app, tc, done)
  263.     XtAppContext app;
  264.     XETC *tc;
  265.     Bool *done;
  266. #endif
  267. {
  268.     XEvent event;
  269.     XtInputMask imask;
  270.     int status = True;
  271.  
  272.     if(done)
  273.     {
  274.         while (!(*done))
  275.         {
  276.             imask = XETrapAppPending(app);
  277.             /* Check to see what's going on so that we don't block
  278.              * in either NextEvent or ProcessEvent since neither
  279.              * of these routines can correctly deal with XTrap Events
  280.              */
  281.             if (imask & XtIMXEvent)
  282.             {
  283.                 (void)XtAppNextEvent(app, &event);
  284.                 (void)XETrapDispatchEvent(&event,tc);
  285.             }
  286.             else if (imask & (XtIMTimer | XtIMAlternateInput))
  287.             {
  288.                 XtAppProcessEvent(app, (XtIMTimer | XtIMAlternateInput));
  289.             }
  290.             else
  291.             {   /* Nothing going on, so we need to block */
  292.                 (void)XETrapWaitForSomething(app);
  293.             }
  294.         }
  295.     }
  296.     else
  297.     {
  298.         status = False;
  299.     }
  300.     return(status);
  301. }
  302. #if defined X11R3 && !defined VMSDW_V3
  303.     /* Create an XtAppInitialize convenience routine */
  304. #include "Shell.h"
  305. #define XtNscreen "screen"
  306. #ifndef XtNargc
  307. #define XtNargc   "argc"
  308. #define XtNargv   "argv"
  309. #endif
  310. #define ALLOCATE_LOCAL(size) XtMalloc((unsigned long)(size))
  311. #define DEALLOCATE_LOCAL(ptr) XtFree((XtPointer)(ptr))
  312. typedef void      *XtPointer;
  313.  
  314. #ifdef FUNCTION_PROTOS
  315. Widget XtAppInitialize(XtAppContext *app_context_return,
  316.     String application_class, XrmOptionDescRec *options,
  317.     Cardinal num_options, Cardinal *argc_in_out, String *argv_in_out,
  318.     String *fallback_resources, ArgList args_in, Cardinal num_args_in)
  319. #else
  320. Widget XtAppInitialize(app_context_return, application_class, options,
  321.     num_options, argc_in_out, argv_in_out, fallback_resources, 
  322.     args_in, num_args_in)
  323. XtAppContext * app_context_return;
  324. String application_class;
  325. XrmOptionDescRec *options;
  326. Cardinal num_options, *argc_in_out, num_args_in;
  327. String *argv_in_out, * fallback_resources;     
  328. ArgList args_in;
  329. #endif
  330. {
  331.     XtAppContext app_con;
  332.     Display * dpy;
  333.     String *saved_argv;
  334.     register int i, saved_argc = *argc_in_out;
  335.     Widget root;
  336.     Arg args[3], *merged_args;
  337.     Cardinal num = 0;
  338.     
  339.     XtToolkitInitialize();
  340.     
  341. /*
  342.  * Save away argv and argc so we can set the properties later 
  343.  */
  344.     
  345.     saved_argv = (String *)
  346.     ALLOCATE_LOCAL( (Cardinal)((*argc_in_out + 1) * sizeof(String)) );
  347.  
  348.     for (i = 0 ; i < saved_argc ; i++) saved_argv[i] = argv_in_out[i];
  349.     saved_argv[i] = NULL;    /* NULL terminate that sucker. */
  350.  
  351.  
  352.     app_con = XtCreateApplicationContext();
  353.  
  354.     dpy = XtOpenDisplay(app_con, (String) NULL, NULL, application_class,
  355.             options, num_options, argc_in_out, argv_in_out);
  356.  
  357.     if (dpy == NULL)
  358.     XtErrorMsg("invalidDisplay","xtInitialize","XToolkitError",
  359.                    "Can't Open display", (String *) NULL, (Cardinal *)NULL);
  360.  
  361.     XtSetArg(args[num], XtNscreen, DefaultScreenOfDisplay(dpy)); num++;
  362.     XtSetArg(args[num], XtNargc, saved_argc);                     num++;
  363.     XtSetArg(args[num], XtNargv, saved_argv);                     num++;
  364.  
  365.     merged_args = XtMergeArgLists(args_in, num_args_in, args, num);
  366.     num += num_args_in;
  367.  
  368.     root = XtAppCreateShell(NULL, application_class, 
  369.                 applicationShellWidgetClass,dpy, merged_args, num);
  370.     
  371.     if (app_context_return != NULL)
  372.     *app_context_return = app_con;
  373.  
  374.     XtFree((XtPointer)merged_args);
  375.     DEALLOCATE_LOCAL((XtPointer)saved_argv);
  376.     return(root);
  377. }
  378. #endif /* X11R3 */
  379.  
  380. /* Wait for either Timer, Alternate Input, or an X Event to arrive */
  381. #ifdef FUNCTION_PROTOS
  382. int XETrapWaitForSomething(XtAppContext app)
  383. #else
  384. int XETrapWaitForSomething(app)
  385.     XtAppContext app;
  386. #endif
  387. {
  388. #ifndef vms
  389. #ifndef X11R3
  390.     return(_XtwaitForSomething(FALSE, FALSE, FALSE, TRUE, 0L, app));
  391. #else
  392.     return(_XtwaitForSomething(FALSE, FALSE, TRUE, 0L, app));
  393. #endif  /* !X11R3 */
  394. #else   /* vms */
  395. #define IS_AFTER(t1,t2) (((t2).high > (t1).high) \
  396.        ||(((t2).high == (t1).high)&& ((t2).low > (t1).low)))
  397.     long retval = 0L;
  398.     TimerEventRec *te_ptr;
  399.     vms_time cur_time,result_time;
  400.     int status = 0;
  401.     long quotient, remainder = 0;
  402.     int d;
  403.  
  404.     if (app->timerQueue!= NULL) 
  405.     {   /* check timeout queue */
  406.         cur_time.low = cur_time.high = result_time.low = result_time.high = 0;
  407.         te_ptr = app->timerQueue;
  408.         sys$gettim(&cur_time);
  409.         if ((IS_AFTER(app->timerQueue->te_timer_value, cur_time))  &&
  410.             (app->timerQueue->te_proc != 0)) 
  411.         {   /* it's fired! return! */
  412.             return(0);
  413.         }
  414.         /* Jump through hoops to get the time specified in the queue into
  415.          * milliseconds 
  416.          */
  417.         status = lib$sub_times (&(te_ptr->te_timer_value.low), &cur_time,
  418.                                 &result_time);
  419.         /*
  420.          * See if this timer has expired.  A timer is considered expired
  421.          * if it's value in the past (the NEGTIM case) or if there is
  422.          * less than one integral milli second before it would go off.
  423.          */
  424.  
  425.         if (status == LIB$_NEGTIM ||
  426.             (result_time.high == -1 && result_time.low > -10000)) 
  427.         {   /* We've got a timer and it's ready to fire! */
  428.             return(0);
  429.         }
  430.         else if ((status & 1) == 1) 
  431.         {
  432.             lib$ediv (&(10000), &result_time, "ient, &remainder);
  433.             quotient *= -1;         /* flip the sign bit */
  434.  
  435.             return(XMultiplexInput(app->count, &(app->list[0L]),
  436.                 app->Input_EF_Mask, quotient, 0L, &retval));
  437.         }
  438.         else
  439.         {
  440.             status = -1;
  441.         }
  442.     }
  443.      
  444.     return((status == -1 ? -1 : XMultiplexInput(app->count, &(app->list[0L]),
  445.            app->Input_EF_Mask, 0L, 0L, &retval)));
  446. #endif  /* vms */
  447. }
  448.