-- Compiler Controllers/n
-- Stone, April 30, 1981  3:19 PM
-- implementing module for griffin file controllers

DIRECTORY StyleDefs: FROM "StyleDefs" USING [Color, StyleHandle, lStyle, LineEnd, EndType, Style, Orientation],
	ControllerDefs: FROM "ControllerDefs",
	GriffinFontDefs: FROM "GriffinFontDefs",
	GraphicsDefs: FROM "GraphicsDefs",
	GriffinMemoryDefs: FROM "GriffinMemoryDefs",
	IODefs: FROM "IODefs",
	InlineDefs: FROM "InlineDefs",
	ObjectDefs: FROM "ObjectDefs",
	Real: FROM "Real",
	RealFns: FROM "RealFns",
	StringDefs: FROM "StringDefs";



-- ---------------------------------------------------------------------------------
-- ---------------------------------------------------------------------------------
Controllers:  PROGRAM IMPORTS GriffinMemoryDefs, StringDefs, Real, GraphicsDefs, IODefs, RealFns, ObjectDefs EXPORTS ControllerDefs =

BEGIN OPEN ControllerDefs; 


-- this section describes the font data
Font: TYPE = RECORD [next: FontHandle, font: GriffinFontDefs.FontDescriptor];
lFont: CARDINAL = SIZE [Font];
FontHandle: TYPE = POINTER TO Font;
firstFont, lastFont: FontHandle _ NIL;
currentFont: GriffinFontDefs.FontDescriptor;

-- this section describes the style data
firstStyle, lastStyle: StyleDefs.StyleHandle _ NIL;
currentStyleRecord: StyleDefs.Style;

--this section describes the hardcopy controller data
hController: HardcopyController;



--this section describes the display controller data
dController: DisplayController;
ControlPair: TYPE = RECORD [next: ControlPairHandle, color: StyleDefs.Color, grey: [0 .. 255]];
lControlPair: CARDINAL = SIZE [ControlPair];
ControlPairHandle: TYPE = POINTER TO ControlPair;
firstControlPair, lastControlPair: ControlPairHandle _ NIL;
GreyArray: TYPE = ARRAY [0 .. 3] OF CARDINAL;
grey50: GreyArray = [52525B, 125252B, 52525B, 125252B];
grey100: GreyArray = [177777B, 177777B, 177777B, 177777B];
grey20: GreyArray = [22222B, 34343B, 23232B, 45454B];
grey0: GreyArray = [0, 0, 0, 0];
maxGrey: INTEGER = 16;
defaultGrey: INTEGER = -1;
defaultColor: CARDINAL = 30;
greyTable: ARRAY [-1 .. maxGrey] OF GreyArray;
RGB: ARRAY [0 .. 29] OF ARRAY[0..2] OF REAL;

PixelsToMicas: REAL;

SetHardcopyController: PUBLIC PROCEDURE [hc: HardcopyController] =
BEGIN hController _hc END;


SetDisplayController: PUBLIC PROCEDURE [dc: DisplayController] =
BEGIN dController _ dc END;



ReadDisplayController: PUBLIC PROCEDURE RETURNS [DisplayController] =
BEGIN RETURN [dController] END;



ReadHardcopyController: PUBLIC PROCEDURE RETURNS [HardcopyController] =
BEGIN RETURN [hController] END;




SetGreyOfColor: PUBLIC PROCEDURE [color: StyleDefs.Color, grey: [0 .. 255]] = BEGIN
rover: ControlPairHandle _ firstControlPair;
IF rover # NIL THEN BEGIN
	UNTIL rover.next = NIL DO IF rover.color = color THEN RETURN; ENDLOOP;
	rover _ rover.next _ GriffinMemoryDefs.Allocate [lControlPair];
	rover.next _ NIL;
	rover.color _ color;
	RETURN;
	END
ELSE BEGIN
	firstControlPair _ GriffinMemoryDefs.Allocate [lControlPair];
	firstControlPair.next _ NIL;
	firstControlPair.color _ color;
	END;
END;




GreyOfColor: PUBLIC PROCEDURE [color: StyleDefs.Color] RETURNS [POINTER TO GreyArray] = BEGIN
rover: ControlPairHandle _ firstControlPair;
-- hack, should be removed and commented code should be uncommented
RETURN [@greyTable [SELECT color FROM
	--black-- [0,0,0] => 16,
	--dk brown-- [7,255,59] => 14,
	--brown-- [7,255,118] => 12,
	--tan-- [0,131,217] => 4,
	--maroon-- [234,255,79] => 13,
	--dk red-- [0,255,160] => 11,
	--red-- [0,255,255] => 8,
	--orange-- [10,255,255] => 6,
	--dk yellow-- [25,255,255] => 7,
	--yellow-- [40,255,255] => 3,
	--lt yellow-- [40,190,255] => 2,
	--dk green-- [71,255,59] => 11,
	--green-- [76,255,255] => 7,
	--lt green-- [71,193,255] => 5,
	--dk blue-- [150,255,170] => 10,
	--blue-- [148,255,255] => 7,
	--lt blue-- [141,150,255] => 4,
	--dk aqua-- [107,255,98] => 9,
	--aqua-- [107,224,255] => 5,
	--cyan-- [120,255,255] => 5,
	--dk purple-- [178,255,178] => 10,
	--purple-- [170,224,255] => 8,
	--violet-- [170,131,255] => 4,
	--magenta-- [200,255,255] => 8,
	--pink-- [206,170,255] => 4,
	--dk grey-- [0,0,40] => 13,
	--grey-- [0,0,120] => 8,
	--lt grey-- [0,0,200] => 4,
	--pale grey-- [0,0,230] => 1,
	--white-- [0,0,255] => 0,
	ENDCASE => defaultGrey]];
-- UNTIL rover = NIL DO
-- 	IF rover.color = color THEN RETURN [greyTable [rover.grey]] ELSE rover _ rover.next;
-- 	ENDLOOP;
-- RETURN [greyTable [maxGrey]];
END;

GetColorMapIndex: PUBLIC PROCEDURE [color: StyleDefs.Color] RETURNS [CARDINAL] =
BEGIN
RETURN [(SELECT color FROM
	--black-- [0,0,0] => 29,
	--dk brown-- [7,255,59] => 28,
	--brown-- [7,255,118] => 27,
	--tan-- [0,131,217] => 26,
	--maroon-- [234,255,79] => 25,
	--dk red-- [0,255,160] => 24,
	--red-- [0,255,255] => 23,
	--orange-- [10,255,255] => 22,
	--dk yellow-- [25,255,255] => 21,
	--yellow-- [40,255,255] => 20,
	--lt yellow-- [40,190,255] => 19,
	--dk green-- [71,255,59] => 18,
	--green-- [76,255,255] => 17,
	--lt green-- [71,193,255] => 16,
	--dk blue-- [150,255,170] => 15,
	--blue-- [148,255,255] => 14,
	--lt blue-- [141,150,255] => 13,
	--dk aqua-- [107,255,98] => 12,
	--aqua-- [107,224,255] => 11,
	--cyan-- [120,255,255] => 10,
	--dk purple-- [178,255,178] => 9,
	--purple-- [170,224,255] => 8,
	--violet-- [170,131,255] => 7,
	--magenta-- [200,255,255] => 6,
	--pink-- [206,170,255] => 5,
	--dk grey-- [0,0,40] => 4,
	--grey-- [0,0,120] => 3,
	--lt grey-- [0,0,200] => 2,
	--pale grey-- [0,0,230] => 1,
	--white-- [0,0,255] => 0,
	ENDCASE => defaultColor)];
END;

InitColorMap: PUBLIC PROCEDURE[color: BOOLEAN]=
BEGIN
cmi: CARDINAL; -- color map index
ihue: INTEGER;
hue, m,n,k,fhue: REAL;
saturation, intensity: REAL;
RGBArray: ARRAY [0..2] OF INTEGER;
ONE: REAL _ 1;
E2: REAL _ 100;
scaler: REAL _ 6 + (3*ONE)/8;	--6.375
gammahigh: REAL _ 1/Real.StringToReal["2.3"];
gammalow: REAL _ 1/Real.StringToReal["3"];
comp: PROCEDURE[value: REAL] RETURNS[REAL] =
	BEGIN
	RETURN[RealFns.Power[value,gammalow]]
	END;
int: PROCEDURE[value: REAL] RETURNS[i: INTEGER] =
	BEGIN
	RETURN[Real.FixI[255*value+ONE/2]];
	END;

HSIForColorMapIndex: ARRAY [0..29] OF StyleDefs.Color _
	[
	--white-- [0,0,255] -- 0--,
	--pale grey-- [0,0,230] -- 1--,
	--lt grey-- [0,0,200] -- 2--,
	--grey-- [0,0,120] -- 3--,
	--dk grey-- [0,0,40] -- 4--,
	--pink-- [206,170,255] -- 5--,
	--magenta-- [200,255,255] -- 6--,
	--violet-- [170,131,255] -- 7--,
	--purple-- [170,224,255] -- 8--,
	--dk purple-- [178,255,178] -- 9--,
	--cyan-- [120,255,255] -- 10--,
	--aqua-- [107,224,255] -- 11--,
	--dk aqua-- [107,255,98] -- 12--,
	--lt blue-- [141,150,255] -- 13--,
	--blue-- [148,255,255] -- 14--,
	--dk blue-- [150,255,170] -- 15--,
	--lt green-- [71,193,255] -- 16--,
	--green-- [76,255,255] -- 17--,
	--dk green-- [71,255,59] -- 18--,
	--lt yellow-- [40,190,255] -- 19--,
	--yellow-- [40,255,255] -- 20--,
	--dk yellow-- [25,255,255] -- 21--,
	--orange-- [10,255,255] -- 22--,
	--red-- [0,255,255] -- 23--,
	--dk red-- [0,255,160] -- 24--,
	--maroon-- [234,255,79] -- 25--,
	--tan-- [0,131,217] -- 26--,
	--brown-- [7,255,118] -- 27--,
	--dk brown-- [7,255,59]--28--,
	--black-- [0,0,0] --29--
	];

IODefs.WriteLine["H S I => R G B"];
IF color THEN FOR cmi IN [0..29] DO
	[hue,saturation,intensity] _ HSIForColorMapIndex[cmi];
	
	Real.WriteReal[IODefs.WriteChar,hue];
	IODefs.WriteChar[' ];
	Real.WriteReal[IODefs.WriteChar,saturation];
	IODefs.WriteChar[' ];
	Real.WriteReal[IODefs.WriteChar,intensity];
	IODefs.WriteString[" => "];

	hue _ scaler*hue/255;
	saturation _ saturation/255;
	intensity _ intensity/255;
	ihue _ Real.FixI[hue];	--integer hue
	fhue _ hue-ihue;	--fractional hue
	m _ intensity*(1-saturation);
	n _ intensity*(1-(saturation*fhue));
	k _ intensity*(1-(saturation*(1-fhue)));
--save the fractional RGB values for monochrome
	SELECT ihue FROM
		0 => RGB[cmi] _ [intensity, k, m];
		1 => RGB[cmi] _ [n, intensity, m];
		2 => RGB[cmi] _ [m, intensity, k];
		3 => RGB[cmi] _ [m, n, intensity];
		4 => RGB[cmi] _ [k, m, intensity];
		5 => RGB[cmi] _ [intensity, m, n];
		ENDCASE;
--compensate and change to scaled integer
	n _ comp[n]; m _ comp[m]; k _ comp[k]; intensity _ comp[intensity];
	SELECT ihue FROM
		0 => RGBArray _ [int[intensity],int[k],int[m]];
		1 => RGBArray _ [int[n],int[intensity],int[m]];
		2 => RGBArray _ [int[m],int[intensity],int[k]];
		3 => RGBArray _ [int[m],int[n],int[intensity]];
		4 => RGBArray _ [int[k],int[m],int[intensity]];
		5 => RGBArray _ [int[intensity],int[m],int[n]];
		ENDCASE;
	PutColor[cmi,RGBArray];

	IODefs.WriteDecimal[RGBArray[0]];
	IODefs.WriteChar[' ];
	IODefs.WriteDecimal[RGBArray[1]];
	IODefs.WriteChar[' ];
	IODefs.WriteDecimal[RGBArray[2]];
	IODefs.WriteLine[" "];
	ENDLOOP
ELSE FOR cmi IN [0..29] DO
	intensity _ (30*RGB[cmi][0]+59*RGB[cmi][1]+11*RGB[cmi][2])/100;
	RGBArray[0] _ RGBArray[1] _ RGBArray[2] _ int[comp[intensity]];
	PutColor[cmi,RGBArray];
	IODefs.WriteDecimal[RGBArray[0]];
	IODefs.WriteChar[' ];
	ENDLOOP;

IODefs.WriteLine[" "];
END;


IntensityOfColor: PUBLIC PROCEDURE [color: StyleDefs.Color] RETURNS [INTEGER]=
BEGIN
cmi: CARDINAL _ GetColorMapIndex[color];
intensity: REAL _ (30*RGB[cmi][0]+59*RGB[cmi][1]+11*RGB[cmi][2])/100;
RETURN[Real.RoundI[(intensity*255)]];
END;

PutColor: PROCEDURE[index: CARDINAL, CArray: ARRAY [0..2] OF INTEGER]=
BEGIN
GraphicsDefs.SetRed[index,CArray[0]];
GraphicsDefs.SetGreen[index,CArray[1]];
GraphicsDefs.SetBlue[index,CArray[2]];
END;


ExpungeStyles: PUBLIC PROC = {
	appendStyle: ObjectDefs.ObjectProc = {
		IF FindStyle[oldStyles,obj.style]#NIL THEN {
			oldStyles _ UnlinkStyle[oldStyles,obj.style];
			AddStyle[obj.style];
			};
		};
--old list
	oldStyles: StyleDefs.StyleHandle _ firstStyle;
	rover,temp: StyleDefs.StyleHandle;
	firstStyle _ lastStyle _ NIL;	--indicate no styles
	ObjectDefs.ForAllObjects[appendStyle];	--move each style in use
--delete the old style list
	rover _ oldStyles;
	UNTIL rover=NIL DO 
		GriffinMemoryDefs.FreeString[rover.name];
		temp _ rover.next;
		GriffinMemoryDefs.Free[rover];
		rover _ temp;
		ENDLOOP;
	};

UnlinkStyle: PROC [list,style: StyleDefs.StyleHandle] RETURNS[StyleDefs.StyleHandle] = {
	ptr: StyleDefs.StyleHandle;
	IF list=style THEN list _ list.next
	ELSE { 
		FOR ptr _ list, ptr.next UNTIL ptr.next=style DO ENDLOOP;
		ptr.next _ style.next;
		};
	RETURN[list];
	};

FindStyle: PROC [list,style: StyleDefs.StyleHandle] RETURNS[StyleDefs.StyleHandle]= {
	ptr: StyleDefs.StyleHandle;
	FOR ptr _ list, ptr.next UNTIL ptr=style OR ptr=NIL DO ENDLOOP;
	RETURN[ptr];
	};

AddStyle: PROC [style: StyleDefs.StyleHandle] = {
	IF firstStyle=NIL THEN firstStyle _ lastStyle _ style 
	ELSE {lastStyle.next _ style; style.next _ NIL; lastStyle _ style};
	};

ForAllControlPairs: PUBLIC PROCEDURE [proc: ControllerDefs.CPProcedure] = BEGIN
	rover: ControlPairHandle _ firstControlPair;
	UNTIL rover = NIL DO
		proc [rover.color, rover.grey];
		rover _ rover.next;
		ENDLOOP;
	END;

AppendStyle: PUBLIC PROCEDURE [src: StyleDefs.StyleHandle]
		RETURNS [CARDINAL] =
	BEGIN OPEN StyleDefs;
	thisstyle, rover: StyleHandle _ NIL;
	FOR rover_firstStyle, rover.next UNTIL rover = NIL
		DO
		IF SameStyle[rover, src]
			THEN RETURN[NumberOfStyle[rover]];
		ENDLOOP;
	thisstyle _ GriffinMemoryDefs.Allocate [lStyle];
	thisstyle^ _ src^; -- copy body of style
	thisstyle.name _ GriffinMemoryDefs.AllocateString[src.name.length];
	thisstyle.name.length _ 0;
	StringDefs.AppendString[thisstyle.name,src.name];
	thisstyle.next _ NIL;
	IF firstStyle = NIL THEN firstStyle _ lastStyle _ thisstyle ELSE lastStyle _ lastStyle.next _ thisstyle;
	RETURN[NumberOfStyle[thisstyle]];
	END;

NumberOfStyle: PUBLIC PROCEDURE [s: StyleDefs.StyleHandle]  RETURNS [count: CARDINAL] = BEGIN
	rover: StyleDefs.StyleHandle _ firstStyle;
	count _ 1;
	UNTIL rover = NIL DO
		IF s = rover THEN RETURN;
		count _ count + 1;
		rover _ rover.next;
		ENDLOOP;
	SIGNAL ControllerError;
	END;
	
StyleWithNumber: PUBLIC PROCEDURE [count: CARDINAL]  RETURNS [s: StyleDefs.StyleHandle] = BEGIN
	s _ firstStyle;
	UNTIL count = 1 DO
		IF s = NIL THEN SIGNAL ControllerError;
		count _ count - 1;
		s _ s.next;
		ENDLOOP;
	END;


AppendFont: PUBLIC PROCEDURE [fd: GriffinFontDefs.FontDescriptor]
		RETURNS [CARDINAL] =
	BEGIN
	thisfont, rover: FontHandle _ NIL;
	FOR rover_firstFont, rover.next UNTIL rover = NIL
		DO
		IF SameFont[@rover.font,@fd]
			THEN RETURN[NumberOfFont[rover]];
		ENDLOOP;
	thisfont _ GriffinMemoryDefs.Allocate [lFont];
	thisfont.font _ fd;
	thisfont.next _ NIL;
	IF firstFont = NIL
		THEN firstFont _ lastFont _ thisfont
		ELSE lastFont _ lastFont.next _ thisfont;
	RETURN[NumberOfFont[thisfont]];
	END;

NumberOfFont: PUBLIC PROCEDURE [font: FontHandle]
		RETURNS [count: CARDINAL] =
	BEGIN
	rover: FontHandle _ firstFont;
	count _ 1;
	UNTIL rover = NIL DO
		IF rover = font THEN RETURN;
		count _ count + 1;
		rover _ rover.next;
		ENDLOOP;
	SIGNAL ControllerError;
	END;
	
FontWithNumber: PUBLIC PROCEDURE [count: CARDINAL]  RETURNS [fd: GriffinFontDefs.FontDescriptor] = BEGIN
	f: FontHandle _ firstFont;
	UNTIL count = 1 DO
		IF f = NIL THEN SIGNAL ControllerError;
		count _ count - 1;
		f _ f.next;
		ENDLOOP;
	fd _ f.font
	END;

CurrentFontDescriptor: PUBLIC PROCEDURE RETURNS [GriffinFontDefs.FontDescriptorHandle] = BEGIN
RETURN [@currentFont];
END;


ForAllStyles: PUBLIC PROCEDURE [proc: PROCEDURE [StyleDefs.StyleHandle]] = BEGIN
	rover: StyleDefs.StyleHandle _ firstStyle;
	UNTIL rover = NIL DO proc [rover]; rover _ rover.next; ENDLOOP;
	END;

ForAllFonts: PUBLIC PROCEDURE [proc: PROCEDURE [GriffinFontDefs.FontDescriptor]] = BEGIN
	rover: FontHandle _ firstFont;
	UNTIL rover = NIL DO proc [rover.font]; rover _ rover.next; ENDLOOP;
	END;


styleCount: CARDINAL _ 0;
CurrentStyle: PUBLIC PROCEDURE RETURNS [answer: StyleDefs.StyleHandle] =BEGIN OPEN StyleDefs;
	str: STRING;
	count: CARDINAL _ 1;
	fontid: CARDINAL _ 0;
	TryFont: PROCEDURE [fd: GriffinFontDefs.FontDescriptor] = BEGIN
		IF StringDefs.EquivalentString [fd.name, currentFont.name] THEN 
			BEGIN
			fd.name _ currentFont.name;
			IF fd = currentFont THEN fontid _ count;
			END;
		count _ count + 1;
		END;
	ForAllFonts [TryFont];
	IF fontid = 0 THEN BEGIN
		[]_AppendFont [currentFont];
		-- just gave away a string that wasn't ours, must restore it
		str_GriffinMemoryDefs.AllocateString[currentFont.name.length];
		StringDefs.AppendString [str, currentFont.name];
		currentFont.name _ str;
		fontid _ count;
		END;
	currentStyleRecord.fontid _ fontid;
	answer _ firstStyle;
	UNTIL answer = NIL DO
		currentStyleRecord.next _ answer.next; -- so they'll be equal
		currentStyleRecord.name _ answer.name; -- so they'll be equal
		IF answer^ = currentStyleRecord THEN RETURN;
		 answer _ answer.next;
		ENDLOOP;
	-- note that at this point currentStyleRecord.next must be NIL
	styleCount _ styleCount + 1;
	answer _ GriffinMemoryDefs.Allocate [lStyle];
	answer^ _ currentStyleRecord;
	answer.name _ GriffinMemoryDefs.AllocateString [20];
	StringDefs.AppendString [answer.name, "Griffin Style "];
	StringDefs.AppendNumber [answer.name, styleCount, 10];
	IF firstStyle = NIL THEN
		firstStyle _ lastStyle _ answer ELSE lastStyle _ lastStyle.next_ answer;
	END;

SameStyle: PROCEDURE[s1, s2: StyleDefs.StyleHandle]
		RETURNS [same: BOOLEAN] =
BEGIN OPEN StyleDefs;
n1: StyleHandle = s1.next;
n2: StyleHandle = s2.next;
name1: STRING = s1.name;
name2: STRING = s2.name;
s1.next_NIL;
s2.next_NIL;
s1.name_NIL;
s2.name_NIL;
same _ s1^=s2^;
s1.next_n1;
s2.next_n2;
s1.name_name1;
s2.name_name2;
END;

SameFont: PROCEDURE[f1, f2: GriffinFontDefs.FontDescriptorHandle]
		RETURNS [BOOLEAN] =
BEGIN
IF StringDefs.EquivalentStrings[f1.name, f2.name]
   AND f1.rotation = f2.rotation
   AND f1.face = f2.face
   AND f1.points = f2.points
	THEN RETURN[TRUE]
	ELSE RETURN[FALSE];
END;

DefaultControllers: PUBLIC PROCEDURE = BEGIN OPEN StyleDefs;
n: FontHandle;
s: StyleHandle;
c: ControlPairHandle;
defaultfontname: STRING;
rOne: REAL _ 1;

-- this section resets the font data
UNTIL firstFont = NIL DO
	GriffinMemoryDefs.FreeString [firstFont.font.name];
	n _ firstFont.next;
	GriffinMemoryDefs.Free [firstFont];
	firstFont _ n;
	ENDLOOP;

lastFont _ NIL;
defaultfontname _ GriffinMemoryDefs.AllocateString [20];
StringDefs.AppendString [defaultfontname, "Helvetica"];
currentFont _ [name: defaultfontname, points: 10, rotation: 0, face: 0];

-- this section resets the style data
UNTIL firstStyle = NIL DO
	s _ firstStyle.next;
	GriffinMemoryDefs.Free [firstStyle];
	firstStyle _ s;
	ENDLOOP;

lastStyle _ NIL;

currentStyleRecord.next _ NIL;
currentStyleRecord.color _  [0,0,0];
currentStyleRecord.dashed _ undashed;
currentStyleRecord.firstend _ LineEnd [round, 0, 0, 0, 0, 0];
currentStyleRecord.lastend _ LineEnd [round, 0, 0, 0, 0, 0];
currentStyleRecord.width _ 64;
currentStyleRecord.junctiontype _ round;
currentStyleRecord.fillcolor _ [0,0,0];
currentStyleRecord.filled _ FALSE;
currentStyleRecord.outlined _ TRUE;
currentStyleRecord.fontid _ 0;
currentStyleRecord.backgndcolor _ Color [0,0,0];
currentStyleRecord.fillbackgnd _ FALSE;
currentStyleRecord.anchor _ left;
currentStyleRecord.orientation _ or0;

--set up the conversion from alto pixels to micas (press)

PixelsToMicas _ 32;
--this section resets the hardcopy controller data
hController _ [hxcenter: 304*PixelsToMicas, hycenter: 404*PixelsToMicas, hwidth: 608*PixelsToMicas, hheight: 808*PixelsToMicas,
	pressxcenter: Real.RoundC[304*PixelsToMicas], pressycenter: Real.RoundC[404*PixelsToMicas], hscale: 1];


--this section resets the display controller data
dController _ [dxcenter: 304, dycenter: 404, dwidth: 608, dheight: 808, dxscale: rOne/PixelsToMicas,
	dyscale: rOne/PixelsToMicas, dxorigin: 0, dyorigin: 0, dgridsize: 8];
UNTIL firstControlPair = NIL DO
	c _ firstControlPair.next;
	GriffinMemoryDefs.Free [firstControlPair];
	firstControlPair _ c;
	ENDLOOP;

lastControlPair _ NIL;
END;

CurrentStyleRecord: PUBLIC PROCEDURE RETURNS [StyleDefs.StyleHandle] = BEGIN
RETURN [@currentStyleRecord] END;


ControllerError: PUBLIC SIGNAL = CODE;

-- this code is executed implicitly before anything happens:

greyTable [-1] _ grey50;
greyTable [0] _ [0B, 0B, 0B, 0B];
greyTable [1] _ [0B, 40100B, 0B, 2004B];
greyTable [2] _ [2004B, 40100B, 40100B, 2004B];
greyTable [3] _ [3006B, 40100B, 60140B, 2004B];
greyTable [4] _ [3006B, 60140B, 60140B, 3006B];
greyTable [5] _ [3407B, 60140B, 70160B, 3006B];
greyTable [6] _ [3407B, 160340B, 70160B, 7016B];
greyTable [7] _ [23447B, 160340B, 71162B, 7016B];
greyTable [8] _ [23447B, 162344B, 71162B, 47116B];
greyTable [9] _ [23447B, 172364B, 71162B, 47517B];
greyTable [10] _ [27475B, 172364B, 171362B, 47517B];
greyTable [11] _ [67557B, 172364B, 173366B, 47517B];
greyTable [12] _ [67557B, 173366B, 173366B, 67557B];
greyTable [13] _ [77577B, 173366B, 173767B, 67557B];
greyTable [14] _ [77577B, 177376B, 173767B, 167757B];
greyTable [15] _ [177777B, 177376B, 177777B, 167757B];
greyTable [16] _ [177777B, 177777B, 177777B, 177777B];
DefaultControllers [];


END.


(847)