/*
 *  R : A Computer Langage for Statistical Data Analysis
 *  Copyright (C) 1995, 1996, 1997 Robert Gentleman and Ross Ihaka
 *
 *  This source code module:
 *  Copyright (C) 1997 Paul Murrell and Ross Ihaka
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  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., 675 Mass Ave, Cambridge, MA 02139, USA.
 */

#include "Mathlib.h"
#include "Graphics.h"
#include "Defn.h"
#ifdef max
#undef max
#endif
#ifdef Unix

		/* return maximum of two doubles */

static double max(double x, double y)
{
	if (x > y) return x;
	else return y;
}

		/* determine match between symbol name and string */

static int symbolMatch(SEXP expr, char *aString)
{
	return !strcmp(CHAR(PRINTNAME(expr)), aString);
}

		/* code to determine the ascii code corresponding */
		/* to an element of a mathematical expression */

static int hatAscii()
{
	return 94;
}

static int tildeAscii()
{
	return 126;
}

static int accentAscii(SEXP expr)
{
	int result = 0;

	if (symbolMatch(expr, "hat"))
		result = hatAscii();
	else if (symbolMatch(expr, "tilde"))
		result = tildeAscii();

	return result;
}

static int operatorAscii(SEXP expr)
{
	int result = 0;

	if (symbolMatch(expr, "sum"))
		result = 229;
	else if (symbolMatch(expr, "integral"))
		result = 242;
	else if (symbolMatch(expr, "product"))
		result = 213;

	return result;
}

static int integralAscii(int section)
{
  if (section == 1)
    return 243;
  else if (section == 2)
    return 244;
  else 
    return 245;
}

static int groupOpenAscii()
{
	return 40;
}

static int groupCloseAscii()
{
	return 41;
}

static int commaAscii()
{
	return 44;
}

static int spaceAscii()
{
	return 32;
}

static int radicalAscii()
{
	return 214;
}

static int radicalExAscii()
{
	return 96;
}

static struct {
	char *name;
	int code;
} GreekTable[] = {

	"Alpha", 65,
	"Beta", 66,
	"Chi", 67,
	"Delta", 68,
	"Epsilon", 69,
	"Phi", 70,
	"Gamma", 71,
	"Eta", 72,
	"Iota", 73,
	"Phi1", 74,
	"Kappa", 75,
	"Lambda", 76,
	"Mu", 77,
	"Nu", 78,
	"Omicron", 79,
	"Pi", 80,
	"Theta", 81,
	"Rho", 82,
	"Sigma", 83,
	"Tau", 84,
	"Upsilon", 85,
	"sigma1", 86,
	"Omega", 87,
	"Xi", 88,
	"Psi", 89,
	"Zeta", 90,

	"alpha", 97,
	"beta", 98,
	"chi", 99,
	"delta", 100,
	"epsilon", 101,
	"phi", 102,
	"gamma", 103,
	"eta", 104,
	"iota", 105,
	"phi1", 106,
	"kappa", 107,
	"lambda", 108,
	"mu", 109,
	"nu", 110,
	"omicron", 111,
	"pi", 112,
	"theta", 113,
	"rho", 114,
	"sigma", 115,
	"tau", 116,
	"upsilon", 117,
	"omega1", 118,
	"omega", 119,
	"xi", 120,
	"psi", 121,
	"zeta", 122,

	NULL, 0,
};

static int greekAscii(SEXP expr)
{
	int i;

	for (i = 0; GreekTable[i].code; i++)
		if (symbolMatch(expr, GreekTable[i].name))
			return GreekTable[i].code;
	return 0;
}

static int relAscii() { return 61; }

	/* initialisation code for mathematical notation */

static double ratioScale = 0.8;
static double scriptScale = 0.65;
static int ratioDepth = 0;
static int metricUnit = 3;

static SEXP plusSymbol;
static SEXP minusSymbol;
static SEXP timesSymbol;
static SEXP divideSymbol;
static SEXP equalSymbol;
static SEXP superSymbol;
static SEXP subSymbol;
static SEXP groupSymbol;

static void initFormulaSymbols()
{
	plusSymbol = install("+");
	minusSymbol = install("-");
	timesSymbol = install("*");
	divideSymbol = install("/");
	equalSymbol = install("==");
	superSymbol = install("^");
	subSymbol = install("[");
	groupSymbol = install("(");
}

	/* code to determine the nature of an expression */

static int formulaExpression(SEXP expr)
{
	return (TYPEOF(expr) == LANGSXP);
}

static int symbolAtom(SEXP expr)
{
	return (TYPEOF(expr) == SYMSXP);
}

static int numberAtom(SEXP expr)
{
	return (TYPEOF(expr) == REALSXP) ||
	    (TYPEOF(expr) == INTSXP) ||
	    (TYPEOF(expr) == CPLXSXP);
}

static int stringAtom(SEXP expr)
{
	return (TYPEOF(expr) == STRSXP);
}

static int binAtom(SEXP expr)
{
	int result = symbolAtom(expr) &&
	((expr == plusSymbol) ||
	 (expr == minusSymbol) ||
	 (expr == timesSymbol) ||
	 (expr == divideSymbol));
	return result;
}

static int relAtom(SEXP expr)
{
	return symbolAtom(expr) &&
	    (expr == equalSymbol);
}

static int multiplicationOperator(SEXP expr)
{
	return binAtom(expr) &&
	    (expr == timesSymbol);
}

static int superAtom(SEXP expr)
{
	return symbolAtom(expr) &&
	    (expr == superSymbol);
}

static int subAtom(SEXP expr)
{
	return symbolAtom(expr) &&
	    (expr == subSymbol);
}

static int hatAtom(SEXP expr)
{
	return symbolMatch(expr, "hat");
}

static int barAtom(SEXP expr)
{
	return symbolMatch(expr, "bar");
}

static int accentAtom(SEXP expr)
{
	return symbolAtom(expr) &&
	    (hatAtom(expr) || barAtom(expr) ||
	     symbolMatch(expr, "tilde"));
}

static int fractionAtom(SEXP expr)
{
	return symbolAtom(expr) &&
	    symbolMatch(expr, "over");
}

static int groupAtom(SEXP expr)
{
	return symbolAtom(expr) && (expr == groupSymbol);
}

static int operatorAtom(SEXP expr)
{
	return symbolAtom(expr) &&
	    (symbolMatch(expr, "sum") ||
	     symbolMatch(expr, "integral") ||
	     symbolMatch(expr, "product"));
}

static int integralOperator(SEXP expr)
{
  return symbolAtom(expr) && symbolMatch(expr, "integral");
}

static int radicalAtom(SEXP expr)
{
	return symbolAtom(expr) &&
	    (symbolMatch(expr, "root") || 
	     symbolMatch(expr, "sqrt"));
}

static int absAtom(SEXP expr)
{
	return symbolAtom(expr) && symbolMatch(expr, "abs");
}

static int curlyAtom(SEXP expr)
{
	return symbolAtom(expr) && symbolMatch(expr, "{");
}

static int boldAtom(SEXP expr)
{
	return symbolAtom(expr) && symbolMatch(expr, "bold");
}

static int italicAtom(SEXP expr)
{
	return symbolAtom(expr) && symbolMatch(expr, "italic");
}

static int plainAtom(SEXP expr)
{
	return symbolAtom(expr) && symbolMatch(expr, "plain");
}

static int boldItalicAtom(SEXP expr)
{
	return symbolAtom(expr) && symbolMatch(expr, "bolditalic");
}

static int italicExpression(SEXP expr)
{
	return formulaExpression(expr) &&
	       (italicAtom(CAR(expr)) || boldItalicAtom(CAR(expr)));
}

static int nonItalicExpression(SEXP expr)
{
	return formulaExpression(expr) &&
	       (boldAtom(CAR(expr)) || plainAtom(CAR(expr)));
}

static int concatenateAtom(SEXP expr)
{
	return symbolAtom(expr) && symbolMatch(expr, "paste");
}

static int greekSymbol(SEXP expr)
{
	int i;
	if (symbolAtom(expr)) {
		for (i = 0; GreekTable[i].code; i++)
			if (symbolMatch(expr, GreekTable[i].name))
				return 1;
	}
	return 0;
}

		/* code to determine a font from the */
		/* nature of the expression */

static int currentFont = 3;

static int getFont() { return currentFont; }

static void setFont(font) { currentFont = font; }

static void boldFont() { setFont(2); }
static void italicFont() { setFont(3); }
static void plainFont() { setFont(1); }
static void boldItalicFont() { setFont(4); }
  
static int isItalic() { return (getFont() == 3 || getFont() == 4); }
  
static int atomFontFace(SEXP expr)
{
	int fontFace = 1;
	if (symbolAtom(expr)) {
		if (greekSymbol(expr) ||
		    binAtom(expr) ||
		    relAtom(expr) ||
		    groupAtom(expr) ||
		    operatorAtom(expr) ||
		    radicalAtom(expr))
			fontFace = 5;
		else
#ifdef OLD
			fontFace = 3;
#else
			fontFace = getFont();
#endif
	}
	return fontFace;
}

	/* a forward declaration */
static double fontHeight();

	/* some forward declarations */

typedef struct {
	double height;
	double depth;
	double width;
} BBOX;

static double bboxHeight(BBOX bbox)
{
	return bbox.height;
}
static double bboxDepth(BBOX bbox)
{
	return bbox.depth;
}
static double bboxWidth(BBOX bbox)
{
	return bbox.width;
}
static BBOX asciiBBox(int ascii);
static BBOX elementBBox(SEXP expr);
static void drawElement(SEXP expr);


	/* code to determine superscript offsets, etc ... */

	/* these "twiddle factors" are given as  */
	/* proportions of the current font height */
	/* NOTE that metric information is obtained */
	/* in INCHES so that the information will */
	/* be useful for rotated math.text */


static float SuperDrop = 0.3;
static float Superscript = 0.3;
static float SubDrop = 0.1;
static float Subscript = -0.3;
static float LineWidth = 0.05;

static float CustomAccentGap = 0.2;
static float CustomHatHeight = 0.3;
static float CustomRadicalWidth = 0.6;
static float CustomRadicalSpace = 0.1;
static float CustomRadicalGap = 0.2;
static float AbsSpace = 0.2;
static float OperatorSpace[] = { 0.1, 0.15, 0.2, 0.6, 0.1 };

static double fontHeight()
{
	double height, depth, width;
	GMetricInfo(0, &height, &depth, &width, metricUnit);
	return height + depth;
}

static double xHeight()
{
	int x = 'x';
	double xheight, depth, width;
	GMetricInfo(x, &xheight, &depth, &width, metricUnit);
	return xheight;
}

static double axisHeight()
{
	int plus = '+';
	double plusHeight, depth, width;
	GMetricInfo(plus, &plusHeight, &depth, &width, metricUnit);
	return 0.5 * plusHeight;
}

static double superscriptDrop()
{
	return SuperDrop * fontHeight();
}
static double subscriptDrop()
{
	return SubDrop * fontHeight();
}
static double superscript()
{
	return Superscript * fontHeight();
}
static double subscript()
{
	return Subscript * fontHeight();
}
static double lineWidth()
{
	return LineWidth * fontHeight();
}
static double numeratorShift()
{
	return axisHeight() + 3 * lineWidth();
}
static double denominatorShift()
{
	return axisHeight() - 3 * lineWidth() - xHeight();
}
static double radicalDrop()
{
	return 1.25 * lineWidth();
}
static double customAccentGap()
{
	return CustomAccentGap * fontHeight();
}
static double customHatHeight()
{
	return CustomHatHeight * fontHeight();
}
static double customRadicalWidth()
{
	return CustomRadicalWidth * fontHeight();
}
static double customRadicalSpace()
{
	return CustomRadicalSpace * fontHeight();
}
static double customRadicalGap()
{
	return CustomRadicalGap * fontHeight();
}
static double absSpace()
{
	return AbsSpace * fontHeight();
}
static double operatorSpace(int i)
{
  return OperatorSpace[i] * fontHeight();
}


	/* should only be called when font=5 (symbol) */

static double radicalExWidth()
{
	int radicalEx = 96;
	double height, depth, REWidth;
	GMetricInfo(radicalEx, &height, &depth, &REWidth, metricUnit);
	return REWidth;
}

static double superscriptShift(SEXP body, SEXP sup)
{
	BBOX bodyBBox = elementBBox(body);
	BBOX superscriptBBox;
	float cexSaved = GP->cex;
	double temp1 = bboxHeight(bodyBBox) - superscriptDrop();
	double temp2 = superscript();
	double temp3;

	GP->cex = GP->cex * scriptScale;
	superscriptBBox = elementBBox(sup);
	GP->cex = cexSaved;
	temp3 = bboxDepth(superscriptBBox) + 0.25 * xHeight();

	return max(temp1, max(temp2, temp3));
}

static double subscriptShift(SEXP body, SEXP sub, int subOnly)
{
	BBOX bodyBBox = elementBBox(body);
	BBOX subscriptBBox;
	float cexSaved = GP->cex;
	double temp1 = bboxDepth(bodyBBox) + subscriptDrop();
	double temp2 = subscript();
	double temp3;

	GP->cex = GP->cex * scriptScale;
	subscriptBBox = elementBBox(sub);
	GP->cex = cexSaved;
	temp3 = bboxHeight(subscriptBBox) - (4 * xHeight() / 5);

	if (subOnly)
		return max(temp1, max(temp2, temp3));
	else
		return max(temp1, temp2);
}

static void supsubShift(SEXP body, SEXP sup, SEXP sub,
			double *supShift, double *subShift)
{
	BBOX superscriptBBox, subscriptBBox;
	float cexSaved = GP->cex;
	double temp1, temp2;

	GP->cex = GP->cex * scriptScale;
	superscriptBBox = elementBBox(sup);
	subscriptBBox = elementBBox(sub);
	GP->cex = cexSaved;
	*supShift = superscriptShift(body, sup);
	*subShift = subscriptShift(body, sub, 0);

	temp1 = (*supShift - bboxDepth(superscriptBBox)) -
	    (bboxHeight(subscriptBBox) - *subShift);
	if (temp1 < (4 * lineWidth()))
		*subShift = bboxHeight(subscriptBBox) -
		    *supShift +
		    bboxDepth(superscriptBBox) +
		    (4 * lineWidth());

	temp2 = (4 * xHeight() / 5) -
	    (*supShift - bboxDepth(superscriptBBox));
	if (temp2 > 0) {
		*supShift = *supShift + temp2;
		*subShift = *subShift - temp2;
	}
}

static double accentVShift(SEXP body)
{
	double temp = xHeight();
	double bodyHeight = bboxHeight(elementBBox(body));

	if (bodyHeight > temp)
		return bodyHeight - temp;
	else
		return 0;
}

static double accentHShift(SEXP body, SEXP accent)
{
	return (bboxWidth(elementBBox(body)) -
		bboxWidth(elementBBox(accent))) / 2;
}

static double numeratorVShift(SEXP num)
{
	BBOX numBBox;
	float cexSaved = GP->cex;
	double theShift, theClearance, minClearance;

	GP->cex = GP->cex * scriptScale;
	numBBox = elementBBox(num);
	GP->cex = cexSaved;

	theShift = numeratorShift();
	theClearance = numeratorShift() - bboxDepth(numBBox) -
	    (axisHeight() + 0.5 * lineWidth());
	minClearance = 3 * lineWidth();

	if (theClearance < minClearance)
		theShift += minClearance - theClearance;

	return theShift;
}

/* RATIO */
static double denominatorVShift(SEXP denom)
{
	BBOX denomBBox;
	float cexSaved = GP->cex;
	double theShift, theClearance, minClearance;

#ifdef OLD
	GP->cex = GP->cex * scriptScale;
#else
	GP->cex = GP->cex * ratioScale;
#endif
	denomBBox = elementBBox(denom);
#ifdef OLD
	GP->cex = cexSaved;
#else
	GP->cex = cexSaved;
#endif

	theShift = denominatorShift();
	theClearance = axisHeight() - 0.5 * lineWidth() -
	    (bboxHeight(denomBBox) - denominatorShift());
	minClearance = 3 * lineWidth();

	if (theClearance < minClearance)
		theShift += minClearance - theClearance;

	return theShift;
}

/* RATIO */
static double fractionWidth(SEXP num, SEXP denom)
{
	BBOX numBBox;
	BBOX denomBBox;
	float cexSaved = GP->cex;
	double temp1, temp2;

#ifdef OLD
	GP->cex = GP->cex * scriptScale;
#else
	GP->cex = GP->cex * ratioScale;
#endif
	numBBox = elementBBox(num);
	denomBBox = elementBBox(denom);
#ifdef OLD
	GP->cex = cexSaved;
#else
	GP->cex = cexSaved;
#endif
	temp1 = bboxWidth(numBBox);
	temp2 = bboxWidth(denomBBox);

	return max(temp1, temp2);
}

/* RATIO */
static void numdenomHShift(SEXP num, SEXP denom,
			   double *numShift, double *denomShift)
{
	BBOX numBBox;
	BBOX denomBBox;
	float cexSaved = GP->cex;
	double temp1, temp2;

#ifdef OLD
	GP->cex = GP->cex * scriptScale;
#else
	GP->cex = GP->cex * ratioScale;
#endif
	numBBox = elementBBox(num);
	denomBBox = elementBBox(denom);
#ifdef OLD
	GP->cex = cexSaved;
#else
	GP->cex = cexSaved;
#endif
	temp1 = bboxWidth(numBBox);
	temp2 = bboxWidth(denomBBox);

	if (temp1 > temp2) {
		*numShift = 0;
		*denomShift = (temp1 - temp2) / 2;
	}
	else {
		*numShift = (temp2 - temp1) / 2;
		*denomShift = 0;
	}
}

static int normalRadical(SEXP body)
{
	BBOX bodyBBox = elementBBox(body);
	BBOX radicalBBox = asciiBBox(radicalAscii());

	return ((bboxHeight(bodyBBox) + radicalDrop())
		<= bboxHeight(radicalBBox)) &&
	    (bboxDepth(bodyBBox) <= bboxDepth(radicalBBox));
}

static double radicalVShift(SEXP body)
{
	BBOX bodyBBox = elementBBox(body);
	return bboxHeight(bodyBBox) + radicalDrop();
}


static BBOX theOperatorBBox(SEXP operator);

static BBOX operatorLimitBBox(SEXP operator);

static double operatorLowerShift(SEXP operator, SEXP lower)
{
  BBOX opBBox = theOperatorBBox(operator);
  BBOX lowerBBox;
  double lowerHeight;
  double spacing2 = operatorSpace(1);
  double spacing4 = operatorSpace(3);

  lowerBBox = operatorLimitBBox(lower);
  lowerHeight = bboxHeight(lowerBBox);
  if (spacing2 > (spacing4 - lowerHeight))
    return bboxDepth(opBBox) + spacing2 + lowerHeight;
  else
    return bboxDepth(opBBox) + spacing4;
}

static double operatorUpperShift(SEXP operator, SEXP upper)
{
  BBOX opBBox = theOperatorBBox(operator);
  BBOX upperBBox;
  double upperDepth;
  double spacing1 = operatorSpace(0);
  double spacing3 = operatorSpace(2);

  upperBBox = operatorLimitBBox(upper);
  upperDepth = bboxDepth(upperBBox);
  if (spacing1 > (spacing3 - upperDepth))
    return bboxHeight(opBBox) + spacing1 + upperDepth;
  else
    return bboxHeight(opBBox) + spacing3;
}

static double operatorLowerHShift(SEXP operator, SEXP lower)
{
  BBOX opBBox = theOperatorBBox(operator);
  BBOX lowerBBox;
  double maxWidth = bboxWidth(opBBox);

  lowerBBox = operatorLimitBBox(lower);
  if (bboxWidth(lowerBBox) < maxWidth)
    return (maxWidth - bboxWidth(lowerBBox))/2;
  else
    return 0;
}

static double operatorHShift(SEXP operator, SEXP lower)
{
  BBOX opBBox = theOperatorBBox(operator);
  BBOX lowerBBox;
  double maxWidth = bboxWidth(opBBox);

  lowerBBox = operatorLimitBBox(lower);
  if (bboxWidth(lowerBBox) > maxWidth)
    return (bboxWidth(lowerBBox) - maxWidth)/2;
  else
    return 0;
}

static double operatorLowerHShiftAll(SEXP operator, SEXP lower, SEXP upper)
{
  BBOX opBBox = theOperatorBBox(operator);
  BBOX lowerBBox, upperBBox;
  double maxWidth = bboxWidth(opBBox);

  lowerBBox = operatorLimitBBox(lower);
  upperBBox = operatorLimitBBox(upper);
  maxWidth = max(maxWidth, max(bboxWidth(lowerBBox), bboxWidth(upperBBox)));

  if (bboxWidth(lowerBBox) < maxWidth)
    return (maxWidth - bboxWidth(lowerBBox))/2;
  else
    return 0;
}

static double operatorUpperHShiftAll(SEXP operator, SEXP lower, SEXP upper)
{
  BBOX opBBox = theOperatorBBox(operator);
  BBOX lowerBBox, upperBBox;
  double maxWidth = bboxWidth(opBBox);

  lowerBBox = operatorLimitBBox(lower);
  upperBBox = operatorLimitBBox(upper);
  maxWidth = max(maxWidth, max(bboxWidth(lowerBBox), bboxWidth(upperBBox)));

  if (bboxWidth(upperBBox) < maxWidth)
    return (maxWidth - bboxWidth(upperBBox))/2;
  else
    return 0;
}

static double operatorHShiftAll(SEXP operator, SEXP lower, SEXP upper)
{
  BBOX opBBox = theOperatorBBox(operator);
  BBOX lowerBBox, upperBBox;
  double maxWidth = bboxWidth(opBBox);

  lowerBBox = operatorLimitBBox(lower);
  upperBBox = operatorLimitBBox(upper);
  maxWidth = max(maxWidth, max(bboxWidth(lowerBBox), bboxWidth(upperBBox)));

  if (bboxWidth(opBBox) < maxWidth)
    return (maxWidth - bboxWidth(opBBox))/2;
  else
    return 0;
}

	/* code to generate bounding boxes and draw formulae */

/* Bounding box basics */

static BBOX makeBBox(double height, double depth, double width)
{
	BBOX bbox;
	bbox.height = height;
	bbox.depth = depth;
	bbox.width = width;
	return bbox;
}

static BBOX nullBBox()
{
	return makeBBox(0.0, 0.0, 0.0);
}

static BBOX makeBBoxFromChar(int chr)
{
	double height, depth, width;
	GMetricInfo(chr, &height, &depth, &width, metricUnit);
	return makeBBox(height, depth, width);
}

static BBOX shiftBBox(BBOX bbox, double shiftV)
{
	return makeBBox(bboxHeight(bbox) + shiftV,
			bboxDepth(bbox) - shiftV,
			bboxWidth(bbox));
}

static BBOX combineBBoxes(BBOX bbox1, BBOX bbox2)
{
	return makeBBox(max(bboxHeight(bbox1), bboxHeight(bbox2)),
			max(bboxDepth(bbox1), bboxDepth(bbox2)),
			bboxWidth(bbox1) + bboxWidth(bbox2));
}

static BBOX combineAlignedBBoxes(BBOX bbox1, BBOX bbox2)
{
	return makeBBox(max(bboxHeight(bbox1), bboxHeight(bbox2)),
			max(bboxDepth(bbox1), bboxDepth(bbox2)),
			max(bboxWidth(bbox1), bboxWidth(bbox2)));
}

/* Drawing basics */

static double referenceX;
static double referenceY;
static double currentX;
static double currentY;
static double currentAngle;
static double cosAngle;
static double sinAngle;

		/* 
		   // convert currentX and currentY from inches and 0 angle
		   // to figure units and currentAngle
		 */
static double convertedX()
{
	double rotatedX = referenceX +
	(currentX - referenceX) * cosAngle -
	(currentY - referenceY) * sinAngle;
	return xInchtoFig(rotatedX);
}

static double convertedY()
{
	double rotatedY = referenceY +
	(currentY - referenceY) * cosAngle +
	(currentX - referenceX) * sinAngle;
	return yInchtoFig(rotatedY);
}

static void moveAcross(double xamount)
{
	currentX += xamount;
}

static void moveUp(double yamount)
{
	currentY += yamount;
}

static void moveTo(double x, double y)
{
	currentX = x;
	currentY = y;
}

/* code for ascii atoms */

	/* NOTE that i assume that all symbols which have */
	/* been converted to ascii are in the symbol font */

static BBOX asciiBBox(int ascii)
{
	if ((ascii == hatAscii()) || (ascii == tildeAscii()))
		GP->font = 1;
	else
		GP->font = 5;
	return makeBBoxFromChar(ascii);
}

static void drawAscii(int ascii)
{
	char asciiStr[2];

	if ((ascii == hatAscii()) || (ascii == tildeAscii()))
		GP->font = 1;
	else
		GP->font = 5;
	asciiStr[0] = ascii;
	asciiStr[1] = '\0';
	GText(convertedX(), convertedY(), asciiStr, 0.0, 0.0, currentAngle);
	moveAcross(GStrWidth(asciiStr, metricUnit));
}

/* code for character atoms */

static BBOX charBBox(char *str, SEXP expr)
{
	BBOX resultBBox = nullBBox();
	int i;

	GP->font = atomFontFace(expr);
	for (i = 0; i < strlen(str); i++)
		resultBBox = combineBBoxes(resultBBox, makeBBoxFromChar(str[i]));

	return resultBBox;
}

static void drawChar(char *str, SEXP expr)
{
	GP->font = atomFontFace(expr);
	GText(convertedX(), convertedY(), str, 0.0, 0.0, currentAngle);
	moveAcross(GStrWidth(str, metricUnit));
}

/* code for symbol atoms */

static BBOX symbolBBox(SEXP expr)
{
	if (greekSymbol(expr))
		return asciiBBox(greekAscii(expr));
	else
		return charBBox(CHAR(PRINTNAME(expr)), expr);
}

static void drawSymbol(SEXP expr)
{
	if (greekSymbol(expr))
		drawAscii(greekAscii(expr));
	else
		drawChar(CHAR(PRINTNAME(expr)), expr);
}

/* code for numeric atoms */

static BBOX numberBBox(SEXP expr)
{
	return charBBox(CHAR(asChar(expr)), expr);
}

static void drawNumber(SEXP expr)
{
	drawChar(CHAR(asChar(expr)), expr);
}

/* code for string atoms */

static BBOX stringBBox(SEXP expr)
{
	return charBBox(CHAR(STRING(expr)[0]), expr);
}

static void drawString(SEXP expr)
{
	drawChar(CHAR(STRING(expr)[0]), expr);
}

/* code for atoms */

static BBOX atomBBox(SEXP expr)
{
	if (symbolAtom(expr))
		return symbolBBox(expr);
	else if (numberAtom(expr))
		return numberBBox(expr);
	else if (stringAtom(expr))
		return stringBBox(expr);
}

static void drawAtom(SEXP expr)
{
	if (symbolAtom(expr))
		drawSymbol(expr);
	else if (numberAtom(expr))
		drawNumber(expr);
	else if (stringAtom(expr))
		drawString(expr);
}

/* code for italic corrections */

static double half_pi = 1.57079632679489661922;

static double italicCorrection(SEXP expr)
{
  BBOX exprBBox = elementBBox(expr);
  return bboxHeight(exprBBox) * tan(half_pi / 6);
}

	/* correction within expression checks for current font italic */

static BBOX correctionWithinBBox(SEXP expr)
{
  if (isItalic() && !nonItalicExpression(expr))
    return makeBBox(0, 0, italicCorrection(expr));
  else
    return nullBBox();
}

static void drawCorrectionWithin(SEXP expr)
{
  if (isItalic() && !nonItalicExpression(expr))
    moveAcross(italicCorrection(expr));
}    

	/* correction between expressions checks current font and font */
	/* of each expression */

static BBOX correctionBetweenBBox(SEXP expr1, SEXP expr2)
{
  if (((isItalic() && !nonItalicExpression(expr1)) ||
       italicExpression(expr1)) &&
      ((!isItalic() && !italicExpression(expr2)) ||
       nonItalicExpression(expr2)))
    return makeBBox(0, 0, italicCorrection(expr1));
  else
    return nullBBox();
}

static void drawCorrectionBetween(SEXP expr1, SEXP expr2)
{
  if (((isItalic() && !nonItalicExpression(expr1)) ||
       italicExpression(expr1)) &&
      ((!isItalic() && !italicExpression(expr2)) ||
       nonItalicExpression(expr2)))
    moveAcross(italicCorrection(expr1));
}

/* code for gaps */

static int cexGap = 1;

static void setGapCEX()
{
  cexGap = GP->cex;
}

static BBOX gapBBox(double gap)
{
  double cexSaved = GP->cex;
  BBOX theBBox;

  GP->cex = cexGap;
  theBBox = makeBBox(0, 0, gap * fontHeight());
  GP->cex = cexSaved;

  return theBBox;
}

static BBOX smallgapBBox(double gap)
{
  double cexSaved = GP->cex;
  BBOX theBBox;

  GP->cex = cexGap;
  theBBox = makeBBox(0, 0, 0.5 * gap * fontHeight());
  GP->cex = cexSaved;

  return theBBox;
}

static void drawGap(double gap)
{
  double cexSaved = GP->cex;

  GP->cex = cexGap;
  moveAcross(gap * fontHeight());
  GP->cex = cexSaved;
}

static void drawSmallGap(double gap)
{
  double cexSaved = GP->cex;

  GP->cex = cexGap;
  moveAcross(0.5 * gap * fontHeight());
  GP->cex = cexSaved;
}

/* code for binary operator (+, -, *, /) expressions */

/* NOTE that gaps are specified as proportions of the current font height */

static double binGapBefore(SEXP beforeOperand)
{
  return 0.2;
}

static double binGapBetween(SEXP operand1, SEXP operand2)
{
    return 0;
}

static double binGapAfter(SEXP afterOperand)
{
    return 0.2;
}

static BBOX binBBox(SEXP expr)
{
	SEXP operator, operand1, operand2;
	BBOX middleBBox;

	operator = CAR(expr);
	operand1 = CADR(expr);
        setGapCEX();
	if(length(expr) == 3) {
		operand2 = CADDR(expr);
		if (multiplicationOperator(operator))
			middleBBox = 
			  correctionBetweenBBox(operand1, operand2);
		else 
			middleBBox = 
                          combineBBoxes(
                            gapBBox(binGapBefore(operand1)),
			    combineBBoxes(atomBBox(operator),
					  gapBBox(binGapAfter(operand2))));

		return combineBBoxes(elementBBox(operand1),
				     combineBBoxes(middleBBox,
						   elementBBox(operand2)));
	}
	else if(length(expr) == 2) {
		middleBBox = combineBBoxes(atomBBox(operator),
				   smallgapBBox(binGapAfter(operand1)));
		return combineBBoxes(middleBBox, elementBBox(operand1));
	}
	else error("invalid formula\n");
}

static void drawBin(SEXP expr)
{
	SEXP operator, operand1, operand2;

	operator = CAR(expr);
	operand1 = CADR(expr);
	setGapCEX();
	if(length(expr) == 3) {
		operand2 = CADDR(expr);
		drawElement(operand1);
		if (multiplicationOperator(operator)) 
		  drawGap(binGapBetween(operand1, operand2));
		else {
			drawGap(binGapBefore(operand1));
			drawAtom(operator);
			drawGap(binGapAfter(operand2));
		}
		drawElement(operand2);
	}
	else {
		drawAtom(operator);
		drawSmallGap(binGapAfter(operand1));
		drawElement(operand1);
	}
}

/* code for superscript and subscript expressions */

static BBOX supsubBBox(SEXP body, SEXP superscript, SEXP subscript);

static BBOX superscriptBBox(SEXP superscript)
{
	BBOX result;
	float cexSaved = GP->cex;

	GP->cex = GP->cex * scriptScale;
	result = elementBBox(superscript);
	GP->cex = cexSaved;

	return result;
}

static BBOX supBBox(SEXP expr)
{
	BBOX result;
	SEXP body = CADR(expr);
	SEXP superscript = CADDR(expr);
	double supShift;
	int supsub = 0;

	if (formulaExpression(body))
		if (subAtom(CAR(body)))
			supsub = 1;

	if (supsub)
		return supsubBBox(CADR(body), superscript, (CADDR(body)));
	else
		return combineBBoxes(
			 elementBBox(body),
			 combineBBoxes(
			   correctionWithinBBox(body),
			   shiftBBox(superscriptBBox(superscript),
				     superscriptShift(body, superscript))));
}

static BBOX subscriptBBox(SEXP subscript)
{
	BBOX result;
	float cexSaved = GP->cex;

	GP->cex = GP->cex * scriptScale;
	result = elementBBox(subscript);
	GP->cex = cexSaved;

	return result;
}

static BBOX subBBox(SEXP expr)
{
	SEXP body = CADR(expr);
	SEXP subscript = CADDR(expr);

	return combineBBoxes(elementBBox(body),
		             shiftBBox(subscriptBBox(subscript),
			               subscriptShift(body, subscript, 1)));
}

static BBOX supsubBBox(SEXP body, SEXP superscript, SEXP subscript)
{
	double supShift, subShift;
	supsubShift(body, superscript, subscript, &supShift, &subShift);

	return combineBBoxes(
		 elementBBox(body),
		 combineAlignedBBoxes(
		   combineBBoxes(
		     correctionWithinBBox(body),
		     shiftBBox(superscriptBBox(superscript), supShift)),
		   shiftBBox(subscriptBBox(subscript), subShift)));
}

static void drawScriptElement(SEXP expr)
{
	float cexSaved = GP->cex;

	GP->cex = GP->cex * scriptScale;
	drawElement(expr);
	GP->cex = cexSaved;
}

static void drawSupSub(SEXP body, SEXP superscript, SEXP subscript);

static void drawSuper(SEXP expr)
{
	SEXP body = CADR(expr);
	SEXP superscript = CADDR(expr);
	double supShift = superscriptShift(body, superscript);
	int supsub = 0;

	if (formulaExpression(body))
		if (subAtom(CAR(body)))
			supsub = 1;

	if (supsub)
		drawSupSub(CADR(body), superscript, CADDR(body));
	else {
		drawElement(body);
		drawCorrectionWithin(body);
		moveUp(supShift);
		drawScriptElement(superscript);
		moveUp(-supShift);
	}
}

static void drawSub(SEXP expr)
{
	SEXP body = CADR(expr);
	SEXP subscript = CADDR(expr);
	double subShift = subscriptShift(body, subscript, 1);

	drawElement(body);
	moveUp(-subShift);
	drawScriptElement(subscript);
	moveUp(subShift);
}

static void drawSupSub(SEXP body, SEXP superscript, SEXP subscript)
{
	double supShift, subShift;
	double savedX, savedY;
	BBOX supBBox = elementBBox(superscript);
	BBOX subBBox = elementBBox(subscript);

	supsubShift(body, superscript, subscript, &supShift, &subShift);
	drawElement(body);
	savedX = currentX;
	savedY = currentY;
	drawCorrectionWithin(body);
	moveUp(supShift);
	drawScriptElement(superscript);
	moveTo(savedX, savedY);
	moveUp(-subShift);
	drawScriptElement(subscript);
	moveTo(savedX, savedY);
	moveAcross(max(bboxWidth(supBBox), bboxWidth(subBBox)));
}

/* code for accented expressions (hat, bar, ...) */

static BBOX hatBBox(SEXP body)
{
	BBOX bodyBBox = elementBBox(body);
	return combineAlignedBBoxes(bodyBBox,
				    makeBBox(bboxHeight(bodyBBox) +
					     customAccentGap() +
					     customHatHeight(), 0, 0));
}

static BBOX barBBox(SEXP body)
{
	BBOX bodyBBox = elementBBox(body);
	return combineAlignedBBoxes(bodyBBox,
				    makeBBox(bboxHeight(bodyBBox) +
					     customAccentGap(), 0, 0));
}

static BBOX accentBBox(SEXP expr)
{
	SEXP accent = CAR(expr);
	SEXP body = CADR(expr);

	if (hatAtom(accent))
		return hatBBox(body);
	else if (barAtom(accent))
		return barBBox(body);
	else
		return combineAlignedBBoxes(
						   elementBBox(body),
		combineBBoxes(makeBBox(accentHShift(body, accent), 0, 0),
			      shiftBBox(asciiBBox(accentAscii(accent)),
					accentVShift(body))));
}

static void drawHat(SEXP body)
{
	BBOX bodyBBox = elementBBox(body);
	double width = bboxWidth(bodyBBox);
	double savedX = currentX;
	double savedY = currentY;

	moveUp(bboxHeight(bodyBBox) + customAccentGap());
	GStartPath();
	GMoveTo(convertedX(), convertedY());
	moveUp(customHatHeight());
	moveAcross(width / 2);
	GLineTo(convertedX(), convertedY());
	moveUp(-customHatHeight());
	moveAcross(width / 2);
	GLineTo(convertedX(), convertedY());
	GEndPath();
	moveTo(savedX, savedY);
	drawElement(body);
}

static void drawBar(SEXP body)
{
	BBOX bodyBBox = elementBBox(body);
	double savedX = currentX;
	double savedY = currentY;

	moveUp(bboxHeight(bodyBBox) + customAccentGap());
	GStartPath();
	GMoveTo(convertedX(), convertedY());
	moveAcross(bboxWidth(bodyBBox));
	GLineTo(convertedX(), convertedY());
	GEndPath();
	moveTo(savedX, savedY);
	drawElement(body);
}

static void drawAccent(SEXP expr)
{
	SEXP accent = CAR(expr);
	SEXP body = CADR(expr);
	double savedX = currentX;
	double savedY = currentY;

	if (hatAtom(accent))
		drawHat(body);
	else if (barAtom(accent))
		drawBar(body);
	else {
		moveAcross(accentHShift(body, accent));
		moveUp(accentVShift(body));
		drawAscii(accentAscii(accent));
		moveTo(savedX, savedY);
		drawElement(body);
	}
}

/* code for fraction expressions (over) */

static BBOX fractionBBox(SEXP expr)
{
	SEXP numerator = CADR(expr);
	SEXP denominator = CADDR(expr);
	BBOX numBBox, denomBBox;
	double numHShift, denomHShift;
	float cexSaved = GP->cex;

#ifdef OLD
	GP->cex = GP->cex * scriptScale;
#else
	GP->cex = GP->cex * ratioScale;
#endif
	numBBox = elementBBox(numerator);
	denomBBox = elementBBox(denominator);
#ifdef OLD
	GP->cex = cexSaved;
#else
	GP->cex = cexSaved;
#endif
	numdenomHShift(numerator, denominator, &numHShift, &denomHShift);

	return combineAlignedBBoxes(
	     shiftBBox(combineBBoxes(makeBBox(numHShift, 0, 0), numBBox),
		       numeratorVShift(numerator)),
	 shiftBBox(combineBBoxes(makeBBox(denomHShift, 0, 0), denomBBox),
		   -denominatorVShift(denominator)));
}

static void drawRatioElement(SEXP expr)
{
	float cexSaved = GP->cex;
	GP->cex = GP->cex * ratioScale;
	drawElement(expr);
	GP->cex = cexSaved;
}

static void drawFraction(SEXP expr)
{
	SEXP numerator = CADR(expr);
	SEXP denominator = CADDR(expr);
	double savedX = currentX;
	double savedY = currentY;
	double fWidth = fractionWidth(numerator, denominator);
	double numHShift, denomHShift;

	numdenomHShift(numerator, denominator, &numHShift, &denomHShift);
	moveAcross(numHShift);
	moveUp(numeratorVShift(numerator));
#ifdef OLD
	drawScriptElement(numerator);
#else
	drawRatioElement(numerator);
#endif
	moveTo(savedX, savedY);
	moveUp(axisHeight());
	GStartPath();
	GMoveTo(convertedX(), convertedY());
	moveAcross(fWidth);
	GLineTo(convertedX(), convertedY());
	GEndPath();
	moveTo(savedX, savedY);
	moveAcross(denomHShift);
	moveUp(-denominatorVShift(denominator));
#ifdef OLD
	drawScriptElement(denominator);
#else
	drawRatioElement(denominator);
#endif
	moveTo(savedX + fWidth, savedY);
}

/* code for group expressions (expressions within parentheses) */

static BBOX groupBBox(SEXP expr)
{
	return combineBBoxes(
		 asciiBBox(groupOpenAscii()),
		 combineBBoxes(
		   elementBBox(CADR(expr)),
		   combineBBoxes(correctionWithinBBox(CADR(expr)),
				 asciiBBox(groupCloseAscii()))));
}

static void drawGroup(SEXP expr)
{
	drawAscii(groupOpenAscii());
	drawElement(CADR(expr));
	drawCorrectionWithin(CADR(expr));
	drawAscii(groupCloseAscii());
}

/* code for operator expressions (sum, product, integral) */

/* NOTE that gaps are specified as proportions of the current font height */

static double operatorGap(SEXP body)
{
    return 0.1;
}

static double integralTopShift() { return 0.5 * fontHeight(); }

static double integralBottomShift() { return -0.5 * fontHeight(); }

static BBOX theOperatorBBox(SEXP operator)
{
  if (integralOperator(operator))
    return combineAlignedBBoxes(
	     shiftBBox(asciiBBox(integralAscii(1)), integralTopShift()),
	     combineAlignedBBoxes(asciiBBox(integralAscii(2)),
				  shiftBBox(asciiBBox(integralAscii(3)),
					    integralBottomShift())));	
  else
    return asciiBBox(operatorAscii(operator));
}

static useRelGap = 1;
  
static BBOX operatorLimitBBox(SEXP limit)
{
  float cexSaved = GP->cex;
  BBOX limitBBox;

  GP->cex = GP->cex * scriptScale;
  useRelGap = 0;
  limitBBox = elementBBox(limit);
  useRelGap = 1;
  GP->cex = cexSaved;

  return limitBBox;
}

static BBOX operatorBBox(SEXP expr)
{
  SEXP operator = CAR(expr);
  SEXP body, lower, upper;
  BBOX opBBox = theOperatorBBox(operator);
  BBOX bodyBBox, lowerBBox, upperBBox;
  setGapCEX();

  if (length(expr) > 1) {
    body = CADR(expr);
    bodyBBox = combineBBoxes(opBBox,
                             combineBBoxes(gapBBox(operatorGap(body)), 
					   elementBBox(body)));
    
    if (length(expr) > 2) {
      lower = CADDR(expr);
      lowerBBox = operatorLimitBBox(lower);

      if (length(expr) > 3) {
	upper = CADDDR(expr);
	upperBBox = operatorLimitBBox(upper);

	return combineAlignedBBoxes(
		 combineBBoxes(
                   makeBBox(operatorHShiftAll(operator, lower, upper), 0, 0),
		   bodyBBox),
		 combineAlignedBBoxes(
                   shiftBBox(
                     combineBBoxes(
                       makeBBox(operatorUpperHShiftAll(operator, lower, upper),
				0, 0),
		       upperBBox),
		     operatorUpperShift(operator, upper)),
		   shiftBBox(
		     combineBBoxes(
		       makeBBox(operatorLowerHShiftAll(operator, lower, upper),
				0, 0),
		       lowerBBox),
		     operatorLowerShift(operator, lower))));
      }
      else
	return combineAlignedBBoxes(
                 combineBBoxes(
		   makeBBox(operatorHShift(operator, lower), 0, 0),
		   bodyBBox),
		 shiftBBox(
		   combineBBoxes(
		     makeBBox(operatorLowerHShift(operator, lower), 0, 0),
		     lowerBBox),
		   operatorLowerShift(operator, lower)));
    }
    else
      return bodyBBox;
  }
  else 
    error("Invalid Formula\n");
    
}

static void drawTheOperator(SEXP operator)
{
  if (integralOperator(operator)) {
    double savedX = currentX;
    double savedY = currentY;
    moveUp(integralTopShift());
    drawAscii(integralAscii(1));
    moveTo(savedX, savedY);
    moveUp(integralBottomShift());
    drawAscii(integralAscii(3));
    moveTo(savedX, savedY);
    drawAscii(integralAscii(2));
  }
  else
    drawAscii(operatorAscii(operator));
}
    
static void drawOperatorLimit(SEXP limit)
{
  useRelGap = 0;
  drawScriptElement(limit);
  useRelGap = 1;
}

static void drawOperator(SEXP expr)
{
  SEXP operator = CAR(expr);
  SEXP body = CADR(expr);
  SEXP lower, upper;
  double savedX = currentX;
  double savedY = currentY;

  setGapCEX();
  
  if (length(expr) > 2) {
    lower = CADDR(expr);

    if (length(expr) > 3) {
      upper = CADDDR(expr);
      moveUp(operatorUpperShift(operator, upper));
      moveAcross(operatorUpperHShiftAll(operator, lower, upper));
      drawOperatorLimit(upper);
      moveTo(savedX, savedY);
      moveUp(-operatorLowerShift(operator, lower));
      moveAcross(operatorLowerHShiftAll(operator, lower, upper));
      drawOperatorLimit(lower);
      moveTo(savedX, savedY);
      moveAcross(operatorHShiftAll(operator, lower, upper));
    }

    else{
      moveUp(-operatorLowerShift(operator, lower));
      moveAcross(operatorLowerHShift(operator, lower));
      drawOperatorLimit(lower);
      moveTo(savedX, savedY);
      moveAcross(operatorHShift(operator, lower));
    }
  }

  drawTheOperator(operator);
  drawGap(operatorGap(body));
  drawElement(body);
}

/* code for radical expressions (root) */

static BBOX customRadicalBBox(SEXP body)
{
	BBOX bodyBBox = elementBBox(body);
	return combineBBoxes(makeBBox(bboxHeight(bodyBBox) + customRadicalGap(),
				      0, customRadicalWidth()),
		      combineBBoxes(makeBBox(0, 0, customRadicalSpace()),
				    bodyBBox));
}

static BBOX radicalBBox(SEXP expr)
{
	SEXP body = CADR(expr);
	return customRadicalBBox(body);
}

static void drawCustomRadical(SEXP body)
{
	BBOX bodyBBox = elementBBox(body);
	double height = bboxHeight(bodyBBox);
	double depth = bboxDepth(bodyBBox);
	double width = bboxWidth(bodyBBox);
	double twiddleHeight = (height - depth) / 2;
	double savedX = currentX;
	double savedY = currentY;

	moveUp(0.8 * twiddleHeight);
	GStartPath();
	GMoveTo(convertedX(), convertedY());
	moveUp(0.2 * twiddleHeight);
	moveAcross(0.3 * customRadicalWidth());
	GLineTo(convertedX(), convertedY());
	moveUp(-(twiddleHeight + depth));
	moveAcross(0.3 * customRadicalWidth());
	GLineTo(convertedX(), convertedY());
	moveUp(depth + height + customRadicalGap());
	moveAcross(0.4 * customRadicalWidth());
	GLineTo(convertedX(), convertedY());
	moveAcross(customRadicalSpace() + width);
	GLineTo(convertedX(), convertedY());
	GEndPath();
	moveTo(savedX, savedY);
	moveAcross(customRadicalWidth() + customRadicalSpace());
	drawElement(body);
}

static void drawRadical(SEXP expr)
{
	SEXP body = CADR(expr);
	drawCustomRadical(body);
}

/* code for absolute expressions (abs) */

static BBOX absBBox(SEXP expr)
{
	SEXP body = CADR(expr);
	return combineBBoxes(makeBBox(0, 0, absSpace()),
			     combineBBoxes(elementBBox(body),
					   makeBBox(0, 0, absSpace())));
}

static void drawAbs(SEXP expr)
{
	SEXP body = CADR(expr);
	BBOX bodyBBox = elementBBox(expr);
	double height = bboxHeight(bodyBBox);
	double depth = bboxDepth(bodyBBox);
	double width = bboxWidth(bodyBBox);
	double savedX = currentX;
	double savedY = currentY;

	moveUp(-depth);
	GStartPath();
	GMoveTo(convertedX(), convertedY());
	moveUp(depth + height);
	GLineTo(convertedX(), convertedY());
	moveUp(-height);
	moveAcross(absSpace());
	drawElement(body);
	moveAcross(absSpace());
	moveUp(-depth);
	GMoveTo(convertedX(), convertedY());
	moveUp(depth + height);
	GLineTo(convertedX(), convertedY());
	GEndPath();
	moveUp(-height);
}

/* code for general expressions with no special meaning in */
/* mathematical notation syntax (e.g., f(x)) */

static BBOX expressionBBox(SEXP expr)
{
	int i;
	int numParams = length(expr) - 1;
	BBOX resultBBox = elementBBox(CAR(expr));
        SEXP lastTerm;

	lastTerm = CAR(expr);
	expr = CDR(expr);
	resultBBox = combineBBoxes(resultBBox, asciiBBox(groupOpenAscii()));
	for (i = 0; i < numParams; i++) {
		resultBBox = combineBBoxes(resultBBox, elementBBox(CAR(expr)));
	        lastTerm = CAR(expr);
		expr = CDR(expr);
		if (i < numParams - 1)
			resultBBox = combineBBoxes(resultBBox,
				   combineBBoxes(asciiBBox(commaAscii()),
					       asciiBBox(spaceAscii())));
	}
	return combineBBoxes(resultBBox, 
			     combineBBoxes(correctionWithinBBox(lastTerm),
					   asciiBBox(groupCloseAscii())));
}

static void drawExpression(SEXP expr)
{
	int i;
	int numParams = length(expr) - 1;
	SEXP lastTerm;

	drawElement(CAR(expr));
	lastTerm = CAR(expr);
	expr = CDR(expr);
	drawAscii(groupOpenAscii());
	for (i = 0; i < numParams; i++) {
		drawElement(CAR(expr));
	        lastTerm = CAR(expr);
		expr = CDR(expr);
		if (i < numParams - 1) {
			drawAscii(commaAscii());
			drawAscii(spaceAscii());
		}
	}
	drawCorrectionWithin(lastTerm);
	drawAscii(groupCloseAscii());
}

/* code for curly expressions (i.e., { ... } ) */

static BBOX curlyBBox(SEXP expr)
{
	return expressionBBox(CADR(expr));
}

static void drawFormula(SEXP);

static drawCurly(SEXP expr)
{
	drawFormula(CADR(expr));
}

/* code for relation expressions (i.e. ... == ...) */

static double relGap()
{
  if (useRelGap)
    return 0.3;
  else
    return 0.1;
}

static BBOX relBBox(SEXP expr)
{
  SEXP arg1 = CADR(expr);
  SEXP arg2 = CADDR(expr);

  return combineBBoxes(
	   elementBBox(arg1),
	   combineBBoxes(
			 gapBBox(relGap()),
			 combineBBoxes(
				       asciiBBox(relAscii()),
				       combineBBoxes(
						     gapBBox(relGap()),
						     elementBBox(arg2)))));
}

static void drawRel(SEXP expr)
{
  SEXP arg1 = CADR(expr);
  SEXP arg2 = CADDR(expr);

  drawElement(arg1);
  drawGap(relGap());
  drawAscii(relAscii());
  drawGap(relGap());
  drawElement(arg2);
}

/* code for bold expressions */

static BBOX boldBBox(SEXP expr)
{
  BBOX result;
  int savedFont = getFont();

  boldFont();
  result = elementBBox(CADR(expr));
  setFont(savedFont);

  return result;
}

static void drawBold(SEXP expr)
{
  int savedFont = getFont();

  boldFont();
  drawElement(CADR(expr));
  setFont(savedFont);
}

/* code for italic expressions */

static BBOX italicBBox(SEXP expr)
{
  BBOX result;
  SEXP body = CADR(expr);
  int savedFont = getFont();

  italicFont();
  result = elementBBox(body);
  setFont(savedFont);

  return result;
}

static void drawItalic(SEXP expr)
{
  SEXP body = CADR(expr);
  int savedFont = getFont();

  italicFont();
  drawElement(body);
  setFont(savedFont);
}

/* code for plain expressions */

static BBOX plainBBox(SEXP expr)
{
  BBOX result = nullBBox();
  SEXP body = CADR(expr);
  int savedFont = getFont();

  plainFont();
  result = elementBBox(CADR(expr));
  setFont(savedFont);

  return result;
}

static void drawPlain(SEXP expr)
{
  int savedFont = getFont();

  plainFont();
  drawElement(CADR(expr));
  setFont(savedFont);
}

/* code for bolditalic expressions */

static BBOX boldItalicBBox(SEXP expr)
{
  BBOX result;
  int savedFont = getFont();

  boldItalicFont();
  result = elementBBox(CADR(expr));
  setFont(savedFont);

  return result;
}

static void drawBoldItalic(SEXP expr)
{
  int savedFont = getFont();

  boldItalicFont();
  drawElement(CADR(expr));
  setFont(savedFont);
}

/* code for concatenating expressions c(...) */

static BBOX concatenateBBox(SEXP expr)
{
  SEXP args = CDR(expr);
  SEXP lastArg;
  int i;
  int numArgs = length(args);
  BBOX result = nullBBox();

  if (numArgs > 0)
  result = elementBBox(CAR(args));
  lastArg = CAR(args);
  args = CDR(args);

  for (i=1; i<numArgs; i++) {
    result = combineBBoxes(
	       result, 
	       combineBBoxes(correctionBetweenBBox(lastArg, CAR(args)),
			     elementBBox(CAR(args))));
    lastArg = CAR(args);
    args = CDR(args);
  }

  return result;
}

static void drawConcatenate(SEXP expr)
{
  SEXP args = CDR(expr);
  SEXP lastArg;
  int i;
  int numArgs = length(args);

  for (i=0; i<numArgs; i++) {
    if (i > 0)
      drawCorrectionBetween(lastArg, CAR(args));
    drawElement(CAR(args));
    lastArg = CAR(args);
    args = CDR(args);
  }
}

/* dispatching procedure which determines nature of expression */

static BBOX formulaBBox(SEXP expr)
{
	SEXP head = CAR(expr);

	if (binAtom(head))
		return binBBox(expr);
	else if (superAtom(head))
		return supBBox(expr);
	else if (subAtom(head))
		return subBBox(expr);
	else if (accentAtom(head))
		return accentBBox(expr);
	else if (fractionAtom(head))
		return fractionBBox(expr);
	else if (groupAtom(head))
		return groupBBox(expr);
	else if (operatorAtom(head))
		return operatorBBox(expr);
	else if (radicalAtom(head))
		return radicalBBox(expr);
	else if (absAtom(head))
		return absBBox(expr);
	else if (curlyAtom(head))
		return curlyBBox(expr);
	else if (relAtom(head))
	  return relBBox(expr);
	else if (boldAtom(head))
	  return boldBBox(expr);
	else if (italicAtom(head))
	  return italicBBox(expr);
	else if (plainAtom(head))
	  return plainBBox(expr);
	else if (boldItalicAtom(head))
	  return boldItalicBBox(expr);
	else if (concatenateAtom(head))
		return concatenateBBox(expr);
	else
		return expressionBBox(expr);
}

static void drawFormula(SEXP expr)
{
	SEXP head = CAR(expr);

	if (binAtom(head))
		drawBin(expr);
	else if (superAtom(head))
		drawSuper(expr);
	else if (subAtom(head))
		drawSub(expr);
	else if (accentAtom(head))
		drawAccent(expr);
	else if (fractionAtom(head))
		drawFraction(expr);
	else if (groupAtom(head))
		drawGroup(expr);
	else if (operatorAtom(head))
		drawOperator(expr);
	else if (radicalAtom(head))
		drawRadical(expr);
	else if (absAtom(head))
		drawAbs(expr);
	else if (curlyAtom(head))
		drawCurly(expr);
	else if (relAtom(head))
	  drawRel(expr);
	else if (boldAtom(head))
	  drawBold(expr);
	else if (italicAtom(head))
	  drawItalic(expr);
	else if (plainAtom(head))
	  drawPlain(expr);
	else if (boldItalicAtom(head))
	  drawBoldItalic(expr);
	else if (concatenateAtom(head))
		drawConcatenate(expr);

	/* if expression is not a special mathematical notation */
	/* function then just reconstruct expression */

	else
		drawExpression(expr);
}

/* top-level:  dispatch on whether atom (symbol, string, number, ...) */
/* or formula (some sort of expression) */

static BBOX elementBBox(SEXP expr)
{
	if (formulaExpression(expr))
		return formulaBBox(expr);
	else
		return atomBBox(expr);
}

static void drawElement(SEXP expr)
{
	if (formulaExpression(expr))
		drawFormula(expr);
	else
		drawAtom(expr);
}

		/* functions forming the API */

void GMathText(double x, double y, SEXP expr, double xc, double yc, double rot)
{
	BBOX expressionBBox;

	initFormulaSymbols();
	expressionBBox = elementBBox(expr);

	/* NOTE that x and y are in Figure coordinates */

	referenceX = xFigtoInch(x);
	referenceY = yFigtoInch(y);

	currentX = referenceX - xc * bboxWidth(expressionBBox);
	currentY = referenceY - yc * bboxHeight(expressionBBox);
	currentAngle = rot;
	cosAngle = cos(rot / 90 * half_pi);
	sinAngle = sin(rot / 90 * half_pi);
	drawElement(expr);
}


#define XINVFMAP(x) ((x - GP->fig2dev.ax)/GP->fig2dev.bx)
#define YINVFMAP(y) ((y - GP->fig2dev.ay)/GP->fig2dev.by)

void GMMathText(SEXP str, int side, double line, int outer, double at, int las)
{
	double a, x, y, xadj, yadj;

	if (outer) {
		switch (side) {
		case 1:
			x = at;
			y = yChartoNDC(GP->cexbase * GP->mex * (GP->oma[0] - line + 1));
			x = DP->inner2dev.ax + DP->inner2dev.bx * x;
			y = DP->ndc2dev.ay + DP->ndc2dev.by * y;
			a = 0.0;
			xadj = GP->adj;
			yadj = 0.0;
			break;
		case 2:
			x = xChartoNDC(GP->cexbase * GP->mex * (GP->oma[1] - line));
			y = at;
			x = DP->ndc2dev.ax + DP->ndc2dev.bx * x;
			y = DP->inner2dev.ay + DP->inner2dev.by * y;
			a = 90.0;
			xadj = GP->adj;
			yadj = 0.0;
			break;
		case 3:
			x = at;
			y = 1.0 - yChartoNDC(GP->cexbase * GP->mex * (GP->oma[2] - line));
			x = DP->inner2dev.ax + DP->inner2dev.bx * x;
			y = DP->ndc2dev.ay + DP->ndc2dev.by * y;
			a = 0.0;
			xadj = GP->adj;
			yadj = 0.0;
			break;
		case 4:
			x = 1.0 - xChartoNDC(GP->cexbase * GP->mex * (GP->oma[3] - line));
			y = at;
			x = DP->ndc2dev.ax + DP->ndc2dev.bx * x;
			y = DP->inner2dev.ay + DP->inner2dev.by * y;
			a = 90.0;
			xadj = GP->adj;
			yadj = 0.0;
			break;
		}
		x = XINVFMAP(x);
		y = YINVFMAP(y);
		GMathText(x, y, str, xadj, yadj, a);
	}
	else {
		switch (side) {
		case 1:
			if (las == 2) {
				y = GP->plt[2] - yInchtoFig(yChartoInch(GP->cexbase * GP->mex * (line + GP->yLineBias)));
				x = XMAP(at) - xInchtoFig(xChartoInch(GP->cexbase * GP->mex * GP->yLineBias));
				a = 90.0;
				xadj = 1.0;
				yadj = 0.5;
			}
			else {
				y = GP->plt[2] - yInchtoFig(yChartoInch(GP->cexbase * GP->mex * (line + 1 - GP->yLineBias)));
				x = XMAP(at);
				a = 0.0;
				xadj = GP->adj;
				yadj = 0.0;
			}
			break;
		case 2:
			if (las == 1 || las == 2) {
				x = GP->plt[0] - xInchtoFig(xChartoInch(GP->cexbase * GP->mex * (line + GP->yLineBias)));
				y = YMAP(at) + yInchtoFig(yChartoInch(GP->cexbase * GP->mex * GP->yLineBias));
				a = 0.0;
				xadj = 1.0;
				yadj = 0.5;
			}
			else {
				x = GP->plt[0] - xInchtoFig(xChartoInch(GP->cexbase * GP->mex * (line + GP->yLineBias)));
				y = YMAP(at);
				a = 90.0;
				xadj = GP->adj;
				yadj = 0.0;
			}
			break;
		case 3:
			if (las == 2) {
				y = GP->plt[3] + yInchtoFig(yChartoInch(GP->cexbase * GP->mex * (line + GP->yLineBias)));
				x = XMAP(at) - xInchtoFig(xChartoInch(GP->cexbase * GP->mex * GP->yLineBias));
				a = 90.0;
				xadj = 0.0;
				yadj = 0.5;
			}
			else {
				y = GP->plt[3] + yInchtoFig(yChartoInch(GP->cexbase * GP->mex * (line + GP->yLineBias)));
				x = XMAP(at);
				a = 0.0;
				xadj = GP->adj;
				yadj = 0.0;
			}
			break;
		case 4:
			if (las == 1 || las == 2) {
				x = GP->plt[1] + xInchtoFig(xChartoInch(GP->cexbase * GP->mex * (line + GP->yLineBias)));
				y = YMAP(at) + yInchtoFig(yChartoInch(GP->cexbase * GP->mex * GP->yLineBias));
				a = 0.0;
				xadj = 0.0;
				yadj = 0.5;
			}
			else {
				x = GP->plt[1] + xInchtoFig(xChartoInch(GP->cexbase * GP->mex * (line + 1 - GP->yLineBias)));
				y = YMAP(at);
				a = 90.0;
				xadj = GP->adj;
				yadj = 0.0;
			}
			break;
		}
		GMathText(x, y, str, xadj, yadj, a);
	}
}

#else

void GMMathText(SEXP str, int side, double line, int outer, double at, int las)
{
	error("Can't print math under Windows ... yet\n");
}

void GMathText(double x, double y, SEXP expr, double xc, double yc, double rot)
{
	error("Can't print math under Windows ... yet\n");
}
#endif