DIRECTORY
Imager USING [ClipOutline, ClipRectangle, ConcatT, Correct, CorrectMask, CorrectSpace, MakeGray, MaskFill, MaskFillOutline, MaskPixel, MaskRectangle, MaskStrokeTrajectory, MaskUnderline, MaskVector, Move, SetColor, SetCorrectMeasure, SetCorrectTolerance, SetFont, SetGray, SetXRel, SetXY, SetXYRel, SetYRel, Space, StartUnderline, Trans, TranslateT, StrokeJoint],
ImagerBackdoor USING [GetColor, GetCP, GetInt, GetReal, GetT, SetInt, SetReal, SetT],
ImagerColor USING [MakeSampledBlack, MakeSampledColor],
ImagerPath USING [ArcTo, ConicTo, CurveTo, LineTo, LineToX, LineToY, MoveTo, Outline, OutlineRep, PathProc, Trajectory],
ImagerPixelArray USING [Extract, PixelArray],
ImagerTransformation USING [Concat, Create, DRound, Invert, Rotate, RoundXY, RoundXYVec, Scale, Scale2, Transform, Transformation, TransformVec, Translate],
IO USING [GetIndex, SetIndex],
IPImage USING [],
IPImager USING [ColorOperatorFromOperator, FindColor, FindColorModelOperator, FindColorOperator, FindFont, FindFontVec, MakePixelArray, ModifyFont, Show, ShowAndXRel],
IPInterpreter USING [CallInlineBody, DoWithMarkProtection, Env, Even, FGet, Frame, GetInteger, Integer, MasterError, NoPool, Operator, Pool, PopBool, PopColor, PopInteger, PopOperator, PopOutline, PopPixelArray, PopReal, PopTrajectory, PopTransformation, PopVec, PopVector, PushColor, PushInteger, PushOperator, PushOutline, PushPixelArray, PushReal, PushTrajectory, PushTransformation, PushVec, PushVector, Ref, Shape, TopType, Vector, VectorFromAny, VectorShape],
IPMaster USING [ImagerVariable],
Vector2 USING [VEC];

IPImageImpl: CEDAR PROGRAM
IMPORTS Imager, ImagerBackdoor, ImagerColor, ImagerPath, ImagerPixelArray, ImagerTransformation, IO, IPImager, IPInterpreter
EXPORTS IPImage
~ BEGIN OPEN IPInterpreter;

VEC: TYPE ~ Vector2.VEC;
Transformation: TYPE ~ ImagerTransformation.Transformation;
PixelArray: TYPE ~ ImagerPixelArray.PixelArray;
Trajectory: TYPE ~ ImagerPath.Trajectory;
Outline: TYPE ~ ImagerPath.Outline;
OutlineRep: TYPE ~ ImagerPath.OutlineRep;

SetMedium: PROC [self: Ref, 
m: Vector, pageNumber: Integer, duplex: BOOL, xImageShift: REAL] ~ {
IF duplex AND Even[pageNumber]
THEN Imager.TranslateT[self.imager, [-xImageShift, 0]]
ELSE Imager.TranslateT[self.imager, [xImageShift, 0]];
};


ImagerVariable: TYPE ~ IPMaster.ImagerVariable;
ImagerVariableVal: TYPE ~ [0..ORD[ImagerVariable.LAST]];

ImagerVariableFromInteger: PROC [i: Integer] RETURNS [ImagerVariable] ~ {
IF i NOT IN ImagerVariableVal THEN MasterError[$boundsFault, 
"Imager variable index out of bounds."];
RETURN[VAL[ImagerVariableVal[i]]];
};

GetShowVec: PROC [self: Ref] RETURNS [Vector] ~ {
RETURN[self.showVec];
};
SetShowVec: PROC [self: Ref, v: Vector] ~ {
self.showVec _ v;
IF v.font#NIL THEN Imager.SetFont[self.imager, v.font];
};
ApplyIGET: PUBLIC PROC [self: Ref] ~ {
i: Integer ~ PopInteger[self];
SELECT ImagerVariableFromInteger[i] FROM
$DCScpx => PushReal[self, ImagerBackdoor.GetReal[self.imager, $DCScpx]];
$DCScpy => PushReal[self, ImagerBackdoor.GetReal[self.imager, $DCScpy]];
$correctMX => PushReal[self, ImagerBackdoor.GetReal[self.imager, $correctMX]];
$correctMY => PushReal[self, ImagerBackdoor.GetReal[self.imager, $correctMY]];
$T => PushTransformation[self, ImagerBackdoor.GetT[self.imager]];
$priorityImportant => PushInteger[self, ImagerBackdoor.GetInt[self.imager, $priorityImportant]];
$mediumXSize => PushReal[self, ImagerBackdoor.GetReal[self.imager, $mediumXSize]];
$mediumYSize => PushReal[self, ImagerBackdoor.GetReal[self.imager, $mediumYSize]];
$fieldXMin => PushReal[self, ImagerBackdoor.GetReal[self.imager, $fieldXMin]];
$fieldYMin => PushReal[self, ImagerBackdoor.GetReal[self.imager, $fieldYMin]];
$fieldXMax => PushReal[self, ImagerBackdoor.GetReal[self.imager, $fieldXMax]];
$fieldYMax => PushReal[self, ImagerBackdoor.GetReal[self.imager, $fieldYMax]];
$showVec => PushVector[self, GetShowVec[self]];
$color => PushColor[self, ImagerBackdoor.GetColor[self.imager]];
$noImage => PushInteger[self, ImagerBackdoor.GetInt[self.imager, $noImage]];
$strokeWidth => PushReal[self, ImagerBackdoor.GetReal[self.imager, $strokeWidth]];
$strokeEnd => PushInteger[self, ImagerBackdoor.GetInt[self.imager, $strokeEnd]];
$strokeJoint => PushInteger[self, ImagerBackdoor.GetInt[self.imager, $strokeJoint]];
$underlineStart => PushReal[self, ImagerBackdoor.GetReal[self.imager, $underlineStart]];
$amplifySpace => PushReal[self, ImagerBackdoor.GetReal[self.imager, $amplifySpace]];
$correctPass => PushInteger[self, ImagerBackdoor.GetInt[self.imager, $correctPass]];
$correctShrink => PushReal[self, ImagerBackdoor.GetReal[self.imager, $correctShrink]];
$correctTX => PushReal[self, ImagerBackdoor.GetReal[self.imager, $correctTX]];
$correctTY => PushReal[self, ImagerBackdoor.GetReal[self.imager, $correctTY]];
ENDCASE => ERROR;
};

ApplyISET: PUBLIC PROC [self: Ref] ~ {
i: Integer ~ PopInteger[self];
SELECT ImagerVariableFromInteger[i] FROM
$DCScpx => ImagerBackdoor.SetReal[self.imager, $DCScpx, PopReal[self]];
$DCScpy => ImagerBackdoor.SetReal[self.imager, $DCScpy, PopReal[self]];
$correctMX => ImagerBackdoor.SetReal[self.imager, $correctMX, PopReal[self]];
$correctMY => ImagerBackdoor.SetReal[self.imager, $correctMY, PopReal[self]];
$T => ImagerBackdoor.SetT[self.imager, PopTransformation[self]];
$priorityImportant => ImagerBackdoor.SetInt[self.imager, $priorityImportant, PopInteger[self]];
$mediumXSize => ImagerBackdoor.SetReal[self.imager, $mediumXSize, PopReal[self]];
$mediumYSize => ImagerBackdoor.SetReal[self.imager, $mediumYSize, PopReal[self]];
$fieldXMin => ImagerBackdoor.SetReal[self.imager, $fieldXMin, PopReal[self]];
$fieldYMin => ImagerBackdoor.SetReal[self.imager, $fieldYMin, PopReal[self]];
$fieldXMax => ImagerBackdoor.SetReal[self.imager, $fieldXMax, PopReal[self]];
$fieldYMax => ImagerBackdoor.SetReal[self.imager, $fieldYMax, PopReal[self]];
$showVec => SetShowVec[self, PopVector[self]];
$color => Imager.SetColor[self.imager, PopColor[self]];
$noImage => ImagerBackdoor.SetInt[self.imager, $noImage, PopInteger[self]];
$strokeWidth => ImagerBackdoor.SetReal[self.imager, $strokeWidth, PopReal[self]];
$strokeEnd => ImagerBackdoor.SetInt[self.imager, $strokeEnd, PopInteger[self]];
$strokeJoint => ImagerBackdoor.SetInt[self.imager, $strokeJoint, FixJoint[PopInteger[self]]];
$underlineStart => ImagerBackdoor.SetReal[self.imager, $underlineStart, PopReal[self]];
$amplifySpace => ImagerBackdoor.SetReal[self.imager, $amplifySpace, PopReal[self]];
$correctPass => ImagerBackdoor.SetInt[self.imager, $correctPass, PopInteger[self]];
$correctShrink => ImagerBackdoor.SetReal[self.imager, $correctShrink, PopReal[self]];
$correctTX => ImagerBackdoor.SetReal[self.imager, $correctTX, PopReal[self]];
$correctTY => ImagerBackdoor.SetReal[self.imager, $correctTY, PopReal[self]];
ENDCASE => ERROR;
};

oldRound: [1..1] ~ ORD[Imager.StrokeJoint.round];
FixJoint: PROC [i: INT] RETURNS [INT] ~ {
IF i = 2 THEN i _ oldRound;
RETURN [i];
};

ApplyDROUND: PUBLIC PROC [self: Ref] ~ {
p: VEC ~ PopVec[self];
PushVec[self, ImagerTransformation.DRound[p]];
};

ApplyMAKET: PUBLIC PROC [self: Ref] ~ {
f: REAL ~ PopReal[self]; e: REAL ~ PopReal[self]; d: REAL ~ PopReal[self];
c: REAL ~ PopReal[self]; b: REAL ~ PopReal[self]; a: REAL ~ PopReal[self];
PushTransformation[self, ImagerTransformation.Create[a, b, c, d, e, f]];
};
ApplyOPENT: PUBLIC PROC [self: Ref] ~ {
m: Transformation ~ PopTransformation[self];
PushReal[self, m.a]; PushReal[self, m.b]; PushReal[self, m.c];
PushReal[self, m.d]; PushReal[self, m.e]; PushReal[self, m.f];
};
ApplyTRANSLATE: PUBLIC PROC [self: Ref] ~ {
t: VEC ~ PopVec[self];
PushTransformation[self, ImagerTransformation.Translate[t]];
};
ApplyROTATE: PUBLIC PROC [self: Ref] ~ {
a: REAL ~ PopReal[self];
PushTransformation[self, ImagerTransformation.Rotate[a]];
};
ApplySCALE: PUBLIC PROC [self: Ref] ~ {
s: REAL ~ PopReal[self];
PushTransformation[self, ImagerTransformation.Scale[s]];
};
ApplySCALE2: PUBLIC PROC [self: Ref] ~ {
s: VEC ~ PopVec[self];
PushTransformation[self, ImagerTransformation.Scale2[s]];
};
ApplyCONCAT: PUBLIC PROC [self: Ref] ~ {
n: Transformation ~ PopTransformation[self];
m: Transformation ~ PopTransformation[self];
PushTransformation[self, ImagerTransformation.Concat[m, n]];
};
ApplyINVERT: PUBLIC PROC [self: Ref] ~ {
m: Transformation ~ PopTransformation[self];
PushTransformation[self, ImagerTransformation.Invert[m]];
};

ApplyTRANSFORM: PUBLIC PROC [self: Ref] ~ {
m: Transformation ~ PopTransformation[self];
p: VEC ~ PopVec[self];
PushVec[self, m.Transform[p]];
};
ApplyTRANSFORMVEC: PUBLIC PROC [self: Ref] ~ {
m: Transformation ~ PopTransformation[self];
v: VEC ~ PopVec[self];
PushVec[self, m.TransformVec[v]];
};
ApplyROUNDXY: PUBLIC PROC [self: Ref] ~ {
m: Transformation ~ PopTransformation[self];
p: VEC ~ PopVec[self];
PushVec[self, m.RoundXY[p]];
};
ApplyROUNDXYVEC: PUBLIC PROC [self: Ref] ~ {
m: Transformation ~ PopTransformation[self];
v: VEC ~ PopVec[self];
PushVec[self, m.RoundXYVec[v]];
};

ApplyCONCATT: PUBLIC PROC [self: Ref] ~ {
m: Transformation ~ PopTransformation[self];
Imager.ConcatT[self.imager, m];
};
ApplyMOVE: PUBLIC PROC [self: Ref] ~ {
Imager.Move[self.imager];
};
ApplyTRANS: PUBLIC PROC [self: Ref] ~ {
Imager.Trans[self.imager];
};

ApplySHOW: PUBLIC PROC [self: Ref] ~ {
v: Vector ~ PopVector[self];
IPImager.Show[self, v];
};
ApplySHOWANDXREL: PUBLIC PROC [self: Ref] ~ {
v: Vector ~ PopVector[self];
IPImager.ShowAndXRel[self, v];
};

ApplySETXY: PUBLIC PROC [self: Ref] ~ {
Imager.SetXY[self.imager, PopVec[self]];
};
ApplySETXYREL: PUBLIC PROC [self: Ref] ~ {
Imager.SetXYRel[self.imager, PopVec[self]];
};
ApplySETXREL: PUBLIC PROC [self: Ref] ~ {
Imager.SetXRel[self.imager, PopReal[self]];
};
ApplySETYREL: PUBLIC PROC [self: Ref] ~ {
Imager.SetYRel[self.imager, PopReal[self]];
};
ApplyGETCP: PUBLIC PROC [self: Ref] ~ {
PushVec[self, ImagerBackdoor.GetCP[context: self.imager]];
};
ApplyGETCPROUNDED: PUBLIC PROC [self: Ref] ~ {
PushVec[self, ImagerBackdoor.GetCP[context: self.imager, rounded: TRUE]];
};

ApplyMAKEPIXELARRAY: PUBLIC PROC [self: Ref] ~ {
samples: Vector ~ PopVector[self];
m: Transformation ~ PopTransformation[self];
samplesInterleaved: BOOL ~ PopBool[self];
maxSampleValue: Vector _ IF TopType[self]=vector THEN PopVector[self] ELSE NIL;
maxSampleValueI: Integer ~ IF maxSampleValue=NIL THEN PopInteger[self] ELSE 0;
samplesPerPixel: Integer ~ PopInteger[self];
yPixels: Integer ~ PopInteger[self];
xPixels: Integer ~ PopInteger[self];
PushPixelArray[self, IPImager.MakePixelArray[
xPixels: xPixels, yPixels: yPixels, samplesPerPixel: samplesPerPixel,
maxSampleValue: maxSampleValue, maxSampleValueI: maxSampleValueI,
samplesInterleaved: samplesInterleaved, m: m, samples: samples]];
};
ApplyEXTRACTPIXELARRAY: PUBLIC PROC [self: Ref] ~ {
select: Vector ~ PopVector[self];
selectShape: VectorShape ~ Shape[select];
pa: PixelArray ~ PopPixelArray[self];
Select: PROC [i: NAT] RETURNS [NAT] ~ {RETURN [GetInteger[select, i]]};
IF selectShape.lowerBound#0 THEN MasterError[$misshapedVector, "EXTRACTPIXELARRAY select Vector should be origin zero."];
PushPixelArray[self, ImagerPixelArray.Extract[old: pa, samplesPerPixel: selectShape.size, select: Select]];
};
ApplyJOINPIXELARRAYS: PUBLIC PROC [self: Ref] ~ {
MasterError[$unimplemented, "JOINPIXELARRAYS is not implemented."];
};
ApplyFINDDECOMPRESSOR: PUBLIC PROC [self: Ref] ~ {
v: Vector ~ PopVector[self];
MasterError[$unimplemented, "FINDDECOMPRESSOR is not implemented."];
};
ApplyFINDCOLOR: PUBLIC PROC [self: Ref] ~ {
v: Vector ~ PopVector[self];
PushColor[self, IPImager.FindColor[self, v]];
};
ApplyFINDCOLOROPERATOR: PUBLIC PROC [self: Ref] ~ {
v: Vector ~ PopVector[self];
PushOperator[self, IPImager.FindColorOperator[self, v]];
};
ApplyFINDCOLORMODELOPERATOR: PUBLIC PROC [self: Ref] ~ {
v: Vector ~ PopVector[self];
PushOperator[self, IPImager.FindColorModelOperator[self, v]];
};
ApplyMAKEGRAY: PUBLIC PROC [self: Ref] ~ {
f: REAL ~ PopReal[self];
PushColor[self, Imager.MakeGray[f]];
};
ApplyMAKESAMPLEDCOLOR: PUBLIC PROC [self: Ref] ~ {
colorOperator: Operator ~ PopOperator[self];
um: Transformation ~ PopTransformation[self];
pa: PixelArray ~ PopPixelArray[self];
PushColor[self, ImagerColor.MakeSampledColor[pa, um, IPImager.ColorOperatorFromOperator[colorOperator]]];
};
ApplyMAKESAMPLEDBLACK: PUBLIC PROC [self: Ref] ~ {
clear: BOOL ~ PopBool[self];
um: Transformation ~ PopTransformation[self];
pa: PixelArray ~ PopPixelArray[self];
PushColor[self, ImagerColor.MakeSampledBlack[pa, um, clear]];
};
ApplySETGRAY: PUBLIC PROC [self: Ref] ~ {
f: REAL ~ PopReal[self];
Imager.SetGray[self.imager, f];
};

ApplyMOVETO: PUBLIC PROC [self: Ref] ~ {
p: VEC ~ PopVec[self];
PushTrajectory[self, ImagerPath.MoveTo[p]];
};
ApplyLINETO: PUBLIC PROC [self: Ref] ~ {
p: VEC ~ PopVec[self];
t: Trajectory ~ PopTrajectory[self];
PushTrajectory[self, ImagerPath.LineTo[t, p]];
};
ApplyLINETOX: PUBLIC PROC [self: Ref] ~ {
x: REAL ~ PopReal[self];
t: Trajectory ~ PopTrajectory[self];
PushTrajectory[self, ImagerPath.LineToX[t, x]];
};
ApplyLINETOY: PUBLIC PROC [self: Ref] ~ {
y: REAL ~ PopReal[self];
t: Trajectory ~ PopTrajectory[self];
PushTrajectory[self, ImagerPath.LineToY[t, y]];
};
ApplyCURVETO: PUBLIC PROC [self: Ref] ~ {
p3: VEC ~ PopVec[self];
p2: VEC ~ PopVec[self];
p1: VEC ~ PopVec[self];
t: Trajectory ~ PopTrajectory[self];
PushTrajectory[self, ImagerPath.CurveTo[t, p1, p2, p3]];
};
ApplyCONICTO: PUBLIC PROC [self: Ref] ~ {
r: REAL ~ PopReal[self];
p2: VEC ~ PopVec[self];
p1: VEC ~ PopVec[self];
t: Trajectory ~ PopTrajectory[self];
PushTrajectory[self, ImagerPath.ConicTo[t, p1, p2, r]];
};
ApplyARCTO: PUBLIC PROC [self: Ref] ~ {
p2: VEC ~ PopVec[self];
p1: VEC ~ PopVec[self];
t: Trajectory ~ PopTrajectory[self];
PushTrajectory[self, ImagerPath.ArcTo[t, p1, p2]];
};
ApplyMAKEOUTLINE: PUBLIC PROC [self: Ref] ~ {
n: Integer ~ PopInteger[self];
outline: Outline ~ NEW[OutlineRep[n]];
FOR i: NAT DECREASING IN[0..outline.size) DO outline[i] _ PopTrajectory[self] ENDLOOP;
PushOutline[self, outline];
};

ApplyMASKFILL: PUBLIC PROC [self: Ref] ~ {
o: Outline ~ PopOutline[self];
Imager.MaskFillOutline[context: self.imager, outline: o];
};
ApplyMASKFILLPARITY: PUBLIC PROC [self: Ref] ~ {
o: Outline ~ PopOutline[self];
Imager.MaskFillOutline[context: self.imager, outline: o, parity: TRUE];
};
ApplyMASKSTROKE: PUBLIC PROC [self: Ref] ~ {
t: Trajectory ~ PopTrajectory[self];
Imager.MaskStrokeTrajectory[context: self.imager, trajectory: t];
};
ApplyMASKSTROKECLOSED: PUBLIC PROC [self: Ref] ~ {
t: Trajectory ~ PopTrajectory[self];
Imager.MaskStrokeTrajectory[context: self.imager, trajectory: t, closed: TRUE];
};
ApplyMASKRECTANGLE: PUBLIC PROC [self: Ref] ~ {
h: REAL ~ PopReal[self]; w: REAL ~ PopReal[self];
y: REAL ~ PopReal[self]; x: REAL ~ PopReal[self];
Imager.MaskRectangle[self.imager, [x: x, y: y, w: w, h: h]];
};
ApplyMASKVECTOR: PUBLIC PROC [self: Ref] ~ {
p2: VEC ~ PopVec[self];
p1: VEC ~ PopVec[self];
Imager.MaskVector[self.imager, p1, p2];
};
ApplySTARTUNDERLINE: PUBLIC PROC [self: Ref] ~ {
Imager.StartUnderline[self.imager];
};
ApplyMASKUNDERLINE: PUBLIC PROC [self: Ref] ~ {
h: REAL ~ PopReal[self]; dy: REAL ~ PopReal[self];
Imager.MaskUnderline[self.imager, dy, h];
};
ApplyMASKTRAPEZOIDX: PUBLIC PROC [self: Ref] ~ {
x4: REAL ~ PopReal[self]; y3: REAL ~ PopReal[self]; x3: REAL ~ PopReal[self];
x2: REAL ~ PopReal[self]; y1: REAL ~ PopReal[self]; x1: REAL ~ PopReal[self];
path: ImagerPath.PathProc ~ {
moveTo[[x1, y1]]; lineTo[[x2, y1]]; lineTo[[x3, y3]]; lineTo[[x4, y3]];
};
Imager.MaskFill[self.imager, path];
};
ApplyMASKTRAPEZOIDY: PUBLIC PROC [self: Ref] ~ {
y4: REAL ~ PopReal[self]; y3: REAL ~ PopReal[self]; x3: REAL ~ PopReal[self];
y2: REAL ~ PopReal[self]; y1: REAL ~ PopReal[self]; x1: REAL ~ PopReal[self];
path: ImagerPath.PathProc ~ {
moveTo[[x1, y1]]; lineTo[[x3, y3]]; lineTo[[x3, y4]]; lineTo[[x1, y2]];
};
Imager.MaskFill[self.imager, path];
};
ApplyMASKPIXEL: PUBLIC PROC [self: Ref] ~ {
pa: PixelArray ~ PopPixelArray[self];
Imager.MaskPixel[self.imager, pa];
};
ApplyCLIPOUTLINE: PUBLIC PROC [self: Ref] ~ {
o: Outline ~ PopOutline[self];
Imager.ClipOutline[context: self.imager, outline: o];
};
ApplyEXCLUDEOUTLINE: PUBLIC PROC [self: Ref] ~ {
o: Outline ~ PopOutline[self];
Imager.ClipOutline[context: self.imager, outline: o, exclude: TRUE];
};
ApplyCLIPRECTANGLE: PUBLIC PROC [self: Ref] ~ {
h: REAL ~ PopReal[self]; w: REAL ~ PopReal[self];
y: REAL ~ PopReal[self]; x: REAL ~ PopReal[self];
Imager.ClipRectangle[context: self.imager, r: [x: x, y: y, w: w, h: h]];
};
ApplyEXCLUDERECTANGLE: PUBLIC PROC [self: Ref] ~ {
h: REAL ~ PopReal[self]; w: REAL ~ PopReal[self];
y: REAL ~ PopReal[self]; x: REAL ~ PopReal[self];
Imager.ClipRectangle[context: self.imager, r: [x: x, y: y, w: w, h: h], exclude: TRUE];
};

ApplyFINDFONT: PUBLIC PROC [self: Ref] ~ {
v: Vector ~ PopVector[self];
PushVector[self, IPImager.FindFont[self, v]];
};
ApplyFINDFONTVEC: PUBLIC PROC [self: Ref] ~ {
v: Vector ~ PopVector[self];
PushVector[self, IPImager.FindFontVec[self, v]];
};
ApplyMODIFYFONT: PUBLIC PROC [self: Ref] ~ {
m: Transformation ~ PopTransformation[self];
v: Vector ~ PopVector[self];
PushVector[self, IPImager.ModifyFont[v, m]];
};
ApplySETFONT: PUBLIC PROC [self: Ref] ~ {
n: Integer ~ PopInteger[self];
v: Vector ~ VectorFromAny[FGet[self, n]];
SetShowVec[self, v];
};

ApplyCORRECTMASK: PUBLIC PROC [self: Ref] ~ {
Imager.CorrectMask[self.imager];
};
ApplyCORRECTSPACE: PUBLIC PROC [self: Ref] ~ {
Imager.CorrectSpace[self.imager, PopVec[self]];
};
ApplyCORRECT: PUBLIC PROC [self: Ref] ~ {
frame: Vector ~ Frame[self];
pool: Pool ~ NoPool[];
env: Vector ~ Env[self];
index: INT ~ IO.GetIndex[self.stream];
action: PROC ~ {
showVec: Vector ~ self.showVec;
inner: PROC ~ { CallInlineBody[self: self, frame: frame, pool: pool, env: env] };
IO.SetIndex[self.stream, index];
DoWithMarkProtection[self, inner];
self.showVec _ showVec;
};
Imager.Correct[self.imager, action];
};
ApplySETCORRECTMEASURE: PUBLIC PROC [self: Ref] ~ {
Imager.SetCorrectMeasure[self.imager, PopVec[self]];
};
ApplySETCORRECTTOLERANCE: PUBLIC PROC [self: Ref] ~ {
Imager.SetCorrectTolerance[self.imager, PopVec[self]];
};
ApplySPACE: PUBLIC PROC [self: Ref] ~ {
Imager.Space[self.imager, PopReal[self]];
};
ApplyAMPLIFIEDSPACE: PUBLIC PROC [self: Ref] ~ {
x: REAL ~ PopReal[self];
amplifySpace: REAL ~ ImagerBackdoor.GetReal[self.imager, $amplifySpace];
Imager.Space[self.imager, x*amplifySpace];
};

END.
"IPImageImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Doug Wyatt, July 8, 1985 4:56:58 pm PDT
Michael Plass, January 3, 1986 12:57:26 pm PST
self.mediumSize _ xxx;
self.fieldMin _ xxx;
self.fieldMax _ xxx;
$strokeDashes => PushVector[self, self.strokeDashes];
$clipper => PushVector[self, VectorFromClipper[Imager.GetClipper[self.imager]]];
$clipper => Imager.SetClipper[self.imager, Pop[self]];
Crock for compatibility between 6.0 Imager and 3.0 Interpress standard.
PushOperator[self, FindDecompressor[self, v]];
Κj˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ'™'K™.—K˜š
Οk	˜	Kšœžœί˜λKšœžœA˜UKšœžœ&˜7Kšœžœh˜xKšœžœ˜-Kšœžœ‚
˜œ
Kšžœ
žœ˜Kšœžœ˜Kšœ	žœ™
˜§
KšœžœΎ˜ΡKšœ	žœ˜ Kšœžœžœ˜—K˜KšΠblœžœ
ž˜KšžœZžœ˜|Kšžœ˜Kšœžœ
žœ˜K˜Kšžœžœžœ
˜Kšœžœ'˜;Kšœžœ˜/Kšœžœ˜)Kšœ	žœ˜#Kšœžœ˜)K˜šΟn	œžœ6žœžœ˜aK™K™K™šžœžœ˜Kšžœ2˜6Kšžœ2˜6—K˜K˜—K˜Kšœžœ˜/šœžœžœžœ˜8K˜—š œžœžœ˜IKšžœžœ
žœžœD˜fKšžœ
žœ˜"K˜K˜—š 
œžœ
žœ
˜1Kšžœ˜K˜—š 
œžœ˜+Kš
œ˜Kšžœžœ
žœ%˜7K˜—š 	œžœ
žœ˜&K˜šžœž˜(Kš
œH˜HKš
œH˜HKš
œN˜NKš
œN˜NKš
œA˜AKš
œ`˜`Kš
œR˜RKš
œR˜RKš
œN˜NKš
œN˜NKš
œN˜NKš
œN˜NKš
œ/˜/Kš
œ@˜@Kš
œL˜LKš
œR˜RKš
œP˜PKš
œT˜TKš
œX˜XKš
œT˜TKš
œT˜TKš
œV˜VKš
œN˜NKš
œN˜NKš
œ5™5Kš
œP™PKšžœžœ
˜—K˜K˜—š 	œžœ
žœ˜&K˜šžœž˜(Kš
œG˜GKš
œG˜GKš
œM˜MKš
œM˜MKš
œ@˜@Kš
œ_˜_Kš
œQ˜QKš
œQ˜QKš
œM˜MKš
œM˜MKš
œM˜MKš
œM˜MKš
œ.˜.Kš
œ7˜7Kš
œK˜KKš
œQ˜QKš
œO˜OKš
œ]˜]Kš
œW˜WKš
œS˜SKš
œS˜SKš
œU˜UKš
œM˜MKš
œM˜MKš
œ6™6Kšžœžœ
˜—K˜—K˜Kšœžœ˜1š
 œžœžœžœžœ˜)K™GKšžœžœ˜Kšžœ˜Kš
œ˜K˜—š œžœ
žœ˜(Kšœžœ˜Kš
œ.˜.K˜—K˜š 
œžœ
žœ˜'Kšœžœžœžœ˜JKšœžœžœžœ˜JKš
œH˜HK˜—š 
œžœ
žœ˜'Kš
œ,˜,Kš
œ>˜>Kš
œ>˜>K˜—š œžœ
žœ˜+Kšœžœ˜Kš
œ<˜<K˜—š œžœ
žœ˜(Kšœžœ˜Kš
œ9˜9K˜—š 
œžœ
žœ˜'Kšœžœ˜Kš
œ8˜8K˜—š œžœ
žœ˜(Kšœžœ˜Kš
œ9˜9K˜—š œžœ
žœ˜(Kš
œ,˜,Kš
œ,˜,Kš
œ<˜<K˜—š œžœ
žœ˜(Kš
œ,˜,Kš
œ9˜9K˜—K˜š œžœ
žœ˜+Kš
œ,˜,Kšœžœ˜Kš
œ˜K˜—š œžœ
žœ˜.Kš
œ,˜,Kšœžœ˜Kš
œ!˜!K˜—š œžœ
žœ˜)Kš
œ,˜,Kšœžœ˜Kš
œ˜K˜—š œžœ
žœ˜,Kš
œ,˜,Kšœžœ˜Kš
œ˜K˜—K˜š œžœ
žœ˜)Kš
œ,˜,Kš
œ˜K˜—š 	œžœ
žœ˜&Kš
œ˜K˜—š 
œžœ
žœ˜'Kš
œ˜K˜—K˜š 	œžœ
žœ˜&Kš
œ˜K˜K˜—š œžœ
žœ˜-Kš
œ˜Kš
œ˜K˜—K˜š 
œžœ
žœ˜'Kš
œ(˜(K˜—š 
œžœ
žœ˜*Kš
œ+˜+K˜—š œžœ
žœ˜)Kš
œ+˜+K˜—š œžœ
žœ˜)Kš
œ+˜+K˜—š 
œžœ
žœ˜'Kš
œ:˜:K˜—š œžœ
žœ˜.KšœBžœ˜IK˜—K˜š œžœ
žœ˜0Kš
œ"˜"Kš
œ,˜,Kšœžœ˜)Kš	œžœžœžœ
žœ
˜OKš	œžœžœ
žœžœ˜NKš
œ,˜,Kš
œ$˜$Kš
œ$˜$Kš
œχ
˜χ
K˜—š œžœ
žœ˜3Kš
œ!˜!Kš
œ)˜)Kš
œ%˜%Kš œžœžœžœžœžœ˜GKšžœžœY˜yKš
œk˜kK˜—š œžœ
žœ˜1Kš
œC˜CK˜—š œžœ
žœ˜2Kš
œ˜Kš
œ.™.Kš
œD˜DK˜—š œžœ
žœ˜+Kš
œ˜Kš
œ-˜-K˜—š œžœ
žœ˜3Kš
œ˜Kš
œ8˜8K˜—š œžœ
žœ˜8Kš
œ˜Kš
œ=˜=K˜—š 
œžœ
žœ˜*Kšœžœ˜Kš
œ$˜$K˜—š œžœ
žœ˜2Kš
œ,˜,Kš
œ-˜-Kš
œ%˜%Kš
œi˜iK˜—š œžœ
žœ˜2Kšœžœ˜Kš
œ-˜-Kš
œ%˜%Kš
œ=˜=K˜—š œžœ
žœ˜)Kšœžœ˜K˜K˜—K˜š œžœ
žœ˜(Kšœžœ˜Kš
œ+˜+K˜—š œžœ
žœ˜(Kšœžœ˜Kš
œ$˜$Kš
œ.˜.K˜—š œžœ
žœ˜)Kšœžœ˜Kš
œ$˜$Kš
œ/˜/K˜—š œžœ
žœ˜)Kšœžœ˜Kš
œ$˜$Kš
œ/˜/K˜—š œžœ
žœ˜)Kšœžœ˜Kšœžœ˜Kšœžœ˜Kš
œ$˜$Kš
œ8˜8K˜—š œžœ
žœ˜)Kšœžœ˜Kšœžœ˜Kšœžœ˜Kš
œ$˜$Kš
œ7˜7K˜—š 
œžœ
žœ˜'Kšœžœ˜Kšœžœ˜Kš
œ$˜$Kš
œ2˜2K˜—š œžœ
žœ˜-Kš
œ˜Kšœžœ˜&Kšžœžœ
ž
œ
žœžœ"žœ
˜VKš
œ˜K˜—K˜š 
œžœ
žœ˜*Kš
œ˜Kš
œ9˜9K˜—š œžœ
žœ˜0Kš
œ˜KšœAžœ˜GK˜—š œžœ
žœ˜,Kš
œ$˜$Kš
œA˜AK˜—š œžœ
žœ˜2Kš
œ$˜$KšœIžœ˜OK˜—š œžœ
žœ˜/Kšœžœžœ˜1Kšœžœžœ˜1K˜<K˜—š œžœ
žœ˜,Kšœžœ˜Kšœžœ˜K˜'K˜—š œžœ
žœ˜0Kš
œ#˜#K˜—š œžœ
žœ˜/Kšœžœžœ˜2Kš
œ)˜)K˜—š œžœ
žœ˜0Kšœžœžœžœ˜MKšœžœžœžœ˜M˜K˜GK˜—K˜#K˜—š œžœ
žœ˜0Kšœžœžœžœ˜MKšœžœžœžœ˜M˜K˜GK˜—K˜#K˜—š œžœ
žœ˜+Kš
œ%˜%K˜"K˜—š œžœ
žœ˜-Kš
œ˜Kš
œ5˜5K˜—š œžœ
žœ˜0Kš
œ˜Kšœ>žœ˜DK˜—š œžœ
žœ˜/Kšœžœžœ˜1Kšœžœžœ˜1Kš
œH˜HK˜—š œžœ
žœ˜2Kšœžœžœ˜1Kšœžœžœ˜1KšœQžœ˜WK˜—K˜š 
œžœ
žœ˜*Kš
œ˜Kš
œ-˜-K˜—š œžœ
žœ˜-Kš
œ˜Kš
œ0˜0K˜—š œžœ
žœ˜,Kš
œ,˜,Kš
œ˜Kš
œ,˜,K˜—š œžœ
žœ˜)Kš
œ˜Kš
œ)˜)K˜K˜—K˜š œžœ
žœ˜-K˜ K˜—š œžœ
žœ˜.Kš
œ/˜/K˜—š œžœ
žœ˜)K˜K˜K˜Kšœžœžœ˜&šœžœ˜Kš
œ˜KšœžœF˜QKšžœ˜ Kš
œ"˜"Kš
œ˜Kš
œ˜—Kš
œ$˜$K˜—š œžœ
žœ˜3Kš
œ4˜4K˜—š œžœ
žœ˜5Kš
œ6˜6K˜—š 
œžœ
žœ˜'Kš
œ)˜)K˜—š œžœ
žœ˜0Kšœžœ˜Kšœžœ6˜HKš
œ*˜*K˜—K˜Kšžœ
˜—…—HZ¦