Atom, CDDraw, CDEvents, CDExtras, CDInline, CDOrient, CDPanel, CDProperties, CDSequencer, CDTechnology, CDValue, CDViewer, CDVPrivate, Graphics, Icons, InputFocus, PrincOpsUtils, Process, Rope, RuntimeError, TerminalIO, TIPUser, UserProfile, ViewerEvents, ViewerOps

BEGIN

otherMe: MyGraphicRef = NARROW[other.data];

r: CD.DesignRect = otherMe.deviceDrawRef.worldClip;

p1: CD.Position = CDVPrivate.DesignToViewerPosition[me, [r.x1, r.y1]];

p2: CD.Position = CDVPrivate.DesignToViewerPosition[me, [r.x2, r.y2]];

CDVPrivate.InvertArea[me, p1.x, p1.y, p1.x+1, p2.y];

CDVPrivate.InvertArea[me, p1.x, p2.y, p2.x, p2.y+1];

CDVPrivate.InvertArea[me, p2.x, p2.y, p2.x+1, p1.y];

CDVPrivate.InvertArea[me, p2.x, p1.y, p1.x, p1.y+1];

END;

IF ~l.first.iconic AND l.first#me.viewer THEN OutlineViewer[me: me, other: l.first];

ENDLOOP

BEGIN

tc: Graphics.Context ~ Graphics.CopyContext[me.viewerContext];

p: CD.Position ~ CDVPrivate.DesignToViewerPosition[me, pos];

Graphics.SetColor[tc, Graphics.black];

Graphics.SetCP[tc, p.x, p.y];

IF coordSys=top THEN Graphics.Scale[tc, 1, -1];

Graphics.DrawRope[tc, text];

END;

IF CDInline.Intersect[CDOrient.RectAt[w.first.location, w.first.ob.size, w.first.orientation], r] THEN

ENDLOOP;

FOR l: MyGraphicRef ← CDVPrivate.linkBase, l.link WHILE l#NIL DO

};

CDDraw.Comm[cmd: ref, erase: FALSE, rect: [pos.x, pos.y, 0, 0], ref: $PutArrow]]

IF design=l.actualDesign THEN {

ENDLOOP

--must be called within monitor lock;

--called through Notify only, uses monitorlock from there

BEGIN

IF me.cursorInhibitations=0 THEN {

END;

BEGIN

IF me.onVC THEN {

END;

--must be called within monitor lock;

--called throgh Notify and ProtectedRepaint only

BEGIN

IF me.onVC THEN {

END;

--called through anybody anytime;

--reset viewer data and then sets up a buffered request for redrawing

BEGIN

ENABLE UNWIND => NULL;

ConsiderRemoveTrack: INTERNAL PROC[me: MyGraphicRef] = -- INLINE --

SetOffset: PROC [me: MyGraphicRef, pos: CD.DesignPosition] =

--SetUpAndRedraw

comm: CDDraw.Comm;

SetOffset[me, me.noff]; -- adjust gridding; replace later by better algorithm

ConsiderRemoveTrack[me];

me.deviceDrawRef ← CDVPrivate.CreateDrawInformation[me];

me.saveList ← NIL;

CDDraw.ModifyCommandTable[me.actualDesign, me.ct, me.deviceDrawRef.worldClip];

comm.cmd ← all;

comm.erase ← TRUE; -- to allow also black backgrounds set freely by colormap

comm.rect ← me.deviceDrawRef.worldClip;

CDDraw.InsertCommand[me.ct, comm];

END;

--eg. former paints ticks

--called through ProtectedRepaint only

BEGIN

END;

tr: TrackRef => {TrackRefTrack[me, tr]}; -- monitored by Notify

atom: ATOM =>

area: RepaintRectAreaRef => { -- monitored by ProtectedRepaint

arrow: ArrowRef => { -- monitored by ProtectedRepaint

ENDCASE =>

--this procedure is logically local to ProtectedRepaint;

--but it must be callable in catch phrase

BEGIN

me.cursorInhibitations ← me.cursorInhibitations-1;

BROADCAST tryToPaint

END;

EnableCursoring[me];

IF CDVPrivate.catchAnyWhichDeadlock THEN GOTO SomeError ELSE REJECT

};

BEGIN

ENABLE {

me.cursorInhibitations ← me.cursorInhibitations+1;

WHILE me.cursorInhibitations>1 DO

IF me.onVC THEN ViewerOps.PaintViewer[me.viewer, client, FALSE, $InternalRemoveTrack];

EXITS

END;

SomeError => NULL;

--me.xBLT is a short pointer! (hardware) therefore must be local to some

--procedure space.

comm ← CDDraw.FetchCommand[me.ct];

SELECT comm.cmd FROM

ENDLOOP;

me.running ← FALSE;

me.ct ← NIL;

me.actualDesign ← NIL;

me.designRec ← NIL;

TerminalIO.WriteRope["Viewer destroyed\n"];

set, pop => {

kill, push => {

ENDCASE => NULL;

IF cursoredViewer#NIL THEN {

UNWIND => NULL;

--sorry; this really happens because: some data is set up by the first call

--of the viewerpaint procedure; but sometime the Notify procedure is called first

--we will not bother every call of Notify to check for that.

RuntimeError.UNCAUGHT =>

};

--makes cursor logically available

BEGIN

IF NOT me.designRec.startLCValid THEN {

END;

--makes cursor logically unavailable

BEGIN

me.designRec.stopLC ← pos;

me.designRec.startLCValid ← FALSE;

END;

--makes cursor changing dirction of L bend

BEGIN

me.firstHorizontalVC ← me.designRec.firstHLC ← NOT me.designRec.firstHLC

END;

--makes cursor logically changing position

BEGIN

me.designRec.startLCValid ← FALSE;

LogicalTrack[me, pos];

END;

--uses intermediate level variable mouse

BEGIN

VisibleTrack: PROC [me: MyGraphicRef, pos: CD.DesignPosition] = -- INLINE --

--Track

pos: CD.DesignPosition = CDVPrivate.ViewerToDesignPosition[me, mouse];

LogicalTrack[me, pos];

IF me.cursorInhibitations#0 THEN RETURN;

VisibleTrack[me, pos]

END;

--uses intermediate level variable mouse

BEGIN

pos: CD.DesignPosition = CDVPrivate.ViewerToDesignPosition[me, mouse];

LogicalTrackOff[me, pos];

MonitoringRemoveCursor[me];

CDVPrivate.SetCursorMode[me, cShadow];

END;

BEGIN

newStartPosition: CD.DesignPosition;

comm: CDSequencer.Command ~ NEW[CDSequencer.CommandRec];

StopTrack[me];

comm^ ← CDSequencer.CommandRec[

newStartPosition ← IF me.designRec.firstHLC THEN

ELSE

CDSequencer.QueueCommand[design: me.actualDesign, comm: comm];

CheatLogicalStartTo[me, newStartPosition];

CursorSwitch[me];

END;

BEGIN

CDDraw.FlushCommands[me.ct]

END;

--silly cedar viewer system allows calls of notify before

--the first call to the paintprocedure happened;

--but for here, some initializations happen in paintprocedure only

RETURN; -- silly system calls notify before first paint

};

BEGIN

tem: ViewerClasses.Viewer = cursoredViewer;

IF tem#NIL AND tem.data#NIL THEN {

cursoredViewer ← self;

SetXMode[me, me.designRec.xMode]

END;

WITH input.first SELECT FROM

ENDLOOP;

AnyErrorHappened => NULL;

RETURN [NARROW[cursoredViewer.data, MyGraphicRef].designRec.modeLC=mode];

deny => RETURN [FALSE]

me: MyGraphicRef = NARROW [l.first.data];

l.first.name ← name;

ViewerOps.PaintViewer[l.first, caption];

IF event=$AfterPop OR (event=$AfterPush AND me.suppressOutsidePushedCell) THEN

ELSE IF (event=$AfterPush AND ~me.suppressOutsidePushedCell) THEN

ENDLOOP;

ip: REF Icons.IconFlavor => RETURN [ip^];

ENDCASE => RETURN [Icons.IconFlavor[unInit]]

flavor: viewerClassAtom,

info: [

];

paint: RePaint,

notify: Notify,

--modify: Modify,

destroy: Destroy,

coordSys: coordSys,

cursor: myCursor

]];

! RuntimeError.UNCAUGHT => {CONTINUE}];