-- color showobjects
-- mstone April 1, 1981  10:52 PM
-- geoff November 26, 1979  10:45 AM

DIRECTORY
	ScreenDefs: FROM "ScreenDefs",
	SplineDefs: FROM "SplineDefs",
	StyleDefs: FROM "StyleDefs",
	GriffinStartDefs: FROM "GriffinStartDefs",
	GriffinMemoryDefs: FROM "GriffinMemoryDefs",
	EncodingDefs: FROM "EncodingDefs",
	GriffinDefs: FROM "GriffinDefs",
	RefreshDefs: FROM "RefreshDefs",
	PointDefs: FROM "PointDefs",
	MenuDefs: FROM "MenuDefs",
	MiscDefs: FROM "MiscDefs",
	ControllerDefs: FROM "ControllerDefs",
	InlineDefs: FROM "InlineDefs",
	ObjectDefs: FROM "ObjectDefs";

ShowObjects: PROGRAM IMPORTS ScreenDefs, ObjectDefs, PointDefs, SplineDefs, MenuDefs, GriffinMemoryDefs, EncodingDefs, MiscDefs, ControllerDefs
	EXPORTS ObjectDefs, GriffinStartDefs = 
BEGIN OPEN ObjectDefs,PointDefs,GriffinMemoryDefs;

--upper level module has to start splines

i: INTEGER;	--the canonical loop counter
--put these somewhere as compile time constants
RuntimeBitmaps: ARRAY [0..3] OF ARRAY [0..8] OF CARDINAL;
TokenMap: ScreenDefs.Bitmap _ [0,1,9,9,NIL];
Token: ScreenDefs.Block _ [@TokenMap,0,0,9,9];
SelectBitmaps: ARRAY [0..3] OF ARRAY [0..15] OF CARDINAL;
SelectTokenMap: ScreenDefs.Bitmap _ [0,1,16,16,NIL];
SelectToken: ScreenDefs.Block _ [@SelectTokenMap,3,3,10,10];
selW: PUBLIC INTEGER _ 5;
HGrid,VGrid: ObjectHandle _ NIL;
hgridlx,hgridrx,vgridty,vgridby,gridt: INTEGER;
debug: BOOLEAN _ FALSE;
MoveTo: PROCEDURE[pt: PointDefs.ScrPt];
FNC: DisplayFnc _ write;
clipperState: ScreenDefs.ClipperState _ clip;

GridOn: PUBLIC PROCEDURE =
BEGIN
IF HGrid=NIL THEN
	BEGIN
	center,tl: ScrPt;
	[center,hgridlx,hgridrx,vgridty,vgridby,gridt] _ ScreenDefs.GetGridParameters[];
	VGrid _ StartObject[token];
	HGrid _ StartObject[token];
	tl _ [hgridlx,center[Y]-gridt/2];	--doing the obvious makes a compiler error
	HGrid.body _ token[hgrid,ScrToObj[tl],NIL];
	tl _ [center[X]-gridt/2,vgridty];	--doing the obvious makes a compiler error
	VGrid.body _ token[vgrid,ScrToObj[tl],NIL];
	HGrid.validEncoding _ VGrid.validEncoding _ FALSE;
	HGrid.visible _ VGrid.visible _ FALSE;
	END;
HGrid.visible _ TRUE;
WriteObject[HGrid];
VGrid.visible _ TRUE;
WriteObject[VGrid];
END;

GridOff: PUBLIC PROCEDURE =
BEGIN
EraseObject[HGrid];
HGrid.visible _ FALSE;
EraseObject[VGrid];
VGrid.visible _ FALSE;
END;


--replots all objects linked to allObjects
ReplotFromObject: PUBLIC PROCEDURE[startObj: ObjectHandle] =
BEGIN
obj: POINTER TO Object _ startObj;
FNC _ write;
UNTIL obj=NIL DO
	PlotObject[obj];
	obj _ obj.link;
	ENDLOOP;
END;

--calls the correct type of plotting routine, be it splines, encoding, whatever
PlotObject:  PROCEDURE [object: ObjectHandle] =
BEGIN 
IF object=NIL THEN RETURN;
IF ~Visible[object] THEN RETURN;
IF object.validEncoding
	THEN clipperState _ ScreenDefs.PrimeClipper[object.tl,object.br];
IF clipperState=cull THEN {clipperState _ clip; RETURN};
WITH obj: object SELECT FROM
	shape => BEGIN
		IF NOT object.validEncoding THEN BEGIN
			EncodingDefs.DeleteChainEncoding[obj.chainEncoding];
			EncodingDefs.DeleteAreaEncoding[obj.areaEncoding];
			obj.chainEncoding _ NIL;
			obj.areaEncoding _ NIL;
			END;
--Curves
		IF NOT obj.closed THEN BEGIN
			IF object.cluster=OpenCluster AND obj.style.outlined=FALSE
			  THEN SetFastStyle[]   --half finished linked obj
			ELSE SetTrajectoryStyle[obj.style];
			IF obj.chainEncoding=NIL THEN BEGIN
				PlotTrajectory[@obj,FALSE];	--displays and sets chain encoding
				END
			ELSE PlotChainEncoding[obj.chainEncoding];
			RETURN;
			END;
--Areas
		IF obj.style.filled AND obj.closed THEN BEGIN
			SetAreaStyle[obj.style];
			IF obj.areaEncoding=NIL THEN FillArea[@obj]
			ELSE PlotAreaEncoding[obj.areaEncoding];
			END;
--Outlined Areas.  TRUE = closed
		IF obj.style.outlined THEN BEGIN
			SetTrajectoryStyle[obj.style];
			IF obj.chainEncoding=NIL THEN BEGIN
				PlotTrajectory[@obj,TRUE];	--displays and sets chain encoding
				END
			ELSE PlotChainEncoding[obj.chainEncoding];
			END;
		END;

	caption => DisplayCaption[@obj];

	menu => MenuDefs.PlotMenu[@obj];

	token => SELECT obj.tokenType FROM
				CP,open => DisplayCP[@obj];
				selected =>  DisplaySelectToken[@obj]; 
				vgrid,hgrid => DisplayGrid[@obj]; 
				ENDCASE;
	ENDCASE;
ScreenDefs.ClipOn[];	--clears PrimeClipper
clipperState _ clip;
END;

DisplayGrid: PROCEDURE[token: POINTER TO token Object]=
BEGIN
pt: ScrPt _ ObjToScr[token.p0];
IF token.tokenType=vgrid THEN BEGIN
	ScreenDefs.BltVGrid[pt[X]] ;
	token.tl _ [pt[X],vgridty];
	token.br _ [pt[X]+gridt-1,vgridby];
	END
ELSE BEGIN
	ScreenDefs.BltHGrid[pt[Y]]; 
	token.tl _ [hgridlx,pt[Y]];
	token.br _ [hgridrx,pt[Y]+gridt-1];
	END;
token.validEncoding _ TRUE;
END;

DisplayCP: PROCEDURE[token: POINTER TO token Object]=
BEGIN
p0: ScrPt _ ObjToScr[token.p0];
i: CARDINAL _ IF token.tokenType=CP THEN 0 ELSE 2;
p0[X] _ p0[X]-4;
p0[Y] _ p0[Y]-4;
IF ~token.validEncoding THEN BEGIN
	token.tl _ p0;
	token.br _ [p0[X]+8,p0[Y]+8];
	token.validEncoding _ TRUE;
	END;
TokenMap.bits _ BASE[RuntimeBitmaps[i+1]];
ScreenDefs.BLTBlockInScreen[@Token,p0,erase];
TokenMap.bits _ BASE[RuntimeBitmaps[i]];
ScreenDefs.BLTBlockInScreen[@Token,p0,paint];
END;

DisplaySelectToken: PROCEDURE [token: POINTER TO token Object] =
BEGIN
selectedObject: ObjectHandle _ token.selected;
coverObj: ObjectHandle _ NIL;
covered: BOOLEAN _ FALSE;
screen: ScreenDefs.ScreenPtr _ ScreenDefs.GetCurrentScreen[];
stl: ScrPt _ [screen.lx,screen.ty];
sbr: ScrPt _ [screen.rx,screen.by];
bm: CARDINAL;
IF selectedObject.validEncoding=FALSE THEN RETURN;
IF token.validEncoding = FALSE 
    THEN  covered _ LocateSelectToken[token, selectedObject]
    ELSE BEGIN
--is token covered?
	coverObj _ GetObjectHandleBetweenObjects
	    [PointDefs.ObjToScr[token.p0], NIL, selectedObject] ;
--if not, is object covered at position of token?
	IF coverObj=token THEN coverObj _
		GetObjectHandleBetweenObjects
			[PointDefs.ObjToScr[token.p0],GetTopPictureObj[],selectedObject];
	covered _ (coverObj#token AND coverObj#NIL);
	END;

-- routine to relocate covered tokens... not used right now
-- IF covered THEN BEGIN
-- 	token.tl _ token.br _ [0,0];	
		-- so token doesn't interfere with search
-- 	covered _ LocateSelectToken[token, selectedObject];
-- 	END;

IF covered THEN bm _ 1 ELSE bm _ 0;
IF selectedObject.cluster # 0 THEN bm _ bm + 2;
SelectTokenMap.bits _ BASE[SelectBitmaps[bm]];
ScreenDefs.ResetClipEdges[];
ScreenDefs.BLTBlockInScreen[@SelectToken,PointDefs.ObjToScr[token.p0],replace];
ScreenDefs.SetClipEdges[stl,sbr];
END;

LocateSelectToken: PROCEDURE [token: POINTER TO token Object,
			object: ObjectHandle] RETURNS [covered: BOOLEAN] =
BEGIN
screenLoc: PointDefs.ScrPt;
covered _ FALSE;
WITH typedObj: object SELECT FROM
	caption => screenLoc _ ObjToScr[typedObj.p0];
	shape => BEGIN
	-- put token over second encoding chunk (encoding1.p0) if
	-- it exists and isnt covered or if encoding0.p0 is covered.
		encoding0: POINTER TO EncodingDefs.ChainEncoding
			_ typedObj.chainEncoding;
		encoding1: POINTER TO EncodingDefs.ChainEncoding
			_ encoding0.link;
		IF encoding1 = NIL THEN
			BEGIN
			covered _ (GetObjectHandleBetweenObjects
			      [encoding0.p0, NIL,object] # NIL);
			screenLoc _ encoding0.p0;
			END
		ELSE IF covered _ (GetObjectHandleBetweenObjects
				[encoding1.p0, NIL,object] # NIL)
			THEN IF covered _ 
			    (GetObjectHandleBetweenObjects
				[encoding0.p0, NIL,object] # NIL)
			    THEN screenLoc _ encoding1.p0
			    ELSE screenLoc _ encoding0.p0
			ELSE screenLoc _ encoding1.p0;
		END;
	ENDCASE => MiscDefs.CallDebugger
					["Selected object is not caption or shape (in LocateSelectToken)"];
screenLoc[X] _ screenLoc[X] - 5;
screenLoc[Y] _ screenLoc[Y] - 5;
token.p0 _ PointDefs.ScrToObj[screenLoc];
token.tl _ screenLoc;
token.br _ [screenLoc[X]+10,screenLoc[Y]+10];
token.validEncoding _ TRUE;
RETURN;
END;

SetChainEncoding: PROCEDURE[object: POINTER TO shape Object]=
BEGIN
tl,br: ScrPt;
num: CARDINAL _ 0;
encoding: POINTER TO EncodingDefs.ChainEncoding _ EncodingDefs.MakeChainEncoding[];
IF object.chainEncoding=NIL THEN object.chainEncoding _ encoding
ELSE BEGIN
	ptr: POINTER TO EncodingDefs.ChainEncoding _ object.chainEncoding;
	UNTIL ptr.link=NIL DO ptr _ ptr.link; num _ ptr.linknumber; ENDLOOP;
	ptr.link _ encoding;
--mark encoding chunks here
	num _ num+1;
	FOR ptr _ encoding, ptr _ ptr.link UNTIL ptr=NIL DO
		ptr.linknumber _ num;
		ENDLOOP;
	END;
[tl,br] _ GetMbb[object.chainEncoding, object.style.width];
object.tl _ tl;
object.br _ br;
object.validEncoding _ TRUE;
EncodingDefs.DeleteAreaEncoding[object.areaEncoding];
object.areaEncoding _ NIL;
END;

GetMbb: PROCEDURE[encoding: POINTER TO EncodingDefs.ChainEncoding,width: REAL] RETURNS[tl,br: ScrPt]=
BEGIN
halfwidth: INTEGER _ (ObjValToScrVal[width]+1)/2;
ptr: POINTER TO EncodingDefs.ChainEncoding _ encoding;
IF ptr=NIL THEN RETURN[[0,0],[0,0]];
tl _ ptr.tl;
br _ ptr.br;
UNTIL ptr=NIL DO
	IF ptr.tl[X] < tl[X] THEN tl[X] _ ptr.tl[X];
	IF ptr.tl[Y] < tl[Y] THEN tl[Y] _ ptr.tl[Y];
	IF ptr.br[X] > br[X] THEN br[X] _ ptr.br[X];
	IF ptr.br[Y] > br[Y] THEN br[Y] _ ptr.br[Y];
	ptr _ ptr.link;
	ENDLOOP;
tl[X] _ tl[X]-halfwidth; tl[Y] _tl[Y]-halfwidth;
br[X] _ br[X]+halfwidth; br[Y] _br[Y]+halfwidth;
END;

PlotChainEncoding: PROCEDURE[encoding: POINTER TO EncodingDefs.ChainEncoding]=
BEGIN OPEN encoding;
cState: ScreenDefs.ClipperState _ clip;
IF encoding=NIL THEN RETURN;
UNTIL encoding=NIL DO
	IF clipperState#inside THEN cState _ ScreenDefs.PrimeClipper[tl,br]; 
	IF cState#cull
		THEN EncodingDefs.PlotChainChunk[encoding,ScreenDefs.DrawSingleDot];
	encoding _ encoding.link;
	ENDLOOP;
--ScreenDefs.EndLine[];
ScreenDefs.ClipOn[];
END;

PlotAreaEncoding: PROCEDURE[encoding: POINTER TO EncodingDefs.AreaEncoding]=
BEGIN OPEN encoding;
cState: ScreenDefs.ClipperState _ clip;
IF encoding=NIL THEN RETURN;
UNTIL encoding=NIL DO
	IF clipperState#inside THEN cState _ ScreenDefs.PrimeClipper[tl,br]; 
	IF cState#cull
			THEN EncodingDefs.PlotAreaChunk[encoding,ScreenDefs.HFill];
	encoding _ encoding.link;
	ENDLOOP;
ScreenDefs.ClipOn[];
END;

SetAreaStyle: PROCEDURE [style: POINTER TO StyleDefs.Style] =
BEGIN OPEN ScreenDefs;
IF FNC=write THEN ScreenDefs.SetFunction[replace] ELSE SetFunction[erase];
ScreenDefs.SetFillParms[ControllerDefs.GreyOfColor[style.fillcolor], ControllerDefs.GetColorMapIndex[style.fillcolor]];
END;

SetTrajectoryStyle: PROCEDURE [style: POINTER TO StyleDefs.Style] =
BEGIN OPEN ScreenDefs;
jnc: JunctionType _ SELECT style.junctiontype FROM
	round => round,
	square => square,
	angled => angled,
	ENDCASE => round;

IF FNC=write THEN SetFunction[replace] ELSE SetFunction[erase];

SetLineParms[jnc,MAX[ObjValToScrVal[style.width],1],ControllerDefs.GreyOfColor[style.color],ControllerDefs.GetColorMapIndex[style.color],ConvertEnd[style.firstend],ConvertEnd[style.lastend]];
END;

SetFastStyle: PROCEDURE  =
BEGIN OPEN ScreenDefs;
IF FNC=write THEN SetFunction[paint] ELSE SetFunction[erase];
--set it to plot oneline wide grey.  grey is arbitray pick here
SetLineParms[round,1,ControllerDefs.GreyOfColor[[0,255,255]],ControllerDefs.GetColorMapIndex[[0,255,255]],[round[]],[round[]]];
END;

ConvertEnd: PROCEDURE [end: StyleDefs.LineEnd] RETURNS[ScreenDefs.EndType]=
BEGIN
RETURN[[round[]]];
END;

--Draws a trajectory
PlotTrajectory: PROCEDURE [shape: POINTER TO shape Object,closed: BOOLEAN] =
BEGIN
traj: Trajectory _ shape.trajectory;
MoveTo _ StartLine;
WITH thistraj: traj SELECT FROM
	linked => BEGIN
		linkPtr: POINTER TO Link _ thistraj.links;
		UNTIL linkPtr = NIL DO
			PlotLink[linkPtr,traj.splineType];
			linkPtr _ linkPtr.link;
			SetChainEncoding[shape];	--make it a link at a time
			ENDLOOP;
		END;
	cyclic => BEGIN
		PlotCurve[thistraj.knots,traj.splineType,TRUE];
		SetChainEncoding[shape];
		END;
	ENDCASE;
--everybody needs an endline.  rework for different end conditions
ScreenDefs.EndLine[];	
END;

PlotLink: PROCEDURE[link: POINTER TO Link,spline: SplineDefs.SplineType]=
BEGIN
IF LENGTH[link.knots]<=0 THEN RETURN;
--debug
IF debug THEN BEGIN
	length: INTEGER _ LENGTH[link.knots];
	knots: DESCRIPTOR FOR ARRAY OF ScrPt
		_ DESCRIPTOR[Allocate[length*SIZE[ObjPt]],length];
	FOR i IN [0..length) DO
		knots[i] _ ObjToScr[link.knots[i]];
		ENDLOOP;
	Free[BASE[knots]];
	END;
SELECT link.degree FROM
	D0 => PlotDots[link.knots];
	D1 => PlotLines[link.knots];
	D2 => NULL;
	D3 => PlotCurve[link.knots,spline,FALSE];
	ENDCASE;
END;

--Plots Dots
PlotDots: PROCEDURE [knots: DESCRIPTOR FOR ARRAY OF PointDefs.ObjPt] =
BEGIN
i: INTEGER;
FOR i IN [0..LENGTH[knots]) DO
	ScreenDefs.DrawSingleDot[ObjToScr[knots[i]]];
	ENDLOOP;
END;

--Plots Lines. 
PlotLines: PROCEDURE [knots: DESCRIPTOR FOR ARRAY OF PointDefs.ObjPt] =
BEGIN
i: INTEGER;
lastknot: INTEGER _ LENGTH[knots]-1;
MoveTo[ObjToScr[knots[0]]];
FOR i IN [1..lastknot] DO
	ScreenDefs.DrawTo[ObjToScr[knots[i]]];
	EncodingDefs.AddChainLine[ObjToScr[knots[i]]];
	ENDLOOP;
END;

--Plots a curve.  description is in the knots and the splinetype
PlotCurve: PROCEDURE [knots: DESCRIPTOR FOR ARRAY OF PointDefs.ObjPt,type: SplineDefs.SplineType,cyclic: BOOLEAN] =
BEGIN --makes an array.  Don't forget to deallocate it
newknots: DESCRIPTOR FOR ARRAY OF PointDefs.ObjPt _ XFormKnots[knots];
coeffs: DESCRIPTOR FOR ARRAY OF SplineDefs.Coeffs;
coeffs _ IF cyclic THEN MakeCyclicSpline[newknots,type] 
	ELSE SplineDefs.MakeSpline[newknots,type ! SplineDefs.TooFewKnots  => BEGIN
		Free[BASE[newknots]]; CONTINUE; END
		];
FOR i IN [0..LENGTH[coeffs]) DO
	SplineDefs.DisplayCubic[@coeffs[i],MoveTo,DrawToShort];
	ENDLOOP;
Free[BASE[newknots]];	--free the base
SplineDefs.FreeCoeffs[coeffs];
END;

MoveToNull: PROCEDURE[pt:PointDefs.ScrPt]=
BEGIN
END;

StartLine: PROCEDURE[pt:PointDefs.ScrPt]=
BEGIN
ScreenDefs.StartLine[pt];
EncodingDefs.AddChainPoint[pt];
END;

DrawToShort: PROCEDURE[pt:PointDefs.ScrPt]=
BEGIN
ScreenDefs.DrawToShort[pt];	
EncodingDefs.AddChainLine[pt];
END;

XFormKnots: PROCEDURE[knots: DESCRIPTOR FOR ARRAY OF PointDefs.ObjPt ]  RETURNS[ newknots: DESCRIPTOR FOR ARRAY OF PointDefs.ObjPt]=
BEGIN
length: INTEGER _ LENGTH[knots];
newknots _ DESCRIPTOR[Allocate[length*SIZE[PointDefs.ObjPt]],length];
FOR i IN [0..length) DO
	newknots[i] _ PointDefs.ObjToScrReal[knots[i]];
	ENDLOOP;
END;

MakeCyclicSpline: PROCEDURE[knots: DESCRIPTOR FOR ARRAY OF ObjPt, type: SplineDefs.SplineType] RETURNS[coeffs: DESCRIPTOR FOR ARRAY OF SplineDefs.Coeffs]=
BEGIN
cycknots: DESCRIPTOR FOR ARRAY OF ObjPt;
numknots: INTEGER _ LENGTH[knots];
newLength: INTEGER;
IF numknots <= 0 THEN RETURN[DESCRIPTOR[NIL,0]];
SELECT type FROM
	naturalUM, naturalAL,bezier=> newLength _ numknots+1;
	bspline, crspline=> newLength _ numknots+3;
	ENDCASE;
cycknots _ DESCRIPTOR[Allocate[newLength*SIZE[ObjPt]],newLength];
FOR i IN [0..numknots) DO
	cycknots[i] _ knots[i];
	ENDLOOP;
cycknots[numknots] _ cycknots[0];
SELECT type FROM
	naturalUM=> type _ cyclicUM;
	naturalAL=> type _ cyclicAL;
	bspline=> BEGIN 
		cycknots[numknots +1] _ cycknots[1];
		cycknots[numknots+2] _ cycknots[2];
		END;
	crspline=> BEGIN 
		cycknots[numknots +1] _ cycknots[1];
		cycknots[numknots+2] _ cycknots[2];
		END;
	ENDCASE;
coeffs _ SplineDefs.MakeSpline[cycknots,type];
Free[BASE[cycknots]];
RETURN;
END;

--makes a new linked trajectory with knuth splines in gaps
FillGaps: PROCEDURE[traj: POINTER TO linked Trajectory,closed: BOOLEAN] RETURNS[POINTER TO linked Trajectory] =
BEGIN
RETURN[traj];
END;

--Fills an area
FillArea: PROCEDURE [area: POINTER TO shape Object] =
BEGIN
--need chain encoding to make area encoding
IF area.chainEncoding=NIL THEN BEGIN
	SetFastStyle;
	PlotTrajectory[area,TRUE];
--object doesn't have an outline (happens as it's being drawn or modified)
	IF area.chainEncoding=NIL THEN RETURN;
	END;
SetAreaStyle[area.style];
area.areaEncoding _ EncodingDefs.MakeAreaEncoding[area.chainEncoding];
area.validEncoding _ TRUE;
END;

--writes the object.  Screen function set to replace or paint depending on type of obj
PlotOneObject: PUBLIC PROCEDURE [object: ObjectHandle,function: DisplayFnc] =
BEGIN
FNC _ function;
PlotObject[object];
END;


WriteObject: PUBLIC PROCEDURE [object: ObjectHandle] =
BEGIN
tl,br: ScrPt;
FNC _ write;
IF object=NIL THEN RETURN;
IF NOT object.validEncoding THEN BEGIN
	PlotOneObject[object,write];
	object _ object.link;	--now clean up above it
	IF object=NIL THEN RETURN;
	END;
--a little slop to catch the select token
tl _ object.tl;
br _ object.br;
IF object.objectType#token AND object.objectType#menu THEN BEGIN
	tl _ [tl[X]-selW,tl[Y]-selW];
	br _ [br[X]+selW,br[Y]+selW];
	END;
ReplotBoxFromObject[tl, br, object];
END;

ReplotBoxFromObject: PUBLIC PROCEDURE[tl,br: ScrPt, object: ObjectHandle]=
BEGIN
FNC _ write;
ScreenDefs.SetClipEdges[tl,br];
ReplotFromObject[object];
ScreenDefs.ResetClipEdges[];
END;

ReplotBox: PUBLIC PROCEDURE[tl,br: ScrPt]=
BEGIN
FNC _ write;
ScreenDefs.SetClipEdges[tl,br];
ReplotAllObjects[];
--reset them
ScreenDefs.ResetClipEdges[];
END;

EraseObject: PUBLIC PROCEDURE [object: ObjectHandle] =
BEGIN
Screen: ObjectProc = BEGIN
	IF obj#object THEN PlotObject[obj];
	END;
tl,br: ScrPt;
erased: BOOLEAN _ FALSE;
IF object=NIL THEN RETURN;
IF NOT object.validEncoding THEN BEGIN
	PlotOneObject[object,erase];
	erased _ TRUE;
	END;
--a little slop to catch the select token
tl _ object.tl;
br _ object.br;
IF object.objectType#token AND object.objectType#menu THEN BEGIN
	tl _ [tl[X]-selW,tl[Y]-selW];
	br _ [br[X]+selW,br[Y]+selW];
	END;
ScreenDefs.SetClipEdges[tl, br];
IF NOT erased THEN ScreenDefs.ClearScreen[];
FNC _ write;
ForAllObjects[Screen];
--reset them
ScreenDefs.ResetClipEdges[];
END;

WriteLink: PUBLIC PROCEDURE[obj: POINTER TO shape Object,link: POINTER TO Link]=
BEGIN
FNC _ write;
--first link 
WITH traj: obj.trajectory SELECT FROM
linked => IF traj.links=link THEN BEGIN
	EncodingDefs.DeleteChainEncoding[obj.chainEncoding];
	EncodingDefs.DeleteAreaEncoding[obj.areaEncoding];
	obj.chainEncoding _ NIL;
	obj.areaEncoding _ NIL;
	END;
ENDCASE => ERROR;
IF obj.style.outlined THEN SetTrajectoryStyle[obj.style] ELSE SetFastStyle;
MoveTo _ StartLine;
PlotLink[link,obj.trajectory.splineType];
ScreenDefs.EndLine[];
SetChainEncoding[obj];
END;

--no EraseLink.  It's all in DeleteLink for now

RuntimeBitmaps[0] _
	[16000B,12000B,12000B,173600B,104200B,173600B,12000B,12000B,16000B];  --CP
RuntimeBitmaps[1] _
	[16000B,16000B,16000B,177600B,177600B,177600B,16000B,16000B,16000B];  --erase cp
RuntimeBitmaps[2] _ [37000B,61400B,140600B,100200B,104200B,100200B,140600B,61400B,37000B];  --open
RuntimeBitmaps[3] _ [37000B,77400B,177600B,177600B,177600B,177600B,177600B,77400B,37000B];  --erase open
SelectBitmaps[0] _ [0,0,0,17770B,17770B,14030B,14030B,14630B,14630B,14030B,
		14030B,17770B,17770B,0,0,0]; --selected not hidden.
SelectBitmaps[1] _ [0,0,0,17770B,17770B,17030B,17430B,15630B,14730B,14370B,
		14170B,17770B,17770B,0,0,0]; --selected and hidden.
SelectBitmaps[2] _ [0,0,0,17770B,17770B,14030B,15730B,15030B,15030B,15730B,
		14030B,17770B,17770B,0,0,0];  --selected not hidden cluster.
SelectBitmaps[3] _ [0,0,0,17770B,17770B,14070B,15730B,15230B,15430B,15730B,
		16030B,17770B,17770B,0,0,0];  --selected and hidden cluster.

--block for local variables
END.(896)\18191i24I107i24I