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