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