DIRECTORY
Basics USING [bitsPerWord],
Char,
Imager USING [Outline, PathProc, Trajectory, Box, ClassRep, Color, ColorOperator, ConstantColor, Context, Font, Object, PixelArray, PixelMap, Rectangle, SampleMap, ScanMode, SpecialColor, StrokeEnd, StrokeJoint, Transformation, VEC, XChar, XStringProc, zeroVEC],
ImagerBackdoor USING [Clipper, CoordSys, IntKey, RealKey, Visibility],
ImagerBitmapContext USING [Create, SetBitmap],
ImagerColor USING [ColorFromGray],
ImagerColorPrivate USING [ColorFromStipple],
ImagerError USING [Error, ErrorDesc, Warning],
ImagerFont USING [FindScaled, MapRope],
ImagerPath USING [MapOutline, MapTrajectory],
ImagerPrivate USING [Class, ClassRep],
ImagerSample USING [GetBox, GetSize, NewSampleMap, ObtainUnsafeDescriptor, ReleaseDescriptor],
ImagerSys USING [CheckForAbort],
Prop USING [PropList, Get, Put],
Rope USING [Map, ROPE, XROPE],
SF USING [Vec];

ImagerImpl: CEDAR PROGRAM
IMPORTS Char, ImagerBitmapContext, ImagerColor, ImagerColorPrivate, ImagerError, ImagerFont, ImagerPath, ImagerSample, ImagerSys, Prop, Rope
EXPORTS Imager, ImagerBackdoor
~ BEGIN OPEN Imager;

ROPE: TYPE ~ Rope.ROPE;
XROPE: TYPE ~ Rope.XROPE;
Class: TYPE ~ ImagerPrivate.Class;
ClassRep: PUBLIC TYPE ~ ImagerPrivate.ClassRep; -- export to Imager.ClassRep

Error: PUBLIC ERROR [error: ImagerError.ErrorDesc] ¬ ImagerError.Error;
GetClass: PUBLIC PROC [context: Context] RETURNS [ATOM] ~ {
class: Class ~ context.class;
RETURN[class.type];
};

Warning: PUBLIC SIGNAL [error: ImagerError.ErrorDesc] ¬ ImagerError.Warning;

SetWarn: PUBLIC PROC [context: Context, warn: BOOL] ~ {
SetInt[context, raiseWarnings, ORD[warn]];
};

GetProp: PUBLIC PROC [context: Context, key: REF] RETURNS [val: REF] ~ {
RETURN[Prop.Get[context.propList, key]];
};

PutProp: PUBLIC PROC [context: Context, key: REF, val: REF] ~ {
ChangePropList[context, Prop.Put[context.propList, key, val]];
};

ChangePropList: PROC [context: Context, new: Prop.PropList] = INLINE {
context.propList ¬ new;
};

DoSave: PUBLIC PROC [context: Context, action: PROC] ~ {
ref: REF ~ Save[context];
action[! UNWIND => Restore[context, ref]];
Restore[context, ref];
};

DoSaveAll: PUBLIC PROC [context: Context, action: PROC] ~ {
ref: REF ~ Save[context: context, all: TRUE];
action[! UNWIND => Restore[context, ref]];
Restore[context, ref];
};

Save: --ImagerBackdoor-- PUBLIC PROC [context: Context, all: BOOL ¬ FALSE] RETURNS [REF] = {
class: Class = context.class;
ImagerSys.CheckForAbort[];
IF context.propList # NIL THEN PutProp[context: context, key: $SavedPropList, val: context.propList];
RETURN [class.Save[context, all]];
};

Restore: --ImagerBackdoor-- PUBLIC PROC [context: Context, ref: REF] = {
class: Class = context.class;
class.Restore[context: context, ref: ref];
IF context.propList # NIL THEN ChangePropList[context, NARROW[GetProp[context: context, key: $SavedPropList]]];
};

ConcatT: PUBLIC PROC [context: Context, m: Transformation] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.ConcatT[context: context, m: m];
};

ScaleT: PUBLIC PROC [context: Context, s: REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.Scale2T[context: context, s: [s, s]];
};
Scale2T: PUBLIC PROC [context: Context, s: VEC] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.Scale2T[context: context, s: s];
};

RotateT: PUBLIC PROC [context: Context, a: REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.RotateT[context: context, a: a];
};

TranslateT: PUBLIC PROC [context: Context, t: VEC] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.TranslateT[context: context, t: t];
};
Move: PUBLIC PROC [context: Context] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.Move[context: context, rounded: FALSE];
};
Trans: PUBLIC PROC [context: Context] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.Move[context: context, rounded: TRUE];
};

SetXY: PUBLIC PROC [context: Context, p: VEC] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetXY[context: context, p: p];
};

SetXYI: PUBLIC PROC [context: Context, x, y: INTEGER] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetXY[context: context, p: [x, y]];
};

SetXYRel: PUBLIC PROC [context: Context, v: VEC] ~ {
class: Class ~ context.class;
class.SetXYRel[context: context, v: v];
};

SetXYRelI: PUBLIC PROC [context: Context, x, y: INTEGER] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetXYRel[context: context, v: [x, y]];
};

SetXRel: PUBLIC PROC [context: Context, x: REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetXYRel[context: context, v: [x, 0]];
};

SetXRelI: PUBLIC PROC [context: Context, x: INTEGER] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetXYRel[context: context, v: [x, 0]];
};

SetYRel: PUBLIC PROC [context: Context, y: REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetXYRel[context: context, v: [0, y]];
};

SetYRelI: PUBLIC PROC [context: Context, y: INTEGER] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetXYRel[context: context, v: [0, y]];
};

FindFontScaled: PUBLIC PROC [name: ROPE, s: REAL] RETURNS [Font] ~ {
RETURN [ImagerFont.FindScaled[name, s]]
};

SetFont: PUBLIC PROC [context: Context, font: Font] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetFont[context: context, font: font];
};

SetAmplifySpace: PUBLIC PROC [context: Context, amplifySpace: REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetReal[context: context, key: $amplifySpace, val: amplifySpace];
};

Show: PUBLIC PROC [context: Context, string: XStringProc, xrel: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.Show[context: context, string: string, xrel: xrel];
};

ShowAndFixedXRel: PUBLIC PROC [context: Context, string: XStringProc, x: REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.ShowAndFixedXRel[context, string, x];
};

ShowBackward: PUBLIC PROC [context: Context, string: XStringProc] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.ShowBackward[context: context, string: string];
};

ShowChar: PUBLIC PROC [context: Context, char: CHAR] ~ {
string: XStringProc ~ { charAction[Char.Make[set: 0, code: ORD[char]]] };
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.Show[context: context, string: string, xrel: FALSE];
};

ShowXChar: PUBLIC PROC [context: Context, char: XChar] ~ {
string: XStringProc ~ { charAction[char] };
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.Show[context: context, string: string, xrel: FALSE];
};

ShowRope: PUBLIC PROC [context: Context, rope: ROPE, 
start: INT ¬ 0, len: INT ¬ INT.LAST, xrel: BOOL ¬ FALSE] ~ {
string: XStringProc ~ { ImagerFont.MapRope[
rope: rope, start: start, len: len, charAction: charAction] 
};
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.Show[context: context, string: string, xrel: xrel];
};

ShowXRope: PUBLIC PROC [context: Context, rope: XROPE, start: INT ¬ 0, len: INT ¬ INT.LAST, xrel: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
WITH rope SELECT FROM
rope: ROPE => {
XString: XStringProc ~ {
Action: PROC [c: CHAR] RETURNS [quit: BOOL ¬ FALSE] ~ {
charAction[Char.Make[set: 0, code: ORD[c]]]
};
[] ¬ Rope.Map[base: rope, action: Action, start: start, len: len];
};
class.Show[context: context, string: XString, xrel: xrel];
};
ENDCASE => { IF rope # NIL THEN ERROR }; -- BUG - if XRope.mesa now exists, this branch nees to be implemented.
};

ShowText: PUBLIC PROC [context: Context, text: REF READONLY TEXT, 
start: NAT ¬ 0, len: NAT ¬ NAT.LAST, xrel: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.ShowText[context: context, text: text, start: start, len: len, xrel: xrel];
};

StartUnderline: PUBLIC PROC [context: Context] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.StartUnderline[context: context];
};

MaskUnderline: PUBLIC PROC [context: Context, dy, h: REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.MaskUnderline[context: context, dy: dy, h: h];
};

MaskUnderlineI: PUBLIC PROC [context: Context, dy, h: INTEGER] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.MaskUnderline[context: context, dy: dy, h: h];
};

CorrectMask: PUBLIC PROC [context: Context] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.CorrectMask[context: context];
};

CorrectSpace: PUBLIC PROC [context: Context, v: VEC] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.CorrectSpace[context: context, v: v];
};

Space: PUBLIC PROC [context: Context, x: REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.Space[context: context, x: x];
};

SpaceI: PUBLIC PROC [context: Context, x: INTEGER] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.Space[context: context, x: x];
};

SetCorrectMeasure: PUBLIC PROC [context: Context, v: VEC] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetCorrectMeasure[context: context, v: v];
};

SetCorrectTolerance: PUBLIC PROC [context: Context, v: VEC] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetCorrectTolerance[context: context, v: v];
};

SetCorrectShrink: PUBLIC PROC [context: Context, correctShrink: REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetReal[context: context, key: $correctShrink, val: correctShrink];
};

Correct: PUBLIC PROC [context: Context, action: PROC] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.Correct[context: context, action: action];
};

DontCorrect: PUBLIC PROC [context: Context, action: PROC, saveCP: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.DontCorrect[context: context, action: action, saveCP: saveCP];
};

SetColor: PUBLIC PROC [context: Context, color: Color] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetColor[context: context, color: color];
};

black: PUBLIC ConstantColor ¬ ImagerColor.ColorFromGray[1];
white: PUBLIC ConstantColor ¬ ImagerColor.ColorFromGray[0];

MakeGray: PUBLIC PROC [f: REAL] RETURNS [ConstantColor] ~ {
IF f>=1.0 THEN RETURN[black];
IF f<=0.0 THEN RETURN[white];
RETURN[ImagerColor.ColorFromGray[f]];
};

SetGray: PUBLIC PROC [context: Context, f: REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetGray[context: context, f: f];
};

SetSampledColor: PUBLIC PROC [context: Context, pa: PixelArray, 
m: Transformation, colorOperator: ColorOperator] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetSampledColor[context: context, pa: pa, m: m, colorOperator: colorOperator];
};

SetSampledBlack: PUBLIC PROC [context: Context, pa: PixelArray, 
m: Transformation, clear: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
class.SetSampledBlack[context: context, pa: pa, m: m, clear: clear];
};

DrawSampledColor: PUBLIC PROC [context: Context, pa: PixelArray, 
colorOperator: ColorOperator, m: Transformation, position: VEC] ~ {
drawSampledColorAction: PROC ~ {
TranslateT[context, position];
SetSampledColor[context, pa, m, colorOperator];
ConcatT[context, m];
ConcatT[context, pa.m];
MaskRectangle[context, [0, 0, pa.sSize, pa.fSize]];
};
DoSave[context, drawSampledColorAction];
};

SetPriorityImportant: PUBLIC PROC [context: Context, priorityImportant: BOOL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetInt[context: context, key: $priorityImportant, val: IF priorityImportant THEN 1 ELSE 0];
};

SetNoImage: PUBLIC PROC [context: Context, noImage: BOOL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetInt[context: context, key: $noImage, val: IF noImage THEN 1 ELSE 0];
};

MaskFill: PUBLIC PROC [context: Context, path: PathProc, oddWrap: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.MaskFill[context: context, path: path, oddWrap: oddWrap];
};

MaskFillTrajectory: PUBLIC PROC [context: Context, trajectory: Trajectory, oddWrap: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
path: PathProc ~ { ImagerPath.MapTrajectory[trajectory: trajectory, 
moveTo: moveTo, lineTo: lineTo, curveTo: curveTo, conicTo: conicTo, arcTo: arcTo] 
};
ImagerSys.CheckForAbort[];
class.MaskFill[context: context, path: path, oddWrap: oddWrap];
};

MaskFillOutline: PUBLIC PROC [context: Context, outline: Outline] ~ {
class: Class ~ context.class;
path: PathProc ~ { ImagerPath.MapOutline[outline: outline, 
moveTo: moveTo, lineTo: lineTo, curveTo: curveTo, conicTo: conicTo, arcTo: arcTo] 
};
ImagerSys.CheckForAbort[];
class.MaskFill[context: context, path: path, oddWrap: outline.oddWrap];
};

MaskRectangle: PUBLIC PROC [context: Context, r: Rectangle] ~ {
class: Class ~ context.class;
class.MaskRectangle[context: context, r: r];
};
MaskRectangleI: PUBLIC PROC [context: Context, x, y, w, h: INTEGER] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.MaskRectangleI[context: context, x: x, y: y, w: w, h: h];
};
MaskBox: PUBLIC PROC [context: Context, box: Box] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.MaskRectangle[context: context, 
r: [x: box.xmin, y: box.ymin, w: box.xmax-box.xmin, h: box.ymax-box.ymin]];
};
SetStrokeWidth: PUBLIC PROC [context: Context, strokeWidth: REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetReal[context: context, key: $strokeWidth, val: strokeWidth];
};

SetStrokeEnd: PUBLIC PROC [context: Context, strokeEnd: StrokeEnd] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetInt[context: context, key: $strokeEnd, val: ORD[strokeEnd]];
};

SetStrokeJoint: PUBLIC PROC [context: Context, strokeJoint: StrokeJoint] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetInt[context: context, key: $strokeJoint, val: ORD[strokeJoint]];
};

MaskStroke: PUBLIC PROC [context: Context, path: PathProc, 
closed: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.MaskStroke[context: context, path: path, closed: closed];
};
MaskStrokeTrajectory: PUBLIC PROC [context: Context, trajectory: Trajectory, 
closed: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
path: PathProc ~ { ImagerPath.MapTrajectory[trajectory: trajectory, 
moveTo: moveTo, lineTo: lineTo, curveTo: curveTo, conicTo: conicTo, arcTo: arcTo] 
};
ImagerSys.CheckForAbort[];
class.MaskStroke[context: context, path: path, closed: closed];
};
MaskVector: PUBLIC PROC [context: Context, p1, p2: VEC] ~ {
class: Class ~ context.class;
class.MaskVector[context: context, p1: p1, p2: p2];
};

MaskDashedStroke: PUBLIC PROC [context: Context, path: PathProc, 
patternLen: NAT, pattern: PROC [NAT] RETURNS [REAL], offset, length: REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.MaskDashedStroke[context: context, path: path, 
patternLen: patternLen, pattern: pattern, offset: offset, length: length];
};
MaskDashedStrokeTrajectory: PUBLIC PROC [context: Context, trajectory: Trajectory, 
patternLen: NAT, pattern: PROC [NAT] RETURNS [REAL], offset, length: REAL] ~ {
class: Class ~ context.class;
path: PathProc ~ { ImagerPath.MapTrajectory[trajectory: trajectory, 
moveTo: moveTo, lineTo: lineTo, curveTo: curveTo, conicTo: conicTo, arcTo: arcTo] 
};
ImagerSys.CheckForAbort[];
class.MaskDashedStroke[context: context, path: path, 
patternLen: patternLen, pattern: pattern, offset: offset, length: length];
};
MaskVectorI: PUBLIC PROC [context: Context, x1, y1, x2, y2: INTEGER] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.MaskVector[context: context, p1: [x1, y1], p2: [x2, y2]];
};

MaskPixel: PUBLIC PROC [context: Context, pa: PixelArray] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.MaskPixel[context: context, pa: pa];
};

MaskBits: PUBLIC PROC [context: Context, base: LONG POINTER, wordsPerLine: NAT, sMin, fMin, sSize, fSize: NAT, tx, ty: INTEGER] ~ TRUSTED {
class: Class ~ context.class;
bitmap: SampleMap ~ ImagerSample.ObtainUnsafeDescriptor[
size: [sSize, fSize],
bitsPerSample: 1,
bitsPerLine: wordsPerLine*Basics.bitsPerWord,
base: [word: base, bit: 0],
ref: NIL,
words: CARD[sMin+sSize]*wordsPerLine,
rawMin: [sMin, fMin]
];
MaskBitmap[context: context, bitmap: bitmap, referencePoint: [0, 0], scanMode: [slow: down, fast: right], position: [tx, ty]];
ImagerSample.ReleaseDescriptor[bitmap];
};

DrawBits: PUBLIC PROC [context: Context, base: LONG POINTER, wordsPerLine: NAT, sMin, fMin, sSize, fSize: NAT, tx, ty: INTEGER] ~ TRUSTED {
class: Class ~ context.class;
bitmap: SampleMap ~ ImagerSample.ObtainUnsafeDescriptor[
size: [sSize, fSize],
bitsPerSample: 1,
bitsPerLine: wordsPerLine*Basics.bitsPerWord,
base: [word: base, bit: 0],
ref: NIL,
words: CARD[sMin+sSize]*wordsPerLine,
rawMin: [sMin, fMin]
];
DrawBitmap[context: context, bitmap: bitmap, referencePoint: [0, 0], scanMode: [slow: down, fast: right], position: [tx, ty]];
ImagerSample.ReleaseDescriptor[bitmap];
};

MaskBitmap: PUBLIC PROC [context: Context, bitmap: SampleMap, referencePoint: SF.Vec,
scanMode: ScanMode, position: VEC] ~ {
class: Class ~ context.class;
class.MaskBitmap[context: context, bitmap: bitmap, referencePoint: referencePoint, scanMode: scanMode, position: position];
};

DrawBitmap: PUBLIC PROC [context: Context, bitmap: SampleMap, referencePoint: SF.Vec,
scanMode: ScanMode, position: VEC] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.DrawBitmap[context: context, bitmap: bitmap, referencePoint: referencePoint, scanMode: scanMode, position: position];
};

DrawPixels: PUBLIC PROC [context: Context, pixelMap: PixelMap, colorOperator: ColorOperator, referencePoint: SF.Vec, scanMode: ScanMode, position: VEC] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.DrawPixels[context: context, pixelMap: pixelMap, colorOperator: colorOperator, referencePoint: referencePoint, scanMode: scanMode, position: position];
};

Clip: PUBLIC PROC [context: Context, path: PathProc, oddWrap, exclude: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.Clip[context: context, path: path, oddWrap: oddWrap, exclude: exclude];
};

ClipOutline: PUBLIC PROC [context: Context, outline: Outline, exclude: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
path: PathProc ~ { ImagerPath.MapOutline[outline: outline, 
moveTo: moveTo, lineTo: lineTo, curveTo: curveTo, conicTo: conicTo, arcTo: arcTo] 
};
ImagerSys.CheckForAbort[];
class.Clip[context: context, path: path, oddWrap: outline.oddWrap, exclude: exclude];
};

ClipRectangle: PUBLIC PROC [context: Context, r: Rectangle, exclude: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.ClipRectangle[context: context, r: r, exclude: exclude];
};

ClipRectangleI: PUBLIC PROC [context: Context, x, y, w, h: INTEGER, exclude: BOOL ¬ FALSE] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.ClipRectangleI[context: context, x: x, y: y, w: w, h: h, exclude: exclude];
};

SetInt: PUBLIC PROC [context: Context, key: ImagerBackdoor.IntKey, val: INT] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetInt[context, key, val];
};
SetReal: PUBLIC PROC [context: Context, key: ImagerBackdoor.RealKey, val: REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetReal[context, key, val];
};
SetT: PUBLIC PROC [context: Context, m: Transformation] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetT[context, m];
};
SetClipper: PUBLIC PROC [context: Context, clipper: ImagerBackdoor.Clipper] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SetClipper[context, clipper];
};
GetInt: PUBLIC PROC [context: Context, key: ImagerBackdoor.IntKey] RETURNS [INT] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
RETURN[class.GetInt[context, key]];
};
GetReal: PUBLIC PROC [context: Context, key: ImagerBackdoor.RealKey] RETURNS [REAL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
RETURN[class.GetReal[context, key]];
};
GetT: PUBLIC PROC [context: Context] RETURNS [Transformation] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
RETURN[class.GetT[context]];
};
GetFont: PUBLIC PROC [context: Context] RETURNS [Font] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
RETURN[class.GetFont[context]];
};
GetColor: PUBLIC PROC [context: Context] RETURNS [Color] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
RETURN[class.GetColor[context]];
};
GetClipper: PUBLIC PROC [context: Context] RETURNS [ImagerBackdoor.Clipper] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
RETURN[class.GetClipper[context]];
};
GetCP: PUBLIC PROC [context: Context, rounded: BOOL ¬ FALSE] RETURNS [VEC] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
RETURN[class.GetCP[context: context, rounded: rounded]];
};

ViewReset: PUBLIC PROC [context: Context] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.ViewReset[context];
};

ViewTranslateI: PUBLIC PROC [context: Context, x, y: INTEGER] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.ViewTranslateI[context, x, y]
};

ViewClip: PUBLIC PROC [context: Context, path: PathProc, oddWrap: BOOL, exclude: BOOL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.ViewClip[context: context, path: path, oddWrap: oddWrap, exclude: exclude];
};

ViewClipRectangleI: PUBLIC PROC [context: Context, x, y, w, h: INTEGER, exclude: BOOL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.ViewClipRectangleI[context: context, x: x, y: y, w: w, h: h, exclude: exclude];
};

TransformPoint: PUBLIC PROC [context: Context, p: VEC, from, to: ImagerBackdoor.CoordSys] RETURNS [pT: VEC ¬ zeroVEC] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
RETURN [class.Transform[context: context, v: p, from: from, to: to, vec: FALSE]]
};

TransformVec: PUBLIC PROC [context: Context, v: VEC, from, to: ImagerBackdoor.CoordSys] RETURNS [vT: VEC ¬ zeroVEC] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
RETURN [class.Transform[context: context, v: v, from: from, to: to, vec: TRUE]]
};

GetTransformation: PUBLIC PROC [context: Context, from, to: ImagerBackdoor.CoordSys] RETURNS [composite: Transformation ¬ NIL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
RETURN [class.GetTransformation[context: context, from: from, to: to]]
};

MoveViewRectangle: PUBLIC PROC [context: Context, width, height, fromX, fromY, toX, toY: INTEGER] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.MoveViewRectangle[context: context, width: width, height: height, fromX: fromX, fromY: fromY, toX: toX, toY: toY]
};

Visibility: TYPE ~ ImagerBackdoor.Visibility;

TestViewRectangle: PUBLIC PROC [context: Context, x, y, w, h: INTEGER] RETURNS [Visibility] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
RETURN[class.TestViewRectangle[context: context, x: x, y: y, w: w, h: h]]
};

GetBounds: PUBLIC PROC [context: Context] RETURNS [Rectangle] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
RETURN[class.GetBounds[context: context]];
};

DoIfVisible: PUBLIC PROC [context: Context, r: Rectangle, action: PROC] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.DoIfVisible[context: context, r: r, action: action];
};
DoWithBuffer: PUBLIC PROC [context: Context, action: PROC, x, y, w, h: INTEGER, backgroundColor: Color ¬ NIL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.DoWithBuffer[context, action, x, y, w, h, backgroundColor];
};

DrawObject: PUBLIC PROC [context: Context, object: Object, position: VEC, interactive: BOOL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.DrawObject[context: context, object: object, position: position, interactive: interactive];
};

NewBitmap: PUBLIC PROC [width, height: NAT] RETURNS [SampleMap] ~ {
RETURN [ImagerSample.NewSampleMap[box: [max: [s: height, f: width]]]]
};

BitmapContext: PUBLIC PROC [bitmap: SampleMap] RETURNS [Context] ~ {
IF ImagerSample.GetBox[bitmap].min # [0, 0]
THEN {
ERROR Error[[$bounds, "The lower bounds on the bitmap for BitmapContext must be zero"]];
}
ELSE {
context: Context ~ ImagerBitmapContext.Create[deviceSpaceSize: ImagerSample.GetSize[bitmap], scanMode: [slow: down, fast: right], surfaceUnitsPerInch: [72, 72], pixelUnits: TRUE, fontCacheName: $Bitmap];
ImagerBitmapContext.SetBitmap[context: context, bitmap: bitmap];
RETURN [context]
};
};

GetBufferColorOperator: PUBLIC PROC [context: Context] RETURNS [ColorOperator] ~ {
class: Class ~ context.class;
colorOperator: ColorOperator ~ class.GetBufferColorOperator[context];
ImagerSys.CheckForAbort[];
RETURN [colorOperator]
};

AccessBuffer: PUBLIC PROC [context: Context, action: PROC [pixelMap: PixelMap], path: PathProc, oddWrap: BOOL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.AccessBuffer[context, action, path, oddWrap];
};

AccessBufferRectangle: PUBLIC PROC [context: Context, action: PROC [pixelMap: PixelMap], rectangle: Rectangle] ~ {
class: Class ~ context.class;
path: PathProc ~ {
moveTo[[rectangle.x, rectangle.y]];
lineTo[[rectangle.x+rectangle.w, rectangle.y]];
lineTo[[rectangle.x+rectangle.w, rectangle.y+rectangle.h]];
lineTo[[rectangle.x, rectangle.y+rectangle.h]];
};
ImagerSys.CheckForAbort[];
class.AccessBuffer[context, action, path, FALSE];
};

SaveBuffer: PUBLIC PROC [context: Context, id: ATOM, path: PathProc, oddWrap: BOOL] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.SaveBuffer[context, id, path, oddWrap];
};

SaveBufferRectangle: PUBLIC PROC [context: Context, id: ATOM, rectangle: Rectangle] ~ {
class: Class ~ context.class;
path: PathProc ~ {
moveTo[[rectangle.x, rectangle.y]];
lineTo[[rectangle.x+rectangle.w, rectangle.y]];
lineTo[[rectangle.x+rectangle.w, rectangle.y+rectangle.h]];
lineTo[[rectangle.x, rectangle.y+rectangle.h]];
};
ImagerSys.CheckForAbort[];
class.SaveBuffer[context, id, path, FALSE];
};

RestoreBuffer: PUBLIC PROC [context: Context, id: ATOM] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.RestoreBuffer[context, id];
};

DiscardBuffer: PUBLIC PROC [context: Context, id: ATOM] ~ {
class: Class ~ context.class;
ImagerSys.CheckForAbort[];
class.DiscardBuffer[context, id];
};

invert: PUBLIC SpecialColor ¬ ImagerColorPrivate.ColorFromStipple[word: WORD.LAST, function: [xor, null]];

MakeStipple: PUBLIC PROC [stipple: WORD ¬ WORD.LAST, xor: BOOL ¬ FALSE] 
RETURNS [SpecialColor] ~ {
IF xor AND stipple=WORD.LAST THEN RETURN[invert];
RETURN[ImagerColorPrivate.ColorFromStipple[word: stipple, function: (IF xor THEN [xor, null] ELSE [null, null])]];
};

END.


Ž
ImagerImpl.mesa
Copyright Σ 1984, 1985, 1986, 1987, 1989, 1991, 1992 by Xerox Corporation.  All rights reserved.
Michael Plass, November 20, 1991 5:20 pm PST
Doug Wyatt, January 19, 1987 7:54:40 pm PST

Imager Implementation
note: BOOL = new # context.propList AND context.class.NewPropList # NIL;
IF note THEN context.class.NewPropList[context];











ImagerBackdoor Implementation


Κί–
(cedarcode) style•NewlineDelimiter

™
codeš
œ™Kšœ
Οe
œU™`K™,Kš
œ+™+K™—š
Οk	˜	Kšœžœ˜K˜KšœžœΨ
žœ˜†Kšœžœ2˜FKšœžœ˜.Kšœžœ˜"Kšœžœ˜,Kšœžœ˜.Kšœžœ˜'Kšœžœ˜-Kšœžœ˜&Kšœ
žœL˜^Kšœ
žœ˜ Kšœžœ˜ Kšœžœžœžœ˜Kšžœ
žœ˜—K˜KšΠln
œžœ
ž˜Kšžœ…
˜Œ
Kšžœ˜šœžœ
žœ˜K˜Kšžœžœžœ
˜Kšžœžœžœ
˜Kšœžœ˜"šœ
žœ
žœΟc˜LK˜——š
œ™KšΟnœžœ
žœ4˜Gš
‘œžœ
žœžœžœ˜;K˜Kšžœ
˜K˜K˜—š‘œžœ
žœ6˜LK˜—š‘œžœ
žœžœ˜7Kšœžœ˜*Kš
œ˜K˜—š‘œžœ
žœžœžœžœ˜HKšžœ"˜(K˜K˜—š
‘œžœ
žœžœžœ˜?Kš
œ>˜>K˜K˜—š‘œžœ*žœ˜FJšœžœžœžœ
™HKš
œ˜Jšžœžœ$™0Kš
œ˜K˜—š‘œžœ
žœžœ˜8Kšœžœ˜Kšœ	žœ˜*Kš
œ˜K˜K˜—š‘	œžœ
žœžœ˜;Kšœžœžœ˜-Kšœ	žœ˜*Kš
œ˜K˜K˜—š‘œ œ
žœ
žœžœžœžœžœ˜\Kš
œ˜K˜Kšžœžœ
žœG˜eKšžœ˜"Kš
œ˜K˜—š
‘œ œ
žœ
žœžœ˜HK˜Kš
œ*˜*Kšžœžœ
žœžœ2˜oK˜K˜—š‘œžœ
žœ*˜>K˜K˜K˜&K˜K˜—š‘œžœ
žœžœ˜3K˜K˜K˜+K˜K™—š‘œžœ
žœžœ˜3K˜K˜K˜&K˜K˜—š‘œžœ
žœžœ˜4K˜K˜K˜&K˜K˜—š‘
œžœ
žœžœ˜6K˜K˜K˜)K˜K™—š‘œžœ
žœ˜(K˜K˜Kšœ&žœ˜-K˜K™—š‘œžœ
žœ˜)K˜K˜Kšœ&žœ˜,K˜K˜—š‘œžœ
žœžœ˜1K˜K˜K˜$K˜K˜—š‘œžœ
žœžœ˜9K˜K˜K˜)K˜K˜—š‘œžœ
žœžœ˜4K˜K˜'K˜K˜—š‘	œžœ
žœžœ˜<K˜K˜K˜,K˜K˜—š‘œžœ
žœžœ˜4K˜K˜K˜,K˜K˜—š‘œžœ
žœžœ˜8K˜K˜K˜,K˜K˜—š‘œžœ
žœžœ˜4K˜K˜K˜,K˜K˜—š‘œžœ
žœžœ˜8K˜K˜K˜,K˜K˜—K™š‘œžœ
žœžœžœžœ˜DKšžœ!˜'K˜K˜—š‘œžœ
žœ#˜7K˜K˜K˜,K˜K˜—š‘œžœ
žœ"žœ˜GK˜K˜K˜GK˜K˜—š
‘œžœ
žœ/žœžœ˜QK˜Kš
œ˜K˜9K˜K˜—š‘œžœ
žœ,žœ˜RK˜Kš
œ˜K˜+K˜K˜—š‘œžœ
žœ,˜EK˜Kš
œ˜Kš
œ5˜5K˜K˜—š‘œžœ
žœžœ˜8Kšœ;žœ˜IK˜Kš
œ˜Kšœ3žœ˜:K˜K˜—š‘	œžœ
žœ$˜:K˜+K˜Kš
œ˜Kšœ3žœ˜:K˜K˜—š‘œžœ
žœžœ˜5Kš
œžœžœžœ
žœžœžœ˜<˜+K˜<K˜—K˜Kš
œ˜K˜9K˜K˜—š‘	œžœ
žœžœ	žœžœžœ
žœžœžœ˜sK˜Kš
œ˜šžœžœ
ž˜šœžœ˜š‘œ˜š‘œžœžœžœžœžœ˜7Kšœ#žœ˜+Kš
œ˜—K˜BKš
œ˜—Kš
œ:˜:Kš
œ˜—Kšžœžœžœ
žœ
žœ F˜o—K˜K˜—š‘œžœ
žœžœ
žœ
žœ˜BKš
œžœžœžœ
žœžœžœ˜<K˜Kš
œ˜K˜QK˜K˜—š‘œžœ
žœ˜2K˜K˜K˜'K˜K˜—š‘
œžœ
žœžœ˜>K˜K˜K˜4K˜K˜—š‘œžœ
žœžœ˜BK˜K˜K˜4K˜K˜—š‘œžœ
žœ˜/K˜K˜K˜$K˜K˜—š‘œžœ
žœžœ˜8K˜K˜K˜+K˜K˜—š‘œžœ
žœžœ˜2K˜K˜K˜$K˜K˜—š‘œžœ
žœžœ˜6K˜K˜K˜$K˜K˜—š‘œžœ
žœžœ˜=K˜K˜K˜0K˜K˜—š‘œžœ
žœžœ˜?K˜K˜K˜2K˜K˜—š‘œžœ
žœ#žœ˜IK˜K˜K˜IK˜K˜—š‘œžœ
žœžœ˜9K˜K˜K˜0K˜K˜—š‘œžœ
žœžœ
žœžœ˜SK˜K˜K˜DK˜K˜—š‘œžœ
žœ%˜:K˜K˜K˜/K˜K˜—Kšœžœ.˜;šœžœ.˜;K˜—š
‘œžœ
žœžœžœ˜;Kšžœžœ
žœ˜Kšžœžœ
žœ˜Kšžœ˜%K˜K˜—š‘œžœ
žœžœ˜4K˜K˜K˜&K˜K˜—š‘œžœ
žœ$˜@K˜4K˜K˜K˜TK˜K˜—š‘œžœ
žœ$˜@Kšœžœžœ˜+K˜K˜DK˜K˜—š‘œžœ
žœ$˜AKšœ;žœ˜Cšœžœ˜ K˜K˜/K˜K˜K˜3K˜—K˜(K˜K˜—š‘œžœ
žœ'žœ˜QK˜K˜Kšœ=žœžœžœ˜aK˜K˜—š‘
œžœ
žœžœ˜=K˜K˜Kšœ3žœ	žœžœ˜MK˜K˜—š
‘œžœ
žœ-žœžœ˜SK˜K˜K˜?˜K˜——š
‘œžœ
žœ5žœžœ˜eK˜˜DK˜RK˜—K˜K˜?K˜K˜—š‘œžœ
žœ)˜EK˜˜;K˜RK˜—K˜K˜GK˜K˜—š‘
œžœ
žœ%˜?K˜K˜,K˜K™—š‘œžœ
žœ žœ˜GK˜K˜K˜?K˜K™—š‘œžœ
žœ!˜5K˜K˜˜&K˜K—K˜K™—š‘œžœ
žœ!žœ˜EK˜K˜K˜EK˜K˜—š‘œžœ
žœ-˜FK˜K˜Kšœ5žœ
˜EK˜K˜—š‘œžœ
žœ1˜LK˜K˜Kšœ7žœ˜IK˜K˜—š‘
œžœ
žœ$˜;Kšœžœžœ˜K˜K˜Kš
œ?˜?K˜K™—š‘œžœ
žœ,˜MKšœžœžœ˜K˜˜DK˜RK˜—K˜Kš
œ?˜?K˜K™—š‘
œžœ
žœžœ˜;K˜Kš
œ3˜3K˜K˜—š‘œžœ
žœ$˜AKš
œžœžœžœžœžœžœ˜NK˜K˜˜5Kš
œJ˜J—K˜K™—š‘œžœ
žœ,˜SKš
œžœžœžœžœžœžœ˜NK˜˜DK˜RK˜—K˜˜5Kš
œJ˜J—K˜K™—š‘œžœ
žœ$žœ˜HK˜K˜Kš
œ?˜?K˜K˜—š‘	œžœ
žœ'˜=K˜K˜K˜*K˜K˜—š‘œžœ
žœžœ
žœžœžœ
žœžœ˜‹
K˜˜8K˜K˜K˜-K˜Kšœžœ
˜	Kšœžœ˜%K˜K˜—K˜~K˜'K˜K˜—š‘œžœ
žœžœ
žœžœžœ
žœžœ˜‹
K˜˜8K˜K˜K˜-K˜Kšœžœ
˜	Kšœžœ˜%K˜K˜—K˜~K˜'K˜K˜—š‘
œžœ
žœ7žœ˜UKšœžœ˜&K˜K˜{K˜K˜—š‘
œžœ
žœ7žœ˜UKšœžœ˜&K˜K˜K˜{K˜K˜—š
‘
œžœ
žœVžœ$žœ˜›
K˜K˜K˜
K˜K˜—š
‘œžœ
žœ6žœžœ˜XK˜K˜K˜MK˜K˜—š
‘œžœ
žœ/žœžœ˜XK˜˜;K˜RK˜—K˜K˜UK˜K˜—š
‘
œžœ
žœ+žœžœ˜VK˜K˜K˜>K˜K˜—š‘œžœ
žœ žœžœžœ˜^K˜K˜K˜QK˜K˜——š
œ™š‘œžœ
žœ5žœ˜PK˜K˜K˜ K˜—š‘œžœ
žœ6žœ˜SK˜K˜K˜!K˜—š‘œžœ
žœ*˜;K˜K˜K˜K˜—š‘
œžœ
žœ8˜OK˜K˜K˜#K˜—š
‘œžœ
žœ0žœžœ˜TK˜K˜Kšžœ˜#K˜—š
‘œžœ
žœ1žœžœ˜WK˜K˜Kšžœ˜$K˜—š‘œžœ
žœžœ˜AK˜K˜Kšžœ˜K˜—š‘œžœ
žœžœ˜:K˜K˜Kšžœ˜K˜—š‘œžœ
žœžœ˜<K˜K˜Kšžœ˜ K˜—š‘
œžœ
žœžœ˜OK˜K˜Kšžœ˜"K˜—š‘œžœ
žœžœžœžœžœ˜NK˜K˜Kšžœ2˜8K˜—K˜K™š‘	œžœ
žœ˜-K˜K˜K˜K˜K˜—š‘œžœ
žœžœ˜AK˜K˜K˜#K˜K˜—š
‘œžœ
žœ-žœžœ˜ZK˜K˜K˜QK˜K˜—š
‘œžœ
žœ žœžœ˜ZK˜K˜K˜UK˜K˜—š‘œžœ
žœžœ%žœžœ˜yK˜K˜KšžœCžœ˜PK˜K˜—š‘œžœ
žœžœ%žœžœ˜wK˜K˜KšžœCžœ˜OK˜K˜—š
‘œžœ
žœ7žœžœ˜‚
K˜K˜Kšžœ@˜FK˜K˜—š‘œžœ
žœ;žœ˜eK˜K˜K˜wK˜K˜—šœžœ˜-K˜—š
‘œžœ
žœ žœžœ˜_K˜K˜KšžœC˜IK˜K˜—š‘	œžœ
žœžœ˜AK˜K˜Kšžœ$˜*K˜K˜—š‘œžœ
žœ*žœ˜KK˜K˜K˜:K˜K™—š‘œžœ
žœžœžœžœ˜qK˜K˜K˜AK˜K˜—š
‘
œžœ
žœ.žœžœ˜`K˜K˜K˜aK˜K˜—š
‘	œžœ
žœžœžœ˜CKšžœ?˜EKš
œ˜K˜—š‘
œžœžœ˜D•StartOfExpansionΖ
[deviceSpaceSize: 
SF.Vec, scanMode: 
ImagerTransformation.ScanMode, surfaceUnitsPerInch: 
VEC, pixelUnits: 
BOOL _ FALSE, fontCacheName: 
ATOM _ NIL, fontTuner: 
ImagerDevice.FontTuner _ NIL]šžœ)˜+šžœ˜KšžœS˜XKš
œ
˜
—šžœ˜Kšœ­
žœ˜Λ
K–=[context: 
Imager.Context, bitmap: 
ImagerSample.SampleMap]š
œ@˜@Kšžœ
˜Kš
œ˜——Kš
œ˜K˜—š‘œžœ
žœžœ˜RK˜Kš
œE˜EK˜Kšžœ˜K˜K˜—š
‘œžœ
žœžœ0žœ˜rK˜K˜Kš
œ3˜3K˜K˜—š‘œžœ
žœžœ0˜rK˜š
œ˜Kš
œ#˜#Kš
œ/˜/Kš
œ;˜;Kš
œ/˜/Kš
œ˜—K˜Kšœ*žœ˜1K˜K˜—š
‘
œžœ
žœžœžœ˜WK˜K˜Kš
œ-˜-K˜K˜—š‘œžœ
žœžœ˜WK˜š
œ˜Kš
œ#˜#Kš
œ/˜/Kš
œ;˜;Kš
œ/˜/Kš
œ˜—K˜Kšœ$žœ˜+K˜K˜—š‘
œžœ
žœžœ˜;K˜K˜Kš
œ!˜!Kš
œ˜K˜—š‘
œžœ
žœžœ˜;K˜K˜Kš
œ!˜!Kš
œ˜K˜—šœžœ:žœ
žœ˜jK˜—š‘œžœ
žœžœžœ
žœžœžœ˜HKšžœ˜Kšžœžœ	žœ
žœ
žœ
žœ	˜1Kšžœ?žœžœ
žœ˜rK˜K˜—Kšžœ
˜—K˜—…—hδƒQ