home *** CD-ROM | disk | FTP | other *** search
/ Vectronix 2 / VECTRONIX2.iso / FILES_01 / PC_V11_B.LZH / DEMO_PC / BGIDEMO.C next >
Text File  |  1993-07-03  |  40KB  |  1,407 lines
  1. /*
  2.    GRAPHICS DEMO FOR TURBO C 2.0
  3.  
  4.    Copyright (c) 1987,88,90 Borland International. All rights reserved.
  5.  
  6.    From the command line, use:
  7.  
  8.         tcc bgidemo graphics.lib
  9.  
  10. */
  11.  
  12. #ifdef __TINY__
  13. #error BGIDEMO will not run in the tiny model.
  14. #endif
  15.  
  16. #ifdef __TOS__
  17. #include <ext.h>
  18. #else
  19. #include <dos.h>
  20. #include <conio.h>
  21. #endif
  22.  
  23. #include <math.h>
  24. #include <stdio.h>
  25. #include <stdlib.h>
  26. #include <stdarg.h>
  27.  
  28. #include <graphics.h>
  29.  
  30. #define ESC    0x1b            /* Define the escape key    */
  31. #define TRUE    1            /* Define some handy constants    */
  32. #define FALSE    0            /* Define some handy constants    */
  33. #define PI    3.14159         /* Define a value for PI    */
  34. #define ON    1            /* Define some handy constants    */
  35. #define OFF    0            /* Define some handy constants    */
  36.  
  37. char *Fonts[] = {
  38.   "DefaultFont",   "TriplexFont",   "SmallFont",
  39.   "SansSerifFont", "GothicFont"
  40. };
  41.  
  42. char *LineStyles[] = {
  43.   "SolidLn",  "DottedLn",  "CenterLn",  "DashedLn",  "UserBitLn"
  44. };
  45.  
  46. char *FillStyles[] = {
  47.   "EmptyFill",  "SolidFill",      "LineFill",      "LtSlashFill",
  48.   "SlashFill",  "BkSlashFill",    "LtBkSlashFill", "HatchFill",
  49.   "XHatchFill", "InterleaveFill", "WideDotFill",   "CloseDotFill"
  50. };
  51.  
  52. char *TextDirect[] = {
  53.   "HorizDir",  "VertDir"
  54. };
  55.  
  56. char *HorizJust[] = {
  57.   "LeftText",   "CenterText",   "RightText"
  58. };
  59.  
  60. char *VertJust[] = {
  61.   "BottomText",  "CenterText",  "TopText"
  62. };
  63.  
  64. struct PTS {
  65.   int x, y;
  66. };    /* Structure to hold vertex points    */
  67.  
  68. int    GraphDriver;        /* The Graphics device driver        */
  69. int    GraphMode;        /* The Graphics mode value        */
  70. double AspectRatio;        /* Aspect ratio of a pixel on the screen*/
  71. int    MaxX, MaxY;        /* The maximum resolution of the screen */
  72. int    MaxColors;        /* The maximum # of colors available    */
  73. int    ErrorCode;        /* Reports any graphics errors        */
  74. struct palettetype palette;        /* Used to read palette info    */
  75.  
  76. /*                                    */
  77. /*    Function prototypes                        */
  78. /*                                    */
  79.  
  80. void Initialize(void);
  81. void ReportStatus(void);
  82. void TextDump(void);
  83. void Bar3DDemo(void);
  84. void RandomBars(void);
  85. void TextDemo(void);
  86. void ColorDemo(void);
  87. void ArcDemo(void);
  88. void CircleDemo(void);
  89. void PieDemo(void);
  90. void BarDemo(void);
  91. void LineRelDemo(void);
  92. void PutPixelDemo(void);
  93. void PutImageDemo(void);
  94. void LineToDemo(void);
  95. void LineStyleDemo(void);
  96. void CRTModeDemo(void);
  97. void UserLineStyleDemo(void);
  98. void FillStyleDemo(void);
  99. void FillPatternDemo(void);
  100. void PaletteDemo(void);
  101. void PolyDemo(void);
  102. void SayGoodbye(void);
  103. void Pause(void);
  104. void MainWindow(char *header);
  105. void StatusLine(char *msg);
  106. void DrawBorder(void);
  107. void changetextstyle(int font, int direction, int charsize);
  108. int  gprintf(int *xloc, int *yloc, char *fmt, ... );
  109.  
  110. /*                                    */
  111. /*    Begin main function                        */
  112. /*                                    */
  113.  
  114. int main()
  115. {
  116.  
  117.   Initialize();         /* Set system into Graphics mode    */
  118.   ReportStatus();        /* Report results of the initialization */
  119.  
  120.   ColorDemo();            /* Begin actual demonstration        */
  121.  
  122.     PaletteDemo();
  123.   PutPixelDemo();
  124.   PutImageDemo();
  125.   Bar3DDemo();
  126.   BarDemo();
  127.   RandomBars();
  128.   ArcDemo();
  129.   CircleDemo();
  130.   PieDemo();
  131.   LineRelDemo();
  132.   LineToDemo();
  133.   LineStyleDemo();
  134.   UserLineStyleDemo();
  135.   TextDump();
  136.   TextDemo();
  137.   CRTModeDemo();
  138.   FillStyleDemo();
  139.   FillPatternDemo();
  140.   PolyDemo();
  141.   SayGoodbye();         /* Give user the closing screen     */
  142.  
  143.   closegraph();         /* Return the system to text mode    */
  144.   return(0);
  145. }
  146.  
  147. /*                                    */
  148. /*    INITIALIZE: Initializes the graphics system and reports     */
  149. /*    any errors which occured.                    */
  150. /*                                    */
  151.  
  152. void Initialize(void)
  153. {
  154.   int xasp, yasp;            /* Used to read the aspect ratio*/
  155.  
  156.   GraphDriver = DETECT;         /* Request auto-detection    */
  157.   initgraph( &GraphDriver, &GraphMode, "" );
  158.   ErrorCode = graphresult();        /* Read result of initialization*/
  159.   if( ErrorCode != grOk ){        /* Error occured during init    */
  160.     printf(" Graphics System Error: %s\n", grapherrormsg( ErrorCode ) );
  161.     exit( 1 );
  162.   }
  163.  
  164.   getpalette( &palette );        /* Read the palette from board    */
  165.   MaxColors = getmaxcolor() + 1;    /* Read maximum number of colors*/
  166.  
  167.   MaxX = getmaxx();
  168.   MaxY = getmaxy();            /* Read size of screen        */
  169.  
  170.   getaspectratio( &xasp, &yasp );    /* read the hardware aspect    */
  171.   AspectRatio = (double)xasp / (double)yasp; /* Get correction factor    */
  172.  
  173. }
  174.  
  175. /*                                    */
  176. /*    REPORTSTATUS: Report the current configuration of the system    */
  177. /*    after the auto-detect initialization.                */
  178. /*                                    */
  179.  
  180. void ReportStatus(void)
  181. {
  182.   struct viewporttype      viewinfo;    /* Params for inquiry procedures*/
  183.   struct linesettingstype lineinfo;
  184.   struct fillsettingstype fillinfo;
  185.   struct textsettingstype textinfo;
  186.   struct palettetype      palette;
  187.  
  188.   char *driver, *mode;            /* Strings for driver and mode    */
  189.   int x, y;
  190.  
  191.   getviewsettings( &viewinfo );
  192.   getlinesettings( &lineinfo );
  193.   getfillsettings( &fillinfo );
  194.   gettextsettings( &textinfo );
  195.   getpalette( &palette );
  196.  
  197.   x = 10;
  198.   y = 4;
  199.  
  200.   MainWindow( "Status report after InitGraph" );
  201.   settextjustify( LEFT_TEXT, TOP_TEXT );
  202.  
  203.   driver = getdrivername();
  204.   mode = getmodename(GraphMode);    /* get current setting        */
  205.  
  206.   gprintf( &x, &y, "Graphics device    : %-20s (%d)", driver, GraphDriver );
  207.   gprintf( &x, &y, "Graphics mode      : %-20s (%d)", mode, GraphMode );
  208.   gprintf( &x, &y, "Screen resolution  : ( 0, 0, %d, %d )", getmaxx(), getmaxy() );
  209.  
  210.   gprintf( &x, &y, "Current view port  : ( %d, %d, %d, %d )",
  211.   viewinfo.left, viewinfo.top, viewinfo.right, viewinfo.bottom );
  212.   gprintf( &x, &y, "Clipping           : %s", viewinfo.clip ? "ON" : "OFF" );
  213.  
  214.   gprintf( &x, &y, "Current position   : ( %d, %d )", getx(), gety() );
  215.   gprintf( &x, &y, "Colors available   : %d", MaxColors );
  216.   gprintf( &x, &y, "Current color      : %d", getcolor() );
  217.  
  218.   gprintf( &x, &y, "Line style         : %s", LineStyles[ lineinfo.linestyle ] );
  219.   gprintf( &x, &y, "Line thickness     : %d", lineinfo.thickness );
  220.  
  221.   gprintf( &x, &y, "Current fill style : %s", FillStyles[ fillinfo.pattern ] );
  222.   gprintf( &x, &y, "Current fill color : %d", fillinfo.color );
  223.  
  224.   gprintf( &x, &y, "Current font       : %s", Fonts[ textinfo.font ] );
  225.   gprintf( &x, &y, "Text direction     : %s", TextDirect[ textinfo.direction ] );
  226.   gprintf( &x, &y, "Character size     : %d", textinfo.charsize );
  227.   gprintf( &x, &y, "Horizontal justify : %s", HorizJust[ textinfo.horiz ] );
  228.   gprintf( &x, &y, "Vertical justify   : %s", VertJust[ textinfo.vert ] );
  229.  
  230.   Pause();                /* Pause for user to read screen*/
  231.  
  232. }
  233.  
  234. /*                                    */
  235. /*    TEXTDUMP: Display the all the characters in each of the     */
  236. /*    available fonts.                        */
  237. /*                                    */
  238.  
  239. void TextDump()
  240. {
  241.   static int CGASizes[]  = {
  242.     1, 3, 7, 3, 3   };
  243.   static int NormSizes[] = {
  244.     1, 4, 7, 4, 4   };
  245.  
  246.   char buffer[80];
  247.   int font, ch, wwidth, lwidth, size;
  248.   struct viewporttype vp;
  249.  
  250.   for( font=0 ; font<5 ; ++font ){    /* For each available font    */
  251.     sprintf( buffer, "%s Character Set", Fonts[font] );
  252.     MainWindow( buffer );        /* Display fontname as banner    */
  253.     getviewsettings( &vp );        /* read current viewport    */
  254.  
  255.     settextjustify( LEFT_TEXT, TOP_TEXT );
  256.     moveto( 2, 3 );
  257.  
  258.     buffer[1] = '\0';                   /* Terminate string             */
  259.     wwidth = vp.right - vp.left;    /* Determine the window width    */
  260.     lwidth = textwidth( "H" );          /* Get average letter width     */
  261.  
  262.     if( font == DEFAULT_FONT ){
  263.       changetextstyle( font, HORIZ_DIR, 1 );
  264.       ch = 0;
  265.       while( ch < 256 ){        /* For each possible character    */
  266.     buffer[0] = ch;         /* Put character into a string    */
  267.     outtext( buffer );        /* send string to screen    */
  268.     if( (getx() + lwidth) > wwidth )
  269.       moveto( 2, gety() + textheight("H") + 3 );
  270.     ++ch;                /* Goto the next character    */
  271.       }
  272.     }
  273.     else{
  274.  
  275.       size = (MaxY < 200) ? CGASizes[font] : NormSizes[font];
  276.       changetextstyle( font, HORIZ_DIR, size );
  277.  
  278.       ch = '!';                         /* Begin at 1st printable       */
  279.       while( ch < 127 ){        /* For each printable character */
  280.     buffer[0] = ch;         /* Put character into a string    */
  281.     outtext( buffer );        /* send string to screen    */
  282.     if( (lwidth+getx()) > wwidth )    /* Are we still in window?    */
  283.       moveto( 2, gety()+textheight("H")+3 );
  284.     ++ch;                /* Goto the next character    */
  285.       }
  286.  
  287.     }
  288.  
  289.     Pause();                /* Pause until user acks    */
  290.  
  291.   }                    /* End of FONT loop        */
  292.  
  293. }
  294.  
  295. /*                                    */
  296. /*    BAR3DDEMO: Display a 3-D bar chart on the screen.        */
  297. /*                                    */
  298.  
  299. void Bar3DDemo(void)
  300. {
  301.   static int barheight[] = {
  302.     1, 3, 5, 4, 3, 2, 1, 5, 4, 2, 3   };
  303.   struct viewporttype vp;
  304.   int xstep, ystep;
  305.   int i, j, h, color, bheight;
  306.   char buffer[10];
  307.  
  308.   MainWindow( "Bar 3-D / Rectangle Demonstration" );
  309.  
  310.   h = 3 * textheight( "H" );
  311.   getviewsettings( &vp );
  312.   settextjustify( CENTER_TEXT, TOP_TEXT );
  313.   changetextstyle( TRIPLEX_FONT, HORIZ_DIR, 4 );
  314.   outtextxy( MaxX/2, 6, "These are 3-D Bars" );
  315.   changetextstyle( DEFAULT_FONT, HORIZ_DIR, 1 );
  316.   setviewport( vp.left+50, vp.top+40, vp.right-50, vp.bottom-10, 1 );
  317.   getviewsettings( &vp );
  318.  
  319.   line( h, h, h, vp.bottom-vp.top-h );
  320.   line( h, (vp.bottom-vp.top)-h, (vp.right-vp.left)-h, (vp.bottom-vp.top)-h );
  321.   xstep = ((vp.right-vp.left) - (2*h)) / 10;
  322.   ystep = ((vp.bottom-vp.top) - (2*h)) / 5;
  323.   j = (vp.bottom-vp.top) - h;
  324.   settextjustify( CENTER_TEXT, CENTER_TEXT );
  325.  
  326.   for( i=0 ; i<6 ; ++i ){
  327.     line( h/2, j, h, j );
  328.     itoa( i, buffer, 10 );
  329.     outtextxy( 0, j, buffer );
  330.     j -= ystep;
  331.   }
  332.  
  333.   j = h;
  334.   settextjustify( CENTER_TEXT, TOP_TEXT );
  335.  
  336.   for( i=0 ; i<11 ; ++i ){
  337.     color = random( MaxColors );
  338.     setfillstyle( i+1, color );
  339.     line( j, (vp.bottom-vp.top)-h, j, (vp.bottom-vp.top-3)-(h/2) );
  340.     itoa( i, buffer, 10 );
  341.     outtextxy( j, (vp.bottom-vp.top)-(h/2), buffer );
  342.     if( i != 10 ){
  343.       bheight = (vp.bottom-vp.top) - h - 1;
  344.       bar3d( j, (vp.bottom-vp.top-h)-(barheight[i]*ystep), j+xstep, bheight, 15, 1 );
  345.     }
  346.     j += xstep;
  347.   }
  348.  
  349.   Pause();                /* Pause for user's response    */
  350.  
  351. }
  352.  
  353. /*                                    */
  354. /*    RANDOMBARS: Display random bars                 */
  355. /*                                    */
  356.  
  357. void RandomBars(void)
  358. {
  359.   int color;
  360.  
  361.   MainWindow( "Random Bars" );
  362.   StatusLine( "Esc aborts or press a key..." ); /* Put msg at bottom of screen   */
  363.   while( !kbhit() ){            /* Until user enters a key...    */
  364.     color = random( MaxColors-1 )+1;
  365.     setcolor( color );
  366.     setfillstyle( random(11)+1, color );
  367.     bar3d( random( getmaxx() ), random( getmaxy() ),
  368.        random( getmaxx() ), random( getmaxy() ), 0, OFF);
  369.   }
  370.  
  371.   Pause();                /* Pause for user's response    */
  372.  
  373. }
  374.  
  375.  
  376. /*                                    */
  377. /*    TEXTDEMO: Show each font in several sizes to the user.        */
  378. /*                                    */
  379.  
  380. void TextDemo(void)
  381. {
  382.   int charsize[] = {
  383.     1, 3, 7, 3, 4   };
  384.   int font, size;
  385.   int h, x, y, i;
  386.   struct viewporttype vp;
  387.   char buffer[80];
  388.  
  389.   for( font=0 ; font<5 ; ++font ){    /* For each of the four fonts    */
  390.  
  391.     sprintf( buffer, "%s Demonstration", Fonts[font] );
  392.     MainWindow( buffer );
  393.     getviewsettings( &vp );
  394.  
  395.     changetextstyle( font, VERT_DIR, charsize[font] );
  396.     settextjustify( CENTER_TEXT, BOTTOM_TEXT );
  397.     outtextxy( 2*textwidth("M"), vp.bottom - 2*textheight("M"), "Vertical" );
  398.  
  399.     changetextstyle( font, HORIZ_DIR, charsize[font] );
  400.     settextjustify( LEFT_TEXT, TOP_TEXT );
  401.     outtextxy( 2*textwidth("M"), 2, "Horizontal" );
  402.  
  403.     settextjustify( CENTER_TEXT, CENTER_TEXT );
  404.     x = (vp.right - vp.left) / 2;
  405.     y = textheight( "H" );
  406.  
  407.     for( i=1 ; i<5 ; ++i ){        /* For each of the sizes */
  408.       size = (font == SMALL_FONT) ? i+3 : i;
  409.       changetextstyle( font, HORIZ_DIR, size );
  410.       h = textheight( "H" );
  411.       y += h;
  412.       sprintf( buffer, "Size %d", size );
  413.       outtextxy( x, y, buffer );
  414.  
  415.     }
  416.  
  417.     if( font != DEFAULT_FONT ){     /* Show user declared font size */
  418.       y += h / 2;            /* Move down the screen     */
  419.       settextjustify( CENTER_TEXT, TOP_TEXT );
  420.       setusercharsize( 5, 6, 3, 2 );
  421.       changetextstyle( font, HORIZ_DIR, USER_CHAR_SIZE );
  422.       outtextxy( (vp.right-vp.left)/2, y, "User Defined Size" );
  423.     }
  424.  
  425.     Pause();                /* Pause to let user look    */
  426.  
  427.   }                    /* End of FONT loop        */
  428.  
  429. }
  430.  
  431. /*                                    */
  432. /*    COLORDEMO: Display the current color palette on the screen.    */
  433. /*                                    */
  434.  
  435. void ColorDemo(void)
  436. {
  437.   struct viewporttype vp;
  438.   int color, height, width;
  439.   int x, y, i, j;
  440.   char cnum[5];
  441.  
  442.   MainWindow( "Color Demonstration" );  /* Show demonstration name      */
  443.  
  444.   color = 1;
  445.   getviewsettings( &vp );        /* Get the current window size    */
  446.   width  = 2 * ( (vp.right+1) / 16 );       /* Get box dimensions       */
  447.   height = 2 * ( (vp.bottom-10) / 10 );
  448.  
  449.   x = width / 2;
  450.   y = height / 2;    /* Leave 1/2 box border     */
  451.  
  452.   for( j=0 ; j<3 ; ++j ){        /* Row loop            */
  453.  
  454.     for( i=0 ; i<5 ; ++i ){        /* Column loop            */
  455.  
  456.       setfillstyle(SOLID_FILL, color);    /* Set to solid fill in color    */
  457.       setcolor( color );        /* Set the same border color    */
  458.  
  459.       bar( x, y, x+width, y+height );    /* Draw the rectangle        */
  460.       rectangle( x, y, x+width, y+height );  /* outline the rectangle    */
  461.  
  462.       if( color == BLACK ){        /* If box was black...        */
  463.     setcolor( WHITE );        /* Set drawing color to white    */
  464.     rectangle( x, y, x+width, y+height );  /* Outline black in white*/
  465.       }
  466.  
  467.       itoa( color, cnum, 10 );        /* Convert # to ASCII        */
  468.       outtextxy( x+(width/2), y+height+4, cnum );  /* Show color #    */
  469.  
  470.       color = ++color % MaxColors;    /* Advance to the next color    */
  471.       x += (width / 2) * 3;        /* move the column base     */
  472.     }                /* End of Column loop        */
  473.  
  474.     y += (height / 2) * 3;        /* move the row base        */
  475.     x = width / 2;            /* reset column base        */
  476.   }                    /* End of Row loop        */
  477.  
  478.   Pause();                /* Pause for user's response    */
  479.  
  480. }
  481.  
  482. /*                                    */
  483. /*    ARCDEMO: Display a random pattern of arcs on the screen */
  484. /*    until the user says enough.                    */
  485. /*                                    */
  486.  
  487. void ArcDemo(void)
  488. {
  489.   int mradius;                /* Maximum radius allowed    */
  490.   int eangle;                /* Random end angle of Arc    */
  491.   struct arccoordstype ai;        /* Used to read Arc Cord info    */
  492.  
  493.   MainWindow( "Arc Demonstration" );
  494.   StatusLine( "ESC Aborts - Press a Key to stop" );
  495.  
  496.   mradius = MaxY / 10;            /* Determine the maximum radius */
  497.  
  498.   while( !kbhit() ){            /* Repeat until a key is hit    */
  499.     setcolor( random( MaxColors - 1 ) + 1 );    /* Randomly select a color    */
  500.     eangle = random( 358 ) + 1;     /* Select an end angle        */
  501.     arc( random(MaxX), random(MaxY), random(eangle), eangle, mradius );
  502.     getarccoords( &ai );        /* Read Cord data        */
  503.     line( ai.x, ai.y, ai.xstart, ai.ystart ); /* line from start to center */
  504.     line( ai.x, ai.y,    ai.xend,   ai.yend ); /* line from end to center   */
  505.   }                    /* End of WHILE not KBHIT    */
  506.  
  507.   Pause();                /* Wait for user's response     */
  508.  
  509. }
  510.  
  511. /*                                    */
  512. /*    CIRCLEDEMO: Display a random pattern of circles on the screen    */
  513. /*    until the user says enough.                    */
  514. /*                                    */
  515.  
  516. void CircleDemo(void)
  517. {
  518.   int mradius;                /* Maximum radius allowed    */
  519.  
  520.   MainWindow( "Circle Demonstration" );
  521.   StatusLine( "ESC Aborts - Press a Key to stop" );
  522.  
  523.   mradius = MaxY / 10;            /* Determine the maximum radius */
  524.  
  525.   while( !kbhit() ){            /* Repeat until a key is hit    */
  526.     setcolor( random( MaxColors - 1 ) + 1 );    /* Randomly select a color    */
  527.     circle( random(MaxX), random(MaxY), random(mradius) );
  528.   }                    /* End of WHILE not KBHIT    */
  529.  
  530.   Pause();                /* Wait for user's response     */
  531.  
  532. }
  533.  
  534. /*                                    */
  535. /*    PIEDEMO: Display a pie chart on the screen.            */
  536. /*                                    */
  537.  
  538. #define adjasp( y )    ((int)(AspectRatio * (double)(y)))
  539. #define torad( d )    (( (double)(d) * PI ) / 180.0 )
  540.  
  541. void PieDemo(void)
  542. {
  543.   struct viewporttype vp;
  544.   int xcenter, ycenter, radius, lradius;
  545.   int x, y;
  546.   double radians, piesize;
  547.  
  548.   MainWindow( "Pie Chart Demonstration" );
  549.  
  550.   getviewsettings( &vp );        /* Get the current viewport    */
  551.   xcenter = (vp.right - vp.left) / 2;    /* Center the Pie horizontally    */
  552.   ycenter = (vp.bottom - vp.top) / 2+20;/* Center the Pie vertically    */
  553.   radius  = (vp.bottom - vp.top) / 3;    /* It will cover 2/3rds screen    */
  554.   piesize = (vp.bottom - vp.top) / 4.0; /* Optimum height ratio of pie    */
  555.  
  556.   while( (AspectRatio*radius) < piesize ) ++radius;
  557.  
  558.   lradius = radius + ( radius / 5 );    /* Labels placed 20% farther    */
  559.  
  560.   changetextstyle( TRIPLEX_FONT, HORIZ_DIR, 4 );
  561.   settextjustify( CENTER_TEXT, TOP_TEXT );
  562.   outtextxy( MaxX/2, 6, "This is a Pie Chart" );
  563.   changetextstyle( TRIPLEX_FONT, HORIZ_DIR, 3 );
  564.   settextjustify( CENTER_TEXT, TOP_TEXT );
  565.  
  566.   setfillstyle( SOLID_FILL, RED );
  567.   pieslice( xcenter+10, ycenter-adjasp(10), 0, 90, radius );
  568.   radians = torad( 45 );
  569.   x = xcenter + (int)( cos( radians ) * (double)lradius );
  570.   y = ycenter - (int)( sin( radians ) * (double)lradius * AspectRatio );
  571.   settextjustify( LEFT_TEXT, BOTTOM_TEXT );
  572.   outtextxy( x, y, "25 %" );
  573.  
  574.   setfillstyle( WIDE_DOT_FILL, GREEN );
  575.   pieslice( xcenter, ycenter, 90, 135, radius );
  576.   radians = torad( 113 );
  577.   x = xcenter + (int)( cos( radians ) * (double)lradius );
  578.   y = ycenter - (int)( sin( radians ) * (double)lradius * AspectRatio );
  579.   settextjustify( RIGHT_TEXT, BOTTOM_TEXT );
  580.   outtextxy( x, y, "12.5 %" );
  581.  
  582.   setfillstyle( INTERLEAVE_FILL, YELLOW );
  583.   settextjustify( RIGHT_TEXT, CENTER_TEXT );
  584.   pieslice( xcenter-10, ycenter, 135, 225, radius );
  585.   radians = torad( 180 );
  586.   x = xcenter + (int)( cos( radians ) * (double)lradius );
  587.   y = ycenter - (int)( sin( radians ) * (double)lradius * AspectRatio );
  588.   settextjustify( RIGHT_TEXT, CENTER_TEXT );
  589.   outtextxy( x, y, "25 %" );
  590.  
  591.   setfillstyle( HATCH_FILL, BLUE );
  592.   pieslice( xcenter, ycenter, 225, 360, radius );
  593.   radians = torad( 293 );
  594.   x = xcenter + (int)( cos( radians ) * (double)lradius );
  595.   y = ycenter - (int)( sin( radians ) * (double)lradius * AspectRatio );
  596.   settextjustify( LEFT_TEXT, TOP_TEXT );
  597.   outtextxy( x, y, "37.5 %" );
  598.  
  599.   Pause();                /* Pause for user's response    */
  600.  
  601. }
  602.  
  603. /*                                    */
  604. /*    BARDEMO: Draw a 2-D bar chart using Bar and Rectangle.        */
  605. /*                                    */
  606.  
  607. void BarDemo(void)
  608. {
  609.   int barheight[] = {
  610.     1, 3, 5, 2, 4   };
  611.   int styles[]      = {
  612.     1, 3, 10, 5, 9, 1    };
  613.   int xstep, ystep;
  614.   int sheight, swidth;
  615.   int i, j, h;
  616.   struct viewporttype vp;
  617.   char buffer[40];
  618.  
  619.   MainWindow( "Bar / Rectangle demonstration" );
  620.   h = 3 * textheight( "H" );
  621.   getviewsettings( &vp );
  622.   settextjustify( CENTER_TEXT, TOP_TEXT );
  623.   changetextstyle( TRIPLEX_FONT, HORIZ_DIR, 4 );
  624.   outtextxy( MaxX /2, 6, "These are 2-D Bars" );
  625.   changetextstyle( DEFAULT_FONT, HORIZ_DIR, 1 );
  626.   setviewport( vp.left+50, vp.top+30, vp.right-50, vp.bottom-10, 1 );
  627.  
  628.   getviewsettings( &vp );
  629.   sheight = vp.bottom - vp.top;
  630.   swidth  = vp.right  - vp.left;
  631.  
  632.   line( h, h, h, sheight-h );
  633.   line( h, sheight-h, sheight-h, sheight-h );
  634.   ystep = (sheight - (2*h) ) / 5;
  635.   xstep = (swidth  - (2*h) ) / 5;
  636.   j = sheight - h;
  637.   settextjustify( CENTER_TEXT, CENTER_TEXT );
  638.  
  639.   for( i=0 ; i<6 ; ++i ){
  640.     line( h/2, j, h, j );
  641.     itoa( i, buffer, 10 );
  642.     outtextxy( 0, j, buffer );
  643.     j -= ystep;
  644.   }
  645.  
  646.   j = h;
  647.   settextjustify( CENTER_TEXT, TOP_TEXT );
  648.   for( i=0 ; i<6 ; ++i ){
  649.     setfillstyle( styles[i], random(MaxColors) );
  650.     line( j, sheight - h, j, sheight- 3 - (h/2) );
  651.     itoa( i, buffer, 10 );
  652.     outtextxy( j, sheight - (h/2), buffer );
  653.     if( i != 5 ){
  654.       bar( j, (sheight-h)-(barheight[i] * ystep), j+xstep, sheight-h-1 );
  655.       rectangle( j, (sheight-h)-(barheight[i] * ystep), j+xstep, sheight-h);
  656.     }
  657.     j += xstep;
  658.   }
  659.  
  660.   Pause();
  661.  
  662. }
  663.  
  664. /*                                    */
  665. /*    LINERELDEMO: Display pattern using moverel and linerel cmds.    */
  666. /*                                    */
  667.  
  668. void LineRelDemo(void)
  669. {
  670.   struct viewporttype vp;
  671.   int h, w, dx, dy, cx, cy;
  672.   struct PTS outs[7];
  673.  
  674.  
  675.   MainWindow( "MoveRel / LineRel Demonstration" );
  676.   StatusLine( "Press any key to continue, ESC to Abort" );
  677.  
  678.   getviewsettings( &vp );
  679.   cx = (vp.right  - vp.left) / 2;    /* Center of the screen coords    */
  680.   cy = (vp.bottom - vp.top ) / 2;
  681.  
  682.   h  = (vp.bottom - vp.top ) / 8;
  683.   w  = (vp.right  - vp.left) / 9;
  684.  
  685.   dx = 2 * w;
  686.   dy = 2 * h;
  687.  
  688.   setcolor( BLACK );
  689.  
  690.   setfillstyle( SOLID_FILL, BLUE );
  691.   bar( 0, 0, vp.right-vp.left, vp.bottom-vp.top );    /* Draw backgnd */
  692.  
  693.   outs[0].x = cx -  dx;
  694.   outs[0].y = cy -  dy;
  695.   outs[1].x = cx - (dx-w);
  696.   outs[1].y = cy - (dy+h);
  697.   outs[2].x = cx +  dx;
  698.   outs[2].y = cy - (dy+h);
  699.   outs[3].x = cx +  dx;
  700.   outs[3].y = cy +  dy;
  701.   outs[4].x = cx + (dx-w);
  702.   outs[4].y = cy + (dy+h);
  703.   outs[5].x = cx -  dx;
  704.   outs[5].y = cy + (dy+h);
  705.   outs[6].x = cx -  dx;
  706.   outs[6].y = cy -  dy;
  707.  
  708.   setfillstyle( SOLID_FILL, WHITE );
  709.   fillpoly( 7, (int far *)outs );
  710.  
  711.   outs[0].x = cx - (w/2);
  712.   outs[0].y = cy + h;
  713.   outs[1].x = cx + (w/2);
  714.   outs[1].y = cy + h;
  715.   outs[2].x = cx + (w/2);
  716.   outs[2].y = cy - h;
  717.   outs[3].x = cx - (w/2);
  718.   outs[3].y = cy - h;
  719.   outs[4].x = cx - (w/2);
  720.   outs[4].y = cy + h;
  721.  
  722.   setfillstyle( SOLID_FILL, BLUE );
  723.   fillpoly( 5, (int far *)outs );
  724.  
  725.   /*    Draw a Tesseract object on the screen using the LineRel and    */
  726.   /*    MoveRel drawing commands.                    */
  727.  
  728.   moveto( cx-dx, cy-dy );
  729.   linerel(  w, -h );
  730.   linerel(  3*w,    0 );
  731.   linerel(   0,  5*h );
  732.   linerel( -w,    h );
  733.   linerel( -3*w,    0 );
  734.   linerel(   0, -5*h );
  735.  
  736.   moverel( w, -h );
  737.   linerel(   0,  5*h );
  738.   linerel( w+(w/2), 0 );
  739.   linerel(   0, -3*h );
  740.   linerel( w/2,   -h );
  741.   linerel( 0, 5*h );
  742.  
  743.   moverel(  0, -5*h );
  744.   linerel( -(w+(w/2)), 0 );
  745.   linerel( 0, 3*h );
  746.   linerel( -w/2, h );
  747.  
  748.   moverel( w/2, -h );
  749.   linerel( w, 0 );
  750.  
  751.   moverel( 0, -2*h );
  752.   linerel( -w, 0 );
  753.  
  754.   Pause();                /* Wait for user's response     */
  755.  
  756. }
  757.  
  758. /*                                    */
  759. /*    PUTPIXELDEMO: Display a pattern of random dots on the screen    */
  760. /*    and pick them back up again.                    */
  761. /*                                    */
  762.  
  763. void PutPixelDemo(void)
  764. {
  765.   int seed = 1958;
  766.   int i, x, y, h, w, color;
  767.   struct viewporttype vp;
  768.  
  769.   MainWindow( "PutPixel / GetPixel Demonstration" );
  770.  
  771.   getviewsettings( &vp );
  772.   h = vp.bottom - vp.top;
  773.   w = vp.right    - vp.left;
  774.  
  775.   srand( seed );            /* Restart random # function    */
  776.  
  777.   for( i=0 ; i<5000 ; ++i ){        /* Put 5000 pixels on screen    */
  778.     x = 1 + random( w - 1 );        /* Generate a random location    */
  779.     y = 1 + random( h - 1 );
  780.     color = random( MaxColors );
  781.     putpixel( x, y, color );
  782.   }
  783.  
  784.   srand( seed );            /* Restart Random # at same #    */
  785.  
  786.   for( i=0 ; i<5000 ; ++i ){        /* Take the 5000 pixels off    */
  787.     x = 1 + random( w - 1 );        /* Generate a random location    */
  788.     y = 1 + random( h - 1 );
  789.     color = getpixel( x, y );        /* Read the color pixel     */
  790.     if( color == random( MaxColors ) )    /* Used to keep RANDOM in sync    */
  791.       putpixel( x, y, 0 );        /* Write pixel to BLACK     */
  792.   }
  793.  
  794.   Pause();                /* Wait for user's response     */
  795.  
  796. }
  797.  
  798. /*                                    */
  799. /*   PUTIMAGEDEMO                            */
  800. /*                                    */
  801. void PutImageDemo(void)
  802. {
  803.   static int r        = 20;
  804.   static int StartX = 100;
  805.   static int StartY = 50;
  806.  
  807.   struct viewporttype vp;
  808.   int PauseTime, x, y, ulx, uly, lrx, lry, i, width, height, step;
  809.   void *Saucer;
  810.   unsigned long size;
  811.  
  812.   MainWindow("GetImage / PutImage Demonstration");
  813.   getviewsettings( &vp );
  814.  
  815.   /* Draw Saucer */
  816.   setfillstyle( SOLID_FILL, getmaxcolor() );
  817.   fillellipse(StartX, StartY, r, (r/3)+2);
  818.   ellipse(StartX, StartY-4, 190, 357, r, r/3);
  819.  
  820.   line(StartX+7, StartY-6, StartX+10, StartY-12);
  821.   circle(StartX+10, StartY-12, 2);
  822.   line(StartX-7, StartY-6, StartX-10, StartY-12);
  823.   circle(StartX-10, StartY-12, 2);
  824.  
  825.  
  826.   /* Read saucer image */
  827.   ulx = StartX-(r+1);
  828.   uly = StartY-14;
  829.   lrx = StartX+(r+1);
  830.   lry = StartY+(r/3)+3;
  831.   width = lrx - ulx + 1;
  832.   height = lry - uly + 1;
  833.   size = imagesize(ulx, uly, lrx, lry);
  834.  
  835.   Saucer = malloc( size );
  836.   getimage(ulx, uly, lrx, lry, Saucer);
  837.   putimage(ulx, uly, Saucer, XOR_PUT);
  838.  
  839. /* Plot some "stars"  */
  840.   for ( i=0 ; i<1000; ++i )
  841.     putpixel(random(MaxX), random(MaxY), random( MaxColors-1 )+1);
  842.   x = MaxX / 2;
  843.   y = MaxY / 2;
  844.   PauseTime = 70;
  845.  
  846.   /* until a key is hit */
  847.   while ( !kbhit() ) {
  848.  
  849.     /* Draw the Saucer */
  850.     putimage(x, y, Saucer, XOR_PUT);             /*  draw image  */
  851.     delay(PauseTime);
  852.     putimage(x, y, Saucer, XOR_PUT);             /* erase image  */
  853.  
  854.     /* Move Saucer */
  855.  
  856.     step = random( 2*r );
  857.     if ((step/2) % 2 != 0 )
  858.       step = -1 * step;
  859.     x = x + step;
  860.     step = random( r );
  861.     if ((step/2) % 2 != 0 )
  862.       step = -1 * step;
  863.     y = y + step;
  864.  
  865.     if (vp.left + x + width - 1 > vp.right)
  866.       x = vp.right-vp.left-width + 1;
  867.     else
  868.       if (x < 0)
  869.     x = 0;
  870.     if (vp.top + y + height - 1 > vp.bottom)
  871.       y = vp.bottom-vp.top-height + 1;
  872.     else
  873.       if (y < 0)
  874.     y = 0;
  875.   }
  876.   free( Saucer );
  877.   Pause();
  878. }
  879.  
  880.  
  881. /*                                    */
  882. /*    LINETODEMO: Display a pattern using moveto and lineto commands. */
  883. /*                                    */
  884.  
  885. #define MAXPTS    15
  886.  
  887. void LineToDemo(void)
  888. {
  889.   struct viewporttype vp;
  890.   struct PTS points[MAXPTS];
  891.   int i, j, h, w, xcenter, ycenter;
  892.   int radius, angle, step;
  893.   double  rads;
  894.  
  895.   MainWindow( "MoveTo / LineTo Demonstration" );
  896.  
  897.   getviewsettings( &vp );
  898.   h = vp.bottom - vp.top;
  899.   w = vp.right    - vp.left;
  900.  
  901.   xcenter = w / 2;            /* Determine the center of circle */
  902.   ycenter = h / 2;
  903.   radius  = (h - 30) / (AspectRatio * 2);
  904.   step      = 360 / MAXPTS;        /* Determine # of increments    */
  905.  
  906.   angle = 0;                /* Begin at zero degrees    */
  907.   for( i=0 ; i<MAXPTS ; ++i ){        /* Determine circle intercepts    */
  908.     rads = (double)angle * PI / 180.0;    /* Convert angle to radians    */
  909.     points[i].x = xcenter + (int)( cos(rads) * radius );
  910.     points[i].y = ycenter - (int)( sin(rads) * radius * AspectRatio );
  911.     angle += step;            /* Move to next increment    */
  912.   }
  913.  
  914.   circle( xcenter, ycenter, radius );    /* Draw bounding circle     */
  915.  
  916.   for( i=0 ; i<MAXPTS ; ++i ){        /* Draw the cords to the circle */
  917.     for( j=i ; j<MAXPTS ; ++j ){    /* For each remaining intersect */
  918.       moveto(points[i].x, points[i].y); /* Move to beginning of cord    */
  919.       lineto(points[j].x, points[j].y); /* Draw the cord        */
  920.     }
  921.   }
  922.  
  923.   Pause();                /* Wait for user's response     */
  924.  
  925. }
  926.  
  927. /*                                    */
  928. /*    LINESTYLEDEMO: Display a pattern using all of the standard    */
  929. /*    line styles that are available.                 */
  930. /*                                    */
  931.  
  932. void LineStyleDemo(void)
  933. {
  934.   int style, step;
  935.   int x, y, w;
  936.   struct viewporttype vp;
  937.   char buffer[40];
  938.  
  939.   MainWindow( "Pre-defined line styles" );
  940.  
  941.   getviewsettings( &vp );
  942.   w = vp.right    - vp.left;
  943.  
  944.   x = 35;
  945.   y = 10;
  946.   step = w / 11;
  947.  
  948.   settextjustify( LEFT_TEXT, TOP_TEXT );
  949.   outtextxy( x, y, "Normal Width" );
  950.  
  951.   settextjustify( CENTER_TEXT, TOP_TEXT );
  952.  
  953.   for( style=0 ; style<4 ; ++style ){
  954.     setlinestyle( style, 0, NORM_WIDTH );
  955.     line( x, y+20, x, vp.bottom-40 );
  956.     itoa( style, buffer, 10 );
  957.     outtextxy( x, vp.bottom-30, buffer );
  958.     x += step;
  959.   }
  960.  
  961.   x += 2 * step;
  962.  
  963.   settextjustify( LEFT_TEXT, TOP_TEXT );
  964.   outtextxy( x, y, "Thick Width" );
  965.   settextjustify( CENTER_TEXT, TOP_TEXT );
  966.  
  967.   for( style=0 ; style<4 ; ++style ){
  968.     setlinestyle( style, 0, THICK_WIDTH );
  969.     line( x, y+20, x, vp.bottom-40 );
  970.     itoa( style, buffer, 10 );
  971.     outtextxy( x, vp.bottom-30, buffer );
  972.     x += step;
  973.   }
  974.  
  975.   settextjustify( LEFT_TEXT, TOP_TEXT );
  976.  
  977.   Pause();                /* Wait for user's response     */
  978.  
  979. }
  980.  
  981. /*                                    */
  982. /*    CRTMODEDEMO: Demonstrate the effects of the change mode     */
  983. /*    commands on the current screen.                 */
  984. /*                                    */
  985.  
  986. void CRTModeDemo(void)
  987. {
  988.   struct viewporttype vp;
  989.   int mode;
  990.  
  991.   MainWindow( "SetGraphMode / RestoreCRTMode demo" );
  992.   getviewsettings( &vp );
  993.   mode = getgraphmode();
  994.   settextjustify( CENTER_TEXT, CENTER_TEXT );
  995.  
  996.   outtextxy( (vp.right-vp.left)/2, (vp.bottom-vp.top)/2,
  997.   "Now you are in graphics mode..." );
  998.   StatusLine( "Press any key for text mode..." );
  999.   getch();
  1000.  
  1001.   restorecrtmode();
  1002.   printf( "Now you are in text mode.\n\n" );
  1003.   printf( "Press any key to go back to graphics..." );
  1004.   getch();
  1005.  
  1006.   setgraphmode( mode );
  1007.   MainWindow( "SetGraphMode / RestoreCRTMode demo" );
  1008.   settextjustify( CENTER_TEXT, CENTER_TEXT );
  1009.   outtextxy( (vp.right-vp.left)/2, (vp.bottom-vp.top)/2,
  1010.   "Back in Graphics Mode..." );
  1011.  
  1012.   Pause();                /* Wait for user's response     */
  1013.  
  1014. }
  1015.  
  1016. /*                                    */
  1017. /*    USERLINESTYLEDEMO: Display line styles showing the user     */
  1018. /*    defined line style functions.                    */
  1019. /*                                    */
  1020.  
  1021. void UserLineStyleDemo(void)
  1022. {
  1023.   int x, y, i, h, flag;
  1024.   unsigned int style;
  1025.   struct viewporttype vp;
  1026.  
  1027.   MainWindow( "User defined line styles" );
  1028.  
  1029.   getviewsettings( &vp );
  1030.   h = vp.bottom - vp.top;
  1031.  
  1032.   x = 4;
  1033.   y = 10;
  1034.   style = 0;
  1035.   i = 0;
  1036.  
  1037.   settextjustify( CENTER_TEXT, TOP_TEXT );
  1038.   flag = TRUE;                /* Set the bits in this pass    */
  1039.  
  1040.   while( x < vp.right-2 ){        /* Draw lines across the screen */
  1041.  
  1042.     if( flag )                /* If flag, set bits...     */
  1043.       style = style | (1 << i);     /*    Set the Ith bit in word    */
  1044.     else                /* If no flag, clear bits    */
  1045.     style = style & !(0x8000 >> i);    /*    Clear the Ith bit in word */
  1046.  
  1047.     setlinestyle( USERBIT_LINE, style, NORM_WIDTH );
  1048.     line( x, y, x, h-y );        /* Draw the new line pattern    */
  1049.  
  1050.     x += 5;                /* Move the X location of line    */
  1051.     i = ++i % 16;            /* Advance to next bit pattern    */
  1052.  
  1053.     if( style == 0xffff ){        /* Are all bits set?        */
  1054.       flag = FALSE;            /*   begin removing bits    */
  1055.       i = 0;                /* Start with whole pattern    */
  1056.     }
  1057.     else{                /* Bits not all set...        */
  1058.       if( style == 0 )            /* Are all bits clear?        */
  1059.     flag = TRUE;            /*   begin setting bits     */
  1060.     }
  1061.   }
  1062.  
  1063.   settextjustify( LEFT_TEXT, TOP_TEXT );
  1064.  
  1065.   Pause();                /* Wait for user's response     */
  1066.  
  1067. }
  1068.  
  1069. /*                                    */
  1070. /*    FILLSTYLEDEMO: Display the standard fill patterns available.    */
  1071. /*                                    */
  1072.  
  1073. void FillStyleDemo(void)
  1074. {
  1075.   int h, w, style;
  1076.   int i, j, x, y;
  1077.   struct viewporttype vp;
  1078.   char buffer[40];
  1079.  
  1080.   MainWindow( "Pre-defined Fill Styles" );
  1081.  
  1082.   getviewsettings( &vp );
  1083.   w = 2 * ((vp.right  +  1) / 13);
  1084.   h = 2 * ((vp.bottom - 10) / 10);
  1085.  
  1086.   x = w / 2;
  1087.   y = h / 2;        /* Leave 1/2 blk margin     */
  1088.   style = 0;
  1089.  
  1090.   for( j=0 ; j<3 ; ++j ){        /* Three rows of boxes        */
  1091.     for( i=0 ; i<4 ; ++i ){        /* Four column of boxes     */
  1092.       setfillstyle(style, MaxColors-1); /* Set the fill style and WHITE */
  1093.       bar( x, y, x+w, y+h );        /* Draw the actual box        */
  1094.       rectangle( x, y, x+w, y+h );    /* Outline the box        */
  1095.       itoa( style, buffer, 10 );    /* Convert style 3 to ASCII    */
  1096.       outtextxy( x+(w / 2), y+h+4, buffer );
  1097.       ++style;                /* Go on to next style #    */
  1098.       x += (w / 2) * 3;         /* Go to next column        */
  1099.     }                /* End of coulmn loop        */
  1100.     x = w / 2;                /* Put base back to 1st column    */
  1101.     y += (h / 2) * 3;            /* Advance to next row        */
  1102.   }                    /* End of Row loop        */
  1103.  
  1104.   settextjustify( LEFT_TEXT, TOP_TEXT );
  1105.  
  1106.   Pause();                /* Wait for user's response     */
  1107.  
  1108. }
  1109.  
  1110. /*                                    */
  1111. /*    FILLPATTERNDEMO: Demonstrate how to use the user definable    */
  1112. /*    fill patterns.                            */
  1113. /*                                    */
  1114.  
  1115. void FillPatternDemo(void)
  1116. {
  1117.   int style;
  1118.   int h, w;
  1119.   int x, y, i, j;
  1120.   char buffer[40];
  1121.   struct viewporttype vp;
  1122.   static char patterns[][8] = {
  1123.     { 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55, 0xAA, 0x55 },
  1124.     { 0x33, 0x33, 0xCC, 0xCC, 0x33, 0x33, 0xCC, 0xCC },
  1125.     { 0xF0, 0xF0, 0xF0, 0xF0, 0x0F, 0x0F, 0x0F, 0x0F },
  1126.     { 0x00, 0x10, 0x28, 0x44, 0x28, 0x10, 0x00, 0x00 },
  1127.     { 0x00, 0x70, 0x20, 0x27, 0x24, 0x24, 0x07, 0x00 },
  1128.     { 0x00, 0x00, 0x00, 0x18, 0x18, 0x00, 0x00, 0x00 },
  1129.     { 0x00, 0x00, 0x3C, 0x3C, 0x3C, 0x3C, 0x00, 0x00 },
  1130.     { 0x00, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x7E, 0x00 },
  1131.     { 0x00, 0x00, 0x22, 0x08, 0x00, 0x22, 0x1C, 0x00 },
  1132.     { 0xFF, 0x7E, 0x3C, 0x18, 0x18, 0x3C, 0x7E, 0xFF },
  1133.     { 0x00, 0x10, 0x10, 0x7C, 0x10, 0x10, 0x00, 0x00 },
  1134.     { 0x00, 0x42, 0x24, 0x18, 0x18, 0x24, 0x42, 0x00 }
  1135.   };
  1136.  
  1137.   MainWindow( "User Defined Fill Styles" );
  1138.  
  1139.   getviewsettings( &vp );
  1140.   w = 2 * ((vp.right  +  1) / 13);
  1141.   h = 2 * ((vp.bottom - 10) / 10);
  1142.  
  1143.   x = w / 2;
  1144.   y = h / 2;        /* Leave 1/2 blk margin     */
  1145.   style = 0;
  1146.  
  1147.   for( j=0 ; j<3 ; ++j ){        /* Three rows of boxes        */
  1148.     for( i=0 ; i<4 ; ++i ){        /* Four column of boxes     */
  1149.       setfillpattern( &patterns[style][0], MaxColors-1 );
  1150.       bar( x, y, x+w, y+h );        /* Draw the actual box        */
  1151.       rectangle( x, y, x+w, y+h );    /* Outline the box        */
  1152.       itoa( style, buffer, 10 );    /* Convert style 3 to ASCII    */
  1153.       outtextxy( x+(w / 2), y+h+4, buffer );
  1154.       ++style;                /* Go on to next style #    */
  1155.       x += (w / 2) * 3;         /* Go to next column        */
  1156.     }                /* End of coulmn loop        */
  1157.     x = w / 2;                /* Put base back to 1st column    */
  1158.     y += (h / 2) * 3;            /* Advance to next row        */
  1159.   }                    /* End of Row loop        */
  1160.  
  1161.   settextjustify( LEFT_TEXT, TOP_TEXT );
  1162.  
  1163.   Pause();                /* Wait for user's response     */
  1164.  
  1165. }
  1166.  
  1167. /*                                    */
  1168. /*    POLYDEMO: Display a random pattern of polygons on the screen    */
  1169. /*    until the user says enough.                    */
  1170. /*                                    */
  1171.  
  1172. void PaletteDemo(void)
  1173. {
  1174.   int i, j, x, y, color;
  1175.   struct viewporttype vp;
  1176.   int height, width;
  1177.  
  1178.   MainWindow( "Palette Demonstration" );
  1179.   StatusLine( "Press any key to continue, ESC to Abort" );
  1180.  
  1181.   getviewsettings( &vp );
  1182.   width  = (vp.right - vp.left) / 15;    /* get width of the box     */
  1183.   height = (vp.bottom - vp.top) / 10;    /* Get the height of the box    */
  1184.  
  1185.   x = y = 0;                /* Start in upper corner    */
  1186.   color = 1;                /* Begin at 1st color        */
  1187.  
  1188.   for( j=0 ; j<10 ; ++j ){        /* For 10 rows of boxes     */
  1189.     for( i=0 ; i<15 ; ++i ){        /* For 15 columns of boxes    */
  1190.       setfillstyle( SOLID_FILL, color++ );    /* Set the color of box */
  1191.       bar( x, y, x+width, y+height );        /* Draw the box     */
  1192.       x += width + 1;                /* Advance to next col    */
  1193.       color = 1 + (color % (MaxColors - 2));    /* Set new color    */
  1194.     }                /* End of COLUMN loop        */
  1195.     x = 0;                /* Goto 1st column        */
  1196.     y += height + 1;            /* Goto next row        */
  1197.   }                    /* End of ROW loop        */
  1198.  
  1199.   while( !kbhit() ){            /* Until user enters a key...    */
  1200.     setpalette( 1+random(MaxColors - 2), random( 65 ) );
  1201.   }
  1202.  
  1203.   setallpalette( &palette );
  1204.  
  1205.   Pause();                /* Wait for user's response     */
  1206.  
  1207. }
  1208.  
  1209. /*                                    */
  1210. /*    POLYDEMO: Display a random pattern of polygons on the screen    */
  1211. /*    until the user says enough.                    */
  1212. /*                                    */
  1213.  
  1214. #define MaxPts        6        /* Maximum # of pts in polygon    */
  1215.  
  1216. void PolyDemo(void)
  1217. {
  1218.   struct PTS poly[ MaxPts ];        /* Space to hold datapoints    */
  1219.   int color;                /* Current drawing color    */
  1220.   int i;
  1221.  
  1222.   MainWindow( "DrawPoly / FillPoly Demonstration" );
  1223.   StatusLine( "ESC Aborts - Press a Key to stop" );
  1224.  
  1225.   while( !kbhit() ){            /* Repeat until a key is hit    */
  1226.  
  1227.     color = 1 + random( MaxColors-1 );    /* Get a random color # (no blk)*/
  1228.     setfillstyle( random(10), color );    /* Set a random line style    */
  1229.     setcolor( color );            /* Set the desired color    */
  1230.  
  1231.     for( i=0 ; i<(MaxPts-1) ; i++ ){    /* Determine a random polygon    */
  1232.       poly[i].x = random( MaxX );    /* Set the x coord of point    */
  1233.       poly[i].y = random( MaxY );    /* Set the y coord of point    */
  1234.     }
  1235.  
  1236.     poly[i].x = poly[0].x;        /* last point = first point    */
  1237.     poly[i].y = poly[1].y;
  1238.  
  1239.     fillpoly( MaxPts, (int far *)poly );    /* Draw the actual polygon        */
  1240.   }                    /* End of WHILE not KBHIT    */
  1241.  
  1242.   Pause();                /* Wait for user's response     */
  1243.  
  1244. }
  1245.  
  1246.  
  1247. /*                                    */
  1248. /*    SAYGOODBYE: Give a closing screen to the user before leaving.    */
  1249. /*                                    */
  1250.  
  1251. void SayGoodbye(void)
  1252. {
  1253.   struct viewporttype viewinfo;     /* Structure to read viewport    */
  1254.   int h, w;
  1255.  
  1256.   MainWindow( "== Finale ==" );
  1257.  
  1258.   getviewsettings( &viewinfo );     /* Read viewport settings    */
  1259.   changetextstyle( TRIPLEX_FONT, HORIZ_DIR, 4 );
  1260.   settextjustify( CENTER_TEXT, CENTER_TEXT );
  1261.  
  1262.   h = viewinfo.bottom - viewinfo.top;
  1263.   w = viewinfo.right  - viewinfo.left;
  1264.   outtextxy( w/2, h/2, "That's all, folks!" );
  1265.  
  1266.   StatusLine( "Press any key to EXIT" );
  1267.   getch();
  1268.  
  1269.   cleardevice();            /* Clear the graphics screen    */
  1270.  
  1271. }
  1272.  
  1273. /*                                    */
  1274. /*    PAUSE: Pause until the user enters a keystroke. If the        */
  1275. /*    key is an ESC, then exit program, else simply return.        */
  1276. /*                                    */
  1277.  
  1278. void Pause(void)
  1279. {
  1280.   static char msg[] = "Esc aborts or press a key...";
  1281.   int c;
  1282.  
  1283.   StatusLine( msg );            /* Put msg at bottom of screen    */
  1284.  
  1285.   c = getch();                /* Read a character from kbd    */
  1286.  
  1287.   if( ESC == c ){            /* Does user wish to leave?    */
  1288.     closegraph();            /* Change to text mode        */
  1289.     exit( 1 );                /* Return to OS         */
  1290.   }
  1291.  
  1292.   if( 0 == c ){             /* Did use hit a non-ASCII key? */
  1293.     c = getch();            /* Read scan code for keyboard    */
  1294.   }
  1295.  
  1296.   cleardevice();            /* Clear the screen        */
  1297.  
  1298. }
  1299.  
  1300. /*                                    */
  1301. /*    MAINWINDOW: Establish the main window for the demo and set    */
  1302. /*    a viewport for the demo code.                    */
  1303. /*                                    */
  1304.  
  1305. void MainWindow( char *header )
  1306. {
  1307.   int height;
  1308.  
  1309.   cleardevice();            /* Clear graphics screen    */
  1310.   setcolor( MaxColors - 1 );        /* Set current color to white    */
  1311.   setviewport( 0, 0, MaxX, MaxY, 1 );    /* Open port to full screen    */
  1312.  
  1313.   height = textheight( "H" );           /* Get basic text height        */
  1314.  
  1315.   changetextstyle( DEFAULT_FONT, HORIZ_DIR, 1 );
  1316.   settextjustify( CENTER_TEXT, TOP_TEXT );
  1317.   outtextxy( MaxX/2, 2, header );
  1318.   setviewport( 0, height+4, MaxX, MaxY-(height+4), 1 );
  1319.   DrawBorder();
  1320.   setviewport( 1, height+5, MaxX-1, MaxY-(height+5), 1 );
  1321.  
  1322. }
  1323.  
  1324. /*                                    */
  1325. /*    STATUSLINE: Display a status line at the bottom of the screen.    */
  1326. /*                                    */
  1327.  
  1328. void StatusLine( char *msg )
  1329. {
  1330.   int height;
  1331.  
  1332.   setviewport( 0, 0, MaxX, MaxY, 1 );    /* Open port to full screen    */
  1333.   setcolor( MaxColors - 1 );        /* Set current color to white    */
  1334.  
  1335.   changetextstyle( DEFAULT_FONT, HORIZ_DIR, 1 );
  1336.   settextjustify( CENTER_TEXT, TOP_TEXT );
  1337.   setlinestyle( SOLID_LINE, 0, NORM_WIDTH );
  1338.   setfillstyle( EMPTY_FILL, 0 );
  1339.  
  1340.   height = textheight( "H" );           /* Detemine current height      */
  1341.   bar( 0, MaxY-(height+4), MaxX, MaxY );
  1342.   rectangle( 0, MaxY-(height+4), MaxX, MaxY );
  1343.   outtextxy( MaxX/2, MaxY-(height+2), msg );
  1344.   setviewport( 1, height+5, MaxX-1, MaxY-(height+5), 1 );
  1345.  
  1346. }
  1347.  
  1348. /*                                    */
  1349. /*    DRAWBORDER: Draw a solid single line around the current     */
  1350. /*    viewport.                            */
  1351. /*                                    */
  1352.  
  1353. void DrawBorder(void)
  1354. {
  1355.   struct viewporttype vp;
  1356.  
  1357.   setcolor( MaxColors - 1 );        /* Set current color to white    */
  1358.  
  1359.   setlinestyle( SOLID_LINE, 0, NORM_WIDTH );
  1360.  
  1361.   getviewsettings( &vp );
  1362.   rectangle( 0, 0, vp.right-vp.left, vp.bottom-vp.top );
  1363.  
  1364. }
  1365.  
  1366. /*                                    */
  1367. /*    CHANGETEXTSTYLE: similar to settextstyle, but checks for    */
  1368. /*    errors that might occur whil loading the font file.        */
  1369. /*                                    */
  1370.  
  1371. void changetextstyle(int font, int direction, int charsize)
  1372. {
  1373.   int ErrorCode;
  1374.  
  1375.   graphresult();            /* clear error code        */
  1376.   settextstyle(font, direction, charsize);
  1377.   ErrorCode = graphresult();        /* check result         */
  1378.   if( ErrorCode != grOk ){        /* if error occured        */
  1379.     closegraph();
  1380.     printf(" Graphics System Error: %s\n", grapherrormsg( ErrorCode ) );
  1381.     exit( 1 );
  1382.   }
  1383. }
  1384.  
  1385. /*                                    */
  1386. /*    GPRINTF: Used like PRINTF except the output is sent to the    */
  1387. /*    screen in graphics mode at the specified co-ordinate.        */
  1388. /*                                    */
  1389.  
  1390. int gprintf( int *xloc, int *yloc, char *fmt, ... )
  1391. {
  1392.   va_list  argptr;            /* Argument list pointer    */
  1393.   char str[140];            /* Buffer to build sting into    */
  1394.   int cnt;                /* Result of SPRINTF for return */
  1395.  
  1396.   va_start( argptr, fmt );        /* Initialize va_ functions    */
  1397.  
  1398.   cnt = vsprintf( str, fmt, argptr );    /* prints string to buffer    */
  1399.   outtextxy( *xloc, *yloc, str );    /* Send string in graphics mode */
  1400.   *yloc += textheight( "H" ) + 2;       /* Advance to next line         */
  1401.  
  1402.   va_end( argptr );            /* Close va_ functions        */
  1403.  
  1404.   return( cnt );            /* Return the conversion count    */
  1405.  
  1406. }
  1407.