-- Compiler ShowObjects/n;bind griffin;griffin
-- mstone April 24, 1981  3:10 PM
-- geoff November 26, 1979  10:45 AM
-- Last Edited by: Stone, February 18, 1983 1:03 pm
-- Last Edited by: Pier, February 14, 1984 10:52:01 am PST

DIRECTORY
	ScreenDefs,
	GriffinViewer USING [PaintProc, DoPaint],
	SplineDefs: FROM "SplineDefs",
	StyleDefs: FROM "StyleDefs",
	GriffinMemoryDefs USING [CZone],
	Graphics USING [Context],
	EncodingDefs: FROM "EncodingDefs",
	GriffinDefs: FROM "GriffinDefs",
	PointDefs: FROM "PointDefs",
	MenuDefs: FROM "MenuDefs",
	DebuggerSwap: FROM "DebuggerSwap",
	ControllerDefs: FROM "ControllerDefs",
	ObjectDefs: FROM "ObjectDefs";

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

--upper level module has to start splines
Context: TYPE=Graphics.Context;
i: INTEGER;	--the canonical loop counter
--put these somewhere as compile time constants
RuntimeBitmaps: ARRAY [0..3] OF ARRAY [0..8] OF CARDINAL;
Token: ScreenDefs.BlockPtr _ CZone.NEW[ScreenDefs.Block _ [NIL,1,0,0,9,9]];
SelectBitmaps: ARRAY [0..3] OF ARRAY [0..15] OF CARDINAL;
SelectToken: ScreenDefs.BlockPtr _ CZone.NEW[ScreenDefs.Block _ [NIL,1,3,3,10,10]];
selW: PUBLIC INTEGER _ 5;
HGrid,VGrid: ObjectHandle _ NIL;
hgridlx,hgridrx,vgridty,vgridby,gridt: INTEGER;
debug: BOOLEAN _ FALSE;
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, dc: Context] =
BEGIN
obj: REF Object _ startObj;
FNC _ write;
UNTIL obj=NIL DO
	PlotObject[obj, dc];
	obj _ obj.link;
	ENDLOOP;
END;

--calls the correct type of plotting routine, be it splines, encoding, whatever
PlotObject:  PROCEDURE [object: ObjectHandle, dc: Context] =
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 object SELECT FROM
	obj: REF Object[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  EncodeTrajectory[obj,FALSE];	--sets chain encoding
			PlotChainEncoding[obj.chainEncoding, dc];
			RETURN;
			END;
--Areas
		IF obj.style.filled AND obj.closed THEN BEGIN
			SetAreaStyle[obj.style];
			IF obj.areaEncoding=NIL THEN EncodeArea[obj];
			PlotAreaEncoding[obj.areaEncoding, dc];
			END;
--Outlined Areas.  TRUE = closed
		IF obj.style.outlined THEN BEGIN
			SetTrajectoryStyle[obj.style];
			IF obj.chainEncoding=NIL THEN  EncodeTrajectory[obj,TRUE];	--sets chain encoding
			PlotChainEncoding[obj.chainEncoding, dc];
			END;
		END;

	obj: REF Object[caption] => DisplayCaption[obj, dc];

	obj: REF Object[menu] => MenuDefs.PlotMenu[obj, dc];

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

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

DisplayCP: PROCEDURE[token: REF token Object, dc: Context]=
BEGIN
i: CARDINAL _ IF token.tokenType=CP THEN 0 ELSE 2;
IF ~token.validEncoding THEN BEGIN
	token.tl _ ObjToScr[token.p0];
	token.br _ [token.tl[X]+8,token.tl[Y]+8];
	token.validEncoding _ TRUE;
	END;
--Token.base _ BASE[RuntimeBitmaps[i+1]];
--ScreenDefs.BLTBlockInScreen[Token,p0,erase];
ScreenDefs.EraseBox[token.tl,token.br, dc];
Token.base _ BASE[RuntimeBitmaps[i]];
ScreenDefs.BLTBlockInScreen[Token,token.tl,transparent, dc];
END;

DisplaySelectToken: PROCEDURE [token: REF token Object, dc: Context] =
BEGIN
selectedObject: ObjectHandle _ token.isSelected;
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;
SelectToken.base _ BASE[SelectBitmaps[bm]];
--ScreenDefs.ResetClipEdges[];
ScreenDefs.BLTBlockInScreen[SelectToken,token.tl,opaque, dc];
--ScreenDefs.SetClipEdges[stl,sbr];
END;

LocateSelectToken: PROCEDURE [token: REF 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: REF EncodingDefs.ChainEncoding
			_ typedObj.chainEncoding;
		encoding1: REF 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 => DebuggerSwap.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: REF shape Object]=
BEGIN
tl,br: ScrPt;
num: CARDINAL _ 0;
encoding: REF EncodingDefs.ChainEncoding _ EncodingDefs.MakeChainEncoding[];
IF object.chainEncoding=NIL THEN object.chainEncoding _ encoding
ELSE BEGIN
	ptr: REF 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: REF EncodingDefs.ChainEncoding,width: REAL] RETURNS[tl,br: ScrPt]=
BEGIN
halfwidth: INTEGER _ (ObjValToScrVal[width]+1)/2;
ptr: REF 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: REF EncodingDefs.ChainEncoding, dc: Context]=
BEGIN OPEN encoding;
cState: ScreenDefs.ClipperState _ clip;
paint: GriffinViewer.PaintProc = {
	UNTIL encoding=NIL DO
		cState _ ScreenDefs.PrimeClipper[tl,br]; 
		IF cState#cull THEN EncodingDefs.PlotChainChunk[encoding, dc];
		encoding _ encoding.link;
		ENDLOOP;
		};
IF encoding=NIL THEN RETURN;
IF dc=NIL THEN GriffinViewer.DoPaint[paint] ELSE paint[dc];
ScreenDefs.ClipOn[];
END;

PlotAreaEncoding: PROCEDURE[encoding: REF EncodingDefs.AreaEncoding, dc: Context]=
BEGIN OPEN encoding;
cState: ScreenDefs.ClipperState _ clip;
paint: GriffinViewer.PaintProc = {
	UNTIL encoding=NIL DO
		cState _ ScreenDefs.PrimeClipper[tl,br]; 
		IF cState#cull THEN EncodingDefs.PlotAreaChunk[encoding,dc];
		encoding _ encoding.link;
		ENDLOOP;
		};
IF encoding=NIL THEN RETURN;
IF dc=NIL THEN GriffinViewer.DoPaint[paint] ELSE paint[dc];
ScreenDefs.ClipOn[];
END;

SetAreaStyle: PROCEDURE [style: REF StyleDefs.Style] =
BEGIN OPEN ScreenDefs;
IF FNC=write THEN ScreenDefs.SetFunction[opaque] ELSE DebuggerSwap.CallDebugger["erase case"];
ScreenDefs.SetFillParms[ControllerDefs.GreyOfColor[style.fillcolor]];
END;

SetTrajectoryStyle: PROCEDURE [style: REF StyleDefs.Style] =
BEGIN
IF FNC=write THEN ScreenDefs.SetFunction[opaque];
ScreenDefs.SetLineParms[
	MAX[ObjValToScrVal[style.width],1],ControllerDefs.GreyOfColor[style.color]];
END;

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

--Draws a trajectory
EncodeTrajectory: PROCEDURE [shape: REF shape Object,closed: BOOLEAN] =
BEGIN
traj: REF Trajectory _ shape.trajectory;
WITH traj SELECT FROM
	thistraj: REF Trajectory[linked] => BEGIN
		linkPtr: REF Link _ thistraj.links;
		UNTIL linkPtr = NIL DO
			EncodeLink[linkPtr,traj.splineType];
			linkPtr _ linkPtr.link;
			SetChainEncoding[shape];	--make it a link at a time
			ENDLOOP;
		END;
	thistraj: REF Trajectory[cyclic] => BEGIN
		EncodeCurve[thistraj.knots,traj.splineType,TRUE];
		SetChainEncoding[shape];
		END;
	ENDCASE;
END;

EncodeLink: PROCEDURE[link: REF Link,spline: SplineDefs.SplineType]=
BEGIN
IF link.knots=NIL OR link.knots.length <=0 THEN RETURN;
SELECT link.degree FROM
	D0 => NULL;
	D1 => EncodeLines[link.knots];
	D2 => NULL;
	D3 => EncodeCurve[link.knots,spline,FALSE];
	ENDCASE;
END;

--Encode Lines. 
EncodeLines: PROCEDURE [knots: PointDefs.ObjPtSequence] =
BEGIN
i: INTEGER;
lastknot: INTEGER _ knots.length-1;
EncodingDefs.AddChainPoint[ObjToScr[knots[0]]];
FOR i IN [1..lastknot] DO
	EncodingDefs.AddChainLine[ObjToScr[knots[i]]];
	ENDLOOP;
END;

--Encodes a curve.  description is in the knots and the splinetype
EncodeCurve: PROCEDURE [knots: PointDefs.ObjPtSequence,type: SplineDefs.SplineType,cyclic: BOOLEAN] =
BEGIN --makes an array.  Don't forget to deallocate it
newknots: SplineDefs.KnotSequence _ XFormKnots[knots];
coeffs: SplineDefs.CoeffsSequence;
coeffs _ IF cyclic THEN MakeCyclicSpline[newknots,type] 
	ELSE SplineDefs.MakeSpline[newknots,type];
FOR i IN [0..coeffs.length) DO
	SplineDefs.DisplayCubic[coeffs[i],EncodingDefs.AddChainPoint,EncodingDefs.AddChainLine];
	ENDLOOP;
END;

XFormKnots: PROCEDURE[knots: PointDefs.ObjPtSequence ] RETURNS[ newknots: SplineDefs.KnotSequence]=
BEGIN
length: INTEGER _ knots.length;
newknots _ CZone.NEW[SplineDefs.KnotSequenceRec[length]];
FOR i IN [0..length) DO
	newknots[i] _ PointDefs.ObjToScrReal[knots[i]];
	ENDLOOP;
END;

MakeCyclicSpline: PROCEDURE[knots: SplineDefs.KnotSequence, type: SplineDefs.SplineType] RETURNS[coeffs: SplineDefs.CoeffsSequence]=
BEGIN
cycknots: SplineDefs.KnotSequence;
numknots: INTEGER _ (IF knots=NIL THEN 0 ELSE knots.length);
newLength: INTEGER;
IF numknots <= 0 THEN RETURN[NIL];
SELECT type FROM
	naturalUM, naturalAL,bezier=> newLength _ numknots+1;
	bspline, crspline=> newLength _ numknots+3;
	ENDCASE;
cycknots _ CZone.NEW[SplineDefs.KnotSequenceRec[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];
RETURN;
END;

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

--Fills an area
EncodeArea: PROCEDURE [area: REF shape Object] =
BEGIN
--need chain encoding to make area encoding
IF area.chainEncoding=NIL THEN BEGIN
	SetFastStyle;
	EncodeTrajectory[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, NIL];
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, NIL];
END;

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

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

EraseObject: PUBLIC PROCEDURE [object: ObjectHandle] =
BEGIN
Screen: ObjectProc = BEGIN
	IF obj#object THEN PlotObject[obj, NIL];
	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[NIL];
FNC _ write;
ForAllObjects[Screen];
--reset them
ScreenDefs.ResetClipEdges[];
END;

WriteLink: PUBLIC PROCEDURE[obj: REF shape Object,link: REF Link]=
BEGIN
paint: GriffinViewer.PaintProc = {PlotChainEncoding[obj.chainEncoding, dc]};
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;
EncodeLink[link,obj.trajectory.splineType];
SetChainEncoding[obj];
GriffinViewer.DoPaint[paint];
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.
Ź
»˜JšČ
ĻcŖ
œ<Ļk	œžœ$žœžœ!žœžœžœžœžœžœžœ"žœ žœžœ
žœˆ
žœžœ
žœ**œ	žœžœMœžœžœ
žœžœ
žœ%žœžœžœžœ
žœ	žœ
žœ+žœžœžœ
žœ"žœ)žœ	žœžœžœEĻnœžœ
ž	œžœ
žœžœ
žœžœ¶
ž
œ+œ'žœž
œ+œ'žœ0žœ#žœžœžœ&žœžœŸœžœ
ž	œžœ%žœ&žœžœ+Ÿœžœ
ž	œ(žœžœžœ
žœžœ
žœ)žœžœPŸ
œž	œ'žœžœžœ
žœ
žœžœžœ
žœžœžœ>žœžœžœžœžœ
žœžœžœžœ
žœžœ
žœ†
žœžœžœ	œžœ
žœžœ
žœžœžœžœžœœžœ#žœžœ
žœžœœ&žœžœžœœžœžœžœ
žœ žœžœ
žœ@žœ!œžœžœ
žœ&žœžœ
žœžœœ0žœžœ	žœ4žœ4žœžœžœžœzžœžœœžœŸœž	œžœžœ!žœžœ
žœž
œž
œž
œžœ
žœ
žœž
œ!ž
œž
œ
žœžœžœŸ	œž	œžœžœžœžœžœ
žœžœžœžœ
žœ7ž
œ
ž
œžœžœYœ9žœRžœŸœž	œ	žœžœKžœžœžœŒ
œžœžœžœ
žœ
žœžœžœžœ9žœ
žœ
œNžœ2œ
žœžœŒ
žœ
žœžœwœkœ
žœ	žœžœ	žœžœ!žœœ>$žœŸœž	œ	žœ(žœžœžœ'žœžœžœ
žœ:žœ:œ
=œ
žœFžœ3žœ
žœ
žœžœEžœžœ#žœžœ
žœ=žœžœžœ
žœEžœžœ	žœ!žœžœžœžœqž
œž
œž
œž
œ]ž
œž
œžœžœžœŸœž	œ	žœžœžœžœ@žœžœ
žœ!žœ
žœžœ5žœ
žœ
žœ'žœœžœ žœžœ
žœžœžœužœNžœžœŸœž	œžœ#žœžœžœžœ%žœ(žœžœ
žœ
žœ)žœžœ
žœžœž
œž
œžœž
œž
œžœž
œž
œžœž
œž
œžœž
œž
œžœž
œž
œžœž
œž
œžœž
œž
œžœž
œž
œž
œž
œž
œž
œž
œž
œ
žœŸœž	œžœ+žœ
žœUžœ
žœ
žœ/žœ
žœJžœžœ
žœ
žœ
žœžœžœ
žœžœ!žœŸœž	œžœ*žœ
žœUžœ
žœ
žœ/žœžœHžœžœ
žœ
žœ
žœžœžœ
žœžœ!žœŸœž	œ	žœžœ
žœ
žœ
žœžœ žœpžœŸœž	œ	žœžœ
žœ
žœžœ9žœJžœŸœž	œžœ
žœ
žœžœ!@œ@žœŸœž	œ	žœžœžœžœ žœžœ
žœžœžœžœžœžœ
žœ`œžœžœ
žœžœ.žœ žœžœžœŸ
œž	œžœ&žœ
žœžœ
žœžœ
žœžœ
žœžœ)žœ'žœžœžœŸœž	œ$žœžœžœCžœžœžœ2žœžœCŸœž	œEžœžœ
1œcžœžœ#žœ'žœžœžœ\žœžœŸ
œž	œ"žœ&žœ	žœ"žœ&žœžœ
žœ3žœžœŸœž	œ>žœ%žœ.žœžœžœ
žœžœžœžœžœ
žœ
žœžœžœfžœžœ)žœžœžœžœ$žœžœHžœQžœžœQžœžœ1žœžœ;Ÿœž	œžœžœžœ
žœžœ
žœžœŸ
œž	œžœžœ
,žœžœ
žœ
žœ'žœKœ
žœžœ
žœ
žœžœxžœžœWŸ
œžœ
ž	œ/žœ
žœ žœžœŸœžœ
ž	œžœžœ
žœžœ
žœ
žœžœ
žœžœ
žœ6œ
žœžœ
žœ
žœžœ*œ žœžœžœ
žœž
œ
ž
œž
œ
ž
œ
žœ&žœžœŸœžœ
ž	œ3žœ
žœežœŸ	œžœ
ž	œžœ
žœ@
œžœŸœžœ
ž	œžœžœžœžœžœžœžœžœžœžœ
žœ
žœžœ
žœžœ
žœ)žœžœ*œ žœžœžœ
žœž
œ
ž
œž
œ
ž
œ
žœ#žœ
žœžœžœžœ!
œžœŸ	œžœ
ž	œžœžœžœNžœ
žœžœ
žœžœžœ
žœ€
žœžœžœžœžœžœžœžœpžœ0œ\œ[œ\œ\
œkœkœlœlœ
žœ
˜ąŠ
—…—EbP#