回复：看来还不错，继续发挥专业知识。

 }

 int isFull() const
 {
 return array.isFull();
 }

 void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
 {
 array.forEach( f, args );
 }

 Object _FAR &firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
 void _FAR *args
 ) const
 {
 return ptrToRef(array.firstThat( f, args ));
 }

 Object _FAR &lastThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
 void _FAR *args
 ) const
 {
 return ptrToRef(array.lastThat( f, args ));
 }

 int getItemsInContainer() const
 {
 return array.getItemsInContainer();
 }

 virtual classType isA() const
 {
 return arrayClass;
 }

 virtual char _FAR *nameOf() const
 {
 return "BI_TCArrayAsVector";
 }

 int ownsElements()
 {
 return array.ownsElements();
 }

 void ownsElements( int del )
 {
 array.ownsElements( del );
 }

 ContainerIterator _FAR &initIterator() const;

private:

 BI_OArrayAsVector array;

};

class _CLASSTYPE BI_TCArrayAsVectorIterator : public ContainerIterator
{

public:

 BI_TCArrayAsVectorIterator( const BI_TCArrayAsVector _FAR &a ) :
 iter(a.array)
 {
 }

 virtual operator int()
 {
 return int(iter);
 }

 virtual Object _FAR & current()
 {
 return Object::ptrToRef(iter.current());
 }

 virtual Object _FAR & operator ++ ( int )
 {
 return Object::ptrToRef(iter++);
 }

 virtual Object _FAR & operator ++ ()
 {
 return Object::ptrToRef(++iter);
 }

 virtual void restart()
 {
 iter.restart();
 }

private:

 BI_OArrayAsVectorIterator iter;

};

inline ContainerIterator _FAR & BI_TCArrayAsVector::initIterator() const
 { return *new BI_TCArrayAsVectorIterator( *this ); }

/*------------------------------------------------------------------------*/
/* */
/* template <class T> class BI_SArrayAsVector */
/* */
/* Implements a sorted array of objects of type T, using a vector as */
/* the underlying implementation. */
/* */
/*------------------------------------------------------------------------*/

template <class T> class _CLASSTYPE BI_SArrayAsVector :
 public BI_ArrayAsVectorImp<BI_SVectorImp<T>,T>
{

public:

 friend class _CLASSTYPE BI_SArrayAsVectorIterator<T>;

 BI_SArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
 BI_ArrayAsVectorImp<BI_SVectorImp<T>,T>( upper, lower, delta )
 {
 }

 T& operator []( int loc )
 {
 grow( loc );
 return data[zeroBase(loc)];
 }

 T& operator []( int loc ) const
 {
 PRECONDITION( loc >= lowerbound && loc < data.count() );
 return data[zeroBase(loc)];
 }

 void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
 {
 if( !isEmpty() )
 data.forEach( f, args );
 }

 T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *),
 void _FAR *args
 ) const
 {
 if( isEmpty() )
 return 0;
 return data.firstThat( f, args );
 }

 T _FAR *lastThat( int (_FAR * f)(const T _FAR &, void _FAR *),
 void _FAR *args
 ) const
 {
 if( isEmpty() )
 return 0;
 return data.lastThat( f, args );
 }

};

template <class T> class _CLASSTYPE BI_SArrayAsVectorIterator :


 BI_VectorIteratorImp<T>
{

public:

 BI_SArrayAsVectorIterator( const BI_SArrayAsVector<T> _FAR & a ) :
 BI_VectorIteratorImp<T>(a.data) {}

};

/*------------------------------------------------------------------------*/
/* */
/* template <class T> class BI_ISArrayAsVector */
/* */
/* Implements an indirect sorted array of objects of type T, using a */
/* vector as the underlying implementation. */
/* */
/*------------------------------------------------------------------------*/

template <class T> class _CLASSTYPE BI_ISArrayAsVector :
 public BI_ArrayAsVectorImp<BI_ISVectorImp<T>,T _FAR *>,
 public virtual TShouldDelete
{

public:

 friend class _CLASSTYPE BI_ISArrayAsVectorIterator<T>;

 BI_ISArrayAsVector( int upper, int lower = 0, int delta = 0 ) :
 BI_ArrayAsVectorImp<BI_ISVectorImp<T>,T _FAR*>( upper, lower, delta )
 {
 }

 ~BI_ISArrayAsVector()
 {
 flush();
 }

 T _FAR * _FAR & operator []( int loc )
 {
 grow( loc );
 return data[zeroBase(loc)];
 }

 T _FAR * _FAR & operator []( int loc ) const
 {
 PRECONDITION( loc >= lowerbound && loc < data.count() );
 return data[zeroBase(loc)];
 }

 void add( T _FAR *t )
 {
 BI_ArrayAsVectorImp<BI_ISVectorImp<T>,T _FAR *>::add(t);
 }

 void addAt( T _FAR *t, int loc )
 {
 BI_ArrayAsVectorImp<BI_ISVectorImp<T>,T _FAR *>::addAt(t,loc);
 }

 void detach( int loc, DeleteType dt = NoDelete )
 {
 data.detach( loc, delObj(dt) );
 }

 void detach( T _FAR *t, DeleteType dt = NoDelete )
 {
 unsigned loc = data.find( t );
 if( loc == UINT_MAX )
 return;
 data.detach( loc, delObj(dt) );
 }

 void flush( DeleteType dt = DefDelete )
 {
 data.flush( delObj(dt), data.limit(), 0 );
 }

 int find( const T *t ) const
 {
 return data.find( (T *)t );
 }

 void forEach( void (_FAR *f)(T _FAR &, void _FAR *), void _FAR *args )
 {
 if( !isEmpty() )
 data.forEach( f, args );
 }

 T _FAR *firstThat( int (_FAR *f)(const T _FAR &, void _FAR *),
 void _FAR *args
 ) const
 {
 if( isEmpty() )
 return 0;
 return data.firstThat( f, args );
 }

 T _FAR *lastThat( int (_FAR * f)(const T _FAR &, void _FAR *),
 void _FAR *args
 ) const
 {
 if( isEmpty() )
 return 0;
 return data.lastThat( f, args );
 }

};

template <class T> class _CLASSTYPE BI_ISArrayAsVectorIterator :
 public BI_IVectorIteratorImp<T>
{

public:

 BI_ISArrayAsVectorIterator( const BI_ISArrayAsVector<T> _FAR &a ) :
 BI_IVectorIteratorImp<T>(a.data) {}

};

/*------------------------------------------------------------------------*/
/* */
/* class BI_ISObjectVector */
/* */
/* Implements a sorted vector of pointers to Object. */
/* This is implemented through the template BI_ISVectorImp<Object>. */
/* */
/*------------------------------------------------------------------------*/

class _CLASSTYPE BI_ISObjectVector :
 public BI_InternalICVectorImp<Object, BI_SVectorImp<void _FAR *> >
{

public:

 BI_ISObjectVector( unsigned sz, unsigned d = 0 ) :
 BI_InternalICVectorImp<Object, BI_SVectorImp<void _FAR *> >(sz)


 {
 delta = d;
 }

 ~BI_ISObjectVector()
 {
 flush();
 }

 void add( Object _FAR *o );

 void addAt( Object _FAR *t, unsigned loc )
 {
 BI_InternalICVectorImp<Object, BI_SVectorImp<void _FAR *> >::addAt(t,loc);
 }

 void detach( unsigned loc, int del = 0 )
 {
 BI_InternalICVectorImp<Object, BI_SVectorImp<void _FAR *> >::detach( loc, del );
 }

 void detach( Object _FAR *t, int del = 0 )
 {
 unsigned loc = find( t );
 if( loc == UINT_MAX )
 return;
 BI_InternalICVectorImp<Object, BI_SVectorImp<void _FAR *> >::detach( loc, del );
 }

 void flush( int del = 0 )
 {
 BI_InternalICVectorImp<Object, BI_SVectorImp<void _FAR *> >::flush( del );
 }

 unsigned find( Object _FAR *t ) const
 {
 return find( (void _FAR *)t );
 }

protected:

 unsigned find( void _FAR *t ) const;

};

class _CLASSTYPE BI_ISObjectVectorIterator :
 public BI_IVectorIteratorImp<Object>
{

public:

 BI_ISObjectVectorIterator( const BI_ISObjectVector _FAR &a ) :
 BI_IVectorIteratorImp<Object>(a) {}

};

/*------------------------------------------------------------------------*/
/* */
/* class BI_ISObjectArray */
/* */
/* Implements an indirect sorted array of pointers to Object, using a */
/* vector as the underlying implementation. */
/* */
/*------------------------------------------------------------------------*/

class _CLASSTYPE BI_ISObjectArray :
 public BI_ArrayAsVectorImp<BI_ISObjectVector,Object _FAR *>,
 public virtual TShouldDelete
{

public:

 friend class _CLASSTYPE BI_ISObjectArrayIterator;

 BI_ISObjectArray( int upr, int lwr = 0, int delta = 0 ) :
 BI_ArrayAsVectorImp<BI_ISObjectVector,Object _FAR*>( upr, lwr, delta )
 {
 }

 ~BI_ISObjectArray()
 {
 flush();
 }

 Object _FAR * _FAR & operator []( int loc )
 {
 grow( loc );
 return data[zeroBase(loc)];
 }

 Object _FAR * _FAR & operator []( int loc ) const
 {
 PRECONDITION( loc >= lowerbound && zeroBase(loc) < data.count() );
 return data[zeroBase(loc)];
 }

 void add( Object _FAR *t )
 {
 BI_ArrayAsVectorImp<BI_ISObjectVector,Object _FAR *>::add(t);
 }

 void addAt( Object _FAR *t, int loc )
 {
 BI_ArrayAsVectorImp<BI_ISObjectVector,Object _FAR *>::addAt(t,loc);
 }

 void detach( int loc, DeleteType dt = NoDelete )
 {
 data.detach( zeroBase(loc), delObj(dt) );
 }

 void detach( Object _FAR *t, DeleteType dt = NoDelete )
 {
 data.detach( t, delObj(dt) );
 }

 void flush( DeleteType dt = DefDelete )
 {
 data.flush( delObj(dt) );
 }

 int find( const Object *t ) const
 {
 return boundBase(data.find( (Object *)t ));
 }

 void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
 {
 if( !isEmpty() )
 data.forEach( f, args );
 }

 Object _FAR *firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
 void _FAR *args
 ) const
 {
 if( isEmpty() )
 return 0;
 return data.firstThat( f, args );
 }

 Object _FAR *lastThat( int (_FAR * f)(const Object _FAR &, void _FAR *),
 void _FAR *args
 ) const
 {
 if( isEmpty() )
 return 0;
 return data.lastThat( f, args );


 }

};

class _CLASSTYPE BI_ISObjectArrayIterator :
 public BI_ISObjectVectorIterator
{

public:

 BI_ISObjectArrayIterator( const BI_ISObjectArray _FAR &a ) :
 BI_ISObjectVectorIterator(a.data) {}

};

/*------------------------------------------------------------------------*/
/* */
/* class BI_OSArrayAsVector */
/* */
/* Implements a sorted array of pointers to Object, */
/* using a vector as the underlying implementation. */
/* */
/* Although the interface is written to take pointers to Object, in */
/* fact, pointers to Sortable are required. */
/* */
/*------------------------------------------------------------------------*/

class _CLASSTYPE BI_OSArrayAsVector
{

public:

 friend class _CLASSTYPE BI_OSArrayAsVectorIterator;

 BI_OSArrayAsVector() : oarray( DEFAULT_ARRAY_SIZE, 0, 0 )
 {
 }

 BI_OSArrayAsVector( int upr, int lwr = 0, unsigned delta = 0 ) :
 oarray( upr, lwr, delta )
 {
 }

 Object *operator [] (int loc)
 {
 return oarray[loc];
 }

 Object *operator [] (int loc) const
 {
 return oarray[loc];
 }

 int lowerBound() const
 {
 return oarray.lowerBound();
 }

 int upperBound() const
 {
 return oarray.upperBound();
 }

 sizeType arraySize() const
 {
 return oarray.arraySize();
 }

 void add( Object _FAR *o )
 {
 PRECONDITION( o->isSortable() );
 oarray.add(o);
 }

 void addAt( Object _FAR *o, int loc )
 {
 PRECONDITION( o->isSortable() );
 oarray.addAt(o,loc);
 }

 void detach( int loc,
 TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
 )
 {
 oarray.detach( loc, dt );
 }

 void detach( Object _FAR *o,
 TShouldDelete::DeleteType dt = TShouldDelete::NoDelete
 )
 {
 PRECONDITION( o->isSortable() );
 oarray.detach( o, dt );
 }

 void flush( TShouldDelete::DeleteType dt = TShouldDelete::DefDelete )
 {
 oarray.flush( dt );
 }

 int hasMember( Object _FAR *o ) const
 {
 PRECONDITION( o->isSortable() );
 return oarray.hasMember(o);
 }

 Object _FAR *findMember( Object _FAR *o ) const
 {
 PRECONDITION( o->isSortable() );
 int loc = oarray.find(o);
 return loc != INT_MAX ? oarray[loc] : 0;
 }

 int isEmpty() const
 {
 return oarray.isEmpty();
 }

 int isFull() const
 {
 return oarray.isFull();
 }

 void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
 {
 oarray.forEach( f, args );
 }

 Object _FAR *firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
 void _FAR *args
 ) const
 {
 return oarray.firstThat( f, args );
 }

 Object _FAR *lastThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
 void _FAR *args
 ) const
 {
 return oarray.lastThat( f, args );
 }

 int getItemsInContainer() const
 {
 return oarray.getItemsInContainer();
 }

 int ownsElements()
 {
 return oarray.ownsElements();
 }

 void ownsElements( int del )
 {
 oarray.ownsElements( del );
 }

protected:

 BI_ISObjectArray oarray;

};

class _CLASSTYPE BI_OSArrayAsVectorIterator :
 public BI_ISObjectArrayIterator
{

public:

 BI_OSArrayAsVectorIterator( const BI_OSArrayAsVector _FAR &a ) :


 BI_ISObjectArrayIterator(a.oarray)
 {
 }

};

/*------------------------------------------------------------------------*/
/* */
/* class BI_TCSArrayAsVector */
/* */
/* Implements a sorted Object array, with the full semantics of */
/* the BC 2.0 style sorted array, using a vector as the underlying */
/* implementation. */
/* */
/*------------------------------------------------------------------------*/

class _CLASSTYPE BI_TCSArrayAsVector : public AbstractArray
{

public:

 friend class _CLASSTYPE BI_TCSArrayAsVectorIterator;

 BI_TCSArrayAsVector( int upper = DEFAULT_ARRAY_SIZE,
 int lower = 0,
 sizeType delta = 0
 ) :
 array( upper, lower, delta )
 {
 }

 virtual Object& operator []( int loc )
 {
 return ptrToRef(array[loc]);
 }

 virtual Object& operator []( int loc ) const
 {
 return ptrToRef(array[loc]);
 }

 virtual int lowerBound() const
 {
 return array.lowerBound();
 }

 virtual int upperBound() const
 {
 return array.upperBound();
 }

 virtual sizeType arraySize() const
 {
 return array.arraySize();
 }

 void add( Object _FAR &o )
 {
 array.add(&o);
 }

 void addAt( Object _FAR &o, int loc )
 {
 array.addAt(&o,loc);
 }

 virtual void detach( int loc, DeleteType dt = NoDelete )
 {
 array.detach( loc, dt );
 }

 void detach( Object _FAR &o, DeleteType dt = NoDelete )
 {
 array.detach( &o, dt );
 }

 void flush( TShouldDelete::DeleteType dt = DefDelete )
 {
 array.flush( dt );
 }

 int hasMember( Object _FAR &o ) const
 {
 return array.hasMember(&o);
 }

 Object _FAR &findMember( Object _FAR &o ) const
 {
 return ptrToRef(array.findMember(&o));
 }

 int isEmpty() const
 {
 return array.isEmpty();
 }

 int isFull() const
 {
 return array.isFull();
 }

 void forEach( void (_FAR*f)(Object _FAR &, void _FAR*), void _FAR*args )
 {
 array.forEach( f, args );
 }

 Object _FAR &firstThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
 void _FAR *args
 ) const
 {
 return ptrToRef(array.firstThat( f, args ));
 }

 Object _FAR &lastThat( int (_FAR *f)(const Object _FAR &, void _FAR *),
 void _FAR *args
 ) const
 {
 return ptrToRef(array.lastThat( f, args ));
 }

 int getItemsInContainer() const
 {
 return array.getItemsInContainer();
 }

 virtual classType isA() const
 {
 return sortedArrayClass;
 }

 virtual char _FAR *nameOf() const
 {
 return "BI_TCSArrayAsVector";
 }

 int ownsElements()
 {
 return array.ownsElements();
 }

 void ownsElements( int del )
 {
 array.ownsElements( del );
 }

 ContainerIterator _FAR & initIterator() const;

private:

 BI_OSArrayAsVector array;

};

class _CLASSTYPE BI_TCSArrayAsVectorIterator : public ContainerIterator
{

public:

 BI_TCSArrayAsVectorIterator( const BI_TCSArrayAsVector _FAR &a ) :
 iter(a.array)
 {
 }

 virtual operator int()
 {
 return int(iter);
 }

 virtual Object _FAR & current()
 {
 return Object::ptrToRef(iter.current());
 }

 virtual Object _FAR & operator ++ ( int )
 {
 return Object::ptrToRef(iter++);
 }

 virtual Object _FAR & operator ++ ()
 {
 return Object::ptrToRef(++iter);
 }

 virtual void restart()
 {
 iter.restart();
 }

private:

 BI_OSArrayAsVectorIterator iter;

};

inline ContainerIterator _FAR & BI_TCSArrayAsVector::initIterator() const
 {
 return *new BI_TCSArrayAsVectorIterator( *this );
 }

#pragma warn .ncf

#endif // __ARRAYS_H

/*
 GRAPHICS DEMO FOR Borland C++ 3.0

 Copyright © 1987,88,91 Borland International. All rights reserved.

 From the command line, use:

bcc bgidemo graphics.lib

*/

#ifdef __TINY__
#error BGIDEMO will not run in the tiny model.
#endif

#include <dos.h>
#include <math.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#include <stdarg.h>

#include <graphics.h>

#define ESC 0x1b /* Define the escape key */
#define TRUE 1 /* Define some handy constants */
#define FALSE 0 /* Define some handy constants */
#define PI 3.14159  /* Define a value for PI */
#define ON 1 /* Define some handy constants */
#define OFF 0 /* Define some handy constants */

#define NFONTS 11

char *Fonts[NFONTS] = {
 "DefaultFont", "TriplexFont", "SmallFont",
 "SansSerifFont", "GothicFont", "ScriptFont", "SimplexFont", "TriplexScriptFont",
 "ComplexFont", "EuropeanFont", "BoldFont"
};

char *LineStyles[] = {
 "SolidLn", "DottedLn", "CenterLn", "DashedLn", "UserBitLn"
};

char *FillStyles[] = {
 "EmptyFill", "SolidFill", "LineFill", "LtSlashFill",
 "SlashFill", "BkSlashFill", "LtBkSlashFill", "HatchFill",
 "XHatchFill", "InterleaveFill", "WideDotFill", "CloseDotFill"
};

char *TextDirect[] = {
 "HorizDir", "VertDir"
};

char *HorizJust[] = {
 "LeftText", "CenterText", "RightText"
};

char *VertJust[] = {
 "BottomText", "CenterText", "TopText"
};

struct PTS {
 int x, y;
}; /* Structure to hold vertex points */

int GraphDriver; /* The Graphics device driver */
int GraphMode; /* The Graphics mode value */
double AspectRatio; /* Aspect ratio of a pixel on the screen*/
int MaxX, MaxY; /* The maximum resolution of the screen */
int MaxColors; /* The maximum # of colors available */
int ErrorCode; /* Reports any graphics errors */
struct palettetype palette; /* Used to read palette info */

/* */
/* Function prototypes */
/* */

void Initialize(void);
void ReportStatus(void);
void TextDump(void);
void Bar3DDemo(void);
void RandomBars(void);
void TextDemo(void);
void ColorDemo(void);
void ArcDemo(void);
void CircleDemo(void);
void PieDemo(void);
void BarDemo(void);
void LineRelDemo(void);
void PutPixelDemo(void);
void PutImageDemo(void);
void LineToDemo(void);
void LineStyleDemo(void);
void CRTModeDemo(void);
void UserLineStyleDemo(void);
void FillStyleDemo(void);
void FillPatternDemo(void);
void PaletteDemo(void);
void PolyDemo(void);
void SayGoodbye(void);
void Pause(void);
void MainWindow(char *header);
void StatusLine(char *msg);
void DrawBorder(void);
void changetextstyle(int font, int direction, int charsize);
int gprintf(int *xloc, int *yloc, char *fmt, ... );

/* */
/* Begin main function */
/* */

int main()
{

 Initialize();  /* Set system into Graphics mode */
 ReportStatus(); /* Report results of the initialization */

 ColorDemo(); /* Begin actual demonstration */
 if( GraphDriver==EGA || GraphDriver==EGALO || GraphDriver==VGA )
 PaletteDemo();


 PutPixelDemo();
 PutImageDemo();
 Bar3DDemo();
 BarDemo();
 RandomBars();
 ArcDemo();
 CircleDemo();
 PieDemo();
 LineRelDemo();
 LineToDemo();
 LineStyleDemo();
 UserLineStyleDemo();
 TextDump();
 TextDemo();
 CRTModeDemo();
 FillStyleDemo();
 FillPatternDemo();
 PolyDemo();
 SayGoodbye();  /* Give user the closing screen  */

 closegraph();  /* Return the system to text mode */
 return(0);
}

/* */
/* INITIALIZE: Initializes the graphics system and reports  */
/* any errors which occured. */
/* */

void Initialize(void)
{
 int xasp, yasp; /* Used to read the aspect ratio*/

 GraphDriver = DETECT;  /* Request auto-detection */
 initgraph( &GraphDriver, &GraphMode, "" );
 ErrorCode = graphresult(); /* Read result of initialization*/
 if( ErrorCode != grOk ){ /* Error occured during init */
 printf(" Graphics System Error: %s\n", grapherrormsg( ErrorCode ) );
 exit( 1 );
 }

 getpalette( &palette ); /* Read the palette from board */
 MaxColors = getmaxcolor() + 1; /* Read maximum number of colors*/

 MaxX = getmaxx();
 MaxY = getmaxy(); /* Read size of screen */

 getaspectratio( &xasp, &yasp ); /* read the hardware aspect */
 AspectRatio = (double)xasp / (double)yasp; /* Get correction factor */

}

/* */
/* REPORTSTATUS: Report the current configuration of the system */
/* after the auto-detect initialization. */
/* */

void ReportStatus(void)
{
 struct viewporttype  viewinfo; /* Params for inquiry procedures*/
 struct linesettingstype lineinfo;
 struct fillsettingstype fillinfo;
 struct textsettingstype textinfo;
 struct palettetype  palette;

 char *driver, *mode; /* Strings for driver and mode */
 int x, y;

 getviewsettings( &viewinfo );
 getlinesettings( &lineinfo );
 getfillsettings( &fillinfo );
 gettextsettings( &textinfo );
 getpalette( &palette );

 x = 10;
 y = 4;

 MainWindow( "Status report after InitGraph" );
 settextjustify( LEFT_TEXT, TOP_TEXT );

 driver = getdrivername();
 mode = getmodename(GraphMode); /* get current setting */

 gprintf( &x, &y, "Graphics device : %-20s (%d)", driver, GraphDriver );
 gprintf( &x, &y, "Graphics mode : %-20s (%d)", mode, GraphMode );
 gprintf( &x, &y, "Screen resolution : ( 0, 0, %d, %d )", getmaxx(), getmaxy() );

 gprintf( &x, &y, "Current view port : ( %d, %d, %d, %d )",
 viewinfo.left, viewinfo.top, viewinfo.right, viewinfo.bottom );
 gprintf( &x, &y, "Clipping : %s", viewinfo.clip ? "ON" : "OFF" );

 gprintf( &x, &y, "Current position : ( %d, %d )", getx(), gety() );
 gprintf( &x, &y, "Colors available : %d", MaxColors );
 gprintf( &x, &y, "Current color : %d", getcolor() );

 gprintf( &x, &y, "Line style : %s", LineStyles[ lineinfo.linestyle ] );
 gprintf( &x, &y, "Line thickness : %d", lineinfo.thickness );

 gprintf( &x, &y, "Current fill style : %s", FillStyles[ fillinfo.pattern ] );
 gprintf( &x, &y, "Current fill color : %d", fillinfo.color );

 gprintf( &x, &y, "Current font : %s", Fonts[ textinfo.font ] );


 gprintf( &x, &y, "Text direction : %s", TextDirect[ textinfo.direction ] );
 gprintf( &x, &y, "Character size : %d", textinfo.charsize );
 gprintf( &x, &y, "Horizontal justify : %s", HorizJust[ textinfo.horiz ] );
 gprintf( &x, &y, "Vertical justify : %s", VertJust[ textinfo.vert ] );

 Pause(); /* Pause for user to read screen*/

}

/* */
/* TEXTDUMP: Display the all the characters in each of the  */
/* available fonts. */
/* */

void TextDump()
{
 static int CGASizes[] = {
 1, 3, 7, 3, 3, 2, 2, 2, 2, 2, 2 };
 static int NormSizes[] = {
 1, 4, 7, 4, 4, 2, 2, 2, 2, 2, 2 };

 char buffer[80];
 int font, ch, wwidth, lwidth, size;
 struct viewporttype vp;

 for( font=0 ; font<NFONTS ; ++font ){ /* For each available font */
 sprintf( buffer, "%s Character Set", Fonts[font] );
 MainWindow( buffer ); /* Display fontname as banner */
 getviewsettings( &vp ); /* read current viewport */

 settextjustify( LEFT_TEXT, TOP_TEXT );
 moveto( 2, 3 );

 buffer[1] = '\0'; /* Terminate string */
 wwidth = vp.right - vp.left; /* Determine the window width */
 lwidth = textwidth( "H" ); /* Get average letter width */

 if( font == DEFAULT_FONT ){
 changetextstyle( font, HORIZ_DIR, 1 );
 ch = 0;
 while( ch < 256 ){ /* For each possible character */
buffer[0] = ch;  /* Put character into a string */
outtext( buffer ); /* send string to screen */
if( (getx() + lwidth) > wwidth )
 moveto( 2, gety() + textheight("H") + 3 );
++ch; /* Goto the next character */
 }
 }
 else{

 size = (MaxY < 200) ? CGASizes[font] : NormSizes[font];
 changetextstyle( font, HORIZ_DIR, size );

 ch = '!'; /* Begin at 1st printable */
 while( ch < 256 ){ /* For each printable character */
buffer[0] = ch;  /* Put character into a string */
outtext( buffer ); /* send string to screen */
if( (lwidth+getx()) > wwidth ) /* Are we still in window? */
 moveto( 2, gety()+textheight("H")+3 );
++ch; /* Goto the next character */
 }

 }

 Pause(); /* Pause until user acks */

 } /* End of FONT loop */

}

/* */
/* BAR3DDEMO: Display a 3-D bar chart on the screen. */
/* */

void Bar3DDemo(void)
{
 static int barheight[] = {
 1, 3, 5, 4, 3, 2, 1, 5, 4, 2, 3 };
 struct viewporttype vp;
 int xstep, ystep;
 int i, j, h, color, bheight;
 char buffer[10];

 MainWindow( "Bar 3-D / Rectangle Demonstration" );

 h = 3 * textheight( "H" );
 getviewsettings( &vp );
 settextjustify( CENTER_TEXT, TOP_TEXT );
 changetextstyle( TRIPLEX_FONT, HORIZ_DIR, 4 );
 outtextxy( MaxX/2, 6, "These are 3-D Bars" );
 changetextstyle( DEFAULT_FONT, HORIZ_DIR, 1 );
 setviewport( vp.left+50, vp.top+40, vp.right-50, vp.bottom-10, 1 );
 getviewsettings( &vp );

 line( h, h, h, vp.bottom-vp.top-h );
 line( h, (vp.bottom-vp.top)-h, (vp.right-vp.left)-h, (vp.bottom-vp.top)-h );
 xstep = ((vp.right-vp.left) - (2*h)) / 10;
 ystep = ((vp.bottom-vp.top) - (2*h)) / 5;
 j = (vp.bottom-vp.top) - h;
 settextjustify( CENTER_TEXT, CENTER_TEXT );

 for( i=0 ; i<6 ; ++i ){


 line( h/2, j, h, j );
 itoa( i, buffer, 10 );
 outtextxy( 0, j, buffer );
 j -= ystep;
 }

 j = h;
 settextjustify( CENTER_TEXT, TOP_TEXT );

 for( i=0 ; i<11 ; ++i ){
 color = random( MaxColors );
 setfillstyle( i+1, color );
 line( j, (vp.bottom-vp.top)-h, j, (vp.bottom-vp.top-3)-(h/2) );
 itoa( i, buffer, 10 );
 outtextxy( j, (vp.bottom-vp.top)-(h/2), buffer );
 if( i != 10 ){
 bheight = (vp.bottom-vp.top) - h - 1;
 bar3d( j, (vp.bottom-vp.top-h)-(barheight[i]*ystep), j+xstep, bheight, 15, 1 );
 }
 j += xstep;
 }

 Pause(); /* Pause for user's response */

}

/* */
/* RANDOMBARS: Display random bars  */
/* */

void RandomBars(void)
{
 int color;

 MainWindow( "Random Bars" );
 StatusLine( "Esc aborts or press a key..." ); /* Put msg at bottom of screen */
 while( !kbhit() ){ /* Until user enters a key... */
 color = random( MaxColors-1 )+1;
 setcolor( color );
 setfillstyle( random(11)+1, color );
 bar3d( random( getmaxx() ), random( getmaxy() ),
 random( getmaxx() ), random( getmaxy() ), 0, OFF);
 }

 Pause(); /* Pause for user's response */

}


/* */
/* TEXTDEMO: Show each font in several sizes to the user. */
/* */

void TextDemo(void)
{
 int charsize[] = {
 1, 3, 7, 3, 4, 2, 2, 2, 2, 2, 2 };
 int font, size;
 int h, x, y, i;
 struct viewporttype vp;
 char buffer[80];

 for( font=0 ; font<NFONTS ; ++font ){ /* For each of the avail. fonts */

 sprintf( buffer, "%s Demonstration", Fonts[font] );
 MainWindow( buffer );
 getviewsettings( &vp );

 changetextstyle( font, VERT_DIR, charsize[font] );
 settextjustify( CENTER_TEXT, BOTTOM_TEXT );
 outtextxy( 2*textwidth("M"), vp.bottom - 2*textheight("M"), "Vertical" );

 changetextstyle( font, HORIZ_DIR, charsize[font] );
 settextjustify( LEFT_TEXT, TOP_TEXT );
 outtextxy( 2*textwidth("M"), 2, "Horizontal" );

 settextjustify( CENTER_TEXT, CENTER_TEXT );
 x = (vp.right - vp.left) / 2;
 y = textheight( "H" );

 for( i=1 ; i<5 ; ++i ){ /* For each of the sizes */
 size = (font == SMALL_FONT) ? i+3 : i;
 changetextstyle( font, HORIZ_DIR, size );
 h = textheight( "H" );
 y += h;
 sprintf( buffer, "Size %d", size );
 outtextxy( x, y, buffer );

 }

 if( font != DEFAULT_FONT ){  /* Show user declared font size */
 y += h / 2; /* Move down the screen  */
 settextjustify( CENTER_TEXT, TOP_TEXT );
 setusercharsize( 5, 6, 3, 2 );
 changetextstyle( font, HORIZ_DIR, USER_CHAR_SIZE );
 outtextxy( (vp.right-vp.left)/2, y, "User Defined Size" );
 }

 Pause(); /* Pause to let user look */

 } /* End of FONT loop */

}

/* */
/* COLORDEMO: Display the current color palette on the screen. */
/* */

void ColorDemo(void)
{
 struct viewporttype vp;
 int color, height, width;
 int x, y, i, j;
 char cnum[5];

 MainWindow( "Color Demonstration" ); /* Show demonstration name */

 color = 1;
 getviewsettings( &vp ); /* Get the current window size */
 width = 2 * ( (vp.right+1) / 16 );  /* Get box dimensions  */


 height = 2 * ( (vp.bottom-10) / 10 );

 x = width / 2;
 y = height / 2; /* Leave 1/2 box border  */

 for( j=0 ; j<3 ; ++j ){ /* Row loop */

 for( i=0 ; i<5 ; ++i ){ /* Column loop */

 setfillstyle(SOLID_FILL, color); /* Set to solid fill in color */
 setcolor( color ); /* Set the same border color */

 bar( x, y, x+width, y+height ); /* Draw the rectangle */
 rectangle( x, y, x+width, y+height ); /* outline the rectangle */

 if( color == BLACK ){ /* If box was black... */
setcolor( WHITE ); /* Set drawing color to white */
rectangle( x, y, x+width, y+height ); /* Outline black in white*/
 }

 itoa( color, cnum, 10 ); /* Convert # to ASCII */
 outtextxy( x+(width/2), y+height+4, cnum ); /* Show color # */

 color = ++color % MaxColors; /* Advance to the next color */
 x += (width / 2) * 3; /* move the column base  */
 } /* End of Column loop */

 y += (height / 2) * 3; /* move the row base */
 x = width / 2; /* reset column base */
 } /* End of Row loop */

 Pause(); /* Pause for user's response */

}

/* */
/* ARCDEMO: Display a random pattern of arcs on the screen */
/* until the user says enough. */
/* */

void ArcDemo(void)
{
 int mradius; /* Maximum radius allowed */
 int eangle; /* Random end angle of Arc */
 struct arccoordstype ai; /* Used to read Arc Cord info */

 MainWindow( "Arc Demonstration" );
 StatusLine( "ESC Aborts - Press a Key to stop" );

 mradius = MaxY / 10; /* Determine the maximum radius */

 while( !kbhit() ){ /* Repeat until a key is hit */
 setcolor( random( MaxColors - 1 ) + 1 ); /* Randomly select a color */
 eangle = random( 358 ) + 1;  /* Select an end angle */
 arc( random(MaxX), random(MaxY), random(eangle), eangle, mradius );
 getarccoords( &ai ); /* Read Cord data */
 line( ai.x, ai.y, ai.xstart, ai.ystart ); /* line from start to center */
 line( ai.x, ai.y, ai.xend, ai.yend ); /* line from end to center */
 } /* End of WHILE not KBHIT */

 Pause(); /* Wait for user's response */

}

/* */
/* CIRCLEDEMO: Display a random pattern of circles on the screen */
/* until the user says enough. */
/* */

void CircleDemo(void)
{
 int mradius; /* Maximum radius allowed */

 MainWindow( "Circle Demonstration" );
 StatusLine( "ESC Aborts - Press a Key to stop" );

 mradius = MaxY / 10; /* Determine the maximum radius */

 while( !kbhit() ){ /* Repeat until a key is hit */
 setcolor( random( MaxColors - 1 ) + 1 ); /* Randomly select a color */
 circle( random(MaxX), random(MaxY), random(mradius) );
 } /* End of WHILE not KBHIT */

 Pause(); /* Wait for user's response */

}

/* */
/* PIEDEMO: Display a pie chart on the screen. */
/* */

#define adjasp( y ) ((int)(AspectRatio * (double)(y)))
#define torad( d ) (( (double)(d) * PI ) / 180.0 )

void PieDemo(void)
{
 struct viewporttype vp;
 int xcenter, ycenter, radius, lradius;
 int x, y;
 double radians, piesize;

 MainWindow( "Pie Chart Demonstration" );


 getviewsettings( &vp ); /* Get the current viewport */
 xcenter = (vp.right - vp.left) / 2; /* Center the Pie horizontally */
 ycenter = (vp.bottom - vp.top) / 2+20;/* Center the Pie vertically */
 radius = (vp.bottom - vp.top) / 3; /* It will cover 2/3rds screen */
 piesize = (vp.bottom - vp.top) / 4.0; /* Optimum height ratio of pie */

 while( (AspectRatio*radius) < piesize ) ++radius;

 lradius = radius + ( radius / 5 ); /* Labels placed 20% farther */

 changetextstyle( TRIPLEX_FONT, HORIZ_DIR, 4 );
 settextjustify( CENTER_TEXT, TOP_TEXT );
 outtextxy( MaxX/2, 6, "This is a Pie Chart" );
 changetextstyle( TRIPLEX_FONT, HORIZ_DIR, 1 );
 settextjustify( CENTER_TEXT, TOP_TEXT );

 setfillstyle( SOLID_FILL, RED );
 pieslice( xcenter+10, ycenter-adjasp(10), 0, 90, radius );
 radians = torad( 45 );
 x = xcenter + (int)( cos( radians ) * (double)lradius );
 y = ycenter - (int)( sin( radians ) * (double)lradius * AspectRatio );
 settextjustify( LEFT_TEXT, BOTTOM_TEXT );
 outtextxy( x, y, "25 %" );

 setfillstyle( WIDE_DOT_FILL, GREEN );
 pieslice( xcenter, ycenter, 90, 135, radius );
 radians = torad( 113 );
 x = xcenter + (int)( cos( radians ) * (double)lradius );
 y = ycenter - (int)( sin( radians ) * (double)lradius * AspectRatio );
 settextjustify( RIGHT_TEXT, BOTTOM_TEXT );
 outtextxy( x, y, "12.5 %" );

 setfillstyle( INTERLEAVE_FILL, YELLOW );
 settextjustify( RIGHT_TEXT, CENTER_TEXT );
 pieslice( xcenter-10, ycenter, 135, 225, radius );
 radians = torad( 180 );
 x = xcenter + (int)( cos( radians ) * (double)lradius );
 y = ycenter - (int)( sin( radians ) * (double)lradius * AspectRatio );
 settextjustify( RIGHT_TEXT, CENTER_TEXT );
 outtextxy( x, y, "25 %" );

 setfillstyle( HATCH_FILL, BLUE );
 pieslice( xcenter, ycenter, 225, 360, radius );
 radians = torad( 293 );
 x = xcenter + (int)( cos( radians ) * (double)lradius );
 y = ycenter - (int)( sin( radians ) * (double)lradius * AspectRatio );
 settextjustify( LEFT_TEXT, TOP_TEXT );
 outtextxy( x, y, "37.5 %" );

 Pause(); /* Pause for user's response */

}

/* */
/* BARDEMO: Draw a 2-D bar chart using Bar and Rectangle. */
/* */

void BarDemo(void)
{
 int barheight[] = {
 1, 3, 5, 2, 4 };
 int styles[]  = {
 1, 3, 10, 5, 9, 1 };
 int xstep, ystep;
 int sheight, swidth;
 int i, j, h;
 struct viewporttype vp;
 char buffer[40];

 MainWindow( "Bar / Rectangle demonstration" );
 h = 3 * textheight( "H" );
 getviewsettings( &vp );
 settextjustify( CENTER_TEXT, TOP_TEXT );
 changetextstyle( TRIPLEX_FONT, HORIZ_DIR, 4 );
 outtextxy( MaxX /2, 6, "These are 2-D Bars" );
 changetextstyle( DEFAULT_FONT, HORIZ_DIR, 1 );
 setviewport( vp.left+50, vp.top+30, vp.right-50, vp.bottom-10, 1 );

 getviewsettings( &vp );
 sheight = vp.bottom - vp.top;
 swidth = vp.right - vp.left;

 line( h, h, h, sheight-h );
 line( h, sheight-h, sheight-h, sheight-h );
 ystep = (sheight - (2*h) ) / 5;
 xstep = (swidth - (2*h) ) / 5;
 j = sheight - h;
 settextjustify( CENTER_TEXT, CENTER_TEXT );


 for( i=0 ; i<6 ; ++i ){
 line( h/2, j, h, j );
 itoa( i, buffer, 10 );
 outtextxy( 0, j, buffer );
 j -= ystep;
 }

 j = h;
 settextjustify( CENTER_TEXT, TOP_TEXT );
 for( i=0 ; i<6 ; ++i ){
 setfillstyle( styles[i], random(MaxColors) );
 line( j, sheight - h, j, sheight- 3 - (h/2) );
 itoa( i, buffer, 10 );
 outtextxy( j, sheight - (h/2), buffer );
 if( i != 5 ){
 bar( j, (sheight-h)-(barheight[i] * ystep), j+xstep, sheight-h-1 );
 rectangle( j, (sheight-h)-(barheight[i] * ystep), j+xstep, sheight-h);
 }
 j += xstep;
 }

 Pause();

}

/* */
/* LINERELDEMO: Display pattern using moverel and linerel cmds. */
/* */

void LineRelDemo(void)
{
 struct viewporttype vp;
 int h, w, dx, dy, cx, cy;
 struct PTS outs[7];


 MainWindow( "MoveRel / LineRel Demonstration" );
 StatusLine( "Press any key to continue, ESC to Abort" );

 getviewsettings( &vp );
 cx = (vp.right - vp.left) / 2; /* Center of the screen coords */
 cy = (vp.bottom - vp.top ) / 2;

 h = (vp.bottom - vp.top ) / 8;
 w = (vp.right - vp.left) / 9;

 dx = 2 * w;
 dy = 2 * h;

 setcolor( BLACK );

 setfillstyle( SOLID_FILL, BLUE );
 bar( 0, 0, vp.right-vp.left, vp.bottom-vp.top ); /* Draw backgnd */

 outs[0].x = cx - dx;
 outs[0].y = cy - dy;
 outs[1].x = cx - (dx-w);
 outs[1].y = cy - (dy+h);
 outs[2].x = cx + dx;
 outs[2].y = cy - (dy+h);
 outs[3].x = cx + dx;
 outs[3].y = cy + dy;
 outs[4].x = cx + (dx-w);
 outs[4].y = cy + (dy+h);
 outs[5].x = cx - dx;
 outs[5].y = cy + (dy+h);
 outs[6].x = cx - dx;
 outs[6].y = cy - dy;

 setfillstyle( SOLID_FILL, WHITE );
 fillpoly( 7, (int far *)outs );

 outs[0].x = cx - (w/2);
 outs[0].y = cy + h;
 outs[1].x = cx + (w/2);
 outs[1].y = cy + h;
 outs[2].x = cx + (w/2);
 outs[2].y = cy - h;
 outs[3].x = cx - (w/2);
 outs[3].y = cy - h;
 outs[4].x = cx - (w/2);
 outs[4].y = cy + h;

 setfillstyle( SOLID_FILL, BLUE );
 fillpoly( 5, (int far *)outs );

 /* Draw a Tesseract object on the screen using the LineRel and */
 /* MoveRel drawing commands. */

 moveto( cx-dx, cy-dy );
 linerel( w, -h );
 linerel( 3*w, 0 );
 linerel( 0, 5*h );
 linerel( -w, h );
 linerel( -3*w, 0 );
 linerel( 0, -5*h );

 moverel( w, -h );
 linerel( 0, 5*h );
 linerel( w+(w/2), 0 );
 linerel( 0, -3*h );
 linerel( w/2, -h );
 linerel( 0, 5*h );

 moverel( 0, -5*h );
 linerel( -(w+(w/2)), 0 );
 linerel( 0, 3*h );
 linerel( -w/2, h );

 moverel( w/2, -h );
 linerel( w, 0 );

 moverel( 0, -2*h );
 linerel( -w, 0 );

 Pause(); /* Wait for user's response */

}

/* */
/* PUTPIXELDEMO: Display a pattern of random dots on the screen */
/* and pick them back up again. */
/* */

void PutPixelDemo(void)
{
 int seed = 1958;
 int i, x, y, h, w, color;
 struct viewporttype vp;

 MainWindow( "PutPixel / GetPixel Demonstration" );

 getviewsettings( &vp );
 h = vp.bottom - vp.top;
 w = vp.right - vp.left;

 srand( seed ); /* Restart random # function */

 for( i=0 ; i<5000 ; ++i ){ /* Put 5000 pixels on screen */


 x = 1 + random( w - 1 ); /* Generate a random location */
 y = 1 + random( h - 1 );
 color = random( MaxColors );
 putpixel( x, y, color );
 }

 srand( seed ); /* Restart Random # at same # */

 for( i=0 ; i<5000 ; ++i ){ /* Take the 5000 pixels off */
 x = 1 + random( w - 1 ); /* Generate a random location */
 y = 1 + random( h - 1 );
 color = getpixel( x, y ); /* Read the color pixel  */
 if( color == random( MaxColors ) ) /* Used to keep RANDOM in sync */
 putpixel( x, y, 0 ); /* Write pixel to BLACK  */
 }

 Pause(); /* Wait for user's response */

}

/* */
/* PUTIMAGEDEMO */
/* */
void PutImageDemo(void)
{
 static int r  = 20;
 static int StartX = 100;
 static int StartY = 50;

 struct viewporttype vp;
 int PauseTime, x, y, ulx, uly, lrx, lry, size, i, width, height, step;
 void *Saucer;

 MainWindow("GetImage / PutImage Demonstration");
 getviewsettings( &vp );

 /* Draw Saucer */
 setfillstyle( SOLID_FILL, getmaxcolor() );
 fillellipse(StartX, StartY, r, (r/3)+2);
 ellipse(StartX, StartY-4, 190, 357, r, r/3);

 line(StartX+7, StartY-6, StartX+10, StartY-12);
 circle(StartX+10, StartY-12, 2);
 line(StartX-7, StartY-6, StartX-10, StartY-12);
 circle(StartX-10, StartY-12, 2);


 /* Read saucer image */
 ulx = StartX-(r+1);
 uly = StartY-14;
 lrx = StartX+(r+1);
 lry = StartY+(r/3)+3;
 width = lrx - ulx + 1;
 height = lry - uly + 1;
 size = imagesize(ulx, uly, lrx, lry);

 Saucer = malloc( size );
 getimage(ulx, uly, lrx, lry, Saucer);
 putimage(ulx, uly, Saucer, XOR_PUT);

/* Plot some "stars" */
 for ( i=0 ; i<1000; ++i )
 putpixel(random(MaxX), random(MaxY), random( MaxColors-1 )+1);
 x = MaxX / 2;
 y = MaxY / 2;
 PauseTime = 70;

 /* until a key is hit */
 while ( !kbhit() ) {

 /* Draw the Saucer */
 putimage(x, y, Saucer, XOR_PUT);  /* draw image */
 delay(PauseTime);
 putimage(x, y, Saucer, XOR_PUT);  /* erase image */

 /* Move Saucer */

 step = random( 2*r );
 if ((step/2) % 2 != 0 )
 step = -1 * step;
 x = x + step;
 step = random( r );
 if ((step/2) % 2 != 0 )
 step = -1 * step;
 y = y + step;

 if (vp.left + x + width - 1 > vp.right)
 x = vp.right-vp.left-width + 1;
 else
 if (x < 0)
x = 0;
 if (vp.top + y + height - 1 > vp.bottom)
 y = vp.bottom-vp.top-height + 1;
 else
 if (y < 0)
y = 0;
 }
 free( Saucer );
 Pause();
}


/* */
/* LINETODEMO: Display a pattern using moveto and lineto commands. */
/* */

#define MAXPTS 15

void LineToDemo(void)
{
 struct viewporttype vp;
 struct PTS points[MAXPTS];
 int i, j, h, w, xcenter, ycenter;
 int radius, angle, step;
 double rads;

 MainWindow( "MoveTo / LineTo Demonstration" );

 getviewsettings( &vp );
 h = vp.bottom - vp.top;
 w = vp.right - vp.left;

 xcenter = w / 2; /* Determine the center of circle */
 ycenter = h / 2;
 radius = (h - 30) / (AspectRatio * 2);
 step  = 360 / MAXPTS; /* Determine # of increments */

 angle = 0; /* Begin at zero degrees */
 for( i=0 ; i<MAXPTS ; ++i ){ /* Determine circle intercepts */


 rads = (double)angle * PI / 180.0; /* Convert angle to radians */
 points[i].x = xcenter + (int)( cos(rads) * radius );
 points[i].y = ycenter - (int)( sin(rads) * radius * AspectRatio );
 angle += step; /* Move to next increment */
 }

 circle( xcenter, ycenter, radius ); /* Draw bounding circle  */

 for( i=0 ; i<MAXPTS ; ++i ){ /* Draw the cords to the circle */
 for( j=i ; j<MAXPTS ; ++j ){ /* For each remaining intersect */
 moveto(points[i].x, points[i].y); /* Move to beginning of cord */
 lineto(points[j].x, points[j].y); /* Draw the cord */
 }
 }

 Pause(); /* Wait for user's response */

}

/* */
/* LINESTYLEDEMO: Display a pattern using all of the standard */
/* line styles that are available.  */
/* */

void LineStyleDemo(void)
{
 int style, step;
 int x, y, w;
 struct viewporttype vp;
 char buffer[40];

 MainWindow( "Pre-defined line styles" );

 getviewsettings( &vp );
 w = vp.right - vp.left;

 x = 35;
 y = 10;
 step = w / 11;

 settextjustify( LEFT_TEXT, TOP_TEXT );
 outtextxy( x, y, "Normal Width" );

 settextjustify( CENTER_TEXT, TOP_TEXT );

 for( style=0 ; style<4 ; ++style ){
 setlinestyle( style, 0, NORM_WIDTH );
 line( x, y+20, x, vp.bottom-40 );
 itoa( style, buffer, 10 );
 outtextxy( x, vp.bottom-30, buffer );
 x += step;
 }

 x += 2 * step;

 settextjustify( LEFT_TEXT, TOP_TEXT );
 outtextxy( x, y, "Thick Width" );
 settextjustify( CENTER_TEXT, TOP_TEXT );

 for( style=0 ; style<4 ; ++style ){
 setlinestyle( style, 0, THICK_WIDTH );
 line( x, y+20, x, vp.bottom-40 );
 itoa( style, buffer, 10 );
 outtextxy( x, vp.bottom-30, buffer );
 x += step;
 }

 settextjustify( LEFT_TEXT, TOP_TEXT );

 Pause(); /* Wait for user's response */

}

/* */
/* CRTMODEDEMO: Demonstrate the effects of the change mode  */
/* commands on the current screen.  */
/* */

void CRTModeDemo(void)
{
 struct viewporttype vp;
 int mode;

 MainWindow( "SetGraphMode / RestoreCRTMode demo" );
 getviewsettings( &vp );
 mode = getgraphmode();
 settextjustify( CENTER_TEXT, CENTER_TEXT );

 outtextxy( (vp.right-vp.left)/2, (vp.bottom-vp.top)/2,
 "Now you are in graphics mode..." );
 StatusLine( "Press any key for text mode..." );
 getch();

 restorecrtmode();
 printf( "Now you are in text mode.\n\n" );
 printf( "Press any key to go back to graphics..." );
 getch();

 setgraphmode( mode );
 MainWindow( "SetGraphMode / RestoreCRTMode demo" );
 settextjustify( CENTER_TEXT, CENTER_TEXT );
 outtextxy( (vp.right-vp.left)/2, (vp.bottom-vp.top)/2,
 "Back in Graphics Mode..." );

 Pause(); /* Wait for user's response */

}

/* */
/* USERLINESTYLEDEMO: Display line styles showing the user  */
/* defined line style functions. */
/* */

void UserLineStyleDemo(void)
{
 int x, y, i, h, flag;
 unsigned int style;
 struct viewporttype vp;

 MainWindow( "User defined line styles" );

 getviewsettings( &vp );
 h = vp.bottom - vp.top;

 x = 4;
 y = 10;
 style = 0;


 poly[i].y = poly[1].y;

 fillpoly( MaxPts, (int far *)poly ); /* Draw the actual polygon  */
 } /* End of WHILE not KBHIT */

 Pause(); /* Wait for user's response */

}


/* */
/* SAYGOODBYE: Give a closing screen to the user before leaving. */
/* */

void SayGoodbye(void)
{
 struct viewporttype viewinfo;  /* Structure to read viewport */
 int h, w;

 MainWindow( "== Finale ==" );

 getviewsettings( &viewinfo );  /* Read viewport settings */
 changetextstyle( TRIPLEX_FONT, HORIZ_DIR, 4 );
 settextjustify( CENTER_TEXT, CENTER_TEXT );

 h = viewinfo.bottom - viewinfo.top;
 w = viewinfo.right - viewinfo.left;
 outtextxy( w/2, h/2, "That's all, folks!" );

 StatusLine( "Press any key to EXIT" );
 getch();

 cleardevice(); /* Clear the graphics screen */

}

/* */
/* PAUSE: Pause until the user enters a keystroke. If the */
/* key is an ESC, then exit program, else simply return. */
/* */

void Pause(void)
{
 static char msg[] = "Esc aborts or press a key...";
 int c;

 StatusLine( msg ); /* Put msg at bottom of screen */

 c = getch(); /* Read a character from kbd */

 if( ESC == c ){ /* Does user wish to leave? */
 closegraph(); /* Change to text mode */
 exit( 1 ); /* Return to OS  */
 }

 if( 0 == c ){  /* Did use hit a non-ASCII key? */
 c = getch(); /* Read scan code for keyboard */
 }

 cleardevice(); /* Clear the screen */

}

/* */
/* MAINWINDOW: Establish the main window for the demo and set */
/* a viewport for the demo code. */
/* */

void MainWindow( char *header )
{
 int height;

 cleardevice(); /* Clear graphics screen */
 setcolor( MaxColors - 1 ); /* Set current color to white */
 setviewport( 0, 0, MaxX, MaxY, 1 ); /* Open port to full screen */

 height = textheight( "H" ); /* Get basic text height */

 changetextstyle( DEFAULT_FONT, HORIZ_DIR, 1 );
 settextjustify( CENTER_TEXT, TOP_TEXT );
 outtextxy( MaxX/2, 2, header );
 setviewport( 0, height+4, MaxX, MaxY-(height+4), 1 );
 DrawBorder();
 setviewport( 1, height+5, MaxX-1, MaxY-(height+5), 1 );

}

/* */
/* STATUSLINE: Display a status line at the bottom of the screen. */
/* */

void StatusLine( char *msg )
{
 int height;

 setviewport( 0, 0, MaxX, MaxY, 1 ); /* Open port to full screen */
 setcolor( MaxColors - 1 ); /* Set current color to white */

 changetextstyle( DEFAULT_FONT, HORIZ_DIR, 1 );
 settextjustify( CENTER_TEXT, TOP_TEXT );
 setlinestyle( SOLID_LINE, 0, NORM_WIDTH );
 setfillstyle( EMPTY_FILL, 0 );

 height = textheight( "H" ); /* Detemine current height */
 bar( 0, MaxY-(height+4), MaxX, MaxY );
 rectangle( 0, MaxY-(height+4), MaxX, MaxY );
 outtextxy( MaxX/2, MaxY-(height+2), msg );
 setviewport( 1, height+5, MaxX-1, MaxY-(height+5), 1 );

}

/* */
/* DRAWBORDER: Draw a solid single line around the current  */
/* viewport. */
/* */

void DrawBorder(void)
{
 struct viewporttype vp;

 setcolor( MaxColors - 1 ); /* Set current color to white */

 setlinestyle( SOLID_LINE, 0, NORM_WIDTH );

 getviewsettings( &vp );
 rectangle( 0, 0, vp.right-vp.left, vp.bottom-vp.top );

}

/* */
/* CHANGETEXTSTYLE: similar to settextstyle, but checks for */
/* errors that might occur whil loading the font file. */
/* */

void changetextstyle(int font, int direction, int charsize)
{
 int ErrorCode;

 graphresult(); /* clear error code */
 settextstyle(font, direction, charsize);
 ErrorCode = graphresult(); /* check result  */
 if( ErrorCode != grOk ){ /* if error occured */
 closegraph();
 printf(" Graphics System Error: %s\n", grapherrormsg( ErrorCode ) );
 exit( 1 );
 }
}

/* */
/* GPRINTF: Used like PRINTF except the output is sent to the */
/* screen in graphics mode at the specified co-ordinate. */
/* */

int gprintf( int *xloc, int *yloc, char *fmt, ... )
{
 va_list argptr; /* Argument list pointer */
 char str[140]; /* Buffer to build sting into */
 int cnt; /* Result of SPRINTF for return */

 va_start( argptr, fmt ); /* Initialize va_ functions */

 cnt = vsprintf( str, fmt, argptr ); /* prints string to buffer */
 outtextxy( *xloc, *yloc, str ); /* Send string in graphics mode */
 *yloc += textheight( "H" ) + 2; /* Advance to next line */

 va_end( argptr ); /* Close va_ functions */

 return( cnt ); /* Return the conversion count */

}