![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to mdraw.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [OS/2 SDKs] / os2sdk / demos / apps / mandel|
Return to mdraw.c CVS log | Up to [OS/2 SDKs] / os2sdk / demos / apps / mandel |
1.1 ! root 1: /* mdraw.c - display Mandelbrot set on EGA ! 2: * R. A. Garmoe 86/12/15 ! 3: */ ! 4: ! 5: ! 6: ! 7: /** Mdraw displays the elements of the Mandelbrot set ! 8: * ! 9: * z = z**2 + c ! 10: * ! 11: * where z and c are in the complex plane and z = 0 + 0i for the first ! 12: * iteration. The elements of the set are displayed in black and ! 13: * elements not in the set are displayed in color. The data to be ! 14: * displayed is computed by the program mandel. ! 15: */ ! 16: ! 17: ! 18: /** Call ! 19: * ! 20: * mdraw file file ... ! 21: * ! 22: * where ! 23: * file a .cnt file created by the computation program mandel ! 24: * ! 25: * All of the files are read and displayed in order. After all of ! 26: * the images are displayed, keystrokes have the following meaning. ! 27: * e edit palette registers ! 28: * up/down arrow - select register ! 29: * right/left arrow - select color ! 30: * i reinitialize palette registers ! 31: * n advance to next display ! 32: * p backup to previous display ! 33: * q cleanup and exit ! 34: * r decrement palette register ripple ! 35: * R increment palette register ripple ! 36: * z continous forward zoom through images ! 37: * Z continous backward zoom through images ! 38: * ! 39: * All other characters are ignored. ! 40: */ ! 41: ! 42: ! 43: ! 44: ! 45: /* ! 46: * The .cnt file has the format ! 47: * int number of points along the real axis ! 48: * int number of points along the imaginary axis ! 49: * int maximum iteration point for each point ! 50: * double real coordinate of upper left ! 51: * double imaginary coordinate of upper left ! 52: * double real coordinate of lower right ! 53: * double imaginary coordinate lower rightft ! 54: * double increment between points on real axis ! 55: * double increment between points on imaginary axis ! 56: * long (loop + 1) counters for histogram values ! 57: * ! 58: * The remainder of the file is the run length encoded scan ! 59: * lines encoded as: ! 60: * int number of words in scan line encoded as: ! 61: * +int actual count value for pixel ! 62: * -int int The first value is the run length and ! 63: * second value is the run value ! 64: */ ! 65: ! 66: ! 67: ! 68: #include <stdio.h> ! 69: #include <subcalls.h> ! 70: #include <doscalls.h> ! 71: #include <dos.h> ! 72: #include "mdraw.h" ! 73: ! 74: /* The routines that are in the IOPL segment must be declared ! 75: * as pascal routines. When the IOPL routine is called through ! 76: * the intersegment call gate, the parameters are copied from the ! 77: * ring 3 user's stack to the ring 2 IOPL stack. The parameters ! 78: * must be popped from the IOPL stack (and the ring 3 stack) by the ! 79: * ret n instruction of the IOPL routine. Otherwise, the ring 2 ! 80: * stack is left in an invalid state. For more information, refer ! 81: * to the 80286 Programmer's Manual for ! 82: * intersegment calls ! 83: * parameter passing through call gates ! 84: * CALLs to and RETurns from inner protection rings ! 85: * ! 86: * Note also that the number of words of passed parameters defined in ! 87: * each of these functions must exactly match the word counts defined ! 88: * in the EXPORTS statements in the mdraw.def linker definitions file. ! 89: */ ! 90: ! 91: extern void far pascal SetDVideo (); ! 92: extern void far pascal SetEVideo (); ! 93: extern void far pascal SetScanClear (); ! 94: extern void far pascal SetScan (int, int, char *); ! 95: extern void far pascal SetScanSave (unsigned far *); ! 96: extern void far pascal SetScanSFont (unsigned); ! 97: extern void far pascal SetScanRFont (unsigned); ! 98: extern void far pascal SetScanRestore (unsigned far *); ! 99: extern void far pascal SetCursor (char far *); ! 100: ! 101: ! 102: void far mode_wait (void); /* starting address for a thread */ ! 103: void far redraw_wait (void); /* starting address for another thread */ ! 104: ! 105: ! 106: ! 107: /* Structures for VIO calls */ ! 108: ! 109: struct ConfigData config; /* Display configuration data */ ! 110: struct ModeData mode; /* Display mode data */ ! 111: struct ModeData grmode; /* graphics display mode data */ ! 112: struct PhysBufData physbuf; /* Physical buffer data */ ! 113: struct CursorData cursor; /* Cursor data structure */ ! 114: struct KeyData key; /* Keystroke data */ ! 115: struct VIOSTATE vstate; /* Set vio state */ ! 116: ! 117: ! 118: ! 119: ! 120: char pmand[60] = "mandel.cnt"; ! 121: FILE *fmand; ! 122: ! 123: char chvalid = FALSE; /* key valid if true */ ! 124: char cinit[15] = {WHITE, BLUE, GREEN, CYAN, RED, MAGENTA, BROWN, IWHITE, ! 125: DGRAY, LBLUE, LGREEN, LCYAN, LRED, LMAGENTA, YELLOW}; ! 126: char firstread = FALSE; /* first character read from keyboard if true */ ! 127: char flip = FALSE; /* flip display pages if true */ ! 128: char graphics = FALSE; /* display is in graphics mode if true */ ! 129: char mapped[MAXREAL]; /* character array holding mapped interation counters */ ! 130: char initpal[16] = { ! 131: 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, ! 132: 0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F ! 133: }; ! 134: char palette[16] = { ! 135: 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07, ! 136: 0x38,0x39,0x3A,0x3B,0x3C,0x3D,0x3E,0x3F ! 137: }; ! 138: ! 139: char *screenbuf; /* pointer to buffer to hold text screen */ ! 140: ! 141: int *bp; /* pointer to next iteration counter in buf */ ! 142: int buf[BUFFER]; /* run length encoded iteration counters */ ! 143: int count = 0; /* number of integers remaining in buf */ ! 144: ! 145: long delay = 0; /* ripple delay in milliseconds */ ! 146: long drawsem = 0; /* RAM semaphore to control drawing */ ! 147: long hist[MAXLOOP + 1] = {0}; /* histogram counters */ ! 148: ! 149: struct image timage = {0}; /* local image descriptor structure */ ! 150: struct ilist *head = NULL; /* pointer to head of ilist */ ! 151: struct ilist *curr = NULL; /* pointer to current ilist */ ! 152: struct ilist *tail = NULL; /* pointer to tail of ilist */ ! 153: ! 154: unsigned curcol; /* cursor column position */ ! 155: unsigned currow; /* cursor row position */ ! 156: unsigned descsel; /* selector for image structure */ ! 157: unsigned fontsel; /* selectors for font saves */ ! 158: unsigned dpoffset = 0; /* display page offset 0x0000 or 0x8000 */ ! 159: unsigned *psel; /* display memory selector */ ! 160: unsigned screenlen; /* length of screen buffer */ ! 161: ! 162: main (argc, argv) ! 163: int argc; ! 164: char **argv; ! 165: { ! 166: int c; ! 167: int i; ! 168: int temp; ! 169: int pal; ! 170: unsigned char *stack1, /* stack for mode_wait thread */ ! 171: *stack2; /* stack for redraw_wait thread */ ! 172: unsigned ThreadID; ! 173: ! 174: /* Validate the display configuration. It must be an EGA on an ! 175: * EGA adapter with at least 128k of memory. ! 176: */ ! 177: ! 178: config.length = 10; ! 179: if ((temp = VIOGETCONFIG (0, (struct ConfigData far *)&config, 0)) != 0) { ! 180: printf ("Unable to get display configuration data - %d\n", temp); ! 181: exit (1); ! 182: } ! 183: if ((config.adapter_type != 2) || (config.display_type != 2) || ! 184: config.memory_size < 0x20000) { ! 185: printf ("Display is not EGA on 128k EGA adapter %d %d %ld\n", ! 186: config.adapter_type, config.display_type, config.memory_size); ! 187: exit (1); ! 188: } ! 189: ! 190: if (config.memory_size == 0x40000) ! 191: flip = TRUE; ! 192: ! 193: /* Save information about the current display mode. This includes ! 194: * the current mode as known by VIO, the cursor type data, the ! 195: * current cursor position and the text screen data. ! 196: */ ! 197: ! 198: mode.length = sizeof (struct ModeData); ! 199: if ((temp = VIOGETMODE ((struct ModeData far *)&mode, 0)) != 0) { ! 200: printf ("Unable to get display mode data - %d\n", temp); ! 201: exit (1); ! 202: } ! 203: if (VIOGETCURTYPE ((struct CursorData *)&cursor, 0) != 0) { ! 204: printf ("Unable to get current cursor data\n"); ! 205: exit (1); ! 206: } ! 207: if (VIOGETCURPOS ((unsigned far *)&currow, (unsigned far *)&curcol, 0) != 0) { ! 208: printf ("Unable to get current cursor position\n"); ! 209: exit (1); ! 210: } ! 211: ! 212: /* Allocate buffer to hold text screen data. Note that the buffer ! 213: * size is doubled because of the attribute bytes. ! 214: */ ! 215: ! 216: screenlen = mode.col * mode.row * 2; ! 217: if ((screenbuf = (char *)malloc (screenlen)) == NULL) { ! 218: printf ("Unable to allocate memory for text screen buffer\n"); ! 219: exit (1); ! 220: } ! 221: if (VIOREADCELLSTR ((char far *)screenbuf, (unsigned far *)&screenlen, ! 222: 0, 0, 0) != 0) { ! 223: printf ("Unable to read text screen data\n"); ! 224: exit (1); ! 225: } ! 226: ! 227: /* Obtain selectors to the display memory */ ! 228: ! 229: physbuf.buf_start = 0xa0000; ! 230: physbuf.buf_length = 0x20000; ! 231: if ((temp = VIOGETPHYSBUF ((struct PhysBufData far *)&physbuf, 0)) != 0) { ! 232: printf ("Unable to get physical buffer mapping - %d\n", temp); ! 233: exit (1); ! 234: } ! 235: if (DOSALLOCSEG (0,(unsigned far *)&fontsel, 0) != 0) { ! 236: printf ("Unable to allocate text font save segment\n"); ! 237: exit (1); ! 238: } ! 239: /* Allocate memory for separate thread execution */ ! 240: ! 241: stack1 = (unsigned char *)malloc (STACKSIZE); ! 242: stack2 = (unsigned char *)malloc (STACKSIZE); ! 243: if (!stack1 || !stack2) { ! 244: printf ("Out of memory\n"); ! 245: exit (1); ! 246: } ! 247: stack1 += STACKSIZE; ! 248: stack2 += STACKSIZE; ! 249: ! 250: /* create thread to execute the mode wait */ ! 251: ! 252: DOSCREATETHREAD (mode_wait, &ThreadID, stack1); ! 253: ! 254: /* create thread that will execute the redraw_wait () */ ! 255: ! 256: DOSCREATETHREAD (redraw_wait, &ThreadID, stack2); ! 257: ! 258: ! 259: /* Pass pointer to the selectors for display memory and the ! 260: * selector to the font save segment to the ring 2 IOPL code. ! 261: */ ! 262: ! 263: psel = physbuf.selectors; ! 264: ! 265: /* Save the font tables */ ! 266: ! 267: SetScanSFont (fontsel); ! 268: ! 269: /* Set the EGA to 640 x 350 graphics mode */ ! 270: ! 271: grmode = mode; ! 272: grmode.type = grmode.type | 0x02; ! 273: grmode.hres = 640; ! 274: grmode.vres = 350; ! 275: VIOSETMODE ((struct ModeData far *)&grmode, 0); ! 276: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 277: setpalette (palette); ! 278: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 279: ! 280: /* Set the file name if specified and open the file for reading */ ! 281: ! 282: argc--; ! 283: argv++; ! 284: graphics = TRUE; ! 285: printf ("Clearing screen\n"); ! 286: SetScanClear (); ! 287: printf ("Screen cleared\n"); ! 288: while (argc > 0) { ! 289: /* set file name */ ! 290: strcpy (pmand, *argv); ! 291: strcat (pmand, ".cnt"); ! 292: if ((fmand = fopen (pmand, "rb")) == NULL) { ! 293: cleandisplay (); ! 294: printf ("Unable to open count file %s\n", pmand); ! 295: exit (3); ! 296: } ! 297: readimage (); ! 298: fclose (fmand); ! 299: argc--; ! 300: argv++; ! 301: } ! 302: ! 303: /* Wait for keyboard input to switch display or terminate. This ! 304: * thread must delay between checks for keyboard input. Otherwise, ! 305: * the code will execute a CPU bound loop and all other threads ! 306: * and processes will execute at a reduced rate. ! 307: */ ! 308: ! 309: while (TRUE) { ! 310: if (nextchar (&c, 1)) { ! 311: switch (c) { ! 312: case 'e': ! 313: /* edit palette registers */ ! 314: paledit (); ! 315: break; ! 316: ! 317: case 'i': ! 318: /* reinitialize palette registers */ ! 319: for (i = 0; i < 16; i++) ! 320: palette[i] = initpal[i]; ! 321: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 322: setpalette (palette); ! 323: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 324: break; ! 325: ! 326: case 'n': ! 327: /* advance to next display */ ! 328: nextimage (); ! 329: break; ! 330: ! 331: case 'p': ! 332: /* backup to previous display */ ! 333: previmage (); ! 334: break; ! 335: ! 336: case 'q': ! 337: /* cleanup and exit */ ! 338: cleandisplay (); ! 339: exit (); ! 340: ! 341: case 'r': ! 342: /* decrement palette register ripple */ ! 343: delay += SCANTIME; ! 344: break; ! 345: ! 346: case 'R': ! 347: /* increment palette register ripple */ ! 348: delay -= SCANTIME; ! 349: break; ! 350: ! 351: case 'z': ! 352: /* continous forward zoom through images */ ! 353: while (!nextchar (&c, 1)) ! 354: nextimage (); ! 355: ungetchar (); ! 356: break; ! 357: ! 358: case 'Z': ! 359: /* continous backward zoom through images */ ! 360: while (!nextchar (&c, 1)) ! 361: previmage (); ! 362: ungetchar (); ! 363: break; ! 364: ! 365: default: ! 366: /* ignore character */ ! 367: break; ! 368: } ! 369: } ! 370: ! 371: /* delay to prevent CPU bound loop */ ! 372: ! 373: if (delay == 0) ! 374: DOSSLEEP ((long)100); ! 375: else if (delay > 0) { ! 376: ripple (RIPPLE_UP); ! 377: DOSSLEEP (delay); ! 378: } ! 379: else { ! 380: ripple (RIPPLE_DN); ! 381: DOSSLEEP ((long)(-delay)); ! 382: } ! 383: } ! 384: } ! 385: ! 386: ! 387: ! 388: ! 389: /** mdisp - display Mandelbrot set ! 390: * ! 391: * mdisp (im); ! 392: * ! 393: */ ! 394: ! 395: ! 396: ! 397: mdisp (im) ! 398: struct image far *im; ! 399: { ! 400: int i; ! 401: int ni; /* scan row counter */ ! 402: int temp; ! 403: int len; ! 404: char *pmapped; ! 405: ! 406: VIOSCRLOCK (1, (char far *)&temp, 0); ! 407: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 408: SetScanClear (); ! 409: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 410: ! 411: for (ni = 0; ni < im->lni; ni++) { ! 412: pmapped = mapped; ! 413: if (!nextvalue (&len)) ! 414: break; ! 415: while ((--len >= 0) && (pmapped - mapped < im->lnr) && nextvalue (&i)) { ! 416: if (i >= 0) ! 417: *pmapped++ = im->cmap[i]; ! 418: else { ! 419: if (!nextvalue (&temp)) ! 420: break; ! 421: len--; ! 422: temp = im->cmap[temp]; ! 423: for (; (i < 0) && (pmapped - mapped < im->lnr); i++) ! 424: *pmapped++ = temp; ! 425: } ! 426: } ! 427: ! 428: /* The scan line drawing is locked with a RAM semaphore so ! 429: * the redraw-wait routine can save and restore the screen ! 430: */ ! 431: ! 432: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 433: SetScan (ni, im->lnr, mapped); ! 434: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 435: } ! 436: ! 437: /* Save screen image and unlock the screen */ ! 438: ! 439: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 440: SetScanSave (curr->desc->savesel); ! 441: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 442: ! 443: VIOSCRUNLOCK (0); ! 444: } ! 445: ! 446: ! 447: ! 448: ! 449: /** nextvalue - return next value from file ! 450: * ! 451: * flag = nextvalue (ptr); ! 452: * ! 453: * Entry ptr = pointer to integer to receive value ! 454: * Exit *ptr = next value from file ! 455: * Return TRUE if next value returned ! 456: * FALSE if end of file ! 457: */ ! 458: ! 459: ! 460: int nextvalue (p) ! 461: int *p; ! 462: { ! 463: if (count == 0) { ! 464: count = fread ((char *)buf, sizeof (int), BUFFER, fmand); ! 465: bp = buf; ! 466: } ! 467: if (count == EOF) ! 468: return (FALSE); ! 469: *p = *bp++; ! 470: count--; ! 471: return (TRUE); ! 472: } ! 473: ! 474: ! 475: ! 476: ! 477: /** mode_wait - wait for mode reset request ! 478: * ! 479: * This routine is executed by another thread that is started ! 480: * by the main routine. ! 481: * ! 482: * This routine calls VIOmode_wait requesting to be notified ! 483: * after the completion of an application or hard error popup. ! 484: * On such a notification, it puts the screen in the desired ! 485: * graphics mode. ! 486: */ ! 487: ! 488: void mode_wait () ! 489: { ! 490: unsigned NotifyType; ! 491: ! 492: while (TRUE) { ! 493: /* wait for notification to restore mode */ ! 494: VIOMODEWAIT (0, &NotifyType, 0); ! 495: if (NotifyType == 0 && graphics) ! 496: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 497: VIOSETMODE ((struct ModeData far *)&grmode, 0); ! 498: SetScanClear (); ! 499: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 500: } ! 501: } ! 502: ! 503: ! 504: ! 505: ! 506: /** redraw_wait - wait for mode reset request ! 507: * ! 508: * This routine is executed by another thread that is started ! 509: * by the main routine. ! 510: * ! 511: * This routine calls VioSavRedrawWait requesting to be notified ! 512: * for both save and redraw. On save notification, it copies the ! 513: * EGA adapter memory to allocated memory segments. On redraw ! 514: * notification, it puts the screen in the desired graphics mode ! 515: * and then redraws the Mandelbrot set. ! 516: */ ! 517: ! 518: ! 519: void redraw_wait () ! 520: { ! 521: unsigned NotifyType; ! 522: ! 523: while (TRUE) { ! 524: VIOSAVREDRAWWAIT (0, &NotifyType, 0); ! 525: if (graphics) { ! 526: if (NotifyType == 0) { ! 527: /* save graphics screen */ ! 528: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 529: SetScanSave (curr->desc->savesel); ! 530: SetScanClear (); ! 531: continue; ! 532: } ! 533: else if (NotifyType == 1) { ! 534: /* restore graphics screen */ ! 535: dpoffset = 0; ! 536: VIOSETMODE ((struct ModeData far *)&grmode, 0); ! 537: SetScanClear (); ! 538: SetDVideo (); ! 539: SetScanRestore (curr->desc->savesel); ! 540: SetEVideo (); ! 541: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 542: } ! 543: } ! 544: } ! 545: } ! 546: ! 547: ! 548: ! 549: ! 550: /** readimage - read and display next image ! 551: * ! 552: * readimage (); ! 553: * ! 554: */ ! 555: ! 556: ! 557: readimage () ! 558: { ! 559: int i; ! 560: struct ilist *tlist; ! 561: int nr; ! 562: ! 563: /* Allocate memory for image structure and link to chain of images */ ! 564: ! 565: if ((tlist = (struct ilist *)malloc (sizeof (struct ilist))) == NULL) { ! 566: cleandisplay (); ! 567: printf ("Unable to allocate memory for ilist structure\n"); ! 568: exit (1); ! 569: } ! 570: if (DOSALLOCSEG (sizeof (struct image),(unsigned far *)&descsel, 0) != 0) { ! 571: cleandisplay (); ! 572: printf ("Unable to allocate image descriptor segment of %d bytes\n", sizeof (struct image)); ! 573: exit (1); ! 574: } ! 575: ! 576: FP_SEG (tlist->desc) = descsel; ! 577: FP_OFF (tlist->desc) = 0; ! 578: ! 579: /* Read description of the computed Mandelbrot set from the file ! 580: * and perform simple validation checks. Limit the display rows and ! 581: * columns to the display maximums. ! 582: */ ! 583: ! 584: if (fread ((char *)&timage.nreal, sizeof (int), 1, fmand) != 1) { ! 585: cleandisplay (); ! 586: printf ("Error reading maximum number of reals %d\n", timage.nreal); ! 587: exit (2); ! 588: } ! 589: timage.lnr = (timage.nreal > 640)? 640: timage.nreal; ! 590: if (fread ((char *)&timage.nimag, sizeof (int), 1, fmand) != 1) { ! 591: cleandisplay (); ! 592: printf ("Error reading maximum number of imaginaries %d\n", timage.nimag); ! 593: exit (2); ! 594: } ! 595: timage.lni = (timage.nimag > 350)? 350: timage.nimag; ! 596: if (fread ((char *)&timage.mloop, sizeof (int), 1, fmand) != 1) { ! 597: cleandisplay (); ! 598: printf ("Error reading maximum loop count %d\n", timage.mloop); ! 599: exit (2); ! 600: } ! 601: if (fread ((char *)&timage.ul, sizeof (timage.ul), 1, fmand) != 1) { ! 602: cleandisplay (); ! 603: printf ("Error reading upper left coordinates\n"); ! 604: exit (2); ! 605: } ! 606: if (fread ((char *)&timage.lr, sizeof (timage.lr), 1, fmand) != 1) { ! 607: cleandisplay (); ! 608: printf ("Error reading lower right coordinates\n"); ! 609: exit (2); ! 610: } ! 611: ! 612: if (fread ((char *)&timage.rinc, sizeof (timage.rinc), 1, fmand) != 1) { ! 613: cleandisplay (); ! 614: printf ("Error reading real increment\n"); ! 615: exit (2); ! 616: } ! 617: if (fread ((char *)&timage.iinc, sizeof (timage.iinc), 1, fmand) != 1) { ! 618: cleandisplay (); ! 619: printf ("Error reading imaginary increment\n"); ! 620: exit (2); ! 621: } ! 622: if (fread ((char *)&timage.aspect, sizeof (timage.aspect), 1, fmand) != 1) { ! 623: cleandisplay (); ! 624: printf ("Error reading aspect ratio\n"); ! 625: exit (2); ! 626: } ! 627: if (fread ((char *)timage.hist, sizeof (long), timage.mloop + 1, fmand) != timage.mloop + 1) { ! 628: cleandisplay (); ! 629: printf ("Error reading histogram\n"); ! 630: exit (2); ! 631: } ! 632: ! 633: /* Assign colors to each iteration count. Black is reserved for ! 634: * points within the Mandelbrot set. ! 635: */ ! 636: ! 637: for (nr = 0; nr < timage.mloop; nr++) { ! 638: timage.cmap[nr] = (nr % 15) + 1; ! 639: } ! 640: timage.cmap[timage.mloop] = 0; ! 641: ! 642: /* Allocate memory for segments to save graphics screen and ! 643: * EGA font tables. ! 644: */ ! 645: ! 646: for ( i = 0; i < 2; i++) { ! 647: if (DOSALLOCSEG (56020, (unsigned far *)&timage.savesel[i], 0) != 0) { ! 648: cleandisplay (); ! 649: printf ("Unable to allocate screen save segments\n"); ! 650: exit (1); ! 651: } ! 652: } ! 653: ! 654: /* Link image to chain of images */ ! 655: ! 656: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 657: /* copy structure to far segment */ ! 658: *(tlist->desc) = timage; ! 659: tlist->next = NULL; ! 660: tlist->prev = tail; ! 661: if (head == NULL) ! 662: head = tlist; ! 663: else ! 664: tail->next = tlist; ! 665: tail = tlist; ! 666: curr = tlist; ! 667: ! 668: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 669: ! 670: /* Lock the screen, set the display to graphics mode ! 671: * and draw the Mandelbrot set ! 672: */ ! 673: ! 674: mdisp (curr->desc); ! 675: } ! 676: ! 677: ! 678: ! 679: ! 680: /** ! 681: * ! 682: * ! 683: */ ! 684: ! 685: cleandisplay () ! 686: { ! 687: /* cancel mode wait and redraw wait threads */ ! 688: ! 689: VIOMODEUNDO (GIVEUPOWNER, KILLTHREAD, RESERVED); ! 690: VIOSAVREDRAWUNDO (GIVEUPOWNER, KILLTHREAD, RESERVED); ! 691: ! 692: /* Return the EGA adapter to a default mode that hopefully ! 693: * matches the mode that was present when we went into graphics ! 694: * mode. Then restore mode data, text screen data, cursor ! 695: * position and cursor type. ! 696: */ ! 697: ! 698: SetDVideo (); ! 699: if (graphics) { ! 700: /* clear display memory */ ! 701: dpoffset = 0; ! 702: SetScanClear (); ! 703: if (flip) ! 704: dpoffset = PAGESIZE; ! 705: SetScanClear (); ! 706: SetScanRFont (fontsel); ! 707: } ! 708: SetEVideo (); ! 709: VIOSETMODE ((struct ModeData far *)&mode, 0); ! 710: if (VIOWRTCELLSTR ((char far *)screenbuf, screenlen, 0, 0, 0) != 0) { ! 711: printf ("Unable to write text screen data\n"); ! 712: exit (1); ! 713: } ! 714: if (VIOSETCURPOS (currow, curcol, 0) != 0) { ! 715: printf ("Unable to set current cursor position\n"); ! 716: exit (1); ! 717: } ! 718: if (VIOSETCURTYPE ((struct CursorData *)&cursor, 0) != 0) { ! 719: printf ("Unable to set current cursor data\n"); ! 720: exit (1); ! 721: } ! 722: } ! 723: ! 724: ! 725: ! 726: /** nextimage ! 727: * ! 728: */ ! 729: ! 730: ! 731: nextimage () ! 732: { ! 733: int temp; ! 734: ! 735: if (head != tail) { ! 736: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 737: if (curr->next == NULL) ! 738: curr = head; ! 739: else ! 740: curr = curr->next; ! 741: if (flip) ! 742: dpoffset ^= PAGESIZE; ! 743: SetScanRestore (curr->desc->savesel); ! 744: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 745: } ! 746: } ! 747: ! 748: ! 749: ! 750: /** previmage ! 751: * ! 752: */ ! 753: ! 754: ! 755: previmage () ! 756: { ! 757: int temp; ! 758: ! 759: if (head != tail) { ! 760: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 761: VIOSCRLOCK (1, (char far *)&temp, 0); ! 762: if (curr->prev == NULL) ! 763: curr = tail; ! 764: else ! 765: curr = curr->prev; ! 766: if (flip) ! 767: dpoffset ^= PAGESIZE; ! 768: SetScanRestore (curr->desc->savesel); ! 769: VIOSCRUNLOCK (0); ! 770: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 771: } ! 772: } ! 773: ! 774: ! 775: ! 776: ! 777: /** ripple - ripple palette registers ! 778: * ! 779: * ripple (direction); ! 780: * ! 781: * Entry direction = 0 if rotate palette registers up ! 782: * direction = 1 if rotate palette registers down ! 783: * Exit palette registers rotated by one ! 784: * Returns none ! 785: */ ! 786: ! 787: ! 788: ripple (dir) ! 789: int dir; ! 790: { ! 791: int temp; ! 792: int i; ! 793: ! 794: switch (dir) { ! 795: case RIPPLE_UP: ! 796: temp = palette[0x0f]; ! 797: for (i = 0x0f; i > 1; i--) ! 798: palette[i] = palette[i - 1]; ! 799: palette[1] = temp; ! 800: break; ! 801: ! 802: case RIPPLE_DN: ! 803: temp = palette[1]; ! 804: for (i = 1; i < 0x0f; i++) ! 805: palette[i] = palette[i + 1]; ! 806: palette[0x0f] = temp; ! 807: break; ! 808: } ! 809: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 810: setpalette (palette); ! 811: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 812: } ! 813: ! 814: ! 815: ! 816: ! 817: /** flicker - flicker palette value ! 818: * ! 819: * flicker (pal); ! 820: * ! 821: * Entry pal = index of register to flicker ! 822: * Exit palette register toggled between value and black ! 823: * until keyboard input ! 824: * Returns none ! 825: */ ! 826: ! 827: ! 828: flicker (pal) ! 829: int pal; ! 830: { ! 831: int temp; ! 832: int c; ! 833: ! 834: if ((pal > 0) && (pal < 0x10)) { ! 835: temp = palette[pal]; ! 836: while (!nextchar (&c, 1)) { ! 837: palette[pal] = BLACK; ! 838: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 839: setpalette (palette); ! 840: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 841: DOSSLEEP ((long)100); ! 842: palette[pal] = temp; ! 843: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 844: setpalette (palette); ! 845: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 846: DOSSLEEP ((long)100); ! 847: } ! 848: ungetchar (); ! 849: } ! 850: } ! 851: ! 852: ! 853: ! 854: ! 855: ! 856: /** paledit - edit palette registers ! 857: * ! 858: * paledit (); ! 859: * ! 860: * Entry none ! 861: */ ! 862: ! 863: ! 864: paledit () ! 865: { ! 866: int pal; ! 867: int c; ! 868: ! 869: /* select palette register */ ! 870: ! 871: pal = 1; ! 872: flicker (pal); ! 873: while (TRUE) { ! 874: nextchar (&c, 0); ! 875: switch (-c) { ! 876: case UP: ! 877: if (pal++ > 0x0f) ! 878: pal = 1; ! 879: flicker (pal); ! 880: break; ! 881: ! 882: case DOWN: ! 883: if (pal-- < 1) ! 884: pal = 0x0f; ! 885: flicker (pal); ! 886: break; ! 887: ! 888: case RIGHT: ! 889: if (++palette[pal] > 0x3f) ! 890: palette[pal] = 1; ! 891: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 892: setpalette (palette); ! 893: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 894: break; ! 895: ! 896: case LEFT: ! 897: if (--palette[pal] == 0) ! 898: palette[pal] = 0x3f; ! 899: DOSSEMREQUEST ((unsigned long)(long far *)&drawsem, (long)-1); ! 900: setpalette (palette); ! 901: DOSSEMCLEAR ((unsigned long)(long far *)&drawsem); ! 902: break; ! 903: ! 904: default: ! 905: ungetchar (); ! 906: return; ! 907: } ! 908: } ! 909: } ! 910: ! 911: ! 912: ! 913: ! 914: /** nextchar - get next character from keyboard ! 915: * ! 916: * flag = nextchar (pchar, wait); ! 917: * ! 918: * Entry char = pointer to character return location ! 919: * wait = 0 if delay until character entered ! 920: * wait = 1 if immediate return if no character ! 921: * Exit char = next character if found ! 922: * char = -scan code if extend character ! 923: * Return flag = TRUE if character read from keyboard ! 924: * flag = FALSE if no character read and immediate return ! 925: */ ! 926: ! 927: ! 928: nextchar (pchar, wait) ! 929: int *pchar; ! 930: int wait; ! 931: { ! 932: int ret; ! 933: ! 934: if (!chvalid) { ! 935: if ((ret = KBDCHARIN ((struct KeyData far *)&key, wait, 0)) != 0) { ! 936: cleandisplay (); ! 937: printf ("Error %d return from KBDCHARIN\n", ret); ! 938: exit (1); ! 939: } ! 940: firstread = TRUE; ! 941: if ((key.status & 0x40) != 0x40) ! 942: return (FALSE); ! 943: } ! 944: chvalid = FALSE; ! 945: if (key.char_code == 0x00) ! 946: /* process extended ASCII character */ ! 947: *pchar = -(int)key.scan_code; ! 948: else ! 949: *pchar = (int)key.char_code; ! 950: return (TRUE); ! 951: } ! 952: ! 953: ! 954: ! 955: ! 956: ! 957: /** ungetchar - unget character from keyboard ! 958: * ! 959: * ungetchar (); ! 960: * ! 961: * Entry none ! 962: * Exit previous character returned to keyboard ! 963: * Return none ! 964: */ ! 965: ! 966: ! 967: ungetchar () ! 968: { ! 969: if (firstread) ! 970: chvalid = TRUE; ! 971: } ! 972: ! 973: ! 974: ! 975: ! 976: /** setpalette - set EGA palette registers ! 977: * ! 978: * setpalette (palette); ! 979: * ! 980: * Entry palette = byte array of palette registers ! 981: * Exit palette registers written to EGA ! 982: * Return none ! 983: */ ! 984: ! 985: ! 986: setpalette (p) ! 987: char *p; ! 988: { ! 989: int *ip; ! 990: ! 991: vstate.length = sizeof (struct VIOSTATE); ! 992: vstate.req_type = 0; ! 993: vstate.double_defined = 0; ! 994: for (ip = &vstate.palette0; ip <= &vstate.palette15; ) ! 995: *ip++ = *p++; ! 996: if (VIOSETSTATE ((struct VIOSTATE far *)&vstate, 0) != 0) { ! 997: cleandisplay (); ! 998: printf ("Unable to set palette registers\n"); ! 999: exit (1); ! 1000: } ! 1001: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.