开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 操作系统开发 > 查看源码
BGIDEMO.C
资源名称：ertos.rar　[点击查看]
上传用户：sunrenlu
上传日期：2022-06-13
资源大小：1419k
文件大小：39k
源码类别：

操作系统开发

开发平台：

DOS

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