![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to libj.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv10no / cmd / movie|
Return to libj.c CVS log | Up to [Research Unix] / researchv10no / cmd / movie |
1.1 ! root 1: #include "xjerq.h" ! 2: #include <errno.h> ! 3: #ifdef BSD ! 4: #include <sys/ioctl.h> ! 5: #else ! 6: #include <sys/filio.h> ! 7: #endif ! 8: ! 9: Rectangle Drect; ! 10: Bitmap display; ! 11: struct Mouse mouse; ! 12: static struct JProc sP; ! 13: struct JProc *P; ! 14: GC gcs[4]; ! 15: Display *dpy; ! 16: unsigned long fgpix; ! 17: unsigned long bgpix; ! 18: Colormap colormap; ! 19: XColor fgcolor, bgcolor; ! 20: Font defont; ! 21: ! 22: static short arrow_bits[]={ ! 23: 0x0004, 0x000E, 0x001F, 0x003E, ! 24: 0x007C, 0x00F8, 0x01F0, 0x83E0, ! 25: 0x87C0, 0xCF80, 0xDF00, 0xFE00, ! 26: 0xFC00, 0xF800, 0xFE00, 0xFF80, ! 27: }; ! 28: Cursor normalcursor; ! 29: ! 30: /* ! 31: * Buffer for keyboard input ! 32: */ ! 33: #define KBDBUFSIZE 128 ! 34: static unsigned char kbdbuffer[KBDBUFSIZE]; ! 35: ! 36: static struct { ! 37: unsigned char *buf; ! 38: unsigned char *in; ! 39: unsigned char *out; ! 40: int cnt; ! 41: int size; ! 42: } kbdbuf = {kbdbuffer, kbdbuffer, kbdbuffer, 0, KBDBUFSIZE}; ! 43: ! 44: initdisplay(argc, argv) ! 45: int argc; ! 46: char *argv[]; ! 47: { ! 48: int i; ! 49: Window win; ! 50: XSetWindowAttributes xswa; ! 51: XSizeHints sizehints; ! 52: Font *df; ! 53: char *font; ! 54: char *geom = 0; ! 55: int flags; ! 56: int width, height, x, y; ! 57: char **ap; ! 58: ! 59: if (!(dpy= XOpenDisplay(NULL))) { ! 60: perror("Cannot open display\n"); ! 61: exit(-1); ! 62: } ! 63: ! 64: if ((font = XGetDefault(dpy, argv[0], "JerqFont")) == NULL) ! 65: font = "fixed"; ! 66: bzero(&sizehints, sizeof(sizehints)); ! 67: ap = argv; i = argc; ! 68: while (i-- > 0) { ! 69: if (!strcmp("-fn", ap[0])) { ! 70: font = ap[1]; ! 71: i--; ap++; ! 72: } ! 73: else if (ap[0][0] == '=') { ! 74: geom = ap[0]; ! 75: flags = XParseGeometry(ap[0], &x, &y, &width, &height); ! 76: if(WidthValue & flags) { ! 77: sizehints.flags |= USSize; ! 78: sizehints.width = width; ! 79: } ! 80: if(HeightValue & flags) { ! 81: sizehints.flags |= USSize; ! 82: sizehints.height = height; ! 83: } ! 84: if(XValue & flags) { ! 85: if(XNegative & flags) ! 86: x = DisplayWidth(dpy, DefaultScreen(dpy)) + x ! 87: - sizehints.width; ! 88: sizehints.flags |= USPosition; ! 89: sizehints.x = x; ! 90: } ! 91: if(YValue & flags) { ! 92: if(YNegative & flags) ! 93: y = DisplayHeight(dpy, DefaultScreen(dpy)) + y ! 94: -sizehints.height; ! 95: sizehints.flags |= USPosition; ! 96: sizehints.y = y; ! 97: } ! 98: } ! 99: ap++; ! 100: } ! 101: ! 102: df = XLoadQueryFont(dpy, font); ! 103: defont = *df; ! 104: P = &sP; ! 105: ! 106: sizehints.width_inc = sizehints.height_inc = 1; ! 107: sizehints.min_width = sizehints.min_height = 20; ! 108: sizehints.flags |= PResizeInc|PMinSize; ! 109: if (!geom) { ! 110: sizehints.width = defont.max_bounds.width * 80; ! 111: sizehints.height = (defont.max_bounds.ascent + ! 112: defont.max_bounds.descent) * 24; ! 113: sizehints.flags |= PSize; ! 114: } ! 115: ! 116: xswa.event_mask = 0; ! 117: bgpix = xswa.background_pixel = WhitePixel(dpy, 0); ! 118: fgpix = xswa.border_pixel = BlackPixel(dpy, 0); ! 119: win = XCreateWindow(dpy, RootWindow(dpy, DefaultScreen(dpy)), ! 120: sizehints.x, sizehints.y, sizehints.width, sizehints.height, ! 121: 2, 0, ! 122: InputOutput, DefaultVisual(dpy, DefaultScreen(dpy)), ! 123: CWEventMask | CWBackPixel | CWBorderPixel, &xswa); ! 124: ! 125: XSetStandardProperties(dpy, win, argv[0], argv[0], ! 126: None, argv, argc, &sizehints); ! 127: ! 128: XSelectInput(dpy, win, ! 129: ButtonPressMask|ButtonReleaseMask|ButtonMotionMask| ! 130: StructureNotifyMask|ExposureMask|KeyPressMask); ! 131: XMapWindow(dpy, win); ! 132: ! 133: colormap = XDefaultColormap(dpy, 0); ! 134: fgcolor.pixel = fgpix; ! 135: bgcolor.pixel = bgpix; ! 136: XQueryColor(dpy, colormap, &fgcolor); ! 137: XQueryColor(dpy, colormap, &bgcolor); ! 138: ! 139: gcs[F_STORE] = XCreateGC(dpy, win, 0, NULL); ! 140: XSetForeground(dpy, gcs[F_STORE], fgpix); ! 141: XSetBackground(dpy, gcs[F_STORE], bgpix); ! 142: XSetFont(dpy, gcs[F_STORE], defont.fid); ! 143: gcs[F_OR] = XCreateGC(dpy, win, 0, NULL); ! 144: XCopyGC(dpy, gcs[F_STORE], GCForeground|GCBackground|GCFont, gcs[F_OR]); ! 145: gcs[F_CLR] = XCreateGC(dpy, win, 0, NULL); ! 146: XCopyGC(dpy, gcs[F_STORE], GCBackground|GCFont, gcs[F_CLR]); ! 147: XSetForeground(dpy, gcs[F_CLR], bgpix); ! 148: gcs[F_XOR] = XCreateGC(dpy, win, 0, NULL); ! 149: XCopyGC(dpy, gcs[F_STORE], GCBackground|GCFont, gcs[F_XOR]); ! 150: XSetForeground(dpy, gcs[F_XOR], AllPlanes); ! 151: XSetFunction(dpy, gcs[F_XOR], GXxor); ! 152: ! 153: display.dr = win; ! 154: Drect.origin.x = 0; ! 155: Drect.origin.y = 0; ! 156: Drect.corner.x = sizehints.width; ! 157: Drect.corner.y = sizehints.height; ! 158: display.rect = Drect; ! 159: while (! P->state & RESHAPED) ! 160: handleinput(); /* wait for exposure */ ! 161: P->state &= ~RESHAPED; ! 162: normalcursor = ToCursor(arrow_bits, arrow_bits, 0, 15); ! 163: cursswitch(&normalcursor); ! 164: ! 165: ! 166: } ! 167: ! 168: Bitmap * ! 169: balloc(r) ! 170: Rectangle r; ! 171: { ! 172: Bitmap *b; ! 173: Pixmap pm; ! 174: b=(Bitmap *)malloc(sizeof (struct Bitmap)); ! 175: pm = XCreatePixmap(dpy, display.dr, r.corner.x-r.origin.x, ! 176: r.corner.y-r.origin.y, DefaultDepth(dpy, 0)); ! 177: b->dr=pm; ! 178: b->rect=r; ! 179: b->flag = BI_PIXMAP; ! 180: return b; ! 181: } ! 182: ! 183: void ! 184: bfree(b) ! 185: Bitmap *b; ! 186: { ! 187: if(b){ ! 188: XFreePixmap(dpy, b->dr); ! 189: free((char *)b); ! 190: } ! 191: } ! 192: ! 193: #define brx(b) (b->rect.origin.x) ! 194: #define bry(b) (b->rect.origin.y) ! 195: ! 196: void ! 197: rectf(b,r,f) ! 198: Bitmap *b; ! 199: Rectangle r; ! 200: Code f; ! 201: { ! 202: register wd=r.corner.x-r.origin.x; ! 203: register ht=r.corner.y-r.origin.y; ! 204: ! 205: if (b->flag & BI_PIXMAP) ! 206: r.origin = sub(r.origin, b->rect.origin); ! 207: XFillRectangle(dpy, b->dr, gcs[f], r.origin.x, r.origin.y, wd, ht); ! 208: } ! 209: ! 210: void ! 211: bitblt(sb,r,db,p,f) ! 212: Bitmap *sb, *db; ! 213: Rectangle r; /* in source bitmap */ ! 214: Point p; /* in dest bitmap */ ! 215: Code f; ! 216: { ! 217: int wd=r.corner.x-r.origin.x; ! 218: int ht=r.corner.y-r.origin.y; ! 219: ! 220: if (sb->flag & BI_PIXMAP) ! 221: r.origin = sub(r.origin, sb->rect.origin); ! 222: if (db->flag & BI_PIXMAP) ! 223: p = sub(p, db->rect.origin); ! 224: XCopyArea(dpy, sb->dr, db->dr, gcs[f], r.origin.x, r.origin.y, ! 225: wd, ht, p.x, p.y); ! 226: } ! 227: ! 228: Point ! 229: string(ft, s, b, p, f) ! 230: XFontStruct *ft; ! 231: char *s; ! 232: Bitmap *b; ! 233: Point p; ! 234: Code f; ! 235: { ! 236: Point p1; ! 237: int i; ! 238: ! 239: i = strlen(s); ! 240: p1 = p; ! 241: p.y += ft->max_bounds.ascent; ! 242: if (b->flag & BI_PIXMAP) ! 243: p = sub(p, b->rect.origin); ! 244: XDrawString(dpy, b->dr, gcs[f], p.x, p.y, s, i); ! 245: p1.x += XTextWidth(ft, s, i); ! 246: return p1; ! 247: } ! 248: ! 249: strwidth(ft,s) ! 250: XFontStruct *ft; ! 251: char *s; ! 252: { ! 253: return XTextWidth(ft, s, strlen(s)); ! 254: } ! 255: ! 256: #ifdef safe ! 257: Point ! 258: Pt(x, y) ! 259: short x, y; ! 260: { ! 261: Point p; ! 262: p.x = x; ! 263: p.y = y; ! 264: return p; ! 265: } ! 266: Rectangle ! 267: SRect(x1, y1, x2, y2) ! 268: short x1, y1, x2, y2; ! 269: { ! 270: Rectangle r; ! 271: r.origin.x = x1; ! 272: r.origin.y = y1; ! 273: r.corner.x = x2; ! 274: r.corner.y = y2; ! 275: return r; ! 276: } ! 277: Rectangle ! 278: Rpt(p1, p2) ! 279: Point p1, p2; ! 280: { ! 281: Rectangle r; ! 282: r.origin = p1; ! 283: r.corner = p2; ! 284: return r; ! 285: } ! 286: #endif safe ! 287: ! 288: Point ! 289: add(a, b) ! 290: Point a, b; ! 291: { ! 292: register short *ap= &a.x, *bp= &b.x; ! 293: *ap++ += *bp++; ! 294: *ap += *bp; ! 295: return a; ! 296: } ! 297: Point ! 298: sub(a, b) ! 299: Point a, b; ! 300: { ! 301: register short *ap= &a.x, *bp= &b.x; ! 302: *ap++ -= *bp++; ! 303: *ap -= *bp; ! 304: return a; ! 305: } ! 306: Rectangle ! 307: inset(r,n) ! 308: Rectangle r; ! 309: register n; ! 310: { ! 311: register short *rp= &r.origin.x; ! 312: *rp++ += n; ! 313: *rp++ += n; ! 314: *rp++ -= n; ! 315: *rp -= n; ! 316: return r; ! 317: } ! 318: Rectangle ! 319: raddp(r, p) ! 320: Rectangle r; ! 321: Point p; ! 322: { ! 323: register short *rp= &r.origin.x, *pp= &p.x; ! 324: *rp++ += *pp++; ! 325: *rp++ += *pp--; ! 326: *rp++ += *pp++; ! 327: *rp += *pp; ! 328: return r; ! 329: } ! 330: eqpt(p, q) ! 331: Point p, q; ! 332: { ! 333: register long *pp=(long *)&p, *qq=(long *)&q; ! 334: return *pp==*qq; ! 335: } ! 336: ptinrect(p, r) ! 337: Point p; ! 338: Rectangle r; ! 339: { ! 340: return(p.x>=r.origin.x && p.x<r.corner.x ! 341: && p.y>=r.origin.y && p.y<r.corner.y); ! 342: } ! 343: ! 344: /* ! 345: * Convert a blit style texture to a pixmap which can be used in tiling ! 346: * or cursor operations. ! 347: */ ! 348: Pixmap ToPixmap(bits) ! 349: short bits[]; ! 350: { ! 351: static XImage *im; ! 352: Pixmap pm; ! 353: ! 354: if (!im) ! 355: im = XCreateImage(dpy, XDefaultVisual(dpy, 0), 1, ! 356: XYBitmap, 0, (char *)bits, 16, 16, 8, 2); ! 357: else ! 358: im->data = (char *)bits; ! 359: pm = XCreatePixmap(dpy, display.dr, 16, 16, 1); ! 360: XPutImage(dpy, pm, gcs[F_STORE], im, 0, 0, 0, 0, 16, 16); ! 361: return pm; ! 362: } ! 363: ! 364: Cursor ToCursor(source, mask, hotx, hoty) ! 365: short source[], mask[]; ! 366: { ! 367: Pixmap sp, mp; ! 368: Cursor c; ! 369: ! 370: sp = ToPixmap(source); ! 371: mp = ToPixmap(mask); ! 372: c = XCreatePixmapCursor(dpy, sp, mp, &fgcolor, &bgcolor, hotx, hoty); ! 373: XFreePixmap(dpy, sp); ! 374: XFreePixmap(dpy, mp); ! 375: return(c); ! 376: } ! 377: ! 378: cursset(p) ! 379: Point p; ! 380: { ! 381: XWarpPointer(dpy, display.dr, display.dr, mouse.xy.x, mouse.xy.y, ! 382: display.rect.corner.x, display.rect.corner.y, p.x, p.y); ! 383: mouse.xy.x = p.x; ! 384: mouse.xy.y = p.y; ! 385: } ! 386: ! 387: jnap(i) ! 388: { ! 389: handleinput(); ! 390: } ! 391: ! 392: kbdchar() ! 393: { ! 394: int i; ! 395: ! 396: if (!kbdbuf.cnt) ! 397: return -1; ! 398: i = *kbdbuf.out++; ! 399: if (kbdbuf.out == &kbdbuf.buf[kbdbuf.size]) ! 400: kbdbuf.out = kbdbuf.buf; ! 401: if (--kbdbuf.cnt == 0) ! 402: P->state &= ~KBD; ! 403: return(i); ! 404: } ! 405: ! 406: #undef button ! 407: handleinput() ! 408: { ! 409: XEvent ev; ! 410: unsigned char s[16], *cp; ! 411: int n; ! 412: ! 413: XNextEvent(dpy, &ev); ! 414: switch (ev.type) { ! 415: case ButtonPress: ! 416: mouse.buttons |= (8 >> ev.xbutton.button); ! 417: mouse.xy.x = ev.xbutton.x; ! 418: mouse.xy.y = ev.xbutton.y; ! 419: mouse.time = ev.xbutton.time; ! 420: break; ! 421: case ButtonRelease: ! 422: mouse.buttons &= ~(8 >> ev.xbutton.button); ! 423: mouse.xy.x = ev.xbutton.x; ! 424: mouse.xy.y = ev.xbutton.y; ! 425: mouse.time = ev.xbutton.time; ! 426: break; ! 427: case MotionNotify: ! 428: mouse.xy.x = ev.xmotion.x; ! 429: mouse.xy.y = ev.xmotion.y; ! 430: break; ! 431: case MapNotify: ! 432: case NoExpose: ! 433: break; ! 434: case ConfigureNotify: ! 435: if (display.rect.corner.x != ev.xconfigure.width || ! 436: display.rect.corner.y != ev.xconfigure.height) { ! 437: display.rect.corner.x = ev.xconfigure.width; ! 438: display.rect.corner.y = ev.xconfigure.height; ! 439: Drect = display.rect; ! 440: } ! 441: break; ! 442: case Expose: ! 443: if (ev.xexpose.count == 0) { ! 444: rectf(&display, Drect, F_CLR); ! 445: P->state |= RESHAPED; ! 446: } ! 447: break; ! 448: case KeyPress: ! 449: mouse.xy.x = ev.xkey.x; ! 450: mouse.xy.y = ev.xkey.y; ! 451: mouse.time = ev.xkey.time; ! 452: n = XLookupString(&ev, s, sizeof(s), NULL, NULL); ! 453: if (n > 0) { ! 454: cp = s; ! 455: P->state |= KBD; ! 456: do { ! 457: if (kbdbuf.cnt == kbdbuf.size) ! 458: break; ! 459: *kbdbuf.in++ = *cp++; ! 460: kbdbuf.cnt++; ! 461: if (kbdbuf.in == &kbdbuf.buf[kbdbuf.size]) ! 462: kbdbuf.in = kbdbuf.buf; ! 463: } while (--n); ! 464: } ! 465: break; ! 466: default: ! 467: break; ! 468: } ! 469: } ! 470: #define button(i) (mouse.buttons&(8>>i)) ! 471: ! 472: char * ! 473: gcalloc(nbytes, where) ! 474: unsigned long nbytes; ! 475: char **where; ! 476: { ! 477: *where=(char *)alloc(nbytes); ! 478: return *where; ! 479: } ! 480: void ! 481: gcfree(s) ! 482: char *s; ! 483: { ! 484: free(s); ! 485: } ! 486: ! 487: min(a,b) ! 488: { ! 489: return (a<b? a: b); ! 490: } ! 491: max(a,b) ! 492: { ! 493: return (a>b? a: b); ! 494: } ! 495: ! 496: /* Form a circle of radius r centered at x1,y1 ! 497: */ ! 498: circle(b,p,r,f) ! 499: Bitmap *b; ! 500: Point p; ! 501: { ! 502: unsigned int diam = 2*r; ! 503: if (b->flag & BI_PIXMAP) ! 504: p = sub(p, b->rect.origin); ! 505: p = sub(p, Pt(r,r)); ! 506: XDrawArc(dpy, b->dr, gcs[f], p.x, p.y, diam, diam, 0, 23040/* 360 deg */); ! 507: } ! 508: ! 509: Cursor * ! 510: cursswitch(cp) ! 511: Cursor *cp; ! 512: { ! 513: static Cursor *prev = &normalcursor; ! 514: Cursor *ret = prev; ! 515: if (!cp) ! 516: cp = &normalcursor; ! 517: XDefineCursor(dpy, display.dr, *cp); ! 518: prev = cp; ! 519: return ret; ! 520: } ! 521: /* Fill a disc of radius r centered at x1,y1 ! 522: */ ! 523: disc(b, p, r, f) ! 524: Bitmap *b; ! 525: Point p; ! 526: int r; ! 527: Code f; ! 528: { ! 529: unsigned int diam = 2*r; ! 530: if (b->flag & BI_PIXMAP) ! 531: p = sub(p, b->rect.origin); ! 532: p = sub(p, Pt(r,r)); ! 533: XFillArc(dpy, b->dr, gcs[f], p.x, p.y, diam, diam, 0, 23040/* 360 deg */); ! 534: } ! 535: ! 536: typedef struct String{ ! 537: char *s; /* pointer to string */ ! 538: short n; /* number used, no terminal null */ ! 539: short size; /* size of allocated area */ ! 540: } String; ! 541: ! 542: getmuxbuf(pmb) ! 543: String *pmb; ! 544: { ! 545: char *ans; ! 546: int n; ! 547: ans=XFetchBytes(dpy, &n); ! 548: pmb->size=pmb->n=n; ! 549: gcalloc(pmb->size, &(pmb->s)); ! 550: strncpy(pmb->s, ans, n); ! 551: free(ans); ! 552: } ! 553: ! 554: #define UP 0 ! 555: #define DOWN 1 ! 556: ! 557: static short boxcurs_bits[] = { ! 558: 0x43FF, 0xE001, 0x7001, 0x3801, 0x1D01, 0x0F01, 0x8701, 0x8F01, ! 559: 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0x8001, 0xFFFF, ! 560: }; ! 561: static Cursor boxcurs; ! 562: ! 563: buttons(updown) ! 564: { ! 565: while((button123()!=0) != updown) ! 566: jnap(2); ! 567: } ! 568: ! 569: Rectangle ! 570: canon(p1, p2) ! 571: Point p1, p2; ! 572: { ! 573: Rectangle r; ! 574: r.origin.x = min(p1.x, p2.x); ! 575: r.origin.y = min(p1.y, p2.y); ! 576: r.corner.x = max(p1.x, p2.x); ! 577: r.corner.y = max(p1.y, p2.y); ! 578: return(r); ! 579: } ! 580: ! 581: static outline(r) ! 582: Rectangle r; ! 583: { ! 584: XPoint p[5], *pp; ! 585: ! 586: pp = p; ! 587: pp->x = r.corner.x; pp->y = r.origin.y; pp++; ! 588: pp->x = r.corner.x; pp->y = r.corner.y; pp++; ! 589: pp->x = r.origin.x; pp->y = r.corner.y; pp++; ! 590: pp->x = r.origin.x; pp->y = r.origin.y; pp++; ! 591: pp->x = r.corner.x; pp->y = r.origin.y; pp++; ! 592: XDrawLines(dpy, display.dr, gcs[F_XOR], p, 5, CoordModeOrigin); ! 593: } ! 594: ! 595: Rectangle ! 596: getrectb(n) ! 597: int n; ! 598: { ! 599: Rectangle r; ! 600: Point p1, p2; ! 601: ! 602: if (!boxcurs) ! 603: boxcurs = ToCursor(boxcurs_bits, boxcurs_bits, 8, 8); ! 604: cursswitch(&boxcurs); ! 605: buttons(UP); ! 606: buttons(DOWN); ! 607: if(!(mouse.buttons&n)){ ! 608: r.origin.x=r.origin.y=r.corner.x=r.corner.y=0; ! 609: buttons(UP); ! 610: goto Return; ! 611: } ! 612: p1=mouse.xy; ! 613: p2=p1; ! 614: r=canon(p1, p2); ! 615: outline(r); ! 616: for(; mouse.buttons&n; jnap(2)){ ! 617: outline(r); ! 618: p2=mouse.xy; ! 619: r=canon(p1, p2); ! 620: outline(r); ! 621: } ! 622: outline(r); /* undraw for the last time */ ! 623: Return: ! 624: cursswitch(0); ! 625: return r; ! 626: } ! 627: ! 628: Rectangle ! 629: getrect(n) ! 630: { ! 631: return getrectb(8>>n); ! 632: } ! 633: ! 634: #define scale(x, inmin, inmax, outmin, outmax)\ ! 635: (outmin + muldiv(x-inmin,outmax-outmin,inmax-inmin)) ! 636: ! 637: #define bound(x, low, high) min(high, max( low, x )) ! 638: ! 639: #define DISPLAY 16 ! 640: #define DELTA 6 ! 641: #define BARWIDTH 18 ! 642: ! 643: static char **table; ! 644: static char * ! 645: tablegen(i) ! 646: { ! 647: return table[i]; ! 648: } ! 649: ! 650: menuhit(m, but) ! 651: register Menu *m; ! 652: { ! 653: register int width, i, j, top, newtop, hit, newhit, items, lines, length; ! 654: Point p, q, savep, baro, barc; ! 655: Rectangle sr, tr, mr; /* scroll, text, menu */ ! 656: register Bitmap *b; ! 657: register char *s, *(*generator)(), *from, *to; ! 658: char fill[64]; ! 659: Font *font = &defont; ! 660: int spacing = font->max_bounds.ascent + font->max_bounds.descent; ! 661: ! 662: #define sro sr.origin ! 663: #define src sr.corner ! 664: #define tro tr.origin ! 665: #define trc tr.corner ! 666: #define mro mr.origin ! 667: #define mrc mr.corner ! 668: ! 669: generator = (table=m->item) ? tablegen : m->generator; ! 670: p = mouse.xy; ! 671: length = width = items = 0; ! 672: for( ; s=(*generator)(items); ++items) { ! 673: length = max(length, strlen(s)); ! 674: width = max(width, strwidth(font,s)); ! 675: } ! 676: if(items == 0){ ! 677: while(button(but)); ! 678: return -1; ! 679: } ! 680: width += 10; ! 681: sro.x = sro.y = src.x = tro.x = mro.x = mro.y = 0; ! 682: if(items <= DISPLAY) ! 683: lines = items; ! 684: else{ ! 685: lines = DISPLAY; ! 686: tro.x = src.x = BARWIDTH; ! 687: sro.x = sro.y = 1; ! 688: } ! 689: tro.y = 1; ! 690: mrc = trc = add(Pt(tro.x, mro.y), Pt(width, min(items, lines)*spacing+2)); ! 691: trc.y = src.y = mrc.y-1; ! 692: newtop = bound(m->prevtop, 0, items-lines); ! 693: p.y -= bound(m->prevhit, 0, lines-1)*spacing+spacing/2; ! 694: p.x = bound(p.x-(src.x+width/2), 0, display.rect.corner.x-mrc.x); ! 695: p.y = bound(p.y, 0, display.rect.corner.y-mrc.y); ! 696: sr = raddp(sr, p); ! 697: tr = raddp(tr, p); ! 698: mr = raddp(mr, p); ! 699: b = balloc(mr); ! 700: if(b) ! 701: bitblt(&display, mr, b, mro, F_STORE); ! 702: rectf(&display, mr, F_OR); ! 703: PaintMenu: ! 704: rectf(&display, inset(mr, 1), F_CLR); ! 705: top = newtop; ! 706: if(items > DISPLAY){ ! 707: baro.y = scale(top, 0, items, sro.y, src.y); ! 708: baro.x = sr.origin.x; ! 709: barc.y = scale(top+DISPLAY, 0, items, sro.y, src.y); ! 710: barc.x = sr.corner.x; ! 711: rectf(&display, Rpt(baro,barc), F_XOR); ! 712: } ! 713: for(p=tro, i=top; i < min(top+lines, items); ++i){ ! 714: q = p; ! 715: from = generator(i); ! 716: for(to = &fill[0]; *from; ++from) ! 717: if(*from & 0x80) ! 718: for(j=length-(strlen(from+1)+(to-&fill[0])); j-->0;) ! 719: *to++ = *from & 0x7F; ! 720: else ! 721: *to++ = *from; ! 722: *to = '\0'; ! 723: q.x += (width-strwidth(font,fill))/2; ! 724: string(font, fill, &display, q, F_XOR); ! 725: p.y += spacing; ! 726: } ! 727: savep = mouse.xy; ! 728: for(newhit = hit = -1; button(but); jnap(2)){ ! 729: if(ptinrect(p = mouse.xy, sr)){ ! 730: if(ptinrect(savep,tr)){ ! 731: p.y = (baro.y+barc.y)/2; ! 732: cursset(p); ! 733: } ! 734: newtop = scale(p.y, sro.y, src.y, 0, items); ! 735: newtop = bound(newtop-DISPLAY/2, 0, items-DISPLAY); ! 736: if(newtop != top) ! 737: goto PaintMenu; ! 738: }else if(ptinrect(savep,sr)){ ! 739: register dx, dy; ! 740: if(abs(dx = p.x-savep.x) < DELTA) ! 741: dx = 0; ! 742: if(abs(dy = p.y-savep.y) < DELTA) ! 743: dy = 0; ! 744: if(abs(dy) >= abs(dx)) ! 745: dx = 0; ! 746: else ! 747: dy = 0; ! 748: cursset(p = add(savep, Pt(dx,dy))); ! 749: } ! 750: savep = p; ! 751: newhit = -1; ! 752: if(ptinrect(p, tr)){ ! 753: newhit = bound((p.y-tro.y)/spacing, 0, lines-1); ! 754: if(newhit!=hit && hit>=0 ! 755: && abs(tro.y+spacing*newhit+spacing/2-p.y) > spacing/3) ! 756: newhit = hit; ! 757: } ! 758: if(newhit != hit){ ! 759: flip(tr, hit, spacing); ! 760: flip(tr, hit = newhit, spacing); ! 761: } ! 762: if(newhit==0 && top>0){ ! 763: newtop = top-1; ! 764: p.y += spacing; ! 765: cursset(p); ! 766: goto PaintMenu; ! 767: } ! 768: if(newhit==DISPLAY-1 && top<items-lines){ ! 769: newtop = top+1; ! 770: p.y -= spacing; ! 771: cursset(p); ! 772: goto PaintMenu; ! 773: } ! 774: } ! 775: if(b){ ! 776: bitblt(b, b->rect, &display, b->rect.origin, F_STORE); ! 777: bfree(b); ! 778: } ! 779: if(hit>=0){ ! 780: m->prevhit = hit; ! 781: m->prevtop = top; ! 782: return hit+top; ! 783: }else ! 784: return -1; ! 785: } ! 786: ! 787: static ! 788: flip(r,n,spacing) ! 789: Rectangle r; ! 790: { ! 791: if(n<0) ! 792: return; ! 793: ++r.origin.x; ! 794: r.corner.y = (r.origin.y += spacing*n) + spacing; ! 795: --r.corner.x; ! 796: rectf(&display, r, F_XOR); ! 797: } ! 798: ! 799: void ! 800: point(b,p,f) ! 801: Bitmap *b; ! 802: Point p; ! 803: Code f; ! 804: { ! 805: if (b->flag & BI_PIXMAP) ! 806: p = sub(p, b->rect.origin); ! 807: XDrawPoint(dpy, b->dr, gcs[f], p.x, p.y); ! 808: } ! 809: ! 810: #define PBSIZE 100 ! 811: ! 812: static XPoint xp[PBSIZE]; ! 813: static xpcnt; ! 814: static Code fc; ! 815: static ispixmap; ! 816: static Bitmap *bitm; ! 817: ! 818: #define flushpt() if (xpcnt) flushpoints(); ! 819: ! 820: points(p) ! 821: Point p; ! 822: { ! 823: register XPoint *x; ! 824: ! 825: if (ispixmap) ! 826: p = sub(p, bitm->rect.origin); ! 827: x = &xp[xpcnt]; ! 828: x->x = p.x; ! 829: x->y = p.y; ! 830: if (++xpcnt == PBSIZE) ! 831: flushpoints(); ! 832: } ! 833: ! 834: initpoints(b, f) ! 835: Bitmap *b; ! 836: Code f; ! 837: { ! 838: if (b->flag & BI_PIXMAP) ! 839: ispixmap = 1; ! 840: else ! 841: ispixmap = 0; ! 842: bitm = b; ! 843: fc = f; ! 844: } ! 845: ! 846: endpoints() ! 847: { ! 848: flushpt(); ! 849: XSync(dpy, 0); ! 850: } ! 851: ! 852: flushpoints() ! 853: { ! 854: if (xpcnt) { ! 855: XDrawPoints(dpy, bitm->dr, gcs[fc], xp, xpcnt, CoordModeOrigin); ! 856: xpcnt = 0; ! 857: } ! 858: } ! 859: ! 860: /* ! 861: * Buffer for keyboard input ! 862: */ ! 863: #define RCVBUFSIZE 1024 ! 864: ! 865: static unsigned char rcvbuffer[RCVBUFSIZE]; ! 866: ! 867: static struct { ! 868: unsigned char *buf; ! 869: unsigned char *in; ! 870: unsigned char *out; ! 871: int cnt; ! 872: int size; ! 873: }rcvbuf = { rcvbuffer, rcvbuffer, rcvbuffer, 0, RCVBUFSIZE }; ! 874: ! 875: ! 876: rcvchar() ! 877: { ! 878: int i; ! 879: ! 880: if (!rcvbuf.cnt) ! 881: return -1; ! 882: i = *rcvbuf.out++; ! 883: if (rcvbuf.out == &rcvbuf.buf[rcvbuf.size]) ! 884: rcvbuf.out = rcvbuf.buf; ! 885: if (--rcvbuf.cnt == 0) ! 886: P->state &= ~RCV; ! 887: return(i); ! 888: } ! 889: ! 890: rcvfill() ! 891: { ! 892: register i; ! 893: ! 894: if (rcvbuf.cnt == rcvbuf.size) ! 895: return; ! 896: if (rcvbuf.in < rcvbuf.out) ! 897: i = rcvbuf.out - rcvbuf.in; ! 898: else ! 899: i = &rcvbuf.buf[rcvbuf.size] - rcvbuf.in; ! 900: i = read(0, rcvbuf.in, i); ! 901: if (i <= 0) ! 902: return; ! 903: P->state |= RCV; ! 904: rcvbuf.cnt += i; ! 905: rcvbuf.in += i; ! 906: if (rcvbuf.in == &rcvbuf.buf[rcvbuf.size]) ! 907: rcvbuf.in = rcvbuf.buf; ! 908: } ! 909: ! 910: void ! 911: request(r) ! 912: int r; ! 913: { ! 914: int i=1; ! 915: if (r & RCV) { ! 916: /* need non-blocking I/O on stdout */ ! 917: #ifdef BSD ! 918: ioctl(1, FIONBIO, &i); ! 919: #else ! 920: ioctl(1, FIOWNBLK, 0); ! 921: #endif ! 922: } ! 923: /* for now, assume MOUSE|KBD requested */ ! 924: } ! 925: ! 926: void ! 927: segment(b,p,q,f) ! 928: Bitmap *b; ! 929: Point p, q; ! 930: Code f; ! 931: { ! 932: if (b->flag & BI_PIXMAP) { ! 933: p = sub(p, b->rect.origin); ! 934: q = sub(q, b->rect.origin); ! 935: } ! 936: XDrawLine(dpy, b->dr, gcs[f], p.x, p.y, q.x, q.y); ! 937: } ! 938: ! 939: #ifndef BSD ! 940: #define EWOULDBLOCK EBUSY ! 941: #endif ! 942: ! 943: sendnchars(n,p) ! 944: char *p; ! 945: int n; ! 946: { ! 947: int i; ! 948: int maxfd, rmask, wmask; ! 949: ! 950: while (n) { ! 951: i = write(1, p, n); ! 952: if (i > 0) { ! 953: n -= i; ! 954: p += i; ! 955: continue; ! 956: } ! 957: if (i < 0 && errno == EWOULDBLOCK) { ! 958: maxfd = dpy->fd + 1; ! 959: do { ! 960: while (XPending(dpy)) ! 961: handleinput(); ! 962: rmask = (1 << dpy->fd) | 1; ! 963: wmask = 2; ! 964: #ifdef BSD ! 965: select(maxfd, &rmask, &wmask, 0, 0); ! 966: #else ! 967: select(maxfd, &rmask, &wmask, 0x6fffffff); ! 968: #endif ! 969: if (rmask & 1) ! 970: rcvfill(); ! 971: if (rmask & (1 << dpy->fd)) ! 972: handleinput(); ! 973: } while (!wmask); ! 974: } ! 975: else ! 976: exit(1); ! 977: } ! 978: } ! 979: #define MAXROOT 0xb504 ! 980: sqrt(x) ! 981: register long x; ! 982: { ! 983: register long high=MAXROOT; ! 984: register long low=0; ! 985: register long current=MAXROOT/2; ! 986: if(x<=0) ! 987: return 0; ! 988: if(x>=MAXROOT*MAXROOT) ! 989: return(MAXROOT); ! 990: while(high>low+1){ ! 991: if(current*current==x) ! 992: return (current); ! 993: if(current*current>x) ! 994: high=current; ! 995: else ! 996: low=current; ! 997: current=(high+low)>>1; ! 998: } ! 999: return(current); ! 1000: } ! 1001: ! 1002: wait(resource) ! 1003: { ! 1004: int maxfd, smask, i; ! 1005: ! 1006: maxfd = dpy->fd + 1; ! 1007: for(;;) { ! 1008: if (P->state & resource) ! 1009: break; ! 1010: if (XPending(dpy)) ! 1011: goto xin; ! 1012: if (resource & CPU) ! 1013: break; ! 1014: smask = (1 << dpy->fd) | 1; ! 1015: #ifdef BSD ! 1016: select(maxfd, &smask, 0, 0, 0); ! 1017: #else ! 1018: select(maxfd, &smask, 0, 0x6fffffff); ! 1019: #endif ! 1020: if (smask & 1) ! 1021: rcvfill(); ! 1022: if (smask & (1 << dpy->fd)) { ! 1023: xin: ! 1024: handleinput(); ! 1025: /* We always have the mouse and cpu */ ! 1026: if (resource & (MOUSE|CPU)) ! 1027: break; ! 1028: } ! 1029: } ! 1030: return P->state; ! 1031: } ! 1032: ! 1033: int ! 1034: own() ! 1035: { ! 1036: return P->state|MOUSE; ! 1037: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.