<> <> <> <> <> DIRECTORY Basics USING [BITSHIFT, BITAND, LongMult, logBitsPerWord], CD, CDBasics, CDColors, CDInstances, CDOps, CDOrient, CDPrivate, 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, 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; <<--I don't trust the damned LOOPHOLE's of List>> DRemove: PROC [ref: REF CDVPrivate.PainterRec, list: CDVPrivate.PainterList] RETURNS [CDVPrivate.PainterList] = { l, l1: CDVPrivate.PainterList _ NIL; l _ list; UNTIL l = NIL DO IF l.first = ref THEN { IF l1 = NIL THEN RETURN[l.rest]; -- ref was first object on list l1.rest _ l.rest; RETURN[list]; }; l1 _ l; l _ l.rest; ENDLOOP; RETURN [list]; }; IncludeAPainterRec: PUBLIC ENTRY PROC [me: CDVPrivate.VRef, pr: REF CDVPrivate.PainterRec] = BEGIN ENABLE UNWIND => NULL; DOIT: PROC [] = TRUSTED { IF ~List.Memb[ref: pr, list: LOOPHOLE[me.painterList]] THEN me.painterList _ CONS[pr, me.painterList]; }; DOIT[]; END; RemoveAPainterRec: PUBLIC ENTRY PROC [me: CDVPrivate.VRef, pr: REF CDVPrivate.PainterRec] = BEGIN ENABLE UNWIND => NULL; DOIT: PROC [] = TRUSTED { me.painterList _ DRemove[ref: pr, list: me.painterList]; }; DOIT[]; 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.ShallContinue[me, TRUE, "CDVDraw.bblt"] THEN GOTO oops; }; 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.vw]; y2 _ MIN[vr.y2, me.vh]; 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; InlineBitBlitOutLine: ENTRY PROC[vRef: VRef, r: CD.Rect, color: REF CDColors.Brick] = TRUSTED INLINE BEGIN <<--r in design coordinates>> ENABLE { UNWIND => NULL; RuntimeError.UNCAUGHT => { IF CDVPrivate.ShallContinue[vRef, TRUE, "CDVDraw.bbout"] THEN GOTO oops; }; }; vr: CD.Rect; --in viewer coordinates clipVr: CD.Rect; --in viewer coordinates DrawGrey: PROC[vRef: VRef, x1, y1, x2, y2: INTEGER] = TRUSTED INLINE BEGIN <<--no empty test; is guaranteed by caller>> xBits: CARDINAL = Basics.BITSHIFT[x1+INTEGER[vRef.vx], vRef.logbpp]; vRef.pBBptr.width _ Basics.BITSHIFT[x2-x1, vRef.logbpp]; vRef.pBBptr.height _ y2-y1; y1 _ vRef.vy-y2; vRef.pBBptr.dst _ [ vRef.screen + Basics.LongMult[y1, vRef.scWidthWords] + LONG[Basics.BITSHIFT[xBits, -Basics.logBitsPerWord]],, Basics.BITAND[xBits, maskModBitsPerWord] ]; vRef.pBBptr.src _ [ LOOPHOLE[ LOOPHOLE[color, LONG CARDINAL] + Basics.BITAND[y1, 3], LONG POINTER],, Basics.BITAND[xBits, maskModBitsPerWord] ]; vRef.pBBptr.srcDesc.gray.yOffset _ Basics.BITAND[y1, 3]; PrincOpsUtils.BITBLT[vRef.pBBptr]; END; DoIt: PROC [] = TRUSTED BEGIN IF vr.x1>=clipVr.x1 THEN DrawGrey[vRef, clipVr.x1, clipVr.y1, clipVr.x1+1, clipVr.y2]; --left IF vr.y2<=clipVr.y2 THEN DrawGrey[vRef, clipVr.x1, clipVr.y2-1, clipVr.x2, clipVr.y2]; --top IF vr.x2<=clipVr.x2 THEN DrawGrey[vRef, clipVr.x2-1, clipVr.y1, clipVr.x2, clipVr.y2]; --right IF vr.y1>=clipVr.y1 THEN DrawGrey[vRef, 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>vRef.dClip.x2 THEN r.x2 _ vRef.dClip.x2+1; IF r.y2>vRef.dClip.y2 THEN r.y2 _ vRef.dClip.y2+1; IF r.x1=clipVr.x2 OR clipVr.y1>=clipVr.y2 THEN RETURN; <> <> vRef.pBBptr^ _ PrincOps.BBTable[ dst: TRASH, dstBpl: vRef.frame.width*vRef.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 vRef.display=bw THEN { DoIt[] } ELSE { Terminal.ModifyColorFrame[vt: virtual, action: DoIt, xmin: clipVr.x1+vRef.vx, ymin: vRef.vy+1-clipVr.y2, xmax: clipVr.x2+vRef.vx-1, ymax: vRef.vy-clipVr.y1 ]; } EXITS oops => NULL; END; InvertArea: PUBLIC ENTRY PROC[me: VRef, x1, y1, x2, y2: INT] = BEGIN ENABLE { UNWIND => NULL; RuntimeError.UNCAUGHT => IF CDVPrivate.ShallContinue[me, TRUE, "CDVDraw.IA"] THEN GOTO oops; }; <<--proc to make the unwind really catching the errors>> SafetyProc: PROC [] = TRUSTED BEGIN xBit: CARDINAL; xc1: CARDINAL _ MIN[MAX[x1, 0], LONG[me.vw-2]]; yc1: CARDINAL _ MIN[MAX[y1, 1], LONG[me.vh-1]]; xc2: CARDINAL _ MIN[MAX[x2, 0], LONG[me.vw-2]]; yc2: CARDINAL _ MIN[MAX[y2, 1], LONG[me.vh-1]]; IF xc1>xc2 THEN {t: CARDINAL=xc1; xc1_xc2; xc2_t}; IF yc1>yc2 THEN {t: CARDINAL=yc1; yc1_yc2; yc2_t}; me.xBBptr.width _ Basics.BITSHIFT[(xc2+1-xc1), me.logbpp]; me.xBBptr.height _ (yc2+1-yc1); xBit _ Basics.BITSHIFT[(xc1+me.vx), me.logbpp]; yc1 _ me.vy-yc2; --yc2>me.vy impossible ?? me.xBBptr.dst _ [ me.screen + Basics.LongMult[yc1, me.scWidthWords] + LONG[Basics.BITSHIFT[xBit, -Basics.logBitsPerWord]],, Basics.BITAND[xBit, maskModBitsPerWord] ]; me.xBBptr.flags.dstFunc _ xor; me.xBBptr.src _ [LOOPHOLE[blackBrick, LONG POINTER],,0]; me.xBBptr.srcDesc _ PrincOps.SrcDesc[gray[PrincOps.GrayParm[ yOffset: 0, widthMinusOne: 0, --words heightMinusOne: 0 --lines ]]]; IF me.display=bw THEN PrincOpsUtils.BITBLT[me.xBBptr] ELSE { Blit: PROC [] = TRUSTED { PrincOpsUtils.BITBLT[me.xBBptr]; }; Terminal.ModifyColorFrame[vt: virtual, action: Blit, xmin: xc1+me.vx, ymin: yc1 , xmax: xc2+me.vx+1, ymax: yc1+me.xBBptr.height ]; }; END; SafetyProc[]; EXITS oops => NULL; END; OutLine: PROC[r: CD.Rect, l: CD.Layer, pr: CD.DrawRef] = BEGIN vRef: VRef = pr.viewerPrivate; InlineBitBlitOutLine[vRef: vRef, r: r, color: vRef.colorTable.bricks[l]] 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.bricks[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.ShallContinue[me, TRUE, "CDVDraw.rep1"] THEN GOTO oops; 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.ShallContinue[me, TRUE, "CDVDraw.rep2"] THEN CONTINUE ] ENDLOOP } EXITS oops=> NULL END; RepaintBackground: PUBLIC ENTRY PROC[me: VRef, r: CD.Rect, eraseFirst: BOOL] = BEGIN ENABLE { UNWIND => NULL; RuntimeError.UNCAUGHT => IF CDVPrivate.ShallContinue[me, TRUE, "CDVDraw.back"] THEN GOTO oops; }; DrawOutside: PROC [r: CD.Rect] = BEGIN BitBlitDraw[me, CDBasics.Intersection[r, me.dClip], me.colorTable.bricks[CD.backgroundLayer]]; 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: INTERNAL 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.vw, me.vh copied to avoid race conditions>> me.vw _ me.viewer.cw; me.vh _ me.viewer.ch; 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.xBBptr^ _ 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 ] ]; }; 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] 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, me.colorTable.cols[layer]]; proc[pr.deviceContext, ob, layer]; END; Imager.DoSave[pr.deviceContext, Action]; } END; ICreateDrawRef: INTERNAL PROC [me: VRef] = BEGIN pr: CD.DrawRef = CD.CreateDrawRef[[ drawRect: BitBlitDrawRectForViewers, drawOutLine: OutLine, drawComment: DrawCommentForViewers, drawContext: ViewerDrawContext, setGround: SetGround, priorityChecker: CheckPriority, devicePrivate: me, stopFlag: me.stoprequest, symbolics: me.symbolics, borders: me.borders, environment: me.environment, specialFonts: me.specialFonts, checkPriority: me.checkPriority, b4: me.b4, b5: me.b5, design: me.actualDesign ]]; InitForBBLT[me]; me.deviceDrawRef _ pr; pr.interestClip _ me.dClip _ CDVScale.GetClipRecord[me.intendedScale, me.vw, me.vh]; pr.scaleHint _ CDVScale.DesignToViewerFactor[me.intendedScale]*me.suppressFactorForCells; pr.contextFilter _ me.contextFilter _ me.colorTable.filter; 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; DoInsideMonitor: PUBLIC ENTRY PROC [proc: PROC [VRef], vRef: VRef] = BEGIN ENABLE UNWIND => NULL; proc[vRef ! RuntimeError.UNCAUGHT => IF CDVPrivate.ShallContinue[vRef, TRUE, "CDVDraw.XXX"] THEN CONTINUE; ] END; CDColors.DefineColor[CD.undefLayer, NIL, bw]; CDColors.DefineColor[CD.undefLayer, NIL, bit4]; CDColors.DefineColor[CD.undefLayer, NIL, bit8]; CDColors.DefineColor[CD.backgroundLayer, NEW[CDColors.Brick_[257,0,0,0]], bw]; CDColors.DefineColor[CD.backgroundLayer, NEW[CDColors.Brick_[0,10,0,11*256]], bit4]; CDColors.DefineColor[CD.backgroundLayer, NEW[CDColors.Brick_[8, 0, 800h, 0]], bit8]; CDColors.DefineColor[CD.shadeLayer, NEW[CDColors.Brick_[101H, 0, 0, 0]], bw]; CDColors.DefineColor[CD.shadeLayer, NEW[CDColors.Brick_[0, 0F0FH, 0, 0]], bit4]; CDColors.DefineColor[CD.shadeLayer, NEW[CDColors.Brick_[255, 0, 255, 0]], bit8]; CDColors.DefineColor[CD.errorLayer, NEW[CDColors.Brick_[101H, 0, 101H, 0]], bw]; CDColors.DefineColor[CD.errorLayer, NEW[CDColors.Brick_[0, 0F0FH, 0, 0F0FH]], bit4]; CDColors.DefineColor[CD.errorLayer, NEW[CDColors.Brick_[0, 255, 0, 0]], bit8]; CDColors.DefineColor[CD.outlineLayer, NEW[CDColors.Brick_[8888h, 4444h, 2222h, 1111h]], bw]; CDColors.DefineColor[CD.outlineLayer, NEW[CDColors.Brick_[07C7CH, 07C7CH, 07C7CH, 07C7CH]], bit4]; CDColors.DefineColor[CD.outlineLayer, NEW[CDColors.Brick_[07C7CH, 07C7CH, 07C7CH, 07C7CH]], bit8]; CDColors.DefineColor[CD.selectionLayer, NEW[CDColors.Brick_[0ffffH, 0ffffH, 0ffffH, 0ffffH]], bw]; CDColors.DefineColor[CD.selectionLayer, NEW[CDColors.Brick_[0ffffH, 0ffffH, 0ffffH, 0ffffH]], bit4]; CDColors.DefineColor[CD.selectionLayer, NEW[CDColors.Brick_[0ffffH, 0ffffH, 0ffffH, 0ffffH]], bit8]; CDColors.DefineColor[CD.commentLayer, NEW[CDColors.Brick_[07777h, 0bbbbH, 0ddddH, 0eeeeH]], bw]; CDColors.DefineColor[CD.commentLayer, NEW[CDColors.Brick_[0bbbbH, 0bbbbH, 0bbbbH, 0bbbbH]], bit4]; CDColors.DefineColor[CD.commentLayer, NEW[CDColors.Brick_[07f7fh, 07f7fh, 07f7fh, 07f7fh]], bit8]; CDColors.DefineColor[CD.commentLayer, NEW[CDColors.Brick_[07f00h, 0007fh, 07f00h, 0007fh]], bit8, pushedOut]; END.