home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / INFO / TURBO_C / TCTUTOR2.ZIP / VIDEO.C < prev    next >
Encoding:
C/C++ Source or Header  |  1987-07-04  |  11.9 KB  |  355 lines
  1. /*          VIDEO.C    VIDEO.C    VIDEO.C    VIDEO.C    VIDEO.C
  2.  
  3. VIDEO OUTPUT ROUTINES    X   X  XXX  XXXX   XXXXX   XXX
  4.                          X   X   X   X   X  X      X   X
  5. July 1, 1987             X   X   X   X   X  X      X   X
  6.                           X X    X   X   X  XXX    X   X
  7.                           X X    X   X   X  X      X   X
  8.                            X     X   X   X  X      X   X
  9.                            X    XXX  XXXX   XXXXX   XXX
  10. */
  11. #include "stdio.h"               /* The standard header information */
  12. #include "dos.h"                 /* The DOS register definitions    */
  13. #include "string.h"              /* String definitions              */
  14. #include "struct.def"            /* The data structures for VC.C    */
  15. #include "defin.h"
  16.  
  17. char outlist[160];
  18. char strngout[80];
  19. extern struct vars allvars[12];
  20. int bkattr;                      /* background attribute (boxes)    */
  21. int valattr;                     /* values and variables attribute  */
  22. int trnsattr;                    /* transcript attribute            */
  23. int helpattr;                    /* help attribute                  */
  24. int errattr;                     /* error message attribute         */
  25. int vidstart;                    /* start of video memory           */
  26.  
  27. /* ******************************************************** monitor */
  28. /* This function looks at location 0449(hex) in memory to determine */
  29. /* what type of monitor is being used and adjusts the video attri-  */
  30. /* butes accordingly. This allows for flexibility.                  */
  31. void monitor(void)
  32. {
  33. char i[2];
  34. struct SREGS segregs;
  35. unsigned int ds;
  36.  
  37.    segread(&segregs);
  38.    ds = segregs.ds;
  39.    movedata(0,0x449,ds,(int)i,1);/* get monitor mode from 0000:0449 */
  40.    if (i[0] == 7) {                    /* monochrome monitor in use */
  41.       bkattr = 7;
  42.       valattr = 7;
  43.       trnsattr = 7;
  44.       helpattr = 7;
  45.       errattr = 7;
  46.       vidstart = 0XB000;
  47.    }
  48.    else {                                   /* color monitor in use */
  49.       bkattr = 15;                                  /* bright white */
  50.       valattr = 10;                                  /* light green */
  51.       trnsattr = 14;                                      /* yellow */
  52.       helpattr = 10;                                 /* light green */
  53.       errattr = 128 + 12;                     /* blinking light red */
  54.       vidstart = 0XB800;
  55.    }
  56. }
  57.  
  58. /* ******************************************************* bkgndvid */
  59. /* This routine sets up the data for the double lines used through- */
  60. /* out the background. The codes for the double lines come from the */
  61. /* extended ASCII set. they are actually output to the display by   */
  62. /* the routine "linedisp()".                                        */
  63. void bkgndvid(void)
  64. {
  65. int index;
  66.    for (index = 0;index < 160;++index)
  67.       outlist[index] = bkattr;
  68.    for (index = 2;index <= 156;index += 2)
  69.         outlist[index] = 205;
  70.    outlist[0] = 201;
  71.    outlist[44] = 203;
  72.    outlist[110] = 203;
  73.    outlist[158] = 187;
  74.    linedisp(1);                                     /* video line 1 */
  75.    outlist[0] = 204;
  76.    outlist[44] = 202;
  77.    outlist[110] = 202;
  78.    outlist[158] = 185;
  79.    linedisp(8);                                     /* video line 8 */
  80.    outlist[44] = 205;
  81.    outlist[110] = 205;
  82.    linedisp(23);                                   /* video line 23 */
  83.    outlist[0] = 200;
  84.    outlist[158] = 188;
  85.    linedisp(25);                                   /* video line 25 */
  86.    for (index = 2;index <= 156;index += 2)
  87.       outlist[index] = 32;
  88.    outlist[0] = 186;
  89.    outlist[158] = 186;
  90.    linedisp(24);                                   /* video line 24 */
  91.    for (index = 9;index <= 22;++index)
  92.       linedisp(index);                       /* video lines 9 to 22 */
  93.    outlist[44] = 186;
  94.    outlist[110] = 186;
  95.    for (index = 2;index <= 7;++index)
  96.       linedisp(index);                        /* video lines 2 to 7 */
  97. }
  98.  
  99. /* ******************************************************* valusvid */
  100. /* This routine actually outputs the calculated data to the monitor.*/
  101. /* It outputs all values every time it is called, even if only a few*/
  102. /* values are changed. It is therefore somewhat inefficient.        */
  103. void valusvid(void)
  104. {
  105. long int temp;
  106.    sprintf(strngout,"     A = %12.6f",allvars[0].value);
  107.    strngout[21] = 0;
  108.    strngdis(1,1,valattr);
  109.    sprintf(strngout,"     B = %12.6f",allvars[1].value);
  110.    strngout[21] = 0;
  111.    strngdis(2,1,valattr);
  112.    sprintf(strngout,"     C = %12.6f",allvars[2].value);
  113.    strngout[21] = 0;
  114.    strngdis(3,1,valattr);
  115.    sprintf(strngout,"     D = %12.6f",allvars[3].value);
  116.    strngout[21] = 0;
  117.    strngdis(4,1,valattr);
  118.    sprintf(strngout,"     E = %12.6f",allvars[4].value);
  119.    strngout[21] = 0;
  120.    strngdis(5,1,valattr);
  121.    sprintf(strngout,"     F = %12.6f",allvars[5].value);
  122.    strngout[21] = 0;
  123.    strngdis(6,1,valattr);
  124.  
  125.    temp = allvars[6].value;
  126.    temp = temp & 077777777;
  127.    allvars[6].value = temp;
  128.    sprintf(strngout,"I = %8ld = %8lo = %6lx",temp,temp,temp);
  129.    strngdis(1,23,valattr);
  130.    temp = allvars[7].value;
  131.    temp = temp & 077777777;
  132.    allvars[7].value = temp;
  133.    sprintf(strngout,"J = %8ld = %8lo = %6lx",temp,temp,temp);
  134.    strngdis(2,23,valattr);
  135.    temp = allvars[8].value;
  136.    temp = temp & 077777777;
  137.    allvars[8].value = temp;
  138.    sprintf(strngout,"K = %8ld = %8lo = %6lx",temp,temp,temp);
  139.    strngdis(3,23,valattr);
  140.    temp = allvars[9].value;
  141.    temp = temp & 077777777;
  142.    allvars[9].value = temp;
  143.    sprintf(strngout,"L = %8ld = %8lo = %6lx",temp,temp,temp);
  144.    strngdis(4,23,valattr);
  145.    temp = allvars[10].value;
  146.    temp = temp & 077777777;
  147.    allvars[10].value = temp;
  148.    sprintf(strngout,"M = %8ld = %8lo = %6lx",temp,temp,temp);
  149.    strngdis(5,23,valattr);
  150.    temp = allvars[11].value;
  151.    temp = temp & 077777777;
  152.    allvars[11].value = temp;
  153.    sprintf(strngout,"N = %8ld = %8lo = %6lx",temp,temp,temp);
  154.    strngdis(6,23,valattr);
  155.  
  156.    strcpy(strngout,"Function Keys --------");
  157.    strngdis(1,56,helpattr);
  158.    strcpy(strngout,"F1-Help-M   F2-Help-S  ");
  159.    strngdis(2,56,helpattr);
  160.    strcpy(strngout,"F3-Print    F4-Mark    ");
  161.    strngdis(3,56,helpattr);
  162.    strcpy(strngout,"F5-Store    F6-Retrieve");
  163.    strngdis(4,56,helpattr);
  164.    strcpy(strngout,"F7-         F8-        ");
  165.    strngdis(5,56,helpattr);
  166.    strcpy(strngout,"F9-Edit     F10-Quit   ");
  167.    strngdis(6,56,helpattr);
  168. }
  169.  
  170. /* ********************************************************* disnew */
  171. /* This routine displays the changed variable only.                 */
  172. void disnew(int varinuse)
  173. {
  174. long int temp;
  175. double xx;
  176.  
  177.    if (varinuse < 6) {                       /* display A through F */
  178.       xx = allvars[varinuse].value;
  179.       if (xx < 0.0) xx = -xx;
  180.       if ((xx> 9999999.0) || (xx < .001))
  181.          sprintf(strngout,"%12.5e",allvars[varinuse].value);
  182.       else
  183.          sprintf(strngout,"%12.6f",allvars[varinuse].value);
  184.       strngout[12] = 0;
  185.       strngdis(1+varinuse,10,valattr);
  186.    }
  187.    else {                                    /* display I through N */
  188.       temp = allvars[varinuse].value;
  189.       temp = temp & 077777777;
  190.       allvars[varinuse].value = temp;
  191.       sprintf(strngout,"%8ld = %8lo = %6lx",temp,temp,temp);
  192.       strngdis(varinuse-5,27,valattr);
  193.    }
  194. }
  195.  
  196. /* ********************************************************** helpm */
  197. /* This outputs the math helps to the monitor.                      */
  198. void helpm(void)
  199. {
  200. strtrans(" ",0);
  201. strtrans("$                Help - Mathematics",0);
  202. strtrans("$   All calculations are done in floating point, then",0);
  203. strtrans("$  converted to fixed point for variables I to N.",0);
  204. strtrans("$     Available    ABS()   SQRT()  EXP()   LOG()",0);
  205. strtrans("$     Functions    SIN()   COS()   ATAN()  FACT()",0);
  206. strtrans("$   Nesting is allowable to any depth, but the line",0);
  207. strtrans("$  length is limited to 62 characters.",0);
  208. }
  209.  
  210. /* ********************************************************** helps */
  211. /* This outputs the system helps to the monitor.                    */
  212. void helps(void)
  213. {
  214. strtrans(" ",0);
  215. strtrans("$                   Help - System",0);
  216. strtrans("$  Arrow - selected line   ;   Star - marked line",0);
  217. strtrans("$  F3-Toggle print mode to print all input lines",0);
  218. strtrans("$  F4-Toggle the mark indicator on selected line",0);
  219. strtrans("$  F5-Store all marked lines to a file",0);
  220. strtrans("$  F6-Retrieve a file and calculate while inputting",0);
  221. strtrans("$  F9-Load selected line into input window",0);
  222. strtrans("$  up/down-Move selector up/down 1 line",0);
  223. strtrans("$  Pgup/Pgdn-Move selector up/down 8 lines",0);
  224. }
  225.  
  226. /* ******************************************************* linedisp */
  227. /* This outputs a complete line with attributes already in place.   */
  228. void linedisp(int line)
  229. {
  230. struct SREGS segregs;
  231. unsigned int ds;
  232.  
  233.    segread(&segregs);
  234.    ds = segregs.ds;
  235.    movedata(ds,(int)outlist,vidstart,160*(line-1),160);
  236. }
  237.  
  238. /* ******************************************************* strngdis */
  239. /* This outputs a part of a line to the monitor, but first it adds  */
  240. /* the attribute bytes between each of the character bytes.         */
  241. void strngdis(int row,int col,int attr)
  242. {
  243. int i = 0;
  244. int j = 0;
  245. struct SREGS segregs;
  246. unsigned int ds;
  247.  
  248.    segread(&segregs);
  249.    ds = segregs.ds;
  250.  
  251.    while (strngout[i] && j <= 160) {
  252.       outlist[j] = strngout[i];
  253.       outlist[j+1] = attr;
  254.       j += 2;
  255.       i++;
  256.    }
  257.    movedata(ds,(int)outlist,vidstart,160*row + 2*col,j);
  258. }
  259.  
  260. /* ******************************************************* blnkline */
  261. /* This routine outputs blanks from here to column 79.              */
  262. void blnkline(int row,int col)
  263. {
  264. int i,j,number;
  265. struct SREGS segregs;
  266. unsigned int ds;
  267.  
  268.    segread(&segregs);
  269.    ds = segregs.ds;
  270.    number = 78 - col;
  271.    j = 0;
  272.    for (i = 0;i <= number;++i){
  273.       outlist[j] = ' ';
  274.       outlist[j+1] = trnsattr;
  275.       j += 2;
  276.    }
  277.   movedata(ds,(int)outlist,vidstart,160*row + 2*col,2*number);
  278. }
  279.  
  280. /* ******************************************************** chardis */
  281. /* This function outputs one character anywhere on the screen.      */
  282. void chardis(int row,int col,int attr,int ch)
  283. {
  284. struct SREGS segregs;
  285. unsigned int ds;
  286.  
  287.    segread(&segregs);
  288.    ds = segregs.ds;
  289.    outlist[0] = ch;
  290.    outlist[1] = attr;
  291.    movedata(ds,(int)outlist,vidstart,160*row + 2*col,2);
  292. }
  293.  
  294. /* ********************************************************* errdis */
  295. /* This function displays the error message with the blinking       */
  296. /* attribute.                                                       */
  297. void errdis(char str[])
  298. {
  299. int row = 21,col = 50;
  300. int i;
  301. struct SREGS segregs;
  302. unsigned int ds;
  303.  
  304.    segread(&segregs);
  305.    ds = segregs.ds;
  306.    for (i = 0;i <= 24;++i) {
  307.       outlist[2*i] = str[i];
  308.       outlist[2*i+1] = errattr;
  309.    }
  310.    movedata(ds,(int)outlist,vidstart,160*row + 2*col,50);
  311. }
  312.  
  313. /* ******************************************************** clrscrn */
  314. /* This function clears the screen.                                 */
  315. void clrscrn(void)
  316. {
  317. int row,col;
  318.  
  319.    for (row = 0;row < 25;++row)
  320.    for (col = 0;col < 80;++col)
  321.       chardis(row,col,7,' ');
  322. }
  323.  
  324. /* ******************************************************** poscurs */
  325. /* This function positions the cursor anywhere on the screen. It    */
  326. /* calls the DOS function call 10, the video interrupt.             */
  327. void poscurs(int row,int col)
  328. {
  329. union REGS inregs;
  330. union REGS outregs;
  331.  
  332.    inregs.h.ah = 2;
  333.    inregs.h.dh = row;
  334.    inregs.h.dl = col;
  335.    inregs.h.bh = 0;
  336.    int86(0x10,&inregs,&outregs);
  337. }
  338.  
  339. /* ******************************************************* prtprblm */
  340. /* This function checks the printer to see if it is turned on and on*/
  341. /* line. It returns a 1 if a problem, 0 if all is OK.               */
  342. int prtprblm(void)
  343. {
  344. union REGS inregs;
  345. union REGS outregs;
  346.  
  347.    inregs.h.ah = 2;
  348.    inregs.x.dx = 0;
  349.    int86(0x17,&inregs,&outregs);
  350.    if ((outregs.h.ah & 0X80) == 0X80)
  351.       return(0);
  352.    else
  353.       return(1);
  354. }
  355.