home *** CD-ROM | disk | FTP | other *** search
/ Stars of Shareware: Programmierung / SOURCE.mdf / programm / windows / c / winfrsrc / windos.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-10-24  |  29.9 KB  |  1,206 lines
  1. /*
  2.     Routines which simulate DOS functions in the existing
  3.     Fractint for DOS
  4. */
  5.  
  6. #include "windows.h"
  7. #include "drivinit.h"
  8. #include "fractint.h"
  9. #include "winfract.h"
  10. #include <string.h>
  11. #include <time.h>
  12. #include <stdarg.h>
  13. #include <stdio.h>
  14.  
  15. #ifndef TIMERINFO
  16.                 /* define TIMERINFO stuff, if needs be */
  17. typedef struct tagTIMERINFO {
  18.     DWORD dwSize;
  19.     DWORD dwmsSinceStart;
  20.     DWORD dwmsThisVM;
  21.     } TIMERINFO;
  22.  
  23. BOOL    far pascal TimerCount(TIMERINFO FAR *);
  24. #endif
  25.  
  26. int stopmsg(int ,CHAR far *);
  27. int  farread(int, LPSTR, WORD);
  28. int  farwrite(int, LPSTR, WORD);
  29.  
  30. extern unsigned char FullPathName[];
  31. extern int FileFormat;
  32.  
  33. int save_system;       /* tag identifying Fractint for Windows */
  34. int save_release;       /* tag identifying version number */
  35. extern int win_release;    /* tag identifying version number  (in WINDOS2.C) */
  36.  
  37. extern BOOL bTrack, bMove;         /* TRUE if user is selecting a region */
  38. extern BOOL zoomflag;             /* TRUE is a zoom-box selected */
  39.  
  40. extern HWND hwnd;             /* handle to main window */
  41. extern HANDLE hInst;
  42.  
  43. extern HANDLE hAccTable;             /* handle to accelerator table */
  44.  
  45. extern char szHelpFileName[];         /* Help file name*/
  46.  
  47. extern int xdots, ydots, colors, maxiter;
  48. extern int xposition, yposition, win_xoffset, win_yoffset, xpagesize, ypagesize;
  49. extern int win_xdots, win_ydots;
  50.  
  51. extern int last_written_y;         /* last line written */
  52. extern int screen_to_be_cleared;     /* clear screen flag */
  53.  
  54. extern int time_to_act;          /* time to take some action? */
  55. extern int time_to_restart;         /* time to restart?  */
  56. extern int time_to_resume;         /* time to resume? */
  57. extern int time_to_quit;         /* time to quit? */
  58. extern int time_to_reinit;         /* time to reinitialize? */
  59. extern int time_to_load;         /* time to load? (DECODE) */
  60. extern int time_to_save;         /* time to save? (ENCODE) */
  61. extern int time_to_print;         /* time to print? (PRINTER) */
  62. extern int time_to_cycle;         /* time to begin color-cycling? */
  63. extern int time_to_starfield;        /* time to make a starfield? */
  64. extern int time_to_orbit;            /* time to activate orbits? */
  65.  
  66. extern unsigned char dacbox[256][3];
  67.  
  68. extern BOOL win_systempaletteused;    /* flag system palette set */
  69.  
  70. extern unsigned char far temp_array[];     /* temporary spot for Encoder rtns */
  71.  
  72. extern HANDLE hpixels;            /* handle to the DIB pixels */
  73. extern unsigned char huge *pixels;   /* the device-independent bitmap pixels */
  74. int pixels_per_byte;             /* pixels/byte in the pixmap */
  75. long pixels_per_bytem1;          /* pixels / byte - 1 (for ANDing) */
  76. int pixelshift_per_byte;         /* 0, 1, 2, or 3 */
  77. int bytes_per_pixelline;         /* pixels/line / pixels/byte */
  78. long win_bitmapsize;             /* bitmap size, in bytes */
  79.  
  80. extern int win_overlay3d;
  81. extern int win_display3d;
  82.  
  83.  
  84. BOOL dont_wait_for_a_key = TRUE;
  85.  
  86. #ifdef __BORLANDC__
  87.  
  88. /* Too many functions defaulting to a type 'int' return that should be
  89.    a type 'void'.  I'll just get rid of the warning message for this file
  90.    only.  MCP 8-6-91 */
  91.  
  92.    #pragma warn -rvl
  93.  
  94.    int LPTNumber;
  95.    int stackavail() { return(10240 + (signed int)_SP); }
  96. #else
  97.    int printf() {}
  98.    int _bios_serialcom(){}
  99. #endif
  100.  
  101.  
  102. extern int far wintext_textmode, far wintext_AltF4hit;
  103.  
  104. int getakey()
  105. {
  106. int i;
  107.  
  108. if (time_to_orbit) {  /* activate orbits? */
  109.     zoomflag = FALSE;
  110.     time_to_orbit = 0;
  111.     i = 'o';
  112.     return(i);
  113.     }
  114.  
  115. dont_wait_for_a_key = FALSE;
  116. i = keypressed();
  117. dont_wait_for_a_key = TRUE;
  118. zoomflag = FALSE;
  119. return(i);
  120.  
  121. }
  122.  
  123. int keypressed()
  124. {
  125. MSG msg;
  126. int time_to;
  127.  
  128. /* is a text-mode screen active? */
  129. if (wintext_textmode == 2 || wintext_AltF4hit) {
  130.     if (dont_wait_for_a_key)
  131.         return(fractint_getkeypress(0));
  132.     else
  133.         return(fractint_getkeypress(1));
  134.     }
  135.  
  136. if (dont_wait_for_a_key)
  137.     if (PeekMessage(&msg, NULL, NULL, NULL, PM_NOREMOVE) == 0) {
  138.     time_to = time_to_act + time_to_reinit+time_to_restart+time_to_quit+
  139.         time_to_load+time_to_save+time_to_print+time_to_cycle+
  140.         time_to_resume+time_to_starfield;
  141.     if (time_to_orbit) {  /* activate orbits? */
  142.         time_to = 'o';
  143.         }
  144.     /* bail out if nothing is happening */
  145.     return(time_to);
  146.     }
  147.  
  148. while (GetMessage(&msg, NULL, NULL, NULL)) {
  149.  
  150.     if (!TranslateAccelerator(hwnd, hAccTable, &msg)) {
  151.         TranslateMessage(&msg);
  152.         DispatchMessage(&msg);
  153.         }
  154.  
  155.     CheckMathTools();
  156.     if (!bTrack && !bMove) {          /* don't do this if mouse-button is down */
  157.     time_to = time_to_act+time_to_reinit+time_to_restart+time_to_quit+
  158.         time_to_load+time_to_save+time_to_print+time_to_cycle+
  159.         time_to_starfield;
  160.     if (time_to_orbit) {  /* activate orbits? */
  161.         time_to = 'o';
  162.         }
  163.     if (dont_wait_for_a_key || time_to)
  164.         return(time_to);
  165.     }
  166.  
  167.     }
  168.  
  169. if (!dont_wait_for_a_key)
  170.     time_to_quit = 1;
  171.  
  172.     /* bail out if nothing is happening */
  173.     time_to = time_to_act+time_to_reinit+time_to_restart+time_to_quit+
  174.     time_to_load+time_to_save+time_to_print+time_to_cycle;
  175.     if (time_to_orbit) {  /* activate orbits? */
  176.         time_to = 'o';
  177.         }
  178.     return(time_to);
  179.  
  180. }
  181.  
  182. int  farread(int handle, LPSTR buf, WORD len)
  183. {
  184. int i;
  185.  
  186.     i = _lread(handle, buf, len);
  187.     return(i);
  188.  
  189. }
  190.  
  191. int  farwrite(int handle, LPSTR buf, WORD len)
  192. {
  193.  
  194.     return(_lwrite(handle, buf, len));
  195.  
  196. }
  197.  
  198.  
  199. extern int win_fastupdate;
  200.  
  201. time_t last_time;
  202. time_t update_time;
  203. long minimum_update;
  204. long pixelsout;
  205. int top_changed, bottom_changed;
  206.  
  207. /* Made global, MCP 6-16-91 */
  208. unsigned char win_andmask[8];
  209. unsigned char win_notmask[8];
  210. unsigned char win_bitshift[8];
  211.  
  212. void putcolor(int x, int y, int color)
  213. {
  214. RECT tempRect;             /* temporary rectangle structure */
  215. long i;
  216. int temp_top_changed, temp_bottom_changed;
  217. time_t this_time;
  218.  
  219. last_written_y = y;
  220. if (y < top_changed) top_changed = y;
  221. if (y > bottom_changed) bottom_changed = y;
  222.  
  223. i = win_ydots-1-y;
  224. i = (i * win_xdots) + x;
  225.  
  226. if (x >= 0 && x < xdots && y >= 0 && y < ydots) {
  227.     if (pixelshift_per_byte == 0) {
  228.       pixels[i] = color % colors;
  229.       }
  230.      else {
  231.       unsigned int j;
  232.       j = i & pixels_per_bytem1;
  233.       i = i >> pixelshift_per_byte;
  234.       pixels[i] = (pixels[i] & win_notmask[j]) +
  235.           (((unsigned char)(color % colors)) << win_bitshift[j]);
  236.       }
  237.  
  238.      /* check the time every nnn pixels */
  239.      if (win_fastupdate || ++pixelsout > 100) {
  240.       pixelsout = 0;
  241.       this_time = time(NULL);
  242.       /* time to update the screen? */
  243.       if (win_fastupdate || (this_time - last_time) > update_time ||
  244.           (minimum_update*(this_time-last_time)) > (bottom_changed-top_changed)) {
  245.           temp_top_changed = top_changed - win_yoffset;
  246.           temp_bottom_changed = bottom_changed - win_yoffset;
  247.           if (!(temp_top_changed >= ypagesize || temp_bottom_changed < 0)) {
  248.           if (temp_top_changed    < 0) temp_top_changed    = 0;
  249.           if (temp_bottom_changed < 0) temp_bottom_changed = 0;
  250.           if (temp_top_changed    > ypagesize) temp_top_changed    = ypagesize;
  251.           if (temp_bottom_changed > ypagesize) temp_bottom_changed = ypagesize;
  252.           tempRect.top = temp_top_changed;
  253.           tempRect.bottom = temp_bottom_changed+1;
  254.           tempRect.left = 0;
  255.           tempRect.right = xdots;
  256.                   if (win_fastupdate == 1) {
  257.                       tempRect.left =  x-win_xoffset;
  258.                       tempRect.right = x-win_xoffset+1;
  259.                       }
  260.           InvalidateRect(hwnd, &tempRect, FALSE);
  261. /*
  262.                   EndDeferWindowPos(BeginDeferWindowPos(0));
  263. */
  264.           }
  265.           if (win_fastupdate) {
  266.                   extern int kbdcount;
  267.                   if (kbdcount > 5)
  268.                       kbdcount = 5;
  269.               win_fastupdate = 1;
  270.               }
  271.           keypressed();    /* force a look-see at the screen */
  272.           last_time = this_time;
  273.           top_changed = win_ydots;
  274.           bottom_changed = 0;
  275.           }
  276.       }
  277.      }
  278.  
  279. }
  280.  
  281. int getcolor(int x, int y)
  282. {
  283. long i;
  284.  
  285. i = win_ydots-1-y;
  286. i = (i * win_xdots) + x;
  287.  
  288. if (x >= 0 && x < xdots && y >= 0 && y < ydots) {
  289.     if (pixelshift_per_byte == 0) {
  290.       return(pixels[i]);
  291.       }
  292.      else {
  293.       unsigned int j;
  294.       j = i & pixels_per_bytem1;
  295.       i = i >> pixelshift_per_byte;
  296.       return((int)((pixels[i] & win_andmask[j]) >> win_bitshift[j]));
  297.       }
  298.      }
  299. else
  300.      return(0);
  301. }
  302.  
  303. int put_line(int rownum, int leftpt, int rightpt, unsigned char *localvalues)
  304. {
  305. int i, len;
  306. long startloc;
  307.  
  308. len = rightpt - leftpt;
  309. if (rightpt >= xdots) len = xdots - 1 - leftpt;
  310. startloc = win_ydots-1-rownum;
  311. startloc = (startloc * win_xdots) + leftpt;
  312.  
  313. if (rownum < 0 || rownum >= ydots || leftpt < 0) {
  314.     return(0);
  315.     }
  316.  
  317. if (pixelshift_per_byte == 0) {
  318.     for (i = 0; i <= len; i++)
  319.     pixels[startloc+i] = localvalues[i];
  320.     }
  321. else {
  322.     unsigned int j;
  323.     long k;
  324.     for (i = 0; i <= len; i++) {
  325.     k = startloc + i;
  326.     j = k & pixels_per_bytem1;
  327.     k = k >> pixelshift_per_byte;
  328.     pixels[k] = (pixels[k] & win_notmask[j]) +
  329.         (((unsigned char)(localvalues[i] % colors)) << win_bitshift[j]);
  330.     }
  331.     }
  332. pixelsout += len;
  333. if (win_fastupdate)
  334.     win_fastupdate = 2;  /* force 'putcolor()' to update a whole scanline */
  335. putcolor(leftpt, rownum, localvalues[0]);
  336. }
  337.  
  338. int get_line(int rownum, int leftpt, int rightpt, unsigned char *localvalues)
  339. {
  340. int i, len;
  341. long startloc;
  342.  
  343. len = rightpt - leftpt;
  344. if (rightpt >= xdots) len = xdots - 1 - leftpt;
  345. startloc = win_ydots-1-rownum;
  346. startloc = (startloc * win_xdots) + leftpt;
  347.  
  348. if (rownum < 0 || rownum >= ydots || leftpt < 0 || rightpt >= xdots) {
  349.     for (i = 0; i <= len; i++)
  350.     localvalues[i] = 0;
  351.     return(0);
  352.     }
  353.  
  354. if (pixelshift_per_byte == 0) {
  355.     for (i = 0; i <= len; i++)
  356.     localvalues[i] = pixels[startloc+i];
  357.     }
  358. else {
  359.     unsigned int j;
  360.     long k;
  361.     for (i = 0; i <= len; i++) {
  362.     k = startloc + i;
  363.     j = k & pixels_per_bytem1;
  364.     k = k >> pixelshift_per_byte;
  365.     localvalues[i] = (pixels[k] & win_andmask[j]) >> win_bitshift[j];
  366.     }
  367.     }
  368. }
  369.  
  370. extern int rowcount;
  371.  
  372. int out_line(unsigned char *localvalues, int numberofdots)
  373. {
  374.     put_line(rowcount++, 0, numberofdots, localvalues);
  375. }
  376.  
  377. extern LPBITMAPINFO pDibInfo;        /* pointer to the DIB info */
  378.  
  379. int clear_screen(int forceclear)
  380. {
  381. long numdots;
  382. int i;
  383.  
  384. /* set up the videoentry values */
  385. strcpy(videoentry.name,   "Windows Video Image");
  386. strcpy(videoentry.comment,"Generated using Winfract");
  387. videoentry.keynum      = 40;
  388. videoentry.videomodeax = 3;
  389. videoentry.videomodebx = 0;
  390. videoentry.videomodecx = 0;
  391. videoentry.videomodedx = 0;
  392. videoentry.dotmode     = 1;
  393. videoentry.xdots       = xdots;
  394. videoentry.ydots       = ydots;
  395. videoentry.colors      = colors;
  396.  
  397. win_xdots = (xdots+3) & 0xfffc;
  398. win_ydots = ydots;
  399. pixelshift_per_byte = 0;
  400. pixels_per_byte   = 1;
  401. pixels_per_bytem1 = 0;
  402. if (colors == 16) {
  403.     win_xdots = (xdots+7) & 0xfff8;
  404.     pixelshift_per_byte = 1;
  405.     pixels_per_byte = 2;
  406.     pixels_per_bytem1 = 1;
  407.     win_andmask[0] = 0xf0;  win_notmask[0] = 0x0f; win_bitshift[0] = 4;
  408.     win_andmask[1] = 0x0f;  win_notmask[1] = 0xf0; win_bitshift[1] = 0;
  409.     }
  410. if (colors == 2) {
  411.     win_xdots = (xdots+31) & 0xffe0;
  412.     pixelshift_per_byte = 3;
  413.     pixels_per_byte = 8;
  414.     pixels_per_bytem1 = 7;
  415.     win_andmask[0] = 0x80;  win_notmask[0] = 0x7f; win_bitshift[0] = 7;
  416.     for (i = 1; i < 8; i++) {
  417.     win_andmask[i] = win_andmask[i-1] >> 1;
  418.     win_notmask[i] = (win_notmask[i-1] >> 1) + 0x80;
  419.     win_bitshift[i] = win_bitshift[i-1] - 1;
  420.     }
  421.     }
  422.  
  423. numdots = (long)win_xdots * (long) win_ydots;
  424. update_time = 2;
  425. /* disable the long delay logic 
  426. if (numdots > 200000L) update_time = 4;
  427. if (numdots > 400000L) update_time = 8;
  428. */
  429. last_time = time(NULL) - update_time + 1;
  430. minimum_update = 7500/xdots;    /* assume 75,000 dots/sec drawing speed */
  431.  
  432. last_written_y = -1;
  433. pixelsout = 0;
  434. top_changed = win_ydots;
  435. bottom_changed = 0;
  436.  
  437. bytes_per_pixelline = win_xdots >> pixelshift_per_byte;
  438.  
  439. /* Create the Device-independent Bitmap entries */
  440. pDibInfo->bmiHeader.biWidth  = win_xdots;
  441. pDibInfo->bmiHeader.biHeight = win_ydots;
  442. pDibInfo->bmiHeader.biSizeImage = (DWORD)bytes_per_pixelline * win_ydots;
  443. pDibInfo->bmiHeader.biBitCount = 8 / pixels_per_byte;
  444.  
  445. /* hard to believe, but this is the fast way to clear the pixel map */
  446. if (hpixels) {
  447.      GlobalUnlock(hpixels);
  448.      GlobalFree(hpixels);
  449.      }
  450.  
  451. win_bitmapsize = (numdots >> pixelshift_per_byte)+1;
  452.  
  453. if (!(hpixels = GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, win_bitmapsize)))
  454.      return(0);
  455. if (!(pixels = (char huge *)GlobalLock(hpixels))) {
  456.      GlobalFree(hpixels);
  457.      return(0);
  458.      }
  459.  
  460. /* adjust the colors for B&W or default */
  461. if (colors == 2) {
  462.     dacbox[0][0] = dacbox[0][1] = dacbox[0][2] = 0;
  463.     dacbox[1][0] = dacbox[1][1] = dacbox[1][2] = 63;
  464.     spindac(0,1);
  465.     }
  466. else
  467.     restoredac();   /* color palette */
  468.  
  469. screen_to_be_cleared = 1;
  470. InvalidateRect(hwnd, NULL, TRUE);
  471.  
  472. if (forceclear)
  473.     keypressed();        /* force a look-see at the screen */
  474.  
  475. return(1);
  476. }
  477.  
  478. int flush_screen()
  479. {
  480.  
  481. last_written_y = 0;
  482.  
  483. InvalidateRect(hwnd, NULL, FALSE);
  484.  
  485. }
  486.  
  487. void buzzer(int i)
  488. {
  489.  
  490. MessageBeep(0);
  491.  
  492. }
  493.  
  494.  
  495. #define MAXFARMEMALLOCS  50        /* max active farmemallocs */
  496. int   farmemallocinit = 0;        /* any memory been allocated yet?   */
  497. HANDLE farmemallochandles[MAXFARMEMALLOCS];            /* handles  */
  498. void far *farmemallocpointers[MAXFARMEMALLOCS]; /* pointers */
  499.  
  500. void far * cdecl farmemalloc(long bytecount)
  501. {
  502. int i;
  503. HANDLE temphandle;
  504. void far *temppointer;
  505.  
  506. if (!farmemallocinit) {     /* never been here yet - initialize */
  507.     farmemallocinit = 1;
  508.     for (i = 0; i < MAXFARMEMALLOCS; i++) {
  509.     farmemallochandles[i] = (HANDLE)0;
  510.     farmemallocpointers[i] = NULL;
  511.     }
  512.     }
  513.  
  514. for (i = 0; i < MAXFARMEMALLOCS; i++)  /* look for a free handle */
  515.     if (farmemallochandles[i] == (HANDLE)0) break;
  516.  
  517. if (i == MAXFARMEMALLOCS)    /* uh-oh - no more handles */
  518.    return(NULL);        /* can't get far memory this way */
  519.  
  520. if (!(temphandle = GlobalAlloc(GMEM_FIXED | GMEM_ZEROINIT, bytecount)))
  521.      return(NULL);        /* can't allocate the memory */
  522.  
  523. if ((temppointer = (void far *)GlobalLock(temphandle)) == NULL) {
  524.      GlobalFree(temphandle);
  525.      return(NULL);        /* ?? can't lock the memory ?? */
  526.      }
  527.  
  528. farmemallochandles[i] =  temphandle;
  529. farmemallocpointers[i] = temppointer;
  530. return(temppointer);
  531. }
  532.  
  533. void farmemfree(void far *bytepointer)
  534. {
  535. int i;
  536.  
  537. if (bytepointer == (void far *)NULL) return;
  538.  
  539. for (i = 0; i < MAXFARMEMALLOCS; i++)    /* search for a matching pointer */
  540.     if (farmemallocpointers[i] == bytepointer)
  541.      break;
  542. if (i < MAXFARMEMALLOCS) {        /* got one */
  543.     GlobalUnlock(farmemallochandles[i]);
  544.     GlobalFree(farmemallochandles[i]);
  545.     farmemallochandles[i] = (HANDLE)0;
  546.     }
  547.  
  548. }
  549.  
  550. debugmessage(char *msg1, char *msg2)
  551. {
  552. MessageBox (
  553.     GetFocus(),
  554.     msg2,
  555.     msg1,
  556.     MB_ICONASTERISK | MB_OK);
  557.  
  558. }
  559.  
  560. texttempmsg(char *msg1)
  561. {
  562. MessageBox (
  563.     GetFocus(),
  564.     msg1,
  565.     "Encoder",
  566.     MB_ICONASTERISK | MB_OK);
  567. }
  568.  
  569. stopmsg(int flags, unsigned char far *msg1)
  570. {
  571. int result;
  572.  
  573. if (! (flags & 4)) MessageBeep(0);
  574.  
  575. result = IDOK;
  576.  
  577. if (!(flags & 2))
  578.     MessageBox (
  579.     NULL,
  580.     msg1,
  581.     "Fractint for Windows",
  582.     MB_TASKMODAL | MB_ICONASTERISK | MB_OK);
  583. else
  584.     result = MessageBox (
  585.     NULL,
  586.     msg1,
  587.     "Fractint for Windows",
  588.     MB_TASKMODAL | MB_ICONQUESTION | MB_OKCANCEL);
  589.  
  590. if (result == 0 || result == IDOK || result == IDYES)
  591.     return(0);
  592. else
  593.     return(-1);
  594. }
  595.  
  596. extern char readname[];
  597. extern int fileydots, filexdots, filecolors;
  598. extern int     iNumColors;    /* Number of colors supported by device           */
  599. extern int     iRasterCaps;   /* Raster capabilities                   */
  600.  
  601. win_load()
  602. {
  603. int i;
  604.  
  605. time_to_load = 0;
  606.  
  607.     start_wait();
  608.     if ((i = read_overlay()) >= 0 && (!win_display3d ||
  609.     xdots < filexdots || ydots < fileydots)) {
  610.     if (win_display3d) stopmsg(0,
  611.         "3D and Overlay3D file image sizes must be\nat least as large as the display image.\nAltering your display image to match the file.");
  612.     xdots = filexdots;
  613.     ydots = fileydots;
  614.     colors = filecolors;
  615.     if (colors > 16) colors = 256;
  616.     if (colors >  2 && colors < 16) colors = 16;
  617.     if (xdots < 50) xdots = 50;
  618.     if (xdots > 2048) xdots = 2048;
  619.     if (ydots < 50) ydots = 50;
  620.     if (ydots > 2048) ydots = 2048;
  621.     set_win_offset();
  622.     clear_screen(0);
  623.     }
  624.     end_wait();
  625.     return(i);
  626. }
  627.  
  628. win_save()
  629. {
  630.     time_to_save = 0;
  631.     save_system = 1;
  632.     save_release = win_release;
  633.  
  634.     /* MCP 10-27-91 */
  635.     if(FileFormat != ID_BMP)
  636.        savetodisk(readname);
  637.     else
  638.        SaveBitmapFile(hwnd, FullPathName);
  639.     CloseStatusBox();
  640. }
  641.  
  642. /*
  643.     Delay code - still not so good for a multi-tasking environment, 
  644.     but what the hell...
  645. */
  646.  
  647. DWORD DelayCount;
  648.  
  649. DWORD DelayMillisecond(void)
  650. {
  651.    DWORD i;
  652.  
  653.    i = 0;
  654.    while(i != DelayCount)
  655.       i++;
  656.    return(i);
  657. }
  658.  
  659. void delay(DWORD milliseconds)
  660. {
  661.    DWORD n, i, j;
  662.  
  663. if (DelayCount == 0) {      /* use version 3.1's 1ms timer */
  664.  
  665.     TIMERINFO timerinfo;
  666.  
  667.     timerinfo.dwSize = sizeof(timerinfo);
  668.     TimerCount(&timerinfo);
  669.     n = timerinfo.dwmsSinceStart;
  670.     i = n + milliseconds;
  671.     for (;;) {
  672.         keypressed();        /* let the other folks in */
  673.         TimerCount(&timerinfo);
  674.         j = timerinfo.dwmsSinceStart;
  675.         if (j < n || j >= i)
  676.             break;
  677.         }   
  678.  
  679.    }
  680. else {
  681.    for(n = 0; n < milliseconds; n++)
  682.       DelayMillisecond();
  683.    }
  684.  
  685. }
  686.  
  687. void CalibrateDelay(void)
  688. {
  689.     DWORD Now, Time, Delta, TimeAdj;
  690.     
  691.     /* this logic switches tothe fast timer logic supplied by TimerCount */
  692.     DelayCount = 0;
  693.     return;
  694.  
  695.    DelayCount = 128;
  696.  
  697.    /* Determine the Windows timer resolution.  It's usually 38ms in
  698.       version 3.0, but that may change latter. */
  699.    Now = Time = GetCurrentTime();
  700.    while(Time == Now)
  701.       Now = GetCurrentTime();
  702.  
  703.    /* Logrithmic Adjust */
  704.    Delta = Now - Time;
  705.    Time = Now;
  706.    while(Time == Now)
  707.    {
  708.       delay(Delta);
  709.       Now = GetCurrentTime();
  710.       if(Time == Now)
  711.       {
  712.          /* Resynch */
  713.          Time = Now = GetCurrentTime();
  714.          while(Time == Now)
  715.             Now = GetCurrentTime();
  716.          Time = Now;
  717.          DelayCount <<= 1;
  718.       }
  719.    }
  720.  
  721.    /* Linear Adjust */
  722.    Time = Now;
  723.    TimeAdj = (DelayCount - (DelayCount >> 1)) >> 1;
  724.    DelayCount -= TimeAdj;
  725.    while(TimeAdj > 16)
  726.    {
  727.       delay(Delta);
  728.       TimeAdj >>= 1;
  729.       if(GetCurrentTime() == Now)
  730.          DelayCount += TimeAdj;
  731.       else
  732.          DelayCount -= TimeAdj;
  733.  
  734.       /* Resynch */
  735.       Time = Now = GetCurrentTime();
  736.       while(Time == Now)
  737.          Now = GetCurrentTime();
  738.       Time = Now;
  739.    }
  740. }
  741.  
  742. /*
  743.     Color-cycling logic
  744.     includes variable-delay capabilities
  745. */
  746.  
  747. extern int win_cycledir, win_cyclerand, win_cyclefreq, win_cycledelay;
  748.  
  749. extern HANDLE  hPal;       /* Palette Handle */
  750. extern LPLOGPALETTE pLogPal;  /* pointer to the application's logical palette */
  751. extern unsigned char far win_dacbox[256][3];
  752. #define PALETTESIZE 256           /* dull-normal VGA            */
  753.  
  754. static int win_fsteps[] = {54, 24, 8};
  755.  
  756. int win_animate_flag = 0;
  757. int win_syscolorindex[21];
  758. DWORD win_syscolorold[21];
  759. DWORD win_syscolornew[21];
  760.  
  761. extern int debugflag;
  762.  
  763. win_cycle()
  764. {
  765. int istep, jstep, fstep, step, oldstep, last, next, maxreg;
  766. int incr, fromred, fromblue, fromgreen, tored, toblue, togreen;
  767. HDC hDC;              /* handle to device context        */
  768.  
  769. fstep = 1;                /* randomization frequency    */
  770. oldstep = 1;                /* single-step            */
  771. step = 256;                /* single-step            */
  772. incr = 999;                /* ready to randomize        */
  773. maxreg = 256;                /* maximum register to rotate    */
  774. last = maxreg-1;            /* last box that was filled    */
  775. next = 1;                /* next box to be filled    */
  776. if (win_cycledir < 0) {
  777.     last = 1;
  778.     next = maxreg;
  779.     }
  780.  
  781. win_title_text(2);
  782.  
  783. srand((unsigned)time(NULL));        /* randomize things        */
  784.  
  785. hDC = GetDC(GetFocus());
  786.  
  787. win_animate_flag = 1;
  788. SetPaletteEntries(hPal, 0, pLogPal->palNumEntries, pLogPal->palPalEntry);
  789. SelectPalette (hDC, hPal, 1);
  790.  
  791. if ((iNumColors == 16 || debugflag == 1000) && !win_systempaletteused) {
  792.     int i;
  793.     DWORD white, black;
  794.     win_systempaletteused = TRUE;
  795.     white = 0xffffff00;
  796.     black = 0;
  797.     for (i = 0; i <= COLOR_ENDCOLORS; i++) {
  798.     win_syscolorindex[i] = i;
  799.     win_syscolorold[i] = GetSysColor(i);
  800.     win_syscolornew[i] = black;
  801.     }
  802.     win_syscolornew[COLOR_BTNTEXT] = white;
  803.     win_syscolornew[COLOR_CAPTIONTEXT] = white;
  804.     win_syscolornew[COLOR_GRAYTEXT] = white;
  805.     win_syscolornew[COLOR_HIGHLIGHTTEXT] = white;
  806.     win_syscolornew[COLOR_MENUTEXT] = white;
  807.     win_syscolornew[COLOR_WINDOWTEXT] = white;
  808.     win_syscolornew[COLOR_WINDOWFRAME] = white;
  809.     win_syscolornew[COLOR_INACTIVECAPTION] = white;
  810.     win_syscolornew[COLOR_INACTIVEBORDER] = white;
  811.     SetSysColors(COLOR_ENDCOLORS,(LPINT)win_syscolorindex,(LONG FAR *)win_syscolornew);
  812.     SetSystemPaletteUse(hDC,SYSPAL_NOSTATIC);
  813.     UnrealizeObject(hPal);
  814.     }
  815.  
  816. while (time_to_cycle) {
  817.     if (win_cyclerand) {
  818.     for (istep = 0; istep < step; istep++) {
  819.         jstep = next + (istep * win_cycledir);
  820.         if (jstep <=      0) jstep += maxreg-1;
  821.         if (jstep >= maxreg) jstep -= maxreg-1;
  822.         if (++incr > fstep) {    /* time to randomize    */
  823.         incr = 1;
  824.         fstep = ((win_fsteps[win_cyclefreq]*
  825.             (rand() >> 8)) >> 6) + 1;
  826.         fromred   = dacbox[last][0];
  827.         fromgreen = dacbox[last][1];
  828.         fromblue  = dacbox[last][2];
  829.         tored      = rand() >> 9;
  830.         togreen   = rand() >> 9;
  831.         toblue      = rand() >> 9;
  832.         }
  833.         dacbox[jstep][0] = fromred     + (((tored   - fromred  )*incr)/fstep);
  834.         dacbox[jstep][1] = fromgreen + (((togreen - fromgreen)*incr)/fstep);
  835.         dacbox[jstep][2] = fromblue  + (((toblue  - fromblue )*incr)/fstep);
  836.         }
  837.     }
  838.     if (step >= 256) step = oldstep;
  839.  
  840.     spindac(win_cycledir,step);
  841.     delay(win_cycledelay);
  842.     AnimatePalette(hPal, 0, pLogPal->palNumEntries, pLogPal->palPalEntry);
  843.     RealizePalette(hDC);
  844.     keypressed();
  845.     if (win_cyclerand == 2) {
  846.     win_cyclerand = 1;
  847.     step = 256;
  848.     }
  849.     }
  850.  
  851. win_animate_flag = 0;
  852. ReleaseDC(GetFocus(),hDC);
  853.  
  854. win_title_text(0);
  855.  
  856. }
  857.  
  858. /* cursor routines */
  859.  
  860. extern HANDLE hSaveCursor;           /* the original cursor value */
  861. extern HANDLE hHourGlass;           /* the hourglass cursor value */
  862.  
  863. start_wait()
  864. {
  865.    hSaveCursor = SetClassWord(hwnd, GCW_HCURSOR, hHourGlass);
  866. }
  867.  
  868. end_wait()
  869. {
  870.    SetClassWord(hwnd, GCW_HCURSOR, hSaveCursor);
  871. }
  872.  
  873. /* video-mode routines */
  874.  
  875. extern int    viewwindow;        /* 0 for full screen, 1 for window */
  876. extern float  viewreduction;        /* window auto-sizing */
  877. extern float  finalaspectratio;     /* for view shape and rotation */
  878. extern int    viewxdots,viewydots;    /* explicit view sizing */
  879. extern int    fileydots, filexdots, filecolors;
  880. extern float  fileaspectratio;
  881. extern int    skipxdots,skipydots;    /* for decoder, when reducing image */
  882.  
  883. int get_video_mode(struct fractal_info *info)
  884. {
  885.    viewwindow = viewxdots = viewydots = 0;
  886.    fileaspectratio = .75;
  887.    skipxdots = skipydots = 0;
  888.    return(0);
  889. }
  890.  
  891.  
  892. int spindac(int direction, int step)
  893. {
  894. int i, j, k;
  895. int cycle_start, cycle_fin;
  896. extern int rotate_lo,rotate_hi;
  897. char tempdacbox;
  898.  
  899. cycle_start = 0;
  900. cycle_fin = 255;
  901. if (time_to_cycle) {
  902.    cycle_start = rotate_lo;
  903.    cycle_fin = rotate_hi;
  904.    }
  905.  
  906. for (k = 0; k < step; k++) {
  907.     if (direction > 0) {
  908.     for (j = 0; j < 3; j++) {
  909.         tempdacbox = dacbox[cycle_fin][j];
  910.         for (i = cycle_fin; i > cycle_start; i--)
  911.         dacbox[i][j] = dacbox[i-1][j];
  912.         dacbox[cycle_start][j] = tempdacbox;
  913.         }
  914.     }
  915.     if (direction < 0) {
  916.     for (j = 0; j < 3; j++) {
  917.         tempdacbox = dacbox[cycle_start][j];
  918.         for (i = cycle_start; i < cycle_fin; i++)
  919.         dacbox[i][j] = dacbox[i+1][j];
  920.         dacbox[cycle_fin][j] = tempdacbox;
  921.         }
  922.     }
  923.     }
  924.  
  925.     /* fill in intensities for all palette entry colors */
  926.     for (i = 0; i < 256; i++) {
  927.     pLogPal->palPalEntry[i].peRed    = ((BYTE)dacbox[i][0]) << 2;
  928.     pLogPal->palPalEntry[i].peGreen = ((BYTE)dacbox[i][1]) << 2;
  929.     pLogPal->palPalEntry[i].peBlue    = ((BYTE)dacbox[i][2]) << 2;
  930.     pLogPal->palPalEntry[i].peFlags = PC_RESERVED;
  931.     }
  932.  
  933.     if (!win_animate_flag) {
  934.     HDC hDC;
  935.     hDC = GetDC(GetFocus());
  936.     SetPaletteEntries(hPal, 0, pLogPal->palNumEntries, pLogPal->palPalEntry);
  937.     SelectPalette (hDC, hPal, 1);
  938.     RealizePalette(hDC);
  939.     ReleaseDC(GetFocus(),hDC);
  940.         /* for non-palette-based adapters, redraw the image */
  941.     if (!iRasterCaps) {
  942.             InvalidateRect(hwnd, NULL, FALSE);
  943.             }
  944.     }
  945. }
  946.  
  947. restoredac()
  948. {
  949. int iLoop;
  950. int j;
  951.  
  952.     /* fill in intensities for all palette entry colors */
  953.     for (iLoop = 0; iLoop < PALETTESIZE; iLoop++)
  954.     for (j = 0; j < 3; j++)
  955.         dacbox[iLoop][j] = win_dacbox[iLoop][j];
  956.     spindac(0,1);
  957. }
  958.  
  959. extern int colorstate;
  960. extern char    colorfile[];
  961.  
  962. int ValidateLuts( char * fn )
  963. {
  964. FILE * f;
  965. unsigned    r, g, b, index;
  966. unsigned char    line[101];
  967. unsigned char    temp[81];
  968.     strcpy (temp,fn);
  969.     if (strchr(temp,'.') == NULL) /* Did name have an extension? */
  970.         strcat(temp,".map");  /* No? Then add .map */
  971.     findpath( temp, line);          /* search the dos path */
  972.     f = fopen( line, "r" );
  973.     if (f == NULL)
  974.         return 1;
  975.     for( index = 0; index < 256; index++ ) {
  976.         if (fgets(line,100,f) == NULL)
  977.             break;
  978.         sscanf( line, "%d %d %d", &r, &g, &b );
  979.         /** load global dac values **/
  980.         dacbox[index][0] = r >> 2;    /* maps default to 8 bits */
  981.         dacbox[index][1] = g >> 2;    /* DAC wants 6 bits */
  982.         dacbox[index][2] = b >> 2;
  983.     }
  984.     fclose( f );
  985.     colorstate = 2;
  986.     strcpy(colorfile,temp);
  987.     return 0;
  988. }
  989.  
  990. int win_thinking = 0;
  991.  
  992. int thinking(int waiting, char *dummy)
  993. {
  994. if (waiting && ! win_thinking) {
  995.     win_thinking = 1;
  996.     start_wait();
  997.     }
  998. if (!waiting)
  999.     end_wait();
  1000. return(keypressed());
  1001. }
  1002.  
  1003. extern HWND far wintext_hWndCopy;                /* a Global copy of hWnd */
  1004.  
  1005. /* Call for help caused by pressing F1 inside the "fractint-style"
  1006.    prompting routines */
  1007. int winfract_help()
  1008. {
  1009.         WinHelp(wintext_hWndCopy,szHelpFileName,HELP_INDEX,0L);
  1010. }
  1011.  
  1012. int far_strlen(char far *string) {
  1013. int i;
  1014. for (i = 0; ; i++)
  1015.     if (string[i] == 0)
  1016.     return(i);
  1017. }
  1018.  
  1019. int far_strnicmp(char far *string1, char far *string2, int maxlen) {
  1020. int i;
  1021. unsigned char j, k;
  1022. for (i = 0;i < maxlen ; i++) {
  1023.     j = string1[i];
  1024.     k = string2[i];
  1025.     if (j >= 'a' && j <= 'z') j -= ('a' - 'A');
  1026.     if (k >= 'a' && k <= 'z') k -= ('a' - 'A');
  1027.     if (j-k != 0)
  1028.     return(j-k);
  1029.     }
  1030. return(0);
  1031. }
  1032.  
  1033. int far_memcpy(void far *string1, void far *string2, int maxlen) {
  1034. int i;
  1035. for (i = 0;i < maxlen ; i++)
  1036.     ((char far *)string1)[i] = ((char far *)string2)[i];
  1037. }
  1038.  
  1039. int far_memcmp(void far *string1, void far *string2, int maxlen) {
  1040. int i;
  1041. unsigned char j, k;
  1042. for (i = 0;i < maxlen ; i++) {
  1043.     j = ((char far *)string1)[i];
  1044.     k = ((char far *)string2)[i];
  1045.     if (j-k != 0)
  1046.     return(j-k);
  1047.     }
  1048. return(0);
  1049. }
  1050.  
  1051. int far_memset(void far *string1, char char2, int maxlen) {
  1052. int i;
  1053. for (i = 0;i < maxlen ; i++)
  1054.     ((char far *)string1)[i] = char2;
  1055. }
  1056.  
  1057. long timer_start,timer_interval;    /* timer(...) start & total */
  1058. extern int  timerflag;
  1059. extern int  show_orbit;
  1060. extern    int    dotmode;        /* video access method        */
  1061. extern    int    maxit;            /* try this many iterations */
  1062.  
  1063. int check_key()
  1064. {
  1065.    int key;
  1066.    if((key = keypressed()) != 0) {
  1067.       if(key != 'o' && key != 'O') {
  1068.      return(-1);
  1069.       }
  1070.       getakey();
  1071.       if (dotmode != 11)
  1072.      show_orbit = 1 - show_orbit;
  1073.    }
  1074.    return(0);
  1075. }
  1076.  
  1077. /* timer function:
  1078.      timer(0,(*fractal)())        fractal engine
  1079.      timer(1,NULL,int width)        decoder
  1080.      timer(2)                encoder
  1081.   */
  1082. #ifndef XFRACT
  1083. int timer(int timertype,int(*subrtn)(),...)
  1084. #else
  1085. int timer(va_alist)
  1086. va_dcl
  1087. #endif
  1088. {
  1089.    va_list arg_marker;    /* variable arg list */
  1090.    char *timestring;
  1091.    time_t ltime;
  1092.    FILE *fp;
  1093.    int out;
  1094.    int i;
  1095.    int do_bench;
  1096.  
  1097. #ifndef XFRACT
  1098.    va_start(arg_marker,subrtn);
  1099. #else
  1100.    int timertype;
  1101.    int (*subrtn)();
  1102.    va_start(arg_marker);
  1103.    timertype = va_arg(arg_marker, int);
  1104.    subrtn = ( int (*)()) va_arg(arg_marker, int *);
  1105. #endif
  1106.  
  1107.    do_bench = timerflag; /* record time? */
  1108.    if (timertype == 2)     /* encoder, record time only if debug=200 */
  1109.       do_bench = (debugflag == 200);
  1110.    if(do_bench)
  1111.       fp=fopen("bench","a");
  1112.    timer_start = clock_ticks();
  1113.    switch(timertype) {
  1114.       case 0:
  1115.      out = (*subrtn)();
  1116.      break;
  1117.       case 1:
  1118.      i = va_arg(arg_marker,int);
  1119.      out = decoder(i);         /* not indirect, safer with overlays */
  1120.      break;
  1121.       case 2:
  1122.      out = encoder();         /* not indirect, safer with overlays */
  1123.      break;
  1124.       }
  1125.    /* next assumes CLK_TCK is 10^n, n>=2 */
  1126.    timer_interval = (clock_ticks() - timer_start) / (CLK_TCK/100);
  1127.  
  1128.    if(do_bench) {
  1129.       time(<ime);
  1130.       timestring = ctime(<ime);
  1131.       timestring[24] = 0; /*clobber newline in time string */
  1132.       switch(timertype) {
  1133.      case 1:
  1134.         fprintf(fp,"decode ");
  1135.         break;
  1136.      case 2:
  1137.         fprintf(fp,"encode ");
  1138.         break;
  1139.      }
  1140.       fprintf(fp,"%s type=%s resolution = %dx%d maxiter=%d",
  1141.       timestring,
  1142.       curfractalspecific->name,
  1143.       xdots,
  1144.       ydots,
  1145.       maxit);
  1146.       fprintf(fp," time= %ld.%02ld secs\n",timer_interval/100,timer_interval%100);
  1147.       if(fp != NULL)
  1148.      fclose(fp);
  1149.       }
  1150.    return(out);
  1151. }
  1152.  
  1153. /* dummy out the environment entries, as we never use them */
  1154. #ifndef QUICKC
  1155. int _setenvp(){return(0);}
  1156. #endif
  1157.  
  1158. void   cdecl far_strcpy( char far *to, char far *from)
  1159. {
  1160. _fstrcpy(to, from);
  1161. }
  1162.  
  1163. extern double zwidth;
  1164.  
  1165. void clear_zoombox()
  1166. {
  1167.    zwidth = 0;
  1168.    drawbox(0);
  1169.    reset_zoom_corners();
  1170. }
  1171.  
  1172. extern double xxmin, xxmax, xx3rd, yymin, yymax, yy3rd;
  1173. extern double sxmin, sxmax, sx3rd, symin, symax, sy3rd;
  1174.  
  1175. int reset_zoom_corners()
  1176. {
  1177.    xxmin = sxmin;
  1178.    xxmax = sxmax;
  1179.    xx3rd = sx3rd;
  1180.    yymax = symax;
  1181.    yymin = symin;
  1182.    yy3rd = sy3rd;
  1183. }
  1184.  
  1185. // fake videotable stuff
  1186.  
  1187. struct videoinfo far videotable[1];
  1188.  
  1189. void vidmode_keyname(int num, char *string)
  1190. {
  1191.     strcpy(string,"    ");  // fill in a blank videomode name
  1192. }
  1193.  
  1194. int check_vidmode_keyname()
  1195. {
  1196.     return(1);  // yeah, sure - that;s a good videomdoe name.
  1197. }
  1198.  
  1199. int check_vidmode_key()
  1200. {
  1201.     // fill in a videomode structure that looks just like the current image
  1202.     videotable[0].xdots = xdots;
  1203.     videotable[0].ydots = ydots;
  1204.     return 0;  // yeah, sure - that's a good key.
  1205. }
  1206.