NAME

SYNOPSIS

DESCRIPTION

The user opens and initializes a graphics device by calling the MFBOpen routine that returns a pointer to that device's MFB data structure defined at the end of this manual. By maintaining several MFB data structures, an application program can drive several graphics devices simultaneously. Once opened, MFB graphics routines can be called to draw geometries, draw graphics text, set device parameters, or receive keyboard input. An application program can also use any of the several utility routines that perform line clipping, polygon clipping, or windowviewport transformations. Control of the graphics device is released by calling the MFBClose routine.

All programs that use MFB routines must include the file mfb.h that defines the MFB data structure to contain the information provided by MFBCAP(5).

INITIALIZATION ROUTINES

MFB *MFBOpen(TerminalName, DeviceName, errorcode)
char *TerminalName, *DeviceName;
int *errorcode;

#define	MFBOK	 1	/* successful return */
#define	MFBBADENT	-10	/* Unknown terminal type */
#define	MFBBADMCF 	-20	/* Can't open MFBCAP file */
#define	MFBMCELNG 	-30	/* MFBCAP entry too long */
#define	MFBBADMCE 	-40	/* Bad MFBCAP entry */
#define	MFBINFMCE 	-50	/* infinite loop in MFBCAP entry */
#define	MFBBADTTY 	-60	/* stdout not in /dev */
#define	MFBBADDEV	-180	/* Can't open or close device */
#define	MFBBADOPT	-190	/* Can't access or set device stat */
#define	MFBBADWRT 	-220	/* Error during write */

void SetCurrentMFB(mfb)
MFB *mfb;

int MFBInitialize()

int MFBClose()

int MFBHalt()

SETTING DEVICE PARAMETERS

#define	MFBOK	 1	/* successful return */
#define	MFBBADLST 	-70	/* Illegal line style */
#define	MFBBADFST 	-80	/* Illegal fill style */
#define	MFBBADCST	-90	/* Illegal color style */
#define	MFBBADTM1	-100	/* No destructive text mode */
#define	MFBBADTM2	-110	/* No overstriking text mode */
#define	MFBNOBLNK 	-150	/* No definable blinkers */
#define	MFBTMBLNK 	-160	/* Too many blinkers */
#define	MFBNOMASK	-170	/* No definable read or write mask */
#define	MFBBADALU	-250	/* Cannot set ALU mode */

int MFBSetLineStyle(styleId)
int styleId;

int MFBSetFillPattern(styleId)
int styleId;

int MFBSetChannelMask(channelMask)
int channelMask;

int MFBSetReadMask(readmask)
int readmask;

int MFBSetColor(colorId)
int colorId;

int MFBSetTextMode(destructiveBool)
Bool destructiveBool;

int MFBSetALUMode(alumode)
int alumode;

#define	MFBALUJAM 	0	/* set ALU mode to JAM */
#define	MFBALUOR	1	/* set ALU mode to OR */
#define	MFBALUNOR	2	/* set ALU mode to NOR */
#define	MFBALUEOR	3	/* set ALU mode to EOR */

int MFBSetCursorColor(colorId1, colorId2)
int colorId1, colorId2;

int MFBSetRubberBanding(onFlag, X, Y)
int X, Y;
Bool onFlag;

int MFBSetBlinker(colorId, red, green, blue, onFlag)
int colorId;
int red, green, blue;
int onFlag;

DEFINING DEVICE PARAMETERS

#define	MFBOK	 1	/* successful return */
#define	MFBNODFLP 	-120	/* No definable line patterns */
#define	MFBNODFFP 	-130	/* No definable fill patterns */
#define	MFBNODFCO 	-140	/* No definable colors */

int MFBDefineColor(colorId, red, green, blue)
int colorId;
int red, green, blue;

int MFBDefineFillPattern(styleId, BitArray)
int styleId;
int *BitArray;

int MFBDefineLineStyle(styleId, Mask)
int styleId;
int Mask;

INPUTOUTPUT ROUTINES

int MFBUpdate()

int MFBPoint(X, Y, key, button)
int *X, *Y, *button;
char *key;

#define	MFBOK	 1	/* successful return */
#define	MFBPNTERR 	-230	/* Error in pointing device */
#define	MFBNOPTFT 	-240	/* No pointing format */
#define	MFBNOPNT	-260	/* No pointing device */

char *MFBKeyboard(X, Y, background, foreground)
int background;
int foreground;
int X, Y;

void MFBAudio()

int MFBPutchar(c)
char c;

int MFBPutstr(cp,nchars)
int nchars;
char *cp;

int MFBGetchar()

TWO DIMENSIONAL GEOMETRY ROUTINES

void MFBMoveTo(X1, Y1)
int X1, Y1;

void MFBDrawLineTo(X1, Y1)
int X1, Y1;

void MFBLine(X1, Y1, X2, Y2)
int X1, Y1, X2, Y2;

void MFBBox(left, bottom, right, top)
int left, bottom, right, top;

void MFBDrawPath(path)
MFBPATH *path;

struct mfbpath {
	int nvertices;	/* number of (x,y) coordinate pairs */
	int *xy;	/* pointer to array of (x,y) coordinates */
	};
typedef struct mfbpath MFBPATH;

void MFBFlood()

void MFBPixel(X, Y)
int X, Y;

void MFBCircle(X, Y, rad, nsides)
int X, Y, rad, nsides;

void MFBFlash(X, Y, rad, nsides)
int X, Y, rad, nsides;

void MFBArc(X, Y, rad, angle1, angle2, nsides)
int X, Y, rad;
int angle1, angle2, nsides;

void MFBPolygon(poly)
MFBPOLYGON *poly;

struct mfbpolygon {
	int nvertices;	/* number of (x,y) coordinate pairs */
	int *xy;	/* pointer to array of (x,y) coordinates */
	};
typedef struct mfbpolygon MFBPOLYGON;

MFBPATH *MFBArcPath(X, Y, rad, angle1, angle2, nsides)
int X, Y, rad;
int angle1, angle2, nsides;

MFBPOLYGON *MFBEllipse(X, Y, radx, rady, nsides)
int X, Y, rad, nsides;

void MFBText(text, X, Y, phi)
char *text;
int X, Y, phi;

void MFBNaiveBoxFill(left, bottom, right, top)
int top, bottom, left, right;

RASTER ROUTINES

void MFBRasterCopy(X,Y,DX,DY,DestX,DestY);
int X,Y,DX,DY,DestX,DestY;

INFORMATION ACQUISITION

int MFBInfo(info);
int info;

#define	MAXX	1	/* max x coordinate */
#define	MAXY	2	/* max y coordinate */
#define	MAXCOLORS	3	/* max number of colors */
#define	MAXINTENSITY	4	/* max color intensity */
#define	MAXFILLPATTERNS	5	/* max number of fill patterns */
#define	MAXLINESTYLES	6	/* max number of line styles */
#define	MAXBLINKERS	7	/* max number of blinkers */
#define	POINTINGDEVICE	8	/* terminal has pointing device */
#define	POINTINGBUTTONS	9	/* pointing device has buttons */
#define	NUMBUTTONS	10	/* num. of pointing dev. buttons */
#define	BUTTON1	11	/* value returned by button 1 */
#define	BUTTON2	12	/* value returned by button 2 */
#define	BUTTON3	13	/* value returned by button 3 */
#define	BUTTON4	14	/* value returned by button 4 */
#define	BUTTON5	15	/* value returned by button 5 */
#define	BUTTON6	16	/* value returned by button 6 */
#define	BUTTON7	17	/* value returned by button 7 */
#define	BUTTON8	18	/* value returned by button 8 */
#define	BUTTON9	19	/* value returned by button 9 */
#define	BUTTON10	20	/* value returned by button 10 */
#define	BUTTON11	21	/* value returned by button 11 */
#define	BUTTON12	22	/* value returned by button 12 */
#define	TEXTPOSITIONALBE	30	/* Bool: positionable text */
#define	TEXTROTATABLE	31	/* Bool: rotatable text */
#define	FONTHEIGHT	32	/* font height in pixels */
#define	FONTWIDTH	33	/* font width in pixels */
#define	FONTXOFFSET	34 	/* font x offset in pixels */
#define	FONTYOFFSET	35	/* font y offset in pixels */
#define	DESTRUCTIVETEXT	36	/* Bool: text can be destructive */
#define	OVERSTRIKETEXT	37	/* Bool: text can be overstrike */
#define	VLT	38	/* Bool: terminal has VLT */
#define	BLINKERS	39	/* Bool: terminal has blinkers */
#define	FILLEDPOLYGONS	40	/* Bool: terminal can fill polygons */
#define	DEFFILLPATTERNS	41	/* Bool: definable fill patterns */
#define	DEFCHANNELMASK	42	/* Bool: definable write mask */
#define	DEFLINEPATTERN	43	/* Bool: definable line styles */
#define	CURFGCOLOR	44	/* current foreground color */
#define	CURFILLPATTERN	45	/* current fill pattern */
#define	CURLINESTYLE	46	/* current line style */
#define	CURCHANNELMASK	47	/* current channel mask */
#define	CURREADMASK	48	/* current read mask */
#define	NUMBITPLANES	49	/* number of bit planes */
#define	DEFREADMASK	50	/* Bool: definable read mask */
#define	RASTERCOPY	51	/* Bool: term has raster copy */
#define	OFFSCREENX	52	/* left of off screen memory */
#define	OFFSCREENY	53	/* bottom of off screen memory */
#define	OFFSCREENDX	54	/* length of off screen memory */
#define	OFFSCREENDY	55	/* width of off screen memory */

WINDOWVIEWPORT TRANSFORMATIONS

void MFBSetViewport(left, bottom, right, top)
int left, bottom, right, top;

void MFBSetWindow(left, bottom, right, top)
int left, bottom, right, top;

int MFBScaleX(X)
int X;

int MFBScaleY(Y)
int Y;

int MFBDescaleX(X)
int X;

int MFBDescaleY(Y)
int Y;

GEOMETRY CLIPPING ROUTINES

void MFB_Y_Intercept(X1, Y1, X2, Y2, value, Yvalue)
int X1, Y1, X2, Y2;
int value;
int *Yvalue;

void MFB_X_Intercept(X1, Y1, X2, Y2, value, Xvalue)
int X1, Y1, X2, Y2;
int value;
int *Xvalue;

void MFBLineClip(X1, Y1, X2, Y2, left, bottom, right, top);
int *X1, *Y1, *X2, *Y2;
int left, bottom, right, top;

void MFBPolygonClip(poly, top, bottom, left, right)
MFBPOLYGON *poly;
int top, bottom, left, right;

MFBPATH *MFBArcClip(path, left, bottom, right, top)
MFBPATH *path;
int left, bottom, right, top;

SPECIAL VIEWPORT ROUTINES

void MFBMore(left, bottom, right, top, Textfile)
int left, bottom, right, top;
FILE *Textfile;

void MFBScroll(left, bottom, right, top, Textfile)
int left, bottom, right, top;
FILE *Textfile;

DIAGNOSTICS

char *MFBError(errnum)
int errnum;

#define	MFBBADENT	-10	/* Unknown terminal type */
#define	MFBBADMCF	-20	/* Can't open mfbcap file */
#define	MFBMCELNG	-30	/* MFBCAP entry too long */
#define	MFBBADMCE	-40	/* Bad mfbcap entry */
#define	MFBINFMCE	-50	/* Infinite mfbcap entry */
#define	MFBBADTTY	-60	/* stdout not in /dev */
#define	MFBBADLST	-70	/* Illegal line style */
#define	MFBBADFST	-80	/* Illegal fill style */
#define	MFBBADCST	-90	/* Illegal color style */
#define	MFBBADTM1	-100	/* No destructive text */
#define	MFBBADTM2	-110	/* No overstriking text */
#define	MFBNODFLP	-120	/* No definable line styles */
#define	MFBNODFFP	-130	/* No definable fill styles */
#define	MFBNODFCO	-140	/* No definable colors */
#define	MFBNOBLNK	-150	/* No blinkers */
#define	MFBTMBLNK	-160	/* Too many blinkers */
#define	MFBBADDEV	-180	/* Can't open or close device */
#define	MFBBADOPT	-190	/* Can't access or set device stat */
#define	MFBNOMASK	-170	/* No definable read or write mask */
#define	MFBBADWRT	-200	/* Error in write */
#define	MFBPNTERR	-210	/* Error in pointing device */
#define	MFBNOPTFT	-220	/* No format for pointing device */
#define	MFBNOPNT	-230	/* No pointing device */
#define	MFBNORBND	-240	/* No Rubberbanding */
#define	MFBBADALU	-250	/* Cannot set ALU mode */

void MFBZeroCounters()

void MFBCounters(nCh,nBx,BxArea,nLn,LnLngth,nPxl)
int *nCh,*nBx,*BxArea,*nLn,*LnLngth,*nPxl;

THE MFB DATA STRUCTURE

The MFB data structure is listed below.

#define	TTY	't'
#define	HCOPY	'r'
typedef enum {false, true} Bool;
struct mfb_window {
	int left;
	int right;
	int top;
	int bottom;
	double length,width;
	};
typedef struct mfb_window WINDOW;
typedef struct mfb_window VIEWPORT;
struct mfbpath {
	int nvertices;
	int *xy;
	};
typedef struct mfbpath MFBPOLYGON;
typedef struct mfbpath MFBPATH;
#ifndef vms
struct mfbremttyb {
	struct sgttyb oldttyb;
	struct sgttyb newttyb;
	};
struct mfbremstat {
	int graphttyw;	/* old mode bits of graphics device */
	int kybrdttyw;	/* old mode bits of standard I/O */
	struct stat graphstat;	/* old fstats of graphics device */
	struct stat kybrdstat;	/* old fstats of standard I/O */
	};
typedef struct mfbremttyb MFBSAVETTYB;
typedef struct mfbremstat MFBSAVESTAT;
#endif
struct mfbformatstrs {
	char *startSequence;	/* first transmitted sequence */
	char *endSequence;	/* last transmitted sequence */
	char *initLineStyles;	/* initialize line styles */
	char *initFillPatterns;	/* initialize fill styles */
	char *initColorStyles;	/* initialize color styles */
	char *vltEntry;	/* define color in VLT */
	char *setForegroundColor;	/* set current foreground color */
	char *screenFlood;	/* flood screen to current color */
	char *channelMaskSet;	/* set write mask */
	char *readMaskSet;	/* set read mask */
	char *enablePointingDevice;	/* initialize pointing device */
	char *enableRubberBanding;	/* turn on rubber banding */
	char *disablePointingDevice;	/* disable pointing device and cursor */
	char *disableRubberBanding;	/* turn off rubber banding */
	char *readPointingDevice;	/* wait and read pointing device */
	char *formatPointingDevice;	/* decode format for pointing device */
	char *keyboardStart;	/* initailize keyboard */
	char *keyboardEnd;	/* terminate keyboard input */
	char *keyboardBackspace;	/* keyboard backspace sequence */
	char *audio;	/* ring the terminals bell */
	char *lineDefineStart;	/* begin defining a line pattern */
	char *lineDefineFormat;	/* define bit array of line pattern */
	char *lineDefineEnd;	/* terminate line pattern definition */
	char *setLineStyle;	/* set current line style */
	char *setSolidLineStyle;	/* set current line style to solid */
	char *movePenSequence;	/* move current graphics position */
	char *drawLineSequence;	/* draw a line in current style */
	char *drawSolidLineSequence;	/* draw a solid line */
	char *drawLineToSequence;	/* move and draw current position */
	char *drawSolidLineToSequence;	/* move and draw solid line */
	char *drawBoxSequence;	/* draw box in current style */
	char *drawSolidBoxSequence;	/* draw a solid box */
	char *beginPlygnSequence;	/* begin polygon in cur. fill style */
	char *beginSolidPlygnSequence;	/* begin solid polygon */
	char *sendPlygnVertex;	/* define one point in polygon */
	char *endPlygnSequence;	/* terminate polygon sequence */
	char *drawCircleSequence;	/* draw a circle in solid line style */
	char *rotateTextSequence;	/* rotate graphic text */
	char *graphicsTextStart;	/* begin graphic text */
	char *graphicsTextEnd;	/* terminate graphic text */
	char *replaceON;	/* turn on destructive text mode */
	char *overstrikeON;	/* turn on overstriking text mode */
	char *writePixel;	/* write one pixel in current color */
	char *setALUEOR;	/* set ALU mode to EOR */
	char *setALUNOR;	/* set ALU mode to NOR */
	char *setALUOR;	/* set ALU mode to OR */
	char *setALUJAM;	/* set ALU mode to JAM or REPLACE */
	char *blinkerON;	/* make a color blink */
	char *blinkerOFF;	/* turn off a blinking layer */
	char *rastCopyStart;	/* begin raster copy sequence */
	char *rastCopyEnd;	/* terminate raster copy sequence */
	char *rastCopyDest;	/* define raster copy destionation */
	char *rastCopySource;	/* define raster copy source area */
	char *fillDefineStart;	/* begin defining a fill style */
	char *fillDefineFormat;	/* define bit array of row/column */
	char *fillDefineEnd;	/* terminate fill style definition */
	char *setFillPattern;	/* set current fill pattern */
	char *setSolidFillPattern;	/* set current fill pattern to solid */
	};
struct mfb {	/* MFB DATA STRUCT */
	/*
	* INTEGERS FIELDS
	*/
/* used for decode */	int lastX,lastY;	/* for Tektronix encoding */
	int X,Y,Z,T;	/* parameter list */
/* Resolution */	int maxX;	/* horizontal resolution */
	int maxY;	/* vertical resolution */
	int maxColors;	/* maximum number of colors */
	int minOffScreenX;	/* left of off screen memory */
	int minOffScreenY;	/* bottom of off screen mem. */
	int offScreenDX;	/* length of off screen mem. */
	int offScreenDY;	/* width of off screen mem. */
/* Video Layer Table */	int maxIntensity;	/* max RGB or LS intensity */
	int lengthOfVLT;	/* number of bit planes */
/* Pointing Device */	int buttonMask[12];	/* returned button masks */
	int numberOfButtons;	/* 12 maximum */
/* Keyboard Control */	int keyboardYOffset;
	int keyboardXOffset;
/* Line Drawing */	int lineDefineLength;	/* number of bytes in array */
	int maxLineStyles;	/* number of line styles */
/* Text font */	int fontHeight;	/* font height in pixels */
	int fontWidth;	/* font width in pixels */
	int fontXOffset;
	int fontYOffset;
/* Blinkers */	int maxBlinkers;	/* number of blinkers */
/* Fill Patterns */	int fillDefineHeight;	/* number of byte rows */
	int fillDefineWidth;	/* number of byte columns */
	int maxFillPatterns;	/* number of fill patterns */
/* Current variables */	int cursorColor1Id;	/* blinked cursor color ID */
	int cursorColor2Id;	/* unblinked cursor color ID */
	int fgColorId;	/* cur. foreground color ID */
	int fillPattern;	/* cur. fill pattern ID */
	int lineStyle;	/* cur. line style ID */
	int channelMask;	/* cur. write mask */
	int readMask;	/* cur. read mask */
	int numBlinkers;	/* cur. number of blinkers */
	int textMode;	/* text mode (1=dest, 0=rep) */
	int stipplePattern[8];	/* cur. stipple pattern */
	int fileDesc;	/* desc. for graphics device */
	int numTtyBuffer;	/* cur. chars in output queue */
	/*
	* POINTERS
	*/
/* for tty's only */	char *name;	/* device name */
	char *terminalName;	/* name of MFBCAP entry */
/* I/O routines */	int (*dsply_getchar)();
	int (*kybrd_getchar)();
	int (*dsply_ungetchar)();
	int (*kybrd_ungetchar)();
	int (*outchar)();
	int (*outstr)();
	/*
	* BOOLEANS
	*/
	Bool initializedBool;
/* Video Layer Table */	Bool vltBool;
	Bool vltUseHLSBool;
/* Channel Mask */	Bool channelMaskBool;
	Bool readMaskBool;
/* Pointing Device */	Bool PointingDeviceBool;
	Bool buttonsBool;
	Bool readImmediateBool;
/* Keyboard Control */	Bool keyboardBool;
/* Line Drawing */	Bool linePatternDefineBool;
	Bool reissueLineStyleBool;
/* Polygon Drawing */	Bool filledPlygnBool;
/* Text font */	Bool textPositionableBool;
	Bool textRotateBool;
	Bool replaceTextBool;
	Bool overstrikeTextBool; 
/* Blinkers */	Bool blinkersBool;
/* Raster Copy */	Bool rastCopyBool;
	Bool rastRSCSFBool;
/* Fill Patterns */	Bool fillPtrnDefineBool;
	Bool fillDefineRowMajorBool;
/* for tty's only */	Bool litout;
	Bool raw;
	Bool ttyIsSet;
	/*
	* STRUCTURES
	*/
	struct mfbformatstrs strings;	/* format strings */
	WINDOW currentWindow;	/* current window */
	VIEWPORT currentViewport;	/* current viewport */
#ifndef vms
	/* graphics device ttyb struct */
	MFBSAVETTYB graphTtyb;
	/* keyboard ttyb struct if graphics device does not have a kybrd */
	MFBSAVETTYB kybrdTtyb;
	/* tty status ints */
	MFBSAVESTAT oldstat;
#endif
	/*
	* CHARACTERS
	*/
	char deviceType;	/* TTY=tty, HCOPY=hard copy */
	char strBuf[BUFSIZE];	/* storage for format strings */
	char ttyBuffer[TTYBUFSIZE];	/* tty output buffer */
	};
typedef struct mfb MFB;

EXAMPLE

#include <cad/mfb.h>
main(argc, argv)
	int argc;
	char *argv[];
	{
	int i, j, k, m;
	int X1, X2, Y1, Y2;
	int numcolors;
	int numlinestyles;
	int button;
	int error;
	MFB *mfb, *MFBOpen();
	MFBPATH *pp;
	char key;
	char *TypeIn;
	/* open graphics device */
	mfb = MFBOpen(argv[1], NULL, &error);
	/* exit on any error */
	if(error < 0) {
		fprintf(stderr, "error:  %s\n", MFBError(error));
		exit(0);
		}
	/* get device information */
	X1 = MFBInfo(MAXX)/2;
	X2 = X1/2;
	Y1 = MFBInfo(MAXY)/30;
	numcolors = MFBInfo(MAXCOLORS);
	numlinestyles = MFBInfo(MAXLINESTYLES);
	if(numcolors > 7)
		numcolors = 7;
	if(numlinestyles > 7)
		numlinestyles = 7;
	/* draw pyramid of lines in different line styles */
	for(j=0; j<28; ++j) {
		/* set color (increment by one to prevent 'invisible' lines) */
		k = j % (numcolors - 1);
		MFBSetColor(k + 1);
		/* define and set line style */
		m = j % numlinestyles;
		MFBDefineLineStyle(m, j * 6);
		MFBSetLineStyle(m);
		/* draw pyramid */
		MFBLine(0, 0, X2, Y1*j + 2*j);
		MFBLine(X1, 0, X2, Y1*j + 2*j);
		}
	/* flush output */
	MFBUpdate();
	/* test of MFBKeyboard */
	MFBText("Test of MFBKeyboard.", X2, Y1*28, 0);
	TypeIn = MFBKeyboard(X1, 5, 0, 1);
	MFBText(TypeIn, X1, 70, 0);
	MFBText(TypeIn, X1, 70, 90);
	MFBText(TypeIn, X1, 70, 180);
	MFBText(TypeIn, X1, 70, 270);
	MFBUpdate();
	sleep(3);
	/* test of MFBPoint */
	MFBSetColor(1);
	MFBFlood();
	MFBSetColor(0);
	MFBText("Test of MFBPoint.", X2, Y1*28, 0);
	MFBPoint(&X1, &Y1, &key, &button);
	MFBPoint(&X2, &Y2, &key, &button);
	MFBSetLineStyle(0);
	MFBLine(X1, Y1, X2, Y2);
	/* draw outline of box to contain arc */
	MFBLine(100, 100, 100, 350);
	MFBLine(100, 100, 370, 100);
	MFBLine(370, 100, 370, 350);
	MFBLine(100, 350, 370, 350);
	/* test of MFBArcPath and MFBClipArc */
	i = 0;
	pp = MFBClipArc(MFBArcPath(70, 70, 200, 0, 0, 30), 100, 100, 370, 350);
	while(pp[i].nvertices != 0 && i < 4) {
		MFBDrawPath(&pp[i]);
		i++;
		}
	/* flush output and wait */
	MFBUpdate();
	sleep(6);
	MFBClose();
	}
    

DEBOUNCING THE POINTING DEVICE

#include <cad/mfb.h>
#ifdef vms
#include <timeb.h>
#else
#include <sys/timeb.h>
#endif
/*
	* This is the minimum time in milliseconds
	* between accepted pointing events.
	*/
#define DEBOUNCETIME 100
/*
	* we keep track of the time between pointing
	* events to debounce the cursor
	*/
static long LastPointTime = 0;
/*
	* routine to read and debounce pointing device.
	*/
point(pointX,pointY,Key,Mask)
	int *pointX,*pointY,*Mask;
	char *Key;
	{
	struct timeb now;
	long newtime;
	int X,Y,Buttons;
	char KeyTyped;
	SetDebounceTime();
	/* Loop until DEBOUNCETIME has passed */
	while(True) {
		/* Loop until valid report is received */
		while(True) {
			/* Get pointing event */
			MFBPoint(&X,&Y,&KeyTyped,&Buttons);
			/* Was a character typed? */
			if(Key != 0)
				break;
			/* Does the pointing device have buttons? */
			if(MFBInfo(POINTINGBUTTONS)){
				/*
				* Test button masks and vicinity of coordinate.
				* Assume a four button mouse.
				*/
				if((Buttons == MFBInfo(BUTTON1) ||
					Buttons == MFBInfo(BUTTON2) ||
					Buttons == MFBInfo(BUTTON3) ||
					Buttons == MFBInfo(BUTTON4)) &&
					(X < MFBInfo(MAXX) && X > 0 &&
					Y < MFBInfo(MAXY) && Y > 0))
					break;
				}
			}
		ftime(&now);
		newtime = 1000 * now.time + now.millitm;
		if((newtime - LastPointTime) < DEBOUNCETIME) continue;
		SetDebounceTime();
		}
	*pointX = X;
	*pointY = Y;
	*Key = KeyTyped;
	*Mask = Buttons;
	}
SetDebounceTime(){
	struct timeb now;
	ftime(&now);
	LastPointTime = 1000 * now.time + now.millitm;
	}
    

NOTES

MFB will also compile to run under VMS (a trademark of Digital Equipment Corp.) or any other operating system. However, special I/O routines such as those in ~cadsrcmfbvmsio.c must be provided for MFB to function properly.

MFB was written to be utmost UNIX compatible and consistent with the style of the C programming language. For example, a control sequence always begins with a call to an (MFB)Open routine and is terminated by a call to a (MFB)Close routine. Another example is the provision of the MFBHalt routine that is intended primarily for the handling of the SIGTSTP signal. One possible exception to the style of C is the use of a global output descriptor that is set by a call to the SetCurrentMFB routine, as opposed to passing the output descriptor as an argument to ever active function call.

MFB was initially aimed toward the modeling of lower performance graphics terminals (e.g., there is currently no support of segments or definable windows and viewports at the device level). As a result, programs that use MFB are likely to work on the low performance (least expensive) graphics terminals as well as on the more expensive devices.

BUGS

FUTURE ENHANCEMENTS

Extension to hard copy graphics devices.

Definable vector and raster character fonts.

Improved cursor support including a definable cursor font, cursor tracking by the host, cursor-on/cursor-off capability, and cursor report without event.

Window/viewport geometry clipping by the terminal if the device possesses that capability.

Bit block transfer (BitBlt).

FILES

~cad/lib/mfbcap
~cad/include/mfb.h
~cad/lib/mfb.a
~cad/src/mfb

SEE ALSO

mfbcap(5), termcap(5), curses(3), more(1), kic(CAD1)

AUTHOR

Giles Billingsley
Ken Keller

STATUS

4014	Tektronix 4014 with thumbwheels
4113	Tektronix 4112/4113 with thumbwheels or tablet
AED5	AED 512 with joystick or tablet
AED7	AED 767 with joystick or tablet
2648	HP 2648 black and white grahpics terminal with tablet
9872	HP 9872 color pen plotter
D125	DEC VT125 black and white graphics terminal

The following table lists routines that depend on device capabilities and may not work on all graphics devices. Other MFB routines that are not listed below will work for all devices.