DIRECTORY
Basics USING [BITSHIFT, BITAND, LongMult, logBitsPerWord],
CD,
CDBasics,
CDColors,
CDInstances,
CDOps,
CDOrient,
CDPrivate,
CDProperties,
CDTexts,
CDVPrivate,
CDVScale,
CedarProcess,
Imager, 
ImagerFont,
ImagerTransformation,
List,
PrincOps USING [BBptr, BitAddress, BBTable, SrcDesc, BitBltFlags, GrayParm],
PrincOpsUtils USING [BITBLT],
Rope,
RuntimeError,
Terminal,
VFonts, 
ViewerClasses,
ViewerSpecs;

CDVDraw: CEDAR MONITOR
IMPORTS Basics, CD, CDBasics, CDColors, CDInstances, CDOps, CDOrient, CDVPrivate, CDProperties, CDVScale, CedarProcess, Imager, ImagerFont, ImagerTransformation, List, PrincOpsUtils, RuntimeError, Terminal, VFonts
EXPORTS CDVPrivate, CD --DrawRef's private fields-- =
BEGIN

VRef: TYPE = CDVPrivate.VRef;
ViewerPrivateRep: PUBLIC TYPE = CDVPrivate.VRec;

virtual: Terminal.Virtual = Terminal.Current[];
blackBrick: REF CDColors.Brick = NEW[CDColors.Brick_ALL[LAST[CARDINAL]]];
whiteBrick: REF CDColors.Brick = NEW[CDColors.Brick_ALL[0]];
defaultFont: Imager.Font = VFonts.DefaultFont[];

maskModBitsPerWord: CARDINAL = 15;


IncludeAPainterRec: PUBLIC ENTRY PROC [me: CDVPrivate.VRef, pr: REF CDVPrivate.PainterRec] =
TRUSTED BEGIN ENABLE UNWIND => NULL;
IF ~List.Memb[ref: pr, list: LOOPHOLE[me.painterList]] THEN 
me.painterList _ CONS[pr, me.painterList];
END;

RemoveAPainterRec: PUBLIC ENTRY PROC [me: CDVPrivate.VRef, pr: REF CDVPrivate.PainterRec] =
TRUSTED BEGIN ENABLE UNWIND => NULL;
me.painterList _ LOOPHOLE[List.DRemove[ref: pr, list: LOOPHOLE[me.painterList]]];
END;

CheckPriority: PUBLIC CD.CheckPriorityProc =
BEGIN
IF pr.checkPriority THEN {
WITH pr.devicePrivate SELECT FROM
me: CDVPrivate.VRef => {
IF me.slowDown THEN {
CedarProcess.SetPriority[CedarProcess.Priority[background]]; 
me.slowDown _ FALSE;
};
IF me.hurryUp THEN { --this will be executed only after the other slowed down ...
CedarProcess.SetPriority[CedarProcess.Priority[normal]]; 
me.hurryUp _ FALSE;
};
me.check _ FALSE;
};
ENDCASE => NULL;
pr.checkPriority _ FALSE;
};
END; 

BitBlitDraw: PROC[me: VRef, r: CD.Rect, color: REF CDColors.Brick] = {
InlineBitBlitDraw[me, r, color];
};

InlineBitBlitDraw: PROC[me: VRef, r: CD.Rect, color: REF CDColors.Brick] =
TRUSTED INLINE BEGIN
ENABLE RuntimeError.UNCAUGHT => {
IF CDVPrivate.catchAny THEN GOTO oops ELSE REJECT;
};
xBit, x1, x2, y1, y2: CARDINAL;
vr: CD.Rect;
IF r.x1>r.x2 OR r.y1>r.y2 THEN RETURN; --silly bad guys could cause overflow
vr _ CDVScale.DesignToViewerRect[me.scale, r]; 
x1 _ MAX[vr.x1, 0]; 
y1 _ MAX[vr.y1, 0]; 
x2 _ MIN[vr.x2, me.viewer.cw]; 	
y2 _ MIN[vr.y2, me.viewer.ch];
IF x1>=x2 OR y1>=y2 THEN RETURN; 
xBit _ Basics.BITSHIFT[x1+me.vx, me.logbpp];
me.pBBptr.width _ Basics.BITSHIFT[x2-x1, me.logbpp];
me.pBBptr.height _ y2-y1;
y1 _ me.vy-y2;
me.pBBptr.dst _ [
me.screen 
+ Basics.LongMult[y1, me.scWidthWords]
+ LONG[Basics.BITSHIFT[xBit, -Basics.logBitsPerWord]],,
Basics.BITAND[xBit, maskModBitsPerWord]
];
me.pBBptr.src _ [ 
LOOPHOLE[ 
LOOPHOLE[color, LONG CARDINAL] + Basics.BITAND[y1, 3], LONG POINTER],, 
Basics.BITAND[xBit, maskModBitsPerWord]
];
me.pBBptr.srcDesc.gray.yOffset _ Basics.BITAND[y1, 3];
IF me.display=bw THEN PrincOpsUtils.BITBLT[me.pBBptr]
ELSE {
Blit: PROC [] = TRUSTED {
PrincOpsUtils.BITBLT[me.pBBptr];
};
Terminal.ModifyColorFrame[vt: virtual, 
action: Blit,
xmin: x1+me.vx, 
ymin: y1, 
xmax: x2+me.vx, 
ymax: y1+me.pBBptr.height
];
};
EXITS oops => NULL;
END;

BitBlitOutLine: ENTRY PROC[r: CD.Rect, pr: CD.DrawRef] = 
BEGIN
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {
IF CDVPrivate.catchAny THEN GOTO oops ELSE REJECT;
};
};
me: VRef = pr.viewerPrivate;
vr: CD.Rect;      --in viewer coordinates
clipVr: CD.Rect; --in viewer coordinates

DrawBlack: PROC[me: VRef, x1, y1, x2, y2: INTEGER] = 
TRUSTED INLINE BEGIN
xBits: CARDINAL = Basics.BITSHIFT[x1+INTEGER[me.vx], me.logbpp]; 
me.oBBptr.width _ Basics.BITSHIFT[x2-x1, me.logbpp];
me.oBBptr.height _ y2-y1;
me.oBBptr.dst _ [
me.screen 
+ Basics.LongMult[INTEGER[me.vy]-y2, me.scWidthWords] 
+ LONG[Basics.BITSHIFT[xBits, -Basics.logBitsPerWord]],,
Basics.BITAND[xBits, maskModBitsPerWord]
];
PrincOpsUtils.BITBLT[me.oBBptr];
END;

DoIt: PROC [] =
BEGIN
IF vr.x1>=clipVr.x1 THEN DrawBlack[me, clipVr.x1, clipVr.y1, clipVr.x1+1, clipVr.y2]; --left
IF vr.y2<=clipVr.y2 THEN DrawBlack[me, clipVr.x1, clipVr.y2-1, clipVr.x2, clipVr.y2]; --top
IF vr.x2<=clipVr.x2 THEN DrawBlack[me, clipVr.x2-1, clipVr.y1, clipVr.x2, clipVr.y2]; --right
IF vr.y1>=clipVr.y1 THEN DrawBlack[me, clipVr.x1, clipVr.y1, clipVr.x2, clipVr.y1+1]; --bot
END;
IF r.x2>me.dClip.x2 THEN r.x2 _ me.dClip.x2+1;
IF r.y2>me.dClip.y2 THEN r.y2 _ me.dClip.y2+1;
IF r.x1<me.dClip.x1 THEN r.x1 _ me.dClip.x1-1;
IF r.y1<me.dClip.y1 THEN r.y1 _ me.dClip.y1-1;
vr _ CDVScale.DesignToViewerRect[me.scale, r];
clipVr _ CDBasics.Intersection[ --remember: interestClip can be smaller than viewer
CDVScale.DesignToViewerRect[me.scale, me.deviceDrawRef.interestClip], 
vr
];
clipVr.x1 _ MAX[clipVr.x1, 0];
clipVr.y1 _ MAX[clipVr.y1, 0];
clipVr.x2 _ MIN[clipVr.x2, LONG[me.viewer.cw]];
clipVr.y2 _ MIN[clipVr.y2, LONG[me.viewer.ch]];
IF clipVr.x1>=clipVr.x2 OR clipVr.y1>=clipVr.y2 THEN RETURN; 
--harder empty test than CDBasics
--necessary because we add/subtract one
IF me.display=bw THEN DoIt[]
ELSE Terminal.ModifyColorFrame[vt: virtual, 
action: DoIt,
xmin: clipVr.x1+me.vx, 
ymin: me.vy+1-clipVr.y2, 
xmax: clipVr.x2+me.vx-1, 
ymax: me.vy-clipVr.y1
];
EXITS oops => NULL;
END;

greyBrick1: REF CDColors.Brick = NEW[CDColors.Brick_[8888h, 4444h, 2222h, 1111h]];
greyBrick8: REF CDColors.Brick = NEW[CDColors.Brick_[07C7CH, 07C7CH, 07C7CH, 07C7CH]];

BitBlitOutLineGrey: ENTRY PROC[r: CD.Rect, pr: CD.DrawRef] = 
TRUSTED BEGIN
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {
IF CDVPrivate.catchAny THEN GOTO oops ELSE REJECT;
};
};
me: VRef = pr.viewerPrivate;
vr: CD.Rect;      --in viewer coordinates
clipVr: CD.Rect; --in viewer coordinates
color: REF CDColors.Brick;

DrawGrey: PROC[me: VRef, x1, y1, x2, y2: INTEGER] = 
TRUSTED INLINE BEGIN
xBits: CARDINAL = Basics.BITSHIFT[x1+INTEGER[me.vx], me.logbpp]; 
me.xBBptr.width _ Basics.BITSHIFT[x2-x1, me.logbpp];
me.xBBptr.height _ y2-y1;
y1 _ me.vy-y2;
me.xBBptr.dst _ [
me.screen 
+ Basics.LongMult[y1, me.scWidthWords] 
+ LONG[Basics.BITSHIFT[xBits, -Basics.logBitsPerWord]],,
Basics.BITAND[xBits, maskModBitsPerWord]
];
me.xBBptr.src _ [ 
LOOPHOLE[ 
LOOPHOLE[color, LONG CARDINAL] + Basics.BITAND[y1, 3], LONG POINTER],, 
Basics.BITAND[xBits, maskModBitsPerWord]
];
me.xBBptr.srcDesc.gray.yOffset _ Basics.BITAND[y1, 3];
PrincOpsUtils.BITBLT[me.xBBptr];
END;

DoIt: PROC [] =
TRUSTED BEGIN
IF vr.x1>=clipVr.x1 THEN DrawGrey[me, clipVr.x1, clipVr.y1, clipVr.x1+1, clipVr.y2]; --left
IF vr.y2<=clipVr.y2 THEN DrawGrey[me, clipVr.x1, clipVr.y2-1, clipVr.x2, clipVr.y2]; --top
IF vr.x2<=clipVr.x2 THEN DrawGrey[me, clipVr.x2-1, clipVr.y1, clipVr.x2, clipVr.y2]; --right
IF vr.y1>=clipVr.y1 THEN DrawGrey[me, clipVr.x1, clipVr.y1, clipVr.x2, clipVr.y1+1]; --bot
END;
IF r.x2>me.dClip.x2 THEN r.x2 _ me.dClip.x2+1;
IF r.y2>me.dClip.y2 THEN r.y2 _ me.dClip.y2+1;
IF r.x1<me.dClip.x1 THEN r.x1 _ me.dClip.x1-1;
IF r.y1<me.dClip.y1 THEN r.y1 _ me.dClip.y1-1;
vr _ CDVScale.DesignToViewerRect[me.scale, r];
clipVr _ CDBasics.Intersection[ --remember: interestClip can be smaller than viewer
CDVScale.DesignToViewerRect[me.scale, me.deviceDrawRef.interestClip], 
vr
];
clipVr.x1 _ MAX[clipVr.x1, 0];
clipVr.y1 _ MAX[clipVr.y1, 0];
clipVr.x2 _ MIN[clipVr.x2, LONG[me.viewer.cw]];
clipVr.y2 _ MIN[clipVr.y2, LONG[me.viewer.ch]];
IF clipVr.x1>=clipVr.x2 OR clipVr.y1>=clipVr.y2 THEN RETURN; 
--harder empty test than CDBasics
--necessary because we add/subtract one
me.xBBptr^ _ PrincOps.BBTable[
dst: TRASH,
dstBpl: me.frame.width*me.frame.bitsPerPixel,
src: TRASH,
srcDesc: PrincOps.SrcDesc[gray[PrincOps.GrayParm[
yOffset: 0, --is actually trash
widthMinusOne: 0, --words
heightMinusOne: 3 --lines 
]]],
width: TRASH,
height: TRASH,
flags: PrincOps.BitBltFlags[
direction: forward,
disjoint: TRUE,
disjointItems: TRUE,
gray: TRUE,
srcFunc: null,
dstFunc: or
]
];
IF me.display=bw THEN {
color _ greyBrick1;
DoIt[]
}
ELSE {
color _ greyBrick8;
Terminal.ModifyColorFrame[vt: virtual, 
action: DoIt,
xmin: clipVr.x1+me.vx, 
ymin: me.vy+1-clipVr.y2, 
xmax: clipVr.x2+me.vx-1, 
ymax: me.vy-clipVr.y1
];
}
EXITS oops => NULL;
END;

BitBlitDrawRectForViewers: ENTRY PROC[r: CD.Rect, l: CD.Layer, pr: CD.DrawRef] =
BEGIN
ENABLE UNWIND => NULL;
me: VRef = pr.viewerPrivate; 
InlineBitBlitDraw[me, CDBasics.Intersection[r, pr.interestClip], me.colorTable[l]];
END;

SetGround: --CD.SetGroundProc-- PROC [pr: CD.DrawRef, pushedOut: BOOL] =
BEGIN
WITH pr.devicePrivate SELECT FROM
me: VRef => 
me.colorTable _ me.personalColors[me.display][IF pushedOut THEN pushedOut ELSE normal]
ENDCASE => NULL;
END;

DrawCommentForViewers: PUBLIC PROC[r: CD.Rect, comment: Rope.ROPE, pr: CD.DrawRef] = 
BEGIN
topToFontLine: NAT = 9+2;
fontHeight: NAT = 10;
leftMargin: NAT = 2;
bothMargin: NAT = 2*leftMargin;
me: VRef _ NARROW[pr.devicePrivate];
vr: CD.Rect _ CDVScale.DesignToViewerRect[me.scale, r];
IF vr.y2-vr.y1>fontHeight THEN {
xw: REAL = ImagerFont.RopeWidth[font: defaultFont, rope: comment].x;
IF vr.x2-vr.x1>xw+bothMargin THEN {
Imager.SetColor[me.viewContext, Imager.black];
Imager.SetFont[me.viewContext, defaultFont];
Imager.SetXY[me.viewContext, [vr.x1+leftMargin, vr.y2-topToFontLine]];
Imager.ShowRope[me.viewContext, comment];
}
};
END;

RepaintRectAreaInViewer: PUBLIC PROC[me: VRef, rect: CD.Rect, eraseFirst: BOOL] =
BEGIN
ENABLE {
RuntimeError.UNCAUGHT => IF CDVPrivate.catchAny THEN GOTO oops ELSE REJECT
};
interestRect: CD.Rect;
ReUseDrawInformation[me];
me.deviceDrawRef.interestClip _ interestRect _ CDBasics.Intersection[rect, me.dClip];
IF CDBasics.NonEmpty[interestRect] THEN {
RepaintBackground[me, interestRect, eraseFirst];
CDOps.QuickDrawDesign[me.actualDesign, me.deviceDrawRef];
FOR pl: CDVPrivate.PainterList _ me.painterList, pl.rest WHILE pl#NIL DO
IF CDBasics.Intersect[interestRect, pl.first.rect] THEN
pl.first.proc[me, pl.first, interestRect !
RuntimeError.UNCAUGHT => IF CDVPrivate.catchAny THEN CONTINUE ELSE REJECT
]
ENDLOOP
}
EXITS oops=> NULL
END;

RepaintBackground: PUBLIC ENTRY PROC[me: VRef, r: CD.Rect, eraseFirst: BOOL] = 
BEGIN
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {
IF CDVPrivate.catchAny THEN GOTO oops ELSE REJECT
};
};

DrawOutside: PROC [r: CD.Rect] =
BEGIN
BitBlitDraw[me, CDBasics.Intersection[r, me.dClip], me.colorTable[CD.backGround]];
END;

IF eraseFirst THEN {
TRUSTED {me.pBBptr.flags.dstFunc _ null};
BitBlitDraw[me, CDBasics.Intersection[r, me.dClip], whiteBrick];
TRUSTED {me.pBBptr.flags.dstFunc _ or};
};
IF me.actualDesign.actual.first.mightReplace#NIL AND me.environment AND
me.actualDesign.actual.first.mightReplace.ob#NIL THEN 
CDBasics.DecomposeRect[r: r, 
test: CDInstances.InstRectO[me.actualDesign.actual.first.mightReplace], 
outside: DrawOutside
];
EXITS oops => NULL;
END;

InitForBBLT: PROC [me: VRef] = 
INLINE --called only from one place..-- BEGIN
IF me.viewer.column=color THEN TRUSTED {
colorMode: Terminal.ColorMode = Terminal.GetColorMode[virtual];
IF colorMode.full THEN ERROR CDVPrivate.notSupportedColorMode;
SELECT colorMode.bitsPerPixelChannelA FROM
8 => {me.display _ bit8; me.logbpp _ 3};
1 => {me.display _ bit1; me.logbpp _ 0};
4 => {me.display _ bit4; me.logbpp _ 2};
2 => {me.display _ bit2; me.logbpp _ 1};
ENDCASE => ERROR CDVPrivate.notSupportedColorMode;
me.frame _ Terminal.GetColorFrameBufferA[virtual];
}
ELSE { -- b+w
me.display _ bw;
me.logbpp _ 0;
me.frame _ Terminal.GetBWFrameBuffer[virtual];
};
me.bpp _ me.frame.bitsPerPixel; 
me.screen _ me.frame.base;
me.colorTable _ me.personalColors[me.display][normal];
me.scWidthWords _ me.frame.wordsPerLine;

-- me.vx _ distance from left of screen to left most pixel
me.vx _ me.viewer.cx+me.viewer.wx; 
me.vy _ me.frame.height-(me.viewer.cy+me.viewer.wy);

TRUSTED {
me.pBBptr^ _ PrincOps.BBTable[
dst: TRASH,
dstBpl: me.frame.width*me.frame.bitsPerPixel,
src: [LOOPHOLE[blackBrick, LONG POINTER],,0],
srcDesc: PrincOps.SrcDesc[gray[PrincOps.GrayParm[
yOffset: 0, --is actually trash
widthMinusOne: 0, --words
heightMinusOne: 3 --lines 
]]],
width: TRASH,
height: TRASH,
flags: PrincOps.BitBltFlags[
direction: forward,
disjoint: TRUE,
disjointItems: TRUE,
gray: TRUE,
srcFunc: null,
dstFunc: or
]
];
me.oBBptr^ _ me.pBBptr^;
me.oBBptr.srcDesc _ PrincOps.SrcDesc[gray[PrincOps.GrayParm[
yOffset: 0,
widthMinusOne: 0, --words
heightMinusOne: 0 --lines 
]]];
me.xBBptr^ _ me.pBBptr^;
};
END;

CreateTransform: PROC [
cellSize: CD.Position, 
cellInstOrient: CD.Orientation, 
cellInstPos: CD.Position _ [0,0]]
RETURNS [Imager.Transformation] =
INLINE BEGIN 
RETURN [SELECT cellInstOrient FROM
--original--0 => 	ImagerTransformation.Create[1, 0, cellInstPos.x, 0, 1, cellInstPos.y],
1 =>		ImagerTransformation.Create[-1, 0, cellInstPos.x+cellSize.x, 0, 1, cellInstPos.y], -- reflection in x
--rotate90-- 2 =>	ImagerTransformation.Create[0, -1, cellInstPos.x+cellSize.y, 1, 0, cellInstPos.y], -- 90 degrees clockwise
3 =>			ImagerTransformation.Create[0, 1, cellInstPos.x, 1, 0, cellInstPos.y], -- 90 degrees clockwise followed by reflection in x
--rotate180-- 4 =>	ImagerTransformation.Create[-1, 0, cellInstPos.x+cellSize.x, 0, -1, cellInstPos.y+cellSize.y], -- 180 degrees clockwise
5 =>			ImagerTransformation.Create[1, 0, cellInstPos.x, 0, -1, cellInstPos.y+cellSize.y], -- 180 degrees clockwise followed by reflection in x
--rotate270-- 6 =>	ImagerTransformation.Create[0, 1, cellInstPos.x, -1, 0, cellInstPos.y+cellSize.x], -- 270 degrees clockwise
7 =>			ImagerTransformation.Create[0, -1, cellInstPos.x+cellSize.y, -1, 0, cellInstPos.y+cellSize.x], -- 270 degrees clockwise followed by reflection in x
ENDCASE => ERROR
];
END;

ViewerDrawContext: PROC [pr: CD.DrawRef, proc: CD.DrawContextLayerProc, ob: CD.Object, pos: CD.Position, orient: CD.Orientation, layer: CD.Layer] =
BEGIN
IF pr.deviceContext#NIL AND pr.contextFilter#NIL AND pr.contextFilter[layer]#NIL THEN { 

Action: PROC [] =
BEGIN
me: VRef = NARROW[pr.viewerPrivate];
Imager.ScaleT[pr.deviceContext, CDVScale.DesignToViewerFactor[me.scale]];
Imager.TranslateT[pr.deviceContext, [-me.scale.off.x, -me.scale.off.y]];
IF ob#NIL THEN {
IF orient=CD.original THEN Imager.TranslateT[pr.deviceContext, [pos.x, pos.y]]
ELSE Imager.ConcatT[pr.deviceContext, CreateTransform[
cellSize: ob.size,
cellInstOrient: orient,
cellInstPos: pos
]];
};
Imager.SetColor[pr.deviceContext, pr.contextFilter[layer]];
proc[pr.deviceContext, ob, layer];
END;

Imager.DoSave[pr.deviceContext, Action];
}
END;

ICreateDrawRef: INTERNAL PROC [me: VRef] =
BEGIN

GetContextFilter: INTERNAL PROC [me: VRef] RETURNS [REF CD.ContextFilter] =
INLINE BEGIN 
RETURN [IF me.bpp>1 THEN CDColors.colorFilter ELSE CDColors.bwFilter];
END; 

pr: CD.DrawRef = CD.CreateDrawRef[me.actualDesign];
me.deviceDrawRef _ pr;
pr.contextFilter _ me.contextFilter _ GetContextFilter[me];
pr.drawRect _ BitBlitDrawRectForViewers;
pr.drawOutLine _ BitBlitOutLine;
IF ~me.b4 THEN CDProperties.PutPropOnPropRef[pr.properties, $border, NEW[CD.DrawOutLineProc_BitBlitOutLineGrey]];
pr.drawComment _ DrawCommentForViewers;
pr.drawContext _ ViewerDrawContext;
pr.setGround _ SetGround; 
pr.priorityChecker _ CheckPriority; 
pr.devicePrivate _ me;
pr.stopFlag _ me.stoprequest;
pr.symbolics _ me.symbolics; 
pr.environment _ me.environment; 
pr.interestClip _ me.dClip _ CDVScale.GetClipRecord[me.intendedScale, me.viewer.cw, me.viewer.ch];
pr.minimalSize _  MIN[(me.dClip.x2-me.dClip.x1)/8, (me.dClip.y2-me.dClip.y1)/8];
pr.scaleHint _ CDVScale.DesignToViewerFactor[me.intendedScale]*me.suppressFactorForCells; 
pr.specialFonts _ me.specialFonts;
pr.checkPriority _ me.checkPriority;
pr.b4 _ me.b4;
pr.b5 _ me.b5;
InitForBBLT[me];
pr.viewerPrivate _ me;  -- this line last! it tells DummyNotify that the rest is initialized
END;

ReUseContext: PROC [pr: CD.DrawRef, me: VRef] = INLINE
BEGIN
pr.deviceContext _ me.viewContext;
Imager.SetColor[me.viewContext, Imager.black];
Imager.SetFont[me.viewContext, defaultFont];
END;

ReUseDrawInformation: ENTRY PROC [me: VRef] = INLINE
BEGIN 
ENABLE UNWIND => NULL;
IF me.deviceDrawRef=NIL THEN --usually not-- ICreateDrawRef[me];
ReUseContext[me.deviceDrawRef, me];
END; 

CreateDrawInformation: PUBLIC ENTRY PROC [me: VRef] =
BEGIN 
ICreateDrawRef[me];
ReUseContext[me.deviceDrawRef, me];
END; 

CDColors.DefineColor[CD.highLightShade, NEW[CDColors.Brick_[101H,0,0,0]], bw];
CDColors.DefineColor[CD.highLightShade, NEW[CDColors.Brick_[0,0F0FH,0,0]], bit4];
CDColors.DefineColor[CD.highLightShade, NEW[CDColors.Brick_[0,255,0,255]], bit8];
CDColors.DefineColor[CD.highLightError, NEW[CDColors.Brick_[101H,0,101H,0]], bw];
CDColors.DefineColor[CD.highLightError, NEW[CDColors.Brick_[0,0F0FH,0,0F0FH]], bit4];
CDColors.DefineColor[CD.highLightError, NEW[CDColors.Brick_[0,255,255,255]], bit8];
END.




²CDVDraw.mesa
Copyright c 1983, 1986 by Xerox Corporation.  All rights reserved.
Christian Jacobi, August 5, 1983 11:07 am
last edited by Christian Jacobi, March 12, 1986 6:11:49 pm PST
-- DONE OUTSIDE r _ CDBasics.Intersection[r, me.deviceDrawRef.interestClip];
--  this guarantees no arithmetic overflows if non empty; but there are nasty guys
-- calling this procedure with empty rects.
-- This is not a complete clip yet
--Arbitrary: rectangles smaller than 1 pixel are not drawn. 
--r in design coordinates
--draw exclusive high border pixels
--no empty test; is guaranteed by caller

--clip to area where
--1) small enough: it does not crash on scaling later
--2) big enough: if drawn, it does not draw artificial lines 
--r in design coordinates
--no empty test; is guaranteed by caller

--clip to area where
--1) small enough: it does not crash on scaling later
--2) big enough: if drawn, it does not draw artificial lines 
--RepaintBackground
-- me.vy _ distance from top of screen to bottom most pixel
-- 	in pixels
--fixed fooBBptr initializations
--done in "viewer" process: me.fooBBptr _ PrincOpsUtils.AlignedBBTable[@fooBTableSpace];
-- Given the size of a cell,
-- the position and orientation of an instance of that cell in "world"
-- co-ordinates, returns the transformation to be applied to
-- cell points to get world points.
--calls proc which may use context; mode and color are set to layer's need
--call is suppressed if layer does not need drawing; this is default.
--on recursive calls, the context may or may not include previous transformations
--old, slower version
Imager.TranslateT[pr.deviceContext, [pos.x, pos.y]];
CDOrient.OrientateContext[pr.deviceContext, ob.size, orient];
Κj˜
codeš
œ™Kšœ
Οm
œ7™BKš
œ)™)Kš
œ>™>K˜—š
Οk	˜	Kšœžœžœžœ˜:Kšžœ
˜K˜	K˜	K˜K˜K˜	K˜
K˜
K˜Kš
œ˜K˜	Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœ	žœ>˜LKšœžœžœ˜K˜Kš
œ
˜
Kš
œ	˜	Kš
œ˜Kš
œ˜K˜—K˜šΠblœžœ
ž˜KšžœžœΓ
˜Υ
Kšžœ
žœ
Οcœ˜5—Kš
ž˜K˜Kšœžœ˜Kšœžœ
žœ˜0K˜Kš
œ/˜/Kšœžœžœžœ
žœ
žœ˜IKšœžœžœžœ˜<Kš
œ0˜0K˜Kšœžœ˜"K˜K˜š
Οnœžœ
žœ
žœžœ˜\Kšž
œ
žœ
žœžœ
˜$šžœžœžœ
˜<Kšœžœ˜*—Kšžœ
˜—K˜š‘œžœžœ˜[Kš
ž$˜$Kšœžœžœ˜QKšžœ
˜—K˜šΟb
œžœ
žœ˜,Kš
ž˜šžœžœ˜šžœžœ
ž˜!š
œ˜šžœ
žœ˜Kš
œ=˜=Kšœžœ
˜K˜—šžœžœ <˜QKš
œ9˜9Kšœ
žœ
˜K˜—Kšœžœ
˜K˜—Kšžœžœ
˜—Kšœžœ
˜Kš
œ˜—Kšžœ˜—K˜š‘œžœžœžœ˜FKš
œ ˜ Kš
œ˜—K˜š‘œžœžœžœ˜JKš
œL™LK™RK™+Kšœ’œ™"Kšžœ
žœ
ž˜šžœžœ˜!Kš
žœžœ
žœžœ
žœ
˜2K˜—Kšœžœ
˜Kšœžœ˜Kš	žœžœžœ
žœ %˜LKš
œ/˜/Kšœžœ˜Kšœžœ˜Kšœžœ˜ Kšœžœ˜šžœžœžœ
žœ˜!K™<—Kšœžœ˜,Kšœžœ˜4Kš
œ˜Kš
œ˜š
œ˜˜
Kš
œ&˜&Kšœžœžœ!˜7—Kšœžœ˜'K˜—š
œ˜šžœ˜
Kšžœžœ
žœžœ	žœ
žœ˜GKšœžœ˜'Kš
œ˜——Kšœ(žœ˜6Kšžœžœžœ˜5šžœ˜š‘œžœžœ˜Kšœžœ˜ Kš
œ˜—š
œ'˜'Kš
œ
˜
Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜—K˜—Kšžœ	žœ
˜Kšžœ
˜—K˜š
‘œžœ
žœžœžœ˜9Kš
ž˜K™šžœ˜Kšžœžœ
˜šœ
žœ˜Kš
žœžœ
žœžœ
žœ
˜2K˜—K˜—K˜Kšœžœ ˜)Kšœžœ ˜(K˜š‘	œžœžœ˜5Kš
œ#™#Kšžœ
žœ
ž˜Kš
œ(™(Kšœžœ
žœžœ˜AKšœžœ˜4Kš
œ˜š
œ˜˜
Kšœžœ˜6Kšœžœžœ"˜8—Kšœžœ˜(K˜—Kšœžœ˜ Kšžœ
˜K˜—š‘œžœ˜Kš
ž˜Kšžœžœ> ˜\Kšžœžœ> ˜[Kšžœžœ> ˜]Kšžœžœ> ˜[Kšžœ
˜—K™š
œ™K™5K™=—Kšžœžœ˜.Kšžœžœ˜.Kšžœžœ˜.Kšžœžœ˜.Kš
œ.˜.šœ  3˜SKš
œF˜FKš
œ˜Kš
œ˜—Kšœžœ˜Kšœžœ˜Kšœžœžœ˜/Kšœžœžœ˜/šžœžœžœ
žœ˜=Kš
 !˜!Kš
 '˜'—Kšžœžœ˜šžœ(˜,Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kšžœ	žœ
˜Kšžœ
˜K˜—Kšœžœžœ.˜RKšœžœžœ2˜VK˜š
‘œžœ
žœžœžœ˜=Kš
ž
˜
K™šžœ˜Kšžœžœ
˜šœ
žœ˜Kš
žœžœ
žœžœ
žœ
˜2K˜—K˜—K˜Kšœžœ ˜)Kšœžœ ˜(Kšœžœ˜K˜š‘œžœžœ˜4Kšžœ
žœ
ž˜Kš
œ(™(Kšœžœ
žœžœ˜AKšœžœ˜4Kš
œ˜Kš
œ˜š
œ˜˜
Kš
œ'˜'Kšœžœžœ"˜8—Kšœžœ˜(K˜—š
œ˜šžœ˜
Kšžœžœ
žœžœ	žœ
žœ˜GKšœžœ˜(Kš
œ˜——Kšœ(žœ˜6Kšœžœ˜ Kšžœ
˜K˜—š‘œžœ˜Kš
ž
˜
Kšžœžœ= ˜[Kšžœžœ= ˜ZKšžœžœ= ˜\Kšžœžœ= ˜ZKšžœ
˜—K™š
œ™K™5K™=—Kšžœžœ˜.Kšžœžœ˜.Kšžœžœ˜.Kšžœžœ˜.Kš
œ.˜.šœ  3˜SKš
œF˜FKš
œ˜Kš
œ˜—Kšœžœ˜Kšœžœ˜Kšœžœžœ˜/Kšœžœžœ˜/šžœžœžœ
žœ˜=Kš
 !˜!Kš
 '˜'—š
œ˜Kšœžœ
˜Kš
œ-˜-Kšœžœ
˜š
œ1˜1Kšœ ˜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˜—š‘œžœ
žœžœ
žœžœ˜PKš
ž˜Kšžœ
žœžœ
˜Kš
œ˜Kš
œS˜SKšžœ
˜K˜—š
‘	œ œ
žœžœžœ˜HKš
ž˜šžœžœ
ž˜!š
œ˜Kšœ.žœžœžœ˜V—Kšžœžœ
˜—Kšžœ
˜—K˜š‘œžœ
žœžœžœžœ˜UKš
ž˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜$Kšœžœ1˜7šžœžœ˜ Kšœžœ<˜Dšžœžœ˜#Kš
œ.˜.Kš
œ,˜,Kš
œF˜FKš
œ)˜)K˜
—K˜—Kšžœ
˜K˜—š
‘œžœ
žœžœžœ˜QKš
ž˜šžœ˜Kšœ
žœžœžœ
žœžœ
ž˜JKš
œ˜—Kšœžœ˜Kš
œ˜Kš
œU˜Ušžœ!žœ˜)Kš
œ0˜0Kš
œ9˜9šžœ6žœžœ
ž˜Hšžœ1ž˜7š
œ*˜*Kšœ
žœžœžœ
žœ
žœ
ž˜IKš
œ
˜
——Kš
ž˜—Kš
œ
˜
—Kšžœž˜Kšžœ
˜K˜—š‘œžœ
žœ
žœžœžœ˜OKš
ž˜šžœ˜Kšžœžœ
˜šœ
žœ˜Kš	žœžœ
žœžœ
ž˜1K˜—Kš
œ˜—K˜š‘œžœžœ˜ Kš
ž˜KšœBžœ˜RKšžœ
˜K˜—Kš
œ™šžœžœ˜Kšžœ"˜)Kš
œ@˜@Kšžœ ˜'K˜—šžœ+žœ
žœž˜GKšœ-žœ
žœ
˜6˜Kš
œH˜HK˜K˜——Kšžœ	žœ
˜Kšžœ
˜K˜—š‘œžœ˜Kšžœ
  œ
ž˜-šžœžœ
žœ˜(Kš
œ?˜?Kšžœžœ
žœ"˜>šžœ ž˜*Kš
œ(˜(Kš
œ(˜(Kš
œ(˜(Kš
œ(˜(Kšžœžœ"˜2—Kš
œ2˜2K˜
—šžœ ˜
Kš
œ˜Kš
œ˜Kš
œ.˜.K˜—Kš
œ ˜ Kš
œ˜Kš
œ6˜6Kš
œ(˜(K˜Kšœ	 1˜:Kšœ 0™;Kš
 
™
Kš
œ#˜#Kš
œ4˜4K˜Kš
œ ™ Kš
œX™Xšžœ˜	š
œ˜Kšœžœ
˜Kš
œ-˜-Kšœžœ
žœ
žœ˜-š
œ1˜1Kšœ ˜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š
œF™FKš
œ<™<Kš
œ#™#Kšžœ
žœ
˜
šžœžœž˜"Kš œL˜XKšœY ˜kKš œY ˜|KšœN 3˜
Kš 
œe ˜Š
KšœZ 4˜Ž
Kš 
œY ˜~Kšœf 4˜š
Kšžœž˜K˜—Kšžœ
˜K˜—š‘œžœžœžœžœžœžœžœ	˜“
Kš
œJ™JKš
œE™EKš
œQ™QKš
ž˜šžœžœ
žœžœ
žœžœ
žœ˜XK˜š‘œžœ˜Kš
ž˜Kšœžœ˜$Kš
œI˜IKš
œH˜Hšžœžœ
žœ˜Kšžœžœ
žœ4˜Nšžœ2˜6Kš
œ˜Kš
œ˜Kš
œ˜K˜—K™Kš
œ4™4Kš
œ=™=K˜—Kš
œ;˜;Kš
œ"˜"Kšžœ
˜—K˜Kš
œ(˜(K˜
—Kšžœ
˜—K˜š‘œžœ
žœ
˜*Kš
ž˜K˜š
‘œž
œžœžœ
žœ˜KKšžœ
˜
Kšžœžœ
žœžœ˜FKšžœ˜K˜—Kšœžœžœ ˜3Kš
œ˜Kš
œ;˜;Kš
œ(˜(K˜ Kšžœžœ7žœ
žœ&˜qKš
œ'˜'Kš
œ#˜#Kš
œ˜Kš
œ$˜$Kš
œ˜K˜Kš
œ˜Kš
œ!˜!Kš
œb˜bKšœžœ;˜PKš
œZ˜ZKš
œ"˜"Kšœž
œ˜$Kš
œ˜Kš
œ˜Kš
œ˜Kšœ D˜\Kšžœ
˜—K˜š‘œžœžœž˜6Kš
ž˜Kš
œ"˜"Kš
œ.˜.Kš
œ,˜,Kšžœ
˜—K˜š‘œžœ
žœž˜4Kšžœ
˜Kšžœ
žœžœ
˜Kšžœžœ
žœ
 œ˜@Kš
œ#˜#Kšžœ˜K˜—š‘œžœ
žœ
žœ
˜5Kšžœ
˜Kš
œ˜Kš
œ#˜#Kšžœ˜K˜—Kšœžœžœ#˜NKšœžœžœ&˜QKšœžœžœ&˜QKšœžœžœ&˜QKšœžœžœ*˜UKšœžœžœ(˜SKšžœ
˜K˜—…—B^