DIRECTORY
BasicTime USING [GMT],
Imager USING [Box, ClipRectangle, ConstantColor, Context, DoSave, MaskBox, MaskStroke, MaskVector, PathProc, Rectangle, Scale2T, SetColor, SetFont, SetStrokeEnd, SetStrokeJoint, SetStrokeWidth, SetXY, ShowRope, TranslateT, VEC],
ImagerBackdoor USING [GetBounds, GetCP],
ImagerFont USING [Extents, Find, Font, FontBoundingBox, RopeBoundingBox, Scale],
IO USING [PutFR, real, rope, time],
Plot USING [Curves, PlotSpec, PlotSpecRec, RopeSequence, Vector],
PlotOps USING [BackgroundType, color, ColorMode, Handle, MaxStep, LineState, LineStateRec, LineStep, NColors, OutputType, StateSequence],
Real USING [FixI, RoundI, RoundLI],
RealFns USING [Log, Power, SqRt], 
Rope USING [Find, IsEmpty, ROPE, Substr], 
VFonts USING [EstablishFont],
ViewerClasses USING [PaintRectangle];

PlotViewerPaint: CEDAR PROGRAM
IMPORTS BasicTime, Imager, ImagerBackdoor, ImagerFont, IO, PlotOps, Real, RealFns, Rope, VFonts
EXPORTS PlotOps = {

OPEN Plot, PlotOps;

TextHeightFudge: REAL = 4.0;
TextWidthFudge: REAL = 4.0;
minLineWidth: REAL = 1.0;

t12b: ImagerFont.Font = VFonts.EstablishFont["TimesRoman", 12, TRUE]; -- bold
t12bp: ImagerFont.Font = ImagerFont.Scale[
ImagerFont.Find["Xerox/PressFonts/TimesRoman-mrr"], 13.0];
h8: ImagerFont.Font = VFonts.EstablishFont["Helvetica", 8];
h8p: ImagerFont.Font = ImagerFont.Scale[
ImagerFont.Find["Xerox/PressFonts/Helvetica-mrr"], 9.0];
textFont: PUBLIC ARRAY FontType OF ARRAY OutputType OF ImagerFont.Font = [[t12b, t12bp, t12bp], [h8, h8p, h8p]];
fontHeight: PUBLIC ARRAY FontType OF ARRAY OutputType OF REAL;

FontType: TYPE = {title, normal};

DrawMe: PUBLIC PROC [context: Imager.Context, handle: Handle, whatChanged: REF ANY, output: OutputType] = {
BoundsValid: PROC [box: Imager.Box] RETURNS [BOOL] = INLINE {
RETURN[box.xmax > box.xmin AND box.ymax > box.ymin];
}; -- BoundsValid

rect: Imager.Rectangle _ IF output = interpress THEN [0.0, -518.16, 670.56, 518.16]
ELSE ImagerBackdoor.GetBounds[context];
box: Imager.Box _ [rect.x, rect.y, rect.x + rect.w, rect.y + rect.h];
foreground: Imager.ConstantColor _ IF output # screen THEN color[15] ELSE
IF handle.background = black OR handle.background = darkGray THEN color[0]
ELSE color[15]; 

IF whatChanged = NIL OR ISTYPE[whatChanged, ViewerClasses.PaintRectangle] THEN {

background: Imager.ConstantColor _ IF output # screen THEN color[0] ELSE
SELECT handle.background FROM
gray => color[13], darkGray => color[14], black => color[15], ENDCASE => color[0];

width: REAL _ rect.w; 
height: REAL _ rect.h;

marginRatio: REAL = 0.05;
innerRatio: REAL = 0.9;
marginX: REAL _ width*marginRatio;
marginY: REAL _ height*marginRatio;

maxX: REAL _ box.xmax - marginX; 
maxY: REAL _ box.ymax - marginY; 
minX: REAL _ box.xmin + marginX; 
minY: REAL _ box.ymin + marginY;
innerWidth: REAL _ width * innerRatio;
innerHeight: REAL _ height * innerRatio;

tenthHeight: REAL _ innerHeight/10.0;
textLineHeight: REAL _ fontHeight[normal][output] + TextHeightFudge;
windowTooLow: BOOL _ tenthHeight < textLineHeight;
legendTop: REAL _ IF windowTooLow THEN minY ELSE minY + tenthHeight*1.8;
axesTop: REAL _ IF windowTooLow THEN maxY ELSE maxY - tenthHeight;

titleBox: Imager.Box _ [minX, axesTop, maxX, maxY];
axesBox: Imager.Box _ [minX, legendTop, maxX, axesTop];
legendBox: Imager.Box _ [minX, minY, maxX, legendTop]; 

IF output = screen THEN { -- clear the screen
context.SetColor[background]; 
context.MaskBox[box];
};

context.SetColor[foreground];
IF NOT windowTooLow THEN {
excl: INT _ handle.plotSpec.file.Find["!"];
pattern: Rope.ROPE = IF excl < 0 THEN handle.plotSpec.file ELSE handle.plotSpec.file.Substr[0, excl];
footNote: Rope.ROPE _ IO.PutFR["File: %g; time: %g.", IO.rope[pattern], IO.time[handle.plotSpec.time]];
DrawTitle[context, titleBox, handle.plotSpec.title, output]; 
DrawLegendFootnote[context, legendBox, handle.plotSpec.legendEntries,
footNote, output, handle.colorMode];
};

IF BoundsValid[handle.plotSpec.bounds] THEN {
c: Curves _ NIL;
[handle.curvesBox, handle.realBounds] _ DrawAxes[context, axesBox, handle.plotSpec.bounds, output];
context.ClipRectangle[
[handle.curvesBox.xmin,
handle.curvesBox.ymin,
handle.curvesBox.xmax - handle.curvesBox.xmin,
handle.curvesBox.ymax - handle.curvesBox.ymin]];
FOR l: Curves _ handle.curves, l.rest UNTIL l = NIL DO
c _ CONS[l.first, c];
ENDLOOP;
DrawCurves[context, handle, c, output];
};
}
ELSE IF ISTYPE[whatChanged, Curves] THEN { OPEN handle;
cv: Curves _ NARROW[whatChanged];
IF cv # NIL AND BoundsValid[handle.realBounds] THEN {
m0, m1: Vector;
m1 _ cv.first;
IF m1 = NIL OR cv.rest = NIL THEN RETURN;
m0 _ cv.rest.first;
IF m0 = NIL THEN RETURN;
IF m0.size = m1.size THEN {
tMin: REAL = realBounds.xmin;
tFactor: REAL = (curvesBox.xmax - curvesBox.xmin + 1)/(realBounds.xmax - tMin);
vMin: REAL = realBounds.ymin;
vFactor: REAL = (curvesBox.ymax - curvesBox.ymin + 1)/(realBounds.ymax - vMin);
t0: REAL = (m0[0] - tMin)*tFactor;
t1: REAL = (m1[0] - tMin)*tFactor;

context.ClipRectangle[
[handle.curvesBox.xmin,
handle.curvesBox.ymin,
handle.curvesBox.xmax - handle.curvesBox.xmin,
handle.curvesBox.ymax - handle.curvesBox.ymin]];
context.TranslateT[[curvesBox.xmin, curvesBox.ymin]];
context.SetStrokeEnd[round];
context.SetStrokeWidth[minLineWidth];
IF handle.colorMode = bw THEN {
context.SetColor[foreground];
FOR index: CARDINAL IN [1..m0.size) DO
ipath: CARDINAL _ index - 1;
DrawLineSeg[context,
[t0, (m0[index]-vMin)*vFactor], [t1, (m1[index]-vMin)*vFactor],
ipath MOD 12, handle.lineStates[ipath]];
ENDLOOP;
}
ELSE FOR index: CARDINAL IN [1..m0.size) DO
ipath: CARDINAL _ index - 1;
context.SetColor[color[(ipath MOD 12) + 1]];
context.MaskVector[
[t0, (m0[index]-vMin)*vFactor], [t1, (m1[index]-vMin)*vFactor]];
ENDLOOP;
};
};
};
}; -- DrawMe

DrawTitle: PROC [context: Imager.Context, box: Imager.Box, title: Rope.ROPE, output: OutputType] = {
xPos: REAL _ box.xmin + (box.xmax - box.xmin) / 2.0;
boxH: REAL _ box.ymax - box.ymin - fontHeight[normal][output];

IF title.IsEmpty[] THEN RETURN;
IF boxH >= fontHeight[title][output] THEN 
[] _ MyDrawText[context, title, xPos, box.ymax, center, top, title, output]
ELSE IF boxH >= fontHeight[normal][output] THEN
[] _ MyDrawText[context, title, xPos, box.ymax, center, top, normal, output];
}; -- DrawTitle

DrawAxes: PROC [context: Imager.Context, box, bounds: Imager.Box, output: OutputType]
RETURNS [innerBox, realBounds: Imager.Box] = {

Border: PROC = {
context.SetStrokeEnd[square];
context.SetStrokeJoint[round];
context.SetStrokeWidth[minLineWidth*2.0];
IF output = press THEN {
-- Press doesn't support MaskStroke.
context.MaskVector[[innerBox.xmin, innerBox.ymin], [innerBox.xmin, innerBox.ymax]];
context.MaskVector[[innerBox.xmin, innerBox.ymax], [innerBox.xmax, innerBox.ymax]];
context.MaskVector[[innerBox.xmax, innerBox.ymax], [innerBox.xmax, innerBox.ymin]];
context.MaskVector[[innerBox.xmax, innerBox.ymin], [innerBox.xmin, innerBox.ymin]];
}
ELSE {
borderPath: Imager.PathProc = {
moveTo[[innerBox.xmin, innerBox.ymin]];
lineTo[[innerBox.xmin, innerBox.ymax]];
lineTo[[innerBox.xmax, innerBox.ymax]];
lineTo[[innerBox.xmax, innerBox.ymin]];
};
context.MaskStroke[path: borderPath, closed: TRUE];
};
}; -- Border

HorizontalAxisLabels: PROC[context: Imager.Context, box:  Imager.Box,
min, max, scale, step: REAL] = {
tickLen:  REAL _ (box.ymax - box.ymin)/50.0;
tickCount: CARDINAL = Real.RoundI[(max - min)/step];
textTop: REAL _ box.ymin - TextHeightFudge;
tick: REAL;

FOR i: CARDINAL IN [0..tickCount] DO
tick _ step*scale*i;
[] _ MyDrawText[context,
IO.PutFR["%g", IO.real[step*i + min]],
box.xmin + tick, textTop,
center, top, normal, output];
IF i # 0 AND i # tickCount THEN {
xPos: REAL = box.xmin + tick;
yStart: REAL _ box.ymin;
yEnd: REAL _ box.ymin + tickLen;
Tick: Imager.PathProc = {moveTo[[xPos, yStart]]; lineTo[[xPos, yEnd]]};
proc: PROC = {context.MaskStroke[path: Tick, closed: FALSE]};
IF output = press THEN context.MaskVector[[xPos, yStart], [xPos, yEnd]]
ELSE context.DoSave[proc];
yStart _ box.ymax; yEnd _ box.ymax - tickLen; 
IF output = press THEN context.MaskVector[[xPos, yStart], [xPos, yEnd]]
ELSE context.DoSave[proc];
};
ENDLOOP;
}; -- HorizontalAxisLabels

VerticalAxisLabels: PROC[context: Imager.Context, box:  Imager.Box,
min, max, scale, step: REAL] = {
tickLen:  REAL _ (box.ymax - box.ymin)/50.0;
tickCount: CARDINAL = Real.RoundI[(max - min)/step];
textRight: REAL _ box.xmin - TextWidthFudge;
tick: REAL;

FOR i: CARDINAL IN [0..tickCount] DO
tick _ step*scale*i;
[] _ MyDrawText[context,
IO.PutFR["%g", IO.real[step*i + min]],
textRight, box.ymin + tick,
right, center, normal, output];
IF i # 0 AND i # tickCount THEN {
yPos: REAL = box.ymin + tick;
xStart: REAL _ box.xmin;
xEnd: REAL _ box.xmin + tickLen;
Tick: Imager.PathProc = {moveTo[[xStart, yPos]]; lineTo[[xEnd, yPos]]};
proc: PROC = {context.MaskStroke[path: Tick, closed: FALSE]};
IF output = press THEN context.MaskVector[[xStart, yPos], [xEnd, yPos]]
ELSE context.DoSave[proc];
xStart _ box.xmax; xEnd _ box.xmax - tickLen; 
IF output = press THEN context.MaskVector[[xStart, yPos], [xEnd, yPos]]
ELSE context.DoSave[proc];
};
ENDLOOP;
}; -- VerticalAxisLabels

xSize: REAL = box.xmax-box.xmin;
ySize: REAL = box.ymax-box.ymin;
xStep, yStep:  REAL;  -- between ticks
xScale, yScale: REAL;
nLabelsX, nLabelsY: CARDINAL;
hLabelWidth, hLabelHeight, vLabelWidth, vLabelHeight, tLabelWidth, tLabelHeight: REAL;
inBoxW, inBoxH: REAL;

[tLabelWidth, tLabelHeight] _ GetRopeSize[IO.PutFR["%g", IO.real[bounds.xmin]],
normal, output];
[hLabelWidth, hLabelHeight] _ GetRopeSize[IO.PutFR["%g", IO.real[bounds.xmax]],
normal, output];
hLabelWidth _ MAX[tLabelWidth, hLabelWidth];
hLabelHeight _ MAX[tLabelHeight, hLabelHeight];

[tLabelWidth, tLabelHeight] _ GetRopeSize[IO.PutFR["%g", IO.real[bounds.ymin]],
normal, output];
[vLabelWidth, vLabelHeight] _ GetRopeSize[IO.PutFR["%g", IO.real[bounds.ymax]],
normal, output];
vLabelWidth _ MAX[tLabelWidth, vLabelWidth];
vLabelHeight _ MAX[tLabelHeight, vLabelHeight];

innerBox _ [
xmin: box.xmin + vLabelWidth + TextWidthFudge,
ymin: box.ymin + hLabelHeight + TextHeightFudge*2,
xmax: box.xmax,
ymax: box.ymax];
IF innerBox.xmin > innerBox.xmax THEN innerBox.xmin _ box.xmin;
IF innerBox.ymin > innerBox.ymax THEN innerBox.ymin _ box.ymin;

inBoxW _ innerBox.xmax - innerBox.xmin;
inBoxH _ innerBox.ymax - innerBox.ymin;

context.DoSave[Border];

nLabelsX _ MAX[1, MIN[10, Real.RoundI[inBoxW/hLabelWidth*5/8]]];
nLabelsY _ MAX[1, MIN[10, Real.RoundI[inBoxH/vLabelHeight*5/8]]];

[realBounds.xmin, realBounds.xmax, xStep, xScale] _ ScaleAxis[
bounds.xmin, bounds.xmax, inBoxW, nLabelsX];
[realBounds.ymin, realBounds.ymax, yStep, yScale] _ ScaleAxis[
bounds.ymin, bounds.ymax, inBoxH, nLabelsY];

context.SetStrokeEnd[butt];
context.SetStrokeWidth[minLineWidth];
HorizontalAxisLabels[context, innerBox, realBounds.xmin, realBounds.xmax, xScale, xStep];
VerticalAxisLabels[context, innerBox, realBounds.ymin, realBounds.ymax, yScale, yStep];
}; -- DrawAxes

GetRopeSize: PROC [text: Rope.ROPE, fontType: FontType _ normal, output: OutputType _ screen] RETURNS [dx, dy: REAL] = {
font: ImagerFont.Font_ textFont[fontType][output];
extents: ImagerFont.Extents _ ImagerFont.RopeBoundingBox[font, text];
dx _ extents.rightExtent - extents.leftExtent;
dy _ extents.descent + extents.ascent;
}; -- GetRopeSize

ScaleAxis: PROC [minDataValue, maxDataValue, innerBoxSize: REAL, nLabels: CARDINAL]
RETURNS [min, max, step, scale: REAL] = {
step _ FindStepSize[maxDataValue - minDataValue, nLabels];
min _ AlignEnd[minDataValue, step, FALSE];
max _ AlignEnd[maxDataValue, step, TRUE];
IF Almost[min, max] THEN {max _ max + 50.0; min _ min - 50.0};
scale _ innerBoxSize/(max - min);
}; -- ScaleAxis

FindStepSize: PROC [range: REAL, nSteps: CARDINAL] RETURNS[step: REAL] = {
logRange:  REAL;
mantissa, minStep:  REAL;
characteristic:  INTEGER;
steps:  ARRAY [0..6) OF REAL = [0.2, 0.5, 1.0, 2.0, 5.0, 10.0];

IF Almost[range, 0.0] THEN range _ 100.0;

logRange _ RealFns.Log[10.0, range];
characteristic _ Real.FixI[logRange];
mantissa _ logRange - characteristic;
IF logRange < 0.0 THEN {
characteristic _ characteristic - 1;
mantissa _ mantissa + 1.0};
minStep _ RealFns.Power[10.0, mantissa]/nSteps;
FOR i: CARDINAL IN [0..5) DO
step _ steps[i];
IF step > minStep OR Almost[step, minStep] THEN EXIT
ENDLOOP;
IF characteristic >= 0 THEN THROUGH [1..characteristic] DO step _ step*10.0 ENDLOOP
ELSE THROUGH [1..-characteristic] DO step _ step/10.0 ENDLOOP;
step _ MAX[1.0, step];
}; -- FindStepSize

AlignEnd: PROC [e, step:  REAL, roundUp:  BOOL] RETURNS [ae:  REAL] = {
absE: REAL = ABS[e];
nSteps: INTEGER;
xend: REAL;

IF e = 0.0 THEN RETURN[0.0];
IF e < 0.0 THEN roundUp _ ~roundUp;
nSteps _ Real.RoundLI[absE/step - 0.5];
xend _ step*nSteps;
IF Almost[nSteps, absE/step] THEN ae _ xend
ELSE IF roundUp
THEN ae _ IF xend >= absE THEN xend ELSE step*(nSteps + 1)
ELSE ae _ IF xend <= absE THEN xend ELSE step*(nSteps - 1);
IF e < 0.0 THEN ae _ -ae;
}; -- AlignEnd

Almost: PROC [p, q: REAL] RETURNS [a: BOOL _ TRUE] = {
max: REAL _ MAX[ABS[p], ABS[q]];
IF max # 0.0 THEN a _ (ABS[p - q]/max) < 0.00001;
}; -- Almost

MyDrawText:  PROC[context: Imager.Context,
text: Rope.ROPE, x0, y0: REAL,
xJustification: {left, center, right} _ left,
yJustification: {top, center, bottom} _ bottom,
fontType: FontType _ normal,
output: OutputType _ screen,
xScale, yScale: REAL _ 1.0] 
RETURNS [Imager.VEC] = {

proc: PROC = {
context.TranslateT[[x0, y0]];
context.SetXY[[xmin, ymin]];
context.SetFont[font];
context.Scale2T[[xScale, yScale]];
context.ShowRope[text];
}; -- proc

extents: ImagerFont.Extents;
xmin, ymin, width, height: REAL;
font: ImagerFont.Font = textFont[fontType][output];

IF text.IsEmpty[] THEN RETURN[[x0, y0]];
extents _ ImagerFont.RopeBoundingBox[font: font, rope: text];
extents _ [extents.leftExtent*xScale, extents.rightExtent*xScale,
extents.descent*yScale, extents.ascent*yScale];
width _ extents.rightExtent - extents.leftExtent;
height _ extents.descent + extents.ascent;
xmin_ SELECT xJustification FROM
right => - width - extents.leftExtent,
center => - width/2.0 - extents.leftExtent,
ENDCASE => - extents.leftExtent;
ymin_ SELECT yJustification FROM
top => - height + extents.descent,
center => - height/2.0 + extents.descent,
ENDCASE => extents.descent;
context.DoSave[proc];
RETURN[IF output = interpress THEN [x0 + width, y0 + height]
ELSE ImagerBackdoor.GetCP[context]];
}; -- MyDrawText

DrawCurves: PROC [context: Imager.Context, handle: Handle,
curves: Curves, output: OutputType] = {
box: Imager.Box _ handle.curvesBox;
bounds: Imager.Box _ handle.realBounds;
colorMode: ColorMode _ handle.colorMode;
IF curves # NIL THEN {
nCurvesMax: CARDINAL = curves.first.size - 1;
tFactor: REAL _ (box.xmax - box.xmin)/(bounds.xmax - bounds.xmin);
vFactor: REAL _ (box.ymax - box.ymin)/(bounds.ymax - bounds.ymin);
drawThem: PROC = {
context.TranslateT[[box.xmin, box.ymin]];
context.SetStrokeWidth[minLineWidth];
context.SetStrokeJoint[mitered];
IF colorMode = bw THEN {
context.SetStrokeEnd[butt];
FOR i: CARDINAL IN [1..nCurvesMax] DO
firstPoint: BOOL _ TRUE;
lastVec, newVec: Imager.VEC;
index: CARDINAL _ i - 1;
handle.lineStates[index]^ _ []; -- cf. AddVector.
FOR graph: Curves _ curves, graph.rest UNTIL graph = NIL DO
newVec _ [
(graph.first[0] - bounds.xmin)*tFactor,
(graph.first[i] - bounds.ymin)*vFactor];
IF firstPoint THEN firstPoint _ FALSE
ELSE DrawLineSeg[context, lastVec, newVec,
index MOD 12, handle.lineStates[index]];
lastVec _ newVec;
ENDLOOP;
ENDLOOP;
}
ELSE {
context.SetStrokeEnd[round];
FOR i: CARDINAL IN [1..nCurvesMax] DO
context.SetColor[color[((i-1) MOD 12)+1]];
IF output = press THEN {
normal: BOOL _ FALSE;
lastVec: Imager.VEC;
FOR graph: Curves _ curves, graph.rest UNTIL graph = NIL DO
t: REAL _ (graph.first[0] - bounds.xmin)*tFactor;
v: REAL _ (graph.first[i] - bounds.ymin)*vFactor;
IF normal THEN context.MaskVector[lastVec, [t, v]] ELSE normal _ TRUE;
lastVec _ [t, v];
ENDLOOP;
}
ELSE { 
oneCurve: Imager.PathProc = {
start: BOOL _ TRUE;
FOR graph: Curves _ curves, graph.rest UNTIL graph = NIL DO
t: REAL _ (graph.first[0] - bounds.xmin)*tFactor;
v: REAL _ (graph.first[i] - bounds.ymin)*vFactor;
IF start THEN moveTo[[t, v]] ELSE lineTo[[t, v]];
start _ FALSE;
ENDLOOP;
}; -- oneCurve
context.MaskStroke[path: oneCurve, closed: FALSE];
};
ENDLOOP;
};
}; -- drawThem

IF nCurvesMax > 0 THEN context.DoSave[drawThem];
};
}; -- DrawCurves

DrawLegendFootnote: PROC [context: Imager.Context, box: Imager.Box,
legendEntries: REF RopeSequence, footNote: Rope.ROPE,
output: OutputType, colorMode: ColorMode] = {
nEntries: CARDINAL _ legendEntries.size;
MaxEntriesPerColumn: CARDINAL = 5;
xmin, xmax: REAL _ 0;
yIncPerRow: REAL _ MAX[-fontHeight[normal][output], (box.ymin - box.ymax) / MaxEntriesPerColumn]; -- note: they are negative.
yScale: REAL = -yIncPerRow / fontHeight[normal][output];
colorSampleLineLength: REAL = 34.0;
sampleLineLength: ARRAY[0..12) OF REAL = [
34.0, 34.0, 34.0, 34.0, 34.0, 34.0, 34.0, 34.0, 31.0, 31.0, 34.0, 34.0];
state: LineState _ NEW[LineStateRec];
proc: PROC = {
context.TranslateT[[box.xmin, box.ymax]];
IF yScale >= 0.99 THEN
[] _ MyDrawText[context, footNote, 0, -(box.ymax-box.ymin), left, top, normal, output];
FOR i: CARDINAL IN [0..nEntries) DO
row: CARDINAL _ i MOD MaxEntriesPerColumn;
col: CARDINAL _ i / MaxEntriesPerColumn;
index: CARDINAL _ i MOD 12;
textStartX, textStartY, lineY, newX: REAL;
IF row = 0 AND col > 0 THEN {
xmin _ xmax + TextWidthFudge;
IF xmin >= box.xmax THEN EXIT;
}; 
textStartX _ xmin + 36.0;
textStartY _ row*yIncPerRow;
lineY _ textStartY + (yIncPerRow/2.0);
context.SetStrokeWidth[minLineWidth];
context.SetStrokeEnd[butt];
IF colorMode = bw THEN {
state^ _ [];
DrawLineSeg[context, [xmin, lineY], [xmin+sampleLineLength[index], lineY],
index, state];
}
ELSE {
context.SetColor[color[index+1]];
context.MaskVector[[xmin, lineY], [xmin+colorSampleLineLength, lineY]];
};
[[newX, ]] _ MyDrawText [
context,
legendEntries[i],
textStartX, textStartY,
left, top, normal, output, 1.0, yScale];
IF newX > xmax THEN xmax _ newX;
ENDLOOP;
}; -- proc

context.DoSave[proc];
}; -- DrawLegendFootnote

LineShape: TYPE = {solid, dot, dash, longDash};
StepSize: ARRAY LineShape[dot..longDash] OF REAL = [3.0, 6.0, 9.0];
LineLimit: ARRAY LineShape[dot..longDash] OF REAL = [1.0, 4.0, 7.0]; -- beyond which is space.
LineStyle: TYPE = NColors[0..12);

shape: ARRAY LineStyle OF ARRAY LineStep OF LineShape = [
[solid, solid, solid, solid, solid, solid], -- solid, useless
[dot, dot, dot, dot, dot, dot], -- dot
[dash, dash, dash, dash, dash, dash], -- dash
[longDash, longDash, longDash, longDash, longDash, longDash], -- longDash
[dot, dash, dot, dash, dot, dash], -- dot-dash
[dot, longDash, dot, longDash, dot, longDash], -- dot-longDash
[dot, dot, dash, dot, dot, dash], -- dot-dot-dash
[dot, dot, longDash, dot, dot, longDash], -- dot-dot-longDash
[dot, dash, dash, dot, dash, dash], -- dot-dash-dash
[dot, longDash, longDash, dot, longDash, longDash], -- dot-longDash-longDash
[dash, longDash, dash, longDash, dash, longDash], -- dash-longDash
[dot, dash, longDash, dot, dash, longDash] -- dot-dash-longDash
];

DrawLineSeg: PROC[context: Imager.Context,
v0, v1: Imager.VEC _ [0.0, 0.0],
style: LineStyle _ 0,
state: LineState _ NIL] = {
IF Almost[v0.x, v1.x] AND Almost[v0.y, v1.y] THEN RETURN;
IF state = NIL THEN state _ NEW[LineStateRec _ []];
IF style = 0 THEN context.MaskVector[v0, v1]
ELSE { -- Note that normally state.step and state.progress will be updated.
dx: REAL = v1.x - v0.x;
dy: REAL = v1.y - v0.y;
lengthToGo: REAL _ RealFns.SqRt[dx*dx + dy*dy];
cosine: REAL _ dx/lengthToGo;
sine: REAL _ dy/lengthToGo;
newVec, oldVec: Imager.VEC _ v0;
stepSize, lineLimit, increment: REAL;
drawIt: BOOL;
UNTIL Almost[lengthToGo, 0.0] DO
stepSize_ StepSize[shape[style][state.step]];
lineLimit_ LineLimit[shape[style][state.step]];
IF state.progress < lineLimit THEN {
drawIt _ TRUE;
increment _ MIN[lengthToGo, lineLimit - state.progress];
}
ELSE {
drawIt _ FALSE;
increment _ MIN[lengthToGo, stepSize - state.progress];
};
lengthToGo _ lengthToGo - increment;
state.progress _ state.progress + increment;
newVec _ [oldVec.x + cosine*increment, oldVec.y + sine*increment];
IF drawIt THEN context.MaskVector[oldVec, newVec]
ELSE IF Almost[state.progress, stepSize] THEN {
state.step _ (state.step + 1) MOD MaxStep;
state.progress _ 0.0;
};
oldVec _ newVec;
ENDLOOP;
};
}; -- DrawLineSeg

Init: PROC [] = {
FOR f: FontType IN FontType DO
FOR o: OutputType IN OutputType DO
extents: ImagerFont.Extents _ ImagerFont.FontBoundingBox[textFont[f][o]];
fontHeight[f][o] _ extents.descent+extents.ascent;
ENDLOOP;
ENDLOOP;
}; -- Init

Init[];
}.

CHANGE LOG.
Chen, August 2, 1985 7:08:09 pm PDT, spin off from PlotViewer.

fPlotViewerPaint.mesa
Last Edited by:
Sweetsun Chen, August 2, 1985 9:28:51 pm PDT

constants
(constant) variables
type
press context has been rotated
title / legend / footnote
axes and curves
external vars referenced: output.
external vars referenced: output.
Press doesn't support MaskStroke.
context.SetColor[foreground]; -- already done. ... bad!


�Ê�˜Jš
Ïc™š
œ™Jš
œ,™,J™—š
Ïk	˜	Jšœ
žœžœ˜JšœžœÓ
žœ˜ä
Jšœžœ˜(Jšœžœ@˜PJšžœ
žœ˜#Jšœžœ7˜AJšœžœ|˜‰
Jšœžœ˜#Jšœžœ˜"Jšœžœžœ˜*Jšœžœ˜Jšœžœ˜%J˜—šœžœ
ž˜Jšžœ0žœ&˜_Jšžœ˜—J˜Jšžœ˜J˜J™	Jšœžœ˜Jšœžœ˜Jšœžœ˜J˜J™Jšœ?žœ�˜Mš
œ*˜*Jš
œ:˜:—Jš
œ;˜;š
œ(˜(Jš
œ8˜8—Jš	œ
žœ
žœ
žœžœ:˜pJšœžœ
žœ
žœžœ
žœ
˜>J˜J™Jšœ
žœ˜!J˜šÏnœžœ8žœ
žœ˜kJš
œ™š
Ÿœžœžœžœžœ˜=Jšžœžœ˜4Jšœ�˜—J˜šœžœžœ˜SJšžœ#˜'—Jš
œE˜Ešœ#žœžœž˜IJšžœžœžœ	˜JJšžœ˜—J˜š
žœžœ
žœ
žœ,žœ˜PJ˜šœ#žœžœ
ž˜Hšžœž˜Jšœ>žœ
˜R——J˜Jšœžœ˜Jšœžœ
˜J˜Jšœ
žœ˜Jšœžœ˜Jšœ	žœ˜"Jšœ	žœ˜#J˜Jšœžœ˜!Jšœžœ˜!Jšœžœ˜!Jšœžœ˜ Jšœžœ˜&Jšœ
žœ˜(J˜Jšœ
žœ˜%Jšœžœ0˜DJšœžœ ˜2Jš	œžœžœžœžœ˜HJš	œ	žœžœžœžœ˜BJ˜Jš
œ3˜3Jš
œ7˜7Jš
œ7˜7J˜šžœžœ�˜-J˜J˜Jš
œ˜—J˜Jš
œ™J˜šžœ
žœžœ˜Jšœžœ"˜+Jš	œžœžœ
žœžœ&˜eJš	œžœžœžœžœ˜gJš
œ=˜=š
œE˜EJš
œ$˜$—J˜—J˜Jš
œ™šžœ%žœ˜-Jšœžœ
˜Jš
œc˜cš
œ˜Jš
œŽ
˜Ž
—šžœ#žœžœ
ž˜6Jšœžœ
˜Jšžœ
˜—Jš
œ'˜'J˜—J˜
—š
žœ
žœ
žœžœžœ˜7Jšœ
žœ˜!šžœžœ žœ˜5J˜J˜Jšžœžœ
žœžœ
žœ
žœ
˜)J˜Jšžœžœ
žœ
žœ
˜šžœžœ˜Jšœžœ˜Jšœ	žœB˜OJšœžœ˜Jšœ	žœB˜OJšœžœ˜"Jšœžœ˜"J˜š
œ˜Jš
œŽ
˜Ž
—Jš
œ5˜5Jš
œ˜Jš
œ%˜%šžœžœ˜Jš
œ˜šžœžœ
žœž˜&Jšœžœ
˜š
œ˜Jš
œ?˜?Jšœžœ˜(—Jšžœ
˜—J˜
—šžœžœ
žœž˜+Jšœžœ
˜Jšœžœ˜,š
œ˜Jš
œ@˜@—Jšžœ
˜—J˜—J˜—J˜—Jšœ�	˜—J˜šŸ	œžœ8žœ˜dJšœžœ*˜4Jšœžœ4˜>J˜Jšžœžœ
žœ
˜šžœ#žœ
˜*Jš
œK˜K—šžœ
žœ$ž˜/Jš
œM˜M—Jšœ�˜J˜—šŸœžœG˜UJšžœ'˜.J˜šŸœžœ˜Jš
œ˜J˜Jš
œ)˜)šžœžœ˜Jš
�$˜$Jš
œS˜SJš
œS˜SJš
œS˜SJš
œS˜SJ˜
—šžœ˜š
œ˜J˜'J˜'J˜'J˜'J˜—Jšœ-žœ˜3J˜—Jšœ�	˜J˜—šŸœžœ+˜EJšœžœ˜ Jš
œ!™!Jšœ
žœ˜,Jšœžœ!˜4Jšœ	žœ˜+Jšœžœ
˜J˜šžœžœ
žœž˜$Jš
œ˜š
œ˜Jšžœ
žœ˜&Jš
œ˜Jš
œ˜—šžœžœžœ˜!Jšœžœ˜Jšœžœ˜Jšœžœ˜ Jš
œG˜GJšœžœ+žœ˜=Jšžœžœ1˜GJšžœ˜Jš
œ.˜.Jšžœžœ1˜GJšžœ˜J˜—Jšžœ
˜Jšœ�˜J˜——šŸœžœ+˜CJšœžœ˜ Jš
œ!™!Jšœ
žœ˜,Jšœžœ!˜4Jšœžœ˜,Jšœžœ
˜J˜šžœžœ
žœž˜$Jš
œ˜˜Jšžœ
žœ˜&Jš
œ˜Jš
œ˜—šžœžœžœ˜!Jšœžœ˜Jšœžœ˜Jšœžœ˜ Jš
œG˜GJšœžœ+žœ˜=Jšžœžœ1˜GJšžœ˜Jš
œ.˜.Jšžœžœ1˜GJšžœ˜J˜——Jšžœ
˜Jšœ�˜—J˜Jšœžœ˜ Jšœžœ˜ Jšœžœ�˜&Jšœžœ
˜Jšœžœ
˜JšœQžœ
˜VJšœžœ
˜J˜šœ*žœ
žœ˜OJš
œ˜—šœ*žœ
žœ˜OJš
œ˜—Jšœžœ˜,Jšœžœ˜/J˜šœ*žœ
žœ˜OJš
œ˜—šœ*žœ
žœ˜OJš
œ˜—Jšœžœ˜,Jšœžœ˜/J˜š
œ˜Jš
œ.˜.Jš
œ2˜2Jš
œ˜Jš
œ˜—Jšžœžœ˜?Jšžœžœ˜?J˜Jš
œ'˜'Jš
œ'˜'J˜Jš
œ˜J˜Jšœžœžœ+˜@Jšœžœžœ,˜AJ˜š
œ>˜>Jš
œ,˜,—š
œ>˜>Jš
œ,˜,—J˜Jš
œ˜Jš
œ%˜%Jš
œY˜YJš
œW˜WJšœ�˜J˜—š
Ÿœžœ
žœ<žœ
žœ˜xJš
œ2˜2Jš
œE˜EJš
œ.˜.Jš
œ&˜&Jšœ�˜J˜—šŸ	œžœ,žœžœ
˜SJšžœžœ˜)J˜:Jšœ#žœ˜*Jšœ#žœ˜)Jšžœžœ&˜>J˜!šœ�˜J˜——šŸœžœ	žœ
žœžœžœ˜JJšœžœ
˜Jšœžœ
˜Jšœžœ
˜Jšœžœžœ
žœ#˜?J˜Jšžœžœ˜)J˜J˜$J˜%J˜%šžœžœ˜Jš
œ$˜$J˜—J˜/šžœžœ
žœž˜Jš
œ˜Jšžœžœžœ
ž˜4Jšžœ
˜—š	žœžœ
žœžœž˜SJšžœ
žœžœžœ
˜>—Jšœžœ˜Jšœ�˜J˜—šŸœžœžœžœžœžœ˜GJšœžœžœ˜Jšœžœ
˜Jšœžœ
˜J˜Jšžœ	žœ
žœ˜Jšžœ	žœ˜#J˜'J˜Jšžœžœ
˜+šžœ
žœ˜Jšžœžœžœžœ˜:Jšžœžœžœžœ˜;—Jšžœ	žœ
˜šœ�˜J˜——šŸœžœžœžœžœžœ˜6Jš	œžœžœ
žœžœ˜ Jšžœžœžœ˜1Jšœ�	˜J˜—šŸ
œžœ˜*Jšœžœ
žœ
˜J˜-J˜/Jš
œ˜Jš
œ˜Jšœžœ˜Jšžœ	žœ˜J˜šœžœ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ˜Jšœ�˜
J˜—Jš
œ˜Jšœžœ
˜ Jš
œ3˜3J˜Jšžœžœ
žœ˜(Jš
œ=˜=š
œA˜AJš
œ/˜/—Jš
œ1˜1Jšœžœ!˜*šœžœž˜ Jš
œ&˜&Jš
œ+˜+Jšžœ˜ —šœžœž˜ Jš
œ"˜"Jš
œ)˜)Jšžœ˜—Jš
œ˜šžœ
žœžœ˜<Jšžœ ˜$—Jšœ�
˜J˜—šŸ
œžœ*˜:Jš
œ'˜'Jš
œ#˜#Jš
œ'˜'Jš
œ(˜(šžœ
žœ
žœ˜Jšœžœ˜-Jšœ	žœ5˜BJšœ	žœ5˜Bšœ
žœ˜Jš
œ)˜)Jš
œ%˜%Jš
œ ˜ šžœžœ˜Jš
œ˜šžœžœ
žœž˜%Jšœžœžœ
˜Jšœžœ
˜Jšœžœ	˜Jšœ �˜1šžœ$žœ	žœ
ž˜;š
œ
˜
Jš
œ'˜'Jš
œ(˜(—Jšžœžœž˜%šžœ&˜*Jšœžœ˜(—Jš
œ˜Jšžœ
˜—Jšžœ
˜—Jš
œ
˜
—šžœ˜Jš
œ˜šžœžœ
žœž˜%Jšœžœ	˜*šžœžœ˜Jš
œ!™!Jšœžœžœ
˜Jšœžœ
˜šžœ$žœ	žœ
ž˜;Jšœžœ*˜1Jšœžœ*˜1Jšžœžœ%žœ
žœ
˜FJš
œ˜Jšžœ
˜—J˜
—šžœ˜˜Jšœžœžœ
˜šžœ$žœ	žœ
ž˜;Jšœžœ*˜1Jšœžœ*˜1Jšžœžœžœ˜1Jšœžœ
˜Jšžœ
˜—Jšœ�˜—Jšœ+žœ˜2J˜—Jšžœ
˜—J˜—Jšœ�˜—J˜Jšžœžœ˜0J˜—Jšœ�
˜J˜—šŸœžœ+˜CJšœžœžœ
˜5Jš
œ-˜-Jšœ
žœ˜(Jšœžœ˜"Jšœžœ˜JšœžœžœL�˜}Jšœžœ,˜8Jšœžœ˜#šœžœžœ
žœ˜*J˜H—Jšœžœ˜%šœžœ˜Jš
œ)˜)šžœž˜Jš
œW˜W—šžœžœ
žœž˜#Jšœžœžœ˜*Jšœžœ˜(Jšœžœžœ˜Jšœ%žœ
˜*šžœ	žœ	žœ˜Jš
œ˜Jšžœžœ
žœ
˜J˜—Jš
œ˜Jš
œ˜Jš
œ&˜&Jš
œ%˜%Jš
œ˜šžœžœ˜Jš
œ7™7Jš
œ˜š
œJ˜JJš
œ˜—J˜
—šžœ˜Jš
œ!˜!Jš
œG˜GJ˜—š
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ(˜(—Jšžœ
žœ
˜ Jšžœ
˜—Jšœ�˜
—J˜Jš
œ˜Jšœ�˜—J˜Jšœžœ ˜/Jšœ
žœžœ
žœ˜CJšœžœžœ
žœ�˜^šœžœ˜!J˜—š	œžœžœ
žœ
žœ˜9Jšœ,�˜=Jšœ �˜&Jšœ&�˜-Jšœ>�˜IJšœ#�˜.Jšœ/�˜>Jšœ"�˜1Jšœ*�˜=Jšœ$�˜4Jšœ4�˜LJšœ2�˜BJšœ+�˜?J˜J˜—šŸœžœ˜*Jšœž
œžœ˜ Jš
œ˜šœžœ˜J™—Jšžœžœžœ
žœ
˜9Jšžœ	žœ
žœ	žœ˜3J™Jšžœžœ˜,šžœ�D˜KJšœžœ˜Jšœžœ˜Jšœžœ˜/Jšœžœ˜Jšœžœ˜Jšœžœ˜ Jšœ žœ
˜%Jšœžœ
˜
šžœž˜ Jš
œ-˜-Jš
œ/˜/šžœžœ˜$Jšœ	žœ
˜Jšœžœ)˜8J˜
—šžœ˜Jšœ	žœ
˜Jšœžœ(˜7J˜—Jš
œ$˜$Jš
œ,˜,Jš
œB˜BJšžœžœ#˜1šžœ
žœ"žœ˜/Jšœžœ	˜*J˜J˜—Jš
œ˜Jšžœ
˜—Jš
œ˜—Jšœ�˜—J˜˜šžœ
žœ
ž˜šžœžœž˜"Jš
œI˜IJš
œ2˜2Jšžœ
˜—Jšžœ
˜—Jšœ�˜
—J˜J˜J˜J˜šžœ
žœ
˜J˜>——…—Qi