DIRECTORY
Basics USING [bitsPerWord],
CD,
CDApplications,
CDExtras,
CDInline,
CDOps,
CDOrient,
CDTexts,
CDVPrivate,
Graphics, 
GraphicsBasic,
GraphicsColor, 
GraphicsOps, 
PrincOps USING [BBptr, BitAddress],
PrincOpsUtils USING [BITBLT, BITSHIFT],
Real,
Rope,
RuntimeError,
Terminal,
TerminalExtras,
ViewerClasses,
ViewerSpecs;

CDVDraw: CEDAR MONITOR
IMPORTS CD, CDApplications, CDExtras, CDInline, CDOps, CDOrient, CDVPrivate, Graphics, GraphicsOps, PrincOpsUtils, Real, RuntimeError, Terminal, TerminalExtras
EXPORTS CDVPrivate, CD --DrawRef's private fields-- =
BEGIN

ViewerPrivateRep: PUBLIC TYPE ~ CDVPrivate.MyGraphicRec;
ViewerSaveRep: PUBLIC TYPE ~ INTEGER;   -- XXXX placeholder

MyGraphicRef: TYPE ~ CDVPrivate.MyGraphicRef;
MyGraphicRec: TYPE ~ CDVPrivate.MyGraphicRec;
maxInfluence: CD.DesignNumber ~ 0;
virtual: Terminal.Virtual ~ Terminal.Current[];
defaultFont: Graphics.FontRef ~ GraphicsOps.DefaultFont[];

errrorReport: RECORD [
text: Rope.ROPE,
me: MyGraphicRef, 
r: CD.Rect, 
color: REF CDVPrivate.Brick
];

blackBrick: REF CDVPrivate.Brick = NEW[CDVPrivate.Brick_ALL[LAST[CARDINAL]]];
whiteBrick: REF CDVPrivate.Brick = NEW[CDVPrivate.Brick_ALL[0]];
backBWBrick: REF CDVPrivate.Brick = NEW[CDVPrivate.Brick_[257,0,0,0]];
back4Brick: REF CDVPrivate.Brick = NEW[CDVPrivate.Brick_[0,10,0,11*256]];
back8Brick: REF CDVPrivate.Brick = NEW[CDVPrivate.Brick_[0,1,256,0]];



BitBlitDraw: --INTERNAL-- PROC[me: MyGraphicRef, r: CD.Rect, color: REF CDVPrivate.Brick] =
TRUSTED 
INLINE BEGIN
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {
errrorReport.text _ "BitBlitDraw";
errrorReport.me _ me;
errrorReport.r_r;
errrorReport.color_color;
IF CDVPrivate.catchAny THEN GOTO SomeError ELSE REJECT;
};
};
xBit, x1, x2, y1, y2: CARDINAL;
vr: CD.Rect;
IF ~CDInline.NonEmpty[r] THEN RETURN;
vr _ CDVPrivate.DesignToViewerRect[me, r];
x1 _ MAX[vr.x1, 0]; y1 _ MAX[vr.y1, 0]; 
IF vr.x2<=0 OR vr.y2<=0 THEN RETURN;
x2 _ MIN[vr.x2, me.vwminus1]; y2 _ MIN[vr.y2, me.vhminus1];
IF x1>=x2 OR y1>=y2 THEN RETURN;
xBit _ PrincOpsUtils.BITSHIFT[(x1+me.vx), me.logbpp];
me.xBLT.width _ PrincOpsUtils.BITSHIFT[(x2 --+1-- -x1), me.logbpp];
me.xBLT.height _ (y2 --+1-- -y1);
y1 _ me.vy-y2;
me.xBLT.dst _ [
me.screen 
+ (LONG[y1]*LONG[me.scWidthWords])
+ LONG[(xBit/Basics.bitsPerWord)],,
xBit MOD Basics.bitsPerWord
];
me.xBLT.src _ [ 
LOOPHOLE[ 
LOOPHOLE[color, LONG CARDINAL] +
y1 MOD 4, LONG POINTER],,
xBit MOD Basics.bitsPerWord];
me.xBLT.srcDesc.gray.yOffset _ y1 MOD 4;
IF me.bpp=1 THEN PrincOpsUtils.BITBLT[me.xBLT]
ELSE {
TerminalExtras.LockColorFrame[vt: virtual, 
xmin: x1+me.vx, 
ymin: y1, 
xmax: x2+me.vx --+1-- , 
ymax: y1+me.xBLT.height
];
PrincOpsUtils.BITBLT[me.xBLT];
TerminalExtras.UnlockColorFrame[virtual]
};
EXITS
SomeError => NULL;
END;

BitBlitSave: ENTRY PROC[me: MyGraphicRef, r: CD.Rect, color: REF CDVPrivate.Brick, clearPattern: REF CDVPrivate.Brick_NIL] =
TRUSTED  BEGIN
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {
errrorReport.text _ "BitBlitSave";
errrorReport.me _ me;
errrorReport.r_r;
errrorReport.color_color;
IF CDVPrivate.catchAny THEN GOTO SomeError ELSE REJECT;
};
};
xBit, x1, x2, y1, y2: CARDINAL;
vr: CD.Rect;
r _ CDInline.Intersection[r, me.deviceDrawRef.worldClip];
IF ~CDInline.NonEmpty[r] THEN RETURN;
vr _ CDVPrivate.DesignToViewerRect[me, r];
x1 _ MAX[vr.x1, 0]; y1 _ MAX[vr.y1, 0]; 
IF vr.x2<=0 OR vr.y2<=0 THEN RETURN;
x2 _ MIN[vr.x2, me.vwminus1]; y2 _ MIN[vr.y2, me.vhminus1];
IF x1>=x2 OR y1>=y2 THEN RETURN;
xBit _ PrincOpsUtils.BITSHIFT[(x1+me.vx), me.logbpp];
me.xBLT.width _ PrincOpsUtils.BITSHIFT[(x2 --+1-- -x1), me.logbpp];
me.xBLT.height _ (y2 --+1-- -y1);
y1 _ me.vy-y2;
me.xBLT.dst _ [
me.screen 
+ (LONG[y1]*LONG[me.scWidthWords])
+ LONG[(xBit/Basics.bitsPerWord)],,
xBit MOD Basics.bitsPerWord
];
me.xBLT.srcDesc.gray.yOffset _ y1 MOD 4;
IF me.bpp#1 THEN TerminalExtras.LockColorFrame[vt: virtual, 
xmin: x1+me.vx, 
ymin: y1, 
xmax: x2+me.vx --+1-- , 
ymax: y1+me.xBLT.height
];
IF clearPattern#NIL THEN {
me.xBLT.flags.dstFunc _ and;
me.xBLT.flags.srcFunc _ complement;
me.xBLT.src _ [ 
LOOPHOLE[ 
LOOPHOLE[clearPattern, LONG CARDINAL] +
y1 MOD 4, LONG POINTER],,
xBit MOD Basics.bitsPerWord];
PrincOpsUtils.BITBLT[me.xBLT];
me.xBLT.flags.srcFunc _ null;
me.xBLT.flags.dstFunc _ or;
};
me.xBLT.src _ [ 
LOOPHOLE[ 
LOOPHOLE[color, LONG CARDINAL] +
y1 MOD 4, LONG POINTER],,
xBit MOD Basics.bitsPerWord];
PrincOpsUtils.BITBLT[me.xBLT];
IF me.bpp#1 THEN TerminalExtras.UnlockColorFrame[virtual];
EXITS
SomeError => NULL;
END;

BitBlitOutLine: ENTRY PROC[r: CD.Rect, pr: CD.DrawRef] = 
BEGIN
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {
errrorReport.text _ "BitBlitOutLine";
errrorReport.me _ pr.viewerPrivate;
errrorReport.r_r;
IF CDVPrivate.catchAny THEN GOTO SomeError ELSE REJECT;
};
};
me: MyGraphicRef ~ pr.viewerPrivate;
vr: CD.Rect;

DrawBlack: --INTERNAL-- PROC[me: MyGraphicRef, xx1, yy1, xx2, yy2: INT] = 
TRUSTED INLINE BEGIN
xBits, x1, x2, y1, y2: CARDINAL; 
IF xx2<=0 OR yy2<=0 OR xx1>me.vwminus1 OR yy1>me.vhminus1 THEN RETURN;
x1 _ MAX[xx1, LONG[0]];
y1 _ MAX[yy1, LONG[0]];
x2 _ MIN[xx2, LONG[me.vwminus1]];
y2 _ MIN[yy2, LONG[me.vhminus1]];
me.bBLT.width _ PrincOpsUtils.BITSHIFT[(x2 --+1-- -x1), me.logbpp];
me.bBLT.height _ (y2 --+1-- -y1);
xBits _ PrincOpsUtils.BITSHIFT[(x1+me.vx), me.logbpp];
y1 _ me.vy-y2;
me.bBLT.dst _ [
me.screen 
+ (LONG[y1]*LONG[me.scWidthWords]) 
+ LONG[(xBits/Basics.bitsPerWord)],,
xBits MOD Basics.bitsPerWord
];
IF me.bpp=1 THEN PrincOpsUtils.BITBLT[me.bBLT]
ELSE {
TerminalExtras.LockColorFrame[vt: virtual,
xmin: x1+me.vx, 
ymin: y1, 
xmax: x2+me.vx --+1--, 
ymax: y1+me.bBLT.height
];
PrincOpsUtils.BITBLT[me.bBLT];
};
END;

IF r.x2>me.deviceDrawRef.worldClip.x2 THEN r.x2_me.deviceDrawRef.worldClip.x2+1;
IF r.y2>me.deviceDrawRef.worldClip.y2 THEN r.y2_me.deviceDrawRef.worldClip.y2+1;
IF r.x1<me.deviceDrawRef.worldClip.x1 THEN r.x1_me.deviceDrawRef.worldClip.x1-1;
IF r.y1<me.deviceDrawRef.worldClip.y1 THEN r.y1_me.deviceDrawRef.worldClip.y1-1;
vr _ CDVPrivate.DesignToViewerRect[me, r];
IF ~CDInline.NonEmpty[vr] THEN RETURN; --empty
DrawBlack[me, vr.x1, vr.y1, vr.x1+1, vr.y2]; --left
DrawBlack[me, vr.x1, vr.y2-1, vr.x2, vr.y2]; --top
DrawBlack[me, vr.x2-1, vr.y1, vr.x2, vr.y2]; --right
DrawBlack[me, vr.x1, vr.y1, vr.x2, vr.y1+1]; --bottom
TerminalExtras.UnlockColorFrame[virtual]; 
EXITS
SomeError => NULL;
END;

BitBlitDrawRectForViewers: ENTRY PROC[r: CD.Rect, l: CD.Level, pr: CD.DrawRef] =
BEGIN
ENABLE UNWIND => NULL;
me: MyGraphicRef = pr.viewerPrivate; 
BitBlitDraw[me, CDInline.Intersection[r, pr.worldClip], me.colorTable[l]];
END;

SaveRectForViewers: ENTRY PROCEDURE[r: CD.Rect, l: CD.Level, pr: CD.DrawRef] =
BEGIN
ENABLE UNWIND => NULL;
me: MyGraphicRef = pr.viewerPrivate; 
me.saveList _ CONS[[r: CDInline.Intersection[r, pr.worldClip], l: l], me.saveList]
END;

DrawCommentForViewers: PUBLIC PROC[r: CD.DesignRect, comment: Rope.ROPE, pr: CD.DrawRef] = 
BEGIN
topToFontLine: NAT ~ 9+2;
fontHeight: NAT ~ 12;
leftMargin: NAT ~ 2;
bothMargin: NAT ~ 2*leftMargin;
me: MyGraphicRef _ NARROW[pr.devicePrivate];
vr: CD.Rect _ CDVPrivate.DesignToViewerRect[me, r];
IF vr.y2-vr.y1>fontHeight THEN {
xw: REAL ~ Graphics.RopeWidth[font: defaultFont, rope: comment].xw;
IF vr.x2-vr.x1>xw+bothMargin THEN {
Graphics.SetCP[me.viewerContext, vr.x1+leftMargin, vr.y2-topToFontLine];
Graphics.DrawRope[me.viewerContext, comment];
}
};
END;

RepaintRectAreaInViewer: PUBLIC PROC[me: MyGraphicRef, rect: CD.DesignRect, eraseFirst: BOOL] =
BEGIN
pr: CD.DrawRef ~ CDVPrivate.CreateDrawInformation[me];
pr.worldClip _ CDInline.Intersection[rect, pr.worldClip];
IF CDInline.NonEmpty[pr.worldClip] THEN
BEGIN
[] _ Graphics.SetPaintMode[me.viewerContext, transparent];
RepaintBackground[me, rect, eraseFirst];
CDOps.QuickDrawDesign[me.actualDesign, pr];
[] _ Graphics.SetPaintMode[me.viewerContext, opaque];
IF me.saveList#NIL THEN {
l: LIST OF CDVPrivate.SavedRect _ me.saveList;
me.saveList _ NIL;
WHILE l#NIL DO
BitBlitSave[me, l.first.r, me.colorTable[l.first.l], me.greyTable[l.first.l]];
l _ l.rest
ENDLOOP;
};
IF me.ticks>0 THEN PaintTicks[me, rect];
IF me.designRec.arrowOn AND me.arrowIsOn 
   AND CDInline.Intersect[rect, me.arrowRect] THEN PaintArrow[me, rect]; 
END
END;

RepaintBackground: PUBLIC ENTRY PROC[me: MyGraphicRef, r: CD.DesignRect, eraseFirst: BOOL] = 
BEGIN
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {
errrorReport.text _ "background";
errrorReport.me _ me;
errrorReport.r _ r;
IF CDVPrivate.catchAny THEN GOTO SomeError ELSE REJECT
};
};

DrawOutside: --INTERNAL-- PROC [r: CD.DesignRect] =
BEGIN
BitBlitDraw[me, CDInline.Intersection[r, me.deviceDrawRef.worldClip], me.backGround];
END;

IF eraseFirst THEN {
TRUSTED {me.xBLT.flags.dstFunc _ null};
BitBlitDraw[me, CDInline.Intersection[r, me.deviceDrawRef.worldClip], whiteBrick];
TRUSTED {me.xBLT.flags.dstFunc _ or};
};
IF me.actualDesign.actual.first.mightReplace#NIL AND ~me.suppressOutsidePushedCell AND
me.actualDesign.actual.first.mightReplace.ob#NIL THEN 
CDExtras.DecomposeRect[r: r, 
test: CDApplications.ARectO[me.actualDesign.actual.first.mightReplace], 
outside: DrawOutside];
EXITS
SomeError => NULL;
END;

PaintArrow: PROC[me: MyGraphicRef, r: CD.DesignRect] =
BEGIN
temContext: Graphics.Context _ Graphics.CopyContext[me.viewerContext];
vp: CD.Position _ CDVPrivate.DesignToViewerPosition[me, 
    [me.designRec.arowAt.x, me.designRec.arowAt.y]];
vp _ CDInline.AddPoints[vp, [1, 1]];
Graphics.SetColor[temContext, Graphics.black];
[]_ Graphics.SetPaintMode[temContext, opaque];
Graphics.SetCP[temContext, vp.x+10, vp.y];
Graphics.DrawTo[temContext, vp.x, vp.y];
Graphics.DrawTo[temContext, vp.x, vp.y+10];
Graphics.SetCP[temContext, vp.x, vp.y];
Graphics.DrawTo[temContext, vp.x+18, vp.y+18];
END;

PaintTicks: PUBLIC ENTRY PROC[me: MyGraphicRef, r: CD.DesignRect] =
BEGIN
ENABLE UNWIND => NULL;

ModUp: PROC [x, md: CD.Number] RETURNS [CD.Number] = INLINE {
RETURN [( IF x>0 THEN (x+md-1) ELSE (x) ) / md * md]
};  -- division rounds towards 0

ModDown: PROC [x, md: CD.Number] RETURNS [CD.Number] = INLINE {
RETURN [( IF x>0 THEN (x) ELSE (x-md+1) ) / md * md]
};  -- division rounds towards 0

IF me.ticks>0 THEN {
vTicks: CD.Number ~ CDVPrivate.ScaleDesignToViewer[me, me.ticks];
IF vTicks>6 THEN TRUSTED {
x, xStop, xMod: INT;
yStart, yStop, yTem, yInc: LONG CARDINAL;
dr: CD.DesignRect ~ CDInline.Intersection[me.deviceDrawRef.worldClip, r]; -- design coords
vr: CD.Rect _ CDVPrivate.DesignToViewerRect[me, CD.Rect[ -- viewer coords
x1: ModUp[dr.x1, me.ticks],
y1: ModUp[dr.y1, me.ticks],
x2: ModDown[dr.x2, me.ticks], 
y2: ModDown[dr.y2, me.ticks]
]];
IF vr.x1<0 THEN vr.x1 _ vr.x1 + ModUp[-vr.x1, vTicks];
IF vr.y1<0 THEN vr.y1 _ vr.y1 + ModUp[-vr.y1, vTicks];
IF vr.x2>me.vwminus1 THEN vr.x2 _ vr.x2 - ModUp[vr.x2-me.vwminus1, vTicks]; 
IF vr.y2>me.vhminus1 THEN vr.y2 _ vr.y2 - ModUp[vr.y2-me.vhminus1, vTicks]; 
me.xBLT.width _ me.bpp;
me.xBLT.height _ 1;
me.xBLT.src _ [LOOPHOLE[blackBrick],,0];
me.xBLT.srcDesc.gray.yOffset _ 0;
yStart _ LOOPHOLE[(me.vy-vr.y2-1)*me.scWidthWords, LONG CARDINAL]+LOOPHOLE[me.screen, LONG CARDINAL];
yStop _ LOOPHOLE[(me.vy-vr.y1-1)*me.scWidthWords, LONG CARDINAL]+LOOPHOLE[me.screen, LONG CARDINAL];
yInc _ vTicks*me.scWidthWords;
x _ (vr.x1+me.vx)*me.bpp;
xStop _ (vr.x2+me.vx)*me.bpp;
IF me.bpp#1 THEN {TerminalExtras.LockColorFrame[virtual]};
WHILE x<=xStop DO
yTem _ yStart+LOOPHOLE[(x/Basics.bitsPerWord), LONG CARDINAL];
xMod _ x MOD Basics.bitsPerWord;
WHILE yTem<=yStop DO
me.xBLT.dst _ [LOOPHOLE[yTem],,xMod];
PrincOpsUtils.BITBLT[me.xBLT];
yTem _ yTem+yInc
ENDLOOP;
x _ x+vTicks*me.bpp
ENDLOOP;
IF me.bpp#1 THEN {TerminalExtras.UnlockColorFrame[virtual]};
};
}
END;

CreateDrawInformation: PUBLIC ENTRY PROC [me: MyGraphicRef] RETURNS [CD.DrawRef] =
BEGIN

GraphicsBoxToRect: PROC[box: Graphics.Box] RETURNS [CD.Rect] =
--INLINE sorry storage overflow in pass 3-- BEGIN
RETURN [CD.Rect[
x1: Real.RoundI[box.xmin], 
y1: Real.RoundI[box.ymin], 
x2: Real.RoundI[box.xmax], 
y2: Real.RoundI[box.ymax]]];
END;

NextBiggerBack: PROC[me: CDVPrivate.MyGraphicRef, r: CD.Rect, off: CD.DesignPosition, scale: CDVPrivate.ScaleRange] 
RETURNS [CD.DesignRect] =
BEGIN

UnGridedScaleViewerToDesignUp: PROC [me: MyGraphicRef, v: LONG CARDINAL] RETURNS [CD.DesignNumber] = 
INLINE {RETURN [LOOPHOLE[(v*me.sA+me.sE+me.sE)/me.sE, CD.DesignNumber]]};

UnGridedScaleViewerToDesignDown: PROC [me: MyGraphicRef, v: LONG CARDINAL] RETURNS [CD.DesignNumber] = 
INLINE {RETURN [LOOPHOLE[(v*me.sA-me.sE)/me.sE, CD.DesignNumber]]};

RETURN [CD.DesignRect[
UnGridedScaleViewerToDesignDown[me, r.x1]+off.x,
UnGridedScaleViewerToDesignDown[me, r.y1]+off.y,
UnGridedScaleViewerToDesignUp[me, r.x2+1]+off.x,
UnGridedScaleViewerToDesignUp[me, r.y2+1]+off.y]]
END;

ScaleValue: PROC [me: MyGraphicRef] RETURNS [s: REAL] = 
--INLINE sorry storage overflow in pass 3-- {RETURN [Real.Float[me.sE]/Real.Float[me.sF]]};

s: REAL;
pr: CD.DrawRef ~ CD.NewNullDeviceDrawRef[me.actualDesign];
pr.drawRect _ BitBlitDrawRectForViewers;
pr.saveRect _ SaveRectForViewers;
pr.outLineProc _ BitBlitOutLine;
pr.drawComment _ DrawCommentForViewers;
pr.deviceContext _ Graphics.CopyContext[me.viewerContext];
s _ ScaleValue[me]; 
pr.scaleHint _ s*me.suppressFactorForCells; 
Graphics.Scale[pr.deviceContext, s, s];
Graphics.Translate[pr.deviceContext, -me.noff.x, -me.noff.y];
pr.contextFilter _ defaultContextFilter;
pr.devicePrivate _ me;
pr.stopFlag _ me.stoprequest;
pr.suppressOutsidePushedCell _ me.suppressOutsidePushedCell; 
pr.worldClip _ NextBiggerBack[me, GraphicsBoxToRect[Graphics.GetBounds[me.viewerContext]],
me.noff, me.nscale];
pr.minimalSize _ 
IF me.cellClipp<0 THEN
MIN[(pr.worldClip.x2-pr.worldClip.x1)/8, (pr.worldClip.y2-pr.worldClip.y1)/8]
ELSE me.cellClipp;

BEGIN
x, y: REAL;
IF me.viewer.column=color THEN TRUSTED {
m: Terminal.ColorMode = Terminal.GetColorMode[virtual];
IF m.full THEN ERROR;
IF m.bitsPerPixelChannelA=0 THEN ERROR;
me.bpp _ m.bitsPerPixelChannelA; 
me.screen _ virtual.colorBitmapA;
me.scWidth _ virtual.colorWidth;  -- pixels 
me.scWidthBits _ virtual.colorWidth*me.bpp;
me.scHeight _ virtual.colorHeight;
IF me.bpp=4 THEN {
me.logbpp _ 2;
me.colorTable _ CDVPrivate.colorTable4;
me.greyTable _ CDVPrivate.greyTable4;
me.backGround _ back4Brick;
}
ELSE IF me.bpp=8 THEN {
me.logbpp _ 3;
me.colorTable _ CDVPrivate.colorTable8;
me.greyTable _ CDVPrivate.greyTable8;
me.backGround _ back8Brick;
}
ELSE ERROR;
}
ELSE { -- b+w
me.bpp _ 1;
me.logbpp _ 0;
me.colorTable _ CDVPrivate.colorTableBW;
me.greyTable _ CDVPrivate.greyTableBW;
me.backGround _ backBWBrick;
me.scWidth _ ViewerSpecs.screenW/Basics.bitsPerWord;
me.scWidthBits _ ViewerSpecs.screenW;
me.scHeight _ ViewerSpecs.screenH;
me.screen _ Terminal.GetBitBltTable[virtual].bbt.dst.word;
};
[x, y] _ GraphicsOps.UserToDevice[me.viewerContext, 0, 0];
me.vx _ Real.RoundI[x];
me.vy _ Real.RoundI[y];
me.vwminus1 _ me.viewer.cw-1;
me.vhminus1 _ me.viewer.ch-1;
me.scWidthWords _ me.scWidthBits/Basics.bitsPerWord;

TRUSTED {i: INTEGER _ me.scWidthBits; me.xBLT.dstBpl _ i};
TRUSTED {
me.xBLT.srcDesc.gray _ [yOffset: 0 --XXX set later--, 
widthMinusOne: 0, --words--
heightMinusOne: 3 --lines-- ]
};
TRUSTED {me.xBLT.flags.disjoint _ TRUE};
TRUSTED {me.xBLT.flags.gray _ TRUE};
TRUSTED {me.xBLT.flags.srcFunc _ null};
TRUSTED {me.xBLT.flags.dstFunc _ or};

TRUSTED {me.bBLT^ _ me.xBLT^};
TRUSTED {
me.bBLT.srcDesc.gray _ [yOffset: 0, 
widthMinusOne: 0, --words--
heightMinusOne: 0 --lines-- ];
me.bBLT.src _ [LOOPHOLE[blackBrick, LONG POINTER],,0]
};
END;

pr.viewerPrivate _ me;  -- this line last! it tells DummyNotify that the rest is initialized
RETURN [pr]
END; 

defaultContextFilter: REF CD.ContextFilter = NEW[CD.ContextFilter];
FOR l: CD.Level IN CD.Level DO
defaultContextFilter[l].doit_TRUE;
ENDLOOP;
END.




êCDVDraw.mesa
Copyright c 1983 by Xerox Corporation.  All rights reserved.
Christian Jacobi   August 5, 1983 11:07 am 
last edited by Christian Jacobi   July 20, 1984 12:04:05 pm PDT
Sorry, storage overflow in pass 3
InvertArea: PUBLIC PROC[me: MyGraphicRef, x1, y1, x2, y2: INT] = 
--x1, y1, x2, y2 in viewers coordinates; inverts all the border points 
TRUSTED BEGIN 
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {
errrorReport.text _ "InvertArea";
errrorReport.me _ me;
errrorReport.r_[x1: x1, x2: x2, y1: y1, y2: y2];
IF CDVPrivate.catchAnyWhichDeadlock THEN GOTO SomeError ELSE REJECT; 
};
};
xBit: CARDINAL;
xc1: CARDINAL _ MIN[MAX[x1, 0], LONG[me.vwminus1]];
yc1: CARDINAL _ MIN[MAX[y1, 0], LONG[me.vhminus1]];
xc2: CARDINAL _ MIN[MAX[x2, 0], LONG[me.vwminus1]];
yc2: CARDINAL _ MIN[MAX[y2, 0], LONG[me.vhminus1]];
IF xc1>xc2 THEN {t: CARDINAL=xc1; xc1_xc2; xc2_t};
IF yc1>yc2 THEN {t: CARDINAL=yc1; yc1_yc2; yc2_t};
me.bBLT.width _ PrincOpsUtils.BITSHIFT[(xc2+1-xc1), me.logbpp];
me.bBLT.height _ (yc2+1-yc1);
xBit _ PrincOpsUtils.BITSHIFT[(xc1+me.vx), me.logbpp];
yc1 _ me.vy-yc2;
me.bBLT.dst _ [
me.screen 
+ (LONG[yc1]*LONG[me.scWidthWords])
+ LONG[(xBit/Basics.bitsPerWord)],,
xBit MOD Basics.bitsPerWord
];
me.bBLT.flags.dstFunc _ xor;  -- cursoring is monitored; no drawing!
IF me.bpp=1 THEN
PrincOpsUtils.BITBLT[me.bBLT]
ELSE {
TerminalExtras.LockColorFrame[vt: virtual, 
xmin: xc1+me.vx, 
ymin: yc1, 
xmax: xc2+me.vx+1,   
ymax: yc1+me.bBLT.height
];
PrincOpsUtils.BITBLT[me.bBLT];
TerminalExtras.UnlockColorFrame[virtual]
};
me.bBLT.flags.dstFunc _ null;
EXITS
SomeError => NULL;
END;
-- r ALLREADY CLIPPED
--DONE OUTSIDE r _ CDInline.Intersection[r, me.deviceDrawRef.worldClip];
--no empty test; is guaranteed by caller
--outside: TerminalExtras.UnlockColorFrame[virtual] 
--clip generous to avoid wrong border
--tc: Graphics.Context;
--tc _ Graphics.CopyContext[me.viewerContext];
--Graphics.SetColor[tc, Graphics.black];
--Graphics.SetCP[tc, vr.x1+leftMargin, vr.y2-topToFontLine];
--Graphics.DrawRope[tc, comment];
--RepaintBackground
--paints ticks
-- Now vr denotes area for ticks; vTicks denote increment; in viewer coordinates
--without translation, gridding, 
--without translation, gridding
--without necessary translation
factor to scale design to viewer
--CreateMyDeviceDrawRef
DoBBLTInit: PROC [] = 
--experiment showed: returns pixel number, not bit number
------------
--fixed xBLT initializations
--done in viewerprocess: me.xBLT _ PrincOpsUtils.AlignedBBTable[@bBTableSpace];
--varying: me.xBLT.dst  
--varying: me.xBLT.src 
-varying: me.xBLT.width
--varying: me.xBLT.height
--default: TRUSTED{me.xBLT.flags.direction _ forward}; 
--default: TRUSTED{me.xBLT.flags.disjointItems _ TRUE};
--default: me.xBLT.flags.reserved
--default: me.xBLT.reserved
�Ê‚˜š
œ™Jšœ
Ïm
œ1™<Jš
œ+™+Jš
œ?™?J˜—š
Ïk	˜	Jšœžœ˜Jšžœ
˜J˜J˜	J˜	J˜J˜	J˜Jš
œ˜J˜
J˜J˜J˜
Jšœ	žœ˜#Jšœžœžœžœ˜'Jš
œ˜J˜Jš
œ
˜
Jš
œ	˜	Jš
œ˜Jš
œ˜J˜J˜—šÏbœžœ
ž˜Jšžœ
žœ•
˜Ÿ
Jšžœ
žœ
Ïcœ˜5—Jš
ž˜J˜Jšœžœ
žœ˜8Jšœžœ
žœžœ ˜;J˜Jšœžœ˜-Jšœžœ˜-Jšœžœ˜"Jš
œ/˜/Jš
œ:˜:J˜šœžœ˜Jšœžœ
˜Jš
œ˜Jšœžœ˜Jšœžœ˜Jš
œ˜—J˜Jšœžœžœžœ
žœ
žœ˜MJšœžœžœžœ˜@Jšœ
žœžœ˜FJšœžœžœ#˜IJšœžœžœ˜EJ˜J˜Jš
Ïn!™!š¡
œžœ
žœ#žœ™AJš
œG™GJšžœ
žœ
™šžœ™Jš
œ™šœ
žœ™Jš
œ!™!Jš
œ™Jš
œ0™0Jš
žœ"žœ
žœžœ
žœ™EJ™—J™—Jšœžœ
™Jš	œžœžœ
žœ	žœ™3Jš	œžœžœ
žœ	žœ™3Jš	œžœžœ
žœ	žœ™3Jš	œžœžœ
žœ	žœ™3Jšžœ	žœžœ™2Jšžœ	žœžœ™2Jšœžœ™?Jš
œ™Jšœžœ™6Jš
œ™™™
Jšœžœžœ™#Jšœžœ™#—Jšœžœ™J™—Jšœ &™Dšžœ
ž™Jšœžœ	™—šžœ™š
œ+™+Jš
œ™Jš
œ™Jš
œ™Jš
œ™Jš
œ™—Jšœžœ
™J™(J™—J™š
ž™Jšœ
žœ
™—Jšžœ
™—J˜š
¡œ œ
žœžœžœ˜[Jšžœ
˜Jš
œ™Jšžœ
ž˜šžœ˜Jšžœžœ
˜šœ
žœ˜Jš
œ"˜"Jš
œ˜Jš
œ˜Jš
œ˜Jš
žœžœ
žœžœ
žœ
˜7J˜—J˜—Jšœžœ
˜Jšœžœ˜Jš
œH™HJšžœžœ
žœ
˜%Jš
œ*˜*Jšœžœžœ˜(Jšžœ
žœ
žœ
žœ
˜$Jšœžœžœ˜;Jšžœžœžœ
žœ
˜ Jšœžœ˜5Jšœžœ œ˜CJšœ œ˜!Jš
œ˜˜˜
Jšœžœžœ˜"Jšœžœ˜#—Jšœžœ˜J˜—˜šžœ˜
šžœžœ
žœ˜ Jšœžœžœ
žœ˜—Jšœžœ˜——Jšœ"žœ˜(Jšžœ
žœžœ	˜.šžœ˜š
œ+˜+Jš
œ˜Jš
œ
˜
Jšœ œ˜Jš
œ˜Jš
œ˜—Jšœžœ
˜Jš
œ(˜(J˜—š
ž˜Jšœ
žœ
˜—Jšžœ
˜—J˜š¡œžœ
žœžœžœ!žœžœ˜|Jšžœž˜šžœ˜Jšžœžœ
˜šœ
žœ˜Jš
œ"˜"Jš
œ˜Jš
œ˜Jš
œ˜Jš
žœžœ
žœžœ
žœ
˜7J˜—J˜—Jšœžœ
˜Jšœžœ˜Jš
œ9˜9Jšžœžœ
žœ
˜%Jš
œ*˜*Jšœžœžœ˜(Jšžœ
žœ
žœ
žœ
˜$Jšœžœžœ˜;Jšžœžœžœ
žœ
˜ Jšœžœ˜5Jšœžœ œ˜CJšœ œ˜!Jš
œ˜˜˜
Jšœžœžœ˜"Jšœžœ˜#—Jšœžœ˜J˜—Jšœ"žœ˜(šžœ
žœ,˜<Jš
œ˜Jš
œ
˜
Jšœ œ˜Jš
œ˜Jš
œ˜—šžœžœ
žœ˜Jš
œ˜Jš
œ#˜#š
œ˜šžœ˜
šžœžœ
žœ˜'Jšœžœžœ
žœ˜—Jšœžœ˜——Jšœžœ
˜Jš
œ˜Jš
œ˜J˜—˜šžœ˜
šžœžœ
žœ˜ Jšœžœžœ
žœ˜—Jšœžœ˜——Jšœžœ
˜Jšžœ
žœ*˜:š
ž˜Jšœ
žœ
˜—Jšžœ
˜—J˜š
¡œžœ
žœžœžœ˜9Jš
ž˜šžœ˜Jšžœžœ
˜šœ
žœ˜Jš
œ%˜%Jš
œ#˜#Jš
œ˜Jš
žœžœ
žœžœ
žœ
˜7J˜—J˜—J˜$Jšœžœ˜J˜š¡	œ œ
žœ'žœ˜JJšžœ
žœ
ž˜Jšœžœ˜!Jšžœžœžœžœžœ
žœ
˜FJš
œ(™(Jšœžœžœ˜Jšœžœžœ˜Jšœžœžœ˜!Jšœžœžœ˜!Jšœžœ œ˜CJšœ œ˜!Jšœžœ˜6Jš
œ˜˜˜
Jšœžœžœ˜#Jšœžœ˜$—Jšœžœ˜J˜—Jšžœ
žœžœ	˜.šžœ˜š
œ*˜*Jš
œ˜Jš
œ
˜
Jšœ œ˜Jš
œ˜Jš
œ˜—Jšœžœ
˜Jš
œ4™4Jš
œ˜—Jšžœ
˜J˜—Jš
œ%™%Jšžœ$žœ&˜PJšžœ$žœ&˜PJšžœ$žœ&˜PJšžœ$žœ&˜PJš
œ*˜*Jšžœžœ
žœ ˜.Jšœ- ˜3Jšœ- ˜2Jšœ- ˜4Jšœ- ˜5Jš
œ*˜*š
ž˜Jšœ
žœ
˜—Jšžœ
˜J˜—š¡œžœ
žœžœ
žœžœ˜PJš
ž˜Jšžœ
žœžœ
˜Jš
œ%˜%Jš
œJ˜JJšžœ
˜J˜—š¡œžœ
ž	œžœ
žœžœ˜NJš
ž˜Jšžœ
žœžœ
˜Jš
œ%˜%Jšœžœ@˜RJšžœ
˜—J˜š¡œžœ
žœžœžœžœ˜[Jš
ž˜Jšœžœ˜Jšœžœ˜Jšœžœ˜Jšœžœ˜Jšœžœ˜,Jšœžœ-˜3šžœžœ˜ Jšœžœ;˜Cšžœžœ˜#J™J™.J™(Jš
œ<™<Jš
œ!™!Jš
œH˜HJš
œ-˜-J˜
—J˜—Jšžœ
˜J˜—š
¡œžœ
žœžœžœ˜_Jš
ž˜Jšœžœ0˜6J˜9šžœ!ž˜'Jš
ž˜J˜:J˜(J˜+J˜5šžœ
žœ
žœ˜Jšœžœ
žœ$˜.Jšœžœ
˜šžœžœ
ž˜Jš
œN˜NJš
œ
˜
Jšžœ
˜—J˜—Jšžœžœ˜(Jšžœžœžœ(žœ˜sJš
ž˜—Jšžœ
˜J˜—š¡œžœ
žœ
žœžœžœ˜]Jš
ž˜šžœ˜Jšžœžœ
˜šœ
žœ˜Jš
œ!˜!Jš
œ˜Jš
œ˜Jš	žœžœ
žœžœ
ž˜6J˜—Jš
œ˜—J˜š¡œ œ
žœžœ˜3Jš
ž˜Jš
œU˜UJšžœ
˜J˜—Jš
œ™šžœžœ˜Jšžœ ˜'Jš
œR˜RJšžœ˜%J˜—šžœ+žœ
žœž˜VJšœ-žœ
žœ
˜6˜Jš
œH˜HJ˜——š
ž˜Jšœ
žœ
˜—Jšžœ
˜J˜—š¡
œžœžœ˜6Jš
ž˜Jš
œF˜FJšœžœg˜mJš
œ$˜$Jš
œ.˜.Jš
œ.˜.Jš
œ*˜*Jš
œ(˜(Jš
œ+˜+Jš
œ'˜'Jš
œ.˜.Jšžœ
˜—J˜š
¡
œžœ
žœ
žœžœ˜CJš
œ™Jš
ž˜Jšžœ
žœžœ
˜J˜š¡œžœ	žœ	žœžœžœ˜=Jšžœžœžœ
žœ˜4Jšœ ˜ —J˜š¡œžœ	žœ	žœžœžœ˜?Jšžœžœžœžœ˜4Jšœ ˜ —J˜šžœžœ˜Jšœžœ7˜Ašžœ
žœ
žœ˜Jšœžœ
˜Jšœžœ
žœ
˜)JšœžœD ˜Zšœžœ*žœ ˜IJš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jšžœ	žœ'˜6Jšžœ	žœ'˜6Jšžœžœ3˜LJšžœžœ3˜LJš
œP™PJš
œ˜Jš
œ˜Jšœžœ˜(Jš
œ!˜!Jš
œ	žœ"žœ
žœžœžœ
žœ˜eJš
œžœ"žœ
žœžœžœ
žœ˜dJš
œ˜Jš
œ˜Jš
œ˜Jšžœ
žœ*˜:šžœ
ž˜Jšœžœžœ
žœ˜>Jšœ	žœ˜ šžœ
ž˜Jšœžœ˜%Jšœžœ
˜Jš
œ˜Jšžœ
˜—Jš
œ˜Jšžœ
˜—Jšžœ
žœ,˜<Jš
œ˜—J˜
—Jšžœ
˜—J˜š¡œžœ
žœ
žœžœžœ˜RJš
ž˜J˜š¡œžœžœžœ˜>Jš +œ
ž˜1šžœžœ˜J˜J˜J˜J˜—Jšžœ
˜—J˜š¡œžœ!žœžœ/˜tJšžœžœ˜Jš
ž˜J˜š¡œžœžœ
žœžœžœ˜eJš
œ!™!Jšžœžœžœžœ˜I—J˜š¡œžœžœ
žœžœžœ˜gJš
œ™Jšžœžœžœžœ˜C—J˜šžœžœ˜Jš
œ0˜0Jš
œ0˜0Jš
œ0˜0Jš
œ1˜1—Jšžœ
˜—J˜š¡
œžœžœžœ˜8Jš
œ™Jš
œ ™ Jš +œžœ(˜[J˜—Jš
œ™Jšœžœ
˜Jšœžœžœ'˜:Jš
œ(˜(J˜!J˜ Jš
œ'˜'Jš
œ:˜:Jš
œ˜Jš
œ,˜,J˜'Jš
œ=˜=Jš
œ(˜(Jš
œ˜J˜Jš
œ=˜=˜ZJ˜—˜šžœž˜JšžœJ˜M—Jšžœ˜—J˜š¡
œžœ™Jš
ž˜Jšœžœ
˜šžœžœ
žœ˜(Jš
œ7˜7Jšžœžœ
žœ
˜Jšžœžœ
žœ
˜'Jš
œ!˜!Jš
œ!˜!Jšœ" 
˜,Jš
œ+˜+Jš
œ"˜"šžœ
žœ˜Jš
œ˜Jš
œ'˜'Jš
œ%˜%Jš
œ˜J˜
—šžœ
žœ
žœ˜Jš
œ˜Jš
œ'˜'Jš
œ%˜%Jš
œ˜J˜
—Jšžœ
žœ
˜J˜
—šžœ ˜
J˜Jš
œ˜Jš
œ(˜(Jš
œ&˜&Jš
œ˜Jš
œ4˜4J˜%J˜"Jš
œ:˜:J˜—˜:Jš
œ9™9—J˜J˜Jš
œ˜Jš
œ˜Jš
œ4˜4J˜Jš
œ™Jš
œ™Jš
œO™OJš
œ™Jšžœžœ'˜:Jš
œ™šžœ˜	Jšœ# œ˜6Jšœ 	˜Jšœ 	œ˜J˜—Jš
œ™Jš
œ™Jš
œ7™7Jšžœžœ˜(Jš
œ7™7Jšžœžœ˜$Jšžœ ˜'Jšžœ˜%Jš
œ!™!Jš
œ™J˜Jšžœ˜šžœ˜	˜$Jšœ 	˜Jšœ 	œ˜—šœžœ
žœ
žœ˜5J˜——Jšžœ
˜—J˜Jšœ D˜\Jšžœ˜Jšžœ˜J˜—Jš	œžœ
žœžœ
žœ˜Cš	žœžœžœ
žœž˜Jšœžœ
˜"Jšžœ
˜—Jšžœ
˜J˜—…—=�^ü