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