home *** CD-ROM | disk | FTP | other *** search
/ ProfitPress Mega CDROM2 …eeware (MSDOS)(1992)(Eng) / ProfitPress-MegaCDROM2.B6I / MISC / NETWORK / TEL23SRC.ZIP / RG / RG9.C < prev    next >
Encoding:
C/C++ Source or Header  |  1991-06-25  |  6.5 KB  |  338 lines
  1. /*
  2. *
  3. *  rg9.c by Aaron Contorer for NCSA
  4. *
  5. *  graphics routines for drawing on Number Nine card
  6. *  Input coordinate space = 0..4095 by 0..4095
  7. *  MUST BE COMPILED WITH LARGE MEMORY MODEL!
  8. * 
  9. *  RG9 = routines callable from outside
  10. *  NO9 = routines for internal use only
  11. *
  12. */
  13.  
  14. #include <stdio.h>    /* used for debugging only */
  15. #include <stdlib.h>
  16. #include <dos.h>    /* used for NO9 init call */
  17. #if defined(MSC) && !defined(__TURBOC__)
  18. #include <memory.h>
  19. #endif
  20. #ifdef MEMORY_DEBUG
  21. #include "memdebug.h"
  22. #endif
  23. #include "externs.h"
  24.  
  25. #define TRUE 1
  26. #define FALSE 0
  27. #define INXMAX 4096
  28. #define INXSHIFT 12
  29. #define INYMAX 4096
  30. #define INYSHIFT 12
  31. #define MAGNIFY 1000
  32. #define SCRNXHI 511
  33. #define SCRNYHI 479
  34. #define MAXWIN 32        /* max. number of windows */
  35. #define NO9xmax 512     /* max. number of pixels in the x direction */
  36. #define NO9ymax 480        /* max. number of pixels in the y direction */
  37.  
  38. static int NO9active;        /* number of currently NO9active window */
  39. static char *NO9ram;
  40. static int *NO9bank;         /* bank control registers */
  41. static unsigned char power2[8]={1,2,4,8,16,32,64,128};
  42. static char *NO9name="Number Nine, 512 x 480";
  43. static void clrbuf(unsigned int bank);
  44.  
  45. /* Current status of an NO9 window */
  46. struct NO9WIN 
  47. {
  48.     char inuse;                             /* true if window in use */
  49.     int pencolor, rotation, size;
  50.     int winbot,winleft,wintall,winwide;        /* position of the window in virtual space */
  51. };
  52.  
  53. static struct NO9WIN NO9win[MAXWIN];
  54.  
  55. void NO9setup()            /* prepare variables for use in other functions */
  56. {
  57. #if defined(MSC) && !defined(__TURBOC__)
  58.     FP_SEG(NO9ram) = 0xA000;  FP_OFF(NO9ram) = 0;
  59.     FP_SEG(NO9bank) = 0xC070;  FP_OFF(NO9bank) = 5;
  60. #else
  61.     NO9ram=(char *)0xA0000;
  62.     NO9bank=(int *)0xC0705;
  63. #endif
  64. }
  65.  
  66. static void clrbuf(bank)
  67. unsigned int bank;
  68. {
  69.     *NO9bank=bank;
  70.     memset(NO9ram,0,0xFFFF);
  71.     NO9ram[0xFFFF]=0;
  72. }
  73.  
  74. void RG9gmode()            /* go into NO9 graphics mode -- not yet implemented */
  75. {
  76.     clrbuf(0x0000);
  77.     clrbuf(0x00ff);
  78.     clrbuf(0xff00);
  79.     clrbuf(0xffff);
  80. }
  81.  
  82. void RG9tmode()            /* go into NO9 text mode -- not supported */
  83. { }
  84.  
  85. void RG9drawline(w,x0,y0,x1,y1)
  86. int w,x0,y0,x1,y1;        /* draw a line from (x0,y0) to (x1,y1) */
  87.                         /* uses Bresenham's Line Algorithm */
  88. {
  89.     int x,y,dx,dy,d,temp,
  90.     dx2,dy2,            /* 2dx and 2dy */
  91.     direction;        /* +1 or -1, used for slope */
  92.     char transpose;    /* true if switching x and y for vertical-ish line */
  93.  
  94.     if(w!=NO9active) 
  95.         return;
  96.     x0=(int)(((long)x0*NO9xmax)>>INXSHIFT);
  97.     y0=NO9ymax-1-(int)(((long)y0*NO9ymax)>>INYSHIFT);
  98.     x1=(int)(((long)x1*NO9xmax)>>INXSHIFT);
  99.     y1=NO9ymax-1-(int)(((long)y1*NO9ymax)>>INYSHIFT);
  100.     if(abs(y1-y0)>abs(x1-x0)) {                /* transpose vertical-ish to horizontal-ish */
  101.         temp=x1;
  102.         x1=y1; 
  103.         y1=temp;
  104.         temp=x0; 
  105.         x0=y0;     
  106.         y0=temp;
  107.         transpose=TRUE;
  108.       } 
  109.     else 
  110.         transpose=FALSE;                
  111.     if(x1<x0){                        /* make sure line is left to right */
  112.         temp=x1; 
  113.         x1=x0; 
  114.         x0=temp; 
  115.         temp=y1; 
  116.         y1=y0; 
  117.         y0=temp;
  118.       }        
  119. /* SPECIAL CASE: 1 POINT */
  120.     if(x1==x0&&y1==y0) { 
  121.         NO9point(x1,y1);
  122.         return;
  123.       }        
  124. /* ANY LINE > 1 POINT */
  125.     x=x0;
  126.     y=y0;
  127.     dx=x1-x0;
  128.     if(y1>=y0) {
  129.         dy=y1-y0;
  130.         direction=1;
  131.       } 
  132.     else {
  133.         dy=y0-y1;
  134.         direction=-1;
  135.       }
  136.     dx2=dx<<1;
  137.     dy2=dy<<1;
  138.     d=(dy<<1)-dx;
  139.     if(transpose) {        /* CASE OF VERTICALISH (TRANSPOSED) LINES */
  140.         while(x<=x1) {
  141.             if(y>=0&&y<NO9xmax&&x>=0&&x<NO9ymax)
  142.                 NO9point(y,x);
  143.             while(d>=0) {
  144.                 y+=direction;
  145.                 d-=dx2;
  146.               }
  147.             d+=dy2;
  148.             x++;
  149.           } 
  150.       } 
  151.     else {            /* CASE OF HORIZONTALISH LINES */
  152.         while(x<=x1) {
  153.             if(x>=0&&x<NO9xmax&&y>=0&&y<NO9ymax)
  154.                 NO9point(x,y);
  155.             while(d>=0) {
  156.                 y+=direction;
  157.                 d-=dx2;
  158.               }
  159.             d+=dy2;
  160.             x++;
  161.           }
  162.       }                 /* end horizontalish */
  163. }                     /* end NO9rasline() */
  164.  
  165. void RG9clrscr(w)
  166. int w;
  167. /* 
  168.     Clear the screen.
  169. */
  170. {
  171.     if(w==NO9active) {
  172.         NO9setup();
  173.         RG9gmode();
  174.       }
  175. }
  176.  
  177. int RG9newwin()
  178. /* 
  179.     Set up a new window; return its number.
  180.     Returns -1 if cannot create window.
  181. */
  182. {
  183.     int w=0;
  184.  
  185.     while(w<MAXWIN && NO9win[w].inuse) 
  186.         w++;
  187.     if(w==MAXWIN) 
  188.         return(-1);             /* no windows available */
  189.     NO9win[w].pencolor=7;
  190.     NO9win[w].winbot=0;
  191.     NO9win[w].wintall=3120;
  192.     NO9win[w].winleft=0;
  193.     NO9win[w].winwide=4096;
  194.     NO9win[w].inuse=TRUE;
  195.     return(w);
  196. }
  197.  
  198. void RG9close(w)
  199. int w;
  200. {
  201.     if(NO9active==w) {
  202.         RG9clrscr(w);
  203.         NO9active=-1;
  204.       }
  205.     NO9win[w].inuse=FALSE;
  206. }
  207.  
  208. void NO9point(x,y)
  209. int x,y;
  210. /*
  211.     set point at real pixel x,y
  212. */
  213. {
  214.     unsigned int bank,loc;
  215.  
  216.     y+=16;                     /* map 480 lines onto 512 lines */
  217.     if(y&256) 
  218.         bank=0xff00;
  219.     else
  220.          bank=0;
  221.     if(y&128)
  222.         bank|=0x00ff;
  223.     *NO9bank=bank;        
  224.     loc=((y&0x7f)<<9)+x;
  225.     NO9ram[loc]=255;         /* only drawing in color 255 */
  226. }
  227.  
  228. void RG9point(w,x,y)
  229. int w,x,y;
  230. /* set pixel at location (x,y) -- no range checking performed */
  231. {
  232.     int x2,y2;                 /* on-screen coordinates */
  233.  
  234.     if(w==NO9active) {
  235.         x2=(int)(((long)x*NO9xmax)>>INXSHIFT);
  236.         y2=SCRNYHI-(int)(((long)y*NO9ymax)>>INYSHIFT);
  237.         NO9point(x2,y2);
  238.       }
  239. }  
  240.  
  241. void RG9pagedone(w)
  242. int w;
  243. /*
  244.     Do whatever has to be done when the drawing is all done.
  245.     (For printers, that means eject page.)
  246. */
  247. {
  248.     /* do nothing for NO9 */
  249.     w=w;
  250. }
  251.  
  252. void RG9dataline(w,data,count)
  253. int w,count;
  254. char *data;
  255. /*
  256.     Copy 'count' bytes of data to screen starting at current
  257.     cursor location.
  258. */
  259. {
  260.     /* Function not supported yet. */
  261.     w=w;
  262.     data=data;
  263.     count=count;
  264. }
  265.  
  266. void RG9pencolor(w,color)
  267. int w,color;
  268. /*
  269.     Change pen color to the specified color.
  270. */
  271. {
  272.     /* Function not supported yet. */
  273.     w=w;
  274.     color=color;
  275. }
  276.  
  277. void RG9charmode(int w,int rotation,int size)
  278. /*
  279.     Set description of future device-supported graphtext.
  280.     Rotation=quadrant.
  281. */
  282. {
  283.     /* No rotatable device-supported graphtext is available on NO9. */
  284.     w=w;
  285.     rotation=rotation;
  286.     size=size;
  287. }
  288.  
  289.  
  290. /* Not yet supported: */
  291. void RG9showcur() {}
  292. void RG9lockcur() {}
  293. void RG9hidecur() {}
  294.  
  295. void RG9bell(w)
  296. int w;        /* Ring bell in window w */
  297. {
  298.     if(w==NO9active) 
  299.         putchar(7);
  300. }
  301.  
  302. char *RG9devname()        /* return name of device that this RG supports */
  303. {
  304.     return(NO9name);
  305. }
  306.  
  307. void RG9init()                /* initialize all RG9 variables */
  308. {
  309.     int i;
  310.     NO9setup();
  311.     for(i=0; i<MAXWIN; i++) {
  312.         NO9win[i].inuse=FALSE;
  313.       }
  314.     NO9active=-1;
  315. }
  316.  
  317. void RG9uncover(w)
  318. int w;
  319. /*
  320.     Make this window visible, hiding all others.
  321.     Caller should follow this with clrscr and redraw to show the current
  322.     contents of the window.
  323. */
  324. {
  325.     NO9active=w;
  326. }
  327.  
  328. void RG9info(int w,int a,int b,int c,int d,int v) {
  329. /* Needed for possible future functionality */
  330.  
  331.     w=w;
  332.     a=a;
  333.     b=b;
  334.     c=c;
  335.     d=d;
  336.     v=v;
  337.     }
  338.