![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to NextEvent.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / oldXtk|
Return to NextEvent.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / oldXtk |
1.1 root 1: /* $Header: NextEvent.c,v 1.4 87/08/28 16:52:08 toddb Exp $ */
2: #ifndef lint
3: static char *sccsid = "@(#)NextEvent.c 1.15 2/25/87";
4: #endif lint
5:
6: /*
7: * Copyright 1987 by Digital Equipment Corporation, Maynard, Massachusetts.
8: *
9: * All Rights Reserved
10: *
11: * Permission to use, copy, modify, and distribute this software and its
12: * documentation for any purpose and without fee is hereby granted,
13: * provided that the above copyright notice appear in all copies and that
14: * both that copyright notice and this permission notice appear in
15: * supporting documentation, and that the name of Digital Equipment
16: * Corporation not be used in advertising or publicity pertaining to
17: * distribution of the software without specific, written prior permission.
18: *
19: *
20: * DIGITAL DISCLAIMS ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING
21: * ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT SHALL
22: * DIGITAL BE LIABLE FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR
23: * ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS,
24: * WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION,
25: * ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS
26: * SOFTWARE.
27: */
28:
29:
30: #include <stdio.h>
31: #include <errno.h>
32: #include "Xlib.h"
33: #include "Intrinsic.h"
34: #include <sys/time.h>
35: #include <sys/file.h>
36: #include <sys/param.h>
37: #include "fd.h"
38: /*
39: * Private definitions
40: */
41:
42: static struct timer_interval {
43: struct timeval ti_interval;
44: struct timeval ti_value;
45: };
46:
47:
48:
49: static struct Timer_event {
50: struct timer_interval Te_tim;
51: struct Timer_event *Te_next;
52: Display *Te_dpy;
53: Window Te_wID;
54: caddr_t Te_cookie;
55: };
56:
57: static struct Select_event {
58: Window Se_wID;
59: struct Select_event *Se_next;
60: XClientMessageEvent Se_event;
61: struct Select_event *Se_oq;
62: };
63:
64:
65: /*
66: * Private data
67: */
68:
69: static struct Timer_event *Timer_queue = NULL;
70: static struct Select_event *Select_rqueue[NOFILE], *Select_wqueue[NOFILE],
71: *Select_equeue[NOFILE];
72: static struct timeval Timer_next = {0};
73: static struct Select_event *outstanding_queue = NULL;
74: static struct
75: {
76: Fd_set rmask;
77: Fd_set wmask;
78: Fd_set emask;
79: int nfds;
80: } composite;
81:
82:
83:
84:
85: /*
86: * Private routines
87: */
88:
89: #define TIMEADD(dest, src1, src2) { \
90: if(((dest)->tv_usec = (src1)->tv_usec + (src2)->tv_usec) >= 1000000) {\
91: (dest)->tv_usec -= 1000000;\
92: (dest)->tv_sec = (src1)->tv_sec + (src2)->tv_sec + 1 ; \
93: } else { (dest)->tv_sec = (src1)->tv_sec + (src2)->tv_sec ; \
94: if(((dest)->tv_sec >= 1) && (((dest)->tv_usec <0))) { \
95: (dest)->tv_sec --;(dest)->tv_usec += 1000000; } } }
96:
97:
98: #define TIMEDELTA(dest, src1, src2) { \
99: if(((dest)->tv_usec = (src1)->tv_usec - (src2)->tv_usec) < 0) {\
100: (dest)->tv_usec += 1000000;\
101: (dest)->tv_sec = (src1)->tv_sec - (src2)->tv_sec - 1;\
102: } else (dest)->tv_sec = (src1)->tv_sec - (src2)->tv_sec; }
103: #define ISAFTER(t1, t2) (((t2)->tv_sec > (t1)->tv_sec) ||(((t2)->tv_sec == (t1)->tv_sec)&& ((t2)->tv_usec > (t1)->tv_usec)))
104:
105: static void ReQueueTimerEvent(ptr)
106: struct Timer_event *ptr;
107: {
108: register struct Timer_event *tptr, *lptr;
109: struct timeval cur_time, when, *inter;
110: struct timezone curzone;
111:
112: (void) gettimeofday(&cur_time, &curzone);
113:
114: ptr->Te_tim.ti_value = ptr->Te_tim.ti_interval;
115: inter = &(ptr->Te_tim.ti_value);
116: TIMEADD(&when, &cur_time, inter);
117: ptr->Te_tim.ti_value = when;
118: if(Timer_queue == NULL)
119: {
120: TIMEADD(&Timer_next, inter, &cur_time)
121: Timer_next = when;
122: Timer_queue = ptr;
123: return;
124: }
125: if (ISAFTER(&when, &Timer_next))
126: {
127: /* This goes on the front */
128: ptr -> Te_next = Timer_queue;
129: Timer_next = when;
130: Timer_queue = ptr;
131: return;
132: }
133:
134: for(tptr = Timer_queue ; tptr ; tptr=tptr->Te_next )
135: {
136: if(ISAFTER( &(tptr->Te_tim.ti_value), &when)) {
137: lptr = tptr;
138: } else {
139: ptr->Te_next = tptr;
140: lptr->Te_next = ptr;
141: return;
142: }
143: }
144: lptr->Te_next = ptr;
145: }
146:
147: /*
148: * Public Routines
149: */
150:
151: void XtSetTimeOut(wID, cookie, interval)
152: Window wID;
153: caddr_t cookie;
154: int interval;
155: {
156: struct Timer_event *tptr;
157:
158: tptr = (struct Timer_event *)XtMalloc(sizeof (*tptr));
159: tptr->Te_next = NULL;
160: tptr->Te_tim.ti_interval.tv_sec = interval/1000;
161: tptr->Te_tim.ti_interval.tv_usec = (interval%1000)*1000;
162: tptr->Te_wID = wID;
163: tptr->Te_cookie = cookie;
164: ReQueueTimerEvent(tptr);
165: }
166:
167: int XtGetTimeOut(wID, cookie)
168: Window wID;
169: caddr_t cookie;
170: {
171: struct timeval sum, cur_time;
172: struct timezone curzone;
173: register struct Timer_event *tptr;
174:
175: (void) gettimeofday(&cur_time, &curzone);
176:
177: for(tptr = Timer_queue; tptr; tptr = tptr->Te_next)
178: {
179: if(wID == tptr->Te_wID && cookie == tptr->Te_cookie){
180: TIMEDELTA(&sum, &(tptr->Te_tim.ti_value), &cur_time);
181: return((sum.tv_sec*1000)+(sum.tv_usec/1000));
182: }
183:
184: }
185: return(-1);
186: }
187:
188: int XtClearTimeOut(wID, cookie)
189: Window wID;
190: caddr_t cookie;
191: {
192: register struct Timer_event *tptr,*lptr;
193: lptr = NULL;
194:
195: for(tptr = Timer_queue ;tptr != NULL;tptr = tptr->Te_next)
196: {
197: if(wID != tptr->Te_wID || cookie != tptr->Te_cookie)
198: {
199: lptr = tptr;
200: continue;
201: }
202: else{
203: if(lptr)
204: lptr->Te_next = tptr->Te_next;
205:
206: else
207: Timer_queue = tptr->Te_next;
208:
209: XtFree((char *) tptr);
210: return(0);
211: }
212: }
213: return(-1);
214: }
215:
216: void XtAddInput(dpy, wID, source, condition)
217: Display *dpy;
218: Window wID;
219: int source;
220: int condition;
221: {
222: struct Select_event *sptr;
223:
224: if(((int)condition &(XtINPUT_READ|XtINPUT_WRITE|XtINPUT_EXCEPT))==0) {
225: return; /* error */ /* XXX */
226: }
227: if(condition&XtINPUT_READ){
228: sptr = (struct Select_event *)XtMalloc(sizeof (*sptr));
229: sptr->Se_wID = wID;
230: sptr->Se_next = Select_rqueue[source];
231: Select_rqueue[source] = sptr;
232: FD_SET(source, &composite.rmask);
233: sptr->Se_event.type = ClientMessage;
234: sptr->Se_event.display = dpy;
235: sptr->Se_event.window = wID;
236: sptr->Se_event.message_type = XtHasInput;
237: sptr->Se_event.format = 32;
238: sptr->Se_event.data.l[0] = (int)source;
239: sptr->Se_event.data.l[1] = XtINPUT_READ;
240: }
241:
242: if(condition&XtINPUT_WRITE) {
243: sptr = (struct Select_event *) XtMalloc(sizeof (*sptr));
244: sptr->Se_wID = wID;
245: sptr->Se_next = Select_wqueue[source];
246: Select_wqueue[source] = sptr;
247: FD_SET(source, &composite.wmask);
248: sptr->Se_event.type = ClientMessage;
249: sptr->Se_event.display = dpy;
250: sptr->Se_event.window = wID;
251: sptr->Se_event.message_type = XtHasInput;
252: sptr->Se_event.format = 32;
253: sptr->Se_event.data.l[0] = (int)source;
254: sptr->Se_event.data.l[1] = XtINPUT_WRITE;
255: }
256:
257: if(condition&XtINPUT_EXCEPT) {
258: sptr = (struct Select_event *) XtMalloc(sizeof (*sptr));
259: sptr->Se_wID = wID;
260: sptr->Se_next = Select_equeue[source];
261: Select_equeue[source] = sptr;
262: FD_SET(source, &composite.emask);
263: sptr->Se_event.type = ClientMessage;
264: sptr->Se_event.display = dpy;
265: sptr->Se_event.window = wID;
266: sptr->Se_event.message_type = XtHasInput;
267: sptr->Se_event.format = 32;
268: sptr->Se_event.data.l[0] = (int)source;
269: sptr->Se_event.data.l[1] = XtINPUT_EXCEPT;
270: }
271: if (composite.nfds < (source+1))
272: composite.nfds = source+1;
273: }
274:
275: void XtRemoveInput(wID, source, condition)
276: Window wID;
277: int source;
278: int condition;
279: {
280: register struct Select_event *sptr, *lptr;
281:
282: if(((int)condition &(XtINPUT_READ|XtINPUT_WRITE|XtINPUT_EXCEPT))==0) {
283: return; /* error */ /* XXX */
284: }
285: if(condition&XtINPUT_READ){
286: if((sptr = Select_rqueue[source]) == NULL)
287: return; /* error */ /* XXX */
288: for(lptr = NULL;sptr; sptr = sptr->Se_next){
289: if(sptr->Se_wID == wID) {
290: if(lptr == NULL) {
291: Select_rqueue[source] = sptr->Se_next;
292: FD_CLR(source, &composite.rmask);
293: } else {
294: lptr->Se_next = sptr->Se_next;
295: }
296: XtFree((char *) sptr);
297: return;
298: }
299: lptr = sptr;
300: }
301: }
302: if(condition&XtINPUT_WRITE){
303: if((sptr = Select_wqueue[source]) == NULL)
304: return; /* error */ /* XXX */
305: for(lptr = NULL;sptr; sptr = sptr->Se_next){
306: if(sptr->Se_wID == wID) {
307: if(lptr == NULL){
308: Select_wqueue[source] = sptr->Se_next;
309: FD_CLR(source, &composite.wmask);
310: }else {
311: lptr->Se_next = sptr->Se_next;
312: }
313: XtFree((char *) sptr);
314: return;
315: }
316: lptr = sptr;
317: }
318:
319: }
320: if(condition&XtINPUT_EXCEPT){
321: if((sptr = Select_equeue[source]) == NULL)
322: return; /* error */ /* XXX */
323: for(lptr = NULL;sptr; sptr = sptr->Se_next){
324: if(sptr->Se_wID == wID) {
325: if(lptr == NULL){
326: Select_equeue[source] = sptr->Se_next;
327: FD_CLR(source, &composite.emask);
328: }else {
329: lptr->Se_next = sptr->Se_next;
330: }
331: XtFree((char *) sptr);
332: return;
333: }
334: lptr = sptr;
335: }
336:
337: }
338: return;
339: /* error */
340: }
341:
342:
343:
344: /*
345: * XtNextEvent()
346: * return next event;
347: */
348:
349: void XtNextEvent(dpy, event)
350: Display *dpy;
351: XEvent *event;
352: {
353: struct Select_event *se_ptr;
354: struct Timer_event *te_ptr;
355: struct timeval cur_time;
356: struct timezone cur_timezone;
357: Fd_set rmaskfd, wmaskfd, emaskfd;
358: int nfound, i;
359: struct timeval wait_time;
360: struct timeval *wait_time_ptr;
361: int Claims_X_is_pending = 0;
362: XClientMessageEvent *ev = (XClientMessageEvent *)event;
363: extern void perror(), exit();
364: extern int errno;
365:
366: for(;;) {
367: if(XPending(dpy) || Claims_X_is_pending) {
368: XNextEvent(dpy, event);
369: return;
370: }
371: if((se_ptr = outstanding_queue) != NULL) {
372: *event = *((XEvent *)&se_ptr->Se_event);
373: outstanding_queue = se_ptr->Se_oq;
374: return;
375: }
376: (void) gettimeofday(&cur_time, &cur_timezone);
377: if(Timer_queue) /* check timeout queue */
378: {
379: if (ISAFTER(&Timer_next, &cur_time)){
380: /* timer has expired */
381: ev->type = ClientMessage;
382: ev->display = dpy;
383: ev->window = Timer_queue->Te_wID;
384: ev->message_type = XtTimerExpired;
385: ev->format = 32;
386: ev->data.l[0] = (int)Timer_queue->Te_cookie;
387: te_ptr = Timer_queue;
388: Timer_queue = Timer_queue->Te_next;
389: te_ptr->Te_next = NULL;
390: if(Timer_queue) /* set up next time out time */
391: Timer_next = Timer_queue->Te_tim.ti_value;
392: ReQueueTimerEvent(te_ptr);
393: return;
394: }
395: }/* No timers ready time to wait */
396: /* should be done only once */
397: if(ConnectionNumber(dpy) +1 > composite.nfds)
398: composite.nfds = ConnectionNumber(dpy) + 1;
399: while(1) {
400: FD_SET(ConnectionNumber(dpy),&composite.rmask);
401: if (Timer_queue) {
402: TIMEDELTA(&wait_time, &Timer_next, &cur_time);
403: wait_time_ptr = &wait_time;
404: } else
405: wait_time_ptr = (struct timeval *)0;
406: rmaskfd = composite.rmask;
407: wmaskfd = composite.wmask;
408: emaskfd = composite.emask;
409: if((nfound=select(composite.nfds,
410: (int *)&rmaskfd,(int *)&wmaskfd,
411: (int *)&emaskfd,wait_time_ptr)) == -1) {
412: if(errno == EINTR)
413: continue;
414: }
415: if(nfound == -1) {
416: perror("select:");
417: exit(-1);
418: }
419: break;
420:
421: }
422: if(nfound == 0)
423: continue;
424: for(i = 0; i < composite.nfds && nfound > 0;i++) {
425: if(FD_ISSET(i,&rmaskfd)) {
426: if(i == ConnectionNumber(dpy)){
427: Claims_X_is_pending= 1;
428: nfound--;
429: } else {
430: Select_rqueue[i] -> Se_oq = outstanding_queue;
431: outstanding_queue = Select_rqueue[i];
432: nfound--;
433: }
434: }
435: if(FD_ISSET(i,&wmaskfd)) {
436: Select_rqueue[i] -> Se_oq = outstanding_queue;
437: outstanding_queue = Select_rqueue[i];
438: nfound--;
439: }
440: if(FD_ISSET(i,&emaskfd)) {
441: Select_rqueue[i] -> Se_oq = outstanding_queue;
442: outstanding_queue = Select_rqueue[i];
443: nfound--;
444: }
445: }
446: }
447: }
448:
449:
450: XtPending(dpy)
451: Display *dpy;
452: {
453: Fd_set rmask, wmask, emask;
454: struct timeval cur_time, wait_time;
455: struct timezone curzone;
456: int ret;
457: Fd_set *compositeRmask = &composite.rmask;
458:
459: (void) gettimeofday(&cur_time, &curzone);
460:
461: if(ret = XPending(dpy))
462: return(ret);
463:
464: if(outstanding_queue)
465: return(1);
466:
467: if(ISAFTER(&cur_time, &(Timer_queue->Te_tim.ti_value)))
468: return(1);
469:
470: FD_SET(ConnectionNumber(dpy),compositeRmask); /*should be done only once */
471: if(ConnectionNumber(dpy) +1 > composite.nfds)
472: composite.nfds = ConnectionNumber(dpy) + 1;
473: wait_time.tv_sec = 0;
474: wait_time.tv_usec = 0;
475: rmask = composite.rmask;
476: wmask = composite.wmask;
477: emask = composite.emask;
478: if(select(composite.nfds,(int *)&rmask,(int *)&wmask,(int*)&emask,&wait_time) > 0)
479: return(1);
480:
481: return(0);
482: }
483:
484: XtPeekEvent(dpy, event)
485: Display *dpy;
486: XEvent *event;
487: {
488: Fd_set rmask, wmask, emask;
489: int nfound, i;
490: struct timeval cur_time, wait_time;
491: struct timezone curzone;
492: int Claims_X_is_pending = 0;
493: XClientMessageEvent *ev = (XClientMessageEvent *)event;
494: Fd_set *compositeRmask = &composite.rmask;
495:
496: if(XPending(dpy)){
497: XPeekEvent(dpy, event); /* Xevents */
498: return(1);
499: }
500: if(outstanding_queue){
501: *event = *((XEvent *)&outstanding_queue->Se_event);
502: return(1);
503: }
504: (void) gettimeofday(&cur_time, &curzone);
505: if(ISAFTER(&cur_time, &(Timer_queue->Te_tim.ti_value))) {
506: ev->type = ClientMessage;
507: ev->display = dpy;
508: ev->window = Timer_queue->Te_wID;
509: ev->format = 32;
510: ev->message_type = XtTimerExpired;
511: ev->format = 32;
512: ev->data.l[0] = (int)Timer_queue->Te_cookie;
513: return(1);
514: }
515:
516: FD_SET(ConnectionNumber(dpy),compositeRmask);/* should be done only once */
517: if(ConnectionNumber(dpy) +1 > composite.nfds)
518: composite.nfds = ConnectionNumber(dpy) + 1;
519: TIMEDELTA(&wait_time, &Timer_next, &cur_time);
520: rmask = composite.rmask;
521: wmask = composite.wmask;
522: emask = composite.emask;
523: nfound=select(composite.nfds,(int *)&rmask,(int *)&wmask,(int *)&emask,&wait_time);
524:
525: for(i = 0; i < composite.nfds && nfound > 0;i++) {
526: if(FD_ISSET(i,&rmask)) {
527: if(i == ConnectionNumber(dpy)) {
528: Claims_X_is_pending= 1;
529: } else {
530: Select_rqueue[i] -> Se_oq = outstanding_queue;
531: outstanding_queue = Select_rqueue[i];
532: nfound--;
533: }
534: }
535: if(FD_ISSET(i,&wmask)) {
536: Select_rqueue[i] -> Se_oq = outstanding_queue;
537: outstanding_queue = Select_rqueue[i];
538: nfound--;
539: }
540: if(FD_ISSET(i,&emask)) {
541: Select_rqueue[i] -> Se_oq = outstanding_queue;
542: outstanding_queue = Select_rqueue[i];
543: nfound--;
544: }
545:
546: }
547: if(Claims_X_is_pending && XPending(dpy)) {
548: XPeekEvent(dpy, event);
549: return(1);
550: }
551:
552: if(outstanding_queue){
553: *event = *((XEvent *)&outstanding_queue->Se_event);
554: return(1);
555: }
556: return(0);
557: }
558:
559:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.