DIRECTORY
Char, Imager, ImagerBackdoor, ImagerBox, ImagerColor, ImagerFont, ImagerPath, ImagerPixelArray, ImagerPixelArrayAIS, ImagerTransformation, JaM, JaMIPrivate, Vector2;

JaMImagerImpl: CEDAR PROGRAM
IMPORTS Char, Imager, ImagerBackdoor, ImagerColor, ImagerFont, ImagerPath, ImagerPixelArrayAIS, ImagerTransformation, JaM, JaMIPrivate
EXPORTS JaMIPrivate
~ BEGIN OPEN JaM;

VEC: TYPE ~ Vector2.VEC;
Outline: TYPE ~ ImagerPath.Outline;

PopVec: PROC [self: State] RETURNS [VEC] ~ {
y: REAL ~ PopReal[self]; x: REAL ~ PopReal[self];
RETURN[[x, y]];
};
PopRectangle: PROC [self: State] RETURNS [ImagerBox.Rectangle] ~ {
h: REAL ~ PopReal[self]; w: REAL ~ PopReal[self];
y: REAL ~ PopReal[self]; x: REAL ~ PopReal[self];
RETURN[[x, y, w, h]];
};
PopFont: PROC [self: State] RETURNS [ImagerFont.Font] ~ {
x: Any ~ Pop[self];
WITH x SELECT FROM
x: ImagerFont.Font => RETURN[x];
ENDCASE => ERROR JaM.Error[WrongType];
};
PopTransformation: PROC [self: State] RETURNS [ImagerTransformation.Transformation] ~ {
x: Any ~ Pop[self];
WITH x SELECT FROM
x: ImagerTransformation.Transformation => RETURN[x];
ENDCASE => ERROR JaM.Error[WrongType];
};
PopPixelArray: PROC [self: State] RETURNS [ImagerPixelArray.PixelArray] ~ {
x: Any ~ Pop[self];
WITH x SELECT FROM
x: ImagerPixelArray.PixelArray => RETURN[x];
ENDCASE => ERROR JaM.Error[WrongType];
};
PopColor: PROC [self: State] RETURNS [ImagerColor.Color] ~ {
x: Any ~ Pop[self];
WITH x SELECT FROM
x: ImagerColor.Color => RETURN[x];
x: ImagerColor.ConstantColor => RETURN[x];
ENDCASE => ERROR JaM.Error[WrongType];
};
PopColorOperator: PROC [self: State] RETURNS [ImagerColor.ColorOperator] ~ {
x: Any ~ Pop[self];
WITH x SELECT FROM
x: ImagerColor.ColorOperator => RETURN[x];
ENDCASE => ERROR JaM.Error[WrongType];
};
PopTrajectory: PROC [self: State] RETURNS [ImagerPath.Trajectory] ~ {
x: Any ~ Pop[self];
WITH x SELECT FROM
x: ImagerPath.Trajectory => RETURN[x];
ENDCASE => ERROR JaM.Error[WrongType];
};
PopOutline: PROC [self: State] RETURNS [Outline] ~ {
x: Any ~ Pop[self];
WITH x SELECT FROM
x: Outline => RETURN[x];
ENDCASE => ERROR JaM.Error[WrongType];
};
PushVec: PROC [self: State, v: VEC] ~ {
PushReal[self, v.x]; PushReal[self, v.y];
};
PushRectangle: PROC [self: State, r: ImagerBox.Rectangle] ~ {
PushReal[self, r.x]; PushReal[self, r.y];
PushReal[self, r.w]; PushReal[self, r.h];
};
PushFont: PROC [self: State, x: ImagerFont.Font] ~ {
IF x#NIL THEN Push[self, x]
ELSE ERROR JaM.Error[WrongType];
};
PushTransformation: PROC [self: State, x: ImagerTransformation.Transformation] ~ {
IF x#NIL THEN Push[self, x]
ELSE ERROR JaM.Error[WrongType];
};
PushColor: PROC [self: State, x: ImagerColor.Color] ~ {
IF x#NIL THEN Push[self, x]
ELSE ERROR JaM.Error[WrongType];
};
PushColorOperator: PROC [self: State, x: ImagerColor.ColorOperator] ~ {
IF x#NIL THEN Push[self, x]
ELSE ERROR JaM.Error[WrongType];
};
PushPixelArray: PROC [self: State, x: ImagerPixelArray.PixelArray] ~ {
IF x#NIL THEN Push[self, x]
ELSE ERROR JaM.Error[WrongType];
};
PushTrajectory: PROC [self: State, x: ImagerPath.Trajectory] ~ {
IF x#NIL THEN Push[self, x]
ELSE ERROR JaM.Error[WrongType];
};
PushOutline: PROC [self: State, x: Outline] ~ {
IF x#NIL THEN Push[self, x]
ELSE ERROR JaM.Error[WrongType];
};

GetContext: PROC [self: State] RETURNS [Imager.Context] ~ {
info: JaMIPrivate.Info ¬ JaMIPrivate.GetInfo[self];
IF info = NIL THEN ERROR;
IF info.ipenabled THEN RETURN [info.ipdc];
RETURN[info.vdc];
};
GetInfoFromState: PROC [self: State] RETURNS [JaMIPrivate.Info] ~ {
info: JaMIPrivate.Info ¬ JaMIPrivate.GetInfo[self];
IF info = NIL THEN ERROR;
RETURN[info];
};


ApplyDoSave: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
x: Any ~ Pop[self];
action: PROC ~ { Execute[self, x] };
Imager.DoSave[context, action];
};
ApplyDoSaveAll: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
x: Any ~ Pop[self];
action: PROC ~ { Execute[self, x] };
Imager.DoSaveAll[context, action];
};


ApplyDRound: PUBLIC PROC [self: State] ~ {
p: VEC ~ PopVec[self];
PushVec[self, ImagerTransformation.DRound[p]];
};
ApplyMakeT: PUBLIC PROC [self: State] ~ {
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: State] ~ {
m: ImagerTransformation.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: State] ~ {
t: VEC ~ PopVec[self];
PushTransformation[self, ImagerTransformation.Translate[t]];
};
ApplyRotate: PUBLIC PROC [self: State] ~ {
a: REAL ~ PopReal[self];
PushTransformation[self, ImagerTransformation.Rotate[a]];
};
ApplyScale: PUBLIC PROC [self: State] ~ {
s: REAL ~ PopReal[self];
PushTransformation[self, ImagerTransformation.Scale[s]];
};
ApplyScale2: PUBLIC PROC [self: State] ~ {
s: VEC ~ PopVec[self];
PushTransformation[self, ImagerTransformation.Scale2[s]];
};
ApplyConcat: PUBLIC PROC [self: State] ~ {
n: ImagerTransformation.Transformation ~ PopTransformation[self];
m: ImagerTransformation.Transformation ~ PopTransformation[self];
PushTransformation[self, ImagerTransformation.Concat[m, n]];
};
ApplyInvert: PUBLIC PROC [self: State] ~ {
m: ImagerTransformation.Transformation ~ PopTransformation[self];
PushTransformation[self, ImagerTransformation.Invert[m]];
};

ApplyTransform: PUBLIC PROC [self: State] ~ {
m: ImagerTransformation.Transformation ~ PopTransformation[self];
p: VEC ~ PopVec[self];
PushVec[self, m.Transform[p]];
};
ApplyTransformVec: PUBLIC PROC [self: State] ~ {
m: ImagerTransformation.Transformation ~ PopTransformation[self];
v: VEC ~ PopVec[self];
PushVec[self, m.TransformVec[v]];
};
ApplyRoundXY: PUBLIC PROC [self: State] ~ {
m: ImagerTransformation.Transformation ~ PopTransformation[self];
p: VEC ~ PopVec[self];
PushVec[self, m.RoundXY[p]];
};
ApplyRoundXYVec: PUBLIC PROC [self: State] ~ {
m: ImagerTransformation.Transformation ~ PopTransformation[self];
v: VEC ~ PopVec[self];
PushVec[self, m.RoundXYVec[v]];
};

ApplyConcatT: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
m: ImagerTransformation.Transformation ~ PopTransformation[self];
Imager.ConcatT[context, m];
};
ApplyScaleT: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
s: REAL ~ PopReal[self];
Imager.ScaleT[context, s];
};
ApplyScale2T: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
s: VEC ~ PopVec[self];
Imager.Scale2T[context, s];
};
ApplyRotateT: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
a: REAL ~ PopReal[self];
Imager.RotateT[context, a];
};
ApplyTranslateT: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
t: VEC ~ PopVec[self];
Imager.TranslateT[context, t];
};
ApplyMove: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.Move[context];
};
ApplyTrans: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.Trans[context];
};

ApplySetXY: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.SetXY[context, PopVec[self]];
};
ApplySetXYRel: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.SetXYRel[context, PopVec[self]];
};
ApplySetXRel: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.SetXRel[context, PopReal[self]];
};
ApplySetYRel: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.SetYRel[context, PopReal[self]];
};
ApplyGetCP: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
PushVec[self, ImagerBackdoor.GetCP[context: context]];
};
ApplyGetCPRounded: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
PushVec[self, ImagerBackdoor.GetCP[context: context, rounded: TRUE]];
};

ApplyFindFont: PUBLIC PROC [self: State] ~ {
name: ROPE ~ PopRope[self];
PushFont[self, ImagerFont.Find[name]];
};
ApplyModifyFont: PUBLIC PROC [self: State] ~ {
m: ImagerTransformation.Transformation ~ PopTransformation[self];
font: ImagerFont.Font ~ PopFont[self];
PushFont[self, ImagerFont.Modify[font, m]];
};
ApplyScaleFont: PUBLIC PROC [self: State] ~ {
s: REAL ~ PopReal[self];
font: ImagerFont.Font ~ PopFont[self];
PushFont[self, ImagerFont.Scale[font, s]];
};
ApplySetFont: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
font: ImagerFont.Font ~ PopFont[self];
info: JaMIPrivate.Info ~ GetInfoFromState[self];
Imager.SetFont[context, font];
info.font ¬ font;
};
ApplyGetBoundingBox: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
font: ImagerFont.Font ~ GetInfoFromState[self].font;
extents: ImagerFont.Extents ~ ImagerFont.FontBoundingBox[font];
PushReal[self, extents.leftExtent]; PushReal[self, extents.descent];
PushReal[self, extents.rightExtent]; PushReal[self, extents.ascent];
};
ApplyGetTextBox: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
font: ImagerFont.Font ~ GetInfoFromState[self].font;
rope: ROPE ~ PopRope[self];
extents: ImagerFont.Extents ~ ImagerFont.RopeBoundingBox[font, rope];
PushReal[self, extents.leftExtent]; PushReal[self, extents.descent];
PushReal[self, extents.rightExtent]; PushReal[self, extents.ascent];
};
ApplySetAmplifySpace: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.SetAmplifySpace[context, PopReal[self]];
};
ApplyShowRope: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
rope: ROPE ~ PopRope[self];
Imager.ShowRope[context, rope];
};
ApplyShowXChar: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
lo: CARDINAL ~ PopInt[self];
hi: CARDINAL ~ PopInt[self];
xchar: ImagerFont.XChar ~ Char.Make[set: hi, code: lo];
Imager.ShowXChar[context, xchar];
};
ApplyStartUnderline: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.StartUnderline[context];
};
ApplyMaskUnderline: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
h: REAL ~ PopReal[self]; dy: REAL ~ PopReal[self];
Imager.MaskUnderline[context, dy, h];
};

ApplyCorrectMask: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.CorrectMask[context];
};
ApplyCorrectSpace: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.CorrectSpace[context, PopVec[self]];
};
ApplySpace: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.Space[context, PopReal[self]];
};
ApplyAmplifiedSpace: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
x: REAL ~ PopReal[self];
amplifySpace: REAL ~ ImagerBackdoor.GetReal[context, $amplifySpace];
Imager.Space[context, x*amplifySpace];
};
ApplySetCorrectMeasure: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.SetCorrectMeasure[context, PopVec[self]];
};
ApplySetCorrectTolerance: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.SetCorrectTolerance[context, PopVec[self]];
};
ApplySetCorrectShrink: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.SetCorrectShrink[context, PopReal[self]];
};

ApplyCorrect: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
x: Any ~ Pop[self];
action: PROC ~ { Execute[self, x] };
Imager.Correct[context, action];
};
ApplyDontCorrect: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
saveCP: BOOL ~ PopBool[self];
x: Any ~ Pop[self];
action: PROC ~ { Execute[self, x] };
Imager.DontCorrect[context, action, saveCP];
};

ApplySetColor: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
color: ImagerColor.Color ~ PopColor[self];
Imager.SetColor[context, color];
};
ApplyMakeGray: PUBLIC PROC [self: State] ~ {
f: REAL ~ PopReal[self];
PushColor[self, Imager.MakeGray[f]];
};
ApplySetGray: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
f: REAL ~ PopReal[self];
Imager.SetGray[context, f];
};
ApplyMakeGrayLinearColorModel: PUBLIC PROC [self: State] ~ {
colorOperator: ImagerColor.ColorOperator ~ ImagerColor.NewColorOperatorGrayLinear[255, 0, 256];
PushColorOperator[self, colorOperator];
};
ApplyMakeRGBLinearColorModel: PUBLIC PROC [self: State] ~ {
colorOperator: ImagerColor.ColorOperator ~ ImagerColor.NewColorOperatorRGB[255];
PushColorOperator[self, colorOperator];
};
ApplyMakePixelArrayFromAIS: PUBLIC PROC [self: State] ~ {
name: ROPE ~ PopRope[self];
PushPixelArray[self, ImagerPixelArrayAIS.FromAIS[name]];
};
ApplyMakePixelArrayJoin3AIS: PUBLIC PROC [self: State] ~ {
name3: ROPE ~ PopRope[self];
name2: ROPE ~ PopRope[self];
name1: ROPE ~ PopRope[self];
PushPixelArray[self, ImagerPixelArrayAIS.Join3AIS[name1, name2, name3]];
};
ApplyPixelArrayBounds: PUBLIC PROC [self: State] ~ {
pa: ImagerPixelArray.PixelArray ~ PopPixelArray[self];
r: ImagerBox.Rectangle ~ ImagerTransformation.TransformRectangle[pa.m, [0, 0, pa.sSize, pa.fSize]];
PushRectangle[self, r];
};
ApplyPixelArraySamplesPerPixel: PUBLIC PROC [self: State] ~ {
pa: ImagerPixelArray.PixelArray ~ PopPixelArray[self];
PushInt[self, pa.samplesPerPixel];
};


ApplyMakeSampledColor: PUBLIC PROC [self: State] ~ {
colorOperator: ImagerColor.ColorOperator ~ PopColorOperator[self];
um: ImagerTransformation.Transformation ~ PopTransformation[self];
pa: ImagerPixelArray.PixelArray ~ PopPixelArray[self];
PushColor[self, ImagerColor.MakeSampledColor[pa, um, colorOperator]];
};
ApplyMakeSampledBlack: PUBLIC PROC [self: State] ~ {
clear: BOOL ~ PopBool[self];
um: ImagerTransformation.Transformation ~ PopTransformation[self];
pa: ImagerPixelArray.PixelArray ~ PopPixelArray[self];
PushColor[self, ImagerColor.MakeSampledBlack[pa, um, clear]];
};
ApplySetSampledColor: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
colorOperator: ImagerColor.ColorOperator ~ PopColorOperator[self];
m: ImagerTransformation.Transformation ~ PopTransformation[self];
pa: ImagerPixelArray.PixelArray ~ PopPixelArray[self];
Imager.SetSampledColor[context, pa, m, colorOperator];
};
ApplySetSampledBlack: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
clear: BOOL ~ PopBool[self];
m: ImagerTransformation.Transformation ~ PopTransformation[self];
pa: ImagerPixelArray.PixelArray ~ PopPixelArray[self];
Imager.SetSampledBlack[context, pa, m, clear];
};

ApplyLastPoint: PUBLIC PROC [self: State] ~ {
t: ImagerPath.Trajectory ~ PopTrajectory[self];
PushVec[self, ImagerPath.LastPoint[t]];
};
ApplyMoveTo: PUBLIC PROC [self: State] ~ {
p: VEC ~ PopVec[self];
PushTrajectory[self, ImagerPath.MoveTo[p]];
};
ApplyLineTo: PUBLIC PROC [self: State] ~ {
p: VEC ~ PopVec[self];
t: ImagerPath.Trajectory ~ PopTrajectory[self];
PushTrajectory[self, ImagerPath.LineTo[t, p]];
};
ApplyLineToX: PUBLIC PROC [self: State] ~ {
x: REAL ~ PopReal[self];
t: ImagerPath.Trajectory ~ PopTrajectory[self];
PushTrajectory[self, ImagerPath.LineToX[t, x]];
};
ApplyLineToY: PUBLIC PROC [self: State] ~ {
y: REAL ~ PopReal[self];
t: ImagerPath.Trajectory ~ PopTrajectory[self];
PushTrajectory[self, ImagerPath.LineToY[t, y]];
};
ApplyCurveTo: PUBLIC PROC [self: State] ~ {
p3: VEC ~ PopVec[self];
p2: VEC ~ PopVec[self];
p1: VEC ~ PopVec[self];
t: ImagerPath.Trajectory ~ PopTrajectory[self];
PushTrajectory[self, ImagerPath.CurveTo[t, p1, p2, p3]];
};
ApplyConicTo: PUBLIC PROC [self: State] ~ {
r: REAL ~ PopReal[self];
p2: VEC ~ PopVec[self];
p1: VEC ~ PopVec[self];
t: ImagerPath.Trajectory ~ PopTrajectory[self];
PushTrajectory[self, ImagerPath.ConicTo[t, p1, p2, r]];
};
ApplyArcTo: PUBLIC PROC [self: State] ~ {
p2: VEC ~ PopVec[self];
p1: VEC ~ PopVec[self];
t: ImagerPath.Trajectory ~ PopTrajectory[self];
PushTrajectory[self, ImagerPath.ArcTo[t, p1, p2]];
};
MakeOutline: PROC [self: State, odd: BOOL ¬ FALSE] ~ {
n: INT ~ PopInt[self];
outline: Outline ~ NEW[ImagerPath.OutlineRep[n]];
outline.oddWrap ¬ odd;
FOR i: NAT DECREASING IN[0..outline.size) DO outline[i] ¬ PopTrajectory[self] ENDLOOP;
PushOutline[self, outline];
};
ApplyMakeOutline: PUBLIC PROC [self: State] ~ { MakeOutline[self] };
ApplyMakeOutlineOdd: PUBLIC PROC [self: State] ~ { MakeOutline[self, TRUE] };

MaskFill: PROC [self: State, oddWrap: BOOL ¬ FALSE] ~ {
context: Imager.Context ~ GetContext[self];
o: Outline ~ PopOutline[self];
path: ImagerPath.PathProc ~ {
FOR i: NAT IN[0..o.size) DO
ImagerPath.MapTrajectory[o[i], moveTo, lineTo, curveTo, conicTo, arcTo];
ENDLOOP;
};
Imager.MaskFill[context: context, path: path, oddWrap: o.oddWrap OR oddWrap];
};
ApplyMaskFill: PUBLIC PROC [self: State] ~ { MaskFill[self] };
ApplyMaskFillParity: PUBLIC PROC [self: State] ~ { MaskFill[self, TRUE] };
ApplySetStrokeWidth: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.SetStrokeWidth[context, PopReal[self]];
};
ApplySetStrokeEnd: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
ImagerBackdoor.SetInt[context, $strokeEnd, PopInt[self]];
};
ApplySetStrokeJoint: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
feature: INT ¬ PopInt[self];
ImagerBackdoor.SetInt[context, $strokeJoint, feature];
};
ApplyMaskStroke: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
t: ImagerPath.Trajectory ~ PopTrajectory[self];
Imager.MaskStrokeTrajectory[context: context, trajectory: t];
};
ApplyMaskStrokeClosed: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
t: ImagerPath.Trajectory ~ PopTrajectory[self];
Imager.MaskStrokeTrajectory[context: context, trajectory: t, closed: TRUE];
};
NarrowToReal: PROC [any: REF ANY] RETURNS [REAL] ~ {
WITH any SELECT FROM
real: REF REAL => RETURN [real­];
int: REF INT => RETURN [int­];
ENDCASE => ERROR Error[WrongType, "wrong type (pattern array must be numeric)"];
};
ApplyMaskDashedStroke: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
length: REAL ~ PopReal[self];
offset: REAL ~ PopReal[self];
pattern: Array ~ PopArray[self];
pGet: PROC [i: NAT] RETURNS [REAL] ~ { RETURN[NarrowToReal[AGet[pattern, i]]] };
t: ImagerPath.Trajectory ~ PopTrajectory[self];
path: ImagerPath.PathProc ~ { ImagerPath.MapTrajectory[trajectory: t, 
moveTo: moveTo, lineTo: lineTo, curveTo: curveTo, conicTo: conicTo, arcTo: arcTo] };
Imager.MaskDashedStroke[context: context, path: path, patternLen: pattern.length, pattern: pGet, offset: offset, length: length];
};
ApplyMaskFillTrajectory: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
t: ImagerPath.Trajectory ~ PopTrajectory[self];
Imager.MaskFillTrajectory[context: context, trajectory: t];
};
ApplyMaskFillTrajectoryParity: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
t: ImagerPath.Trajectory ~ PopTrajectory[self];
Imager.MaskFillTrajectory[context: context, trajectory: t, oddWrap: TRUE];
};
ApplyMaskRectangle: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.MaskRectangle[context, PopRectangle[self]];
};
ApplyMaskBox: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
ymax: REAL ~ PopReal[self]; xmax: REAL ~ PopReal[self];
ymin: REAL ~ PopReal[self]; xmin: REAL ~ PopReal[self];
Imager.MaskBox[context, [xmin, ymin, xmax, ymax]];
};
ApplyMaskVector: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
p2: VEC ~ PopVec[self]; p1: VEC ~ PopVec[self];
Imager.MaskVector[context, p1, p2];
};
ApplyMaskPixel: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
pa: ImagerPixelArray.PixelArray ~ PopPixelArray[self];
Imager.MaskPixel[context, pa];
};
ApplySetPriorityImportant: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.SetPriorityImportant[context, PopBool[self]];
};
ApplySetNoImage: PUBLIC PROC [self: State] ~ {
context: Imager.Context ~ GetContext[self];
Imager.SetNoImage[context, PopBool[self]];
};

ClipOutline: PROC [self: State, exclude: BOOL ¬ FALSE] ~ {
context: Imager.Context ~ GetContext[self];
o: Outline ~ PopOutline[self];
path: ImagerPath.PathProc ~ {
FOR i: NAT IN[0..o.size) DO
ImagerPath.MapTrajectory[o[i], moveTo, lineTo, curveTo, conicTo, arcTo];
ENDLOOP;
};
Imager.Clip[context: context, path: path, oddWrap: o.oddWrap, exclude: exclude];
};
ApplyClipOutline: PUBLIC PROC [self: State] ~ { ClipOutline[self] };
ApplyExcludeOutline: PUBLIC PROC [self: State] ~ { ClipOutline[self, TRUE] };
ClipRectangle: PROC [self: State, exclude: BOOL ¬ FALSE] ~ {
context: Imager.Context ~ GetContext[self];
r: ImagerBox.Rectangle ~ PopRectangle[self];
Imager.ClipRectangle[context: context, r: r, exclude: exclude];
};
ApplyClipRectangle: PUBLIC PROC [self: State] ~ { ClipRectangle[self] };
ApplyExcludeRectangle: PUBLIC PROC [self: State] ~ { ClipRectangle[self, TRUE] };

RegisterImager: PUBLIC PROC [self: State] ~ {
Register[self, ".dosave", ApplyDoSave];
Register[self, ".dosaveall", ApplyDoSaveAll];
Register[self, ".dround", ApplyDRound];
Register[self, ".maket", ApplyMakeT];
Register[self, ".opent", ApplyOpenT];
Register[self, ".translate", ApplyTranslate];
Register[self, ".rotate", ApplyRotate];
Register[self, ".scale", ApplyScale];
Register[self, ".scale2", ApplyScale2];
Register[self, ".concat", ApplyConcat];
Register[self, ".invert", ApplyInvert];
Register[self, ".transform", ApplyTransform];
Register[self, ".transformvec", ApplyTransformVec];
Register[self, ".roundxy", ApplyRoundXY];
Register[self, ".roundxyvec", ApplyRoundXYVec];
Register[self, ".concatt", ApplyConcatT];
Register[self, ".scalet", ApplyScaleT];
Register[self, ".scale2t", ApplyScale2T];
Register[self, ".rotatet", ApplyRotateT];
Register[self, ".translatet", ApplyTranslateT];
Register[self, ".move", ApplyMove];
Register[self, ".trans", ApplyTrans];
Register[self, ".setxy", ApplySetXY];
Register[self, ".setxyrel", ApplySetXYRel];
Register[self, ".setxrel", ApplySetXRel];
Register[self, ".setyrel", ApplySetYRel];
Register[self, ".getcp", ApplyGetCP];
Register[self, ".getcprounded", ApplyGetCPRounded];
Register[self, ".findfont", ApplyFindFont];
Register[self, ".modifyfont", ApplyModifyFont];
Register[self, ".scalefont", ApplyScaleFont];
Register[self, ".setfont", ApplySetFont];
Register[self, ".fontbox", ApplyGetBoundingBox];
Register[self, ".textbox", ApplyGetTextBox];

Register[self, ".setamplifyspace", ApplySetAmplifySpace];
Register[self, ".showrope", ApplyShowRope];
Register[self, ".showxchar", ApplyShowXChar];
Register[self, ".startunderline", ApplyStartUnderline];
Register[self, ".maskunderline", ApplyMaskUnderline];
Register[self, ".correctmask", ApplyCorrectMask];
Register[self, ".correctspace", ApplyCorrectSpace];
Register[self, ".space", ApplySpace];
Register[self, ".amplifiedspace", ApplyAmplifiedSpace];
Register[self, ".setcorrectmeasure", ApplySetCorrectMeasure];
Register[self, ".setcorrecttolerance", ApplySetCorrectTolerance];
Register[self, ".setcorrectshrink", ApplySetCorrectShrink];
Register[self, ".correct", ApplyCorrect];
Register[self, ".dontcorrect", ApplyDontCorrect];
Register[self, ".setcolor", ApplySetColor];
Register[self, ".makegray", ApplyMakeGray];
Register[self, ".setgray", ApplySetGray];
Register[self, ".graylinearcolormodel", ApplyMakeGrayLinearColorModel];
Register[self, ".rgblinearcolormodel", ApplyMakeRGBLinearColorModel];
Register[self, ".pixelarrayfromais", ApplyMakePixelArrayFromAIS];
Register[self, ".pixelarrayfrom3ais", ApplyMakePixelArrayJoin3AIS];
Register[self, ".pixelarraybounds", ApplyPixelArrayBounds];
Register[self, ".pixelarraysamplesperpixel", ApplyPixelArraySamplesPerPixel];
Register[self, ".makesampledcolor", ApplyMakeSampledColor];
Register[self, ".makesampledblack", ApplyMakeSampledBlack];
Register[self, ".setsampledcolor", ApplySetSampledColor];
Register[self, ".setsampledblack", ApplySetSampledBlack];
Register[self, ".lastpoint", ApplyLastPoint];
Register[self, ".moveto", ApplyMoveTo];
Register[self, ".lineto", ApplyLineTo];
Register[self, ".linetox", ApplyLineToX];
Register[self, ".linetoy", ApplyLineToY];
Register[self, ".curveto", ApplyCurveTo];
Register[self, ".conicto", ApplyConicTo];
Register[self, ".arcto", ApplyArcTo];
Register[self, ".makeoutline", ApplyMakeOutline];
Register[self, ".makeoutlineodd", ApplyMakeOutlineOdd];
Register[self, ".maskfill", ApplyMaskFill];
Register[self, ".maskfillparity", ApplyMaskFillParity];
Register[self, ".maskfilltrajectory", ApplyMaskFillTrajectory];
Register[self, ".maskfilltrajectoryparity", ApplyMaskFillTrajectoryParity];
Register[self, ".setstrokewidth", ApplySetStrokeWidth];
Register[self, ".setstrokeend", ApplySetStrokeEnd];
Register[self, ".setstrokejoint", ApplySetStrokeJoint];
Register[self, ".maskstroke", ApplyMaskStroke];
Register[self, ".maskstrokeclosed", ApplyMaskStrokeClosed];
Register[self, ".maskdashedstroke", ApplyMaskDashedStroke];
Register[self, ".maskrectangle", ApplyMaskRectangle];
Register[self, ".maskbox", ApplyMaskBox];
Register[self, ".maskvector", ApplyMaskVector];
Register[self, ".maskpixel", ApplyMaskPixel];
Register[self, ".setpriorityimportant", ApplySetPriorityImportant];
Register[self, ".setnoimage", ApplySetNoImage];
Register[self, ".clipoutline", ApplyClipOutline];
Register[self, ".excludeoutline", ApplyExcludeOutline];
Register[self, ".cliprectangle", ApplyClipRectangle];
Register[self, ".excluderectangle", ApplyExcludeRectangle];
};


END.

~
JaMImagerImpl.mesa
Copyright Σ 1985, 1986, 1987, 1992 by Xerox Corporation.  All rights reserved.
Michael Plass, October 8, 1987 4:41:24 pm PDT
Tim Diebert: August 1, 1985 12:59:51 pm PDT
Doug Wyatt, August 7, 1986 11:28:07 am PDT
Last edited by: Mik Lamming - December 23, 1986 2:45:18 pm PST
Rick Beach, March 22, 1987 10:13:24 pm PST
Bier, September 15, 1992 5:18 pm PDT
Κι–
"cedarcode" style•NewlineDelimiter

™
codeš
œ™Kšœ
Οe
œC™NK™-K™+Kš
œ*™*K™>K™*K™$—K˜š
Οk	˜	J˜₯
—K˜KšΠbl
œžœ
ž˜Jšžœ
œ~˜†
Kšžœ˜Kšœžœ
žœ˜K˜Kšžœžœžœ
˜Kšœ	žœ˜#K˜šΟnœžœžœžœ˜,Kšœžœžœ˜1Kšžœ	˜K˜—š œžœžœ˜BKšœžœžœ˜1Kšœžœžœ˜1Kšžœ˜K˜—š œžœžœ˜9K˜šžœžœ
ž˜Kšœžœ˜ Kšžœžœ˜&—K˜—š œžœžœ*˜WK˜šžœžœ
ž˜Kšœ*žœ˜4Kšžœžœ˜&—K˜—š 
œžœžœ"˜KK˜šžœžœ
ž˜Kšœ"žœ˜,Kšžœžœ˜&—K˜—š œžœžœ˜<K˜šžœžœ
ž˜Kšœžœ˜"Kšœ žœ˜*Kšžœžœ˜&—K˜—š œžœžœ ˜LK˜šžœžœ
ž˜Kšœ žœ˜*Kšžœžœ˜&—K˜—š 
œžœžœ˜EK˜šžœžœ
ž˜Kšœžœ˜&Kšžœžœ˜&—K˜—š 
œžœžœ˜4K˜šžœžœ
ž˜Kšœžœ˜Kšžœžœ˜&—K˜—š œžœžœ˜'K˜)K˜—š 
œžœ*˜=Kš
œ)˜)Kš
œ)˜)K˜—š œžœ&˜4Kšžœžœ
žœ˜Kšžœ
žœ˜ K˜—š œžœ:˜RKšžœžœ
žœ˜Kšžœ
žœ˜ K˜—š 	œžœ(˜7Kšžœžœ
žœ˜Kšžœ
žœ˜ K˜—š œžœ0˜GKšžœžœ
žœ˜Kšžœ
žœ˜ K˜—š œžœ2˜FKšžœžœ
žœ˜Kšžœ
žœ˜ K˜—š œžœ,˜@Kšžœžœ
žœ˜Kšžœ
žœ˜ K˜—š œžœ˜/Kšžœžœ
žœ˜Kšžœ
žœ˜ K˜—K˜š 
œžœžœ˜;K˜3Kšžœžœ
žœ
žœ
˜Kšžœžœ
žœ
˜*Kšžœ˜K˜—š œžœžœ˜CK˜3Kšžœžœ
žœ
žœ
˜Kšžœ˜
K˜K˜—K˜š œžœ
žœ˜*K˜+K˜Kšœžœ˜$Kš
œ˜K˜—š œžœ
žœ˜-K˜+K˜Kšœžœ˜$Kš
œ"˜"K˜K˜—K˜š œžœ
žœ˜*Kšœžœ˜Kš
œ.˜.K˜—š 
œžœ
žœ˜)Kšœžœžœžœ˜JKšœžœžœžœ˜JKš
œH˜HK˜—š 
œžœ
žœ˜)Kš
œA˜AKš
œ>˜>Kš
œ>˜>K˜—š œžœ
žœ˜-Kšœžœ˜Kš
œ<˜<K˜—š œžœ
žœ˜*Kšœžœ˜Kš
œ9˜9K˜—š 
œžœ
žœ˜)Kšœžœ˜Kš
œ8˜8K˜—š œžœ
žœ˜*Kšœžœ˜Kš
œ9˜9K˜—š œžœ
žœ˜*Kš
œA˜AKš
œA˜AKš
œ<˜<K˜—š œžœ
žœ˜*Kš
œA˜AKš
œ9˜9K˜—K˜š œžœ
žœ˜-Kš
œA˜AKšœžœ˜Kš
œ˜K˜—š œžœ
žœ˜0Kš
œA˜AKšœžœ˜Kš
œ!˜!K˜—š œžœ
žœ˜+Kš
œA˜AKšœžœ˜Kš
œ˜K˜—š œžœ
žœ˜.Kš
œA˜AKšœžœ˜Kš
œ˜K˜—K˜š œžœ
žœ˜+K˜+Kš
œA˜AKš
œ˜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š
œ6˜6K˜—š œžœ
žœ˜0K˜+Kšœ>žœ˜EK˜—K˜š 
œžœ
žœ˜,Kšœžœ˜Kš
œ&˜&K˜—š œžœ
žœ˜.Kš
œA˜AKš
œ&˜&Kš
œ+˜+K˜—š œžœ
žœ˜-Kšœžœ˜Kš
œ&˜&Kš
œ*˜*K˜—š œžœ
žœ˜+K˜+Kš
œ&˜&K˜0Kš
œ˜K˜K˜—š œžœ
žœ˜2K˜+Kš
œ4˜4Kš
œ?˜?Kš
œD˜DKš
œD˜DK˜—š œžœ
žœ˜.K˜+Kš
œ4˜4Kšœžœ˜Kš
œE˜EKš
œD˜DKš
œD˜DK˜—š œžœ
žœ˜3K˜+Kš
œ/˜/K˜—š 
œžœ
žœ˜,K˜+Kšœžœ˜Kš
œ˜K˜—š œžœ
žœ˜-K˜+Kšœžœ˜Kšœžœ˜K•StartOfExpansion -- [set: BYTE, code: BYTE]˜7Kš
œ!˜!K˜—š œžœ
žœ˜2K˜+Kš
œ˜K˜—š œžœ
žœ˜1K˜+Kšœžœžœ˜2Kš
œ%˜%K˜—K˜š œžœ
žœ˜/K˜+K˜K˜—š œžœ
žœ˜0K˜+Kš
œ+˜+K˜—š 
œžœ
žœ˜)K˜+Kš
œ%˜%K˜—š œžœ
žœ˜2K˜+Kšœžœ˜Kšœžœ2˜DKš
œ&˜&K˜—š œžœ
žœ˜5K˜+Kš
œ0˜0K˜—š œžœ
žœ˜7K˜+Kš
œ2˜2K˜—š œžœ
žœ˜4K˜+Kš
œ0˜0K˜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š
œP˜PKš
œ'˜'K˜—š œžœ
žœ˜9Kšœžœ˜K˜8K˜—š œžœ
žœ˜:Kšœžœ˜Kšœžœ˜Kšœžœ˜K˜HK˜—š œžœ
žœ˜4Kš
œ6˜6Kš
œc˜cKš
œ˜K˜—š œžœ
žœ˜=Kš
œ6˜6Kš
œ"˜"K˜—˜K˜—š œžœ
žœ˜4Kš
œB˜BKš
œB˜BKš
œ6˜6Kš
œE˜EK˜—š œžœ
žœ˜4Kšœžœ˜Kš
œB˜BKš
œ6˜6Kš
œ=˜=K˜—š œžœ
žœ˜3K˜+Kš
œB˜BKš
œA˜AKš
œ6˜6Kš
œ6˜6K˜—š œžœ
žœ˜3K˜+Kšœžœ˜Kš
œA˜AKš
œ6˜6Kš
œ.˜.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˜—š œžœžœžœ˜6Kšœžœ˜Kšœžœ˜1K˜Kšžœžœ
ž
œ
žœžœ"žœ
˜VKš
œ˜K˜—Kš œžœ
žœ'˜DKš œžœ
žœ%žœ˜MK˜š œžœžœžœ˜7K˜+Kš
œ˜˜šžœžœ
žœž˜K˜HKšžœ
˜—K˜—KšœAžœ
˜MK˜—Kš 
œžœ
žœ$˜>Kš œžœ
žœ"žœ˜Jš œžœ
žœ˜2K˜+Kš
œ.˜.K˜—š œžœ
žœ˜0K˜+Kš
œ9˜9K˜—š œžœ
žœ˜2K˜+Kšœ	žœ˜Kš
œ6˜6K˜—š œžœ
žœ˜.K˜+Kš
œ/˜/Kš
œ=˜=K˜—š œžœ
žœ˜4K˜+Kš
œ/˜/KšœEžœ˜KK˜—š œžœžœ
žœžœžœ˜4šžœžœ
ž˜Kšœžœ
žœžœ	˜!Kšœžœ
žœžœ˜Kšžœžœ@˜P—Kš
œ˜—š œžœ
žœ˜4K˜+Kšœžœ˜Kšœžœ˜Kš
œ ˜ Kšœžœžœžœžœžœ#˜PKš
œ/˜/K˜›
KšœIž
œ7˜
K˜—š œžœ
žœ˜6K˜+Kš
œ/˜/Kš
œ;˜;K˜—š œžœ
žœ˜<K˜+Kš
œ/˜/KšœDžœ˜JK˜—š œžœ
žœ˜1K˜+K˜2K˜—š œžœ
žœ˜+K˜+Kšœžœžœ˜7Kšœžœžœ˜7K˜2K˜—š œžœ
žœ˜.K˜+Kšœžœžœ˜/K˜#K˜—š œžœ
žœ˜-K˜+Kš
œ6˜6K˜K˜—š œžœ
žœ˜8K˜+Kš
œ4˜4K˜—š œžœ
žœ˜.K˜+Kš
œ*˜*K˜—K˜š œžœžœžœ˜:K˜+Kš
œ˜˜šžœžœ
žœž˜K˜HKšžœ
˜—K˜—Kš
œP˜PK˜—Kš œžœ
žœ'˜DKš œžœ
žœ%žœ˜Mš 
œžœžœžœ˜<K˜+Kš
œ,˜,Kš
œ?˜?K˜—Kš œžœ
žœ)˜HKš œžœ
žœ'žœ˜QK˜š œžœ
žœ˜-Kš
œ'˜'Kš
œ-˜-Kš
œ'˜'Kš
œ%˜%Kš
œ%˜%Kš
œ-˜-Kš
œ'˜'Kš
œ%˜%Kš
œ'˜'Kš
œ'˜'Kš
œ'˜'Kš
œ-˜-Kš
œ3˜3Kš
œ)˜)Kš
œ/˜/Kš
œ)˜)Kš
œ'˜'Kš
œ)˜)Kš
œ)˜)Kš
œ/˜/Kš
œ#˜#Kš
œ%˜%Kš
œ%˜%Kš
œ+˜+Kš
œ)˜)Kš
œ)˜)Kš
œ%˜%Kš
œ3˜3Kš
œ+˜+Kš
œ/˜/Kš
œ-˜-Kš
œ)˜)Kš
œ0˜0Kš
œ,˜,K˜Kš
œ9˜9Kš
œ+˜+Kš
œ-˜-Kš
œ7˜7Kš
œ5˜5Kš
œ1˜1Kš
œ3˜3Kš
œ%˜%Kš
œ7˜7Kš
œ=˜=Kš
œA˜AKš
œ;˜;Kš
œ)˜)Kš
œ1˜1Kš
œ+˜+Kš
œ+˜+Kš
œ)˜)Kš
œG˜GKš
œE˜EKš
œA˜AKš
œC˜CKš
œ;˜;Kš
œM˜MKš
œ;˜;Kš
œ;˜;Kš
œ9˜9Kš
œ9˜9Kš
œ-˜-Kš
œ'˜'Kš
œ'˜'Kš
œ)˜)Kš
œ)˜)Kš
œ)˜)Kš
œ)˜)Kš
œ%˜%Kš
œ1˜1Kš
œ7˜7Kš
œ+˜+Kš
œ7˜7Kš
œ?˜?Kš
œK˜KKš
œ7˜7Kš
œ3˜3Kš
œ7˜7Kš
œ/˜/Kš
œ;˜;Kš
œ;˜;Kš
œ5˜5Kš
œ)˜)Kš
œ/˜/Kš
œ-˜-Kš
œC˜CKš
œ/˜/Kš
œ1˜1Kš
œ7˜7Kš
œ5˜5Kš
œ;˜;K˜K˜—K˜Kšžœ
˜—…—cΪ}A