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