CDVDraw.mesa
Copyright © 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
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] =
-- 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
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;
--Arbitrary: rectangles smaller than 1 pixel are not drawn.
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
--r in design coordinates
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] =
--draw exclusive high border pixels
TRUSTED INLINE BEGIN
--no empty test; is guaranteed by caller
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;
--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
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
--r in design coordinates
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
--no empty test; is guaranteed by caller
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;
--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
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;
--RepaintBackground
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.vy ← distance from top of screen to bottom most pixel
-- in pixels
me.vx ← me.viewer.cx+me.viewer.wx;
me.vy ← me.frame.height-(me.viewer.cy+me.viewer.wy);
--fixed fooBBptr initializations
--done in "viewer" process: me.fooBBptr ← PrincOpsUtils.AlignedBBTable[@fooBTableSpace];
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] =
-- 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.
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] =
--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
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
]];
--old, slower version
Imager.TranslateT[pr.deviceContext, [pos.x, pos.y]];
CDOrient.OrientateContext[pr.deviceContext, ob.size, orient];
};
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𡤋itBlitOutLineGrey]];
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.