You could, however, use GRAD as a PC device driver for a more general set of line-oriented library functions. GRAD supplies almost all of the primitives you would need for such a project. Also, most printers support pixel graphics, so they can serve as hard-copy devices for programs that use pixel graphics. If your printer is similar to the Epson FX-80 or the Okidata ML192, you can adapt the software to work with your printer. An appendix at the back of the manual documents that process. In the general case, however, you may have to buy the source code from the author to make GRAD work with your printer.

• Translation—Moving a graphic element (a square, for example) to a new location.
• Scaling—Making a graphic element appear shorter and fatter, or taller and thinner.
• Rotation—Turning a graphic element around an axis.

GRAD does not support graphics scaling or rotation. If you want to draw the same symbol with different heights or widths, you must implement the scaling with your own code. Likewise, if you want to rotate a graphic image so that it appears sideways or upside-down, you'll have to write your own code to do this.

One reason you might want to do a transformation such as scaling is to solve the problem of aspect ratio. Aspect ratio is the ratio of a pixel's height to its width. GRAD assumes that each pixel is square, the same height as width. However, on a typical CGA monitor, each pixel is rectangular instead of square, that is, its aspect ratio is not 1:1.

The aspect ratio problem becomes very clear when you ask GRAD to draw a circle on a CGA monitor. It draws a true circle, but because the pixels are not square, the result on the screen is a "stretched" circle (an ellipse). In a line-based graphics library, this problem can be solved by applying the appropriate scaling transformation just before translating the line into pixels. In GRAD, however, there isn't much you can do except take the problem into account in your code and draw a rectangle to get a square, an ellipse to get a circle, and so on.

GRAD provides virtual screens which it calls "frames". A frame is a rectangular memory area where a graphic image is stored. If the memory area corresponds to video memory, then the graphic is visible on the screen. If the memory area is regular memory, the frame is a virtual graphics screen. A graphic image created in this area can only be seen by dumping it to the printer or by copying it to the video memory. Frames are especially useful for windowing operations, as described in the following section.

Another drawing attribute that GRAD lets you specify is the writing mode. On a pen plotter, a line is a line—you can never erase an existing line. On a graphics screen, however, there are several interesting possibilities. Usually, you want the screen to look like it would on a pen plotter. This is called OR mode, since it is accomplished by bitwise ORing the pixels to be drawn with the screen pixels' existing value. GRAD also supports an XOR mode and an AND mode.

The XOR mode can be used to "erase" lines, because if you draw a line in OR mode and then redraw the line in XOR mode, the line disappears. This isn't perfect, however; if there is a second line on the screen that intersects the first one, it will have a "hole" in it, because the pixel where the two lines intersected is turned off. You can also use XOR mode to achieve a kind of reverse-video effect, by turning on a block of pixels, switching to XOR mode, then drawing on the block.

Drawing lines in AND mode doesn't make much sense, because the only pixels that will get turned on are those that were already on. In other words, it will look as though nothing got drawn. AND mode is useful for Bit-Block Transfers, however.

Bit-Block Transfers, or bitblts (pronounced "bitblits"), are at the heart of windowing systems that operate in graphics mode. For example, moving a window from one place to another is a bitblt operation; so is removing a window (copying a block of background pattern to it). GRAD provides basic bitblt operations that allow you to transfer blocks between virtual screens and to and from files. GRAD's bitblt operations obey the current writing mode, so you can combine the block transfers with the bit-wise modes to do things like erase a window or cause a window to appear in reverse-video.

GRAD allows you to specify a single, rectangular clipping region called a "window". There is no on/off function to disable or enable the defined clipping region. Instead, GRAD supplies a ResetWin() function that redefines the clipping region to be the entire virtual screen (which effectively turns clipping off).

GRAD has no stroke fonts but supports bitmapped fonts. These fonts can be stored on files and loaded into memory dynamically, as needed. This is useful when you want to use many fonts, but don't want to consume a lot of memory. You can get the effect of rotated fonts (you can get one of four, 90-degree rotations) by using a specially rotated font file. There are 18 font files on the GRAD disk. Although most of these are variations on a couple of fonts, they provide good examples of what you can do. You can also make bitmapped fonts that have variable width. This looks more professional, especially with larger fonts.

GRAD also supplies a graphics input function that reads from the keyboard. This is very handy when you need to query the user while you are drawing graphics, since you will want the keyboard input to be echoed on the screen with graphic text. Remember that just calling gets() probably won't produce the desired result when the screen is in graphics mode.

draw() takes three arguments: a C string containing drawing commands and two integer arguments that can be used to parameterize the commands in the string. The key feature of the graphics commands that you store in the string is that they are relative to the current drawing coordinate. For example, here is a command that draws a rectangle at the current location.

Draw("RT10 DN5 LF10 UP5", 0, 0);

Draw("RT%OX DN%OY, LF%OX, UP%OY", 3, 10);

Notice that you could build up command strings, save them to files, and bring them back later — just as you would use a symbol library. GRAD just supplies the basic command string ability, though. You would have to design your own functions to manage a symbol library.

Fortunately, there is an easier solution. GRAD groups attributes like the current origin, clip region, line style, font, and so on, into a bundle which it calls an environment. The modular symbol or graphics routine can simply save the current environment before it begins drawing, and restore it after all its graphics operations are complete.

The input to the interpreter mimics the analagous C functions. Whenever a particular function returns a value, you can simply write:

var1 = function(val1, val2, ...)

function (&var1, &var2, ...)

MPrint (Merge Print) is a variation of Interp. MPrint allows you to specify a file containing lines of text that are merged with the graphics drawn by the interpreter. In other words, you can print graphics in graphics mode on the printer and print the text portions in text mode, which is much faster than printing text in graphics mode.

Conrad Kwok, GRAD's author, is distributing this graphics package as shareware. If you find his program useful, he requests that you send a contribution of $20 to him. If you send $20 or more, you will receive updates to the library. If you send a contribution of $60 or more, you will get the source for the latest version of GRAD, as well as a programmer reference manual which documents the internal data structures and algorithms used in the library. The source is copyrighted.

The licensing terms for GRAD are as follows:

• You may freely copy and distribute the GRAD library and related programs provided the documentation and sample programs are not modified in any way. However, you may write additions to the library and distribute those along with the original library.
• You may not charge a fee for distributing the library or your enhancements to it. However, you may charge a small fee for the cost of the disk, shipping, and handling.
• Your program must be in the public domain and must contain a message indicating that it contains code from GRAD, written by Conrad Kwok.