![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to XlibInt.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 / X / save|
Return to XlibInt.c CVS log | Up to [Research Unix] / researchv9 / X11 / src / X.V11R1 / lib / X / save |
1.1 root 1: #include "copyright.h"
2: /* Copyright Massachusetts Institute of Technology 1985, 1986, 1987 */
3:
4: #ifndef lint
5: static char rcsid[] = "$Header: XlibInt.c,v 11.55 87/08/20 17:25:23 newman Exp $";
6: #endif
7:
8: /*
9: * XlibInternal.c - Internal support routines for the C subroutine
10: * interface library (Xlib) to the X Window System Protocol V11.0.
11: */
12: #define NEED_EVENTS
13: #define NEED_REPLIES
14:
15: #include <stdio.h>
16: #include "Xlibint.h"
17:
18: /*
19: * The following routines are internal routines used by Xlib for protocol
20: * packet transmission and reception.
21: *
22: * XIOError(Display *) will be called if any sort of system call error occurs.
23: * This is assumed to be a fatal condition, i.e., XIOError should not return.
24: *
25: * XError(Display *, XErrorEvent *) will be called whenever an X_Error event is
26: * received. This is not assumed to be a fatal condition, i.e., it is
27: * acceptable for this procedure to return. However, XError should NOT
28: * perform any operations (directly or indirectly) on the DISPLAY.
29: *
30: * Routines declared with a return type of 'Status' return 0 on failure,
31: * and non 0 on success. Routines with no declared return type don't
32: * return anything. Whenever possible routines that create objects return
33: * the object they have created.
34: */
35:
36: _XQEvent *_qfree = NULL; /* NULL _XQEvent. */
37:
38: static int padlength[4] = {0, 3, 2, 1};
39: /* lookup table for adding padding bytes to data that is read from
40: or written to the X socket. */
41:
42: static xReq _dummy_request = {
43: 0, 0, 0
44: };
45: /*
46: * _XFlush - Flush the X request buffer. If the buffer is empty, no
47: * action is taken. This routine correctly handles incremental writes.
48: * This routine may have to be reworked if int < long.
49: */
50: _XFlush (dpy)
51: register Display *dpy;
52: {
53: register long size;
54: register int write_stat;
55: register char *bufindex;
56:
57: size = dpy->bufptr - dpy->buffer;
58: bufindex = dpy->bufptr = dpy->buffer;
59: /*
60: * While write has not written the entire buffer, keep looping
61: * until the entire buffer is written. bufindex will be incremented
62: * and size decremented as buffer is written out.
63: */
64: while (size) {
65: write_stat = WriteToServer(dpy->fd, bufindex, (int) size);
66: if (write_stat > 0) {
67: size -= write_stat;
68: bufindex += write_stat;
69: } else {
70: /* Write failed! */
71: /* errno set by write system call. */
72: (*_XIOErrorFunction)(dpy);
73: }
74: }
75: dpy->last_req = (char *)&_dummy_request;
76: }
77:
78: /*
79: * _XRead - Read bytes from the socket taking into account incomplete
80: * reads. This routine may have to be reworked if int < long.
81: */
82: _XRead (dpy, data, size)
83: register Display *dpy;
84: register char *data;
85: register long size;
86: {
87: register long bytes_read;
88:
89: if (size == 0) return;
90: while ((bytes_read = ReadFromServer(dpy->fd, data, (int)size))
91: != size) {
92:
93: if (bytes_read > 0) {
94: size -= bytes_read;
95: data += bytes_read;
96: }
97:
98: else if (bytes_read == 0) {
99: /* Read failed because of end of file! */
100: errno = EPIPE;
101: (*_XIOErrorFunction)(dpy);
102: }
103:
104: else /* bytes_read is less than 0; presumably -1 */ {
105: /* If it's a system call interrupt, it's not an error. */
106: if (errno != EINTR)
107: (*_XIOErrorFunction)(dpy);
108: }
109: }
110: }
111:
112: /*
113: * _XReadPad - Read bytes from the socket taking into account incomplete
114: * reads. If the number of bytes is not 0 mod 32, read additional pad
115: * bytes. This routine may have to be reworked if int < long.
116: */
117: _XReadPad (dpy, data, size)
118: register Display *dpy;
119: register char *data;
120: register long size;
121: {
122: register long bytes_read;
123: long padsize;
124: char pad[3];
125:
126: if (size == 0) return;
127: /*
128: * The following hack is used to provide 32 bit long-word
129: * aligned padding. The [1] vector is of length 0, 1, 2, or 3,
130: * whatever is needed.
131: */
132: padsize = padlength[size & 3];
133:
134: while ((bytes_read = ReadFromServer (dpy->fd, data, size)) != size) {
135:
136: if (bytes_read > 0) {
137: size -= bytes_read;
138: data += bytes_read;
139: }
140:
141: else if (bytes_read == 0) {
142: /* Read failed because of end of file! */
143: errno = EPIPE;
144: (*_XIOErrorFunction)(dpy);
145: }
146:
147: else /* bytes_read is less than 0; presumably -1 */ {
148: /* If it's a system call interrupt, it's not an error. */
149: if (errno != EINTR)
150: (*_XIOErrorFunction)(dpy);
151: }
152: }
153:
154: size = padsize;
155: if (size == 0) return;
156: data = pad;
157: while ((bytes_read = ReadFromServer (dpy->fd, data, size)) != size) {
158: if (bytes_read > 0) {
159: size -= bytes_read;
160: data += bytes_read;
161: }
162:
163: else if (bytes_read == 0) {
164: /* Read failed because of end of file! */
165: errno = EPIPE;
166: (*_XIOErrorFunction)(dpy);
167: }
168:
169: else /* bytes_read is less than 0; presumably -1 */ {
170: /* If it's a system call interrupt, it's not an error. */
171: if (errno != EINTR)
172: (*_XIOErrorFunction)(dpy);
173: }
174: }
175:
176: }
177:
178: /*
179: * _XSend - Flush the buffer and send the client data. 32 bit word aligned
180: * transmission is used, if size is not 0 mod 4, extra bytes are transmitted.
181: * This routine may have to be reworked if int < long;
182: */
183: _XSend (dpy, data, size)
184: register Display *dpy;
185: char *data;
186: register long size;
187: {
188: register long len;
189: static char pad[3] = {0, 0, 0};
190: /* XText8 and XText16 require that the padding bytes be zero! */
191:
192: len = dpy->bufptr - dpy->buffer;
193: dpy->bufptr = dpy->buffer;
194: if (len && WriteToServer(dpy->fd, dpy->buffer, len) != len)
195: (*_XIOErrorFunction)(dpy);
196: if (size && WriteToServer(dpy->fd, data, size) != size)
197: (*_XIOErrorFunction)(dpy);
198: /*
199: * The following hack is used to provide 32 bit long-word
200: * aligned padding. The [2] vector is of length 0, 1, 2, or 3,
201: * whatever is needed.
202: */
203: len = padlength[size & 3];
204: if (len && WriteToServer(dpy->fd, pad, len) != len)
205: (*_XIOErrorFunction)(dpy);
206: dpy->last_req = (char *) & _dummy_request;
207: }
208:
209: /*
210: * _XAllocID - normal resource ID allocation routine. A client
211: * can roll his own and instatantiate it if he wants, but must
212: * follow the rules.
213: */
214: XID _XAllocID(dpy)
215: register Display *dpy;
216: {
217: return (dpy->resource_base + (dpy->resource_id++ << dpy->resource_shift));
218: }
219:
220: /*
221: * _XReply - Wait for a reply packet and copy its contents into the
222: * specified rep. Mean while we must handle error and event packets that
223: * we may encounter.
224: */
225: Status _XReply (dpy, rep, extra, discard)
226: register Display *dpy;
227: register xReply *rep;
228: int extra; /* number of 32-bit words expected after the reply */
229: Bool discard; /* should I discard data followind "extra" words? */
230: {
231: _XFlush(dpy);
232: while (1) {
233: _XRead(dpy, (char *)rep, (long)sizeof(xReply));
234: switch ((int)rep->generic.type) {
235:
236: case X_Reply:
237: /* Reply recieved. */
238: if (extra == 0) {
239: if (discard && (rep->generic.length > 0))
240: /* unexpectedly long reply! */
241: _EatData (dpy, rep->generic.length);
242: return (1);
243: }
244: if (extra == rep->generic.length) {
245: /*
246: * Read the extra data into storage immediately following
247: * the GenericReply structure.
248: */
249: _XRead (dpy, (char *) (rep+1), ((long)extra)<<2);
250: return (1);
251: }
252: if (extra < rep->generic.length) {
253: /* Actual reply is longer than "extra" */
254: _XRead (dpy, (char *) (rep+1), ((long)extra)<<2);
255: if (discard)
256: _EatData (dpy, rep->generic.length - extra);
257: return (1);
258: }
259: /*
260: *if we get here, then extra > rep->generic.length--meaning we
261: * read a reply that's shorter than we expected. This is an
262: * error, but we still need to figure out how to handle it...
263: */
264: _XRead (dpy, (char *) (rep+1), (long) (rep->generic.length<<2));
265: (*_XIOErrorFunction) (dpy);
266: return (0);
267:
268: case X_Error:
269: {
270: register _XExtension *ext;
271: register Bool ret = False;
272: int ret_code;
273: xError *err = (xError *) rep;
274: if (err->sequenceNumber == dpy->request)
275: /* do not die on "no such font", "can't allocate",
276: "can't grab" failures */
277: switch ((int)err->errorCode) {
278: case BadName:
279: switch (err->majorCode)
280: case X_OpenFont:
281: case X_LookupColor:
282: case X_AllocNamedColor:
283: return(0);
284: break;
285: case BadFont:
286: if (err->majorCode == X_QueryFont)
287: return (0);
288: break;
289: case BadAlloc:
290: case BadAccess:
291: return (0);
292: /*
293: * we better see if there is an extension who may
294: * want to suppress the error.
295: */
296: default:
297: ext = dpy->ext_procs;
298: while (ext) {
299: if (ext->error != NULL)
300: ret = (*ext->error)
301: (dpy, err, &ext->codes, &ret_code);
302: ext = ext->next;
303: }
304: if (ret) return (ret_code);
305: break;
306: }
307: _XError(dpy, err);
308: if (err->sequenceNumber == dpy->request)
309: return(0);
310: }
311: break;
312: default:
313: _XEnq(dpy, (xEvent *) rep);
314: break;
315: }
316: }
317: }
318:
319:
320: /* Read and discard "n" 32-bit words. */
321:
322: static _EatData (dpy, n)
323: Display *dpy;
324: unsigned long n;
325: {
326: unsigned int bufsize;
327: char *buf;
328: n <<= 2; /* convert to number of bytes */
329: buf = Xmalloc (bufsize = (n > 2048) ? 2048 : n);
330: while (n) {
331: long bytes_read = (n > bufsize) ? bufsize : n;
332: _XRead (dpy, buf, bytes_read);
333: n -= bytes_read;
334: }
335: Xfree (buf);
336: }
337:
338: /*
339: * _XEnq - Place event packets on the display's queue.
340: * note that no squishing of move events in V11, since there
341: * is pointer motion hints....
342: */
343: _XEnq (dpy, event)
344: register Display *dpy;
345: register xEvent *event;
346: {
347: register _XQEvent *qelt;
348:
349: /*NOSTRICT*/
350: if (qelt = _qfree) {
351: /* If _qfree is non-NULL do this, else malloc a new one. */
352: _qfree = qelt->next;
353: }
354: else if ((qelt =
355: (_XQEvent *) Xmalloc((unsigned)sizeof(_XQEvent))) == NULL) {
356: /* Malloc call failed! */
357: errno = ENOMEM;
358: (*_XIOErrorFunction)(dpy);
359: }
360: qelt->next = NULL;
361: /* go call through display to find proper event reformatter */
362: (*dpy->event_vec[event->u.u.type & 0177])(dpy, &qelt->event, event);
363:
364: if (dpy->tail) dpy->tail->next = qelt;
365: else dpy->head = qelt;
366:
367: dpy->tail = qelt;
368: dpy->qlen++;
369: }
370: /*
371: * EventToWire in seperate file in that often not needed.
372: */
373:
374: /*ARGSUSED*/
375: _XUnknownWireEvent(dpy, re, event)
376: register Display *dpy; /* pointer to display structure */
377: register XEvent *re; /* pointer to where event should be reformatted */
378: register xEvent *event; /* wire protocol event */
379: {
380: (void) fprintf(stderr,
381: "Xlib: unhandled wire event! event number = %d, display = %x\n.",
382: event->u.u.type, dpy);
383: exit(1);
384: }
385:
386: /*ARGSUSED*/
387: _XUnknownNativeEvent(dpy, re, event)
388: register Display *dpy; /* pointer to display structure */
389: register XEvent *re; /* pointer to where event should be reformatted */
390: register xEvent *event; /* wire protocol event */
391: {
392: (void) fprintf(stderr,
393: "Xlib: unhandled native event! event number = %d, display = %x\n.",
394: re->type, dpy);
395: exit(1);
396: }
397: /*
398: * reformat a wire event into an XEvent structure of the right type.
399: */
400: _XWireToEvent(dpy, re, event)
401: register Display *dpy; /* pointer to display structure */
402: register XEvent *re; /* pointer to where event should be reformatted */
403: register xEvent *event; /* wire protocol event */
404: {
405:
406: ((XAnyEvent *)re)->display = dpy;
407: re->type = event->u.u.type;
408:
409: /* Ignore the leading bit of the event type since it is set when a
410: client sends an event rather than the server. */
411:
412: switch (event-> u.u.type & 0177) {
413: case KeyPress:
414: case KeyRelease:
415: {
416: register XKeyEvent *ev = (XKeyEvent*) re;
417: ev->root = event->u.keyButtonPointer.root;
418: ev->window = event->u.keyButtonPointer.event;
419: ev->subwindow = event->u.keyButtonPointer.child;
420: ev->time = event->u.keyButtonPointer.time;
421: ev->x = event->u.keyButtonPointer.eventX;
422: ev->y = event->u.keyButtonPointer.eventY;
423: ev->x_root = event->u.keyButtonPointer.rootX;
424: ev->y_root = event->u.keyButtonPointer.rootY;
425: ev->state = event->u.keyButtonPointer.state;
426: ev->same_screen = event->u.keyButtonPointer.sameScreen;
427: ev->keycode = event->u.u.detail;
428: }
429: break;
430: case ButtonPress:
431: case ButtonRelease:
432: {
433: register XButtonEvent *ev = (XButtonEvent *) re;
434: ev->root = event->u.keyButtonPointer.root;
435: ev->window = event->u.keyButtonPointer.event;
436: ev->subwindow = event->u.keyButtonPointer.child;
437: ev->time = event->u.keyButtonPointer.time;
438: ev->x = event->u.keyButtonPointer.eventX;
439: ev->y = event->u.keyButtonPointer.eventY;
440: ev->x_root = event->u.keyButtonPointer.rootX;
441: ev->y_root = event->u.keyButtonPointer.rootY;
442: ev->state = event->u.keyButtonPointer.state;
443: ev->same_screen = event->u.keyButtonPointer.sameScreen;
444: ev->button = event->u.u.detail;
445: }
446: break;
447: case MotionNotify:
448: {
449: register XMotionEvent *ev = (XMotionEvent *)re;
450: ev->root = event->u.keyButtonPointer.root;
451: ev->window = event->u.keyButtonPointer.event;
452: ev->subwindow = event->u.keyButtonPointer.child;
453: ev->time = event->u.keyButtonPointer.time;
454: ev->x = event->u.keyButtonPointer.eventX;
455: ev->y = event->u.keyButtonPointer.eventY;
456: ev->x_root = event->u.keyButtonPointer.rootX;
457: ev->y_root = event->u.keyButtonPointer.rootY;
458: ev->state = event->u.keyButtonPointer.state;
459: ev->same_screen = event->u.keyButtonPointer.sameScreen;
460: ev->is_hint = event->u.u.detail;
461: }
462: break;
463: case EnterNotify:
464: case LeaveNotify:
465: {
466: register XCrossingEvent *ev = (XCrossingEvent *) re;
467: ev->root = event->u.enterLeave.root;
468: ev->window = event->u.enterLeave.event;
469: ev->subwindow = event->u.enterLeave.child;
470: ev->time = event->u.enterLeave.time;
471: ev->x = event->u.enterLeave.eventX;
472: ev->y = event->u.enterLeave.eventY;
473: ev->x_root = event->u.enterLeave.rootX;
474: ev->y_root = event->u.enterLeave.rootY;
475: ev->state = event->u.enterLeave.state;
476: ev->mode = event->u.enterLeave.mode;
477: ev->same_screen = (event->u.enterLeave.flags &
478: ELFlagSameScreen) && True;
479: ev->focus = (event->u.enterLeave.flags &
480: ELFlagFocus) && True;
481: ev->detail = event->u.u.detail;
482: }
483: break;
484: case FocusIn:
485: case FocusOut:
486: {
487: register XFocusChangeEvent *ev = (XFocusChangeEvent *) re;
488: ev->window = event->u.focus.window;
489: ev->mode = event->u.focus.mode;
490: ev->detail = event->u.u.detail;
491: }
492: break;
493: case KeymapNotify:
494: {
495: register XKeymapEvent *ev = (XKeymapEvent *) re;
496: ev->window = dpy->current;
497: bcopy ((char *)((xKeymapEvent *) event)->map,
498: &ev->key_vector[1],
499: sizeof (((xKeymapEvent *) event)->map));
500: }
501: break;
502: case Expose:
503: {
504: register XExposeEvent *ev = (XExposeEvent *) re;
505: ev->window = event->u.expose.window;
506: ev->x = event->u.expose.x;
507: ev->y = event->u.expose.y;
508: ev->width = event->u.expose.width;
509: ev->height = event->u.expose.height;
510: ev->count = event->u.expose.count;
511: }
512: break;
513: case GraphicsExpose:
514: {
515: register XGraphicsExposeEvent *ev =
516: (XGraphicsExposeEvent *) re;
517: ev->drawable = event->u.graphicsExposure.drawable;
518: ev->x = event->u.graphicsExposure.x;
519: ev->y = event->u.graphicsExposure.y;
520: ev->width = event->u.graphicsExposure.width;
521: ev->height = event->u.graphicsExposure.height;
522: ev->count = event->u.graphicsExposure.count;
523: ev->major_code = event->u.graphicsExposure.majorEvent;
524: ev->minor_code = event->u.graphicsExposure.minorEvent;
525: }
526: break;
527: case NoExpose:
528: {
529: register XNoExposeEvent *ev = (XNoExposeEvent *) re;
530: ev->drawable = event->u.noExposure.drawable;
531: ev->major_code = event->u.noExposure.majorEvent;
532: ev->minor_code = event->u.noExposure.minorEvent;
533: }
534: break;
535: case VisibilityNotify:
536: {
537: register XVisibilityEvent *ev = (XVisibilityEvent *) re;
538: ev->window = event->u.visibility.window;
539: ev->state = event->u.visibility.state;
540: }
541: break;
542: case CreateNotify:
543: {
544: register XCreateWindowEvent *ev =
545: (XCreateWindowEvent *) re;
546: ev->window = event->u.createNotify.window;
547: ev->parent = event->u.createNotify.parent;
548: ev->x = event->u.createNotify.x;
549: ev->y = event->u.createNotify.y;
550: ev->width = event->u.createNotify.width;
551: ev->height = event->u.createNotify.height;
552: ev->border_width = event->u.createNotify.borderWidth;
553: ev->override_redirect = event->u.createNotify.override;
554: }
555: break;
556: case DestroyNotify:
557: {
558: register XDestroyWindowEvent *ev =
559: (XDestroyWindowEvent *) re;
560: ev->window = event->u.destroyNotify.window;
561: ev->event = event->u.destroyNotify.event;
562: }
563: break;
564: case UnmapNotify:
565: {
566: register XUnmapEvent *ev = (XUnmapEvent *) re;
567: ev->window = event->u.unmapNotify.window;
568: ev->event = event->u.unmapNotify.event;
569: ev->from_configure = event->u.unmapNotify.fromConfigure;
570: }
571: break;
572: case MapNotify:
573: {
574: register XMapEvent *ev = (XMapEvent *) re;
575: ev->window = event->u.mapNotify.window;
576: ev->event = event->u.mapNotify.event;
577: ev->override_redirect = event->u.mapNotify.override;
578: }
579: break;
580: case MapRequest:
581: {
582: register XMapRequestEvent *ev = (XMapRequestEvent *) re;
583: ev->window = event->u.mapRequest.window;
584: ev->parent = event->u.mapRequest.parent;
585: }
586: break;
587: case ReparentNotify:
588: {
589: register XReparentEvent *ev = (XReparentEvent *) re;
590: ev->event = event->u.reparent.event;
591: ev->window = event->u.reparent.window;
592: ev->parent = event->u.reparent.parent;
593: ev->x = event->u.reparent.x;
594: ev->y = event->u.reparent.y;
595: ev->override_redirect = event->u.reparent.override;
596: }
597: break;
598: case ConfigureNotify:
599: {
600: register XConfigureEvent *ev = (XConfigureEvent *) re;
601: ev->event = event->u.configureNotify.event;
602: ev->window = event->u.configureNotify.window;
603: ev->above = event->u.configureNotify.aboveSibling;
604: ev->x = event->u.configureNotify.x;
605: ev->y = event->u.configureNotify.y;
606: ev->width = event->u.configureNotify.width;
607: ev->height = event->u.configureNotify.height;
608: ev->border_width = event->u.configureNotify.borderWidth;
609: ev->override_redirect = event->u.configureNotify.override;
610: }
611: break;
612: case ConfigureRequest:
613: {
614: register XConfigureRequestEvent *ev =
615: (XConfigureRequestEvent *) re;
616: ev->window = event->u.configureRequest.window;
617: ev->parent = event->u.configureRequest.parent;
618: ev->above = event->u.configureRequest.sibling;
619: ev->x = event->u.configureRequest.x;
620: ev->y = event->u.configureRequest.y;
621: ev->width = event->u.configureRequest.width;
622: ev->height = event->u.configureRequest.height;
623: ev->border_width = event->u.configureRequest.borderWidth;
624: ev->value_mask = event->u.configureRequest.valueMask;
625: ev->detail = event->u.u.detail;
626: }
627: break;
628: case GravityNotify:
629: {
630: register XGravityEvent *ev = (XGravityEvent *) re;
631: ev->window = event->u.gravity.window;
632: ev->event = event->u.gravity.event;
633: ev->x = event->u.gravity.x;
634: ev->y = event->u.gravity.y;
635: }
636: break;
637: case ResizeRequest:
638: {
639: register XResizeRequestEvent *ev =
640: (XResizeRequestEvent *) re;
641: ev->window = event->u.resizeRequest.window;
642: ev->width = event->u.resizeRequest.width;
643: ev->height = event->u.resizeRequest.height;
644: }
645: break;
646: case CirculateNotify:
647: {
648: register XCirculateEvent *ev = (XCirculateEvent *) re;
649: ev->window = event->u.circulate.window;
650: ev->event = event->u.circulate.event;
651: ev->place = event->u.circulate.place;
652: }
653: break;
654: case CirculateRequest:
655: {
656: register XCirculateRequestEvent *ev =
657: (XCirculateRequestEvent *) re;
658: ev->window = event->u.circulate.window;
659: ev->parent = event->u.circulate.event;
660: ev->place = event->u.circulate.place;
661: }
662: break;
663: case PropertyNotify:
664: {
665: register XPropertyEvent *ev = (XPropertyEvent *) re;
666: ev->window = event->u.property.window;
667: ev->atom = event->u.property.atom;
668: ev->time = event->u.property.time;
669: ev->state = event->u.property.state;
670: }
671: break;
672: case SelectionClear:
673: {
674: register XSelectionClearEvent *ev =
675: (XSelectionClearEvent *) re;
676: ev->window = event->u.selectionClear.window;
677: ev->selection = event->u.selectionClear.atom;
678: ev->time = event->u.selectionClear.time;
679: }
680: break;
681: case SelectionRequest:
682: {
683: register XSelectionRequestEvent *ev =
684: (XSelectionRequestEvent *) re;
685: ev->owner = event->u.selectionRequest.owner;
686: ev->requestor = event->u.selectionRequest.requestor;
687: ev->selection = event->u.selectionRequest.selection;
688: ev->target = event->u.selectionRequest.target;
689: ev->property = event->u.selectionRequest.property;
690: ev->time = event->u.selectionRequest.time;
691: }
692: break;
693: case SelectionNotify:
694: {
695: register XSelectionEvent *ev = (XSelectionEvent *) re;
696: ev->requestor = event->u.selectionNotify.requestor;
697: ev->selection = event->u.selectionNotify.selection;
698: ev->target = event->u.selectionNotify.target;
699: ev->property = event->u.selectionNotify.property;
700: ev->time = event->u.selectionNotify.time;
701: }
702: break;
703: case ColormapNotify:
704: {
705: register XColormapEvent *ev = (XColormapEvent *) re;
706: ev->window = event->u.colormap.window;
707: ev->colormap = event->u.colormap.colormap;
708: ev->new = event->u.colormap.new;
709: ev->state = event->u.colormap.state;
710: }
711: break;
712: case ClientMessage:
713: {
714: register int i;
715: register XClientMessageEvent *ev
716: = (XClientMessageEvent *) re;
717: ev->window = event->u.clientMessage.window;
718: ev->format = event->u.u.detail;
719: switch (ev->format) {
720: case 8:
721: ev->message_type = event->u.clientMessage.u.b.type;
722: for (i = 0; i < 20; i++)
723: ev->data.b[i] = event->u.clientMessage.u.b.bytes[i];
724: break;
725: case 16:
726: ev->message_type = event->u.clientMessage.u.s.type;
727: ev->data.s[0] = event->u.clientMessage.u.s.shorts0;
728: ev->data.s[1] = event->u.clientMessage.u.s.shorts1;
729: ev->data.s[2] = event->u.clientMessage.u.s.shorts2;
730: ev->data.s[3] = event->u.clientMessage.u.s.shorts3;
731: ev->data.s[4] = event->u.clientMessage.u.s.shorts4;
732: ev->data.s[5] = event->u.clientMessage.u.s.shorts5;
733: ev->data.s[6] = event->u.clientMessage.u.s.shorts6;
734: ev->data.s[7] = event->u.clientMessage.u.s.shorts7;
735: ev->data.s[8] = event->u.clientMessage.u.s.shorts8;
736: ev->data.s[9] = event->u.clientMessage.u.s.shorts9;
737: break;
738: case 32:
739: ev->message_type = event->u.clientMessage.u.l.type;
740: ev->data.l[0] = event->u.clientMessage.u.l.longs0;
741: ev->data.l[1] = event->u.clientMessage.u.l.longs1;
742: ev->data.l[2] = event->u.clientMessage.u.l.longs2;
743: ev->data.l[3] = event->u.clientMessage.u.l.longs3;
744: ev->data.l[4] = event->u.clientMessage.u.l.longs4;
745: break;
746: default: /* XXX should never occur */
747: break;
748: }
749: }
750: break;
751: case MappingNotify:
752: {
753: register XMappingEvent *ev = (XMappingEvent *)re;
754: ev->first_keycode = event->u.mappingNotify.firstKeyCode;
755: ev->request = event->u.mappingNotify.request;
756: ev->count = event->u.mappingNotify.count;
757: }
758: break;
759: default:
760: /* XXX should do something about unknown event here */
761: break;
762: }
763: }
764:
765:
766: /*
767: * _XIOError - Default fatal system error reporting routine. Called when
768: * an X internal system error is encountered.
769: */
770: _XIOError (dpy)
771: Display *dpy;
772: {
773: if (errno == EPIPE) {
774: (void) fprintf (stderr,
775: "Connection # %d to server broken.\n", dpy->fd);
776: }
777: perror("XIO");
778: exit(1);
779: }
780:
781: /*
782: * _XError - Default non-fatal error reporting routine. Called when an
783: * X_Error packet is encountered in the input stream.
784: */
785: int _XError (dpy, rep)
786: Display *dpy;
787: xError *rep;
788: {
789: XErrorEvent event;
790: /*
791: * X_Error packet encountered! We need to unpack the error before
792: * giving it to the user.
793: */
794:
795: event.display = dpy;
796: event.type = X_Error;
797: event.serial = rep->sequenceNumber;
798: event.resourceid = rep->resourceID;
799: event.error_code = rep->errorCode;
800: event.request_code = rep->majorCode;
801: event.minor_code = rep->minorCode;
802: if (_XErrorFunction != NULL) {
803: return ((*_XErrorFunction)(dpy, &event));
804: }
805: exit(1);
806: return(0); /* stupid lint */
807: }
808:
809: int _XDefaultError(dpy, event)
810: Display *dpy;
811: XErrorEvent *event;
812: {
813: char buffer[BUFSIZ];
814: char mesg[BUFSIZ];
815: char number[32];
816: char *mtype = "XlibMessage";
817: XGetErrorText(dpy, event->error_code, buffer, BUFSIZ);
818: XGetErrorDatabaseText(dpy, mtype, "XError", "X Error", mesg, BUFSIZ);
819: (void) fprintf(stderr, "%s: %s\n ", mesg, buffer);
820: XGetErrorDatabaseText(dpy, mtype, "MajorCode", "Request Major code %d",
821: mesg, BUFSIZ);
822: (void) fprintf(stderr, mesg, event->request_code);
823: sprintf(number, "%d", event->request_code);
824: XGetErrorDatabaseText(dpy, "XRequest", number, "", buffer, BUFSIZ);
825: (void) fprintf(stderr, " %s", buffer);
826: fputs("\n ", stderr);
827: XGetErrorDatabaseText(dpy, mtype, "MinorCode", "Request Minor code",
828: mesg, BUFSIZ);
829: (void) fprintf(stderr, mesg, event->minor_code);
830: fputs("\n ", stderr);
831: XGetErrorDatabaseText(dpy, mtype, "ResourceID", "ResourceID 0x%x",
832: mesg, BUFSIZ);
833: (void) fprintf(stderr, mesg, event->resourceid);
834: fputs("\n ", stderr);
835: XGetErrorDatabaseText(dpy, mtype, "ErrorSerial", "Error Serial #%d",
836: mesg, BUFSIZ);
837: (void) fprintf(stderr, mesg, event->serial);
838: fputs("\n ", stderr);
839: XGetErrorDatabaseText(dpy, mtype, "CurrentSerial", "Current Serial #%d",
840: mesg, BUFSIZ);
841: (void) fprintf(stderr, mesg, dpy->request);
842: fputs("\n ", stderr);
843: if (event->error_code == BadImplementation) return 0;
844: exit(1);
845: return (0); /* stupid lint */
846: }
847:
848: int (*_XIOErrorFunction)() = _XIOError;
849: int (*_XErrorFunction)() = _XDefaultError;
850:
851: /*
852: * This routine can be used to (cheaply) get some memory within a single
853: * Xlib routine for scratch space. It is reallocated from the same place
854: * each time, unless the library needs a large scratch space.
855: */
856: char *_XAllocScratch (dpy, nbytes)
857: register Display *dpy;
858: unsigned long nbytes;
859: {
860: if (nbytes > dpy->scratch_length) {
861: if (dpy->scratch_buffer != NULL) Xfree (dpy->scratch_buffer);
862: return( dpy->scratch_length = nbytes,
863: dpy->scratch_buffer = Xmalloc ((unsigned)nbytes) );
864: }
865: return (dpy->scratch_buffer);
866: }
867:
868: /*
869: * Given a visual id, find the visual structure for this id on this display.
870: */
871: Visual *_XVIDtoVisual (dpy, id)
872: Display *dpy;
873: VisualID id;
874: {
875: register int i, j, k;
876: register Screen *sp;
877: register Depth *dp;
878: register Visual *vp;
879: for (i = 0; i < dpy->nscreens; i++) {
880: sp = &dpy->screens[i];
881: for (j = 0; j < sp->ndepths; j++) {
882: dp = &sp->depths[j];
883: for (k = 0; k < dp->nvisuals; k++) {
884: vp = &dp->visuals[k];
885: if (vp->visualid == id) return (vp);
886: }
887: }
888: }
889: return (NULL);
890: }
891:
892: XFree (data)
893: char *data;
894: {
895: Xfree (data);
896: }
897:
898: #ifdef BIGSHORTS
899: UnpackShorts(from, to, bytes)
900: ushort_p *from;
901: short *to;
902: unsigned bytes;
903: {
904: unsigned i;
905: for (i = 0; i < (bytes/psizeof(short)); i++)
906: if (i&1)
907: to[i] = from[i>>1].right;
908: else
909: to[i] = from[i>>1].left;
910: }
911:
912: char packbuffer[1000];
913: PackData(dpy, data, len)
914: register Display *dpy;
915: short *data;
916: unsigned len;
917: {
918: if (dpy->bufptr + len < dpy->bufmax) {
919: PackShorts(data, dpy->bufptr, len);
920: dpy->bufptr += (len + 3) & ~3;
921: } else {
922: PackShorts(data, packbuffer, len);
923: _XSend(dpy, packbuffer, len);
924: }
925: }
926:
927: PackShorts(from, to, bytes)
928: short *from;
929: char *to;
930: unsigned bytes;
931: {
932: unsigned i, n, offset;
933: ushort_p *uto;
934:
935: uto = (ushort_p *)to;
936: offset = ((int)to & 2) >> 1; /* lost 2 bits of pointer */
937: n = (bytes / 2) + offset;
938: for (i = offset; i < n; i++) {
939: if (i&1)
940: uto[i>>1].right = from[i-offset];
941: else
942: uto[i>>1].left = from[i-offset];
943: }
944: }
945: #endif
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.