DIRECTORY Atom, ImagerBackdoorPrivate, ImagerForkContext, Rope, ImagerDevice, ImagerBackdoor, ImagerScanConverter, ImagerPixelMap, ImagerFont, ImagerManhattan, ImagerPath, ImagerTransformation, Vector2, Imager, ImagerFontPrivate, ImagerPrivate;
 
ImagerForkContextImpl: CEDAR PROGRAM
IMPORTS Atom, ImagerBackdoor 
EXPORTS Imager, ImagerFont, ImagerForkContext

~ BEGIN

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

ROPE: TYPE ~ Rope.ROPE;

CharMask: TYPE ~ ImagerDevice.CharMask;
Clipper: TYPE ~ ImagerBackdoor.Clipper;
Color: TYPE ~ Imager.Color;
ColorOperator: TYPE ~ Imager.ColorOperator;
Context: TYPE ~ Imager.Context;
Device: TYPE ~ ImagerDevice.Device;
DeviceBox: TYPE ~ ImagerDevice.DeviceBox;
RunProc: TYPE ~ ImagerDevice.RunProc;
DevicePath: TYPE ~ ImagerScanConverter.DevicePath;
DeviceRectangle: TYPE ~ ImagerPixelMap.DeviceRectangle;
Font: TYPE ~ ImagerFont.Font;
ManhattanPolygon: TYPE ~ ImagerManhattan.Polygon;
PathProc: TYPE ~ ImagerPath.PathProc;
PixelArray: TYPE ~ Imager.PixelArray;
Rectangle: TYPE ~ ImagerTransformation.Rectangle;
Transformation: TYPE ~ ImagerTransformation.Transformation;
TransformationRep: TYPE ~ ImagerTransformation.TransformationRep;
VEC: TYPE ~ Vector2.VEC;
XChar: TYPE ~ ImagerFont.XChar;
XStringProc: TYPE ~ ImagerFont.XStringProc;
FontImpl: TYPE ~ ImagerFontPrivate.FontImpl;
FontImplRep: PUBLIC TYPE ~ ImagerFontPrivate.FontImplRep;
IntKey: TYPE ~ ImagerBackdoor.IntKey;
RealKey: TYPE ~ ImagerBackdoor.RealKey;
-- Clipper: TYPE ~ ImagerBackdoor.Clipper;

Data: TYPE ~ REF DataRec;
DataRec: TYPE ~ RECORD [
contextA, contextB: Imager.Context,
aActive, bActive: BOOLEAN _ TRUE
];

forkViewClass: ImagerBackdoorPrivate.Class ~ NEW[ImagerBackdoorPrivate.ClassRep _ [
type: $fork,
ViewReset: ViewReset,
ViewTranslateI: ViewTranslateI,
ViewClip: ViewClip,
ViewClipRectangleI: ViewClipRectangleI,
ViewFromClient: ViewFromClient,
ClientFromView: ClientFromView,
DeviceFromView: DeviceFromView,
ViewFromDevice: ViewFromDevice,
DeviceFromClient: DeviceFromClient,
ClientFromDevice: ClientFromDevice,
MoveViewRectangle: MoveViewRectangle,
TestViewRectangle: TestViewRectangle
]];

forkClass: Class ~ NEW[ClassRep _ [
type: $ForkContext,
DoSave: ForkDoSave,
SetInt: ForkSetInt,
SetReal: ForkSetReal,
SetT: ForkSetT,
SetFont: ForkSetFont,
SetColor: ForkSetColor,
SetClipper: ForkSetClipper,
GetInt: ForkGetInt,
GetReal: ForkGetReal,
GetT: ForkGetT,
GetFont: ForkGetFont,
GetColor: ForkGetColor,
GetClipper: ForkGetClipper,
ConcatT: ForkConcatT,
Scale2T: ForkScale2T,
RotateT: ForkRotateT,
TranslateT: ForkTranslateT,
Move: ForkMove,
SetXY: ForkSetXY,
SetXYRel: ForkSetXYRel,
Show: ForkShow,
ShowText: ForkShowText,
StartUnderline: ForkStartUnderline,
MaskUnderline: ForkMaskUnderline,
CorrectMask: ForkCorrectMask,
CorrectSpace: ForkCorrectSpace,
Space: ForkSpace,
SetCorrectMeasure: ForkSetCorrectMeasure,
SetCorrectTolerance: ForkSetCorrectTolerance,
Correct: ForkCorrect,
DontCorrect: ForkDontCorrect,
SetGray: ForkSetGray,
SetSampledColor: ForkSetSampledColor,
SetSampledBlack: ForkSetSampledBlack,
MaskFill: ForkMaskFill,
MaskStroke: ForkMaskStroke,
MaskDashedStroke: ForkMaskDashedStroke,
MaskRectangle: ForkMaskRectangle,
MaskRectangleI: ForkMaskRectangleI,
MaskVector: ForkMaskVector,
MaskPixel: ForkMaskPixel,
MaskBits: ForkMaskBits,
DrawBits: ForkDrawBits,
Clip: ForkClip,
ClipRectangle: ForkClipRectangle,
ClipRectangleI: ForkClipRectangleI,
GetCP: ForkGetCP,
GetBoundingRectangle: ForkGetBoundingRectangle,
propList: Atom.PutPropOnList[NIL, $viewOperations, forkViewClass]
]];


Create: PUBLIC PROC [contextA, contextB: Imager.Context] RETURNS [contextAB: Imager.Context] ~ {
data: Data _ NEW[DataRec _ [contextA, contextB]];
RETURN[NEW[Imager.ContextRep _ [class: forkClass, state: NIL, data: data]]];
};

Activate: PUBLIC PROC [contextAB: Imager.Context, a, b: BOOLEAN] ~ {
WITH contextAB.data SELECT FROM
data: Data => {
data.aActive _ a; data.bActive _ b;
};
ENDCASE;
};

GetContexts: PUBLIC PROC [contextAB: Imager.Context] RETURNS [contextA, contextB: Imager.Context] ~ {
WITH contextAB.data SELECT FROM
data: Data => {
RETURN [data.contextA, data.contextB]
};
ENDCASE;
RETURN [NIL, NIL]
};


ForkDoSave: PROC[context: Context, action: PROC, all: BOOL] ~ {
data: Data _ NARROW[context.data];
aSave, bSave: BOOLEAN;
aSave _ data.aActive; bSave _ data.bActive;
IF data.aActive THEN {
IF data.bActive THEN { 
myAction: PROC ~ {
classB: Class _ data.contextB.class;
classB.DoSave[context: data.contextB, action: action, all: all];
};
classA: Class _ data.contextA.class;
classA.DoSave[context: data.contextA, action: myAction, all: all];
}
ELSE {
classA: Class _ data.contextA.class;
classA.DoSave[context: data.contextA, action: action, all: all];
};
}
ELSE {
IF data.bActive THEN { 
classB: Class _ data.contextB.class;
classB.DoSave[context: data.contextB, action: action, all: all];
}
}; 
data.aActive _ aSave; data.bActive _ bSave;
};
ForkSetInt: PROC[context: Context, key: IntKey, val: INT] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN {
class: Class _ data.contextA.class;
class.SetInt[context: data.contextA, key: key, val: val];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.SetInt[context: data.contextB, key: key, val: val]; 
};
};
ForkSetReal: PROC[context: Context, key: RealKey, val: REAL]
 ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN {
class: Class _ data.contextA.class;
class.SetReal[context: data.contextA, key: key, val: val];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.SetReal[context: data.contextB, key: key, val: val]; 
};
};
ForkSetT: PROC[context: Context, m: Transformation] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.SetT[context: data.contextA, m: m];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.SetT[context: data.contextB, m: m]; 
};
};
ForkSetFont: PROC[context: Context, font: Font] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.SetFont[context: data.contextA, font: font];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.SetFont[context: data.contextB, font: font]; 
};
};
ForkSetColor: PROC[context: Context, color: Color] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.SetColor[context: data.contextA, color: color];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.SetColor[context: data.contextB, color: color]; 
};
};
ForkSetClipper: PROC[context: Context, clipper: Clipper] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.SetClipper[context: data.contextA, clipper: clipper];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.SetClipper[context: data.contextB, clipper: clipper]; 
};
};
ForkGetInt: PROC[context: Context, key: IntKey] RETURNS[INT] ~ {
data: Data _ NARROW[context.data];
result: INT;
IF data.aActive THEN { 
class: Class _ data.contextA.class;
RETURN[class.GetInt[context: data.contextA, key: key]];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
result _ class.GetInt[context: data.contextB, key: key];
};
RETURN [result]
};
ForkGetReal: PROC[context: Context, key: RealKey] RETURNS[REAL] ~ {
data: Data _ NARROW[context.data];
result: REAL;
IF data.aActive THEN { 
class: Class _ data.contextA.class;
RETURN[class.GetReal[context: data.contextA, key: key]];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
result _ class.GetReal[context: data.contextB, key: key];
};
RETURN [result]
};
ForkGetT: PROC[context: Context] RETURNS[Transformation] ~ {
data: Data _ NARROW[context.data];
result: Transformation;
IF data.aActive THEN { 
class: Class _ data.contextA.class;
RETURN[class.GetT[context: data.contextA]];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
result _ class.GetT[context: data.contextB];
};
RETURN [result]
};
ForkGetFont: PROC[context: Context] RETURNS[Font] ~ {
data: Data _ NARROW[context.data];
result: Font;
IF data.aActive THEN { 
class: Class _ data.contextA.class;
RETURN[class.GetFont[context: data.contextA]];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
result _ class.GetFont[context: data.contextB];
};
RETURN [result]
};
ForkGetColor: PROC[context: Context] RETURNS[Color] ~ {
data: Data _ NARROW[context.data];
result: Color;
IF data.aActive THEN { 
class: Class _ data.contextA.class;
RETURN[class.GetColor[context: data.contextA]];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
result _ class.GetColor[context: data.contextB];
};
RETURN [result]
};
ForkGetClipper: PROC[context: Context] RETURNS[Clipper] ~ {
data: Data _ NARROW[context.data];
result: Clipper;
IF data.aActive THEN { 
class: Class _ data.contextA.class;
RETURN[class.GetClipper[context: data.contextA]];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
result _ class.GetClipper[context: data.contextB];
};
RETURN [result]
};
ForkConcatT: PROC[context: Context, m: Transformation] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.ConcatT[context: data.contextA, m: m];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.ConcatT[context: data.contextB, m: m]; 
};
};
ForkScale2T: PROC[context: Context, s: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.Scale2T[context: data.contextA, s: s];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.Scale2T[context: data.contextB, s: s]; 
};
};
ForkRotateT: PROC[context: Context, a: REAL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.RotateT[context: data.contextA, a: a];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.RotateT[context: data.contextB, a: a]; 
};
};
ForkTranslateT: PROC[context: Context, t: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.TranslateT[context: data.contextA, t: t];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.TranslateT[context: data.contextB, t: t]; 
};
};
ForkMove: PROC[context: Context, rounded: BOOL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.Move[context: data.contextA, rounded: rounded];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.Move[context: data.contextB, rounded: rounded]; 
};
};
ForkSetXY: PROC[context: Context, p: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.SetXY[context: data.contextA, p: p];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.SetXY[context: data.contextB, p: p]; 
};
};
ForkSetXYRel: PROC[context: Context, v: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.SetXYRel[context: data.contextA, v: v];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.SetXYRel[context: data.contextB, v: v]; 
};
};
ForkGetCP: PROC[context: Context, rounded: BOOL] RETURNS[VEC] ~ {
data: Data _ NARROW[context.data];
result: VEC;
IF data.aActive THEN { 
class: Class _ data.contextA.class;
RETURN[class.GetCP[context: data.contextA, rounded: rounded]];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
result _ class.GetCP[context: data.contextB, rounded: rounded];
};
RETURN [result]
};
ForkStartUnderline: PROC[context: Context] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.StartUnderline[context: data.contextA];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.StartUnderline[context: data.contextB]; 
};
};
ForkMaskUnderline: PROC[context: Context, dy, h: REAL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.MaskUnderline[context: data.contextA, dy: dy, h: h];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.MaskUnderline[context: data.contextB, dy: dy, h: h]; 
};
};
ForkCorrectMask: PROC[context: Context] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.CorrectMask[context: data.contextA];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.CorrectMask[context: data.contextB]; 
};
};
ForkCorrectSpace: PROC[context: Context, v: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.CorrectSpace[context: data.contextA, v: v];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.CorrectSpace[context: data.contextB, v: v]; 
};
};
ForkSpace: PROC[context: Context, x: REAL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.Space[context: data.contextA, x: x];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.Space[context: data.contextB, x: x]; 
};
};
ForkSetCorrectMeasure: PROC[context: Context, v: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.SetCorrectMeasure[context: data.contextA, v: v];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.SetCorrectMeasure[context: data.contextB, v: v]; 
};
};
ForkSetCorrectTolerance: PROC[context: Context, v: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.SetCorrectTolerance[context: data.contextA, v: v];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.SetCorrectTolerance[context: data.contextB, v: v]; 
};
};
ForkCorrect: PROC[context: Context, action: PROC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN {
class: Class _ data.contextA.class;
class.Correct[context: data.contextA, action: action];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.Correct[context: data.contextB, action: action]; 
};
};
ForkDontCorrect: PROC[context: Context, action: PROC, saveCP: BOOL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.DontCorrect[context: data.contextA, action: action, saveCP: saveCP];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.DontCorrect[context: data.contextB, action: action, saveCP: saveCP]; 
};
};
ForkSetGray: PROC[context: Context, f: REAL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.SetGray[context: data.contextA, f: f];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.SetGray[context: data.contextB, f: f]; 
};
};
ForkSetSampledColor: PROC[context: Context, pa: PixelArray, m: Transformation, colorOperator: ColorOperator] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.SetSampledColor[context: data.contextA, pa: pa, m: m, colorOperator: colorOperator];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.SetSampledColor[context: data.contextB, pa: pa, m: m, colorOperator: colorOperator]; 
};
};
ForkSetSampledBlack: PROC[context: Context, pa: PixelArray, m: Transformation, clear: BOOL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.SetSampledBlack[context: data.contextA, pa: pa, m: m, clear: clear];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.SetSampledBlack[context: data.contextB, pa: pa, m: m, clear: clear]; 
};
};
ForkClip: PROC[context: Context, path: PathProc, oddWrap: BOOL, exclude: BOOL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.Clip[context: data.contextA, path: path, oddWrap: oddWrap, exclude: exclude];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.Clip[context: data.contextB, path: path, oddWrap: oddWrap, exclude: exclude]; 
};
};
ForkClipRectangle: PROC[context: Context, r: Rectangle, exclude: BOOL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.ClipRectangle[context: data.contextA, r: r, exclude: exclude];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.ClipRectangle[context: data.contextB, r: r, exclude: exclude]; 
};
};
ForkClipRectangleI: PROC[context: Context, x, y, w, h: INTEGER, exclude: BOOL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.ClipRectangleI[context: data.contextA, x: x, y: y, w: w, h: h, exclude: exclude];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.ClipRectangleI[context: data.contextB, x: x, y: y, w: w, h: h, exclude: exclude]; 
};
};
ForkShow: PROC [context: Context, string: XStringProc, xrel: BOOL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.Show[context: data.contextA, string: string, xrel: xrel];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.Show[context: data.contextB, string: string, xrel: xrel]; 
};
};
ForkShowText: PROC [context: Context, text: REF READONLY TEXT, start, len: NAT, xrel: BOOL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.ShowText[context: data.contextA, text: text, start: start, len: len, xrel: xrel];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.ShowText[context: data.contextB, text: text, start: start, len: len, xrel: xrel]; 
};
};
ForkMaskFill: PROC [context: Context, path: PathProc, oddWrap: BOOL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.MaskFill[context: data.contextA, path: path, oddWrap: oddWrap];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.MaskFill[context: data.contextB, path: path, oddWrap: oddWrap]; 
};
};
ForkMaskRectangle: PROC [context: Context, r: Rectangle] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.MaskRectangle[context: data.contextA, r: r];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.MaskRectangle[context: data.contextB, r: r]; 
};
};
ForkMaskRectangleI: PROC [context: Context, x, y, w, h: INTEGER] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.MaskRectangleI[context: data.contextA, x: x, y: y, w: w, h: h];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.MaskRectangleI[context: data.contextB, x: x, y: y, w: w, h: h]; 
};
};
ForkMaskStroke: PROC [context: Context, path: PathProc, closed: BOOL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.MaskStroke[context: data.contextA, path: path, closed: closed];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.MaskStroke[context: data.contextB, path: path, closed: closed]; 
};
};
ForkMaskVector: PROC [context: Context, p1, p2: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.MaskVector[context: data.contextA, p1: p1, p2: p2];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.MaskVector[context: data.contextB, p1: p1, p2: p2]; 
};
};
ForkMaskDashedStroke: PROC [context: Context, path: PathProc, 
patternLen: NAT, pattern: PROC [i: NAT] RETURNS [REAL], offset, length: REAL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.MaskDashedStroke[context: data.contextA, path: path, 
patternLen: patternLen, pattern: pattern, offset: offset, length: length];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.MaskDashedStroke[context: data.contextB, path: path, 
patternLen: patternLen, pattern: pattern, offset: offset, length: length]; 
};
};
ForkMaskPixel: PROC [context: Context, pa: PixelArray] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.MaskPixel[context: data.contextA, pa: pa];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.MaskPixel[context: data.contextB, pa: pa]; 
};
};
ForkMaskBits: PROC [context: Context, base: LONG POINTER, wordsPerLine: NAT, 
sMin, fMin: NAT _ 0, sSize, fSize: NAT, tx, ty: INTEGER] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.MaskBits[context: data.contextA, base: base, wordsPerLine: wordsPerLine, 
sMin: sMin, fMin: fMin, sSize: sSize, fSize: fSize, tx: tx, ty: ty];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.MaskBits[context: data.contextB, base: base, wordsPerLine: wordsPerLine, 
sMin: sMin, fMin: fMin, sSize: sSize, fSize: fSize, tx: tx, ty: ty]; 
};
};
ForkDrawBits: PROC [context: Context, base: LONG POINTER, wordsPerLine: NAT, 
sMin, fMin: NAT _ 0, sSize, fSize: NAT, tx, ty: INTEGER] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
class: Class _ data.contextA.class;
class.DrawBits[context: data.contextA, base: base, wordsPerLine: wordsPerLine, 
sMin: sMin, fMin: fMin, sSize: sSize, fSize: fSize, tx: tx, ty: ty];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
class.DrawBits[context: data.contextB, base: base, wordsPerLine: wordsPerLine, 
sMin: sMin, fMin: fMin, sSize: sSize, fSize: fSize, tx: tx, ty: ty]; 
};
};
ForkGetBoundingRectangle: PROC [context: Context] RETURNS [Rectangle] ~ {
data: Data _ NARROW[context.data];
result: Rectangle;
IF data.aActive THEN { 
class: Class _ data.contextA.class;
RETURN[class.GetBoundingRectangle[context: data.contextA]];
};
IF data.bActive THEN { 
class: Class _ data.contextB.class;
result _ class.GetBoundingRectangle[context: data.contextB];
};
RETURN [result]
};

ViewReset: PROC [context: Context] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
ImagerBackdoor.ViewReset[context: data.contextA];
};
IF data.bActive THEN { 
ImagerBackdoor.ViewReset[context: data.contextB];
};
};
ViewTranslateI: PROC [context: Context, x, y: INTEGER] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
ImagerBackdoor.ViewTranslateI[context: data.contextA, x:x, y:y];
};
IF data.bActive THEN { 
ImagerBackdoor.ViewTranslateI[context: data.contextB, x:x, y:y];
};
};
ViewClip: PROC [context: Context, path: PathProc, parity: BOOL, exclude: BOOL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
ImagerBackdoor.ViewClip[context: data.contextA, path: path, parity: parity, exclude: exclude];
};
IF data.bActive THEN { 
ImagerBackdoor.ViewClip[context: data.contextB, path: path, parity: parity, exclude: exclude];
};
};
ViewClipRectangleI: PROC [context: Context, x, y, w, h: INTEGER, exclude: BOOL] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
ImagerBackdoor.ViewClipRectangleI[context: data.contextA, x:x, y:y, w:w, h:h, exclude:exclude];
};
IF data.bActive THEN { 
ImagerBackdoor.ViewClipRectangleI[context: data.contextB, x:x, y:y, w:w, h:h, exclude:exclude];
};
};
ViewFromClient: PROC [context: Context, p: VEC] RETURNS [v: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
RETURN[ImagerBackdoor.ViewFromClient[context: data.contextA, p:p]];
};
IF data.bActive THEN { 
v _ ImagerBackdoor.ViewFromClient[context: data.contextB, p:p];
};
};
ClientFromView: PROC [context: Context, p: VEC] RETURNS [v: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
RETURN[ImagerBackdoor.ClientFromView[context: data.contextA, p:p]];
};
IF data.bActive THEN { 
v _ ImagerBackdoor.ClientFromView[context: data.contextB, p:p];
};
};
DeviceFromView: PROC [context: Context, p: VEC] RETURNS [v: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
RETURN[ImagerBackdoor.DeviceFromView[context: data.contextA, p:p]];
};
IF data.bActive THEN { 
v _ ImagerBackdoor.DeviceFromView[context: data.contextB, p:p];
};
};
ViewFromDevice: PROC [context: Context, p: VEC] RETURNS [v: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
RETURN[ImagerBackdoor.ViewFromDevice[context: data.contextA, p:p]];
};
IF data.bActive THEN { 
v _ ImagerBackdoor.ViewFromDevice[context: data.contextB, p:p];
};
};
DeviceFromClient: PROC [context: Context, p: VEC] RETURNS [v: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
RETURN[ImagerBackdoor.DeviceFromClient[context: data.contextA, p:p]];
};
IF data.bActive THEN { 
v _ ImagerBackdoor.DeviceFromClient[context: data.contextB, p:p];
};
};
ClientFromDevice: PROC [context: Context, p: VEC] RETURNS [v: VEC] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
RETURN[ImagerBackdoor.ClientFromDevice[context: data.contextA, p:p]];
};
IF data.bActive THEN { 
v _ ImagerBackdoor.ClientFromDevice[context: data.contextB, p:p];
};
};
MoveViewRectangle: PROC [context: Context, width, height, fromX, fromY, toX, toY: INTEGER] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
ImagerBackdoor.MoveViewRectangle[context: data.contextA, width:width, height:height, fromX:fromX, fromY:fromY, toX:toX, toY:toY];
};
IF data.bActive THEN { 
ImagerBackdoor.MoveViewRectangle[context: data.contextB, width:width, height:height, fromX:fromX, fromY:fromY, toX:toX, toY:toY];
};
};
TestViewRectangle: PROC [context: Context, x, y, w, h: INTEGER] RETURNS [vis: ImagerBackdoor.Visibility] ~ {
data: Data _ NARROW[context.data];
IF data.aActive THEN { 
RETURN[ImagerBackdoor.TestViewRectangle[context: data.contextA, x:x, y:y, w:w, h:h]];
};
IF data.bActive THEN { 
vis _ ImagerBackdoor.TestViewRectangle[context: data.contextB, x:x, y:y, w:w, h:h];
};
};






END.

–-- ImagerForkContextImpl.mesa
-- Mik Lamming - July 30, 1986 5:34:19 pm PDT
-- Last edited by: Mik Lamming - September 27, 1986 2:37:46 pm PDT

Κ˜Jš
œ™J™-J™BJ™IcodešΟk	œλ
˜τ
K˜
KšΠlnœœ
˜$Kšœ˜Kšœ&˜-K˜Kšœ˜K˜Kšœœ˜"Kšœ
œ
œΟc˜LK˜šœœœ
˜K˜—Kšœ
œ˜'Kšœ	œ˜'Kšœœ˜Kšœœ˜+Kšœ	œ˜Kšœœ˜#Kšœœ˜)Kšœ	œ˜%Kšœœ"˜2Kšœœ"˜7Kšœœ˜Kšœœ˜1Kšœ
œ˜%Kšœœ˜%Kšœœ"˜1Kšœœ'˜;Kšœœ*˜AKšœœœ
˜Kšœœ˜Kšœ
œ˜+Kšœ
œ˜,Kšœ
œ!˜9Kšœœ˜%Kšœ	œ˜'Kšœœ˜*K˜Kšœœœ	˜šœ	œœ˜Kš
œ#˜#Kšœœ˜ K˜K˜—šœ-œ#˜SKš
œ˜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š
œ-˜-Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ%˜%Kš
œ%˜%Kš
œ˜Kš
œ˜Kš
œ'˜'Kš
œ!˜!Kš
œ#˜#Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ!˜!Kš
œ#˜#Kš
œ˜Kš
œ/˜/Kšœœ!˜AK˜K˜—K˜šΟnœœ&œ ˜`Kšœ
œ!˜1Kšœ
œ/œ˜LKš
œ˜—K˜š œœ#œ˜Dšœœ
˜š
œ˜Kš
œ#˜#Kš
œ˜—Kšœ
˜—Kš
œ˜K˜—š œœœ(˜ešœœ
˜š
œ˜Kšœ˜%Kš
œ˜—Kšœ
˜—Kšœœœ
˜Kš
œ˜K˜—K˜š 
œœœœ˜?Kšœ
œ˜"Kšœœ
˜Kš
œ+˜+šœœ˜šœœ˜š œœ˜Kš
œ$˜$Kš
œ@˜@K˜—Kš
œ$˜$Kš
œB˜BKš
œ
˜
—šœ˜Kš
œ$˜$Kš
œ@˜@K˜—K˜
—šœ˜šœœ˜Kš
œ$˜$Kš
œ@˜@Kš
œ
˜
—Kš
œ˜—Kš
œ+˜+Kš
œ˜—š 
œœ%œ˜=Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ9˜9K˜—šœœ˜Kš
œ#˜#Kš
œ:˜:K˜—Kš
œ˜—š œœ&œ
˜<Kš
œ˜Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ:˜:K˜—šœœ˜Kš
œ#˜#Kš
œ;˜;K˜—Kš
œ˜—š œœ)˜7Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ)˜)K˜—šœœ˜Kš
œ#˜#Kš
œ*˜*K˜—Kš
œ˜—š œœ"˜3Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ2˜2K˜—šœœ˜Kš
œ#˜#Kš
œ3˜3K˜—Kš
œ˜—š œœ$˜6Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ5˜5K˜—šœœ˜Kš
œ#˜#Kš
œ6˜6K˜—Kš
œ˜—š œœ(˜<Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ;˜;K˜—šœœ˜Kš
œ#˜#Kš
œ<˜<K˜—Kš
œ˜—š 
œœ œ
œ˜@Kšœ
œ˜"Kšœœ
˜šœœ˜Kš
œ#˜#Kšœ1˜7K˜—šœœ˜Kš
œ#˜#Kš
œ8˜8K˜—Kšœ	˜Kš
œ˜—š œœ!œ
œ˜CKšœ
œ˜"Kšœœ
˜
šœœ˜Kš
œ#˜#Kšœ2˜8K˜—šœœ˜Kš
œ#˜#Kš
œ9˜9K˜—Kšœ	˜Kš
œ˜—š œœœ˜<Kšœ
œ˜"Kš
œ˜šœœ˜Kš
œ#˜#Kšœ%˜+K˜—šœœ˜Kš
œ#˜#Kš
œ,˜,K˜—Kšœ	˜Kš
œ˜—š œœœ
˜5Kšœ
œ˜"Kš
œ
˜
šœœ˜Kš
œ#˜#Kšœ(˜.K˜—šœœ˜Kš
œ#˜#Kš
œ/˜/K˜—Kšœ	˜Kš
œ˜—š œœœ˜7Kšœ
œ˜"Kš
œ˜šœœ˜Kš
œ#˜#Kšœ)˜/K˜—šœœ˜Kš
œ#˜#Kš
œ0˜0K˜—Kšœ	˜Kš
œ˜—š œœœ
˜;Kšœ
œ˜"Kš
œ˜šœœ˜Kš
œ#˜#Kšœ+˜1K˜—šœœ˜Kš
œ#˜#Kš
œ2˜2K˜—Kšœ	˜Kš
œ˜—š œœ)˜:Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ,˜,K˜—šœœ˜Kš
œ#˜#Kš
œ-˜-K˜—Kš
œ˜—š œœœ˜/Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ,˜,K˜—šœœ˜Kš
œ#˜#Kš
œ-˜-K˜—Kš
œ˜—š œœœ˜0Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ,˜,K˜—šœœ˜Kš
œ#˜#Kš
œ-˜-K˜—Kš
œ˜—š œœœ˜2Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ/˜/K˜—šœœ˜Kš
œ#˜#Kš
œ0˜0K˜—Kš
œ˜—š œœœ˜3Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ5˜5K˜—šœœ˜Kš
œ#˜#Kš
œ6˜6K˜—Kš
œ˜—š 	œœœ˜-Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ*˜*K˜—šœœ˜Kš
œ#˜#Kš
œ+˜+K˜—Kš
œ˜—š œœœ˜0Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ-˜-K˜—šœœ˜Kš
œ#˜#Kš
œ.˜.K˜—Kš
œ˜—š
 	œœœœ
œ˜AKšœ
œ˜"Kšœœ
˜šœœ˜Kš
œ#˜#Kšœ8˜>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š
œ˜—š œœœ˜4Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ1˜1K˜—šœœ˜Kš
œ#˜#Kš
œ2˜2K˜—Kš
œ˜—š 	œœœ˜.Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ*˜*K˜—šœœ˜Kš
œ#˜#Kš
œ+˜+K˜—Kš
œ˜—š œœœ˜9Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ6˜6K˜—šœœ˜Kš
œ#˜#Kš
œ7˜7K˜—Kš
œ˜—š œœœ˜;Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ8˜8K˜—šœœ˜Kš
œ#˜#Kš
œ9˜9K˜—Kš
œ˜—š œœœ˜5Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ6˜6K˜—šœœ˜Kš
œ#˜#Kš
œ7˜7K˜—Kš
œ˜—š œœœ
œ˜GKšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œJ˜JK˜—šœœ˜Kš
œ#˜#Kš
œK˜KK˜—Kš
œ˜—š œœœ˜0Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ,˜,K˜—šœœ˜Kš
œ#˜#Kš
œ-˜-K˜—Kš
œ˜—š œœW˜pKšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œZ˜ZK˜—šœœ˜Kš
œ#˜#Kš
œ[˜[K˜—Kš
œ˜—š œœ=œ˜_Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œJ˜JK˜—šœœ˜Kš
œ#˜#Kš
œK˜KK˜—Kš
œ˜—š œœ,œœ˜RKšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œS˜SK˜—šœœ˜Kš
œ#˜#Kš
œT˜TK˜—Kš
œ˜—š œœ*œ˜JKšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œD˜DK˜—šœœ˜Kš
œ#˜#Kš
œE˜EK˜—Kš
œ˜—š œœœœ˜RKšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œW˜WK˜—šœœ˜Kš
œ#˜#Kš
œX˜XK˜—Kš
œ˜—š œœ/œ˜FKšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ?˜?K˜—šœœ˜Kš
œ#˜#Kš
œ@˜@K˜—Kš
œ˜—š œœœ
œ
œœœ˜_Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œW˜WK˜—šœœ˜Kš
œ#˜#Kš
œX˜XK˜—Kš
œ˜—š œœ-œ˜HKšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œE˜EK˜—šœœ˜Kš
œ#˜#Kš
œF˜FK˜—Kš
œ˜—š œœ%˜<Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ2˜2K˜—šœœ˜Kš
œ#˜#Kš
œ3˜3K˜—Kš
œ˜—š œœ œ˜DKšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œE˜EK˜—šœœ˜Kš
œ#˜#Kš
œF˜FK˜—Kš
œ˜—š œœ,œ˜IKšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œE˜EK˜—šœœ˜Kš
œ#˜#Kš
œF˜FK˜—Kš
œ˜—š œœœ˜8Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ9˜9K˜—šœœ˜Kš
œ#˜#Kš
œ:˜:K˜—Kš
œ˜—š œœ1œœœœœœ˜
Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
Ϡ
˜†
K˜—šœœ˜Kš
œ#˜#Kš
œ‡
˜‡
K˜—Kš
œ˜—š 
œœ'˜:Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ0˜0K˜—šœœ˜Kš
œ#˜#Kš
œ1˜1K˜—Kš
œ˜—š œœœ
œœœœ
œ˜Š
Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ”
˜”
K˜—šœœ˜Kš
œ#˜#Kš
ϥ
˜•
K˜—Kš
œ˜—š œœœ
œœœœ
œ˜Š
Kšœ
œ˜"šœœ˜Kš
œ#˜#Kš
œ”
˜”
K˜—šœœ˜Kš
œ#˜#Kš
ϥ
˜•
K˜—Kš
œ˜—š œœœ˜IKšœ
œ˜"Kš
œ˜šœœ˜Kš
œ#˜#Kšœ5˜;K˜—šœœ˜Kš
œ#˜#Kš
œ<˜<K˜—Kšœ	˜Kš
œ˜—K˜š 	œœ˜&Kšœ
œ˜"šœœ˜Jš
œ1˜1K˜—šœœ˜Jš
œ1˜1K˜—Kš
œ˜—š œœœ˜:Kšœ
œ˜"šœœ˜Jš
œ@˜@K˜—šœœ˜Jš
œ@˜@K˜—Kš
œ˜—š œœ,œœ˜RKšœ
œ˜"šœœ˜Jš
œ^˜^K˜—šœœ˜Jš
œ^˜^K˜—Kš
œ˜—š œœ œœ˜SKšœ
œ˜"šœœ˜Jš
œ_˜_K˜—šœœ˜Jš
œ_˜_K˜—Kš
œ˜—š
 œœœœœ˜DKšœ
œ˜"šœœ˜Jšœ=˜CK˜—šœœ˜Jš
œ?˜?K˜—Kš
œ˜—š
 œœœœœ˜DKšœ
œ˜"šœœ˜Jšœ=˜CK˜—šœœ˜Jš
œ?˜?K˜—Kš
œ˜—š œœœœœœ˜DKšœ
œ˜"šœœ˜Jšœ=˜CK˜—šœœ˜Jš
œ?˜?K˜—Kš
œ˜—š œœœœœœ˜DKšœ
œ˜"šœœ˜Jšœ=˜CK˜—šœœ˜Jš
œ?˜?K˜—Kš
œ˜—š œœœœœœ˜FKšœ
œ˜"šœœ˜Jšœ?˜EK˜—šœœ˜Jš
œA˜AK˜—Kš
œ˜—š œœœœœœ˜FKšœ
œ˜"šœœ˜Jšœ?˜EK˜—šœœ˜Jš
œA˜AK˜—Kš
œ˜—š œœœ'œ˜^Kšœ
œ˜"šœœ˜Jš
œ
˜
K˜—šœœ˜Jš
œ
˜
K˜—Kš
œ˜—š
 œœœœœ%˜lKšœ
œ˜"šœœ˜JšœO˜UK˜—šœœ˜Jš
œS˜SK˜—Kš
œ˜—K˜K˜K˜K˜K˜K˜Kšœ
˜J˜—…—eH‚ζ