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šœ<˜žœ˜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š œžœžœ"žœ˜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˜—š œžœžœ˜