home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / Samples / C-ASM_VI.ARJ / PROGC.ZIP / PROGC.C next >
Encoding:
C/C++ Source or Header  |  1988-05-27  |  32.0 KB  |  801 lines
  1. #include <stdio.h>
  2. #include <dos.h>
  3.  
  4. /************************************************************************/
  5. /* This is a main routine which is used to test all the functions       */
  6. /* provided in the examples.  This program allows the operator to       */
  7. /* select the function to be demonstrated and will call the approriate  */
  8. /* sample routine.  To quit select any number outside the range.        */
  9. /************************************************************************/
  10.  
  11. main()
  12.         {
  13.         select_demo();
  14.         }
  15. #include "progc000.c"
  16. #include "progc001.c"
  17. #include "progc002.c"
  18. #include "progc003.c"
  19. #include "progc004.c"
  20. #include "progc005.c"
  21.  
  22. /************************************************************************/
  23. /* Test low level example: Get_Cursor_Address                           */
  24. /************************************************************************/
  25.  
  26. test_GCA()
  27.         {
  28.         printf("\nCursor address = %X hex",get_cursor_address());
  29.         }
  30.  
  31. /************************************************************************/
  32. /* Test BIOS example: BIOS_Palette                                      */
  33. /************************************************************************/
  34.  
  35. test_BP()
  36.         {
  37.         #define MONO    5
  38.         #define VMONO   7
  39.         if (get_display_type() == MONO || get_display_type() == VMONO)
  40.                 set_mode(7);            /* Example uses values for color*/
  41.                                         /* color display, cannot use    */
  42.         else                            /* with mono displays           */
  43.                 BIOS_Palette();
  44.         }
  45.  
  46. #include "progc006.c"
  47.  
  48. /************************************************************************/
  49. /* Time how long it takes to get 32000 retraces                         */
  50. /************************************************************************/
  51.  
  52. wait_4_horiz()
  53.         {
  54.         int i;
  55.         long int count, ticks();
  56.         printf("\n...counting");
  57.         count = ticks();                        /* Get current tick     */
  58.         for (i = 0; i < 32000; i++)
  59.                 horizontal_retrace();           /* Wait for start of    */
  60.                                                 /* next retrace         */
  61.         count = ticks() - count;
  62.         printf("\n32,000 horizontal retraces took %ld ticks",count);
  63.         printf("\nThat is %d Hz horizontal rate",
  64.                 (32000 * (long)91)/(5 * count));
  65.         }
  66.  
  67. #include "progc007.c"
  68. #include "progc009.c"
  69. #include "progc010.c"
  70. #include "progc011.c"
  71. #include "progc012.c"
  72. #include "progc013.c"
  73. #include "progc014.c"
  74.  
  75. /************************************************************************/
  76. /* Test low level exammple: Clear screen using BIOS scroll              */
  77. /************************************************************************/
  78.  
  79. test_BC()
  80.         {
  81.         BIOS_Clear();
  82.         }
  83. #include "progc020.c"
  84.  
  85. /************************************************************************/
  86. /* Fetch current mode using BIOS function F                             */
  87. /************************************************************************/
  88.  
  89. print_BIOS_mode()
  90.         {
  91.                                         /* Print current video mode     */
  92.         printf("\nCurrent video mode is %x hex", BIOS_get_mode());
  93.         }
  94.  
  95. #include "progc021.c"
  96. #include "progc022.c"
  97. #include "progc023.c"
  98. #include "progc024.c"
  99. #include "progc025.c"
  100. #include "progc026.c"
  101. #include "progc027.c"
  102.  
  103. /************************************************************************/
  104. /* Test BIOS example to get type display attached to EGA                */
  105. /************************************************************************/
  106.  
  107. test_BIOS_display()
  108.         {
  109.         static  char    *types[] =
  110.                         {"Unknown", "Unknown", "Unknown", "Enhanced",
  111.                          "Color",   "Monochrome", "Unknown", "Monochrome",
  112.                          "Color"};
  113.         int     index;
  114.         index = BIOS_get_display();             /* Get display type     */
  115.                                                 /* Print the type       */
  116.         if (index < 7)
  117.                 printf("\n%s Display attached to EGA", types[index]);
  118.         else if (index < 9)
  119.                 printf("\n%s Display attached to VGA", types[index]);
  120.         else
  121.                 printf("\EGA/VGA are not installed");
  122.         }
  123.  
  124. #include "progc028.c"
  125. #include "progc029.c"
  126.  
  127. /************************************************************************/
  128. /* Test BIOS call to get memory size                                    */
  129. /************************************************************************/
  130.  
  131. test_BIOS_RAM()
  132.         {
  133.         int     memory;                 /* Declare variables            */
  134.         memory = BIOS_get_mem();        /* Get memory size              */
  135.         printf("\n%dKBytes of Memory Available", memory); /*Print it    */
  136.         }
  137.  
  138. #include "progc030.c"
  139. #include "progc031.c"
  140. #include "progc032.c"
  141.  
  142. #include "progc040.c"
  143.  
  144. /************************************************************************/
  145. /* Test BIOS function example which sets cursor in upper right          */
  146. /************************************************************************/
  147.  
  148. test_BIOS_SCP()
  149.         {
  150.         cls();
  151.         BIOS_set_curs_pos(0,79);        /* Set cursor to upper right    */
  152.         printf("This string starts at upper right");
  153.         }
  154.  
  155. #include "progc041.c"
  156.  
  157. /************************************************************************/
  158. /* Test BIOS function example which gets current cursor position        */
  159. /************************************************************************/
  160.  
  161. test_BIOS_GCP()
  162.         {
  163.         int     pos;
  164.         pos = BIOS_get_cursor_pos(0,79);/* Set cursor to upper right    */
  165.         printf("\nCursor at row=%d col=%d", pos >> 8, pos & 0x00FF);
  166.         }
  167.  
  168. #include "progc042.c"
  169.  
  170. /************************************************************************/
  171. /* Test BIOS function example which sets current cursor size            */
  172. /************************************************************************/
  173.  
  174. test_BIOS_SCS()
  175.         {
  176.         char    far *p = 0;             /* Declare pointer to BIOS area */
  177.         if (p[0x485] > 8)               /* Check char height            */
  178.             BIOS_set_curs_size(10,11);  /* Set cursor size to underline */
  179.         else
  180.             BIOS_set_curs_size( 6, 7);  /* Set cursor size to underline */
  181.         }
  182.  
  183. /************************************************************************/
  184. /* Test BIOS function to get current cursor size                        */
  185. /************************************************************************/
  186.  
  187. test_BIOS_GCS()
  188.         {
  189.         int     size;                           /* Declare variables    */
  190.         size = BIOS_get_curs_size();            /* Get size             */
  191.         printf("\nCursor starts at %d and stops at %d",
  192.                 size >> 8, size & 0x00FF);      /* Print the values     */
  193.         }
  194.  
  195. #include "progc043.c"
  196.  
  197. /************************************************************************/
  198. /* Test BIOS example of text window scroll                              */
  199. /************************************************************************/
  200.  
  201. test_BIOS_ST()
  202.         {
  203.         int     i,j;
  204.         for (i = 0; i < 25; i++)        /* Fill screen with data        */
  205.                 {
  206.                 printf("\n");
  207.                 for (j = 0; j < 40; j++)
  208.                         printf("%1d",i%10);
  209.                 }
  210.         getchar();                      /* Wait for <Enter>             */
  211.         BIOS_Scroll_Text(1,3,12,19, -6);/* Scroll text window down      */
  212.         }
  213.  
  214. #include "progc044.c"
  215.  
  216. /************************************************************************/
  217. /* Test BIOS example of page scroll                                     */
  218. /************************************************************************/
  219.  
  220. test_BIOS_SP()
  221.         {
  222.         int     i;
  223.         for (i = 0; i < 25; i++)        /* Fill screen with data        */
  224.                 printf("\nThis is line %d",i);
  225.         getchar();                      /* Wait for <Enter>             */
  226.         BIOS_Scroll_Page( -6);          /* Scroll text page down by 6   */
  227.         }
  228.  
  229. #include "progc045.c"
  230.  
  231. /************************************************************************/
  232. /* Test BIOS examples of character write                                */
  233. /************************************************************************/
  234.  
  235. test_BIOS_WC()
  236.         {
  237.         BIOS_Char_9();  getchar();
  238.         BIOS_Char_A();  getchar();
  239.         BIOS_Char_E();  getchar();
  240.         BIOS_Char_13();
  241.         }
  242.  
  243. #include "progc046.c"
  244.  
  245. /************************************************************************/
  246. /* Test the BIOS example of inverting character attribute               */
  247. /************************************************************************/
  248.  
  249. test_BIOS_IA()
  250.         {
  251.         int     row, col;               /* Declare local variables      */
  252.         for (row = 0; row < 12; row++)  /* Loop over 12 rows            */
  253.                 for (col = 0; col < 80; col++)  /* Loop over 80 columns */
  254.                         {               /* Set cursor position and      */
  255.                         set_cursor_position(row, col);
  256.                         BIOS_invert();  /* invert attribute             */
  257.                         }
  258.         }
  259.  
  260. #include "progc047.c"
  261.  
  262. /************************************************************************/
  263. /* Test the BIOS example of blink enable/disable                        */
  264. /************************************************************************/
  265.  
  266. test_BIOS_B()
  267.         {
  268.         #define DISABLE         0
  269.         BIOS_blink(DISABLE);
  270.         }
  271.  
  272. #include "progc048.c"
  273.  
  274. /************************************************************************/
  275. /* Test the BIOS example of string write                                */
  276. /************************************************************************/
  277.  
  278. test_BIOS_WS()
  279.         {
  280.         BIOS_write_string();
  281.         }
  282.  
  283. #include "progc049.c"
  284.  
  285. /************************************************************************/
  286. /* Test the BIOS example of get pointer to ROM based character generator*/
  287. /************************************************************************/
  288.  
  289. test_BIOS_GCG()
  290.         {
  291.         int long char_gen, BIOS_get_rom_cg();
  292.         char_gen = BIOS_get_rom_cg();
  293.         printf("\nCharacter generator pointer = %lx", char_gen);
  294.         }
  295.  
  296. #include "progc050.c"
  297.  
  298. /************************************************************************/
  299. /* Test the BIOS example of overwrite first 32 characters with a box    */
  300. /************************************************************************/
  301.  
  302. test_BIOS_WCG()
  303.         {
  304.         int     i;
  305.         for (i = 0; i < 64; i++) write_char(i, 24, i);
  306.         BIOS_Write_CG();
  307.         }
  308.  
  309. #include "progc051.c"
  310.  
  311. /************************************************************************/
  312. /* Test the BIOS example of downloading two character generators        */
  313. /************************************************************************/
  314.  
  315. test_BIOS_512()
  316.         {
  317.         static  char    seta[256][32];  /* Buffer for char gen          */
  318.         static  char    setb[256][32];  /* Buffer for char gen          */
  319.         int     i, j;
  320.  
  321.         /*--- Read the first set and 'italicize' it into second         */
  322.  
  323.         read_char_gen(seta);            /* Read old character generator */
  324.         read_char_gen(setb);            /* Read old character generator */
  325.         for (i = 0; i < 255; i++)       /* Create a new char set        */
  326.                 for (j = 0; j < 4; j++) /* from the old by 'italisizing'*/
  327.                         {
  328.                         setb[i][j]    = setb[i][j] >> 1;
  329.                         setb[i][j+10] = setb[i][j+10] << 1;
  330.                         }
  331.  
  332.         /* Download the two character generators using BIOS funciton    */
  333.  
  334.         BIOS_512_Set(seta, setb);
  335.         }
  336.  
  337. #include "progc052.c"
  338.  
  339. #include "progc053.c"
  340.  
  341. /************************************************************************/
  342. /* Test BIOS example for setting 43 lines                               */
  343. /************************************************************************/
  344.  
  345. test_BIOS_43()
  346.         {
  347.         int     i, mode;
  348.         mode = get_mode();                      /* Get current mode     */
  349.         BIOS_43_lines();                        /* Set 43 text mode     */
  350.         for (i = 0; i < 43; i++)                /* Fill screen with text*/
  351.                 printf("\nThis is line %d in 43 line text mode",i);
  352.         getchar();                              /* Wait for <Enter> key */
  353.         set_mode(mode);                         /* Restore all by       */
  354.         }                                       /* setting mode         */
  355.  
  356. #include "progc054.c"
  357.  
  358. #include "progc055.c"
  359.  
  360. #include "progc056.c"
  361.  
  362. /************************************************************************/
  363. /* Test BIOS example of reading characters                              */
  364. /************************************************************************/
  365.  
  366. test_BIOS_RC()
  367.         {
  368.         printf("\Character read using BIOS is: %2x(hex)",
  369.                 BIOS_read_char(24, 0));
  370.         }
  371.  
  372. #include "progc057.c"
  373.  
  374. /************************************************************************/
  375. /* Test BIOS example of reading attributes                              */
  376. /************************************************************************/
  377.  
  378. test_BIOS_RA()
  379.         {
  380.         printf("\Attribute read using BIOS is: %2x(hex)",
  381.                 BIOS_read_attr(24, 0));
  382.         }
  383.  
  384. /************************************************************************/
  385. /* Routine to use to setup a graphics mode and call demo routine        */
  386. /************************************************************************/
  387.  
  388. /************************************************************************/
  389. /* Routine to use to setup a graphics mode and call demo routine        */
  390. /************************************************************************/
  391.  
  392. do_demo_routine()
  393.         {
  394.         #define MONO            5
  395.         #define VMONO           7
  396.         #define COLOR           4
  397.         #define ENHANCED        3
  398.         #define VCOLOR          8
  399.         int     type;
  400.  
  401.         /* Get display type and select mode accordingly                 */
  402.  
  403.         type = get_display_type();              /* Get display type     */
  404.         switch (type)                           /* Set mode according to*/
  405.                 {                               /* type of display      */
  406.                 case VMONO:
  407.                 case MONO:
  408.                         set_mode(0x0F);
  409.                         break;
  410.                 case COLOR:
  411.                         set_mode(0x0E);
  412.                         break;
  413.                 case VCOLOR:
  414.                 case ENHANCED:
  415.                         set_mode(0x10);
  416.                         break;
  417.                 }
  418.  
  419.         /* Call procedure to perform the example                                */
  420.  
  421.         demo_routine();                         /* Draw the example     */
  422.         getchar();                              /* Wait for <Enter>     */
  423.  
  424.         /* Restore the original mode                                                    */
  425.  
  426.         if (type == MONO)       setmode(7);     /* Restore text mode    */
  427.         else                    setmode(3);
  428.         exit(0);                                /* Quit                 */
  429.         }
  430.  
  431. demo_routine()
  432.         {
  433.         /* This is where we would call our test routine                 */
  434.         }
  435.  
  436. /************************************************************************/
  437. /* Test BIOS example of pixel write                                     */
  438. /************************************************************************/
  439.  
  440. test_BIOS_PW()
  441.         {
  442.         cls();
  443.         BIOS_Pixel_Write();
  444.         }
  445.  
  446. #include "progc080.c"
  447. #include "progc081.c"
  448.  
  449. /************************************************************************/
  450. /* Test BIOS example of pixel read                                      */
  451. /************************************************************************/
  452.  
  453. test_BIOS_PR()
  454.         {
  455.         int     x, y;
  456.         for (x = 0, y = 19; x < 10; x++)
  457.                printf(" %2d", BIOS_Pixel_Read(x,y));
  458.         }
  459.  
  460. #include "progc082.c"
  461. #include "progc083.c"
  462. #include "progc084.c"
  463. #include "progc085.c"
  464.  
  465. /************************************************************************/
  466. /* Test slow line demo routine                                          */
  467. /************************************************************************/
  468.  
  469. slow_radial_lines()
  470.         {
  471.         int     i;
  472.         cls();
  473.         for (i = 0; i < 640; i += 20) slow_line(320,100,i,  0,i/20);
  474.         for (i = 0; i < 640; i += 20) slow_line(320,100,i,199,i/20);
  475.         for (i = 0; i < 200; i += 10) slow_line(320,100,0,  i,i/10);
  476.         for (i = 0; i < 200; i += 10) slow_line(320,100,639,i,i/10);
  477.         }
  478.  
  479. /************************************************************************/
  480. /* Draw a moving line in each quadrant of the screen.  Each of the      */
  481. /* four lines has a different color and the endpoints of the line will  */
  482. /* 'bounce' of the edges of the corresponding quadrant.                 */
  483. /************************************************************************/
  484.  
  485. #define M    100
  486. #define N    10
  487. #define MAXX 319
  488. #define MAXY 174                /* Change this to 100 for Color Monitor */
  489.  
  490. lines_demo()
  491.         {
  492.         int   i, j, k, p[4], d[4], c1 = 8,c2 = 9,c3 =10,c4 =11;
  493.         int   l, n;
  494.         long  x0,y0,x1,y1,ticks();
  495.         if (kbhit()) return;
  496.  
  497.         cls();                  /* Clear screen                         */
  498.  
  499.         /****************************************************************/
  500.         /* start a next set of four lines, picking semirandom starting  */
  501.         /* point at p and moving with speed d.                          */
  502.         /****************************************************************/
  503.  
  504.         while(!kbhit())
  505.           {
  506.           x0=ticks(); x1=ticks()*33; y0=ticks()*23; y1=ticks()*7;
  507.           p[0] = (x0 * 320) & 255;         /*initial points of the line*/
  508.           p[1] = (y0 * 175) & 127;
  509.           p[2] = p[0] + 15 + (p[0] & 7);
  510.           p[3] = p[1] + 15 + (p[0] & 7);
  511.           d[0] = 5 + x0 & 7;               /*initial motion vector */
  512.           d[1] = 7 + x1 & 7;
  513.           d[2] = 5 + y0 & 7;
  514.           d[3] = 7 + y1 & 7;
  515.           cls();
  516.  
  517.           /* pick four semirandom colors */
  518.  
  519.           if (get_display_type() == MONO || get_display_type() == VMONO)
  520.                 c1 = c2 = c3 = c4 = 15;
  521.           else
  522.                 {
  523.                 c1 = (++c1) & 15;
  524.                 if (c1 == 13) c1 = 8;
  525.                 c2 = c1 + 1; c3 = c1 + 2; c4 = c1 + 3;
  526.                 }
  527.  
  528.         /****************************************************************/
  529.         /* draw the line (and the three mirror images) and then compute */
  530.         /* new position                                                 */
  531.         /****************************************************************/
  532.  
  533.           for (n = 0; n < M && !kbhit(); n++)
  534.              {
  535.              i = p[0]; j = p[1]; k = p[2]; l = p[3];
  536.              line(i,j,k,l,c1);
  537.  
  538.              i = 639 - i; k = 639 - k;
  539.              line(i,j,k,l,c2);
  540.  
  541.              j = 349 - j; l = 349 - l;
  542.              line(i,j,k,l,c3);
  543.  
  544.              i = 639 - i; k = 639 - k;
  545.              line(i,j,k,l,c4);
  546.  
  547.              /* update position of the line */
  548.  
  549.              move(p, d);
  550.              }
  551.           for (x0 = ticks(); ticks() - x0 < 18;);       /*Take a rest*/
  552.           }
  553.         return;
  554.         }
  555.  
  556. move(p, d)
  557. int  p[4], d[4];
  558.         {
  559.         /****************************************************************/
  560.         /* update two end points of a line (four coordinates) with the  */
  561.         /* values specified in d.  Should the resulting points fall     */
  562.         /* outside the bounds, 'bounce' them of the sides.              */
  563.         /****************************************************************/
  564.  
  565.         int i;
  566.         /*reverse motion if lines fall outside the bounds */
  567.         if ((p[0] + d[0]) <    0) d[0] = -d[0];
  568.         if ((p[0] + d[0]) > MAXX) d[0] = -d[0];
  569.         if ((p[1] + d[1]) <    0) d[1] = -d[1];
  570.         if ((p[1] + d[1]) > MAXY) d[1] = -d[1];
  571.         if ((p[2] + d[2]) <    0) d[2] = -d[2];
  572.         if ((p[2] + d[2]) > MAXX) d[2] = -d[2];
  573.         if ((p[3] + d[3]) <    0) d[3] = -d[3];
  574.         if ((p[3] + d[3]) > MAXY) d[3] = -d[3];
  575.         /*compute next endpoints of the line */
  576.         for (i = 0; i < 4; i ++)
  577.            p[i] = p[i] + d[i];
  578.         }
  579.  
  580. #include "progc086.c"
  581.  
  582. /************************************************************************/
  583. /* Test slow pattern line routine                                       */
  584. /************************************************************************/
  585.  
  586. slow_pattern_radials()
  587.         {
  588.         int     i;
  589.         cls();
  590.         for(i= 0; i < 640; i += 20)slow_pattern_line(320,100,i,  0,i/20,0x0F0F);
  591.         for(i= 0; i < 640; i += 20)slow_pattern_line(320,100,i,199,i/20,0x0F0F);
  592.         for(i= 0; i < 200; i += 10)slow_pattern_line(320,100,0,  i,i/20,0x0F0F);
  593.         for(i= 0; i < 200; i += 10)slow_pattern_line(320,100,639,i,i/20,0x0F0F);
  594.         }
  595.  
  596.  
  597. #include "progc087.c"
  598. #include "progc088.c"
  599. #include "progc089.c"
  600. #include "progc090.c"
  601. #include "progc095.c"
  602.  
  603. /************************************************************************/
  604. /* Test the demo routine 'slow_bitblt'                                  */
  605. /* Copy a 100x100 block from upper left corner of the screen            */
  606. /* and move it successively 10 times, two pixels at a time              */
  607. /************************************************************************/
  608.  
  609. test_slow_bitblt()
  610.         {
  611.         #define COPY    0
  612.         int     i;
  613.         for (i = 0; i < 10; i += 2)     /* Copy next block              */
  614.                 slow_bitblt(0, 0, 320 + i, 100 + i, 100, 100, COPY);
  615.         }
  616.  
  617. #include "progc091.c"
  618. #include "progc092.c"
  619. #include "progc093.c"
  620. #include "progc094.c"
  621.  
  622. /************************************************************************/
  623. /* This is a main routine which is used to test all the functions       */
  624. /* provided in the examples.  This program allows the operator to       */
  625. /* select the function to be demonstrated and will call the approriate  */
  626. /* sample routine.  To quit select any number outside the displayed     */
  627. /* range                                                                */
  628. /************************************************************************/
  629.  
  630. select_demo()
  631.         {
  632.         int     select, i, j;
  633.         char    buffer[10];
  634.         typedef int (*FnPtr)();
  635.         struct Demo_Table
  636.                 {
  637.                 char    *prompt;
  638.                 FnPtr   proc;
  639.                 };
  640.  
  641.         #define MAX_PROC        83
  642.         static struct Demo_Table       demo_table[MAX_PROC] = {
  643.                 "Write_Reg (cursor start to 1)",        write_curs_start,
  644.                 "Write_Reg_Set (load mode 0, 3 or 7)",  select_mode_x,
  645.                 "Read Reg (cursor address)",            read_cursor_address,
  646.                 "Read Reg (feature bits)",              read_feature,
  647.                 "Read Reg (switches)",                  read_switches,
  648.                 "Read Reg (low level cursor addr)",     test_GCA,
  649.                 "Write Palette (invert B & W)",         invert_B_n_W,
  650.                 "Write Palette (BIOS call)",            test_BP,
  651.                 "Vert Retrace (count)",                 wait_4_vert,
  652.                 "Horiz Retrace (count)",                wait_4_horiz,
  653.  
  654.                 "Smooth horiz (use cursor keys & ESC)", smooth_horizontal,
  655.                 "Smooth vert (use cursor keys & ESC)",  smooth_vertical,
  656.                 "Clear Screen (fill memory)",           cls,
  657.                 "Clear Screen (use BIOS call)",         test_BC,
  658.                 "Video BIOS (print string)",            test_video_BIOS,
  659.                 "Set Mode (lib)",                       test_set_mode,
  660.                 "Get Cursor Position (test BIOS)",      test_BIOS_GCP,
  661.                 "Get Mode (from library fn)",           print_mode,
  662.                 "Get Mode (from BIOS)",                 print_BIOS_mode,
  663.  
  664.                 "Get Mode (from BIOS data area)",       print_data_mode,
  665.                 "Get Rows & Cols (library fn)",         print_rows_cols,
  666.                 "Get Rows & Cols (from BIOS data area)",print_data_rc,
  667.                 "Get Page Size (library fn)",           print_page_size,
  668.                 "Get Page Size (from BIOS data area)",  print_data_page_size,
  669.                 "Get Display Type (library fn)",        print_display_type,
  670.                 "Get Display Type (BIOS help)",         test_BIOS_display,
  671.                 "Get Scanlines (lib)",                  print_scanlines,
  672.                 "Get Memory Size (library fn)",         print_memory_size,
  673.                 "Get Memory Size (BIOS call)",          test_BIOS_RAM,
  674.  
  675.                 "Get Primary (library fn)",             print_primary,
  676.                 "Get Primary (from BIOS data area)",    print_data_primary,
  677.                 "Get Second (library fn)",              print_if_second,
  678.                 "Set Curs Pos (library fn)",            cursor_in_middle,
  679.                 "Set Curs Pos (test BIOS example)",     test_BIOS_SCP,
  680.                 "Set Curs Size (library fn)",           demo_cursor_size,
  681.                 "Set Curs Size (test BIOS example)",    test_BIOS_SCS,
  682.                 "Get Curs Size (library fn)",           print_cursor_size,
  683.                 "Get Curs Size (test BIOS fn)",         test_BIOS_GCS,
  684.                 "Scroll text (scroll window using lib)",sample_scroll_text,
  685.  
  686.                 "Scroll text (scroll window using BIOS)",test_BIOS_ST,
  687.                 "Scroll page (scroll lines using lib)", sample_scroll_page,
  688.                 "Scroll page (scroll lines using BIOS)",test_BIOS_SP,
  689.                 "Write char (library fn)",              write_one_char,
  690.                 "Write char (test four BIOS calls)",    test_BIOS_WC,
  691.                 "Write attrib (library fn)",            make_reverse,
  692.                 "Write attrib (use BIOS to invert)",    test_BIOS_IA,
  693.                 "Read char (library fn)",               print_10_chars,
  694.                 "Read char (test BIOS call)",           test_BIOS_RC,
  695.                 "Read attrib (library fn)",             print_10_attr,
  696.  
  697.                 "Read attrib (test BIOS call)",         test_BIOS_RA,
  698.                 "Text Blink (library fn)",              demo_text_blink,
  699.                 "Text Blink (BIOS fn)",                 test_BIOS_B,
  700.                 "Write String (library fn)",            print_hello,
  701.                 "Write String (BIOS example)",          test_BIOS_WS,
  702.                 "Read Char Gen (library fn)",           italicize,
  703.                 "Read Char Gen (test BIOS example)",    test_BIOS_GCG,
  704.                 "Write Char Gen (library fn)",          replace_a,
  705.                 "Write Char Gen (test BIOS example)",   test_BIOS_WCG,
  706.                 "512 Set (library fn)",                 print_512_chars,
  707.  
  708.                 "512 Set (test BIOS example)",          test_BIOS_512,
  709.                 "Split Screen (use cursor keys)",       demo_split_screen,
  710.                 "Set 43 Lines (library function)",      demo_43_lines,
  711.                 "Set 43 Lines (test BIOS example)",     test_BIOS_43,
  712.                 "Drawing text boxes",                   boxed_hello,
  713.                 "Smooth text scroll",                   smooth_text_scroll,
  714.                 "Pixel Write (16 boxes using lib)",     pixel_box16,
  715.                 "Pixel Write (BIOS box)",               test_BIOS_PW,
  716.                 "Pixel Read (10 values using lib)",     read_10_pixels,
  717.                 "Pixel Read (10 values using BIOS)",    test_BIOS_PR,
  718.  
  719.                 "Scanline (lib draw triangle)",         fill_triag,
  720.                 "Solid box (lib 16 boxes)",             solid_box16,
  721.                 "Line (lib radial lines)",              radial_lines,
  722.                 "Line (lib lines demo)",                lines_demo,
  723.                 "Slow line (slow radial lines)",        slow_radial_lines,
  724.                 "Patterned line (slow radials)",        slow_pattern_radials,
  725.                 "Patterned line (slow triangle)",       pattern_triag,
  726.                 "Patterned line (slow checkers)",       checkers,
  727.                 "Arc",                                  arc_demo,
  728.                 "BITBLT (lib slide down_right)",        slide_block,
  729.  
  730.                 "BITBLT (test slow slide)",             test_slow_bitblt,
  731.                 "Graphics Cursor (use arrow keys)",     demo_cursor,
  732.                 "Screen Dump (save into PICTURE.xxx)",  save_screen,
  733.                 "Screen Load (lib load PICTURE.xxx)",   restore_screen
  734.                 };
  735.  
  736.         /****************************************************************/
  737.         /* Here we print all prompts and user selects which routine     */
  738.         /* to do next.  0 to do all,  out of range to quit              */
  739.         /****************************************************************/
  740.  
  741.         select = 0;
  742.         while(1)
  743.                 {
  744.                 if (select == -1)
  745.                     for (j = 0; j <= MAX_PROC; j += 22)
  746.                         {
  747.                         for (i = 0; i < 22 && i + j < MAX_PROC; i++)
  748.                                 printf("\n%3d: %s",i+j+1,demo_table[i+j].prompt);
  749.                         if (j < MAX_PROC - 22) getchar();
  750.                         }
  751.                 printf("\nEnter test (0 = all, -1 = list, 99 = quit): ");
  752.                 gets(buffer);
  753.                 sscanf(buffer,"%d",&select);
  754.  
  755.                 /********************************************************/
  756.                 /* User wants to quit so oblige                         */
  757.                 /********************************************************/
  758.  
  759.                 if (select > MAX_PROC || select < -1)
  760.                         exit(0);
  761.  
  762.                 /********************************************************/
  763.                 /* A single function has been selected so wait for      */
  764.                 /* Enter key, call the sample procedure, wait for Enter */
  765.                 /* agin (so user can marvel at the display).            */
  766.                 /********************************************************/
  767.  
  768.                 else if (select > 0)
  769.                         {
  770.                         set_cursor_position(24,0);
  771.                         printf("\nPress <Enter> to '%d: %s'",
  772.                               select, demo_table[select-1].prompt);
  773.                         getchar();
  774.                         (*(demo_table[select-1].proc))();
  775.                         getchar();
  776.                         select++;
  777.                         }
  778.  
  779.                 /********************************************************/
  780.                 /* Loop throgh all the samples one a time and wait for  */
  781.                 /* Enter key to be pressed at the start of each sample  */
  782.                 /* and after each sample is done.                       */
  783.                 /********************************************************/
  784.  
  785.                 else if (select == 0)
  786.                         for (i = 0; i < MAX_PROC; i++)
  787.                                 {
  788.                                 set_cursor_position(24,0);
  789.                                 printf("\nPress <Enter> to '%d: %s'",
  790.                                       i+1,demo_table[i].prompt);
  791.                                 getchar();
  792.                                 (*(demo_table[i].proc))();
  793.                                 getchar();
  794.                                 }
  795.                 else
  796.                         {
  797.                         }
  798.                 }
  799.  
  800.         }
  801.