-- 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
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.