The R Project SVN – R – Diff – /trunk/src/main/plotmath.c



 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
 
/* <UTF8-FIXME>
   byte-level access and use of ctype functions
   byte-level charmetric information.
   Has encoding of symbol font hard-coded.
*/
 
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif

			  mathContext*, R_GE_gcontext*, GEDevDesc*);
static BBOX RenderOffsetElement(SEXP, double, double, int,
				mathContext*, R_GE_gcontext*, GEDevDesc*);
static BBOX RenderExpression(SEXP, int,
			     mathContext*, R_GE_gcontext*, GEDevDesc*);
static BBOX RenderSymbolChar(int, int,
			     mathContext*, R_GE_gcontext*, GEDevDesc*);
 
 
/*  Code to Generate Bounding Boxes and Draw Formulae.	*/
 
static BBOX RenderItalicCorr(BBOX bbox, int draw, mathContext *mc,
			     R_GE_gcontext *gc, GEDevDesc *dd)
{
    if (bboxItalic(bbox) > 0) {
	if (draw)
	    PMoveAcross(bboxItalic(bbox), mc);
	bboxWidth(bbox) += bboxItalic(bbox);
	bboxItalic(bbox) = 0;
    }
    return bbox;
}
 
static BBOX RenderGap(double gap, int draw, mathContext *mc,
		      R_GE_gcontext *gc, GEDevDesc *dd)
{
    if (draw)
	PMoveAcross(gap, mc);
    return MakeBBox(0, 0, gap);
}
 
/* Draw a Symbol from the Special Font */
 
static BBOX RenderSymbolChar(int ascii, int draw, mathContext *mc,
			     R_GE_gcontext *gc, GEDevDesc *dd)
{
    FontType prev;
    BBOX bbox;
    char asciiStr[2];
    if (ascii == A_HAT || ascii == A_TILDE)

	prev = SetFont(SymbolFont, gc);
    bbox = GlyphBBox(ascii, gc, dd);
    if (draw) {
	asciiStr[0] = ascii;
	asciiStr[1] = '\0';
	GEText(ConvertedX(mc ,dd), ConvertedY(mc, dd), asciiStr,
	       0.0, 0.0, mc->CurrentAngle, gc,
	       dd);
	PMoveAcross(bboxWidth(bbox), mc);
    }
    SetFont(prev, gc);

 
/* Draw a Symbol String in "Math Mode */
/* This code inserts italic corrections after */
/* every character. */
 
static BBOX RenderSymbolStr(char *str, int draw, mathContext *mc,
			    R_GE_gcontext *gc, GEDevDesc *dd)
{
    char chr[2];
    BBOX glyphBBox;
    BBOX resultBBox = NullBBox();
    double lastItalicCorr = 0;

    return resultBBox;
}
 
/* Code for Character String Atoms. */
 
static BBOX RenderChar(int ascii, int draw, mathContext *mc,
		       R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox;
    char asciiStr[2];
    bbox = GlyphBBox(ascii, gc, dd);
    if (draw) {

	PMoveAcross(bboxWidth(bbox), mc);
    }
    return bbox;
}
 
static BBOX RenderStr(char *str, int draw, mathContext *mc,
		      R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX glyphBBox;
    BBOX resultBBox = NullBBox();
    if (str) {
	char *s = str;

}
 
 
/* Code for Symbol Font Atoms */
 
static BBOX RenderSymbol(SEXP expr, int draw, mathContext *mc,
			 R_GE_gcontext *gc, GEDevDesc *dd)
{
    int code;
    if ((code = TranslatedSymbol(expr)))
	return RenderSymbolChar(code, draw, mc, gc, dd);
    else
	return RenderSymbolStr(CHAR(PRINTNAME(expr)), draw, mc, gc, dd);
}
 
static BBOX RenderSymbolString(SEXP expr, int draw, mathContext *mc,
			       R_GE_gcontext *gc, GEDevDesc *dd)
{
    int code;
    if ((code = TranslatedSymbol(expr)))
	return RenderSymbolChar(code, draw, mc, gc, dd);
    else

}
 
 
/* Code for Numeric Atoms */
 
static BBOX RenderNumber(SEXP expr, int draw, mathContext *mc,
			 R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox;
    FontType prevfont = SetFont(PlainFont, gc);
    bbox = RenderStr(CHAR(asChar(expr)), draw, mc, gc, dd);
    SetFont(prevfont, gc);
    return bbox;
}
 
/* Code for String Atoms */
 
static BBOX RenderString(SEXP expr, int draw, mathContext *mc,
			 R_GE_gcontext *gc, GEDevDesc *dd)
{
    return RenderStr(CHAR(STRING_ELT(expr, 0)), draw, mc, gc, dd);
}
 
/* Code for Ellipsis (ldots, cdots, ...) */

	NameMatch(expr, "ldots"))
	    return 1;
    return 0;
}
 
static BBOX RenderDots(SEXP expr, int draw, mathContext *mc,
		       R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox = RenderSymbolChar(S_ELLIPSIS, 0, mc, gc, dd);
    if (NameMatch(expr, "cdots") || NameMatch(expr, "...")) {
	double shift = AxisHeight(gc, dd) - 0.5 * bboxHeight(bbox);
	if (draw) {

 *
 *  Code for Atoms
 *
 */
 
static BBOX RenderAtom(SEXP expr, int draw, mathContext *mc,
		       R_GE_gcontext *gc, GEDevDesc *dd)
{
    if (NameAtom(expr)) {
	if (DotsAtom(expr))
	    return RenderDots(expr, draw, mc, gc, dd);
	else

{
    return NameAtom(expr) && NameMatch(expr, "~");
}
 
 
static BBOX RenderSpace(SEXP expr, int draw, mathContext *mc,
			R_GE_gcontext *gc, GEDevDesc *dd)
{
 
    BBOX opBBox, arg1BBox, arg2BBox;
    int nexpr = length(expr);
 

    return 0;
}
 
#define SLASH2
 
static BBOX RenderSlash(int draw, mathContext *mc, R_GE_gcontext *gc,
			GEDevDesc *dd)
{
#ifdef SLASH0
    /* The Default Font Character */
    return RenderSymbolChar(S_SLASH, draw, mc, gc, dd);
#endif

    double delta = TeX(sigma22, gc, dd);
    if (draw)
	PMoveUp(-delta, mc);
    ansBBox = ShiftBBox(RenderSymbolChar(S_SLASH, draw), -delta, mc, gc, dd);
    PMoveUp(2 * delta, mc);
    ansBBox = CombineBBoxes(ansBBox, RenderGap(2 * delta / slope, draw,
					       mc, gc, dd));
    ansBBox = ShiftBBox(RenderSymbolChar(S_SLASH, draw), 2 * delta,
			mc, gc, dd);
    PMoveUp(-delta, mc);
    return ansBBox;
#endif
}
 
static BBOX RenderBin(SEXP expr, int draw, mathContext *mc,
		      R_GE_gcontext *gc, GEDevDesc *dd)
{
    int op = BinAtom(CAR(expr));
    int nexpr = length(expr);
    BBOX bbox;
    double gap;
 
    if(nexpr == 3) {
	if (op == S_ASTERISKMATH) {
	    bbox = RenderElement(CADR(expr), draw, mc, gc, dd);
	    bbox = RenderItalicCorr(bbox, draw, mc, gc, dd);
	    return CombineBBoxes(bbox, RenderElement(CADDR(expr), draw,
						     mc, gc, dd));
	}
	else if (op == S_SLASH) {
	    gap = 0;
	    bbox = RenderElement(CADR(expr), draw, mc, gc, dd);
	    bbox = RenderItalicCorr(bbox, draw, mc, gc, dd);
	    bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));
	    bbox = CombineBBoxes(bbox, RenderSlash(draw, mc, gc, dd));
	    bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));
	    return CombineBBoxes(bbox, RenderElement(CADDR(expr), draw,
						     mc, gc, dd));
	}
	else {
	    gap = (mc->CurrentStyle > STYLE_S) ? MediumSpace(gc, dd) : 0;
	    bbox = RenderElement(CADR(expr), draw, mc, gc, dd);
	    bbox = RenderItalicCorr(bbox, draw, mc, gc, dd);
	    bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));
	    bbox = CombineBBoxes(bbox, RenderSymbolChar(op, draw, mc, gc, dd));
	    bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));
	    return CombineBBoxes(bbox, RenderElement(CADDR(expr), draw,
						     mc, gc, dd));
	}
    }
    else if(nexpr == 2) {
	gap = (mc->CurrentStyle > STYLE_S) ? ThinSpace(gc, dd) : 0;
	bbox = RenderSymbolChar(op, draw, mc, gc, dd);
	bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));
	return CombineBBoxes(bbox, RenderElement(CADR(expr), draw, mc,
						 gc, dd));
    }
    else
	error("invalid mathematical annotation");
 
    return NullBBox();		/* -Wall */

}
 
/* Note : If all computations are correct */
/* We do not need to save and restore the */
/* current location here.  This is paranoia. */
static BBOX RenderSub(SEXP expr, int draw, mathContext *mc,
		      R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bodyBBox, subBBox;
    SEXP body = CADR(expr);
    SEXP sub = CADDR(expr);
    STYLE style = GetStyle(mc);

    if (draw)
	PMoveTo(savedX + bboxWidth(bodyBBox), savedY, mc);
    return bodyBBox;
}
 
static BBOX RenderSup(SEXP expr, int draw, mathContext *mc,
		      R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bodyBBox, subBBox, supBBox;
    SEXP body = CADR(expr);
    SEXP sup = CADDR(expr);
    SEXP sub = R_NilValue;	/* -Wall */

static int WideTildeAtom(SEXP expr)
{
    return NameAtom(expr) && NameMatch(expr, "widetilde");
}
 
static BBOX RenderWideTilde(SEXP expr, int draw, mathContext *mc,
			    R_GE_gcontext *gc, GEDevDesc *dd)
{
    double savedX = mc->CurrentX;
    double savedY = mc->CurrentY;
    BBOX bbox = RenderElement(CADR(expr), draw, mc, gc, dd);
    double height = bboxHeight(bbox);

static int WideHatAtom(SEXP expr)
{
    return NameAtom(expr) && NameMatch(expr, "widehat");
}
 
static BBOX RenderWideHat(SEXP expr, int draw, mathContext *mc,
			  R_GE_gcontext *gc, GEDevDesc *dd)
{
    double savedX = mc->CurrentX;
    double savedY = mc->CurrentY;
    BBOX bbox = RenderElement(CADR(expr), draw, mc, gc, dd);
    double accentGap = ACCENT_GAP * XHeight(gc, dd);

static int BarAtom(SEXP expr)
{
    return NameAtom(expr) && NameMatch(expr, "bar");
}
 
static BBOX RenderBar(SEXP expr, int draw, mathContext *mc,
		      R_GE_gcontext *gc, GEDevDesc *dd)
{
    double savedX = mc->CurrentX;
    double savedY = mc->CurrentY;
    BBOX bbox = RenderElement(CADR(expr), draw, mc, gc, dd);
    double accentGap = ACCENT_GAP * XHeight(gc, dd);

static void InvalidAccent(SEXP expr)
{
    errorcall(expr, "invalid accent");
}
 
static BBOX RenderAccent(SEXP expr, int draw, mathContext *mc,
			 R_GE_gcontext *gc, GEDevDesc *dd)
{
    SEXP body, accent;
    double savedX = mc->CurrentX;
    double savedY = mc->CurrentY;
    BBOX bodyBBox, accentBBox;

    bodyBBox = CombineBBoxes(bodyBBox, RenderElement(body, draw, mc, gc, dd));
    bodyBBox = CombineBBoxes(bodyBBox, RenderGap(xoffset, draw, mc, gc, dd));
    PMoveTo(savedX, savedY, mc);
    xoffset = 0.5 *(width - bboxWidth(accentBBox))
	+ 0.9 * italic;
    yoffset = bboxHeight(bodyBBox) + bboxDepth(accentBBox) +
	0.1 * XHeight(gc, dd);
    if (draw) {
	PMoveTo(savedX + xoffset, savedY + yoffset, mc);
	if (code == 215) /* dotmath */
	    RenderSymbolChar(code, draw, mc, gc, dd);
	else

	*numShift = (denomWidth - numWidth) / 2;
	*denomShift = 0;
    }
}
 
static BBOX RenderFraction(SEXP expr, int rule, int draw,
			   mathContext *mc, R_GE_gcontext *gc, GEDevDesc *dd)
{
    SEXP numerator = CADR(expr);
    SEXP denominator = CADDR(expr);
    BBOX numBBox, denomBBox;
    double nHShift, dHShift;

    double savedY = mc->CurrentY;
    STYLE style;
 
    style = GetStyle(mc);
    SetNumStyle(style, mc, gc);
    numBBox = RenderItalicCorr(RenderElement(numerator, 0, mc, gc, dd), 0,
			       mc, gc, dd);
    SetDenomStyle(style, mc, gc);
    denomBBox = RenderItalicCorr(RenderElement(denominator, 0, mc, gc, dd), 0,
				 mc, gc, dd);
    SetStyle(style, mc, gc);
 
    width = max(bboxWidth(numBBox), bboxWidth(denomBBox));
    NumDenomHShift(numBBox, denomBBox, &nHShift, &dHShift);
    NumDenomVShift(numBBox, denomBBox, &nVShift, &dVShift, mc, gc, dd);
 
    mc->CurrentX = savedX;
    mc->CurrentY = savedY;
    SetNumStyle(style, mc, gc);
    numBBox = RenderOffsetElement(numerator, nHShift, nVShift, draw, mc,
				  gc, dd);
 
    mc->CurrentX = savedX;
    mc->CurrentY = savedY;
    SetDenomStyle(style, mc, gc);
    denomBBox = RenderOffsetElement(denominator, dHShift, -dVShift, draw,
				    mc, gc, dd);
 
    SetStyle(style, mc, gc);
 
    if (draw) {
	if (rule) {

{
    return NameAtom(expr) &&
	(NameMatch(expr, "over") || NameMatch(expr, "frac"));
}
 
static BBOX RenderOver(SEXP expr, int draw, mathContext *mc,
		       R_GE_gcontext *gc, GEDevDesc *dd)
{
    return RenderFraction(expr, 1, draw, mc, gc, dd);
}
 
static int UnderlAtom(SEXP expr)
{
    return NameAtom(expr) && NameMatch(expr, "underline");
}
 
static BBOX RenderUnderl(SEXP expr, int draw, mathContext *mc,
			 R_GE_gcontext *gc, GEDevDesc *dd)
{
    return RenderUnderline(expr, draw, mc, gc, dd);
}
 
 
static int AtopAtom(SEXP expr)
{
    return NameAtom(expr) && NameMatch(expr, "atop");
}
 
static BBOX RenderAtop(SEXP expr, int draw, mathContext *mc,
		       R_GE_gcontext *gc, GEDevDesc *dd)
{
    return RenderFraction(expr, 0, draw, mc, gc, dd);
}
 
/*----------------------------------------------------------------------

    if (code == 0)
	errorcall(expr, "invalid group delimiter");
    return code;
}
 
static BBOX RenderDelimiter(int delim, int draw, mathContext *mc,
			    R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox;
    double savecex = gc->cex;
    gc->cex = DelimSymbolMag * gc->cex;
    bbox = RenderSymbolChar(delim, draw, mc, gc, dd);

static int GroupAtom(SEXP expr)
{
    return NameAtom(expr) && NameMatch(expr, "group");
}
 
static BBOX RenderGroup(SEXP expr, int draw, mathContext *mc,
			R_GE_gcontext *gc, GEDevDesc *dd)
{
    double cexSaved = gc->cex;
    BBOX bbox;
    int code;
    if (length(expr) != 4)

static int BGroupAtom(SEXP expr)
{
    return NameAtom(expr) && NameMatch(expr, "bgroup");
}
 
static BBOX RenderDelim(int which, double dist, int draw, mathContext *mc,
			R_GE_gcontext *gc, GEDevDesc *dd)
{
    double savedX = mc->CurrentX;
    double savedY = mc->CurrentY;
    FontType prev = SetFont(SymbolFont, gc);
    BBOX ansBBox, topBBox, botBBox, extBBox, midBBox;

    double topShift, botShift, extShift, midShift;
    double ytop, ybot, extHeight, delta;
    double axisHeight = TeX(sigma22, gc, dd);
 
    switch(which) {
    case '.':
	SetFont(prev, gc);
	return NullBBox();
	break;
    case '|':
    case 2:

		+ (bboxHeight(botBBox) + bboxDepth(botBBox));
	    n = ceil((ytop - ybot) / (0.99 * extHeight));
	    if (n > 0) {
		delta = (ytop - ybot) / n;
		for (i = 0; i < n; i++) {
		    PMoveTo(savedX, savedY + ybot +
			    (i + 0.5) * delta - extShift, mc);
		    RenderSymbolChar(ext, draw, mc, gc, dd);
		}
	    }
	    PMoveTo(savedX + bboxWidth(ansBBox), savedY, mc);
 

    }
    SetFont(prev, gc);
    return ansBBox;
}
 
static BBOX RenderBGroup(SEXP expr, int draw, mathContext *mc,
			 R_GE_gcontext *gc, GEDevDesc *dd)
{
    double dist;
    BBOX bbox;
    double axisHeight = TeX(sigma22, gc, dd);
    double extra = 0.2 * xHeight(gc, dd);

    bbox = RenderElement(CADDR(expr), 0, mc, gc, dd);
    dist = max(bboxHeight(bbox) - axisHeight, bboxDepth(bbox) + axisHeight);
    bbox = RenderDelim(delim1, dist + extra, draw, mc, gc, dd);
    bbox = CombineBBoxes(bbox,	RenderElement(CADDR(expr), draw, mc, gc, dd));
    bbox = RenderItalicCorr(bbox, draw, mc, gc, dd);
    bbox = CombineBBoxes(bbox,	RenderDelim(delim2, dist + extra, draw, mc,
					    gc, dd));
    return bbox;
}
 
/*----------------------------------------------------------------------
 *

static int ParenAtom(SEXP expr)
{
    return NameAtom(expr) && NameMatch(expr, "(");
}
 
static BBOX RenderParen(SEXP expr, int draw, mathContext *mc,
			R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox;
    bbox = RenderDelimiter(S_PARENLEFT, draw, mc, gc, dd);
    bbox = CombineBBoxes(bbox, RenderElement(CADR(expr), draw, mc, gc, dd));
    bbox = RenderItalicCorr(bbox, draw, mc, gc, dd);

{
    return NameAtom(expr) && NameMatch(expr, "integral");
}
 
 
static BBOX RenderIntSymbol(int draw, mathContext *mc, R_GE_gcontext *gc,
			    GEDevDesc *dd)
{
    double savedX = mc->CurrentX;
    double savedY = mc->CurrentY;
    if (GetStyle(mc) > STYLE_T) {
	BBOX bbox1 = RenderSymbolChar(243, 0, mc, gc, dd);

	mc->CurrentY = savedY;
	shift = TeX(sigma22, gc, dd) - 0.99 * bboxHeight(bbox2);
	PMoveUp(shift, mc);
	bbox2 = ShiftBBox(RenderSymbolChar(245, draw, mc, gc, dd), shift);
	if (draw)
	    PMoveTo(savedX + max(bboxWidth(bbox1), bboxWidth(bbox2)),
		    savedY, mc);
	else
	    PMoveTo(savedX, savedY, mc);
	return CombineAlignedBBoxes(bbox1, bbox2);
    }
    else {
	return RenderSymbolChar(0362, draw, mc, gc, dd);
    }
}
 
static BBOX RenderInt(SEXP expr, int draw, mathContext *mc,
		      R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX opBBox, lowerBBox, upperBBox, bodyBBox;
    int nexpr = length(expr);
    STYLE style = GetStyle(mc);
    double savedX = mc->CurrentX;

    if (nexpr > 2) {
	hshift = 0.5 * width + ThinSpace(gc, dd);
	SetSubStyle(style, mc, gc);
	lowerBBox = RenderElement(CADDR(expr), 0, mc, gc, dd);
	vshift = bboxDepth(opBBox) + CenterShift(lowerBBox);
	lowerBBox = RenderOffsetElement(CADDR(expr), hshift, -vshift, draw,
					mc, gc, dd);
	opBBox = CombineAlignedBBoxes(opBBox, lowerBBox);
	SetStyle(style, mc, gc);
	mc->CurrentX = savedX;
	mc->CurrentY = savedY;
    }
    if (nexpr > 3) {
	hshift = width + ThinSpace(gc, dd);
	SetSupStyle(style, mc, gc);
	upperBBox = RenderElement(CADDDR(expr), 0, mc, gc, dd);
	vshift = bboxHeight(opBBox) - CenterShift(upperBBox);
	upperBBox = RenderOffsetElement(CADDDR(expr), hshift, vshift, draw,
					mc, gc, dd);
	opBBox = CombineAlignedBBoxes(opBBox, upperBBox);
	SetStyle(style, mc, gc);
	mc->CurrentX = savedX;
	mc->CurrentY = savedY;
    }

	if (NameMatch(expr, OpTable[i].name))
	    return OpTable[i].code;
    return 0;
}
 
static BBOX RenderOpSymbol(SEXP op, int draw, mathContext *mc,
			   R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox;
    double cexSaved = gc->cex;
    /*double savedX = mc->CurrentX;*/
    /*double savedY = mc->CurrentY;*/

    if (opId == S_SUM || opId == S_PRODUCT ||
	opId == S_UNION || opId == S_INTERSECTION) {
	if (display) {
	    gc->cex = OperatorSymbolMag * gc->cex;
	    bbox = RenderSymbolChar(OpAtom(op), 0, mc, gc, dd);
	    shift = 0.5 * (bboxHeight(bbox) - bboxDepth(bbox)) -
		TeX(sigma22, gc, dd);
	    if (draw) {
		PMoveUp(-shift, mc);
		bbox = RenderSymbolChar(opId, 1, mc, gc, dd);
		PMoveUp(shift, mc);
	    }

	SetFont(prevfont, gc);
	return bbox;
    }
}
 
static BBOX RenderOp(SEXP expr, int draw, mathContext *mc,
		     R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX lowerBBox, upperBBox, bodyBBox;
    double savedX = mc->CurrentX;
    double savedY = mc->CurrentY;
    int nexpr = length(expr);

    if (nexpr > 2) {
	SetSubStyle(style, mc, gc);
	lowerBBox = RenderElement(CADDR(expr), 0, mc, gc, dd);
	SetStyle(style, mc, gc);
	width = max(width, bboxWidth(lowerBBox));
	lvshift = max(TeX(xi10, gc, dd), TeX(xi12, gc, dd) -
		      bboxHeight(lowerBBox));
	lvshift = bboxDepth(opBBox) + bboxHeight(lowerBBox) + lvshift;
    }
    if (nexpr > 3) {
	SetSupStyle(style, mc, gc);
	upperBBox = RenderElement(CADDDR(expr), 0, mc, gc, dd);
	SetStyle(style, mc, gc);
	width = max(width, bboxWidth(upperBBox));
	uvshift = max(TeX(xi9, gc, dd), TeX(xi11, gc, dd) -
		      bboxDepth(upperBBox));
	uvshift = bboxHeight(opBBox) + bboxDepth(upperBBox) + uvshift;
    }
    hshift = 0.5 * (width - bboxWidth(opBBox));
    opBBox = RenderGap(hshift, draw, mc, gc, dd);
    opBBox = CombineBBoxes(opBBox,
			   RenderOpSymbol(CAR(expr), draw, mc, gc, dd));
    mc->CurrentX = savedX;
    mc->CurrentY = savedY;
    if (nexpr > 2) {
	SetSubStyle(style, mc, gc);
	hshift = 0.5 * (width - bboxWidth(lowerBBox));
	lowerBBox = RenderOffsetElement(CADDR(expr), hshift, -lvshift, draw,
					mc, gc, dd);
	SetStyle(style, mc, gc);
	opBBox = CombineAlignedBBoxes(opBBox, lowerBBox);
	mc->CurrentX = savedX;
	mc->CurrentY = savedY;
    }
    if (nexpr > 3) {
	SetSupStyle(style, mc, gc);
	hshift = 0.5 * (width - bboxWidth(upperBBox));
	upperBBox = RenderOffsetElement(CADDDR(expr), hshift, uvshift, draw,
					mc, gc, dd);
	SetStyle(style, mc, gc);
	opBBox = CombineAlignedBBoxes(opBBox, upperBBox);
	mc->CurrentX = savedX;
	mc->CurrentY = savedY;
    }
    opBBox = EnlargeBBox(opBBox, TeX(xi13, gc, dd), TeX(xi13, gc, dd), 0);
    if (draw)
	PMoveAcross(width, mc);
    opBBox = CombineBBoxes(opBBox,
			   RenderGap(ThinSpace(gc, dd), draw, mc, gc, dd));
    bodyBBox = RenderElement(CADR(expr), draw, mc, gc, dd);
    return CombineBBoxes(opBBox, bodyBBox);
}
 
 

    return NameAtom(expr) &&
	(NameMatch(expr, "root") ||
	 NameMatch(expr, "sqrt"));
}
 
static BBOX RenderScript(SEXP expr, int draw, mathContext *mc,
			 R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox;
    STYLE style = GetStyle(mc);
    SetSupStyle(style, mc, gc);
    bbox = RenderElement(expr, draw, mc, gc, dd);
    SetStyle(style, mc, gc);
    return bbox;
}
 
static BBOX RenderRadical(SEXP expr, int draw, mathContext *mc,
			  R_GE_gcontext *gc, GEDevDesc *dd)
{
    SEXP body = CADR(expr);
    SEXP order = CADDR(expr);
    BBOX bodyBBox, orderBBox;
    double radWidth, radHeight, radDepth;

	GEPolyline(5, x, y, gc, dd);
	PMoveTo(savedX, savedY, mc);
	gc->lty = savedlty;
	gc->lwd = savedlwd;
    }
    orderBBox =
	CombineAlignedBBoxes(orderBBox,
			     RenderGap(leadWidth + radSpace, draw, mc, gc, dd));
    SetPrimeStyle(style, mc, gc);
    orderBBox = CombineBBoxes(orderBBox,
			      RenderElement(body, draw, mc, gc, dd));
    orderBBox = CombineBBoxes(orderBBox,
			      RenderGap(2 * radTrail, draw, mc, gc, dd));
    orderBBox = EnlargeBBox(orderBBox, radGap, 0, 0);/* << fixes PR#1101 */
    SetStyle(style, mc, gc);
    return orderBBox;
}
 

static int AbsAtom(SEXP expr)
{
    return NameAtom(expr) && NameMatch(expr, "abs");
}
 
static BBOX RenderAbs(SEXP expr, int draw, mathContext *mc,
		      R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox = RenderElement(CADR(expr), 0, mc, gc, dd);
    double height = bboxHeight(bbox);
    double depth = bboxDepth(bbox);
    double x[2], y[2];

{
    return NameAtom(expr) &&
	NameMatch(expr, "{");
}
 
static BBOX RenderCurly(SEXP expr, int draw, mathContext *mc,
			R_GE_gcontext *gc, GEDevDesc *dd)
{
    return RenderElement(CADR(expr), draw, mc, gc, dd);
}
 
 

	if (NameMatch(expr, RelTable[i].name))
	    return RelTable[i].code;
    return 0;
}
 
static BBOX RenderRel(SEXP expr, int draw, mathContext *mc,
		      R_GE_gcontext *gc, GEDevDesc *dd)
{
    int op = RelAtom(CAR(expr));
    int nexpr = length(expr);
    BBOX bbox;
    double gap;

	bbox = RenderElement(CADR(expr), draw, mc, gc, dd);
	bbox = RenderItalicCorr(bbox, draw, mc, gc, dd);
	bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));
	bbox = CombineBBoxes(bbox, RenderSymbolChar(op, draw, mc, gc, dd));
	bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));
	return
	    CombineBBoxes(bbox, RenderElement(CADDR(expr), draw, mc, gc, dd));
    }
    else error("invalid mathematical annotation");
 
    return NullBBox();		/* -Wall */
}

{
    return NameAtom(expr) &&
	NameMatch(expr, "bold");
}
 
static BBOX RenderBold(SEXP expr, int draw, mathContext *mc,
		       R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox;
    FontType prevfont = SetFont(BoldFont, gc);
    bbox = RenderElement(CADR(expr), draw, mc, gc, dd);
    SetFont(prevfont, gc);

{
    return NameAtom(expr) &&
	(NameMatch(expr, "italic") || NameMatch(expr, "math"));
}
 
static BBOX RenderItalic(SEXP expr, int draw, mathContext *mc,
			 R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox;
    FontType prevfont = SetFont(ItalicFont, gc);
    bbox = RenderElement(CADR(expr), draw, mc, gc, dd);
    SetFont(prevfont, gc);

{
    return NameAtom(expr) &&
	NameMatch(expr, "plain");
}
 
static BBOX RenderPlain(SEXP expr, int draw, mathContext *mc,
			R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox;
    int prevfont = SetFont(PlainFont, gc);
    bbox = RenderElement(CADR(expr), draw, mc, gc, dd);
    SetFont(prevfont, gc);

{
    return NameAtom(expr) &&
	(NameMatch(expr, "bolditalic") || NameMatch(expr, "boldmath"));
}
 
static BBOX RenderBoldItalic(SEXP expr, int draw, mathContext *mc,
			     R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox;
    int prevfont = SetFont(BoldItalicFont, gc);
    bbox = RenderElement(CADR(expr), draw, mc, gc, dd);
    SetFont(prevfont, gc);

	     NameMatch(expr, "textstyle")    ||
	     NameMatch(expr, "scriptstyle")   ||
	     NameMatch(expr, "scriptscriptstyle")));
}
 
static BBOX RenderStyle(SEXP expr, int draw, mathContext *mc,
			R_GE_gcontext *gc, GEDevDesc *dd)
{
    STYLE prevstyle = GetStyle(mc);
    BBOX bbox;
    if (NameMatch(CAR(expr), "displaystyle"))
	SetStyle(STYLE_D, mc, gc);

    return (NameAtom(expr) &&
	    (NameMatch(expr, "phantom") ||
	     NameMatch(expr, "vphantom")));
}
 
static BBOX RenderPhantom(SEXP expr, int draw, mathContext *mc,
			  R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox = RenderElement(CADR(expr), 0, mc, gc, dd);
    if (NameMatch(CAR(expr), "vphantom")) {
	bboxWidth(bbox) = 0;
	bboxItalic(bbox) = 0;

static int ConcatenateAtom(SEXP expr)
{
    return NameAtom(expr) && NameMatch(expr, "paste");
}
 
static BBOX RenderConcatenate(SEXP expr, int draw, mathContext *mc,
			      R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox = NullBBox();
    int i, n;
 
    expr = CDR(expr);

 *
 *  Code for Comma-Separated Lists
 *
 */
 
static BBOX RenderCommaList(SEXP expr, int draw, mathContext *mc,
			    R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox = NullBBox();
    double small = 0.4 * ThinSpace(gc, dd);
    int i, n;
    n = length(expr);
    for (i = 0; i < n; i++) {
	if (NameAtom(CAR(expr)) && NameMatch(CAR(expr), "...")) {
	    if (i > 0) {
		bbox = CombineBBoxes(bbox, RenderSymbolChar(S_COMMA, draw,
							    mc, gc, dd));
		bbox = CombineBBoxes(bbox, RenderSymbolChar(S_SPACE, draw,
							    mc, gc, dd));
	    }
	    bbox = CombineBBoxes(bbox, RenderSymbolChar(S_ELLIPSIS, draw,
							mc, gc, dd));
	    bbox = CombineBBoxes(bbox, RenderGap(small, draw, mc, gc, dd));
	}
	else {
	    if (i > 0) {
		bbox = CombineBBoxes(bbox, RenderSymbolChar(S_COMMA, draw,
							    mc, gc, dd));
		bbox = CombineBBoxes(bbox, RenderSymbolChar(S_SPACE, draw,
							    mc, gc, dd));
	    }
	    bbox = CombineBBoxes(bbox, RenderElement(CAR(expr), draw, mc,
						     gc, dd));
	}
	expr = CDR(expr);
    }
    return bbox;
}

 *
 *  Code for General Expressions
 *
 */
 
static BBOX RenderExpression(SEXP expr, int draw, mathContext *mc,
			     R_GE_gcontext *gc, GEDevDesc *dd)
{
    BBOX bbox;
    if (NameAtom(CAR(expr)))
	bbox = RenderSymbolString(CAR(expr), draw, mc, gc, dd);
    else

static int ListAtom(SEXP expr)
{
    return NameAtom(expr) && NameMatch(expr, "list");
}
 
static BBOX RenderList(SEXP expr, int draw, mathContext *mc,
		       R_GE_gcontext *gc, GEDevDesc *dd)
{
    return RenderCommaList(CDR(expr), draw, mc, gc, dd);
}
 
/* Dispatching procedure which determines nature of expression. */
 
 
static BBOX RenderFormula(SEXP expr, int draw, mathContext *mc,
			  R_GE_gcontext *gc, GEDevDesc *dd)
{
    SEXP head = CAR(expr);
 
    if (SpaceAtom(head))
	return RenderSpace(expr, draw, mc, gc, dd);

 
 
/* Dispatch on whether atom (symbol, string, number, ...) */
/* or formula (some sort of expression) */
 
static BBOX RenderElement(SEXP expr, int draw, mathContext *mc,
			  R_GE_gcontext *gc, GEDevDesc *dd)
{
    if (FormulaExpression(expr))
	return RenderFormula(expr, draw, mc, gc, dd);
    else
	return RenderAtom(expr, draw, mc, gc, dd);
}
 
static BBOX RenderOffsetElement(SEXP expr, double x, double y, int draw,
				mathContext *mc, R_GE_gcontext *gc,
				GEDevDesc *dd)
{
    BBOX bbox;
    double savedX = mc->CurrentX;
    double savedY = mc->CurrentY;
    if (draw) {

/* Functions forming the R API */
 
/* Calculate width of expression */
/* BBOXes are in INCHES (see MetricUnit) */
 
double GEExpressionWidth(SEXP expr,
			 R_GE_gcontext *gc,
			 GEDevDesc *dd)
{
    BBOX bbox;
    double width;

    mc.SinAngle = 0;
 
    SetFont(PlainFont, gc);
    bbox = RenderElement(expr, 0, &mc, gc, dd);
    width  = bboxWidth(bbox);
    /*
     * NOTE that we do fabs() here in case the device
     * runs right-to-left.
     * This is so that these calculations match those
     * for string widths and heights, where the width
     * and height of text is positive no matter how
     * the device drawing is oriented.
     */
    return fabs(toDeviceWidth(width, GE_INCHES, dd));
}
 
double GEExpressionHeight(SEXP expr,
			  R_GE_gcontext *gc,
			  GEDevDesc *dd)
{
    BBOX bbox;
    double height;

     */
    return fabs(toDeviceHeight(height, GE_INCHES, dd));
}
 
void GEMathText(double x, double y, SEXP expr,
		double xc, double yc, double rot,
		R_GE_gcontext *gc,
		GEDevDesc *dd)
{
    BBOX bbox;
    mathContext mc;

}/* GMathText */
 
 
/********************************
 * Code below here ...
 * ... should be moved to base.c and
 * ... is part of the base graphics API NOT the graphics engine API
 ********************************
 */
double GExpressionWidth(SEXP expr, GUnit units, DevDesc *dd)
{
    R_GE_gcontext gc;
    double width;
    gcontextFromGP(&gc, dd);
    width = GEExpressionWidth(expr, &gc, (GEDevDesc*) dd);
    if (units == DEVICE)
	return width;
    else

    else
	return GConvertYUnits(height, DEVICE, units, dd);
}
 
/* This is just here to satisfy the Rgraphics.h API.
 * This allows new graphics API (GraphicsDevice.h, GraphicsEngine.h)
 * to be developed alongside.
 * Could be removed if Rgraphics.h ever gets REPLACED by new API
 * NOTE that base graphics code no longer calls this -- the base
 * graphics system directly calls the graphics engine for mathematical
 * annotation (GEMathText)
 */
void GMathText(double x, double y, int coords, SEXP expr,
	       double xc, double yc, double rot,
	       DevDesc *dd)
{
    R_GE_gcontext gc;
    gcontextFromGP(&gc, dd);
    GConvert(&x, &y, coords, DEVICE, dd);

Rev 32380	Rev 32392
Line 19...	Line 19...
19	`* You should have received a copy of the GNU General Public License`	19	`* You should have received a copy of the GNU General Public License`
20	`* along with this program; if not, write to the Free Software`	20	`* along with this program; if not, write to the Free Software`
21	`* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA`	21	`* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA`
22	`*/`	22	`*/`
23		23
24	`/* <UTF8-FIXME>`	24	`/* <UTF8-FIXME>`
25	`byte-level access and use of ctype functions`	25	`byte-level access and use of ctype functions`
26	`byte-level charmetric information.`	26	`byte-level charmetric information.`
-		27	`Has encoding of symbol font hard-coded.`
27	`*/`	28	`*/`
28		29
29	`#ifdef HAVE_CONFIG_H`	30	`#ifdef HAVE_CONFIG_H`
30	`#include <config.h>`	31	`#include <config.h>`
31	`#endif`	32	`#endif`
Line 949...	Line 950...
949	`mathContext, R_GE_gcontext, GEDevDesc*);`	950	`mathContext, R_GE_gcontext, GEDevDesc*);`
950	`static BBOX RenderOffsetElement(SEXP, double, double, int,`	951	`static BBOX RenderOffsetElement(SEXP, double, double, int,`
951	`mathContext, R_GE_gcontext, GEDevDesc*);`	952	`mathContext, R_GE_gcontext, GEDevDesc*);`
952	`static BBOX RenderExpression(SEXP, int,`	953	`static BBOX RenderExpression(SEXP, int,`
953	`mathContext, R_GE_gcontext, GEDevDesc*);`	954	`mathContext, R_GE_gcontext, GEDevDesc*);`
954	`static BBOX RenderSymbolChar(int, int,`	955	`static BBOX RenderSymbolChar(int, int,`
955	`mathContext, R_GE_gcontext, GEDevDesc*);`	956	`mathContext, R_GE_gcontext, GEDevDesc*);`
956		957
957		958
958	`/* Code to Generate Bounding Boxes and Draw Formulae. */`	959	`/* Code to Generate Bounding Boxes and Draw Formulae. */`
959		960
960	`static BBOX RenderItalicCorr(BBOX bbox, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	961	`static BBOX RenderItalicCorr(BBOX bbox, int draw, mathContext *mc,`
-		962	`R_GE_gcontext gc, GEDevDesc dd)`
961	`{`	963	`{`
962	`if (bboxItalic(bbox) > 0) {`	964	`if (bboxItalic(bbox) > 0) {`
963	`if (draw)`	965	`if (draw)`
964	`PMoveAcross(bboxItalic(bbox), mc);`	966	`PMoveAcross(bboxItalic(bbox), mc);`
965	`bboxWidth(bbox) += bboxItalic(bbox);`	967	`bboxWidth(bbox) += bboxItalic(bbox);`
966	`bboxItalic(bbox) = 0;`	968	`bboxItalic(bbox) = 0;`
967	`}`	969	`}`
968	`return bbox;`	970	`return bbox;`
969	`}`	971	`}`
970		972
971	`static BBOX RenderGap(double gap, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	973	`static BBOX RenderGap(double gap, int draw, mathContext *mc,`
-		974	`R_GE_gcontext gc, GEDevDesc dd)`
972	`{`	975	`{`
973	`if (draw)`	976	`if (draw)`
974	`PMoveAcross(gap, mc);`	977	`PMoveAcross(gap, mc);`
975	`return MakeBBox(0, 0, gap);`	978	`return MakeBBox(0, 0, gap);`
976	`}`	979	`}`
977		980
978	`/* Draw a Symbol from the Special Font */`	981	`/* Draw a Symbol from the Special Font */`
979		982
980	`static BBOX RenderSymbolChar(int ascii, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	983	`static BBOX RenderSymbolChar(int ascii, int draw, mathContext *mc,`
-		984	`R_GE_gcontext gc, GEDevDesc dd)`
981	`{`	985	`{`
982	`FontType prev;`	986	`FontType prev;`
983	`BBOX bbox;`	987	`BBOX bbox;`
984	`char asciiStr[2];`	988	`char asciiStr[2];`
985	`if (ascii == A_HAT \|\| ascii == A_TILDE)`	989	`if (ascii == A_HAT \|\| ascii == A_TILDE)`
Line 988...	Line 992...
988	`prev = SetFont(SymbolFont, gc);`	992	`prev = SetFont(SymbolFont, gc);`
989	`bbox = GlyphBBox(ascii, gc, dd);`	993	`bbox = GlyphBBox(ascii, gc, dd);`
990	`if (draw) {`	994	`if (draw) {`
991	`asciiStr[0] = ascii;`	995	`asciiStr[0] = ascii;`
992	`asciiStr[1] = '\0';`	996	`asciiStr[1] = '\0';`
993	`GEText(ConvertedX(mc ,dd), ConvertedY(mc, dd), asciiStr,`	997	`GEText(ConvertedX(mc ,dd), ConvertedY(mc, dd), asciiStr,`
994	`0.0, 0.0, mc->CurrentAngle, gc,`	998	`0.0, 0.0, mc->CurrentAngle, gc,`
995	`dd);`	999	`dd);`
996	`PMoveAcross(bboxWidth(bbox), mc);`	1000	`PMoveAcross(bboxWidth(bbox), mc);`
997	`}`	1001	`}`
998	`SetFont(prev, gc);`	1002	`SetFont(prev, gc);`
Line 1001...	Line 1005...
1001		1005
1002	`/* Draw a Symbol String in "Math Mode */`	1006	`/* Draw a Symbol String in "Math Mode */`
1003	`/* This code inserts italic corrections after */`	1007	`/* This code inserts italic corrections after */`
1004	`/* every character. */`	1008	`/* every character. */`
1005		1009
1006	`static BBOX RenderSymbolStr(char str, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc dd)`	1010	`static BBOX RenderSymbolStr(char str, int draw, mathContext mc,`
-		1011	`R_GE_gcontext gc, GEDevDesc dd)`
1007	`{`	1012	`{`
1008	`char chr[2];`	1013	`char chr[2];`
1009	`BBOX glyphBBox;`	1014	`BBOX glyphBBox;`
1010	`BBOX resultBBox = NullBBox();`	1015	`BBOX resultBBox = NullBBox();`
1011	`double lastItalicCorr = 0;`	1016	`double lastItalicCorr = 0;`
Line 1048...	Line 1053...
1048	`return resultBBox;`	1053	`return resultBBox;`
1049	`}`	1054	`}`
1050		1055
1051	`/* Code for Character String Atoms. */`	1056	`/* Code for Character String Atoms. */`
1052		1057
1053	`static BBOX RenderChar(int ascii, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1058	`static BBOX RenderChar(int ascii, int draw, mathContext *mc,`
-		1059	`R_GE_gcontext gc, GEDevDesc dd)`
1054	`{`	1060	`{`
1055	`BBOX bbox;`	1061	`BBOX bbox;`
1056	`char asciiStr[2];`	1062	`char asciiStr[2];`
1057	`bbox = GlyphBBox(ascii, gc, dd);`	1063	`bbox = GlyphBBox(ascii, gc, dd);`
1058	`if (draw) {`	1064	`if (draw) {`
Line 1064...	Line 1070...
1064	`PMoveAcross(bboxWidth(bbox), mc);`	1070	`PMoveAcross(bboxWidth(bbox), mc);`
1065	`}`	1071	`}`
1066	`return bbox;`	1072	`return bbox;`
1067	`}`	1073	`}`
1068		1074
1069	`static BBOX RenderStr(char str, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc dd)`	1075	`static BBOX RenderStr(char str, int draw, mathContext mc,`
-		1076	`R_GE_gcontext gc, GEDevDesc dd)`
1070	`{`	1077	`{`
1071	`BBOX glyphBBox;`	1078	`BBOX glyphBBox;`
1072	`BBOX resultBBox = NullBBox();`	1079	`BBOX resultBBox = NullBBox();`
1073	`if (str) {`	1080	`if (str) {`
1074	`char *s = str;`	1081	`char *s = str;`
Line 1093...	Line 1100...
1093	`}`	1100	`}`
1094		1101
1095		1102
1096	`/* Code for Symbol Font Atoms */`	1103	`/* Code for Symbol Font Atoms */`
1097		1104
1098	`static BBOX RenderSymbol(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1105	`static BBOX RenderSymbol(SEXP expr, int draw, mathContext *mc,`
-		1106	`R_GE_gcontext gc, GEDevDesc dd)`
1099	`{`	1107	`{`
1100	`int code;`	1108	`int code;`
1101	`if ((code = TranslatedSymbol(expr)))`	1109	`if ((code = TranslatedSymbol(expr)))`
1102	`return RenderSymbolChar(code, draw, mc, gc, dd);`	1110	`return RenderSymbolChar(code, draw, mc, gc, dd);`
1103	`else`	1111	`else`
1104	`return RenderSymbolStr(CHAR(PRINTNAME(expr)), draw, mc, gc, dd);`	1112	`return RenderSymbolStr(CHAR(PRINTNAME(expr)), draw, mc, gc, dd);`
1105	`}`	1113	`}`
1106		1114
1107	`static BBOX RenderSymbolString(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1115	`static BBOX RenderSymbolString(SEXP expr, int draw, mathContext *mc,`
-		1116	`R_GE_gcontext gc, GEDevDesc dd)`
1108	`{`	1117	`{`
1109	`int code;`	1118	`int code;`
1110	`if ((code = TranslatedSymbol(expr)))`	1119	`if ((code = TranslatedSymbol(expr)))`
1111	`return RenderSymbolChar(code, draw, mc, gc, dd);`	1120	`return RenderSymbolChar(code, draw, mc, gc, dd);`
1112	`else`	1121	`else`
Line 1114...	Line 1123...
1114	`}`	1123	`}`
1115		1124
1116		1125
1117	`/* Code for Numeric Atoms */`	1126	`/* Code for Numeric Atoms */`
1118		1127
1119	`static BBOX RenderNumber(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1128	`static BBOX RenderNumber(SEXP expr, int draw, mathContext *mc,`
-		1129	`R_GE_gcontext gc, GEDevDesc dd)`
1120	`{`	1130	`{`
1121	`BBOX bbox;`	1131	`BBOX bbox;`
1122	`FontType prevfont = SetFont(PlainFont, gc);`	1132	`FontType prevfont = SetFont(PlainFont, gc);`
1123	`bbox = RenderStr(CHAR(asChar(expr)), draw, mc, gc, dd);`	1133	`bbox = RenderStr(CHAR(asChar(expr)), draw, mc, gc, dd);`
1124	`SetFont(prevfont, gc);`	1134	`SetFont(prevfont, gc);`
1125	`return bbox;`	1135	`return bbox;`
1126	`}`	1136	`}`
1127		1137
1128	`/* Code for String Atoms */`	1138	`/* Code for String Atoms */`
1129		1139
1130	`static BBOX RenderString(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1140	`static BBOX RenderString(SEXP expr, int draw, mathContext *mc,`
-		1141	`R_GE_gcontext gc, GEDevDesc dd)`
1131	`{`	1142	`{`
1132	`return RenderStr(CHAR(STRING_ELT(expr, 0)), draw, mc, gc, dd);`	1143	`return RenderStr(CHAR(STRING_ELT(expr, 0)), draw, mc, gc, dd);`
1133	`}`	1144	`}`
1134		1145
1135	`/* Code for Ellipsis (ldots, cdots, ...) */`	1146	`/* Code for Ellipsis (ldots, cdots, ...) */`
Line 1141...	Line 1152...
1141	`NameMatch(expr, "ldots"))`	1152	`NameMatch(expr, "ldots"))`
1142	`return 1;`	1153	`return 1;`
1143	`return 0;`	1154	`return 0;`
1144	`}`	1155	`}`
1145		1156
1146	`static BBOX RenderDots(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1157	`static BBOX RenderDots(SEXP expr, int draw, mathContext *mc,`
-		1158	`R_GE_gcontext gc, GEDevDesc dd)`
1147	`{`	1159	`{`
1148	`BBOX bbox = RenderSymbolChar(S_ELLIPSIS, 0, mc, gc, dd);`	1160	`BBOX bbox = RenderSymbolChar(S_ELLIPSIS, 0, mc, gc, dd);`
1149	`if (NameMatch(expr, "cdots") \|\| NameMatch(expr, "...")) {`	1161	`if (NameMatch(expr, "cdots") \|\| NameMatch(expr, "...")) {`
1150	`double shift = AxisHeight(gc, dd) - 0.5 * bboxHeight(bbox);`	1162	`double shift = AxisHeight(gc, dd) - 0.5 * bboxHeight(bbox);`
1151	`if (draw) {`	1163	`if (draw) {`
Line 1166...	Line 1178...
1166	`*`	1178	`*`
1167	`* Code for Atoms`	1179	`* Code for Atoms`
1168	`*`	1180	`*`
1169	`*/`	1181	`*/`
1170		1182
1171	`static BBOX RenderAtom(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1183	`static BBOX RenderAtom(SEXP expr, int draw, mathContext *mc,`
-		1184	`R_GE_gcontext gc, GEDevDesc dd)`
1172	`{`	1185	`{`
1173	`if (NameAtom(expr)) {`	1186	`if (NameAtom(expr)) {`
1174	`if (DotsAtom(expr))`	1187	`if (DotsAtom(expr))`
1175	`return RenderDots(expr, draw, mc, gc, dd);`	1188	`return RenderDots(expr, draw, mc, gc, dd);`
1176	`else`	1189	`else`
Line 1197...	Line 1210...
1197	`{`	1210	`{`
1198	`return NameAtom(expr) && NameMatch(expr, "~");`	1211	`return NameAtom(expr) && NameMatch(expr, "~");`
1199	`}`	1212	`}`
1200		1213
1201		1214
1202	`static BBOX RenderSpace(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1215	`static BBOX RenderSpace(SEXP expr, int draw, mathContext *mc,`
-		1216	`R_GE_gcontext gc, GEDevDesc dd)`
1203	`{`	1217	`{`
1204		1218
1205	`BBOX opBBox, arg1BBox, arg2BBox;`	1219	`BBOX opBBox, arg1BBox, arg2BBox;`
1206	`int nexpr = length(expr);`	1220	`int nexpr = length(expr);`
1207		1221
Line 1248...	Line 1262...
1248	`return 0;`	1262	`return 0;`
1249	`}`	1263	`}`
1250		1264
1251	`#define SLASH2`	1265	`#define SLASH2`
1252		1266
1253	`static BBOX RenderSlash(int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1267	`static BBOX RenderSlash(int draw, mathContext mc, R_GE_gcontext gc,`
-		1268	`GEDevDesc *dd)`
1254	`{`	1269	`{`
1255	`#ifdef SLASH0`	1270	`#ifdef SLASH0`
1256	`/* The Default Font Character */`	1271	`/* The Default Font Character */`
1257	`return RenderSymbolChar(S_SLASH, draw, mc, gc, dd);`	1272	`return RenderSymbolChar(S_SLASH, draw, mc, gc, dd);`
1258	`#endif`	1273	`#endif`
Line 1310...	Line 1325...
1310	`double delta = TeX(sigma22, gc, dd);`	1325	`double delta = TeX(sigma22, gc, dd);`
1311	`if (draw)`	1326	`if (draw)`
1312	`PMoveUp(-delta, mc);`	1327	`PMoveUp(-delta, mc);`
1313	`ansBBox = ShiftBBox(RenderSymbolChar(S_SLASH, draw), -delta, mc, gc, dd);`	1328	`ansBBox = ShiftBBox(RenderSymbolChar(S_SLASH, draw), -delta, mc, gc, dd);`
1314	`PMoveUp(2 * delta, mc);`	1329	`PMoveUp(2 * delta, mc);`
1315	`ansBBox = CombineBBoxes(ansBBox, RenderGap(2 * delta / slope, draw, mc, gc, dd));`	1330	`ansBBox = CombineBBoxes(ansBBox, RenderGap(2 * delta / slope, draw,`
-		1331	`mc, gc, dd));`
1316	`ansBBox = ShiftBBox(RenderSymbolChar(S_SLASH, draw), 2 * delta, mc, gc, dd);`	1332	`ansBBox = ShiftBBox(RenderSymbolChar(S_SLASH, draw), 2 * delta,`
-		1333	`mc, gc, dd);`
1317	`PMoveUp(-delta, mc);`	1334	`PMoveUp(-delta, mc);`
1318	`return ansBBox;`	1335	`return ansBBox;`
1319	`#endif`	1336	`#endif`
1320	`}`	1337	`}`
1321		1338
1322	`static BBOX RenderBin(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1339	`static BBOX RenderBin(SEXP expr, int draw, mathContext *mc,`
-		1340	`R_GE_gcontext gc, GEDevDesc dd)`
1323	`{`	1341	`{`
1324	`int op = BinAtom(CAR(expr));`	1342	`int op = BinAtom(CAR(expr));`
1325	`int nexpr = length(expr);`	1343	`int nexpr = length(expr);`
1326	`BBOX bbox;`	1344	`BBOX bbox;`
1327	`double gap;`	1345	`double gap;`
1328		1346
1329	`if(nexpr == 3) {`	1347	`if(nexpr == 3) {`
1330	`if (op == S_ASTERISKMATH) {`	1348	`if (op == S_ASTERISKMATH) {`
1331	`bbox = RenderElement(CADR(expr), draw, mc, gc, dd);`	1349	`bbox = RenderElement(CADR(expr), draw, mc, gc, dd);`
1332	`bbox = RenderItalicCorr(bbox, draw, mc, gc, dd);`	1350	`bbox = RenderItalicCorr(bbox, draw, mc, gc, dd);`
1333	`return CombineBBoxes(bbox, RenderElement(CADDR(expr), draw, mc, gc, dd));`	1351	`return CombineBBoxes(bbox, RenderElement(CADDR(expr), draw,`
-		1352	`mc, gc, dd));`
1334	`}`	1353	`}`
1335	`else if (op == S_SLASH) {`	1354	`else if (op == S_SLASH) {`
1336	`gap = 0;`	1355	`gap = 0;`
1337	`bbox = RenderElement(CADR(expr), draw, mc, gc, dd);`	1356	`bbox = RenderElement(CADR(expr), draw, mc, gc, dd);`
1338	`bbox = RenderItalicCorr(bbox, draw, mc, gc, dd);`	1357	`bbox = RenderItalicCorr(bbox, draw, mc, gc, dd);`
1339	`bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));`	1358	`bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));`
1340	`bbox = CombineBBoxes(bbox, RenderSlash(draw, mc, gc, dd));`	1359	`bbox = CombineBBoxes(bbox, RenderSlash(draw, mc, gc, dd));`
1341	`bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));`	1360	`bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));`
1342	`return CombineBBoxes(bbox, RenderElement(CADDR(expr), draw, mc, gc, dd));`	1361	`return CombineBBoxes(bbox, RenderElement(CADDR(expr), draw,`
-		1362	`mc, gc, dd));`
1343	`}`	1363	`}`
1344	`else {`	1364	`else {`
1345	`gap = (mc->CurrentStyle > STYLE_S) ? MediumSpace(gc, dd) : 0;`	1365	`gap = (mc->CurrentStyle > STYLE_S) ? MediumSpace(gc, dd) : 0;`
1346	`bbox = RenderElement(CADR(expr), draw, mc, gc, dd);`	1366	`bbox = RenderElement(CADR(expr), draw, mc, gc, dd);`
1347	`bbox = RenderItalicCorr(bbox, draw, mc, gc, dd);`	1367	`bbox = RenderItalicCorr(bbox, draw, mc, gc, dd);`
1348	`bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));`	1368	`bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));`
1349	`bbox = CombineBBoxes(bbox, RenderSymbolChar(op, draw, mc, gc, dd));`	1369	`bbox = CombineBBoxes(bbox, RenderSymbolChar(op, draw, mc, gc, dd));`
1350	`bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));`	1370	`bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));`
1351	`return CombineBBoxes(bbox, RenderElement(CADDR(expr), draw, mc, gc, dd));`	1371	`return CombineBBoxes(bbox, RenderElement(CADDR(expr), draw,`
-		1372	`mc, gc, dd));`
1352	`}`	1373	`}`
1353	`}`	1374	`}`
1354	`else if(nexpr == 2) {`	1375	`else if(nexpr == 2) {`
1355	`gap = (mc->CurrentStyle > STYLE_S) ? ThinSpace(gc, dd) : 0;`	1376	`gap = (mc->CurrentStyle > STYLE_S) ? ThinSpace(gc, dd) : 0;`
1356	`bbox = RenderSymbolChar(op, draw, mc, gc, dd);`	1377	`bbox = RenderSymbolChar(op, draw, mc, gc, dd);`
1357	`bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));`	1378	`bbox = CombineBBoxes(bbox, RenderGap(gap, draw, mc, gc, dd));`
1358	`return CombineBBoxes(bbox, RenderElement(CADR(expr), draw, mc, gc, dd));`	1379	`return CombineBBoxes(bbox, RenderElement(CADR(expr), draw, mc,`
-		1380	`gc, dd));`
1359	`}`	1381	`}`
1360	`else`	1382	`else`
1361	`error("invalid mathematical annotation");`	1383	`error("invalid mathematical annotation");`
1362		1384
1363	`return NullBBox(); /* -Wall */`	1385	`return NullBBox(); /* -Wall */`
Line 1384...	Line 1406...
1384	`}`	1406	`}`
1385		1407
1386	`/* Note : If all computations are correct */`	1408	`/* Note : If all computations are correct */`
1387	`/* We do not need to save and restore the */`	1409	`/* We do not need to save and restore the */`
1388	`/* current location here. This is paranoia. */`	1410	`/* current location here. This is paranoia. */`
1389	`static BBOX RenderSub(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1411	`static BBOX RenderSub(SEXP expr, int draw, mathContext *mc,`
-		1412	`R_GE_gcontext gc, GEDevDesc dd)`
1390	`{`	1413	`{`
1391	`BBOX bodyBBox, subBBox;`	1414	`BBOX bodyBBox, subBBox;`
1392	`SEXP body = CADR(expr);`	1415	`SEXP body = CADR(expr);`
1393	`SEXP sub = CADDR(expr);`	1416	`SEXP sub = CADDR(expr);`
1394	`STYLE style = GetStyle(mc);`	1417	`STYLE style = GetStyle(mc);`
Line 1409...	Line 1432...
1409	`if (draw)`	1432	`if (draw)`
1410	`PMoveTo(savedX + bboxWidth(bodyBBox), savedY, mc);`	1433	`PMoveTo(savedX + bboxWidth(bodyBBox), savedY, mc);`
1411	`return bodyBBox;`	1434	`return bodyBBox;`
1412	`}`	1435	`}`
1413		1436
1414	`static BBOX RenderSup(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1437	`static BBOX RenderSup(SEXP expr, int draw, mathContext *mc,`
-		1438	`R_GE_gcontext gc, GEDevDesc dd)`
1415	`{`	1439	`{`
1416	`BBOX bodyBBox, subBBox, supBBox;`	1440	`BBOX bodyBBox, subBBox, supBBox;`
1417	`SEXP body = CADR(expr);`	1441	`SEXP body = CADR(expr);`
1418	`SEXP sup = CADDR(expr);`	1442	`SEXP sup = CADDR(expr);`
1419	`SEXP sub = R_NilValue; /* -Wall */`	1443	`SEXP sub = R_NilValue; /* -Wall */`
Line 1502...	Line 1526...
1502	`static int WideTildeAtom(SEXP expr)`	1526	`static int WideTildeAtom(SEXP expr)`
1503	`{`	1527	`{`
1504	`return NameAtom(expr) && NameMatch(expr, "widetilde");`	1528	`return NameAtom(expr) && NameMatch(expr, "widetilde");`
1505	`}`	1529	`}`
1506		1530
1507	`static BBOX RenderWideTilde(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1531	`static BBOX RenderWideTilde(SEXP expr, int draw, mathContext *mc,`
-		1532	`R_GE_gcontext gc, GEDevDesc dd)`
1508	`{`	1533	`{`
1509	`double savedX = mc->CurrentX;`	1534	`double savedX = mc->CurrentX;`
1510	`double savedY = mc->CurrentY;`	1535	`double savedY = mc->CurrentY;`
1511	`BBOX bbox = RenderElement(CADR(expr), draw, mc, gc, dd);`	1536	`BBOX bbox = RenderElement(CADR(expr), draw, mc, gc, dd);`
1512	`double height = bboxHeight(bbox);`	1537	`double height = bboxHeight(bbox);`
Line 1553...	Line 1578...
1553	`static int WideHatAtom(SEXP expr)`	1578	`static int WideHatAtom(SEXP expr)`
1554	`{`	1579	`{`
1555	`return NameAtom(expr) && NameMatch(expr, "widehat");`	1580	`return NameAtom(expr) && NameMatch(expr, "widehat");`
1556	`}`	1581	`}`
1557		1582
1558	`static BBOX RenderWideHat(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1583	`static BBOX RenderWideHat(SEXP expr, int draw, mathContext *mc,`
-		1584	`R_GE_gcontext gc, GEDevDesc dd)`
1559	`{`	1585	`{`
1560	`double savedX = mc->CurrentX;`	1586	`double savedX = mc->CurrentX;`
1561	`double savedY = mc->CurrentY;`	1587	`double savedY = mc->CurrentY;`
1562	`BBOX bbox = RenderElement(CADR(expr), draw, mc, gc, dd);`	1588	`BBOX bbox = RenderElement(CADR(expr), draw, mc, gc, dd);`
1563	`double accentGap = ACCENT_GAP * XHeight(gc, dd);`	1589	`double accentGap = ACCENT_GAP * XHeight(gc, dd);`
Line 1594...	Line 1620...
1594	`static int BarAtom(SEXP expr)`	1620	`static int BarAtom(SEXP expr)`
1595	`{`	1621	`{`
1596	`return NameAtom(expr) && NameMatch(expr, "bar");`	1622	`return NameAtom(expr) && NameMatch(expr, "bar");`
1597	`}`	1623	`}`
1598		1624
1599	`static BBOX RenderBar(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1625	`static BBOX RenderBar(SEXP expr, int draw, mathContext *mc,`
-		1626	`R_GE_gcontext gc, GEDevDesc dd)`
1600	`{`	1627	`{`
1601	`double savedX = mc->CurrentX;`	1628	`double savedX = mc->CurrentX;`
1602	`double savedY = mc->CurrentY;`	1629	`double savedY = mc->CurrentY;`
1603	`BBOX bbox = RenderElement(CADR(expr), draw, mc, gc, dd);`	1630	`BBOX bbox = RenderElement(CADR(expr), draw, mc, gc, dd);`
1604	`double accentGap = ACCENT_GAP * XHeight(gc, dd);`	1631	`double accentGap = ACCENT_GAP * XHeight(gc, dd);`
Line 1656...	Line 1683...
1656	`static void InvalidAccent(SEXP expr)`	1683	`static void InvalidAccent(SEXP expr)`
1657	`{`	1684	`{`
1658	`errorcall(expr, "invalid accent");`	1685	`errorcall(expr, "invalid accent");`
1659	`}`	1686	`}`
1660		1687
1661	`static BBOX RenderAccent(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1688	`static BBOX RenderAccent(SEXP expr, int draw, mathContext *mc,`
-		1689	`R_GE_gcontext gc, GEDevDesc dd)`
1662	`{`	1690	`{`
1663	`SEXP body, accent;`	1691	`SEXP body, accent;`
1664	`double savedX = mc->CurrentX;`	1692	`double savedX = mc->CurrentX;`
1665	`double savedY = mc->CurrentY;`	1693	`double savedY = mc->CurrentY;`
1666	`BBOX bodyBBox, accentBBox;`	1694	`BBOX bodyBBox, accentBBox;`
Line 1686...	Line 1714...
1686	`bodyBBox = CombineBBoxes(bodyBBox, RenderElement(body, draw, mc, gc, dd));`	1714	`bodyBBox = CombineBBoxes(bodyBBox, RenderElement(body, draw, mc, gc, dd));`
1687	`bodyBBox = CombineBBoxes(bodyBBox, RenderGap(xoffset, draw, mc, gc, dd));`	1715	`bodyBBox = CombineBBoxes(bodyBBox, RenderGap(xoffset, draw, mc, gc, dd));`
1688	`PMoveTo(savedX, savedY, mc);`	1716	`PMoveTo(savedX, savedY, mc);`
1689	`xoffset = 0.5 *(width - bboxWidth(accentBBox))`	1717	`xoffset = 0.5 *(width - bboxWidth(accentBBox))`
1690	`+ 0.9 * italic;`	1718	`+ 0.9 * italic;`
1691	`yoffset = bboxHeight(bodyBBox) + bboxDepth(accentBBox) + 0.1 * XHeight(gc, dd);`	1719	`yoffset = bboxHeight(bodyBBox) + bboxDepth(accentBBox) +`
-		1720	`0.1 * XHeight(gc, dd);`
1692	`if (draw) {`	1721	`if (draw) {`
1693	`PMoveTo(savedX + xoffset, savedY + yoffset, mc);`	1722	`PMoveTo(savedX + xoffset, savedY + yoffset, mc);`
1694	`if (code == 215) /* dotmath */`	1723	`if (code == 215) /* dotmath */`
1695	`RenderSymbolChar(code, draw, mc, gc, dd);`	1724	`RenderSymbolChar(code, draw, mc, gc, dd);`
1696	`else`	1725	`else`
Line 1750...	Line 1779...
1750	`*numShift = (denomWidth - numWidth) / 2;`	1779	`*numShift = (denomWidth - numWidth) / 2;`
1751	`*denomShift = 0;`	1780	`*denomShift = 0;`
1752	`}`	1781	`}`
1753	`}`	1782	`}`
1754		1783
1755	`static BBOX RenderFraction(SEXP expr, int rule, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1784	`static BBOX RenderFraction(SEXP expr, int rule, int draw,`
-		1785	`mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`
1756	`{`	1786	`{`
1757	`SEXP numerator = CADR(expr);`	1787	`SEXP numerator = CADR(expr);`
1758	`SEXP denominator = CADDR(expr);`	1788	`SEXP denominator = CADDR(expr);`
1759	`BBOX numBBox, denomBBox;`	1789	`BBOX numBBox, denomBBox;`
1760	`double nHShift, dHShift;`	1790	`double nHShift, dHShift;`
Line 1764...	Line 1794...
1764	`double savedY = mc->CurrentY;`	1794	`double savedY = mc->CurrentY;`
1765	`STYLE style;`	1795	`STYLE style;`
1766		1796
1767	`style = GetStyle(mc);`	1797	`style = GetStyle(mc);`
1768	`SetNumStyle(style, mc, gc);`	1798	`SetNumStyle(style, mc, gc);`
1769	`numBBox = RenderItalicCorr(RenderElement(numerator, 0, mc, gc, dd), 0, mc, gc, dd);`	1799	`numBBox = RenderItalicCorr(RenderElement(numerator, 0, mc, gc, dd), 0,`
-		1800	`mc, gc, dd);`
1770	`SetDenomStyle(style, mc, gc);`	1801	`SetDenomStyle(style, mc, gc);`
1771	`denomBBox = RenderItalicCorr(RenderElement(denominator, 0, mc, gc, dd), 0, mc, gc, dd);`	1802	`denomBBox = RenderItalicCorr(RenderElement(denominator, 0, mc, gc, dd), 0,`
-		1803	`mc, gc, dd);`
1772	`SetStyle(style, mc, gc);`	1804	`SetStyle(style, mc, gc);`
1773		1805
1774	`width = max(bboxWidth(numBBox), bboxWidth(denomBBox));`	1806	`width = max(bboxWidth(numBBox), bboxWidth(denomBBox));`
1775	`NumDenomHShift(numBBox, denomBBox, &nHShift, &dHShift);`	1807	`NumDenomHShift(numBBox, denomBBox, &nHShift, &dHShift);`
1776	`NumDenomVShift(numBBox, denomBBox, &nVShift, &dVShift, mc, gc, dd);`	1808	`NumDenomVShift(numBBox, denomBBox, &nVShift, &dVShift, mc, gc, dd);`
1777		1809
1778	`mc->CurrentX = savedX;`	1810	`mc->CurrentX = savedX;`
1779	`mc->CurrentY = savedY;`	1811	`mc->CurrentY = savedY;`
1780	`SetNumStyle(style, mc, gc);`	1812	`SetNumStyle(style, mc, gc);`
1781	`numBBox = RenderOffsetElement(numerator, nHShift, nVShift, draw, mc, gc, dd);`	1813	`numBBox = RenderOffsetElement(numerator, nHShift, nVShift, draw, mc,`
-		1814	`gc, dd);`
1782		1815
1783	`mc->CurrentX = savedX;`	1816	`mc->CurrentX = savedX;`
1784	`mc->CurrentY = savedY;`	1817	`mc->CurrentY = savedY;`
1785	`SetDenomStyle(style, mc, gc);`	1818	`SetDenomStyle(style, mc, gc);`
1786	`denomBBox = RenderOffsetElement(denominator, dHShift, -dVShift, draw, mc, gc, dd);`	1819	`denomBBox = RenderOffsetElement(denominator, dHShift, -dVShift, draw,`
-		1820	`mc, gc, dd);`
1787		1821
1788	`SetStyle(style, mc, gc);`	1822	`SetStyle(style, mc, gc);`
1789		1823
1790	`if (draw) {`	1824	`if (draw) {`
1791	`if (rule) {`	1825	`if (rule) {`
Line 1856...	Line 1890...
1856	`{`	1890	`{`
1857	`return NameAtom(expr) &&`	1891	`return NameAtom(expr) &&`
1858	`(NameMatch(expr, "over") \|\| NameMatch(expr, "frac"));`	1892	`(NameMatch(expr, "over") \|\| NameMatch(expr, "frac"));`
1859	`}`	1893	`}`
1860		1894
1861	`static BBOX RenderOver(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1895	`static BBOX RenderOver(SEXP expr, int draw, mathContext *mc,`
-		1896	`R_GE_gcontext gc, GEDevDesc dd)`
1862	`{`	1897	`{`
1863	`return RenderFraction(expr, 1, draw, mc, gc, dd);`	1898	`return RenderFraction(expr, 1, draw, mc, gc, dd);`
1864	`}`	1899	`}`
1865		1900
1866	`static int UnderlAtom(SEXP expr)`	1901	`static int UnderlAtom(SEXP expr)`
1867	`{`	1902	`{`
1868	`return NameAtom(expr) && NameMatch(expr, "underline");`	1903	`return NameAtom(expr) && NameMatch(expr, "underline");`
1869	`}`	1904	`}`
1870		1905
1871	`static BBOX RenderUnderl(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1906	`static BBOX RenderUnderl(SEXP expr, int draw, mathContext *mc,`
-		1907	`R_GE_gcontext gc, GEDevDesc dd)`
1872	`{`	1908	`{`
1873	`return RenderUnderline(expr, draw, mc, gc, dd);`	1909	`return RenderUnderline(expr, draw, mc, gc, dd);`
1874	`}`	1910	`}`
1875		1911
1876		1912
1877	`static int AtopAtom(SEXP expr)`	1913	`static int AtopAtom(SEXP expr)`
1878	`{`	1914	`{`
1879	`return NameAtom(expr) && NameMatch(expr, "atop");`	1915	`return NameAtom(expr) && NameMatch(expr, "atop");`
1880	`}`	1916	`}`
1881		1917
1882	`static BBOX RenderAtop(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1918	`static BBOX RenderAtop(SEXP expr, int draw, mathContext *mc,`
-		1919	`R_GE_gcontext gc, GEDevDesc dd)`
1883	`{`	1920	`{`
1884	`return RenderFraction(expr, 0, draw, mc, gc, dd);`	1921	`return RenderFraction(expr, 0, draw, mc, gc, dd);`
1885	`}`	1922	`}`
1886		1923
1887	`/*----------------------------------------------------------------------`	1924	`/*----------------------------------------------------------------------`
Line 1932...	Line 1969...
1932	`if (code == 0)`	1969	`if (code == 0)`
1933	`errorcall(expr, "invalid group delimiter");`	1970	`errorcall(expr, "invalid group delimiter");`
1934	`return code;`	1971	`return code;`
1935	`}`	1972	`}`
1936		1973
1937	`static BBOX RenderDelimiter(int delim, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1974	`static BBOX RenderDelimiter(int delim, int draw, mathContext *mc,`
-		1975	`R_GE_gcontext gc, GEDevDesc dd)`
1938	`{`	1976	`{`
1939	`BBOX bbox;`	1977	`BBOX bbox;`
1940	`double savecex = gc->cex;`	1978	`double savecex = gc->cex;`
1941	`gc->cex = DelimSymbolMag * gc->cex;`	1979	`gc->cex = DelimSymbolMag * gc->cex;`
1942	`bbox = RenderSymbolChar(delim, draw, mc, gc, dd);`	1980	`bbox = RenderSymbolChar(delim, draw, mc, gc, dd);`
Line 1947...	Line 1985...
1947	`static int GroupAtom(SEXP expr)`	1985	`static int GroupAtom(SEXP expr)`
1948	`{`	1986	`{`
1949	`return NameAtom(expr) && NameMatch(expr, "group");`	1987	`return NameAtom(expr) && NameMatch(expr, "group");`
1950	`}`	1988	`}`
1951		1989
1952	`static BBOX RenderGroup(SEXP expr, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	1990	`static BBOX RenderGroup(SEXP expr, int draw, mathContext *mc,`
-		1991	`R_GE_gcontext gc, GEDevDesc dd)`
1953	`{`	1992	`{`
1954	`double cexSaved = gc->cex;`	1993	`double cexSaved = gc->cex;`
1955	`BBOX bbox;`	1994	`BBOX bbox;`
1956	`int code;`	1995	`int code;`
1957	`if (length(expr) != 4)`	1996	`if (length(expr) != 4)`
Line 1983...	Line 2022...
1983	`static int BGroupAtom(SEXP expr)`	2022	`static int BGroupAtom(SEXP expr)`
1984	`{`	2023	`{`
1985	`return NameAtom(expr) && NameMatch(expr, "bgroup");`	2024	`return NameAtom(expr) && NameMatch(expr, "bgroup");`
1986	`}`	2025	`}`
1987		2026
1988	`static BBOX RenderDelim(int which, double dist, int draw, mathContext mc, R_GE_gcontext gc, GEDevDesc *dd)`	2027	`static BBOX RenderDelim(int which, double dist, int draw, mathContext *mc,`
-		2028	`R_GE_gcontext gc, GEDevDesc dd)`
1989	`{`	2029	`{`
1990	`double savedX = mc->CurrentX;`	2030	`double savedX = mc->CurrentX;`
1991	`double savedY = mc->CurrentY;`	2031	`double savedY = mc->CurrentY;`
1992	`FontType prev = SetFont(SymbolFont, gc);`	2032	`FontType prev = SetFont(SymbolFont, gc);`
1993	`BBOX ansBBox, topBBox, botBBox, extBBox, midBBox;`	2033	`BBOX ansBBox, topBBox, botBBox, extBBox, midBBox;`
Line 1996...	Line 2036...
1996	`double topShift, botShift, extShift, midShift;`	2036	`double topShift, botShift, extShift, midShift;`
1997	`double ytop, ybot, extHeight, delta;`	2037	`double ytop, ybot, extHeight, delta;`
1998	`double axisHeight = TeX(sigma22, gc, dd);`	2038	`double axisHeight = TeX(sigma22, gc, dd);`
1999		2039
2000	`switch(which) {`	2040	`switch(which) {`
2001	`case '.':`	2041	`case '.':`
2002	`SetFont(prev, gc);`	2042	`SetFont(prev, gc);`
2003	`return NullBBox();`	2043	`return NullBBox();`
2004	`break;`	2044	`break;`
2005	`case '\|':`	2045	`case '\|':`
2006	`case 2:`	2046	`case 2:`
Line 2076...	Line 2116...
2076	`+ (bboxHeight(botBBox) + bboxDepth(botBBox));`	2116	`+ (bboxHeight(botBBox) + bboxDepth(botBBox));`
2077	`n = ceil((ytop - ybot) / (0.99 * extHeight));`	2117	`n = ceil((ytop - ybot) / (0.99 * extHeight));`
2078	`if (n > 0) {`	2118	`if (n > 0) {`
2079	`delta = (ytop - ybot) / n;`	2119	`delta = (ytop - ybot) / n;`
2080	`for (i = 0; i < n; i++) {`	2120	`for (i = 0; i < n; i++) {`
-		2121	`PMoveTo(savedX, savedY + ybot +`

The R Project SVN R

(root)/trunk/src/main/plotmath.c @ 34412 – Rev 32380 → 32392