mfbbasic.c File Reference

#include "spice.h"
#include "mfb.h"
#include <stdio.h>
#include <string.h>

Include dependency graph for mfbbasic.c:

Go to the source code of this file.

Macros
#define	RadToDeg   57.29577951
#define	MFBFORMAT   MFBCurrent->strings
#define	WNDW   MFBCurrent->currentWindow
#define	VWPRT   MFBCurrent->currentViewport

Functions
void	MFBNaiveBoxFill ()
void	MFBSetGhost ()
int	MFBInfo (int Info)
void	MFBConvertToHLS (int r, int g, int b)
void	SetCurrentMFB (MFB *mfb)
void	MFBZeroCounters ()
void	MFBCounters (int *nChars, int *nBoxes, int *meanBoxArea, int *nLines, int *meanLineLength, int *nPixels)
	MFBSetLineStyle (int styleId)
	MFBSetFillPattern (int styleId)
int	MFBSetChannelMask (int channelMask)
int	MFBSetReadMask (int readMask)
int	MFBSetColor (int colorId)
int	MFBSetTextMode (Bool destructiveBool)
int	MFBSetALUMode (int mode)
int	MFBSetCursorColor (int colorId1, int colorId2)
int	MFBSetBlinker (int colorId, int r, int g, int b, int onFlag)
int	MFBSetRubberBanding (Bool RubberBandingBool, int X, int Y)
int	MFBDefineColor (int colorId, int r, int g, int b)
int	MFBDefineFillPattern (int styleId, int *BitArray)
int	MFBDefineLineStyle (int styleId, int BitArray)
void	MFBMoveTo (int X1, int Y1)
void	MFBDrawPath (MFBPATH *path)
void	MFBDrawLineTo (int X1, int Y1)
void	MFBLine (int X1, int Y1, int X2, int Y2)
void	MFBBox (int l, int b, int r, int t)
void	MFBArc (int x, int y, int r, int astart, int astop, int s)
void	MFBCircle (int x, int y, int r, int s)
void	MFBFlash (int x, int y, int r, int s)
void	MFBPolygon (MFBPOLYGON *p)
void	MFBText (char *text, int x, int y, int phi)
void	MFBPixel (int x, int y)
void	MFBFlood ()
MFBPATH *	MFBArcPath (int x, int y, int r, int astart, int astop, int s)
MFBPOLYGON *	MFBEllipse (int x, int y, int rx, int ry, int s)
int	MFBScaleX (int X)
int	MFBScaleY (int Y)
int	MFBDescaleX (int X)
int	MFBDescaleY (int Y)
void	MFBSetViewport (int left, int bottom, int right, int top)
void	MFBSetWindow (int left, int bottom, int right, int top)
void	MFBNaiveBoxFill (left, bottom, right, top)

Variables
MFB *	MFBCurrent
int	LastX
int	LastY

Macro Definition Documentation

#define MFBFORMAT   MFBCurrent->strings

Definition at line 28 of file mfbbasic.c.

#define RadToDeg   57.29577951

Definition at line 27 of file mfbbasic.c.

#define VWPRT   MFBCurrent->currentViewport

Definition at line 1094 of file mfbbasic.c.

#define WNDW   MFBCurrent->currentWindow

Definition at line 1093 of file mfbbasic.c.

Function Documentation

void MFBArc	(	int	x,
		int	y,
		int	r,
		int	astart,
		int	astop,
		int	s
	)

Definition at line 780 of file mfbbasic.c.

{
    int i,j,xx,yy;
    double d;

    d = astart / RadToDeg;
    xx = x + (int)(r * cos(d));
    yy = y + (int)(r * sin(d));
    /* Must use MFBLine to force a DSL sequence if style Id is solid */
    MFBLine(xx,yy,xx,yy);
    while(astart >= astop)
        astop += 360;
    if(s>2 && s<181)
        j = MFBmax(1,(astop - astart)/s);
    else
        j = MFBmax(1,(astop - astart)/18);
    for(i = astart + j; i <= astop; i += j){
        d = i / RadToDeg;
        MFBCurrent->X = x + (int)(r * cos(d));
        MFBCurrent->Y = y + (int)(r * sin(d));
        MFBGenCode(MFBFORMAT.drawLineToSequence);
    }
    d = astop / RadToDeg;
    MFBCurrent->X = x + (int)(r * cos(d));
    MFBCurrent->Y = y + (int)(r * sin(d));
    MFBGenCode(MFBFORMAT.drawLineToSequence);
}

MFBPATH* MFBArcPath	(	int	x,
		int	y,
		int	r,
		int	astart,
		int	astop,
		int	s
	)

Definition at line 1002 of file mfbbasic.c.

{
    static MFBPATH pth;
    static int xy[400];
    int *ip,i,j;
    double d;

    pth.xy = ip = xy;
    while(astart >= astop)
        astop += 360;
    if(s<2 || s>180)
        s = 20;
    pth.nvertices = 2;
    j = MFBmax(1,(astop - astart)/s);
    d = astart / RadToDeg;
    *ip++ = x + (int)(r * cos(d));
    *ip++ = y + (int)(r * sin(d));
    for(i = astart + j; i <= astop; i += j){
        d = i / RadToDeg;
        *ip++ = x + (int)(r * cos(d));
        *ip++ = y + (int)(r * sin(d));
        ++pth.nvertices;
    }
    d = astop / RadToDeg;
    *ip++ = x + (int)(r * cos(d));
    *ip   = y + (int)(r * sin(d));
    return(&pth);
}

void MFBBox	(	int	l,
		int	b,
		int	r,
		int	t
	)

Definition at line 751 of file mfbbasic.c.

{
#ifdef DEBUG
    MFBCurrent->nBoxes += 1;
    MFBCurrent->sumBoxArea += (r-l)*(t-b);
#endif
    MFBCurrent->X = l; MFBCurrent->Y = b; MFBCurrent->Z = r; MFBCurrent->T = t;
    if(MFBCurrent->fillPattern == 0
            && MFBFORMAT.drawSolidBoxSequence != NULL
            && *MFBFORMAT.drawSolidBoxSequence != 0) {
        MFBGenCode(MFBFORMAT.drawSolidBoxSequence);
    }
    else if (MFBFORMAT.drawBoxSequence != NULL
            && *MFBFORMAT.drawBoxSequence != 0) {
        MFBGenCode(MFBFORMAT.drawBoxSequence);
    }
    else
        MFBNaiveBoxFill(l,b,r,t);
}

void MFBCircle	(	int	x,
		int	y,
		int	r,
		int	s
	)

Definition at line 821 of file mfbbasic.c.

{
    int i,j=5;
    double d=0;

    if(MFBFORMAT.drawCircleSequence == NULL 
            || *MFBFORMAT.drawCircleSequence == 0) {
        MFBCurrent->X = x + r;
        MFBCurrent->Y = y;
        if(s>2 && s<181)
            j = MFBmax(1,360/s);
        for(i = j; i <= 360; i += j){
            d = i / RadToDeg;
            MFBCurrent->Z = x + (int)(r * cos(d));
            MFBCurrent->T = y + (int)(r * sin(d));
            MFBGenCode(MFBFORMAT.drawLineSequence);
            MFBCurrent->X = MFBCurrent->Z;
            MFBCurrent->Y = MFBCurrent->T;
            }
    } else {
        MFBCurrent->X = x;
        MFBCurrent->Y = y;
        MFBCurrent->Z = r;
        MFBGenCode(MFBFORMAT.drawCircleSequence);
    }
}

void MFBConvertToHLS	(	int	r,
		int	g,
		int	b
	)

Definition at line 158 of file mfbbasic.c.

{
    double rrr,ggg,bbb,rr,gg,bb,sum,dif,mx,mn,lit,intensity;
    intensity = (double)MFBCurrent->maxIntensity;
    /* RGB is normalized to 1000 */
    rr = ((double) r)/1000.0;
    gg = ((double) g)/1000.0;
    bb = ((double) b)/1000.0;
    mx = rr;
    if(mx < gg) mx = gg;
    if(mx < bb) mx = bb;
    mn = rr;
    if(mn > gg) mn = gg;
    if(mn > bb) mn = bb;
    sum = mx + mn; dif = mx - mn;
    if(dif != 0.0){
        rrr = (mx - rr)/dif; ggg = (mx - gg)/dif; bbb = (mx - bb)/dif;
    }
    /* lightness calculation */
    lit = sum/2.0;
    /* saturation calculation */
    if(mx == mn) MFBCurrent->T = 0;
    else if(lit <= .5) MFBCurrent->T = (int)(intensity * dif/sum);
    else MFBCurrent->T = (int)((intensity * dif)/(2.0 - sum));
    /* hue calculation */
    if(MFBCurrent->T == 0) MFBCurrent->Y = 0;
    else if(rr == mx) MFBCurrent->Y = (int)(60.0 * (2.0 + bbb - ggg));
    else if(gg == mx) MFBCurrent->Y = (int)(60.0 * (4.0 + rrr - bbb));
    else MFBCurrent->Y = (int)(60.0 * (6.0 + ggg - rrr));
    MFBCurrent->Z = (int)(intensity * lit);
}

void MFBCounters	(	int *	nChars,
		int*	nBoxes,
		int*	meanBoxArea,
		int*	nLines,
		int*	meanLineLength,
		int*	nPixels
	)

Definition at line 224 of file mfbbasic.c.

{
#ifdef DEBUG
    /*
     * routine for measuring approximate pixel bandwidth
     */
    *nChars = MFBCurrent->nChars;
    *nBoxes = MFBCurrent->nBoxes;
    *nLines = MFBCurrent->nLines;
    *meanLineLength = 0;
    *meanBoxArea = 0;
    if(MFBCurrent->nBoxes != 0)
        *meanBoxArea = MFBCurrent->sumBoxArea/MFBCurrent->nBoxes;
    if(MFBCurrent->nLines != 0)
        *meanLineLength = MFBCurrent->sumLineLength/MFBCurrent->nLines;
    *nPixels = 
        MFBCurrent->nChars*MFBCurrent->fontHeight*MFBCurrent->fontWidth+
        MFBCurrent->sumBoxArea+
        MFBCurrent->sumLineLength;
#else
    *nChars = *nBoxes = *nLines = *meanLineLength = *meanBoxArea = 0;
#endif
}

int MFBDefineColor	(	int	colorId,
		int	r,
		int	g,
		int	b
	)

Definition at line 549 of file mfbbasic.c.

{

    /* Are there user defineable colors? */
    if(!MFBCurrent->vltBool)
        return(MFBNODFCO);
    if(MFBCurrent->vltUseHLSBool){
        /* HLS return in MFBCurrent->Y, MFBCurrent->Z, MFBCurrent->T */
        MFBConvertToHLS(r,g,b);
    }
    else{
        /* Normalize to 1000 */
        MFBCurrent->Y = r * MFBCurrent->maxIntensity / 1000;
        MFBCurrent->Z = g * MFBCurrent->maxIntensity / 1000;
        MFBCurrent->T = b * MFBCurrent->maxIntensity / 1000;
    }
    MFBCurrent->X = MFBmax(0,MFBmin(MFBCurrent->maxColors,colorId));
    MFBGenCode(MFBFORMAT.vltEntry);
    return(MFBOK);
}

int MFBDefineFillPattern	(	int	styleId,
		int *	BitArray
	)

Definition at line 579 of file mfbbasic.c.

{
    int i,*j,Count;

    /* save current stipple pattern */
    for(i=0; i<8; ++i)
        MFBCurrent->stipplePattern[i] = BitArray[i];

    /*
     * Are there defineable fill patterns for this frame buffer?
     */
    if(!MFBCurrent->fillPtrnDefineBool) 
        return(MFBNODFFP);

    MFBCurrent->X = styleId;
    if(MFBCurrent->fillDefineRowMajorBool)
        Count = MFBCurrent->fillDefineHeight;
    else
        Count = MFBCurrent->fillDefineWidth;
    MFBGenCode(MFBFORMAT.fillDefineStart);
    for(i=0; i<Count; ++i){
        if( (int)((i/8) * 8) == i) j = BitArray;
        MFBCurrent->Y = *j++;
        MFBGenCode(MFBFORMAT.fillDefineFormat);
    }
    MFBGenCode(MFBFORMAT.fillDefineEnd);
    /* return with the new fill pattern as the current one */
    return( MFBSetFillPattern(styleId) );
}

int MFBDefineLineStyle	(	int	styleId,
		int	BitArray
	)

Definition at line 619 of file mfbbasic.c.

{
    int l;

    /*
     * Are there defineable line styles for this frame buffer?
     */
    if(!MFBCurrent->linePatternDefineBool)
        return(MFBNODFLP);

    MFBCurrent->X = styleId;
    MFBGenCode(MFBFORMAT.lineDefineStart);
    MFBCurrent->Y = BitArray;
    for(l = 0; l < MFBCurrent->lineDefineLength; ++l)
        MFBGenCode(MFBFORMAT.lineDefineFormat);
    MFBGenCode(MFBFORMAT.lineDefineEnd);
    /* return with the new line style as the current one */
    return( MFBSetLineStyle(styleId) );
}

int MFBDescaleX

(

int

X

)

Definition at line 1121 of file mfbbasic.c.

{
    int XX;

    XX = ((X-VWPRT.left)*WNDW.length)/VWPRT.length+WNDW.left;
    return(XX);
}

int MFBDescaleY

(

int

Y

)

Definition at line 1131 of file mfbbasic.c.

{
    int YY;

    YY = ((Y-VWPRT.bottom)*WNDW.width)/VWPRT.width+WNDW.bottom;
    return(YY);
}

void MFBDrawLineTo	(	int	X1,
		int	Y1
	)

Definition at line 696 of file mfbbasic.c.

{
    if(MFBCurrent->reissueLineStyleBool)
        MFBSetLineStyle(MFBCurrent->lineStyle);
    if(MFBFORMAT.drawLineToSequence == NULL
            || *MFBFORMAT.drawLineToSequence == 0) {
        MFBLine(LastX,LastY,X1,Y1);
        /* the assignment of lastX/Y is redundant for a Tek terminal */
        LastX = X1; LastY = Y1;
    }
    else{
        MFBCurrent->X = X1; MFBCurrent->Y = Y1;
        if(MFBCurrent->lineStyle == 0
                && MFBFORMAT.drawSolidLineToSequence != NULL
                && *MFBFORMAT.drawSolidLineToSequence != 0)
            MFBGenCode(MFBFORMAT.drawSolidLineToSequence);
        else
            MFBGenCode(MFBFORMAT.drawLineToSequence);
    }
}

void MFBDrawPath

(

MFBPATH *

path

)

Definition at line 669 of file mfbbasic.c.

{
    int n,x,y;
    if(MFBCurrent->reissueLineStyleBool)
        MFBSetLineStyle(MFBCurrent->lineStyle);
    if(path->nvertices < 2)
        return;
    n = 2;
    MFBLine(path->xy[0],path->xy[1],path->xy[2],path->xy[3]);
    while(n < path->nvertices){
        x = path->xy[(n << 1)];
        y = path->xy[(n << 1) + 1];
        MFBDrawLineTo(x,y);
        n++;
    }
}

MFBPOLYGON* MFBEllipse	(	int	x,
		int	y,
		int	rx,
		int	ry,
		int	s
	)

Definition at line 1043 of file mfbbasic.c.

{
    static MFBPOLYGON poly;
    static int xy[400];
    int i=0;
    int j;
    int *ip;
    double d=0;

    poly.xy = ip = xy;
    *ip++ = x + rx;
    *ip++ = y;
    if(s>2 && s<181)
        j = 360/s;
    else {
        j = 18;
        s = 20;
    }
    poly.nvertices = s + 1;
    while(--s) {
        i += j;
        d = i / RadToDeg;
        *ip++ = x + (int)(rx * cos(d));
        *ip++ = y + (int)(ry * sin(d));
    }
    *ip++ = x + rx;
    *ip++ = y;
    return(&poly);
}

void MFBFlash	(	int	x,
		int	y,
		int	r,
		int	s
	)

Definition at line 859 of file mfbbasic.c.

{
    int i=0,j;
    double d=0;

    MFBCurrent->X = x + r;
    MFBCurrent->Y = y;
    if(s>2 && s<181)
        j = 360/s;
    else {
        j = 5;
        s = 72;
    }
    MFBCurrent->Z = s;
    MFBGenCode(MFBFORMAT.beginPlygnSequence);
    for(i = j; i < 360; i += j){
        d = i / RadToDeg;
        MFBCurrent->X = x + (int)(r * cos(d));
        MFBCurrent->Y = y + (int)(r * sin(d));
        MFBGenCode(MFBFORMAT.sendPlygnVertex);
    }
    MFBCurrent->X = x + r;
    MFBCurrent->Y = y;
    MFBGenCode(MFBFORMAT.endPlygnSequence);
}

void MFBFlood

(

)

Definition at line 985 of file mfbbasic.c.

{
    MFBCurrent->X = MFBCurrent->fgColorId;
    MFBGenCode(MFBFORMAT.screenFlood);

    /*
     * MFBFlood may destroy last x/y,so be safe about it.
     */
    MFBCurrent->lastX  = MFBCurrent->lastY  = -1;
}

int MFBInfo

(

int

Info

)

Definition at line 44 of file mfbbasic.c.

{
    /*
     * Notes:
     *    MFBInfo is the only routine for acquiring device
     *    specific information.  The valid arguments are to
     *    MFBInfo are defined in mfb.h.  If an invalid argument
     *    is used, MFBInfo returns -1.
     */
    switch(Info){
    case  MAXX:
        return(MFBCurrent->maxX);
    case  MAXY:
        return(MFBCurrent->maxY);
    case  MAXCOLORS:
        return(MFBCurrent->maxColors);
    case  MAXINTENSITY:
        return(MFBCurrent->maxIntensity);
    case  MAXFILLPATTERNS:
        return(MFBCurrent->maxFillPatterns);
    case  MAXLINESTYLES:
        return(MFBCurrent->maxLineStyles);
    case  MAXBLINKERS:
        return(MFBCurrent->maxBlinkers);
    case  POINTINGDEVICE:
        return((int)MFBCurrent->PointingDeviceBool);
    case  POINTINGBUTTONS:
        return((int)MFBCurrent->buttonsBool);
    case  NUMBUTTONS:
        return(MFBCurrent->numberOfButtons);
    case  BUTTON1:
        return(MFBCurrent->buttonMask[0]);
    case  BUTTON2:
        return(MFBCurrent->buttonMask[1]);
    case  BUTTON3:
        return(MFBCurrent->buttonMask[2]);
    case  BUTTON4:
        return(MFBCurrent->buttonMask[3]);
    case  BUTTON5:
        return(MFBCurrent->buttonMask[4]);
    case  BUTTON6:
        return(MFBCurrent->buttonMask[5]);
    case  BUTTON7:
        return(MFBCurrent->buttonMask[6]);
    case  BUTTON8:
        return(MFBCurrent->buttonMask[7]);
    case  BUTTON9:
        return(MFBCurrent->buttonMask[8]);
    case  BUTTON10:
        return(MFBCurrent->buttonMask[9]);
    case  BUTTON11:
        return(MFBCurrent->buttonMask[10]);
    case  BUTTON12:
        return(MFBCurrent->buttonMask[11]);
    case  TEXTPOSITIONALBE:
        return((int)MFBCurrent->textPositionableBool);
    case  TEXTROTATABLE:
        return((int)MFBCurrent->textRotateBool);
    case  FONTHEIGHT:
        return(MFBCurrent->fontHeight);
    case  FONTWIDTH:
        return(MFBCurrent->fontWidth);
    case  FONTXOFFSET:
        return(MFBCurrent->fontXOffset);
    case  FONTYOFFSET:
        return(MFBCurrent->fontYOffset);
    case  DESTRUCTIVETEXT:
        return((int)MFBCurrent->replaceTextBool);
    case  OVERSTRIKETEXT:
        return((int)MFBCurrent->overstrikeTextBool);
    case  VLT:
        return((int)MFBCurrent->vltBool);
    case  BLINKERS:
        return((int)MFBCurrent->blinkersBool);
    case  FILLEDPOLYGONS:
        return((int)MFBCurrent->filledPlygnBool);
    case  DEFFILLPATTERNS:
        return((int)MFBCurrent->fillPtrnDefineBool);
    case  DEFREADMASK:
        return((int)MFBCurrent->readMaskBool);
    case  DEFCHANNELMASK:
        return((int)MFBCurrent->channelMaskBool);
    case  DEFLINEPATTERN:
        return((int)MFBCurrent->linePatternDefineBool);
    case  CURFGCOLOR:
        return(MFBCurrent->fgColorId);
    case  CURFILLPATTERN:
        return(MFBCurrent->fillPattern);
    case  CURLINESTYLE:
        return(MFBCurrent->lineStyle);
    case  CURCHANNELMASK:
        return(MFBCurrent->channelMask);
    case  CURREADMASK:
        return(MFBCurrent->readMask);
    case  NUMBITPLANES:
        return(MFBCurrent->lengthOfVLT);
    case  RASTERCOPY:
        return((int)MFBCurrent->rastCopyBool);
    case  OFFSCREENX:
        return(MFBCurrent->minOffScreenX);
    case  OFFSCREENY:
        return(MFBCurrent->minOffScreenY);
    case  OFFSCREENDX:
        return(MFBCurrent->offScreenDX);
    case  OFFSCREENDY:
        return(MFBCurrent->offScreenDY);
    default:
        return(-1);
    }
}

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

Definition at line 725 of file mfbbasic.c.

{
#ifdef DEBUG
    MFBCurrent->nLines += 1;
    MFBCurrent->sumLineLength += MFBmax(abs(X1-X2),abs(Y1-Y2));
#endif
    if(MFBCurrent->reissueLineStyleBool)
        MFBSetLineStyle(MFBCurrent->lineStyle);
    MFBCurrent->X = X1; MFBCurrent->Y = Y1;
    MFBCurrent->Z = X2; MFBCurrent->T = Y2;
    if(MFBCurrent->lineStyle == 0 && MFBFORMAT.drawSolidLineSequence != NULL
            && *MFBFORMAT.drawSolidLineSequence != 0)
        MFBGenCode(MFBFORMAT.drawSolidLineSequence);
    else
        MFBGenCode(MFBFORMAT.drawLineSequence);
    LastX = X2; LastY = Y2;
}

void MFBMoveTo	(	int	X1,
		int	Y1
	)

Definition at line 655 of file mfbbasic.c.

{
    /* the assignment of lastX/Y is redundant for a Tek terminal */
    LastX = MFBCurrent->X = X1; LastY = MFBCurrent->Y = Y1;
    MFBGenCode(MFBFORMAT.movePenSequence);
}

void MFBNaiveBoxFill

(

)

void MFBNaiveBoxFill	(	left	,
		bottom	,
		right	,
		top
	)

Definition at line 1169 of file mfbbasic.c.

{
    int     step;
    int     incr;
    int     incr2;
    int     ll, bb, rr, tt;

    if (top < bottom)
        MFBSwapInt (top, bottom);
    if (right < left)
        MFBSwapInt (left, right);
    incr = MFBmax (MFBmax (MFBCurrent->maxX, MFBCurrent->maxY) / 400, 1);
    step = incr * 5;
    incr2 = incr + (incr >> 1);
    ll = left;
    bb = bottom;
    rr = right;
    tt = top;
    switch (MFBCurrent->fillPattern) {

        case 0: 
            /* 
             * solid
             */
            if ((right - left) > (top - bottom)) {
                for (bb = bottom; bb <= top; bb += incr)
                    MFBLine (ll, bb, rr, bb);
            }
            else {
                for (ll = left; ll <= right; ll += incr)
                    MFBLine (ll, bb, ll, tt);
            }
            break;

        case 1: 
            /* 
             * horizontal striped
             */
            for (bb = bottom; bb < top; bb += step)
                MFBLine (ll, bb, rr, bb);
            break;

        case 2: 
            /* 
             * vertical striped
             */
            for (ll = left; ll < right; ll += step)
                MFBLine (ll, bb, ll, tt);
            break;

        case 3: 
            /* 
             * diagonal lines
             */
            ll += step;
            bb += step;
            while (ll < right && bb < top) {
                MFBLine (left, bb, ll, bottom);
                ll += step;
                bb += step;
            }
            if (ll >= right) {
                while (bb < top) {
                    MFB_Y_Intercept (left, bb, ll, bottom, right, &tt);
                    MFBLine (left, bb, right, tt);
                    bb += step;
                    ll += step;
                }
            }
            else {
                while (ll < right) {
                    MFB_X_Intercept (left, bb, ll, bottom, top, &rr);
                    MFBLine (rr, top, ll, bottom);
                    bb += step;
                    ll += step;
                }
            }
            while (rr <= right && tt <= top) {
                MFB_X_Intercept (left, bb, ll, bottom, top, &rr);
                MFB_Y_Intercept (left, bb, ll, bottom, right, &tt);
                if (rr > right || tt > top)
                    break;
                MFBLine (rr, top, right, tt);
                bb += step;
                ll += step;
            }
            break;

        case 4: 
            /* 
             * diagonal lines
             */
            rr -= step;
            bb += step;
            while (rr > left && bb < top) {
                MFBLine (rr, bottom, right, bb);
                rr -= step;
                bb += step;
            }
            if (rr <= left) {
                while (bb < top) {
                    MFB_Y_Intercept (rr, bottom, right, bb, left, &tt);
                    MFBLine (left, tt, right, bb);
                    bb += step;
                    rr -= step;
                }
            }
            else {
                while (rr > left) {
                    MFB_X_Intercept (rr, bottom, right, bb, top, &ll);
                    MFBLine (rr, bottom, ll, top);
                    bb += step;
                    rr -= step;
                }
            }
            while (ll >= left && tt <= top) {
                MFB_X_Intercept (rr, bottom, right, bb, top, &ll);
                MFB_Y_Intercept (rr, bottom, right, bb, left, &tt);
                if (ll < left || tt > top)
                    break;
                MFBLine (left, tt, ll, top);
                bb += step;
                rr -= step;
            }
            break;

        case 5: 
            /* 
             * plus signs
             */
            for (bb = bottom; bb < top; bb += (step + step)) {
                for (ll = left; ll < right; ll += step) {
                    MFBLine (ll - incr2, bb, ll + incr2, bb);
                    MFBLine (ll, bb - incr2, ll, bb + incr2);
                }
            }
            break;

        case 6: 
            /* 
             * x's
             */
            for (bb = bottom; bb < top; bb += (step + step)) {
                for (ll = left; ll < right; ll += step) {
                    MFBLine (ll - incr2, bb - incr2, ll + incr2, bb + incr2);
                    MFBLine (ll - incr2, bb + incr2, ll + incr2, bb - incr2);
                }
            }
            break;

        default: 
        case 7: 
            /* 
             * outline
             */
            MFBLine (left, bottom, left, top);
            MFBLine (left, top, right, top);
            MFBLine (right, top, right, bottom);
            MFBLine (right, bottom, left, bottom);
            break;

    }
}

void MFBPixel	(	int	x,
		int	y
	)

Definition at line 972 of file mfbbasic.c.

{
    MFBCurrent->X = x; MFBCurrent->Y = y;
    MFBGenCode(MFBFORMAT.writePixel);
}

void MFBPolygon

(

MFBPOLYGON *

p

)

Definition at line 893 of file mfbbasic.c.

{
    int *xy0,*xy1,n;

    xy0 = xy1 = p->xy;
    MFBCurrent->Z = n = p->nvertices;
    if(n <= 0) return;
        MFBCurrent->X = *xy1++;
    MFBCurrent->Y = *xy1++;
    if(MFBCurrent->fillPattern == 0 &&
            MFBFORMAT.beginSolidPlygnSequence != NULL &&
            *MFBFORMAT.beginSolidPlygnSequence != 0)
        MFBGenCode(MFBFORMAT.beginSolidPlygnSequence);
    else
        MFBGenCode(MFBFORMAT.beginPlygnSequence);
    n--;
    while(n--) {
        MFBCurrent->X = *xy1++;
        MFBCurrent->Y = *xy1++;
        MFBGenCode(MFBFORMAT.sendPlygnVertex);
    }
    MFBCurrent->X = *xy0;
    MFBCurrent->Y = *(xy0+1);
    MFBGenCode(MFBFORMAT.endPlygnSequence);
}

int MFBScaleX

(

int

X

)

Definition at line 1097 of file mfbbasic.c.

{
    int XX;

    XX = (int)(((double)(X-WNDW.left)*VWPRT.length)/WNDW.length) + VWPRT.left;
    if(XX < VWPRT.left) XX = VWPRT.left;
    else if(XX > VWPRT.right) XX = VWPRT.right; 
    return(XX);
}

int MFBScaleY

(

int

Y

)

Definition at line 1109 of file mfbbasic.c.

{
    int YY;
     
    YY = (int)(((double)(Y-WNDW.bottom)*VWPRT.width)/WNDW.width) + VWPRT.bottom;
    if(YY < VWPRT.bottom) YY = VWPRT.bottom;
    else if(YY > VWPRT.top) YY = VWPRT.top;
    return(YY);
}

int MFBSetALUMode

(

int

mode

)

Definition at line 423 of file mfbbasic.c.

{
    char *cp;
    switch(mode){
        case MFBALUJAM:
        cp = MFBFORMAT.setALUJAM;
        break;
        case MFBALUOR:
        cp = MFBFORMAT.setALUOR;
        break;
        case MFBALUNOR:
        cp = MFBFORMAT.setALUNOR;
        break;
        case MFBALUEOR:
        cp = MFBFORMAT.setALUEOR;
        break;
        default:
        cp = NULL;
    }
    if(cp == NULL || *cp == 0)
        return(MFBBADALU);
    MFBGenCode(cp);
    return(MFBOK);
}

int MFBSetBlinker	(	int	colorId,
		int	r,
		int	g,
		int	b,
		int	onFlag
	)

Definition at line 477 of file mfbbasic.c.

{
    if(!MFBCurrent->blinkersBool)
        return(MFBNOBLNK);

    MFBCurrent->X = colorId;
    if(MFBCurrent->vltUseHLSBool){
        MFBConvertToHLS(r,g,b);
    }
    else{
        /* Normalize to 1000 */
        MFBCurrent->Y = r * MFBCurrent->maxIntensity / 1000;
        MFBCurrent->Z = g * MFBCurrent->maxIntensity / 1000;
        MFBCurrent->T = b * MFBCurrent->maxIntensity / 1000;
    }

    if(onFlag == ON) {
        MFBGenCode(MFBFORMAT.blinkerON);
        ++MFBCurrent->numBlinkers;
    }
    else {
        MFBGenCode(MFBFORMAT.blinkerOFF);
        --MFBCurrent->numBlinkers;
    }
    if(MFBCurrent->numBlinkers >= MFBCurrent->maxBlinkers)
        return(MFBTMBLNK);
    return(MFBOK);
}

int MFBSetChannelMask

(

int

channelMask

)

Definition at line 322 of file mfbbasic.c.

{

    /* Is channel mask already set? */
    if(channelMask == MFBCurrent->channelMask)
        return(MFBOK);
    /* Are there channel or write-enable masks? */
    if(!MFBCurrent->channelMaskBool)
        return(MFBNOMASK);
    else{
        MFBCurrent->X = MFBCurrent->channelMask = channelMask;
        MFBGenCode(MFBFORMAT.channelMaskSet);
    }
    return(MFBOK);
}

int MFBSetColor

(

int

colorId

)

Definition at line 370 of file mfbbasic.c.

{

    /*
     * Check if styleId is already the foreground color
     */
    if(colorId == MFBCurrent->fgColorId) return(MFBOK);

    if(colorId < 0 || colorId >= MFBCurrent->maxColors)
        /* bad colorId */
        return(MFBBADCST);
    else {
        MFBCurrent->X = MFBCurrent->fgColorId = colorId;
        MFBGenCode(MFBFORMAT.setForegroundColor);
    }
    return(MFBOK);
}

int MFBSetCursorColor	(	int	colorId1,
		int	colorId2
	)

Definition at line 463 of file mfbbasic.c.

{
    MFBCurrent->cursorColor1Id = colorId1;
    MFBCurrent->cursorColor2Id = colorId2;
    return(MFBOK);
}

MFBSetFillPattern

(

int

styleId

)

Definition at line 288 of file mfbbasic.c.

{

    /*
     * Check if styleId is already the current fill style
     */
    if(styleId == MFBCurrent->fillPattern)
        return(MFBOK);
    if(styleId < 0 || styleId >= MFBCurrent->maxFillPatterns)
        /* bad styleId */
        return(MFBBADFST);
    else {
        MFBCurrent->X = MFBCurrent->fillPattern = styleId;
    if(styleId == 0 && MFBFORMAT.setSolidFillPattern != NULL
            && *MFBFORMAT.setSolidFillPattern != 0)
        MFBGenCode(MFBFORMAT.setSolidFillPattern);
    else
        MFBGenCode(MFBFORMAT.setFillPattern);
    }
    return(MFBOK);
}

void MFBSetGhost

(

)

Definition at line 34 of file mfbbasic.c.

{}

MFBSetLineStyle

(

int

styleId

)

Definition at line 259 of file mfbbasic.c.

{
    /*
     * Check if styleId is already the current line style
     */
    if(styleId == MFBCurrent->lineStyle && !MFBCurrent->reissueLineStyleBool)
        return(MFBOK);
    if(styleId < 0 || styleId >= MFBCurrent->maxLineStyles)
        /* bad styleId */
        return(MFBBADLST);
    else {
        MFBCurrent->X = MFBCurrent->lineStyle = styleId;
    if(styleId == 0 && MFBFORMAT.setSolidLineStyle != NULL
            && *MFBFORMAT.setSolidLineStyle != 0)
        MFBGenCode(MFBFORMAT.setSolidLineStyle);
    else
        MFBGenCode(MFBFORMAT.setLineStyle);
    }
    return(MFBOK);
}

int MFBSetReadMask

(

int

readMask

)

Definition at line 346 of file mfbbasic.c.

{

    /* Is channel mask already set? */
    if(readMask == MFBCurrent->readMask)
        return(MFBOK);
    /* Are there channel or write-enable masks? */
    if(!MFBCurrent->readMaskBool)
        return(MFBNOMASK);
    else{
        MFBCurrent->X = MFBCurrent->readMask = readMask;
        MFBGenCode(MFBFORMAT.readMaskSet);
    }
    return(MFBOK);
}

int MFBSetRubberBanding	(	Bool	RubberBandingBool,
		int	X,
		int	Y
	)

Definition at line 513 of file mfbbasic.c.

{
    if(MFBFORMAT.enableRubberBanding == NULL 
            || *MFBFORMAT.enableRubberBanding == 0)
        return(MFBNORBND);
    if(RubberBandingBool){
        MFBCurrent->X = X;
        MFBCurrent->Y = Y;
        MFBGenCode(MFBFORMAT.movePenSequence);
        MFBGenCode(MFBFORMAT.enableRubberBanding);
    }
    else
        MFBGenCode(MFBFORMAT.disableRubberBanding);
        return(MFBOK);
}

int MFBSetTextMode

(

Bool

destructiveBool

)

Definition at line 395 of file mfbbasic.c.

{
    if(MFBCurrent->textMode != (int)destructiveBool) {
        if(destructiveBool){
            if(!MFBCurrent->replaceTextBool)
                return(MFBBADTM1);
            MFBGenCode(MFBFORMAT.replaceON);
        }
        else{
            if(!MFBCurrent->overstrikeTextBool)
                return(MFBBADTM2);
            MFBGenCode(MFBFORMAT.overstrikeON);
        }
        MFBCurrent->textMode = (int)destructiveBool;
    }
    return(MFBOK);
}

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

Definition at line 1141 of file mfbbasic.c.

{
    VWPRT.bottom = bottom;
    VWPRT.top = top;
    VWPRT.left = left;
    VWPRT.right = right;
    VWPRT.length = VWPRT.right - VWPRT.left;
    VWPRT.width = VWPRT.top - VWPRT.bottom;
}

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

Definition at line 1153 of file mfbbasic.c.

{
    WNDW.bottom = bottom;
    WNDW.top = top;
    WNDW.left = left;
    WNDW.right = right;
    WNDW.length = WNDW.right - WNDW.left;
    WNDW.width = WNDW.top - WNDW.bottom;
}

void MFBText	(	char *	text,
		int	x,
		int	y,
		int	phi
	)

Definition at line 926 of file mfbbasic.c.

{
    char *c;
    
#ifdef DEBUG
    MFBCurrent->nChars += strlen(text);
#endif
    if((phi != 0) && (MFBCurrent->textRotateBool == true)){
        MFBCurrent->X = phi;
        MFBGenCode(MFBFORMAT.rotateTextSequence);
    }

    /* Move to (x + GTW),(Y + GTH). */
    MFBCurrent->X = x + MFBCurrent->fontXOffset;
    MFBCurrent->Y = y + MFBCurrent->fontYOffset;

    /* Get ready for graphics text. */
    c = text;
    MFBCurrent->Z = 0;
    while(*c++ != 0) (MFBCurrent->Z)++;

    MFBGenCode(MFBFORMAT.graphicsTextStart);

    /* Output the text. */
    while(*text) MFBPutchar(*text++);

    /* Finish the graphics text */
    MFBGenCode(MFBFORMAT.graphicsTextEnd);

    /* rotate text back to zero */
    if((phi != 0) && (MFBCurrent->textRotateBool == true)){
        MFBCurrent->X = 0;
        MFBGenCode(MFBFORMAT.rotateTextSequence);
    }
}

void MFBZeroCounters

(

)

Definition at line 213 of file mfbbasic.c.

                  {
#ifdef DEBUG
    if(MFBCurrent == NULL) return;
    MFBCurrent->nChars = MFBCurrent->nBoxes
        = MFBCurrent->nLines = MFBCurrent->nChars
        = MFBCurrent->sumBoxArea = MFBCurrent->sumLineLength = 0;
#endif
}

void SetCurrentMFB

(

MFB *

mfb

)

Definition at line 198 of file mfbbasic.c.

{
    MFBCurrent = mfb;
}

Variable Documentation

int LastX

Definition at line 652 of file mfbbasic.c.

int LastY

Definition at line 652 of file mfbbasic.c.

MFB* MFBCurrent

Definition at line 31 of file mfbbasic.c.