1. Arc, circle, pieslice <GRAPHICS.H>
■ arc draws a circular arc
■ circle draws a circle
■ pieslice draws and fills a circular pie slice
Declaration:
■ void far arc(int x, int y, int stangle, int endangle, int radius);
■ void far circle(int x, int y, int radius);
■ void far pieslice(int x, int y, int stangle, int endangle, int radius);
Remarks:
arc draws a circular arc in the current drawing color. circle draws a circle in the current drawing color. pieslice draws a pie slice in the current drawing color, then fills it using the current fill pattern and fill color.
Argument │ What It Is/Does
══════════Ï════════════════════════════════════════════
(x,y) │ Center point of arc, circlew, or pie slice
stangle │ Start angle in degrees
endangle │ End angle in degrees
radius │ Radius of arc, circle, and pieslice
The arc or slice travels from stangle to endangle. If stangle = 0 and endangle = 360, the call to arc draws a complete circle. If your circles are not perfectly round, use setaspectratio to adjust the aspect ratio.
Angle for arc, circle, and pieslice (counter-clockwise)
90
degrees
║
║
180 ══════╬══════ 0 degrees,
degrees ║ 360 degrees
║
270
degrees
The linestyle parameter does not affect arcs, circles, ellipses, or pie slices. Only the thickness parameter is used. If you're using a CGA in high resolution mode or a monochrome graphics adapter, examples in this Help system that show how to use graphics functions might not produce the expected results. If your system runs on a CGA or monochrome adapter, pass 1 to those functions that alter the fill or drawing color (don't pass one of the symbolic color constants defined in GRAPHICS.H).
Return Value: None
Portability: Dos
See Also: ellipse fill_patterns fillellipse getarccoords
getaspectratio graphresult setfillpattern setfillstyle
setgraphbufsize
Examples:
· arc example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
int stangle = 45, endangle = 135;
int radius = 100;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
/* an error occurred */
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
setcolor(getmaxcolor());
/* draw arc */
arc(midx, midy, stangle, endangle, radius);
/* clean up */
getch();
closegraph();
return 0;
}
· circle example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
int radius = 100;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
setcolor(getmaxcolor());
/* draw the circle */
circle(midx, midy, radius);
/* clean up */
getch();
closegraph();
return 0;
}
· pieslice example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
int stangle = 45, endangle = 135, radius = 100;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* set fill style and draw a pie slice */
setfillstyle(EMPTY_FILL, getmaxcolor());
pieslice(midx, midy, stangle, endangle, radius);
/* clean up */
getch();
closegraph();
return 0;
}
2. Bar <GRAPHICS.H>
Draws a bar
Declaration: void far bar(int left, int top, int right, int bottom);
Remarks: bar draws a filled-in, rectangular, two-dimensional bar.
The bar is filled using the current fill pattern and fill color. bar does not outline the bar. To draw an outlined two-dimensional bar, use bar3d with depth = 0.
Parameters │ What they are
═════════════════Ï══════════════════════════════════════
(left, top) │ the rectangle's upper left corner
(right, bottom) │ the rectangle's lower right corner
The coordinates are in pixels.
Return Value: None
Portability: Dos
See Also: bar3d rectangle setcolor
setfillstyle setlinestyle
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy, i;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* loop through the fill patterns */
for (i=SOLID_FILL; i<USER_FILL; i++)
{
/* set the fill style */
setfillstyle(i, getmaxcolor());
/* draw the bar */
bar(midx-50, midy-50, midx+50,
midy+50);
getch();
}
/* clean up */
closegraph();
return 0;
}
3. Bar3d <GRAPHICS.H>
Draws a 3-D bar
Declaration: void far bar3d(int left, int top, int right, int bottom,
int depth, int topflag);
Remarks: bar3d draws a three-dimensional rectangular bar, then fills it using the current fill pattern and fill color. The three-dimensional outline of the bar is drawn in the current line style and color.
Parameter │ What It Is/Does
═════════════════Ï══════════════════════════════════════
depth │ Bar's depth in pixels
topflag │ Governs whether a three-dimensional
│ top is put on the bar
(left, top) │ Rectangle's upper left corner
(right, bottom) │ Rectangle's lower right corner
If topflag is non-zero, a top is put on the bar. If topflag is 0, no top is put on the bar: This makes it possible to stack several bars on top of one another. To calculate a typical depth for bar3d, take 25% of the width of the bar, like this:
bar3d(left, top, right, bottom, (right-left)/4, 1);
Return Value: None
Portability: Dos
See Also: bar rectangle setcolor
setfillstyle setlinestyle
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy, i;
/* initialize graphics, local variables*/
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* loop through the fill patterns */
for (i=EMPTY_FILL; i<USER_FILL; i++)
{
/* set the fill style */
setfillstyle(i, getmaxcolor());
/* draw the 3-d bar */
bar3d(midx-50, midy-50, midx+50,
midy+50, 10, 1);
getch();
}
/* clean up */
closegraph();
return 0;
}
4. Cleardevice <GRAPHICS.H>
Clears the graphics screen
Declaration: void far cleardevice(void);
Remarks: cleardevice erases the entire graphics screen and moves the CP (current position) to home (0,0). (Erasing consists of filling with the current background color.)
Return Value: None
Portability: Dos
It works only with IBM PCs and compatibles equipped with supported graphics display adapters.
See Also: clearviewport
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
setcolor(getmaxcolor());
/* for centering screen messages */
settextjustify(CENTER_TEXT, CENTER_TEXT);
/* output a message to the screen */
outtextxy(midx, midy, "press any key to clear the screen:");
/* wait for a key */
getch();
/* clear the screen */
cleardevice();
/* output another message */
outtextxy(midx, midy, "press any key to quit:");
/* clean up */
getch();
closegraph();
return 0;
}
5. Clearviewport <GRAPHICS.H>
Clears the current viewport
Declaration: void far clearviewport(void);
Remarks: clearviewport erases the viewport and moves the CP (current position) to home (0,0), relative to the viewport.
Return Value: None
Portability: Dos
See Also: cleardevice getviewsettings setviewport
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#define CLIP_ON 1 /* activates clipping in viewport */
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int ht;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
setcolor(getmaxcolor());
ht = textheight("W");
/* message in default full-screen viewport */
outtextxy(0, 0, "* <-- (0, 0) in default viewport");
/* create a smaller viewport */
setviewport(50, 50, getmaxx()-50, getmaxy()-50, CLIP_ON);
/* display some messages */
outtextxy(0, 0, "* <-- (0, 0) in smaller viewport");
outtextxy(0, 2*ht, "Press any key to clear viewport:");
/* wait for a key */
getch();
/* clear the viewport */
clearviewport();
/* output another message */
outtextxy(0, 0, "Press any key to quit:");
/* clean up */
getch();
closegraph();
return 0;
}
6. Closegraph <GRAPHICS.H>
Shuts down the graphics system
Declaration: void far closegraph(void);
Remarks: closegraph deallocates all memory allocated by the graphics system.
It then restores the screen to the mode it was in before you called initgraph. (The graphics system deallocates memory, such as the drivers, fonts, and an internal buffer, through a call to _graphfreemem.)
Return Value: None
Portability: Dos
See Also: initgraph setgraphbufsize
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int x, y;
/* initialize graphics mode */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
x = getmaxx() / 2;
y = getmaxy() / 2;
/* output a message */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(x, y, "Press a key to close the graphics system:");
/* wait for a key */
getch();
/* closes down the graphics system */
closegraph();
printf("We're now back in text mode.\n");
printf("Press any key to halt:");
getch();
return 0;
}
7. Detectgraph <GRAPHICS.H>
Determines graphics driver and mode to use by checking the hardware.
Declaration: void far detectgraph(int far *graphdriver, int far *graphmode);
Remarks: detectgraph detects your system's graphics adapter and chooses the mode that provides the highest resolution for that adapter.
If no graphics hardware is detected, detectgraph sets *graphdriver to grNotDetected, and graphresult returns grNotDetected. The main reason to call detectgraph directly is to override the graphics mode that detectgraph recommends to initgraph. *graphdriver is an integer that specifies the graphics driver to be used. You can give *graphdriver a value using a constant of the graphics_drivers enum type, defined in GRAPHICS.H.
*graphmode specifies the initial graphics mode. However, if *graphdriver = DETECT, *graphmode is set to the highest resolution available for the detected driver. You can give *graphmode a value using a constant of the graphics_modes enum type, also defined in GRAPHICS.H.
Return Value: None
Portability: Dos
See Also: graphresult initgraph
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
/* names of the various cards supported */
char *dname[] = { "requests detection", "a CGA","an MCGA", "an EGA",
"a 64K EGA", "a monochrome EGA", "an IBM 8514",
"a Hercules monochrome", "an AT&T 6300 PC", "a VGA",
"an IBM 3270 PC"};
int main(void)
{
/* returns detected hardware info. */
int gdriver, gmode, errorcode;
/* detect graphics hardware available */
detectgraph(&gdriver, &gmode);
/* read result of detectgraph call */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* display the information detected */
clrscr();
printf("You have %s video display card.\n", dname[gdriver]);
printf("Press any key to halt:");
getch();
return 0;
}
8. Drawpoly, fillpoly <GRAPHICS.H>
■ drawpoly draws the outline of a polygon
■ fillpoly draws and fills a polygon
Declaration:
■ void far drawpoly(int numpoints, int far *polypoints);
■ void far fillpoly(int numpoints, int far *polypoints);
Remarks:
drawpoly draws a polygon using the current line style and color. fillpoly draws the outline of a polygon using the current line style and color, then fills the polygon using the current fill pattern and fill color.
Argument │ What It Does
═════════════Ï═════════════════════════════════════════════════
numpoints │ Specifies number of points
*polypoints │ Points to a sequence of (numpoints x 2) integers
Each pair of integers gives the x and y coordinates of a point on the polygon. To draw a closed figure with N vertices, you must pass N+1 coordinates to drawpoly, where the Nth coordinate == the 0th coordinate.
Return Value: None
Portability: Dos
See Also: fill_patterns floodfill graphresult setfillstyle setwritemode
Examples:
· drawpoly example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int maxx, maxy;
/* our polygon array */
int poly[10];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk)
/* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
/* terminate with an error code */
exit(1);
}
maxx = getmaxx();
maxy = getmaxy();
poly[0] = 20; /* 1st vertext */
poly[1] = maxy / 2;
poly[2] = maxx - 20; /* 2nd */
poly[3] = 20;
poly[4] = maxx - 50; /* 3rd */
poly[5] = maxy - 20;
poly[6] = maxx / 2; /* 4th */
poly[7] = maxy / 2;
/* drawpoly doesn't automatically close the polygon, so we close it. */
poly[8] = poly[0];
poly[9] = poly[1];
/* draw the polygon */
drawpoly(5, poly);
/* clean up */
getch();
closegraph();
return 0;
}
· fillpoly example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int i, maxx, maxy;
/* our polygon array */
int poly[8];
/* initialize graphics, local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk)
/* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
/* terminate with an error code */
}
maxx = getmaxx();
maxy = getmaxy();
poly[0] = 20; /* 1st vertex */
poly[1] = maxy / 2;
poly[2] = maxx - 20; /* 2nd */
poly[3] = 20;
poly[4] = maxx - 50; /* 3rd */
poly[5] = maxy - 20;
/* 4th vertex. fillpoly automatically closes the polygon. */
poly[6] = maxx / 2;
poly[7] = maxy / 2;
/* loop through the fill patterns */
for (i=EMPTY_FILL; i<USER_FILL; i++)
{
/* set fill pattern */
setfillstyle(i, getmaxcolor());
/* draw a filled polygon */
fillpoly(4, poly);
getch();
}
/* clean up */
closegraph();
return 0;
}
9. Ellipse, fillellipse, sector <GRAPHICS.H>
■ ellipse draws an elliptical arc
■ fillellipse draws and fills an ellipse
■ sector draws and fills an elliptical pie slice
Declaration:
■ void far ellipse(int x, int y, int stangle, int endangle,
int xradius, int yradius);
■ void far fillellipse(int x, int y, int xradius, int yradius);
■ void far sector(int x, int y, int stangle, int endangle,
int xradius, int yradius);
Remarks:
ellipse draws an elliptical arc in the current drawing color.
fillellipse draws an ellipse, then fills the ellipse with the current fill color and fill pattern. sector draws and fills an elliptical pie slice in the current drawing color, then fills it using the pattern and color defined by
setfillstyle or setfillpattern.
Argument │ What It Is
══════════Ï═══════════════════
(x,y) │ Center of ellipse
xradius │ Horizontal axis
yradius │ Vertical axis
stangle │ Starting angle
endangle │ Ending angle
The ellipse or sector travels from stangle to endangle. If stangle = 0 and endangle = 360, the call to ellipse draws a complete ellipse.
Angle for ellipse, fillellipse, and sector (counter-clockwise)
Same as Angle for arc, circle, and pieslice (counter-clockwise) Page 1
The linestyle parameter does not affect arcs, circles, ellipses, or pie slices. Only the thickness parameter is used.
Return Value: None
If an error occurs while the elliptical pie slice is filling, graphresult returns –6 (grNoScanMem).
Portability: Dos
See Also: arc circle getaspectratio
piesliceset aspectratio
Example:
· ellipse example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
int stangle = 0, endangle = 360;
int xradius = 100, yradius = 50;
/* initialize graphics, local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk)
/* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
/* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
setcolor(getmaxcolor());
/* draw ellipse */
ellipse(midx, midy, stangle, endangle,
xradius, yradius);
/* clean up */
getch();
closegraph();
return 0;
}
· fillellipse example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request autodetection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy, i;
int xradius = 100, yradius = 50;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) { /* an error occurred */
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* loop through the fill patterns */
for (i = EMPTY_FILL; i < USER_FILL; i++) {
/* set fill pattern */
setfillstyle(i, getmaxcolor());
/* draw a filled ellipse */
fillellipse(midx, midy, xradius, yradius);
getch();
}
/* clean up */
closegraph();
return 0;
}
· sector example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy, i;
int stangle = 45, endangle = 135;
int xrad = 100, yrad = 50;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* loop through the fill patterns */
for (i=EMPTY_FILL; i<USER_FILL; i++)
{
/* set the fill style */
setfillstyle(i, getmaxcolor());
/* draw the sector slice */
sector(midx, midy, stangle, endangle, xrad, yrad);
getch();
}
/* clean up */
closegraph();
return 0;
}
10.Floodfill <GRAPHICS.H>
Flood-fills a bounded region
Declaration: void far floodfill(int x, int y, int border);
Remarks: floodfill fills an enclosed area on bitmap devices. The area bounded by the color border is flooded with the current fill pattern and fill color.
(x,y) is a "seed point".
■ If the seed is within an enclosed area,
the inside will be filled.
■ If the seed is outside the enclosed area,
the exterior will be filled.
Use fillpoly instead of floodfill whenever possible so you can maintain code compatibility with future versions. floodfill does not work with the IBM-8514 driver.
Return Value:
If an error occurs while flooding a region, graphresult returns -7.
Portability: Dos
See Also: drawpoly fill_patterns fillpoly
graphresult setfillstyle
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int maxx, maxy;
/* initialize graphics, local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk)
/* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
/* terminate with an error code */
}
maxx = getmaxx();
maxy = getmaxy();
/* select drawing color */
setcolor(getmaxcolor());
/* select fill color */
setfillstyle(SOLID_FILL, getmaxcolor());
/* draw a border around the screen */
rectangle(0, 0, maxx, maxy);
/* draw some circles */
circle(maxx / 3, maxy /2, 50);
circle(maxx / 2, 20, 100);
circle(maxx-20, maxy-50, 75);
circle(20, maxy-20, 25);
/* wait for a key */
getch();
/* fill in bounded region */
floodfill(2, 2, getmaxcolor());
/* clean up */
getch();
closegraph();
return 0;
}
11.Getarccoords <GRAPHICS.H>
Gets coordinates of the last call to arc
Declaration: void far getarccoords(struct arccoordstype far *arccoords);
Remarks: getarccoords puts information about the last call to arc in the arccoordstype structure *arccoords.
Return Value: None
Portability: Dos
See Also: arc fillellipse sector
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
struct arccoordstype arcinfo;
int midx, midy;
int stangle = 45, endangle = 270;
char sstr[80], estr[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
/* an error occurred */
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
/* terminate with an error code */
exit(1);
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* draw arc and get coordinates */
setcolor(getmaxcolor());
arc(midx, midy, stangle, endangle, 100);
getarccoords(&arcinfo);
/* convert arc information into strings */
sprintf(sstr, "*- (%d, %d)", arcinfo.xstart, arcinfo.ystart);
sprintf(estr, "*- (%d, %d)", arcinfo.xend, arcinfo.yend);
/* output the arc information */
outtextxy(arcinfo.xstart, arcinfo.ystart, sstr);
outtextxy(arcinfo.xend, arcinfo.yend, estr);
/* clean up */
getch();
closegraph();
return 0;
}
12.Getaspectratio, setaspectratio <GRAPHICS.H>
■ getaspectratio gets the current graphics mode's aspect ratio
■ setaspectratio sets the graphics aspect ratio
Declaration:
■ void far getaspectratio(int far *xasp, int far *yasp);
■ void far setaspectratio(int xasp, int yasp);
Remarks:
getaspectratio gets the aspect-ratio values in *xasp and *yasp. setaspectratio changes the default aspect ratio of the graphics system.
Arg. │ Function │ What It Is/Does
══════Ï════════════════Ï════════════════════════════════
xasp │ getaspectratio │ Points to the x aspect factor
│ setaspectratio │ New value for x aspect factor
│ │
yasp │ getaspectratio │ Points to the y aspect factor
│ setaspectratio │ New value for y aspect factor
Return Value: None
Portability: Dos
See Also: arc circle ellipse
fillellipse pieslice sector
Example (for both functions):
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int xasp, yasp, midx, midy;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
setcolor(getmaxcolor());
/* get current aspect ratio settings */
getaspectratio(&xasp, &yasp);
/* draw normal circle */
circle(midx, midy, 100);
getch();
/* clear the screen */
cleardevice();
/* adjust the aspect for a wide circle */
setaspectratio(xasp/2, yasp);
circle(midx, midy, 100);
getch();
/* adjust the aspect for a narrow circle */
cleardevice();
setaspectratio(xasp, yasp/2);
circle(midx, midy, 100);
/* clean up */
getch();
closegraph();
return 0;
}
13.Getbkcolor, setbkcolor <GRAPHICS.H>
■ getbkcolor returns the current background color
■ setbkcolor sets the current background color using the palette
Declaration:
■ int far getbkcolor(void);
■ void far setbkcolor(int color);
Remarks:
getbkcolor returns the current background color. setbkcolor sets the background to the color specified by color.
· color
color is either a number or symbolic name specifying the color to set. For example, if you want to set the background color to blue, you can call
setbkcolor(BLUE) /* or */ setbkcolor(1)
On CGA and EGA systems, setbkcolor changes the background color by changing the first entry in the palette. On an EGA or a VGA, if you call setpalette or setallpalette to change the palette colors, the defined symbolic constants might not give the correct color. This is because the color parameter to setbkcolor indicates the entry number in the current palette, rather than a specific color. (Except 0, which always sets the background color to black).
Return Value:
■ getbkcolor returns the current background
color.
■ setbkcolor does not return.
Portability: Dos
See Also: getcolor getmaxcolor getpalette
setallpalette setcolor setpalette
Examples:
· getbkcolor example
#include <graphics.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int bkcolor, midx, midy;
char bkname[35];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
/* an error occurred */
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
/* terminate with an error code */
exit(1);
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
setcolor(getmaxcolor());
/* for centering text on the display */
settextjustify(CENTER_TEXT, CENTER_TEXT);
/* get the current background color */
bkcolor = getbkcolor();
/* convert color value into a string */
itoa(bkcolor, bkname, 10);
strcat(bkname, " is the current background color.");
/* display a message */
outtextxy(midx, midy, bkname);
/* clean up */
getch();
closegraph();
return 0;
}
· setbkcolor example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* select a driver and mode that supports */
/* multiple background colors. */
int gdriver = EGA, gmode = EGAHI, errorcode;
int bkcol, maxcolor, x, y;
char msg[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* maximum color index supported */
maxcolor = getmaxcolor();
/* for centering text messages */
settextjustify(CENTER_TEXT, CENTER_TEXT);
x = getmaxx() / 2;
y = getmaxy() / 2;
/* loop through the available colors */
for (bkcol=0; bkcol<=maxcolor; bkcol++)
{
/* clear the screen */
cleardevice();
/* select a new background color */
setbkcolor(bkcol);
/* output a messsage */
if (bkcol == WHITE)
setcolor(EGA_BLUE);
sprintf(msg, "Background color: %d", bkcol);
outtextxy(x, y, msg);
getch();
}
/* clean up */
closegraph();
return 0;
}
14.Getcolor, setcolor <GRAPHICS.H>
■ getcolor returns the current drawing color
■ setcolor sets the current drawing color
Declaration:
■ int far getcolor(void);
■ void far setcolor(int color);
Remarks:
getcolor returns the current drawing color. setcolor sets the current drawing color to color, which can range from 0 to getmaxcolor. To select a drawing color with setcolor, you can pass either the color number or the equivalent color name. The drawing color is the value that pixels are set to when the program draws lines, etc. For example, in CGAC0 mode (palette number 0), the palette contains four colors (background, light green, light red, and yellow):
■ If getcolor returns 1, the current drawing
color is light green.
■ Either setcolor(3) or setcolor(CGA_YELLOW)
selects yellow as the drawing color.
In CGAC3 mode, if getcolor returns 1, the
current drawing color is cyan.
Return Value:
■ getcolor returns the current drawing color.
■ setcolor does not return
Portability: Dos
See Also: getbkcolor getmaxcolor getpalette graphresult
setallpalette setbkcolor setpalette
Examples:
· getcolor example
#include <graphics.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int color, midx, midy;
char colname[35];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
/* an error occurred */
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
/* terminate with an error code */
exit(1);
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
setcolor(getmaxcolor());
/* for centering text on the display */
settextjustify(CENTER_TEXT, CENTER_TEXT);
/* get the current drawing color */
color = getcolor();
/* convert color value into a string */
itoa(color, colname, 10);
strcat(colname," is the current drawing color.");
/* display a message */
outtextxy(midx, midy, colname);
/* clean up */
getch();
closegraph();
return 0;
}
· setcolor example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* select a driver and mode that supports */
/* multiple drawing colors. */
int gdriver = EGA, gmode = EGAHI, errorcode;
int color, maxcolor, x, y;
char msg[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* maximum color index supported */
maxcolor = getmaxcolor();
/* for centering text messages */
settextjustify(CENTER_TEXT, CENTER_TEXT);
x = getmaxx() / 2;
y = getmaxy() / 2;
/* loop through the available colors */
for (color=1; color<=maxcolor; color++)
{
/* clear the screen */
cleardevice();
/* select a new background color */
setcolor(color);
/* output a messsage */
sprintf(msg, "Color: %d", color);
outtextxy(x, y, msg);
getch();
}
/* clean up */
closegraph();
return 0;
}
15.Getdefaultpalette, getpalette, and setallpalette <GRAPHICS.H>
■ getdefaultpalette returns the palette definition structure
■ getpalette gets information about the current palette
■ setallpalette changes all palette colors as specified
Declaration:
■ struct palettetype *far getdefaultpalette(void);
■ void far getpalette(struct palettetype far *palette);
■ void far setallpalette(struct palettetype far *palette);
Remarks:
■ getdefaultpalette finds the palettetype structure that contains the palette initialized by the driver during initgraph.
■ getpalette fills the palettetype structure *palette with information about the current palette's size and colors.
■ setallpalette sets the current palette to the values given in the palettetype structure *palette. setallpalette can partially (or completely) change the colors in the EGA/VGA palette.
┌────────────────────────────────────────┐
│ NOTE: getpalette and setallpalette can │
│ NOT be used with the IBM-8514 │
│ driver. See setrgbpalette. │
└────────────────────────────────────────┘
Valid colors depend on the current graphics driver and current graphics mode.
Changes made to the palette appear onscreen immediately. Each time a palette color changes, all occurrences of that color change to the new color value.
Return Value:
■ getdefault returns a pointer to the default palette set up by the current driver when that driver was initialized.
■ getpalette and setallpalette do not return.
If invalid input is passed to setallpalette, graphresult returns -11 (grError), and the current palette remains unchanged.
Portability: Dos
See Also: getbkcolor getcolor getmaxcolor getpalettesize
graphresult setbkcolor setcolor
Examples:
· getdefaultpalette example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int i;
/* structure for returning palette copy */
struct palettetype far *pal=(void *) 0;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
/* an error occurred */
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
/* terminate with an error code */
exit(1);
}
setcolor(getmaxcolor());
/* return a pointer to the default palette */
pal = getdefaultpalette();
for (i=0; i<16; i++)
{
printf("colors[%d] = %d\n", i, pal->colors[i]);
getch();
}
/* clean up */
getch();
closegraph();
return 0;
}
· getpalette example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
struct palettetype pal;
char psize[80], pval[20];
int i, ht;
int y = 10;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
/* an error occurred */
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
/* terminate with an error code */
exit(1);
}
/* grab a copy of the palette */
getpalette(&pal);
/* convert palette info. into strings */
sprintf(psize, "The palette has %d modifiable entries.", pal.size);
/* display the information */
outtextxy(0, y, psize);
if (pal.size != 0)
{
ht = textheight("W");
y += 2*ht;
outtextxy(0, y, "Here are the current values:");
y += 2*ht;
for (i=0; i<pal.size; i++, y+=ht)
{
sprintf(pval, "palette[%02d]: 0x%02X", i, pal.colors[i]);
outtextxy(0, y, pval);
}
}
/* clean up */
getch();
closegraph();
return 0;
}
· setallpalette example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
struct palettetype pal;
int color, maxcolor, ht;
int y = 10;
char msg[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
maxcolor = getmaxcolor();
ht = 2 * textheight("W");
/* grab a copy of the palette */
getpalette(&pal);
/* display the default palette colors */
for (color=1; color<=maxcolor; color++)
{
setcolor(color);
sprintf(msg, "Color: %d", color);
outtextxy(1, y, msg);
y += ht;
}
/* wait for a key */
getch();
/* black out the colors one by one */
for (color=1; color<=maxcolor; color++)
{
setpalette(color, BLACK);
getch();
}
/* restore the palette colors */
setallpalette(&pal);
/* clean up */
getch();
closegraph();
return 0;
}
16.Getdrivername <GRAPHICS.H>
Returns a pointer to the name of the current graphics driver
Declaration: char *far getdrivername(void);
Remarks: After a call to initgraph, getdrivername returns the name of the driver that is currently loaded.
Return Value: Returns a pointer to a string with the name ofthe currently loaded graphics driver.
Portability: Dos
See Also: initgraph
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
/* stores the device driver name */
char *drivername;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
/* an error occurred */
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
/* terminate with an error code */
exit(1);
}
setcolor(getmaxcolor());
/* get name of the device driver in use */
drivername = getdrivername();
/* for centering text on the screen */
settextjustify(CENTER_TEXT, CENTER_TEXT);
/* output the name of the driver */
outtextxy(getmaxx() / 2, getmaxy() / 2, drivername);
/* clean up */
getch();
closegraph();
return 0;
}
17.Getfillpattern, setfillpattern <GRAPHICS.H>
■ getfillpattern copies a user-defined fill pattern into memory
■ setfillpattern selects a user-defined fill pattern
Declaration:
■ void far getfillpattern(char far *pattern);
■ void far setfillpattern(char far *upattern, int color);
Remarks:
getfillpattern copies the user-defined fill pattern (set by setfillpattern) into the 8-byte area *pattern. setfillpattern sets the current fill pattern to a user-defined 8x8 pattern.
Argument │ Function │ What Argument Is/Does
══════════Ï══════════Ï══════════════════════════════════════════════════════
pattern │ (get...) │ Points to a sequence of 8 bytes; each byte
│ │ corresponds to 8 pixels in the pattern fetched
upattern │ (set...) │ Points to a sequence of 8 bytes; each byte
│ │ corresponds to 8 pixels in the user-defined pattern
Whenever a bit in a pattern's byte is set to 1, the corresponding pixel is plotted. For example, the following user-defined fill pattern represents a checkerboard:
char checkerboard[8] = {
0xAA, /* 10101010 = █ █ █ █ */
0x55, /* 01010101 = █ █ █ █ */
0xAA, /* 10101010 = █ █ █ █ */
0x55, /* 01010101 = █ █ █ █ */
0xAA, /* 10101010 = █ █ █ █ */
0x55, /* 01010101 = █ █ █ █ */
0xAA, /* 10101010 = █ █ █ █ */
0x55 /* 01010101 = █ █ █ █ */
};
Return Value: None
Portability: Dos
See Also: fill_patterns getfillsettings graphresult
sector setfillstyle
Example (for both functions):
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int maxx, maxy;
char pattern[8] = {0x00, 0x70, 0x20, 0x27, 0x25, 0x27, 0x04, 0x04};
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
maxx = getmaxx();
maxy = getmaxy();
setcolor(getmaxcolor());
/* select a user defined fill pattern */
setfillpattern(pattern, getmaxcolor());
/* fill the screen with the pattern */
bar(0, 0, maxx, maxy);
getch();
/* get the current user defined fill pattern */
getfillpattern(pattern);
/* alter the pattern we grabbed */
pattern[4] -= 1;
pattern[5] -= 3;
pattern[6] += 3;
pattern[7] -= 4;
/* select our new pattern */
setfillpattern(pattern, getmaxcolor());
/* fill the screen with the new pattern */
bar(0, 0, maxx, maxy);
/* clean up */
getch();
closegraph();
return 0;
}
18.Getfillsettings <GRAPHICS.H>
Gets information about current fill pattern and color.
Declaration:
void far getfillsettings (struct fillsettingstype far *fillinfo);
Remarks:
getfillsettings fills in a structure with information about the current fill pattern and fill color.
Argument │ What It Is/Does
══════════Ï═════════════════════════════════
fillinfo │ Points to the fillsettingstype
│ structure where getfillsettings
│ stores the current fill pattern
│ and color
Return Value: None
Portability: Dos
See Also: getfillpattern setfillpattern setfillstyle
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
/* the names of the fill styles supported */
char *fname[] = { "EMPTY_FILL", "SOLID_FILL", "LINE_FILL", "LTSLASH_FILL",
"SLASH_FILL", "BKSLASH_FILL", "LTBKSLASH_FILL", "HATCH_FILL",
"XHATCH_FILL", "INTERLEAVE_FILL", "WIDE_DOT_FILL",
"CLOSE_DOT_FILL", "USER_FILL"};
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
struct fillsettingstype fillinfo;
int midx, midy;
char patstr[40], colstr[40];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* get information about current fill pattern and color */
getfillsettings(&fillinfo);
/* convert fill information into strings */
sprintf(patstr, "%s is the fill style.", fname[fillinfo.pattern]);
sprintf(colstr, "%d is the fill color.", fillinfo.color);
/* display the information */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(midx, midy, patstr);
outtextxy(midx, midy+2*textheight("W"), colstr);
/* clean up */
getch();
closegraph();
return 0;
}
19.Getgraphmode, setgraphmode <GRAPHICS.H>
■ getgraphmode returns the current graphics mode
■ setgraphmode sets the system to graphics mode, clears the screen
Declaration:
■ int far getgraphmode(void);
■ void far setgraphmode(int mode);
Remarks:
■ getgraphmode returns the current graphics mode.
NOTE: Your program must make a successful call to initgraph or setgraphmode BEFORE calling getgraphmode.
■ setgraphmode selects a graphics mode different than the default one set by initgraph. It clears the screen and resets all graphics settings to their defaults. mode must be a valid mode for the current device driver.
The enumeration graphics_modes, defined in GRAPHICS.H, gives names for the predefinedgraphics modes. You can use setgraphmode in conjunction with
restorecrtmode to switch back and forth between text and graphics modes.
Return Value:
■ getgraphmode returns the graphics mode set by initgraph or setgraphmode
■ setgraphmode does not return.
If you give setgraphmode an invalid mode for the current device driver, graphresult returns -10 (grInvalidMode).
Portability: Dos
See Also: getmoderange graphresult
Examples:
· getgraphmode example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy, mode;
char numname[80], modename[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
/* an error occurred */
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
/* terminate with an error code */
exit(1);
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* get mode number and name strings */
mode = getgraphmode();
sprintf(numname, "%d is the current mode number.", mode);
sprintf(modename, "%s is the current graphics mode", getmodename(mode));
/* display the information */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(midx, midy, numname);
outtextxy(midx, midy+2*textheight("W"), modename);
/* clean up */
getch();
closegraph();
return 0;
}
· setgraphmode example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int x, y;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
x = getmaxx() / 2;
y = getmaxy() / 2;
/* output a message */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(x, y, "Press any key to exit graphics:");
getch();
/* restore system to text mode */
restorecrtmode();
printf("We're now in text mode.\n");
printf("Press any key to return to graphics mode:");
getch();
/* return to graphics mode */
setgraphmode(getgraphmode());
/* output a message */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(x, y, "We're back in graphics mode.");
outtextxy(x, y+textheight("W"), "Press any key to halt:");
/* clean up */
getch();
closegraph();
return 0;
}
20.Getimage, putimage <GRAPHICS.H>
■ getimage saves a bit image of the specified region into memory
■ putimage outputs a bit image onto the screen
Declaration:
■ void far getimage(int left, int top, int right, int bottom,
void far *bitmap);
■ void far putimage(int left, int top, void far *bitmap, int op);
Remarks:
■ getimage copies an image from the screen tomemory.
■ putimage puts the bit image previously saved with getimage back onto the screen, with the upper left corner of the image placed at (left,top).
Argument │ What It Is/Does
══════════Ï════════════════════════════════════════════════════════════════
bitmap │ Points to the area in memory where the bit image is stored.
│ The first two words of this area are used for the width and
│ height of the rectangle. The remainder holds the image itself.
──────────┼────────────────────────────────────────────────────────────────
bottom │ (left, top) and (right, bottom) define the rectangular screen
left │ area from which getimage copies the bit image.
right │ (left, top) is where putimage places the upper left corner of
top │ the stored image.
──────────┼────────────────────────────────────────────────────────────────
op │ Specifies a combination operator that controls how the color
│ for each destination pixel onscreen is computed, based on the
│ pixel already onscreen and the corresponding source pixel in
│ memory.
The enumeration putimage_ops, defined in GRAPHICS.H, gives names to the putimage combination operators.
Return Value: None
Portability: Dos
See Also: imagesize putpixel setvisualpage
Examples:
· getimage example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
void save_screen(void far *buf[4]);
void restore_screen(void far *buf[4]);
int maxx, maxy;
int main(void)
{
int gdriver=DETECT, gmode, errorcode;
void far *ptr[4];
/* auto-detect the graphics driver and mode */
initgraph(&gdriver, &gmode, "");
errorcode = graphresult(); /* check for any errors */
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
}
maxx = getmaxx();
maxy = getmaxy();
/* draw an image on the screen */
rectangle(0, 0, maxx, maxy);
line(0, 0, maxx, maxy);
line(0, maxy, maxx, 0);
save_screen(ptr); /* save the current screen */
getch(); /* pause screen */
cleardevice(); /* clear screen */
restore_screen(ptr); /* restore the screen */
getch(); /* pause screen */
closegraph();
return 0;
}
void save_screen(void far *buf[4])
{
unsigned size;
int ystart=0, yend, yincr, block;
yincr = (maxy+1) / 4;
yend = yincr;
size = imagesize(0, ystart, maxx, yend);
/* get byte size of image */
for (block=0; block<=3; block++)
{
if ((buf[block] = farmalloc(size)) == NULL)
{
closegraph();
printf("Error: not enough heap space in save_screen().\n");
exit(1);
}
getimage(0, ystart, maxx, yend, buf[block]);
ystart = yend + 1;
yend += yincr + 1;
}
}
void restore_screen(void far *buf[4])
{
int ystart=0, yend, yincr, block;
yincr = (maxy+1) / 4;
yend = yincr;
for (block=0; block<=3; block++)
{
putimage(0, ystart, buf[block], COPY_PUT);
farfree(buf[block]);
ystart = yend + 1;
yend += yincr + 1;
}
}
· putimage example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#define ARROW_SIZE 10
void draw_arrow(int x, int y);
int main(void)
{
/* request autodetection */
int gdriver = DETECT, gmode, errorcode;
void *arrow;
int x, y, maxx;
unsigned int size;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
maxx = getmaxx();
x = 0;
y = getmaxy() / 2;
/* draw the image to be grabbed */
draw_arrow(x, y);
/* calculate the size of the image */
size = imagesize(x, y-ARROW_SIZE, x+(4*ARROW_SIZE), y+ARROW_SIZE);
/* allocate memory to hold the image */
arrow = malloc(size);
/* grab the image */
getimage(x, y-ARROW_SIZE, x+(4*ARROW_SIZE), y+ARROW_SIZE, arrow);
/* repeat until a key is pressed */
while (!kbhit())
{
/* erase old image */
putimage(x, y-ARROW_SIZE, arrow, XOR_PUT);
x += ARROW_SIZE;
if (x >= maxx)
x = 0;
/* plot new image */
putimage(x, y-ARROW_SIZE, arrow, XOR_PUT);
}
/* clean up */
free(arrow);
closegraph();
return 0;
}
void draw_arrow(int x, int y)
{
/* draw an arrow on the screen */
moveto(x, y);
linerel(4*ARROW_SIZE, 0);
linerel(-2*ARROW_SIZE, -1*ARROW_SIZE);
linerel(0, 2*ARROW_SIZE);
linerel(2*ARROW_SIZE, -1*ARROW_SIZE);
}
21.Getlinesettings <GRAPHICS.H>
Gets the current line style, pattern, and thickness
Declaration:
void far getlinesettings(struct linesettingstype far *lineinfo);
Remarks: getlinesettings fills the linesettingstype structure *lineinfo with information about the current line style, pattern, and thickness.
Return Value: None
Portability: Dos
See Also: setlinestyle
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
/* the names of the line styles supported */
char *lname[] = { "SOLID_LINE","DOTTED_LINE","CENTER_LINE","DASHED_LINE",
"USERBIT_LINE"};
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
struct linesettingstype lineinfo;
int midx, midy;
char lstyle[80], lpattern[80], lwidth[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* get information about current line settings */
getlinesettings(&lineinfo);
/* convert line information into strings */
sprintf(lstyle, "%s is the line style.", lname[lineinfo.linestyle]);
sprintf(lpattern, "0x%X is the user-defined line pattern.",
lineinfo.upattern);
sprintf(lwidth, "%d is the line thickness.",
lineinfo.thickness);
/* display the information */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(midx, midy, lstyle);
outtextxy(midx, midy+2*textheight("W"), lpattern);
outtextxy(midx, midy+4*textheight("W"), lwidth);
/* clean up */
getch();
closegraph();
return 0;
}
22.Getmaxcolor <GRAPHICS.H>
Returns maximum color value
Declaration: int far getmaxcolor(void);
Remarks: getmaxcolor returns the highest valid color value that can be passed to setcolor for the current graphics driver and mode. For example, on a 256K EGA, getmaxcolor always returns 15. This means that any call to setcolor with a value from 0 to 15 is valid. On a CGA in high-resolution mode (or on a Hercules monochrome adapter) getmaxcolor returns 1.
Return Value: Returns the highest available color value.
Portability: Dos
See Also: getbkcolor getcolor getpalette
getpalettesize setcolor
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
char colstr[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* */
/* grab the color info. and convert it to a string */
sprintf(colstr, "This mode supports colors 0..%d", getmaxcolor());
/* display the information */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(midx, midy, colstr);
/* */
/* * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * * */
/* clean up */
getch();
closegraph();
return 0;
}
23.Getmaxmode <GRAPHICS.H>
Returns maximum graphics mode number for current driver
Declaration: int far getmaxmode(void);
Remarks: getmaxmode lets you find out the maximum mode number for the currently loaded driver, directly from the driver. This gives it an advantage over getmoderange, which works for Borland drivers only.
The minimum mode is 0.
Return Value: getmaxmode returns the maximum mode number for the current driver.
Portability: Dos
See Also: getmodename getmoderange
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
char modestr[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* grab the mode info. and convert it to a string */
sprintf(modestr, "This driver supports modes 0..%d", getmaxmode());
/* display the information */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(midx, midy, modestr);
/* clean up */
getch();
closegraph();
return 0;
}
24.Getmaxx and getmaxy <GRAPHICS.H>
Returns maximum x or y screen coordinate
Declaration:
■ int far getmaxx(void);
■ int far getmaxy(void);
Remarks:
■ getmaxx returns the maximum x value (screen-relative) for the current graphics driver and mode.
■ getmaxy returns the maximum y value (screen-relative) for the current graphics driver and mode.
For example, on a CGA in 320 x 200 mode, getmaxx returns 319 and getmaxy returns 199.
Return Value:
■ getmaxx: maximum x screen coordinate
■ getmaxy: maximum y screen coordinate
Portability: Dos
See Also: getx gety
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
char xrange[80], yrange[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* convert max resolution values into strings */
sprintf(xrange, "X values range from 0..%d", getmaxx());
sprintf(yrange, "Y values range from 0..%d", getmaxy());
/* display the information */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(midx, midy, xrange);
outtextxy(midx, midy+textheight("W"), yrange);
/* clean up */
getch();
closegraph();
return 0;
}
25.Getmodename <GRAPHICS.H>
Returns the name of a specified graphics mode
Declaration: char * far getmodename(int mode_number);
Remarks: getmodename accepts a graphics mode number as input and returns a string containing the name of the corresponding graphics mode. The mode names are embedded in each driver. The return values are useful for building menus or displaying status.
Return Value: getmodename returns a pointer to a string contining the name of the graphics mode.
Portability: Dos
See Also: getmaxmode getmoderange
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request autodetection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy, mode;
char numname[80], modename[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* get mode number and name strings */
mode = getgraphmode();
sprintf(numname, "%d is the current mode number.", mode);
sprintf(modename, "%s is the current graphics mode.",
getmodename(mode));
/* display the information */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(midx, midy, numname);
outtextxy(midx, midy+2*textheight("W"), modename);
/* clean up */
getch();
closegraph();
return 0;
}
26.Getmoderange <GRAPHICS.H>
Gets the range of modes for a given graphics driver
Declaration:
void far getmoderange(int graphdriver, int far *lomode, int far*himode);
Remarks: getmoderange gets the range of valid graphics modes for the given graphics driver.
Argument │ What It Is/Does
═════════════Ï═════════════════════════════════════════════════════════════
graphdriver │ Specified graphics driver
│ ■ If graphdriver = -1, getmoderange gets the currently
│ loaded driver modes.
│ ■ If graphdriver specifies an invalid graphics driver,
│ both *lomode and *himode are set to -1.
│
lomode │ Points to location where lowest permissible mode value
│ is returned.
himode │ Points to location where highest permissible mode value
│ is returned.
Return Value: None
Portability: Dos
See Also: getgraphmode getmaxmode getmodename
initgraph setgraphmode
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
int low, high;
char mrange[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* get the mode range for this driver */
getmoderange(gdriver, &low, &high);
/* convert mode range info. into strings */
sprintf(mrange, "This driver supports modes %d..%d", low, high);
/* display the information */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(midx, midy, mrange);
/* clean up */
getch();
closegraph();
return 0;
}
27.Getpalettesize <GRAPHICS.H>
Returns size of palette color lookup table
Declaration: int far getpalettesize(void);
Remarks: getpalettesize is used to determine how many palette entries can be set for the current graphics mode.
For example, the EGA in color mode returns 16.
Return Value: getpalettesize returns the number of palette entries in the current palette.
Portability: Dos
See Also: setallpalette setpalette
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main()
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
char psize[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* convert palette size info. into string */
sprintf(psize, "The palette has %d modifiable entries.",
getpalettesize());
/* display the information */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(midx, midy, psize);
/* clean up */
getch();
closegraph();
return 0;
}
28.Getpixel, putpixel <GRAPHICS.H>
■ getpixel gets the color of a specified pixel
■ putpixel plots a pixel at a specified point
Declaration:
■ unsigned far getpixel(int x, int y);
■ void far putpixel(int x, int y, int color);
Remarks: getpixel gets the color of the pixel located at (x,y). putpixel plots a point in the color defined by color at (x,y).
Return Value:
■ getpixel returns the color of the given pixel
■ putpixel does not return
Portability: Dos
See Also: getimage/putimage
Example (for both functions):
";INCLUDE GETPIXEL.CEX"
29.Gettextsettings <GRAPHICS.H>
Gets information about the current graphic text font
Declaration:
void far gettextsettings(struct textsettingstype far *texttypeinfo);
Remarks: gettextsettings fills a structure with information about the current text font, direction, size, and justification.
Argument │ What It Is/Does
══════════════Ï══════════════════════════════════════════
texttypeinfo │ Points to the textsettingstype structure
│ that gettextsettings fills in
Return Value: None
Portability: Dos
See Also: outtext outtextxy registerbgifont settextjustify
settextstyle setusercharsize textheight textwidth\
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
/* the names of the fonts supported */
char *font[] = { "DEFAULT_FONT",
"TRIPLEX_FONT",
"SMALL_FONT",
"SANS_SERIF_FONT",
"GOTHIC_FONT"
};
/* the names of the text directions supported */
char *dir[] = { "HORIZ_DIR", "VERT_DIR" };
/* horizontal text justifications supported */
char *hjust[] = { "LEFT_TEXT", "CENTER_TEXT", "RIGHT_TEXT" };
/* vertical text justifications supported */
char *vjust[] = { "BOTTOM_TEXT", "CENTER_TEXT", "TOP_TEXT" };
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
struct textsettingstype textinfo;
int midx, midy, ht;
char fontstr[80], dirstr[80], sizestr[80];
char hjuststr[80], vjuststr[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* get information about current text settings */
gettextsettings(&textinfo);
/* convert text information into strings */
sprintf(fontstr, "%s is the text style.", font[textinfo.font]);
sprintf(dirstr, "%s is the text direction.", dir[textinfo.direction]);
sprintf(sizestr, "%d is the text size.", textinfo.charsize);
sprintf(hjuststr, "%s is the horizontal justification.",
hjust[textinfo.horiz]);
sprintf(vjuststr, "%s is the vertical justification.",
vjust[textinfo.vert]);
/* display the information */
ht = textheight("W");
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(midx, midy, fontstr);
outtextxy(midx, midy+2*ht, dirstr);
outtextxy(midx, midy+4*ht, sizestr);
outtextxy(midx, midy+6*ht, hjuststr);
outtextxy(midx, midy+8*ht, vjuststr);
/* clean up */
getch();
closegraph();
return 0;
}
30.Getviewsettings <GRAPHICS.H>
Gets information about the current viewport
Declaration:
void far getviewsettings (struct viewporttype far *viewport);
Remarks: getviewsettings fills a structure with information about the current viewport.
Argument │ What It Is/Does
══════════Ï═════════════════════════════════
viewport │ Points to viewporttype structure
│ that getviewsettings fills
Return Value: None
Portability: Dos
See Also: clearviewport getx
gety setviewport
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
char *clip[] = { "OFF", "ON" };
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
struct viewporttype viewinfo;
int midx, midy, ht;
char topstr[80], botstr[80], clipstr[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* get information about current viewport */
getviewsettings(&viewinfo);
/* convert text information into strings */
sprintf(topstr, "(%d, %d) is the upper left viewport corner.",
viewinfo.left, viewinfo.top);
sprintf(botstr, "(%d, %d) is the lower right viewport corner.",
viewinfo.right, viewinfo.bottom);
sprintf(clipstr, "Clipping is turned %s.", clip[viewinfo.clip]);
/* display the information */
settextjustify(CENTER_TEXT, CENTER_TEXT);
ht = textheight("W");
outtextxy(midx, midy, topstr);
outtextxy(midx, midy+2*ht, botstr);
outtextxy(midx, midy+4*ht, clipstr);
/* clean up */
getch();
closegraph();
return 0;
}
31.Getx, gety <GRAPHICS.H>
■ getx returns the current position's x coordinate
■ gety returns the current position's y coordinate
Declaration:
■ int far getx(void);
■ int far gety(void);
Remarks:
■ getx returns the x-coordinate of the current graphics position.
■ gety returns the y-coordinate of the current graphics position.
The values are viewport-relative.
Return Value:
■ getx: x-coordinate of current position
■ gety: y-coordinate of current position
Portability: Dos
See Also: getmaxx/getmaxy getviewsetting moveto
Example (for both functions):
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
char msg[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* move to the screen center point */
moveto(getmaxx() / 2, getmaxy() / 2);
/* create a message string */
sprintf(msg, "<-(%d, %d) is here.", getx(), gety());
/* display the message */
outtext(msg);
/* clean up */
getch();
closegraph();
return 0;
}
32.Graphdefaults <GRAPHICS.H>
Resets all graphics settings to their defaults
Declaration: void far graphdefaults(void);
Remarks:
graphdefaults resets all graphics settings to their defaults:
■ sets the viewport to the entire screen.
■ moves the current position to (0,0).
■ sets the default palette colors, background color, and drawing color.
■ sets the default fill style and pattern.
■ sets the default text font and justification.
Return Value: None
Portability: Dos
See Also: initgraph setgraphmode
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int maxx, maxy;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "c:\\bor\\turbo5\\bgi");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
maxx = getmaxx();
maxy = getmaxy();
/* output line with non-default settings */
setlinestyle(DOTTED_LINE, 0, 3); line(0, 0, maxx, maxy);
outtextxy(maxx/2, maxy/3, "Before default values are restored.");
getch();
/* restore default values for everything */
graphdefaults();
/* clear the screen */
cleardevice();
/* output line with default settings */
line(0, 0, maxx, maxy);
outtextxy(maxx/2, maxy/3, "After restoring default values.");
/* clean up */
getch();
closegraph();
return 0;
}
33.Grapherrormsg <GRAPHICS.H>
Returns a pointer to an error message string
Declaration: char *far grapherrormsg(int errorcode);
Remarks: grapherrormsg returns a pointer to the error message string associated with errorcode, the value returned by graphresult.
See the errno Help screen for a list of error messages and mnemonics.
Return Value: Returns a pointer to an error message string.
Portability: Dos
See Also: graphresult
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#define NONSENSE -50
int main(void)
{
/* FORCE AN ERROR TO OCCUR */
int gdriver = NONSENSE, gmode, errorcode;
/* initialize graphics mode */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
/* if an error occurred, then output a */
/* descriptive error message. */
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* draw a line */
line(0, 0, getmaxx(), getmaxy());
/* clean up */
getch();
closegraph();
return 0;
}
34._Graphfreemem, _graphgetmem <GRAPHICS.H>
User hooks into graphics memory deallocation
Declaration:
■ void far _graphfreemem(void far *ptr, unsigned size);
■ void far * far _graphgetmem(unsigned size);
Remarks: Routines in the graphics library (not in your program) normally call _graphgetmem to allocate memory for internal buffers, graphics drivers, and character sets. The graphics library calls _graphfreemem to release memory previously allocated through _graphgetmem. You can to control the graphics library memory management by defining your own versions of _graphfreemem and _graphgetmem. (You must declare them exactly as shown.)
The default version of _graphgetmem calls malloc; the default version of _graphfreemem calls free.
Return Value: None
Portability: Dos
See Also: initgraph setgraphbufsize
Example (for both functions):
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
/* clear the text screen */
clrscr();
printf("Press any key to initialize graphics mode:");
getch();
clrscr();
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* display a message */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(midx, midy, "Press any key to exit graphics mode:");
/* clean up */
getch();
closegraph();
return 0;
}
/* called by the graphics kernel to allocate memory */
void far * far _graphgetmem(unsigned size)
{
printf("_graphgetmem called to allocate %d bytes.\n", size);
printf("press any key:");
getch();
printf("\n");
/* allocate memory from far heap */
return farmalloc(size);
}
/* called by the graphics kernel to free memory */
void far _graphfreemem(void far *ptr, unsigned size)
{
printf("_graphfreemem called to free %d bytes.\n", size);
printf("press any key:");
getch();
printf("\n");
/* free ptr from far heap */
farfree(ptr);
}
35._graphfreemem, _graphgetmem <GRAPHICS.H>
User hooks into graphics memory deallocation
Declaration:
■ void far _graphfreemem(void far *ptr, unsigned size);
■ void far * far _graphgetmem(unsigned size);
Remarks: Routines in the graphics library (not in your program) normally call _graphgetmem to allocate memory for internal buffers, graphics drivers, and character sets. The graphics library calls _graphfreemem to release memory previously allocated through _graphgetmem. You can to control the graphics library memory management by defining your own versions of
_graphfreemem and _graphgetmem. (You must declare them exactly as shown.)
The default version of _graphgetmem calls malloc; the default version of _graphfreemem calls free.
Return Value: None
Portability: Dos
See Also: initgraph setgraphbufsize
Example (for both functions):
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#include <alloc.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
/* clear the text screen */
clrscr();
printf("Press any key to initialize graphics mode:");
getch();
clrscr();
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* display a message */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(midx, midy, "Press any key to exit graphics mode:");
/* clean up */
getch();
closegraph();
return 0;
}
/* called by the graphics kernel to allocate memory */
void far * far _graphgetmem(unsigned size)
{
printf("_graphgetmem called to allocate %d bytes.\n", size);
printf("press any key:");
getch();
printf("\n");
/* allocate memory from far heap */
return farmalloc(size);
}
/* called by the graphics kernel to free memory */
void far _graphfreemem(void far *ptr, unsigned size)
{
printf("_graphfreemem called to free %d bytes.\n", size);
printf("press any key:");
getch();
printf("\n");
/* free ptr from far heap */
farfree(ptr);
}
36.Graphresult <GRAPHICS.H>
Returns an error code for the last unsuccessful graphics operation
Declaration: int far graphresult(void);
Remarks: graphresult returns the error code for the last graphics operation that reported an error, then resets the error level to grOk. The enumerated type graphics_errors defines the error codes. The variable maintained by graphresult is reset to 0 after graphresult has been called. Therefore, you should store the value of graphresult into a temporary variable and then test it.
Return Value: Returns the current graphics error number, (an integer in the range -15 to 0).
NOTE: grapherrormsg returns a pointer to a string associated with the integer value returned by graphresult.
Portability: Dos
See Also: detectgraph drawpol fillpoly floodfill
grapherrormsg initgraph pieslice registerbgidriver
registerbgifont setallpalette setcolor setfillstyle
setgraphmode setlinestyle setpalette settextjustify
settextstyle setusercharsize setviewport setvisualpage
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* draw a line */
line(0, 0, getmaxx(), getmaxy());
/* clean up */
getch();
closegraph();
return 0;
}
37.Imagesize <GRAPHICS.H>
Returns the number of bytes required to store a bit image
Declaration:
unsigned far imagesize(int left, int top, int right, int bottom);
Remarks: imagesize determines the size of the memory area required to store a bit image.
Return Value:
■ On success, returns the size of the required memory area in bytes.
■ On error (if the size required for the selected image is >= (64K - 1) bytes), returns 0xFFFF (-1)
Portability: Dos
See Also: getimage putimage
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#define ARROW_SIZE 10
void draw_arrow(int x, int y);
int main(void)
{
/* request autodetection */
int gdriver = DETECT, gmode, errorcode;
void *arrow;
int x, y, maxx;
unsigned int size;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
maxx = getmaxx();
x = 0;
y = getmaxy() / 2;
/* draw the image to be grabbed */
draw_arrow(x, y);
/* calculate the size of the image */
size = imagesize(x, y-ARROW_SIZE, x+(4*ARROW_SIZE), y+ARROW_SIZE);
/* allocate memory to hold the image */
arrow = malloc(size);
/* grab the image */
getimage(x, y-ARROW_SIZE, x+(4*ARROW_SIZE), y+ARROW_SIZE, arrow);
/* repeat until a key is pressed */
while (!kbhit())
{
/* erase old image */
putimage(x, y-ARROW_SIZE, arrow, XOR_PUT);
x += ARROW_SIZE;
if (x >= maxx)
x = 0;
/* plot new image */
putimage(x, y-ARROW_SIZE, arrow, XOR_PUT);
}
/* clean up */
free(arrow);
closegraph();
return 0;
}
void draw_arrow(int x, int y)
{
/* draw an arrow on the screen */
moveto(x, y);
linerel(4*ARROW_SIZE, 0);
linerel(-2*ARROW_SIZE, -1*ARROW_SIZE);
linerel(0, 2*ARROW_SIZE);
linerel(2*ARROW_SIZE, -1*ARROW_SIZE);
}
38.Initgraph <GRAPHICS.H>
Initializes the graphics system
Declaration:
void far initgraph(int far *graphdriver,
int far *graphmode, char far *pathtodriver);
Remarks: To start the graphics system, you must first call initgraph.
initgraph initializes the graphics system by loading a graphics driver from disk (or validating a registered driver) then putting the system into graphics mode. initgraph also resets all graphics settings (color, palette, current position, viewport, etc.) to their defaults, then resets graphresult to 0.
Argument │ What It Is/Does
══════════════Ï═══════════════════════════════════════════════════════════
*graphdriver │ Integer that specifies the graphics driver to be used.
│ You can give graphdriver a value using a constant of
│ the graphics_drivers enumeration type.
──────────────┼───────────────────────────────────────────────────────────
*graphmode │ Integer that specifies the initial graphics mode
│ (unless *graphdriver = DETECT).
│ If *graphdriver = DETECT, initgraph sets *graphmode to
│ the highest resolution available for the detected driver.
│ You can give *graphmode a value using a constant of
│ the graphics_modes enumeration type.
──────────────┼───────────────────────────────────────────────────────────
pathtodriver │ Specifies the directory path where initgraph looks for
│ graphics drivers (*.BGI) first.
│ ■ If they're not there, initgraph looks in the current
│ directory.
│ ■ If pathtodriver is null, the driver files must be in
│ the current directory.
│ This is also the path settextstyle searches for the stroked
│ character font files (*.CHR).
*graphdriver and *graphmode must be set to valid graphics_drivers and graphics_mode values or you'll get unpredictable results. (The exception is graphdriver = DETECT.) After a call to initgraph, *graphdriver is set to the current graphics driver, and *graphmode is set to the current graphics mode.
You can tell initgraph to use a particular graphics driver and mode, or to autodetect the attached video adapter at run time and pick the corresponding driver. If you tell initgraph to autodetect, it calls detectgraph to select a graphics driver and mode. Normally, initgraph loads a graphics driver by allocating memory for the driver (through _graphgetmem), then loading the appropriate .BGI file from disk. As an alternative to this dynamic loading scheme, you can link a graphics driver file (or several of them) directly into your executable program file.
Return Value: initgraph always sets the internal error code.
■ On success, initgraph sets the code to 0
■ On error, initgraph sets *graphdriver to -2, -3, -4, or -5, and graphresult returns the same value. See the enumeration graphics_errors for definitions of error codes and graphresult return values.
Portability: Dos
See Also: closegraph getdefaultpalette getdrivername
Getgraphmode getmoderange graphdefaults
installuserdriver registerbgidriver registerbgifont
restorecrtmode setgraphbufsize setgraphmode
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
/* initialize graphics mode */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* return with error code */
}
/* draw a line */
line(0, 0, getmaxx(), getmaxy());
/* clean up */
getch();
closegraph();
return 0;
}
39.Installuserdriver <GRAPHICS.H>
Installs a vendor-added device driver to the BGI device driver table
Declaration:
int far installuserdriver(char far *name, int huge (*detect)(void));
Remarks: With installuserdriver, you can add a vendor-added device driver to the BGI internal table.
Argument│ What It Is/Does
════════Ï══════════════════════════════════════════════════════════════════
name │ Name of the new device driver file (filename.BGI)
detect │ Points to an optional autodetect function that can accompany the
│ new driver. This autodetect function takes no parameters and
│ returns an integer value.
You can install up to 10 drivers at one time. There are two ways to use the vendor-supplied driver:
1) passing the driver number directly to initgraph, or
2) linking in an autodetect function.
Passing driver number directly to initgraph
Assume you have a new video card called the Spiffy Graphics Array (SpGA) and that the SpGA manufacturer provided you with a BGI device driver (SPGA.BGI).
The easiest way to use this driver is to install it by calling installuserdriver and then passing the return value (the assigned driver number) directly to initgraph.
Linking in an autodetect function
The more general way to use this hypothetical SpGA driver is to link in an autodetect function that will be called by initgraph as part of its hardware-detection logic. (Presumably, the manufacturer of the SpGA gave you this autodetect function). When you install the driver (by calling installuserdriver), you pass the address of this autodetect function, along with the device driver's file name. After you install the device driver's file name and the SpGA autodetect function, call initgraph and let it go through its normal autodetection process. Before initgraph calls its own built-in autodetection function (detectgraph), it first calls the SpGA autodetect function.
■ If the SpGA autodetect function doesn't find the SpGA hardware, it returns a value of –11 (grError), and initgraph proceeds with its normal hardware detection logic. (This can include calling any other vendor-supplied autodetection functions in the order in which they were "installed").
■ If, however, the autodetect function determines that an SpGA is present, it returns a non-negative mode number.
initgraph then:
1) locates and loads SPGA.BGI
2) puts the hardware into the default graphics mode recommended by the
autodetect function
3) returns control to your program.
Return Value: Returns the driver number you pass to initgraph to manually select the newly installed driver.
Portability: Dos
See Also: initgraph registerbgidriver
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
/* function prototypes */
int huge detectEGA(void);
void checkerrors(void);
int main(void)
{
int gdriver, gmode;
/* install a user written device driver */
gdriver = installuserdriver("EGA", detectEGA);
/* must force use of detection routine */
gdriver = DETECT;
/* check for any installation errors */
checkerrors();
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* check for any initialization errors */
checkerrors();
/* draw a line */
line(0, 0, getmaxx(), getmaxy());
/* clean up */
getch();
closegraph();
return 0;
}
/* detects EGA or VGA cards */
int huge detectEGA(void)
{
int driver, mode, sugmode = 0;
detectgraph(&driver, &mode);
if ((driver == EGA) || (driver == VGA))
/* return suggested video mode number */
return sugmode;
else
/* return an error code */
return grError;
}
/* check for and report any graphics errors */
void checkerrors(void)
{
int errorcode;
/* read result of last graphics operation */
errorcode = graphresult();
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
}
}
40.Installuserfont <GRAPHICS.H>
Loads a font file (.CHR) that is not built into the BGI system
Declaration: int far installuserfont(char far *name);
Remarks:
Arg. │ What It Is/Does
══════Ï══════════════════════════════════════
name │ Path name to a font file containing
│ a stroked font
You can install up to 20 fonts at one time. installuserfont returns a font ID number that can then be passed to settextstyle to select the corresponding font.
Return Value:
■ On success, returns a font ID number.
■ On error (if the internal font table is full), returns -11 (grError).
Portability: Dos
See Also: settextstyle
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
/* function prototype */
void checkerrors(void);
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode;
int userfont;
int midx, midy;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* check for any initialization errors */
checkerrors();
/* install a user defined font file */
userfont = installuserfont("USER.CHR");
/* check for any installation errors */
checkerrors();
/* select the user font */
settextstyle(userfont, HORIZ_DIR, 4);
/* output some text */
outtextxy(midx, midy, "Testing!");
/* clean up */
getch();
closegraph();
return 0;
}
/* check for and report any graphics errors */
void checkerrors(void)
{
int errorcode;
/* read result of last graphics operation */
errorcode = graphresult();
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
}
}
41.Line, linerel, lineto <GRAPHICS.H>
■ line draws a line between two specified points
■ linerel draws a line a relative distance from the current position (CP)
■ lineto draws a line from the current position (CP) to (x,y)
Declaration:
■ void far line(int x1, int y1, int x2, int y2);
■ void far linerel(int dx, int dy);
■ void far lineto(int x, int y);
Remarks:
■ line draws a line from (x1, y1) to (x2, y2) using the current color, line style, and thickness. It does not update the current position (CP).
■ linerel draws a line from the CP to a point that is a relative distance (dx, dy) from the CP, then advances the CP by (dx, dy).
■ lineto draws a line from the CP to (x, y), then moves the CP to (x, y).
Return Value: None
Portability: Dos
See Also: getlinesettings setcolor setlinestyle
setvisualpage setwritemode
Examples:
· line example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int xmax, ymax;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
/* an error occurred */
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
}
setcolor(getmaxcolor());
xmax = getmaxx();
ymax = getmaxy();
/* draw a diagonal line */
line(0, 0, xmax, ymax);
/* clean up */
getch();
closegraph();
return 0;
}
· linerel example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
char msg[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
}
/* move the C.P. to location (20, 30) */
moveto(20, 30);
/* create and output a
message at (20, 30) */
sprintf(msg, " (%d, %d)", getx(), gety());
outtextxy(20, 30, msg);
/* draw a line to a point a relative distance away from the current
value of C.P. */
linerel(100, 100);
/* create and output a message at C.P. */
sprintf(msg, " (%d, %d)", getx(), gety());
outtext(msg);
/* clean up */
getch();
closegraph();
return 0;
}
· lineto example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
char msg[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1);
}
/* move the C.P. to location (20, 30) */
moveto(20, 30);
/* create and output a
message at (20, 30) */
sprintf(msg, " (%d, %d)", getx(), gety());
outtextxy(20, 30, msg);
/* draw a line to (100, 100) */
lineto(100, 100);
/* create and output a message at C.P. */
sprintf(msg, " (%d, %d)", getx(), gety());
outtext(msg);
/* clean up */
getch();
closegraph();
return 0;
}
42.Moverel, moveto <GRAPHICS.H>
■ moverel moves the current position (CP) a relative distance
■ moveto moves the CP to (x, y)
Declaration:
■ void far moverel(int dx, int dy);
■ void far moveto(int x, int y);
Remarks:
■ moverel moves the current position (CP) dx pixels in the x direction and dy pixels in the y direction.
■ moveto moves the current position (CP) to viewport position (x, y).
Return Value: None
Portability: Dos
Examples:
· moverel example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
char msg[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* move the C.P. to location (20, 30) */
moveto(20, 30);
/* plot a pixel at the C.P. */
putpixel(getx(), gety(), getmaxcolor());
/* create and output a message at (20, 30) */
sprintf(msg, " (%d, %d)", getx(), gety());
outtextxy(20, 30, msg);
/* move to a point a relative distance */
/* away from the current value of C.P. */
moverel(100, 100);
/* plot a pixel at the C.P. */
putpixel(getx(), gety(), getmaxcolor());
/* create and output a message at C.P. */
sprintf(msg, " (%d, %d)", getx(), gety());
outtext(msg);
/* clean up */
getch();
closegraph();
return 0;
}
· moveto example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
char msg[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* move the C.P. to location (20, 30) */
moveto(20, 30);
/* plot a pixel at the C.P. */
putpixel(getx(), gety(), getmaxcolor());
/* create and output a message at (20, 30) */
sprintf(msg, " (%d, %d)", getx(), gety());
outtextxy(20, 30, msg);
/* move to (100, 100) */
moveto(100, 100);
/* plot a pixel at the C.P. */
putpixel(getx(), gety(), getmaxcolor());
/* create and output a message at C.P. */
sprintf(msg, " (%d, %d)", getx(), gety());
outtext(msg);
/* clean up */
getch();
closegraph();
return 0;
}
43.Outtext, outtextxy <GRAPHICS.H>
■ outtext displays a string in the viewport (graphics mode)
■ outtextxy displays a string at the specified location (graphics mode)
Declaration:
■ void far outtext(char far *textstring);
■ void far outtextxy(int x, int y, char far *textstring);
Remarks: outtext and outtextxy display a text string, using the current justification settings and the current font, direction, and size.
■ outtext outputs textstring at the current position (CP)
■ outtextxy displays textstring in the viewport at the position (x, y)
To maintain code compatibility when using several fonts, use textwidth and textheight todetermine the dimensions of the string. If a string is printed with the default font using outtext or outtextxy, any part of the string that extends outside the current viewport is truncated. With outtext, if the horizontal text justification is LEFT_TEXT and the text direction is HORIZ_DIR, the CP's x-coordinate is advanced by textwidth(textstring).
Otherwise, the CP remains unchanged. outtext and outtextxy are for use in graphics mode; they will not work in text mode.
Return Value: None
Portability: Dos
See Also: gettextsettings settextjustify
Examples:
· outtext example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* move the C.P. to the center of the screen */
moveto(midx, midy);
/* output text starting at the C.P. */
outtext("This ");
outtext("is ");
outtext("a ");
outtext("test.");
/* clean up */
getch();
closegraph();
return 0;
}
· outtextxy example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* output text at the center of the screen */
/* Note: the C.P. doesn't get changed. */
outtextxy(midx, midy, "This is a test.");
/* clean up */
getch();
closegraph();
return 0;
}
44.Rectangle <GRAPHICS.H>
Draws a rectangle (graphics mode)
Declaration:
void far rectangle(int left, int top, int right, int bottom);
Remarks: rectangle draws a rectangle in the current line style, thickness, and drawing color. (left,top) is the upper left corner of the rectangle, and (right,bottom) is its lower right corner.
Return Value: None
Portability: Dos
See Also: bar bar3d setcolor setlinestyle
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int left, top, right, bottom;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
left = getmaxx() / 2 - 50;
top = getmaxy() / 2 - 50;
right = getmaxx() / 2 + 50;
bottom = getmaxy() / 2 + 50;
/* draw a rectangle */
rectangle(left,top,right,bottom);
/* clean up */
getch();
closegraph();
return 0;
}
45.Registerbgidriver, registerfarbgidriver <GRAPHICS.H>
Registers linked-in graphics driver
Declaration:
■ int registerbgidriver(void (*driver)(void));
■ int far registerfarbgidriver(void far *driver);
Remarks:
■ registerbgidriver enables a user to load a driver file and "register" the driver.
■ registerfarbgidriver is used to register far drivers.
Once the driver's memory location has been passed to registerbgidriver, initgraph uses the registered driver. A user-registered driver can be loaded from disk onto the heap, or converted to an .OBJ file (using BINOBJ.EXE) and linked into the .EXE. Calling registerbgidriver informs the BGI graphics system that the driver *driver was included at link time. registerbgidriver checks the linked-in code for the specified driver. If the code is valid, it registers the code in internal tables. Linked-in drivers are discussed in detail in UTIL.DOC in Turbo C++ directory. By using the name of a linked-in driver in a call to registerbgidriver, you also tell the compiler (and linker) to link in the object file with that public name.
Far drivers
Far drivers are created with the /F switch of the BGIOBJ utility. This switch is described in UTIL.DOC (an online text file included with your distribution disks).
Return Value
■ On success, returns a negative graphics error code if the specified driver or font is invalid.
■ Otherwise, returns the driver number.
If you register a user-supplied driver, you MUST pass the result of registerbgidriver to initgraph as the drive number to be used.
Portability: Dos
See Also: graphresult initgraph
installuserdriver registerbgifont
Example (registerbgidriver only):
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
/* register a driver that was added into graphics.lib */
/* For information on adding the driver, see the
/* BGIOBJ section of UTIL.DOC */
errorcode = registerbgidriver(EGAVGA_driver);
/* report any registration errors */
if (errorcode < 0)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* draw a line */
line(0, 0, getmaxx(), getmaxy());
/* clean up */
getch();
closegraph();
return 0;
}
46.Registerbgifont <GRAPHICS.H>
Registers linked-in stroked-font code
Declaration:
■ int registerbgifont(void (*font)(void));
■ int registerfarbgifont(void far *font);
Remarks:
■ Calling registerbgifont informs the graphics system that the font *font was included at link time.
■ registerfarbgifont is used to register far fonts.
registerbgidriver checks the linked-in code for the specified font. If the code is valid, it registers the code in internal tables. Linked-in fonts are discussed in detail under BGIOBJ in UTIL.DOC (an online text file included with your distribution disks). By using the name of a linked-in font in a call to registerbgifont, you also tell the compiler (and linker) to link in the object file with that public name. If you register a user-supplied font, you MUST pass the result of registerbgifont to settextstyle as the font number to be used. Far fonts are created with the /F switch of the BGIOBJ utility. This switch is described in UTIL.DOC in Turbo C++ Directory.
Return Value
■ On success, returns a negative graphics error code if the specified
font is invalid.
■ Otherwise, returns the font number of the registered font.
Portability: Dos
See Also: graphresult initgraph installuserdriver
registerbgidriver settextstyle
Example (registerbgifont only):
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy;
/* register a font file that was added into graphics.lib */
/* For information on adding the font, see the
/* BGIOBJ section of UTIL.DOC */
errorcode = registerbgifont(triplex_font);
/* report any registration errors */
if (errorcode < 0)
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* select the registered font */
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 4);
/* output some text */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(midx, midy, "The TRIPLEX FONT");
/* clean up */
getch();
closegraph();
return 0;
}
47.Restorecrtmode <GRAPHICS.H>
Restores screen mode to pre-initgraph setting
Declaration: void far restorecrtmode(void);
Remarks: restorecrtmode restores the original video mode detected by initgraph. This function can be used in conjunction with setgraphmode to switch back and forth between text and graphics modes.
■ NOTE: Do NOT use textmode for this purpose. Use textmode only when the screen is in text mode, to change to a different text mode.
Return Value: None
Portability: Dos
See Also: getgraphmode initgraph setgraphmode
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int x, y;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
x = getmaxx() / 2;
y = getmaxy() / 2;
/* output a message */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(x, y, "Press any key to exit graphics:");
getch();
/* restore system to text mode */
restorecrtmode();
printf("We're now in text mode.\n");
printf("Press any key to return to graphics mode:");
getch();
/* return to graphics mode */
setgraphmode(getgraphmode());
/* output a message */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(x, y, "We're back in graphics mode.");
outtextxy(x, y+textheight("W"), "Press any key to halt:");
/* clean up */
getch();
closegraph();
return 0;
}
48.Setactivepage, setvisualpage <GRAPHICS.H>
■ setactivepage sets the active page for graphics output
■ setvisualpage sets the visual graphics page number
Declaration:
■ void far setactivepage(int page);
■ void far setvisualpage(int page);
Remarks:
■ setactivepage makes page the active graphics page. All subsequent graphics output will be directed to that graphics page.
■ setvisualpage makes page the visual graphics page.
The active graphics page might not be the one you see onscreen, depending on how many graphics pages are available on your system. Only the EGA, VGA, and Hercules graphics cards support multiple pages. The visual page is the one actually displayed on the screen. Graphics functions write output to the active page.
Return Value: None
Portability: Dos
See Also: graphresult
Example (for both functions):
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* select a driver and mode that supports multiple pages. */
int gdriver = EGA, gmode = EGAHI, errorcode;
int x, y, ht;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
x = getmaxx() / 2;
y = getmaxy() / 2;
ht = textheight("W");
/* select the off screen page for drawing */
setactivepage(1);
/* draw a line on page #1 */
line(0, 0, getmaxx(), getmaxy());
/* output a message on page #1 */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(x, y, "This is page #1:");
outtextxy(x, y+ht, "Press any key to halt:");
/* select drawing to page #0 */
setactivepage(0);
/* output a message on page #0 */
outtextxy(x, y, "This is page #0.");
outtextxy(x, y+ht, "Press any key to view page #1:");
getch();
/* select page #1 as the visible page */
setvisualpage(1);
/* clean up */
getch();
closegraph();
return 0;
}
49.Setfillstyle <GRAPHICS.H>
Sets the fill pattern and color
Declaration: void far setfillstyle(int pattern, int color);
Remarks: setfillstyle sets the current fill pattern and fill color.
To set a user-defined fill pattern, do not give a pattern of 12 (USER_FILL) to setfillstyle; instead, call setfillpattern. The enumeration fill_patterns, defined in GRAPHICS.H, gives names for the predefined fill patterns, plus an indicator for a user-defined pattern.
Return Value: None
If invalid input is passed to setfillstyle, graphresult returns -11 (grError), and the current fill pattern and fill color remain unchanged.
Portability: Dos
See Also: bar bar3d fillpoly floodfill
getfillsettings graphresult pieslice sector
Example:
#include <graphics.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
/* the names of the fill styles supported */
char *fname[] = { "EMPTY_FILL", "SOLID_FILL", "LINE_FILL", "LTSLASH_FILL",
"SLASH_FILL", "BKSLASH_FILL", "LTBKSLASH_FILL", "HATCH_FILL",
"XHATCH_FILL", "INTERLEAVE_FILL", "WIDE_DOT_FILL",
"CLOSE_DOT_FILL", "USER_FILL" };
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int style, midx, midy;
char stylestr[40];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
for (style = EMPTY_FILL; style < USER_FILL; style++)
{
/* select the fill style */
setfillstyle(style, getmaxcolor());
/* convert style into a string */
strcpy(stylestr, fname[style]);
/* fill a bar */
bar3d(0, 0, midx-10, midy, 0, 0);
/* output a message */
outtextxy(midx, midy, stylestr);
/* wait for a key */
getch();
cleardevice();
}
/* clean up */
getch();
closegraph();
return 0;
}
50.Setgraphbufsize <GRAPHICS.H)
Changes the size of the internal graphics buffer
Declaration: unsigned far setgraphbufsize(unsigned bufsize);
Remarks: Some of the graphics routines (such as floodfill) use a memory buffer that is allocated when initgraph is called, and released when closegraph is called. The default size of this buffer, allocated by
_graphgetmem, is 4,096 bytes. You can make this buffer smaller (to save memory space) or bigger (if, for example, a call to floodfill produces error -7: Out of flood memory). setgraphbufsize tells initgraph how much memory to allocate for this internal graphics buffer when it calls _graphgetmem. You must call setgraphbufsize before calling initgraph. Once initgraph has been called, all calls to setgraphbufsize are ignored until after the next call to closegraph.
Return Value:setgraphbufsize returns the previous size of the internal buffer.
Portability: Dos
See Also: _graphfreemem _graphgetmem closegraph
initgraph sector
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#define BUFSIZE 1000 /* internal graphics buffer size */
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int x, y, oldsize;
char msg[80];
/* set the size of the internal graphics buffer */
/* before making a call to initgraph. */
oldsize = setgraphbufsize(BUFSIZE);
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
x = getmaxx() / 2;
y = getmaxy() / 2;
/* output some messages */
sprintf(msg, "Graphics buffer size: %d", BUFSIZE);
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(x, y, msg);
sprintf(msg, "Old graphics buffer size: %d", oldsize);
outtextxy(x, y+textheight("W"), msg);
/* clean up */
getch();
closegraph();
return 0;
}
51.Setlinestyle <GRAPHICS.H>
Sets the current line style and width or pattern
Declaration:
void far setlinestyle(int linestyle, unsigned upattern, int thickness);
Remarks: setlinestyle sets the style for all lines drawn by line, lineto, rectangle, drawpoly, etc.
Return Value: If invalid input is passed to setlinestyle, graphresult returns -11, and the current line style remains unchanged.
Portability: Dos
See Also: arc bar3d circle drawpoly
ellipse getlinesettings graphresult line
linerel lineto pieslice rectangle
sector
Example:
#include <graphics.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <conio.h>
/* the names of the line styles supported */
char *lname[] = {"SOLID_LINE", "DOTTED_LINE", "CENTER_LINE",
"DASHED_LINE", "USERBIT_LINE"};
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int style, midx, midy, userpat;
char stylestr[40];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* a user defined line pattern */
/* binary: "0000000000000001" */
userpat = 1;
for (style=SOLID_LINE; style<=USERBIT_LINE; style++)
{
/* select the line style */
setlinestyle(style, userpat, 1);
/* convert style into a string */
strcpy(stylestr, lname[style]);
/* draw a line */
line(0, 0, midx-10, midy);
/* draw a rectangle */
rectangle(0, 0, getmaxx(), getmaxy());
/* output a message */
outtextxy(midx, midy, stylestr);
/* wait for a key */
getch();
cleardevice();
}
/* clean up */
closegraph();
return 0;
}
52.Setpalette <GRAPHICS.H>
Changes one palette color
Declaration: void far setpalette(int colornum, int color);
Remarks: setpalette changes the colornum entry in the palette to color. For example, setpalette(0,5) changes the first color in the current palette (the background color) to actual color number 5. If size is the number of entries in the current palette, colornum can range between 0 and (size - 1). You can partially (or completely) change the colors in the EGA/VGA palette with setpalette. On a CGA, you can only change the first entry in the palette (colornum = 0, the background color) with a call to setpalette. The color parameter passed to setpalette can be represented by symbolic constants defined in GRAPHICS.H. Valid colors depend on the current graphics driver and current graphics mode. Changes made to the palette are seen immediately onscreen. Each time a palette color is changed, all occurrences of that color onscreen change to the new color value.
┌───────────────────────────────────────────┐
│ NOTE: setpalette can't be used with the │
│ IBM-8514 driver. Use setrgbpalette │
│ instead. │
└───────────────────────────────────────────┘
Return Value: If invalid input is passed to setpalette, graphresult returns -11, and the current palette remains unchanged.
Portability: Dos
See Also: getpalette graphresult setallpalette
setbkcolor setcolor
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int color, maxcolor, ht;
int y = 10;
char msg[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
maxcolor = getmaxcolor();
ht = 2 * textheight("W");
/* display the default colors */
for (color=1; color<=maxcolor; color++)
{
setcolor(color);
sprintf(msg, "Color: %d", color);
outtextxy(1, y, msg);
y += ht;
}
/* wait for a key */
getch();
/* black out the colors one by one */
for (color=1; color<=maxcolor; color++)
{
setpalette(color, BLACK);
getch();
}
/* clean up */
closegraph();
return 0;
}
53.Setrgbpalette <GRAPHICS.H>
Defines colors for IBM-8514 graphics card
Declaration:
void far setrgbpalette(int colornum, int red, int green, int blue);
Remarks: setrgbpalette can be used with the IBM 8514 and VGA drivers. colornum defines the palette entry to be loaded, while red, green, and blue define the component colors of the palette entry. For the IBM 8514 display (and the VGA in 256K color mode), colornum is in the range 0 to 255. For the remaining modes of the VGA, colornum is in the range 0 to 15. Only the lower byte of red, green, or blue is used, and out of each byte, only the 6 most significant bits are loaded in the palette. For compatibility with other IBM graphics adapters, the BGI driver defines the first 16 palette entries of the IBM 8514 to the default colors of the EGA/VGA. These values can be used as is, or they can be changed with setrgbpalette.
Return Value: None
Portability: Dos
See Also: setpalette
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* select a driver and mode that supports the use */
/* of the setrgbpalette function. */
int gdriver = VGA, gmode = VGAHI, errorcode;
struct palettetype pal;
int i, ht, y, xmax;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* grab a copy of the palette */
getpalette(&pal);
/* create gray scale */
for (i=0; i<pal.size; i++)
setrgbpalette(pal.colors[i], i*4, i*4, i*4);
/* display the gray scale */
ht = getmaxy() / 16;
xmax = getmaxx();
y = 0;
for (i=0; i<pal.size; i++)
{
setfillstyle(SOLID_FILL, i);
bar(0, y, xmax, y+ht);
y += ht;
}
/* clean up */
getch();
closegraph();
return 0;
}
54.Settextjustify <GRAPHICS.H>
Sets text justification for graphics mode
Declaration: void far settextjustify(int horiz, int vert);
Remarks: Text output after a call to settextjustify is justified around the current position (CP) horizontally and vertically, as specified.
The default justification settings are
■ LEFT_TEXT (for horizontal) and
■ TOP_TEXT (for vertical)
The enumeration text_just in GRAPHICS.H provides names for the horiz and vert settings passed to settextjustify. settextjustify affects text written with
outtext and can't be used with text-mode and stream functions.
Return Value: If invalid input is passed to settextjustify, graphresult returns -11, and the current text justification remains unchanged.
Portability: Dos
See Also: gettextsettings graphresult outtext settextstyle
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
/* function prototype */
void xat(int x, int y);
/* horizontal text justification settings */
char *hjust[] = { "LEFT_TEXT", "CENTER_TEXT", "RIGHT_TEXT"};
/* vertical text justification settings */
char *vjust[] = { "LEFT_TEXT", "CENTER_TEXT", "RIGHT_TEXT"};
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int midx, midy, hj, vj;
char msg[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
/* loop through text justifications */
for (hj=LEFT_TEXT; hj<=RIGHT_TEXT; hj++)
for (vj=LEFT_TEXT; vj<=RIGHT_TEXT; vj++)
{
cleardevice();
/* set the text justification */
settextjustify(hj, vj);
/* create a message string */
sprintf(msg, "%s %s", hjust[hj], vjust[vj]);
/* create cross hairs on the screen */
xat(midx, midy);
/* output the message */
outtextxy(midx, midy, msg);
getch();
}
/* clean up */
closegraph();
return 0;
}
/* draw an "x" at (x, y) */
void xat(int x, int y)
{
line(x-4, y, x+4, y);
line(x, y-4, x, y+4);
}
55.Settextstyle <GRAPHICS.H>
Sets the current text characteristics
Declaration:
void far settextstyle(int font, int direction, int charsize);
Remarks: settextstyle sets the text font, the direction in which text is displayed, and the size of the characters. A call to settextstyle affects all text output by outtext and outtextxy.
font
One 8x8 bit-mapped font and several "stroked" fonts are available. The 8x8 bit-mapped font, the default, is built into the graphics system.
The enumeration font_names, defined in GRAPHICS.H, provides names for the different font settings.
direction
Font directions supported are horizontal text (left to right) and vertical text (rotated 90 degrees counterclockwise).
The default direction is HORIZ_DIR.
Name │ Value │ Direction
═══════════Ï═══════Ï═══════════════
HORIZ_DIR │ 0 │ Left to right
VERT_DIR │ 1 │ Bottom to top
charsize
The size of each character can be magnified using the charsize factor.
If charsize is non-zero, it can affect bit-mapped or stroked characters.
A charsize value of 0 can be used only with stroked fonts.
charsize │
value │ outtext and outtextxy ...
══════════Ï════════════════════════════════════════════════════════════════
0 │ Magnify the stroked font text using either the default
│ character magnification factor (4) or the user-defined
│ character size given by setusercharsize.
1 │ Display characters from the 8x8 bit-mapped font in an
│ 8x8 pixel rectangle onscreen.
2 │ Display characters from the 8x8 bit-mapped font in a
│ 16x16 pixel rectangle
3 │ Display characters from the 8x8 bit-mapped font in a
│ 24x24 pixel rectangle
... │ (Up to a limit of ten times the normal size)
Always use textheight and textwidth to determine the actual dimensions of the text.
Return Value: None
Portability: Dos
See Also: gettextsettings graph_charsize graphresult
installuserfont settextjustify
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
/* the names of the text styles supported */
char *fname[] = { "DEFAULT font", "TRIPLEX font", "SMALL font",
"SANS SERIF font", "GOTHIC font"};
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int style, midx, midy;
int size = 1;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
midx = getmaxx() / 2;
midy = getmaxy() / 2;
settextjustify(CENTER_TEXT, CENTER_TEXT);
/* loop through the available text styles */
for (style=DEFAULT_FONT; style<=GOTHIC_FONT; style++)
{
cleardevice();
if (style == TRIPLEX_FONT)
size = 4;
/* select the text style */
settextstyle(style, HORIZ_DIR, size);
/* output a message */
outtextxy(midx, midy, fname[style]);
getch();
}
/* clean up */
closegraph();
return 0;
}
56.Setusercharsize <GRAPHICS.H>
User-defined character magnification factor for stroked fonts
Declaration:
void far setusercharsize(int multx, int divx, int multy, int divy);
Remarks: setusercharsize gives you finer control over the size of text from stroked fonts used with graphics functions. The values set by setusercharsize are active only if charsize = 0, as set by a previous call to settextstyle. With setusercharsize, you specify factors by which the width and height are scaled.
■ the default width is scaled by multx : divx
■ the default height is scaled by multy : divy.
For example, to make text twice as wide and 50% taller than the default, set
multx = 2; divx = 1; /* 2:1 */
multy = 3; divy = 2; /* 3:2 */
Return Value: None
Portability: Dos
See Also: gettextsettings graphresult settextstyle
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request autodetection */
int gdriver = DETECT, gmode, errorcode;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* select a text style */
settextstyle(TRIPLEX_FONT, HORIZ_DIR, 4);
/* move to the text starting position */
moveto(0, getmaxy() / 2);
/* output some normal text */
outtext("Norm ");
/* make the text 1/3 the normal width */
setusercharsize(1, 3, 1, 1);
outtext("Short ");
/* make the text 3 times normal width */
setusercharsize(3, 1, 1, 1);
outtext("Wide");
/* clean up */
getch();
closegraph();
return 0;
}
57.Setviewport <GRAPHICS.H>
Sets the current viewport for graphics output
Declaration:
void far setviewport(int left, int top, int right, int bottom, int clip);
Remarks: setviewport establishes a new viewport for graphics output. The viewport's corners are given in absolute screen coordinates by (left,top) and
(right,bottom). The current position (CP) is moved to (0,0) in the new window. The clip argument determines whether drawings are clipped (truncated) at the current viewport boundaries. If clip is non-zero, all drawings will be clipped to the current viewport.
Return Value: setviewport does not return. If invalid input is passed to setviewport, graphresult returns -11, and the current view settings remain unchanged.
Portability:
See Also: clearviewport getviewsettings graphresult
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
#define CLIP_ON 1 /* activates clipping in viewport */
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
setcolor(getmaxcolor());
/* message in default full-screen viewport */
outtextxy(0, 0, "* <-- (0, 0) in default viewport");
/* create a smaller viewport */
setviewport(50, 50, getmaxx()-50, getmaxy()-50, CLIP_ON);
/* display some text */
outtextxy(0, 0, "* <-- (0, 0) in smaller viewport");
/* clean up */
getch();
closegraph();
return 0;
}
58.Setactivepage, setvisualpage <GRAPHICS.H>
■ setactivepage sets the active page for graphics output
■ setvisualpage sets the visual graphics page number
Declaration:
■ void far setactivepage(int page);
■ void far setvisualpage(int page);
Remarks:
■ setactivepage makes page the active graphics page. All subsequent graphics output will be directed to that graphics page.
■ setvisualpage makes page the visual graphics page.
The active graphics page might not be the one you see onscreen, depending on how many graphics pages are available on your system. Only the EGA, VGA, and Hercules graphics cards support multiple pages. The visual page is the one actually displayed on the screen. Graphics functions write output to the active page.
Return Value: None
Portability: Dos
See Also: graphresult
Example (for both functions):
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* select a driver and mode that supports multiple pages. */
int gdriver = EGA, gmode = EGAHI, errorcode;
int x, y, ht;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
x = getmaxx() / 2;
y = getmaxy() / 2;
ht = textheight("W");
/* select the off screen page for drawing */
setactivepage(1);
/* draw a line on page #1 */
line(0, 0, getmaxx(), getmaxy());
/* output a message on page #1 */
settextjustify(CENTER_TEXT, CENTER_TEXT);
outtextxy(x, y, "This is page #1:");
outtextxy(x, y+ht, "Press any key to halt:");
/* select drawing to page #0 */
setactivepage(0);
/* output a message on page #0 */
outtextxy(x, y, "This is page #0.");
outtextxy(x, y+ht, "Press any key to view page #1:");
getch();
/* select page #1 as the visible page */
setvisualpage(1);
/* clean up */
getch();
closegraph();
return 0;
}
59.setwritemode <GRAPHICS.H>
Sets the writing mode for line drawing in graphics mode
Declaration: void far setwritemode(int mode);
Remarks: Symbolic constants are defined for mode. Each constant corresponds to a binary operation between each byte in the line and the corresponding bytes onscreen.
Constant │Value│ What It Means
══════════Ï═════Ï════════════════════════════════════════════════════════
COPY_PUT │ 0 │ Uses the assembly language MOV instruction, overwriting
│ │ with the line whatever is on the screen.
XOR_PUT │ 1 │ Uses the XOR command to combine the line with the
│ │ screen.
│ │ Two successive XOR commands will erase the line and
│ │ restore the screen to its original appearance.
setwritemode currently works only with line, linerel, lineto, rectangle, and drawpoly.
Return Value: None
Portability: Dos
See Also: drawpoly line linerel
lineto putimage rectangle
Example:
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main()
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int xmax, ymax;
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
xmax = getmaxx();
ymax = getmaxy();
/* select XOR drawing mode */
setwritemode(XOR_PUT);
/* draw a line */
line(0, 0, xmax, ymax);
getch();
/* erase the line by drawing over it */
line(0, 0, xmax, ymax);
getch();
/* select overwrite drawing mode */
setwritemode(COPY_PUT);
/* draw a line */
line(0, 0, xmax, ymax);
/* clean up */
getch();
closegraph();
return 0;
}
60.Textheight, textwidth <GRAPHICS.H>
■ textheight returns the height of a string in pixels
■ textwidth returns the width of a string in pixels
Declaration:
■ int far textheight(char far *textstring);
■ int far textwidth(char far *textstring);
Remarks:
■ textheight takes the current font size and multiplication factor, and determines the height of textstring in pixels.
■ textwidth takes the string length, current font size, and multiplication factor, and determines the width of textstring in pixels.
These functions are useful for adjusting the spacing between lines, computing viewport heights, sizing a title to make it fit on a graph or in a box, etc..
For example, with the 8x8 bit-mapped font and a multiplication factor of 2 (set by settextstyle), the string "Turbo C++" is 16 pixels high. Instead of doing the computations manually, use textheight to compute the height of strings, and use textwidth to compute their width. When you use these functions, no source code modifications are required when you select different fonts.
Return Value: textheight returns the text height in pixels. textwidth returns the text width in pixels.
Portability: Dos
It works only with IBM PCs and compatibles equipped with supported graphics display adapters.
See Also: gettextsettings outtext outtextxy settextstyle
Examples:
· textheight example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int y = 0;
int i;
char msg[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
/* draw some text on the screen */
for (i=1; i<11; i++)
{
/* select the text style, direction, and size */
settextstyle(TRIPLEX_FONT, HORIZ_DIR, i);
/* create a message string */
sprintf(msg, "Size: %d", i);
/* output the message */
outtextxy(1, y, msg);
/* advance to the next text line */
y += textheight(msg);
}
/* clean up */
getch();
closegraph();
return 0;
}
· textwidth example
#include <graphics.h>
#include <stdlib.h>
#include <stdio.h>
#include <conio.h>
int main(void)
{
/* request auto detection */
int gdriver = DETECT, gmode, errorcode;
int x = 0, y = 0;
int i;
char msg[80];
/* initialize graphics and local variables */
initgraph(&gdriver, &gmode, "");
/* read result of initialization */
errorcode = graphresult();
if (errorcode != grOk) /* an error occurred */
{
printf("Graphics error: %s\n", grapherrormsg(errorcode));
printf("Press any key to halt:");
getch();
exit(1); /* terminate with an error code */
}
y = getmaxy() / 2;
settextjustify(LEFT_TEXT, CENTER_TEXT);
for (i=1; i<11; i++)
{
/* select the text style, direction, and size */
settextstyle(TRIPLEX_FONT, HORIZ_DIR, i);
/* create a message string */
sprintf(msg, "Size: %d", i);
/* output the message */
outtextxy(x, y, msg);
/* advance to the end of the text */
x += textwidth(msg);
}
/* clean up */
getch();
closegraph();
return 0;
}
Constants, data types, and global variables
1. Arccoordstype <GRAPHICS.H>
Used to get current viewport settings from getarccoords.
struct arccoordstype {
int x, y; /* center point of arc*/
int xstart, ystart; /* start position */
int xend, yend; /* end position */
};
These values are useful if you need to make a line meet the end of an arc.
See Also: arc
2. COLORS, CGA_COLORS, and EGA_COLORS
(Enumerated Constants for Colors)
These tables show
■ the symbolic constants used to set text attributes on CGA and EGA monitors. (Defined in CONIO.H.)
■ the drawing colors available for BGI functions running on CGA and EGA
monitors. (Defined in GRAPHICS.H.)
The COLORS constants are used by these text mode functions:
textattr textbackground textcolor
The CGA_COLORS and EGA_COLORS constants are used by these BGI graphics functions: setallpalette setbkcolor
setcolor setpalette
Valid colors depend on the current graphics
driver and current graphics mode.
COLORS (text mode) │Back-│Fore-
Constant │Value│grnd?│grnd?
══════════════Ï═════Ï═════Ï═════
BLACK │ 0 │ Yes │ Yes
BLUE │ 1 │ Yes │ Yes
GREEN │ 2 │ Yes │ Yes
CYAN │ 3 │ Yes │ Yes
RED │ 4 │ Yes │ Yes
MAGENTA │ 5 │ Yes │ Yes
BROWN │ 6 │ Yes │ Yes
LIGHTGRAY │ 7 │ Yes │ Yes
DARKGRAY │ 8 │ No │ Yes
LIGHTBLUE │ 9 │ No │ Yes
LIGHTGREEN │ 10 │ No │ Yes
LIGHTCYAN │ 11 │ No │ Yes
LIGHTRED │ 12 │ No │ Yes
LIGHTMAGENTA │ 13 │ No │ Yes
YELLOW │ 14 │ No │ Yes
WHITE │ 15 │ No │ Yes
──────────────┼─────┼─────┼──────
BLINK │128 │ No │ ***
*** To display blinking characters in text mode, add BLINK to the foreground color. (Defined in CONIO.H.)
3. CGA_COLORS (graphics mode)
In this table, the palette listings CGA0, CGA1, CGA2, and CGA3 refer to the four predefined four-color palettes available on CGA (and compatible) systems.
Palette║ Constant assigned to this color number (pixel value)
Number ║ 1 │ 2 │ 3
════════╬════════════════Ï══════════════════Ï═════════════════
CGA0 ║ CGA_LIGHTGREEN │ CGA_LIGHTRED │ CGA_YELLOW
CGA1 ║ CGA_LIGHTCYAN │ CGA_LIGHTMAGENTA │ CGA_WHITE
CGA2 ║ CGA_GREEN │ CGA_RED │ CGA_BROWN
CGA3 ║ CGA_CYAN │ CGA_MAGENTA │ CGA_LIGHTGRAY
You can select the background color (entry #0) in each of these palettes, but the other colors are fixed.
4. EGA_ COLORS (graphics mode)
Constant │Value║ Constant │Value
═══════════════Ï═════╬══════════════════Ï═════
EGA_BLACK │ 0 ║ EGA_DARKGRAY │ 56
EGA_BLUE │ 1 ║ EGA_LIGHTBLUE │ 57
EGA_GREEN │ 2 ║ EGA_LIGHTGREEN │ 58
EGA_CYAN │ 3 ║ EGA_LIGHTCYAN │ 59
EGA_RED │ 4 ║ EGA_LIGHTRED │ 60
EGA_MAGENTA │ 5 ║ EGA_LIGHTMAGENTA │ 61
EGA_LIGHTGRAY │ 7 ║ EGA_YELLOW │ 62
EGA_BROWN │ 20 ║ EGA_WHITE │ 63
5. Fill_patterns <GRAPHICS.H>
Enum: Fill patterns for getfillsettings and setfillstyle.
Names │Value│ Means Fill With...
═════════════════Ï═════Ï════════════════════════════
EMPTY_FILL │ 0 │ Background color
SOLID_FILL │ 1 │ Solid fill
LINE_FILL │ 2 │ ---
LTSLASH_FILL │ 3 │ ///
SLASH_FILL │ 4 │ ///, thick lines
BKSLASH_FILL │ 5 │ \\\, thick lines
LTBKSLASH_FILL │ 6 │ \\\
HATCH_FILL │ 7 │ Light hatch
XHATCH_FILL │ 8 │ Heavy crosshatch
INTERLEAVE_FILL │ 9 │ Interleaving lines
WIDE_DOT_FILL │ 10 │ Widely spaced dots
CLOSE_DOT_FILL │ 11 │ Closely spaced dots
USER_FILL │ 12 │ User-defined fill pattern
All but EMPTY_FILLL fill with the current fill color. EMPTY_FILL uses the current background color.
6. Fillsettingstype <GRAPHICS.H>
Used to get current fill settings from getfillsettings.
struct fillsettingstype {
int pattern; /* current fill pattern */
int color; /* current fill color */
};
The functions bar, bar3d, fillpoly, pieslice, and floodfill all fill an area with the current fill pattern in the current fill color.
If pattern = 12 (USER_FILL), a user-defined fill pattern is being used.
Otherwise, pattern gives the number of a predefined pattern.
There are 11 predefined fill pattern styles (solid, crosshatch, dotted, etc.). Symbolic names for the predefined patterns are provided by the enumerated type fill_patterns in GRAPHICS.H. You can also define your own fill pattern. Symbolic names for colors are also defined in GRAPHICS.H.
7. Font_names <GRAPHICS.H>
Enum: Names for BGI fonts
Name │Value│ Meaning
════════════════Ï═════Ï═════════════════════════
DEFAULT_FONT │ 0 │ 8x8 bit-mapped font
TRIPLEX_FONT │ 1 │ Stroked triplex font
SMALL_FONT │ 2 │ Stroked small font
SANS_SERIF_FONT│ 3 │ Stroked sans-serif font
GOTHIC_FONT │ 4 │ Stroked gothic font
See Also: settextstyle
8. Graphics_drivers <GRAPHICS.H>
Enum: BGI graphics drivers
Constant │ Value
══════════Ï═════════════════════════════════
DETECT │ 0 (requests autodetection)
CGA │ 1
MCGA │ 2
EGA │ 3
EGA64 │ 4
EGAMONO │ 5
IBM8514 │ 6
HERCMONO │ 7
ATT400 │ 8
VGA │ 9
PC3270 │ 10
See Also: graphics_modes initgraph
9. Graphics_errors <GRAPHICS.H>
Enum: Error return code from graphresult
Error│ graphics_errors │
code │ constant │ Corresponding error message string
══════Ï═══════════════════Ï═══════════════════════════════════════════════
0 │ grOk │ No error
-1 │ grNoInitGraph │ (BGI) graphics not installed (use initgraph)
-2 │ grNotDetected │ Graphics hardware not detected
-3 │ grFileNotFound │ Device driver file not found
-4 │ grInvalidDriver │ Invalid device driver file
-5 │ grNoLoadMem │ Not enough memory to load driver
-6 │ grNoScanMem │ Out of memory in scan fill
-7 │ grNoFloodMem │ Out of memory in flood fill
-8 │ grFontNotFound │ Font file not found
-9 │ grNoFontMem │ Not enough memory to load font
-10 │ grInvalidMode │ Invalid graphics mode for selected driver
-11 │ grError │ Graphics error
-12 │ grIOerror │ Graphics I/O error
-13 │ grInvalidFont │ Invalid font file
-14 │ grInvalidFontNum │ Invalid font number
-15 │ grInvalidDeviceNum│ Invalid device number
-18 │ grInvalidVersion │ Invalid version number
10.Graphics_modes <GRAPHICS.H>
Enum: Graphics modes for each BGI driver
Graphics│
driver │graphics_modes│Value│Column x Row│ Palette │Pages
═════════Ï══════════════Ï═════Ï════════════Ï═════════Ï══════════
CGA │ CGAC0 │ 0 │ 320 x 200 │ C0 │ 1
│ CGAC1 │ 1 │ 320 x 200 │ C1 │ 1
│ CGAC2 │ 2 │ 320 x 200 │ C2 │ 1
│ CGAC3 │ 3 │ 320 x 200 │ C3 │ 1
│ CGAHI │ 4 │ 640 x 200 │ 2 color│ 1
─────────┼──────────────┼─────┼────────────┼─────────┼───────
MCGA │ MCGAC0 │ 0 │ 320 x 200 │ C0 │ 1
│ MCGAC1 │ 1 │ 320 x 200 │ C1 │ 1
│ MCGAC2 │ 2 │ 320 x 200 │ C2 │ 1
│ MCGAC3 │ 3 │ 320 x 200 │ C3 │ 1
│ MCGAMED │ 4 │ 640 x 200 │ 2 color│ 1
│ MCGAHI │ 5 │ 640 x 480 │ 2 color│ 1
─────────┼──────────────┼─────┼────────────┼─────────┼───────
EGA │ EGALO │ 0 │ 640 x 200 │ 16 color│ 4
│ EGAHI │ 1 │ 640 x 350 │ 16 color│ 2
─────────┼──────────────┼─────┼────────────┼─────────┼───────
EGA64 │ EGA64LO │ 0 │ 640 x 200 │ 16 color│ 1
│ EGA64HI │ 1 │ 640 x 350 │ 4 color│ 1
─────────┼──────────────┼─────┼────────────┼─────────┼───────
EGA-MONO│ EGAMONOHI │ 3 │ 640 x 350 │ 2 color│ 1*
│ EGAMONOHI │ 3 │ 640 x 350 │ 2 color│ 2**
─────────┼──────────────┼─────┼────────────┼─────────┼───────
HERC │ HERCMONOHI │ 0 │ 720 x 348 │ 2 color│ 2
─────────┼──────────────┼─────┼────────────┼─────────┼───────
ATT400 │ ATT400C0 │ 0 │ 320 x 200 │ C0 │ 1
│ ATT400C1 │ 1 │ 320 x 200 │ C1 │ 1
│ ATT400C2 │ 2 │ 320 x 200 │ C2 │ 1
│ ATT400C3 │ 3 │ 320 x 200 │ C3 │ 1
│ ATT400MED │ 4 │ 640 x 200 │ 2 color│ 1
│ ATT400HI │ 5 │ 640 x 400 │ 2 color│ 1
─────────┼──────────────┼─────┼────────────┼─────────┼───────
VGA │ VGALO │ 0 │ 640 x 200 │ 16 color│ 2
│ VGAMED │ 1 │ 640 x 350 │ 16 color│ 2
│ VGAHI │ 2 │ 640 x 480 │ 16 color│ 1
─────────┼──────────────┼─────┼────────────┼─────────┼───────
PC3270 │ PC3270HI │ 0 │ 720 x 350 │ 2 color│ 1
─────────┼──────────────┼─────┼────────────┼─────────┼───────
IBM8514 │ IBM8514HI │ 1 │ 1024 x 760 │256 color│
│ IBM8514LO │ 0 │ 640 x 480 │256 color│
* 64K on EGAMONO card
** 256K on EGAMONO card
See Also: detectgraph graphics_drivers initgraph
11.HORIZ_DIR and VERT_DIR <GRAPHICS.H>
#defines that set the direction of graphics output
Name │Value│ Direction
═══════════Ï═════Ï═══════════════════════════
HORIZ_DIR │ 0 │ Left to right
VERT_DIR │ 1 │ Bottom to top (rotated 90
│ │ degrees counterclockwise)
See Also: gettextsettings settextstyle setusercharsize
12.Line_styles <GRAPHICS.H>
Enum: Line styles for getlinesettings and setlinestyle.
Name │Value│ Meaning
═════════════Ï═════Ï═════════════════════════
SOLID_LINE │ 0 │ Solid line
DOTTED_LINE │ 1 │ Dotted line
CENTER_LINE │ 2 │ Centered line
DASHED_LINE │ 3 │ Dashed line
USERBIT_LINE│ 4 │ User-defined line style
13.Line_widths <GRAPHICS.H>
Enum: Line widths for getlinesettings and setlinestyle.
Name │Value│ Meaning
════════════Ï═════Ï══════════════
NORM_WIDTH │ 1 │ 1 pixel wide
THICK_WIDTH│ 3 │ 3 pixels wide
See Also: line_styles
14.Linesettingstype <GRAPHICS.H>
Used by getlinesettings and setlinestyle to adjust how lines are drawn.
struct linesettingstype {
int linestyle;
unsigned upattern;
int thickness;
};
Element │ What It Is/Does
═══════════Ï══════════════════════════════════════════════════════════════
upattern │ The user-defined bit pattern used when linestyle is set to
│ USERBIT_LINE.
linestyle │ Specifies in which style subsequent lines will be drawn
│ (such as solid, dotted, centered, dashed).
thickness │ Specifies whether the width of subsequent lines drawn will be
│ normal or thick. (enum line_widths)
upattern is a 16-bit pattern that applies only if linestyle is USERBIT_LINE (4). In that case, whenever a bit in the pattern word is 1, the corresponding pixel in the line is drawn in the current drawing color.
For example, a solid line corresponds to a upattern of 0xFFFF (all pixels drawn), while a dashed line can correspond to a upattern of 0x3333 or 0x0F0F or 0x3F3F.
16-bit pattern │ upattern
══════════════════Ï═══════════════════════
..xx..xx..xx..xx │ 0x3333 (short dashes)
....xxxx....xxxx │ 0x0F0F (long dashes)
..xxxxxx..xxxxxx │ 0x3F3F (longer dashes)
xxxxxxxxxxxxxxxx │ 0xFFFF (solid line)
15.MAXCOLORS <GRAPHICS.H>
Defines the maximum number of color entries
for the color array field in the palettetype.
See Also: setallpalette
16.Palettetype <GRAPHICS.H>
Contains palette information for the current graphics driver when calling getpalette, setpalette, and setallpalette.
struct palettetype {
unsigned char size;
signed char colors[MAXCOLORS+1];
};
Element│ What It Is/Does
════════Ï═══════════════════════════════════════════════════════════════════
size │ Gives the number of colors in the palette for the current
│ graphics driver in the current mode.
colors │ An array of size bytes containing the actual raw color numbers
│ for each entry in the palette. If an element of colors is
│ -1, the palette color for that entry is not changed.
17.Pointtype <GRAPHICS.H>
Coordinates of a point.
struct pointtype {
int x ;
int y ;
};
18.Putimage_ops <GRAPHICS.H>
Enum: Operators for putimage
Constant│Value│ Meaning
═════════Ï═════Ï═══════════════════════════════════════════════════════
COPY_PUT│ 0 │ Copies source bitmap onto screen
XOR_PUT │ 1 │ Exclusive ORs source image with that already onscreen
OR_PUT │ 2 │ Inclusive ORs image with that already onscreen
AND_PUT │ 3 │ ANDs image with that already onscreen
NOT_PUT │ 4 │ Copy the inverse of the source
19.Text_just <GRAPHICS.H>
Enum: Horizontal and vertical justification for settextjustify
Argument│ Constant │Value│ Meaning
═════════Ï═════════════Ï═════Ï═════════════════════
horiz │ LEFT_TEXT │ 0 │ Left-justify text
│ CENTER_TEXT │ 1 │ Center text
│ RIGHT_TEXT │ 2 │ Right-justify text
vert │ BOTTOM_TEXT │ 0 │ Justify from bottom
│ CENTER_TEXT │ 1 │ Center text
│ TOP_TEXT │ 2 │ Justify from top
In calls to settextjustify, if
■ horiz = LEFT_TEXT and
■ direction = HORIZ_DIR
the CP's x component is advanced after a call to outtext(string) by textwidth(string).
20.Textsettingstype <GRAPHICS.H>
Used to get the current text settings from
gettextsettings.
struct textsettingstype {
int font;
int direction;
int charsize;
int horiz;
int vert;
};
21.USER_CHAR_SIZE
User-defined charsize (charsize = character magnification in graphics output)
Values define
Value│ Display size of 8 x 8 bit-mapped fonts
═════Ï════════════════════════════════════════
1 │ Display chars in 8 x 8 box onscreen
2 │ Display chars in 16 x 16 box onscreen
... │ ...
10 │ Display chars in 80 x 80 box onscreen
See Also: gettextsettings settextstyle
setusercharsize textsettingstype
22.Viewporttype <GRAPHICS.H>
Used to get current viewport settings from getviewsettings.
struct viewporttype {
int left;
int top;
int right;
int bottom;
int clip;
};
No comments :
Post a Comment