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

 #include <Graphics.h>
 /* The R graphics device */
+/* These are a bit unthreadable aren't they?
+ * Better to pass them all down, but that's a heck of a lot of
+ * changes to make to the function call argument lists!!
+ */
-static DevDesc *MathDevice;
+static GEDevDesc *MathDevice;
 static unsigned int BoxColor;
 static unsigned int TextColor;
+/* The value of cex passed into GEMathText
+ */
 static double BaseCex = 1;
+static double MathGamma;
+/* The value of font passed into GEMathText
+ * May be modified by plotmath code -- it is plotmath code's
+ * responsibility to save and restore temporary changes.
+ */
+static int MathFont;
+/* A temporary value of cex that may be modified by plotmath code.
+ */
+static double MathCex;
+static double MathPs;
-static GUnit MetricUnit = INCHES;
+static GEUnit MetricUnit = GE_INCHES;
 /* Font Definitions */
 typedef enum {
     PlainFont	   = 1,
 static double CurrentY;
 static double CurrentAngle;
 static double CosAngle;
 static double SinAngle;
 /* Convert CurrentX and CurrentY from */
 /* 0 angle to and CurrentAngle */
 static double ConvertedX()
+{
     double rotatedX = ReferenceX +
 	(CurrentX - ReferenceX) * CosAngle -
 	(CurrentY - ReferenceY) * SinAngle;
-    return rotatedX;
+    return toDeviceX(rotatedX, MetricUnit, MathDevice);
+}
 static double ConvertedY()
+{
     double rotatedY = ReferenceY +
 	(CurrentY - ReferenceY) * CosAngle +
 	(CurrentX - ReferenceX) * SinAngle;
-    return rotatedY;
+    return toDeviceY(rotatedY, MetricUnit, MathDevice);
+}
 static void PMoveAcross(double xamount)
+{
     CurrentX += xamount;
 #ifdef OLD
 static double FontHeight()
+{
     double height, depth, width;
+    GEMetricInfo(0,
+		MathFont, MathCex, MathPs,
-    GMetricInfo(0, &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
-    return height + depth;
+    return fromDeviceHeight(height + depth, MetricUnit, MathDevice);
+}
 #endif
 static double xHeight()
+{
     double height, depth, width;
+    GEMetricInfo('x',
+		MathFont, MathCex, MathPs,
-    GMetricInfo('x', &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
-    return height;
+    return fromDeviceHeight(height, MetricUnit, MathDevice);
+}
 static double XHeight()
+{
     double height, depth, width;
+    GEMetricInfo('X',
+		MathFont, MathCex, MathPs,
-    GMetricInfo('X', &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
-    return height;
+    return fromDeviceHeight(height, MetricUnit, MathDevice);
+}
 static double AxisHeight()
+{
     double height, depth, width;
+    GEMetricInfo('+',
+		MathFont, MathCex, MathPs,
-    GMetricInfo('+', &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
-    return 0.5 * height;
+    return fromDeviceHeight(0.5 * height, MetricUnit, MathDevice);
+}
 static double Quad()
+{
     double height, depth, width;
+    GEMetricInfo('M',
+		MathFont, MathCex, MathPs,
-    GMetricInfo('M', &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
-    return width;
+    return fromDeviceHeight(width, MetricUnit, MathDevice);
+}
 /* The height of digits */
 static double FigHeight()
+{
     double height, depth, width;
+    GEMetricInfo('0',
+		MathFont, MathCex, MathPs,
-    GMetricInfo('0', &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
-    return height;
+    return fromDeviceHeight(height, MetricUnit, MathDevice);
+}
 /* Depth of lower case descenders */
 static double DescDepth()
+{
     double height, depth, width;
+    GEMetricInfo('g',
+		MathFont, MathCex, MathPs,
-    GMetricInfo('g', &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
-    return depth;
+    return fromDeviceHeight(depth, MetricUnit, MathDevice);
+}
 #ifdef NOT_used_currently/*-- out 'def'	 (-Wall) --*/
 static double AscHeight()
+{
     double height, depth, width, save;
+    GEMetricInfo('d',
+		MathFont, MathCex, MathPs,
-    GMetricInfo('d', &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
     save = height;
+    GEMetricInfo('a',
+		MathFont, MathCex, MathPs,
-    GMetricInfo('a', &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
-    return save - height;
+    return fromDeviceHeight(save - height, MetricUnit, MathDevice);
+}
 #endif
 /* Thickness of rules */
 static double RuleThickness()
+{
 static double ThinSpace()
+{
     double height, depth, width;
     static double OneSixth = 0.16666666666666666666;
+    GEMetricInfo('M',
+		MathFont, MathCex, MathPs,
-    GMetricInfo('M', &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
-    return OneSixth * width;
+    return fromDeviceHeight(OneSixth * width, MetricUnit, MathDevice);
+}
 static double MediumSpace()
+{
     double height, depth, width;
     static double TwoNinths = 0.22222222222222222222;
+    GEMetricInfo('M',
+		MathFont, MathCex, MathPs,
-    GMetricInfo('M', &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
-    return TwoNinths * width;
+    return fromDeviceHeight(TwoNinths * width, MetricUnit, MathDevice);
+}
 static double ThickSpace()
+{
     double height, depth, width;
     static double FiveEighteenths = 0.27777777777777777777;
+    GEMetricInfo('M',
+		MathFont, MathCex, MathPs,
-    GMetricInfo('M', &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
-    return FiveEighteenths * width;
+    return fromDeviceHeight(FiveEighteenths * width, MetricUnit, MathDevice);
+}
 static double MuSpace()
+{
     double height, depth, width;
     static double OneEighteenth = 0.05555555555555555555;
+    GEMetricInfo('M',
+		MathFont, MathCex, MathPs,
-    GMetricInfo('M', &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
-    return OneEighteenth * width;
+    return fromDeviceHeight(OneEighteenth * width, MetricUnit, MathDevice);
+}
 /*
  *  Mathematics Layout Parameters
     switch (newstyle) {
     case STYLE_D:
     case STYLE_T:
     case STYLE_D1:
     case STYLE_T1:
-	Rf_gpptr(MathDevice)->cex = 1.0 * BaseCex;
+	MathCex = 1.0 * BaseCex;
 	break;
     case STYLE_S:
     case STYLE_S1:
-	Rf_gpptr(MathDevice)->cex = 0.7 * BaseCex;
+	MathCex = 0.7 * BaseCex;
 	break;
     case STYLE_SS:
     case STYLE_SS1:
-	Rf_gpptr(MathDevice)->cex = 0.5 * BaseCex;
+	MathCex = 0.5 * BaseCex;
 	break;
     default:
 	error("invalid math style encountered");
+    }
     CurrentStyle = newstyle;
     double xsaved = CurrentX;
     double ysaved = CurrentY;
     double x[5], y[5];
     CurrentX += xoffset;
     CurrentY += yoffset;
-    Rf_gpptr(MathDevice)->col = BoxColor;
     PMoveUp(-bboxDepth(bbox));
     x[4] = x[0] = ConvertedX();
     y[4] = y[0] = ConvertedY();
     PMoveAcross(bboxWidth(bbox));
     x[1] = ConvertedX();
     x[2] = ConvertedX();
     y[2] = ConvertedY();
     PMoveAcross(-bboxWidth(bbox));
     x[3] = ConvertedX();
     y[3] = ConvertedY();
-    GPolyline(5, x, y, INCHES, MathDevice);
+    GEPolyline(5, x, y, BoxColor, MathGamma, LTY_SOLID, 1, INCHES, MathDevice);
     PMoveTo(xsaved, ysaved);
-    Rf_gpptr(MathDevice)->col = TextColor;
     return bbox;
+}
 #endif
 typedef struct {
 #ifdef NOT_used_currently/*-- out 'def'	 (-Wall) --*/
 static FontType CurrentFont = 3;
 #endif
 static FontType GetFont()
+{
-    return Rf_gpptr(MathDevice)->font;
+    return MathFont;
+}
 static FontType SetFont(FontType font)
+{
-    FontType prevfont = Rf_gpptr(MathDevice)->font;
+    FontType prevfont = MathFont;
-    Rf_gpptr(MathDevice)->font = font;
+    MathFont = font;
     return prevfont;
+}
 static int UsingItalics()
+{
-    return (Rf_gpptr(MathDevice)->font == ItalicFont ||
+    return (MathFont == ItalicFont ||
-	    Rf_gpptr(MathDevice)->font == BoldItalicFont);
+	    MathFont == BoldItalicFont);
+}
 static BBOX GlyphBBox(int chr)
+{
     BBOX bbox;
     double height, depth, width;
+    GEMetricInfo(chr,
+		MathFont, MathCex, MathPs,
-    GMetricInfo(chr, &height, &depth, &width, MetricUnit, MathDevice);
+		&height, &depth, &width, MathDevice);
-    bboxHeight(bbox) = height;
+    bboxHeight(bbox) = fromDeviceHeight(height, MetricUnit, MathDevice);
-    bboxDepth(bbox)  = depth;
+    bboxDepth(bbox)  = fromDeviceHeight(depth, MetricUnit, MathDevice);
-    bboxWidth(bbox)  = width;
+    bboxWidth(bbox)  = fromDeviceHeight(width, MetricUnit, MathDevice);
     bboxItalic(bbox) = 0;
     bboxSimple(bbox) = 1;
     return bbox;
+}
 	prev = SetFont(SymbolFont);
     bbox = GlyphBBox(ascii);
     if (draw) {
 	asciiStr[0] = ascii;
 	asciiStr[1] = '\0';
-	GText(ConvertedX(), ConvertedY(), INCHES, asciiStr,
+	GEText(ConvertedX(), ConvertedY(), asciiStr,
-.0, 0.0, CurrentAngle, MathDevice);
+.0, 0.0, CurrentAngle,
+	      TextColor, MathGamma, MathFont, MathCex, MathPs,
+	      MathDevice);
 	PMoveAcross(bboxWidth(bbox));
+    }
     SetFont(prev);
     return bbox;
+}
 	    else
 		bboxItalic(glyphBBox) = 0;
 	    if (draw) {
 		chr[0] = *s;
 		PMoveAcross(lastItalicCorr);
-		GText(ConvertedX(), ConvertedY(), INCHES, chr,
+		GEText(ConvertedX(), ConvertedY(), chr,
-.0, 0.0, CurrentAngle, MathDevice);
+.0, 0.0, CurrentAngle,
+		      TextColor, MathGamma, MathFont, MathCex, MathPs,
+		      MathDevice);
 		PMoveAcross(bboxWidth(glyphBBox));
+	    }
 	    bboxWidth(resultBBox) += lastItalicCorr;
 	    resultBBox = CombineBBoxes(resultBBox, glyphBBox);
 	    lastItalicCorr = bboxItalic(glyphBBox);
     char asciiStr[2];
     bbox = GlyphBBox(ascii);
     if (draw) {
 	asciiStr[0] = ascii;
 	asciiStr[1] = '\0';
-	GText(ConvertedX(), ConvertedY(), INCHES, asciiStr,
+	GEText(ConvertedX(), ConvertedY(), asciiStr,
-.0, 0.0, CurrentAngle, MathDevice);
+.0, 0.0, CurrentAngle,
+	      TextColor, MathGamma, MathFont, MathCex, MathPs,
+	      MathDevice);
 	PMoveAcross(bboxWidth(bbox));
+    }
     return bbox;
+}
 	    glyphBBox = GlyphBBox(*s);
 	    resultBBox = CombineBBoxes(resultBBox, glyphBBox);
 	    s++;
+	}
 	if (draw) {
-	    GText(ConvertedX(), ConvertedY(), INCHES, str,
+	    GEText(ConvertedX(), ConvertedY(), str,
-.0, 0.0, CurrentAngle, MathDevice);
+.0, 0.0, CurrentAngle,
+		  TextColor, MathGamma, MathFont, MathCex, MathPs,
+		  MathDevice);
 	    PMoveAcross(bboxWidth(resultBBox));
+	}
 	if (UsingItalics())
 	    bboxItalic(resultBBox) = ItalicFactor * bboxHeight(glyphBBox);
 	else
     /* The Default Font Character */
     return RenderSymbolChar(S_SLASH, draw);
 #endif
 #ifdef SLASH1
     /* Symbol Magnify Version */
-    double savecex = Rf_gpptr(MathDevice)->cex;
+    double savecex = MathCex;
     BBOX bbox;
     double height1, height2;
     height1 = bboxHeight(RenderSymbolChar(S_SLASH, 0));
-    Rf_gpptr(MathDevice)->cex = 1.2 * Rf_gpptr(MathDevice)->cex;
+    MathCex = 1.2 * MathCex;
     height2 = bboxHeight(RenderSymbolChar(S_SLASH, 0));
     if (draw)
 	PMoveUp(- 0.5 * (height2 - height1));
     bbox = RenderSymbolChar(S_SLASH, draw);
     if (draw)
 	PMoveUp(0.5 * (height2 - height1));
-    Rf_gpptr(MathDevice)->cex = savecex;
+    MathCex = savecex;
     return bbox;
 #endif
 #ifdef SLASH2
     /* Line Drawing Version */
     double x[2], y[2];
 	PMoveAcross(width);
 	PMoveUp(depth + height);
 	x[1] = ConvertedX();
 	y[1] = ConvertedY();
 	PMoveUp(-height);
+	GEPolyline(2, x, y,
-	GPolyline(2, x, y, INCHES, MathDevice);
+		  TextColor, MathGamma, LTY_SOLID, 1, MathDevice);
 	PMoveAcross(0.5 * width);
+    }
     return MakeBBox(height, depth, 2 * width);
 #endif
 #ifdef SLASH3
 	    y[i + 1] = ConvertedY();
+	}
 	PMoveTo(baseX + totalwidth, baseY + hatHeight);
 	x[NTILDE + 2] = ConvertedX();
 	y[NTILDE + 2] = ConvertedY();
-	GPolyline(NTILDE + 3, x, y, INCHES, MathDevice);
+	GEPolyline(NTILDE + 3, x, y,
+		  TextColor, MathGamma, LTY_SOLID, 1, MathDevice);
 	PMoveTo(savedX + totalwidth, savedY);
+    }
     return MakeBBox(height + accentGap + hatHeight,
 		    bboxDepth(bbox), totalwidth);
+}
 	y[1] = ConvertedY();
 	PMoveAcross(0.5 * totalwidth);
 	PMoveUp(-hatHeight);
 	x[2] = ConvertedX();
 	y[2] = ConvertedY();
-	GPolyline(3, x, y, INCHES, MathDevice);
+	GEPolyline(3, x, y,
+		  TextColor, MathGamma, LTY_SOLID, 1, MathDevice);
 	PMoveTo(savedX + width, savedY);
+    }
     return EnlargeBBox(bbox, accentGap + hatHeight, 0, 0);
+}
 	x[0] = ConvertedX();
 	y[0] = ConvertedY();
 	PMoveAcross(width);
 	x[1] = ConvertedX();
 	y[1] = ConvertedY();
-	GPolyline(2, x, y, INCHES, MathDevice);
+	GEPolyline(2, x, y,
+		  TextColor, MathGamma, LTY_SOLID, 1, MathDevice);
 	PMoveTo(savedX + width, savedY);
+    }
     return EnlargeBBox(bbox, accentGap, 0, 0);
+}
 	    x[0] = ConvertedX();
 	    y[0] = ConvertedY();
 	    PMoveAcross(width);
 	    x[1] = ConvertedX();
 	    y[1] = ConvertedY();
-	    GPolyline(2, x, y, INCHES, MathDevice);
+	    GEPolyline(2, x, y,
+		  TextColor, MathGamma, LTY_SOLID, 1, MathDevice);
 	    PMoveUp(-AxisHeight());
+	}
 	PMoveTo(savedX + width, savedY);
+    }
     return CombineAlignedBBoxes(numBBox, denomBBox);
+}
 static BBOX RenderDelimiter(int delim, int draw)
+{
     BBOX bbox;
-    double savecex = Rf_gpptr(MathDevice)->cex;
+    double savecex = MathCex;
-    Rf_gpptr(MathDevice)->cex = DelimSymbolMag * Rf_gpptr(MathDevice)->cex;
+    MathCex = DelimSymbolMag * MathCex;
     bbox = RenderSymbolChar(delim, draw);
-    Rf_gpptr(MathDevice)->cex = savecex;
+    MathCex = savecex;
     return bbox;
+}
 static int GroupAtom(SEXP expr)
+{
     return NameAtom(expr) && NameMatch(expr, "group");
+}
 static BBOX RenderGroup(SEXP expr, int draw)
+{
-    double cexSaved = Rf_gpptr(MathDevice)->cex;
+    double cexSaved = MathCex;
     BBOX bbox;
     int code;
     if (length(expr) != 4)
 	errorcall(expr, "invalid group specification");
     bbox = NullBBox();
     code = DelimCode(expr, CADR(expr));
-    Rf_gpptr(MathDevice)->cex = DelimSymbolMag * Rf_gpptr(MathDevice)->cex;
+    MathCex = DelimSymbolMag * MathCex;
     if (code == 2) {
 	bbox = RenderSymbolChar('|', draw);
 	bbox = RenderSymbolChar('|', draw);
+    }
     else if (code != '.')
 	bbox = RenderSymbolChar(code, draw);
-    Rf_gpptr(MathDevice)->cex = cexSaved;
+    MathCex = cexSaved;
     bbox = CombineBBoxes(bbox, RenderElement(CADDR(expr), draw));
     bbox = RenderItalicCorr(bbox, draw);
     code = DelimCode(expr, CADDDR(expr));
-    Rf_gpptr(MathDevice)->cex = DelimSymbolMag * Rf_gpptr(MathDevice)->cex;
+    MathCex = DelimSymbolMag * MathCex;
     if (code == 2) {
 	bbox = CombineBBoxes(bbox, RenderSymbolChar('|', draw));
 	bbox = CombineBBoxes(bbox, RenderSymbolChar('|', draw));
+    }
     else if (code != '.')
 	bbox = CombineBBoxes(bbox, RenderSymbolChar(code, draw));
-    Rf_gpptr(MathDevice)->cex = cexSaved;
+    MathCex = cexSaved;
     return bbox;
+}
 static int BGroupAtom(SEXP expr)
+{
+}
 static BBOX RenderOpSymbol(SEXP op, int draw)
+{
     BBOX bbox;
-    double cexSaved = Rf_gpptr(MathDevice)->cex;
+    double cexSaved = MathCex;
     /*double savedX = CurrentX;*/
     /*double savedY = CurrentY;*/
     double shift;
     int display = (GetStyle() > STYLE_T);
     int opId = OpAtom(op);
     if (opId == S_SUM || opId == S_PRODUCT ||
 	opId == S_UNION || opId == S_INTERSECTION) {
 	if (display) {
-	    Rf_gpptr(MathDevice)->cex = OperatorSymbolMag * Rf_gpptr(MathDevice)->cex;
+	    MathCex = OperatorSymbolMag * MathCex;
 	    bbox = RenderSymbolChar(OpAtom(op), 0);
 	    shift = 0.5 * (bboxHeight(bbox) - bboxDepth(bbox)) - TeX(sigma22);
 	    if (draw) {
 		PMoveUp(-shift);
 		bbox = RenderSymbolChar(opId, 1);
 		PMoveUp(shift);
+	    }
-	    Rf_gpptr(MathDevice)->cex = cexSaved;
+	    MathCex = cexSaved;
 	    return ShiftBBox(bbox, -shift);
+	}
 	else return RenderSymbolChar(opId, draw);
+    }
     else {
 	x[3] = ConvertedX();
 	y[3] = ConvertedY();
 	PMoveAcross(radSpace + bboxWidth(bodyBBox) + radTrail);
 	x[4] = ConvertedX();
 	y[4] = ConvertedY();
-	GPolyline(5, x, y, INCHES, MathDevice);
+	GEPolyline(5, x, y,
+		  TextColor, MathGamma, LTY_SOLID, 1, MathDevice);
 	PMoveTo(savedX, savedY);
+    }
     orderBBox = CombineAlignedBBoxes(orderBBox,
 				     RenderGap(leadWidth + radSpace, draw));
     SetPrimeStyle(style);
 	x[0] = ConvertedX();
 	y[0] = ConvertedY();
 	PMoveUp(depth + height);
 	x[1] = ConvertedX();
 	y[1] = ConvertedY();
-	GPolyline(2, x, y, INCHES, MathDevice);
+	GEPolyline(2, x, y,
+		  TextColor, MathGamma, LTY_SOLID, 1, MathDevice);
 	PMoveUp(-height);
+    }
     bbox = CombineBBoxes(bbox, RenderGap(MuSpace(), draw));
     bbox = CombineBBoxes(bbox, RenderElement(CADR(expr), draw));
     bbox = RenderItalicCorr(bbox, draw);
 	x[0] = ConvertedX();
 	y[0] = ConvertedY();
 	PMoveUp(depth + height);
 	x[1] = ConvertedX();
 	y[1] = ConvertedY();
-	GPolyline(2, x, y, INCHES, MathDevice);
+	GEPolyline(2, x, y,
+		  TextColor, MathGamma, LTY_SOLID, 1, MathDevice);
 	PMoveUp(-height);
+    }
     bbox = CombineBBoxes(bbox, RenderGap(MuSpace(), draw));
     return bbox;
+}
     CurrentY = savedY;
     return bbox;
+}
+/* Functions forming the R API */
 /* Calculate width of expression */
 /* BBOXes are in INCHES (see MetricUnit) */
-/* #ifdef'ed this function out to shut -Wall up */
-#ifdef OLD
-static
-void GExpressionBBox(SEXP expr, GUnit units, double *width,
+double GEExpressionWidth(SEXP expr,
-		     double *height, double *depth, DevDesc *dd)
+			 int font, double cex, double ps,
-{
-    BBOX bbox;
-    MathDevice = dd;
+			 GEDevDesc *dd)
-/* The following two lines don't look right to me, but I inserted them
-   because otherwise you get trouble if you calculate BBoxes without
-   plotting any math first... Similar problem in the next two functions
-	 --pd */
-    CurrentStyle = STYLE_D;
-    SetFont(PlainFont);
-    bbox = RenderElement(expr, 0);
-    *width  = bboxWidth(bbox);
-    *height  = bboxHeight(bbox);
-    *depth  = bboxDepth(bbox);
-    if (units != INCHES) {
-	*width = GConvertXUnits(*width, INCHES, units, dd);
-	*height = GConvertYUnits(*height, INCHES, units, dd);
-	*depth = GConvertYUnits(*depth, INCHES, units, dd);
-    }
-}
-#endif
-double GExpressionWidth(SEXP expr, GUnit units, DevDesc *dd)
+{
     BBOX bbox;
     double width;
     MathDevice = dd;
+    BaseCex = cex;
+    MathFont = font;
+    MathCex = cex;
+    MathPs = ps;
     CurrentStyle = STYLE_D;
     SetFont(PlainFont);
     bbox = RenderElement(expr, 0);
     width  = bboxWidth(bbox);
-    if (units == INCHES)
-	return width;
-    else
-	return GConvertXUnits(width, INCHES, units, dd);
+    return toDeviceWidth(width, GE_INCHES, dd);
+}
-double GExpressionHeight(SEXP expr, GUnit units, DevDesc *dd)
+double GEExpressionHeight(SEXP expr,
+			  int font, double cex, double ps,
+			  GEDevDesc *dd)
+{
     BBOX bbox;
     double height;
     MathDevice = dd;
+    BaseCex = cex;
+    MathFont = font;
+    MathCex = cex;
+    MathPs = ps;
     CurrentStyle = STYLE_D;
     SetFont(PlainFont);
     bbox = RenderElement(expr, 0);
     height = bboxHeight(bbox) + bboxDepth(bbox);
-    if (units == INCHES)
-	return height;
-    else
-	return GConvertYUnits(height, INCHES, units, dd);
+    return toDeviceHeight(height, GE_INCHES, dd);
+}
-/* Functions forming the R API */
-void GMathText(double x, double y, int coords, SEXP expr,
+void GEMathText(double x, double y, SEXP expr,
-	       double xc, double yc, double rot, DevDesc *dd)
+		double xc, double yc, double rot,
+		int col, double gamma, int font, double cex, double ps,
+		GEDevDesc *dd)
+{
     BBOX bbox;
 #ifdef BUG61
 #else
     /* IF font metric information is not available for device */
     /* then bail out */
     double ascent, descent, width;
+    GEMetricInfo(0,
+		font, cex, ps,
-    GMetricInfo(0, &ascent, &descent, &width, DEVICE, dd);
+		&ascent, &descent, &width, dd);
     if ((ascent==0) && (descent==0) && (width==0))
 	error("Metric information not yet available for this device");
 #endif
     MathDevice = dd;
-    BaseCex = Rf_gpptr(MathDevice)->cex;
+    BaseCex = cex;
     BoxColor = name2col("pink");
-    TextColor = Rf_gpptr(MathDevice)->col;
+    TextColor = col;
+    MathGamma = gamma;
+    MathFont = font;
+    MathCex = cex;
+    MathPs = ps;
     CurrentStyle = STYLE_D;
     SetFont(PlainFont);
     bbox = RenderElement(expr, 0);
-    ReferenceX = x;
+    ReferenceX = fromDeviceX(x, GE_INCHES, dd);
-    ReferenceY = y;
-    GConvert(&ReferenceX, &ReferenceY, coords, INCHES, dd);
+    ReferenceY = fromDeviceY(y, GE_INCHES, dd);
     if (R_FINITE(xc))
 	CurrentX = ReferenceX - xc * bboxWidth(bbox);
     else
 	/* Paul 11/2/02
 	 * If xc == NA then should centre horizontally.
     SinAngle = sin(rot);
     RenderElement(expr, 1);
 }/* 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)
+{
+    double width = GEExpressionWidth(expr,
+				     Rf_gpptr(dd)->font, Rf_gpptr(dd)->cex,
+				     Rf_gpptr(dd)->ps, (GEDevDesc*) dd);
+    if (units == DEVICE)
+	return width;
+    else
+	return GConvertXUnits(width, DEVICE, units, dd);
+}
+double GExpressionHeight(SEXP expr, GUnit units, DevDesc *dd)
+{
+    double height = GEExpressionHeight(expr,
+				       Rf_gpptr(dd)->font, Rf_gpptr(dd)->cex,
+				       Rf_gpptr(dd)->ps, (GEDevDesc*) dd);
+    if (units == DEVICE)
+	return height;
+    else
+	return GConvertYUnits(height, DEVICE, units, dd);
+}
 void GMMathText(SEXP str, int side, double line, int outer,
 		double at, int las, DevDesc *dd)
+{
     int coords = 0, subcoords;
     double xadj, yadj = 0, angle = 0;
     GMetricInfo(0, &ascent, &descent, &width, DEVICE, dd);
     if ((ascent==0) && (descent==0) && (width==0))
 	error("Metric information not yet available for this device");
 #endif
-    MathDevice = dd;
+    MathDevice = (GEDevDesc*) dd;
-    xadj = Rf_gpptr(MathDevice)->adj;
+    xadj = Rf_gpptr(dd)->adj;
     /* This is MOSTLY the same as the same section of GMtext
      * BUT it differs because it sets different values for yadj for
      * different situations.
      * Paul
 	    angle = 90;
 	    yadj = 0;
+	}
 	break;
+    }
+    GConvert(&at, &line, coords, DEVICE, dd);
-    GMathText(at, line, coords, str, xadj, yadj, angle, dd);
+    GEMathText(at, line, str, xadj, yadj, angle,
+	       Rf_gpptr(dd)->col, Rf_gpptr(dd)->gamma, Rf_gpptr(dd)->font,
+	       Rf_gpptr(dd)->cex, Rf_gpptr(dd)->ps, (GEDevDesc*) dd);
 }/* GMMathText */

The R Project SVN R

(root)/trunk/src/main/plotmath.c @ 28362 – Rev 19598 → 19875