DIRECTORY
AMTypes, Atom, RTMiniModel, BBApply, Rope, ViewerClasses, ViewerOps, ViewerTools, ViewRec, ViewRecInsides, VFonts, Buttons, Containers, Labels, Rules, Process, Convert, IO, Icons, Real, TIPUser;

ViewRecCreate: CEDAR PROGRAM
IMPORTS AMTypes, Atom, VO: ViewerOps, VF:VFonts, VT:ViewerTools, Containers, Buttons, Labels, Rope, Rules, IO, Icons, Real, ViewRec, ViewRecInsides
EXPORTS ViewRec, ViewRecInsides
SHARES Atom =

BEGIN OPEN ViewRecInsides;

AlreadyHandled: PUBLIC ERROR = CODE;

RecordViewer: TYPE = REF RecordViewerRep;
RecordViewerRep: PUBLIC TYPE = RECORD [data: Data];


nameStyles: PUBLIC NameStyles;

myIconFlavors: ARRAY BOOLEAN OF Icons.IconFlavor;

ecHandlerProp: PUBLIC ATOM _ Atom.Gensym[];
gtHandlerProp: PUBLIC ATOM _ Atom.Gensym[];
befores: PUBLIC ARRAY Reductions OF RList _ ALL[NIL];
afterAlls: PUBLIC RList _ NIL;
classRecers: PUBLIC ARRAY AMTypes.Class OF RList _ ALL[NIL];

evClass: ViewerClasses.ViewerClass;

RegisterRecognizerByType: PUBLIC PROC [r: Recognizer, end: AddPlace, type: Type--unreduced--, reductions: Reductions] =
BEGIN
IF reductions # EquivalenceClass THEN type _ AMTypes.GroundStar[type];
IF reductions = TypeClass THEN
BEGIN
tc: AMTypes.Class _ AMTypes.TypeClass[type];
classRecers[tc] _ AddToList[classRecers[tc], r, end];
END
ELSE BEGIN
hp: ATOM _ IF reductions = StripSubranges THEN gtHandlerProp ELSE ecHandlerProp;
rl: RList _ NARROW[Atom.TypeGetProp[type: type, prop: hp]];
rl _ AddToList[rl, r, end];
Atom.TypePutProp[type: type, prop: hp, val: rl];
END;
END;

RegisterRecognizerBeforeReductions: PUBLIC PROC [r: Recognizer, end: AddPlace, applyBefore: Reductions] =
BEGIN
befores[applyBefore] _ AddToList[befores[applyBefore], r, end];
END;

RegisterRecognizerToApplyAfterAll: PUBLIC PROC [r: Recognizer, end: AddPlace] =
BEGIN
afterAlls _ AddToList[afterAlls, r, end];
END;

AddToList: PROC [rl: RList, r: Recognizer, end: AddPlace] RETURNS [new: RList] =
BEGIN
IF end = Front THEN RETURN [CONS[r, rl]];
IF rl = NIL THEN RETURN [LIST[r]];
new _ rl;
WHILE rl.rest # NIL DO rl _ rl.rest ENDLOOP;
rl.rest _ LIST[r];
END;

DoBindings: PROC [obj: TypedVariable, type: Type, bl: BindingList] =
BEGIN
SELECT AMTypes.TypeClass[type] FROM
record, structure => NULL;
ENDCASE => ERROR;
FOR i: CARDINAL IN [1..AMTypes.NComponents[type]] DO
var: TypedVariable _ AMTypes.IndexToTV[obj, i];
vt: Type _ AMTypes.IndexToType[type, i];
ut: Type _ AMTypes.GroundStar[vt];
name: ROPE _ AMTypes.IndexToName[type, i];
val: TypedVariable;
sublist: BindingList;
inList: BOOLEAN;
[sublist, , val, inList, , , ,] _ SelectBindings[bl, name, i];
IF inList THEN
BEGIN
c: TypedVariable;
c _ AMTypes.Coerce[val, vt];
AMTypes.Assign[var, val];
END
ELSE IF sublist # NIL THEN SELECT AMTypes.TypeClass[ut] FROM
record, structure => DoBindings[var, ut, sublist];
ENDCASE => ERROR;
ENDLOOP;
END;

RightFont: PROC [f: VF.Font] RETURNS [rf: VF.Font] =
{RETURN [IF f = NIL THEN VF.defaultFont ELSE f]};

FillInDefaultFields: PROC [tv: TypedVariable, type: Type] =
BEGIN
n: CARDINAL _ AMTypes.NComponents[type];
FOR i: CARDINAL IN [1..n] DO
div: TypedVariable _ NIL;
div _ AMTypes.IndexToDefaultInitialValue[type, i !AMTypes.Error => {div _ NIL; CONTINUE}];
IF div # NIL THEN
BEGIN
field: TypedVariable _ AMTypes.IndexToTV[tv, i];
AMTypes.Assign[lhs: field, rhs: div];
END;
ENDLOOP;
END;

ViewTV: PUBLIC PROC [rec: TypedVariable,
specs: ViewRec.BindingList _ NIL,
label: Rope.ROPE _ NIL,
otherStuff: OtherStuffProc _ NIL,
toDo: DoitProc _ NIL,
toDoData: REF ANY _ NIL,
parent: RecordViewer _ NIL,
sample: BOOLEAN _ TRUE,
holdOff: BOOLEAN _ FALSE,
highlightSelectedProc: BOOLEAN _ TRUE,
createOptions: CreateOptions _ [],
viewerInit: ViewerClasses.ViewerRec _ [],
paint: BOOLEAN _ TRUE]
RETURNS [rv: RecordViewer] =
BEGIN

NewProcedure: PROC [pt: Type, p: TypedVariable, name: ROPE, hasDom, hasRange: BOOLEAN, argSpecs, retSpecs: BindingList] RETURNS [Viewer] =
BEGIN
pd: ProcData _ NEW [EltDataRec[Proc]];
pco: CreateOptions _ createOptions;
by, rx: INTEGER _ 0;
dt: Type _ AMTypes.Domain[pt];
rt: Type _ AMTypes.Range[pt];
doitButton: Buttons.Button;
pco.feedBackHeight _ 0;
pd.name _ name;
pd.domainInst _ AMTypes.New[dt];
IF hasDom THEN FillInDefaultFields[pd.domainInst, dt];
pd.proc _ p;
pd.parent _ d;
pd.prev _ d.last;
d.last _ pd;
pd.variable _ FALSE;
pd.update _ ProcUpdate;
pd.hasDom _ hasDom;
pd.hasRet _ hasRange;
pd.argret _ Containers.Create[paint: FALSE,
info: [parent: d.argContainer, ww: targetWidth, wh: 10, border: FALSE,
scrollable: FALSE]];
IF NOT holdOff THEN
BEGIN
doitButton _ Buttons.Create[paint: FALSE,
font: RightFont[createOptions.doitFont],
proc: InnerProcButtonProc, clientData: pd,
info: [parent: pd.argret, border: createOptions.bordDoit,
name: Rope.Cat["Do ", name]] ];
pd.stateLabel _ Labels.Create[paint: FALSE,
font: RightFont[createOptions.stateFont],
info: [parent: pd.argret, border: createOptions.bordState,
wx: doitButton.wx + doitButton.ww + createOptions.hSep,
name: "working on old"]];
Labels.Set[label: pd.stateLabel, value: "", paint: FALSE];
by _ MAX[doitButton.wy + doitButton.wh, pd.stateLabel.wy + pd.stateLabel.wh] + createOptions.vSep;
rx _ MAX[rx, pd.stateLabel.wx + pd.stateLabel.ww];
END;
IF hasDom THEN 
BEGIN
pd.argRV _ ViewTV[rec: pd.domainInst,
specs: argSpecs,
toDo: ProcDoit,
parent: rv, sample: FALSE,
createOptions: pco,
viewerInit: [parent: pd.argret,
wy: by,
ww: pd.argret.cw,
border: FALSE,
scrollable: FALSE],
paint: FALSE].data;
pd.argRV.edParent _ pd;
rx _ MAX[rx, pd.argRV.v.ww];
by _ pd.argRV.v.wy + pd.argRV.v.wh;
END
ELSE BEGIN
IF AMTypes.TypeClass[dt] # nil THEN
DoBindings[pd.domainInst, dt, argSpecs];
END;
pd.retInst _ AMTypes.New[rt];
IF pd.hasRet THEN
BEGIN
IF hasDom THEN BEGIN
[] _ Rules.Create[paint: FALSE,
info: [parent: pd.argret, wx: 0, wy: by+createOptions.vSep,
ww: 1023, wh: 1, border: FALSE]];
by _ by + 1 + 2*createOptions.vSep;
END;
pd.retRV _ ViewTV[rec: pd.retInst,
specs: retSpecs,
parent: rv, sample: FALSE,
createOptions: pco,
viewerInit: [parent: pd.argret,
ww: pd.argret.cw,
wy: by,
border: FALSE,
scrollable: FALSE],
paint: FALSE].data;
pd.retRV.edParent _ pd;
rx _ MAX[rx, pd.retRV.v.ww];
by _ pd.retRV.v.wy + pd.retRV.v.wh;
END;
IF pd.hasRet OR hasDom THEN BEGIN
VO.MoveViewer[viewer: pd.argret, paint: FALSE,
x: nowhere, y: 0,
w: pd.argret.ww,
h: by + pd.argret.wh - pd.argret.ch];
argH _ MAX[argH, pd.argret.wh];
rightX _ MAX[rightX, rx + pd.argret.ww - pd.argret.cw];
argumentive _ TRUE;
END
ELSE BEGIN
VO.DestroyViewer[viewer: pd.argret, paint: FALSE];
pd.argret _ NIL;
END;
pd.b _ Buttons.Create[paint: FALSE,
font: RightFont[createOptions.procFont],
proc: ProcButtonProc, clientData: pd,
info: [parent: d.v, name: name, border: createOptions.bordProcs]];
RETURN [pd.b];
END;

NewSimple: PROC [tt, wt: Type, sv: TypedVariable, handler: SimpleHandler, name: ROPE, editable: BOOLEAN, notifies: NotifyList, handlerData: REF ANY] RETURNS [v: Viewer] =
BEGIN
mx, askW: INTEGER;
askLines: REAL;
sd: SimpleData _ NEW [EltDataRec[Simple]];
ut: Type _ AMTypes.UnderType[tt];
tc: AMTypes.Class _ AMTypes.TypeClass[tt];
v _ VO.CreateViewer[flavor: $EltViewer, paint: FALSE,
info: [parent: d.v, name: name, data: sd, ww: 10, wh: 10, border: createOptions.bordElts]];
sd.name _ name;
sd.var _ sv;
sd.old _ AMTypes.New[tt];
AMTypes.Assign[sd.old, sd.var];
sd.handler _ handler;
sd.handlerData _ handlerData;
sd.wideAsTV _ AMTypes.New[wt];
sd.targType _ tt;
sd.variable _ editable AND AMTypes.TVStatus[sv] = mutable AND handler.Parse # NIL;
sd.notifyRequests _ notifies;
sd.ToRope _ SimpleToRope;
sd.AssignRope _ SimpleAssignRope;
IF tc # definition THEN sd.typeDoc _ IO.PutFR["%g", IO.type[tt]]
ELSE sd.typeDoc _ IO.PutFR["%g=%g", IO.type[tt], IO.type[ut]];
sd.parent _ d;
sd.prev _ d.last;
d.last _ sd;
sd.update _ UpdateNV;
sd.b _ Buttons.Create[paint: FALSE,
proc: NVButtonProc,
clientData: sd,
info: [parent: v, name: name.Concat[":"], border: FALSE,
wy: createOptions.vStilts],
font: RightFont[createOptions.nameFont]];
mx _ sd.b.wx + sd.b.ww + createOptions.nvSep;
[askW, askLines] _ handler.Max[sv, tt, handlerData];
sd.t _ VO.CreateViewer[flavor: $Text, paint: FALSE,
info: [parent: v, border: FALSE, scrollable: askLines > 1,
wx: sd.b.wx+sd.b.ww + createOptions.nvSep,
ww: MIN[askW + createOptions.hPad, targetWidth - mx],
wh: Real.RoundI[askLines*VF.FontHeight[]+createOptions.vPad] ]];
VO.AddProp[viewer: sd.t, prop: $EltData, val: sd];
VT.InhibitUserEdits[sd.t];
VO.MoveViewer[viewer: v, x: v.wx, y: v.wy, w: sd.t.wx+sd.t.ww, h: MAX[sd.b.wh+createOptions.vStilts, sd.t.wh], paint: FALSE];
VO.MoveViewer[viewer: sd.b, x: sd.b.wx, y: MAX[(v.wh - sd.b.wh)/2, createOptions.vStilts], w: sd.b.ww, h: sd.b.wh, paint: FALSE];
SetRope[sd, SimpleToRope[sd], FALSE];
ShowState[sd, FALSE];
END;

NewRecord: PROC [tt, rt: Type, r: TypedVariable, name: ROPE, bindings: BindingList, editable: BOOLEAN] RETURNS [v: Viewer] =
BEGIN
rd: RecordData _ NEW [EltDataRec[Record]];
tc: AMTypes.Class _ AMTypes.TypeClass[tt];
rco: CreateOptions _ createOptions;
mx: INTEGER;
v _ VO.CreateViewer[flavor: $EltViewer, paint: FALSE,
info: [parent: d.v, name: name, data: rd, ww: 10, wh: 10, border: createOptions.bordElts]];
rd.name _ name;
rd.update _ UpdateRecord;
rd.var _ r;
rd.old _ AMTypes.New[tt];
rd.variable _ editable AND AMTypes.TVStatus[r] = mutable;
rd.typeDoc _ IF tc # definition THEN IO.PutFR["%g", IO.type[tt]]
ELSE IO.PutFR["%g=%g", IO.type[tt], IO.type[rt]];
AMTypes.Assign[rd.old, rd.var];
rd.parent _ d;
rd.prev _ d.last;
d.last _ rd;
rd.b _ Buttons.Create[paint: FALSE,
proc: NVButtonProc,
clientData: rd,
info: [parent: v, name: name.Concat[":"], border: FALSE],
font: RightFont[createOptions.nameFont]];
rco.feedBackHeight _ 0;
mx _ rd.b.wx + rd.b.ww + createOptions.nvSep;
rd.d _ ViewTV[rec: r,
specs: bindings,
toDo: toDo,
parent: rv, sample: FALSE,
createOptions: rco,
viewerInit: [parent: v, border: createOptions.bordRecs,
wx: mx, wh: 10,
ww: MAX[targetWidth - mx, createOptions.minRecordWidth],
scrollable: FALSE],
paint: FALSE].data;
rd.d.edParent _ rd;
VO.MoveViewer[viewer: v, x: v.wx, y: v.wy, w: rd.d.v.wx+rd.d.v.ww,
h: MAX[rd.b.wh, rd.d.v.wh], paint: FALSE];
VO.MoveViewer[viewer: rd.b, x: rd.b.wx,
y: (v.ch - rd.b.wh)/2, w: rd.b.ww, h: rd.b.wh, paint: FALSE];
END;

NewComplex: PROC [tt, ut: Type, cv: TypedVariable, handler: ComplexHandler, name: ROPE, editable: BOOLEAN, notifies: NotifyList, handlerData: REF ANY] RETURNS [v: Viewer] =
BEGIN
cd: ComplexData _ NEW [EltDataRec[Complex]];
tc: AMTypes.Class _ AMTypes.TypeClass[tt];
cco: CreateOptions _ createOptions;
cco.feedBackHeight _ 0;
cd.name _ name;
cd.updater _ handler.updater;
cd.handlerData _ handlerData;
[v, cd.clientData] _ handler.producer[cv, [main: d.v, for: rv, name: name, createOptions: cco, notifies: notifies], handlerData];
cd.update _ UpdateComplex;
cd.var _ cv;
cd.old _ AMTypes.New[tt];
AMTypes.Assign[cd.old, cd.var];
cd.notifyRequests _ notifies;
cd.variable _ editable AND AMTypes.TVStatus[cv] = mutable;
cd.typeDoc _ IF tc # definition THEN IO.PutFR["%g", IO.type[tt]]
ELSE IO.PutFR["%g=%g", IO.type[tt], IO.type[ut]];
cd.parent _ d;
cd.prev _ d.last;
d.last _ cd;
END;

Place: PROC [v: Viewer] =
BEGIN
dx: INTEGER _ IF bottomRightX # 0 THEN createOptions.hSep ELSE 0;
IF forceNewRow OR (v.ww + dx + bottomRightX > targetWidth) THEN
BEGIN
rightX _ MAX[rightX, bottomRightX];
bottomY _ bottomY + rowH +
(IF rightX > 0 THEN createOptions.vSep ELSE 0);
rowH _ dx _ bottomRightX _ 0;
END;
VO.MoveViewer[viewer: v,
x: bottomRightX + dx, y: bottomY, w: v.ww, h: v.wh, paint: FALSE];
bottomRightX _ v.wx+v.ww;
rowH _ MAX[rowH, v.wh];
forceNewRow _ FALSE;
END;

recsType: Type _ AMTypes.UnderType[AMTypes.TVType[rec]];
len: CARDINAL;
bottomY, bottomRightX, rightX, rowH, argH: INTEGER _ 0;
forceNewRow: BOOLEAN _ FALSE;
argumentive: BOOLEAN _ FALSE;
targetWidth: INTEGER;
d: Data _ NEW [DataRec];
vParent: Viewer _ viewerInit.parent;
rv _ NEW [RecordViewerRep _ [d]];
d.asRV _ rv;
d.toDo _ toDo;
d.toDoData _ toDoData;
d.holdOff _ holdOff;
d.highlightSelectedProc _ highlightSelectedProc;
SELECT AMTypes.TypeClass[recsType] FROM
record, structure => NULL;
ENDCASE => ERROR ViewRec.NotARecord;
targetWidth _ viewerInit.ww;
IF vParent = NIL THEN viewerInit.ww _ 0;
IF viewerInit.icon = unInit THEN
viewerInit.icon _ myIconFlavors[VF.StringWidth[viewerInit.name] > 75];
d.v _ Containers.Create[paint: FALSE, info: viewerInit];
VO.AddProp[d.v, $RecordViewerData, rv];
targetWidth _ 
IF targetWidth # 0 THEN
(IF vParent = NIL THEN targetWidth ELSE d.v.cw)
ELSE IF vParent = NIL AND NOT viewerInit.iconic THEN d.v.cw
ELSE createOptions.defaultTargetWidth;
d.argContainer _ Containers.Create[paint: FALSE,
info: [parent: d.v, wx: 0, wy: 0, ww: 10, wh: 10,
border: FALSE, scrollable: FALSE]];
IF label.Length[] > 0 THEN
BEGIN
fnr: BOOLEAN _ FALSE;
IF label.Fetch[label.Length[] - 1] = '\n THEN
BEGIN
label _ label.Substr[len: label.Length[] - 1];
fnr _ TRUE;
END;
Place[Labels.Create[paint: FALSE,
info: [name: label, parent: d.v, border: FALSE],
font: RightFont[createOptions.labelFont] ]];
forceNewRow _ fnr;
END;
IF otherStuff # NIL THEN
BEGIN
stuff: LIST OF Viewer _ otherStuff[d.v];
WHILE stuff # NIL DO Place[stuff.first]; stuff _ stuff.rest ENDLOOP;
END;
len _ AMTypes.NComponents[recsType];
FOR i: CARDINAL IN [1..len] DO
v: TypedVariable _ AMTypes.IndexToTV[rec, i];
iType: Type _ AMTypes.TVType[v];
cType: Type _ AMTypes.GroundStar[iType];
cClass: AMTypes.Class _ AMTypes.TypeClass[cType];
name: ROPE _ AMTypes.IndexToName[recsType, i];
val: TypedVariable;
sublist, altSublist: BindingList;
inList, visible, editable: BOOLEAN;
notifies: NotifyList;
recers: RList;
IF v = NIL THEN LOOP;
IF name.Length[] = 0 THEN name _ "anonymous";
[sublist, altSublist, val, inList, visible, editable, notifies, recers] _ SelectBindings[specs, name, i];
IF inList THEN
BEGIN
c: TypedVariable;
c _ AMTypes.Coerce[val, iType];
AMTypes.Assign[v, c];
END;
IF NOT (inList AND NOT visible) THEN
BEGIN
recognized: BOOLEAN;
handler, handlerData: REF ANY;
[recognized, handler, handlerData] _ Recognize[t: iType, specials: recers, onlyRecognize: FALSE];
IF recognized
THEN WITH handler SELECT FROM
sh: SimpleHandler => BEGIN
Place[NewSimple[iType, cType, v, sh, name, editable, notifies, handlerData]];
END;
ch: ComplexHandler => BEGIN
Place[NewComplex[iType, AMTypes.UnderType[iType], v, ch, name, editable, notifies, handlerData]];
END;
ENDCASE => ERROR
ELSE SELECT cClass FROM
record, structure => BEGIN
ok: BOOLEAN;
presentable: CARDINAL;
[ok, presentable] _ SimpleEnough[cType, sublist, createOptions.doAllRecords];
IF ok AND presentable > 0 THEN Place[NewRecord[iType, cType, v, name, sublist, editable]];
END;
procedure => BEGIN
ok, hasDom, hasRange: BOOLEAN;
[ok, hasDom, hasRange] _ OKProc[cType, sublist, altSublist, createOptions.doAllRecords];
IF ok THEN Place[NewProcedure[cType, v, name, hasDom, hasRange, sublist, altSublist]];
END;
ENDCASE;
END;
ENDLOOP;
FOR e: EltData _ d.last, e.prev WHILE e # NIL DO
IF e.prev # NIL THEN e.prev.next _ e ELSE d.first _ e;
ENDLOOP;
bottomY _ bottomY + rowH;
IF argumentive THEN
BEGIN
[] _ Rules.Create[paint: FALSE,
info: [parent: d.v, wx: 0, wy: bottomY+createOptions.vSep,
ww: 1023, wh: 1, border: FALSE]];
d.argPlace _ bottomY + 1+2*createOptions.vSep;
VO.MoveViewer[viewer: d.argContainer, paint: FALSE,
x: 0, y: d.argPlace,
w: rightX + d.argContainer.ww - d.argContainer.cw,
h: argH + d.argContainer.wh - d.argContainer.ch];
bottomY _ d.argContainer.wy + d.argContainer.wh;
END
ELSE BEGIN
VO.DestroyViewer[viewer: d.argContainer, paint: FALSE];
d.argContainer _ NIL;
END;
IF createOptions.feedBackHeight > 0 THEN
BEGIN
fPlace: INTEGER _ bottomY + 1+2*createOptions.vSep;
[] _ Rules.Create[paint: FALSE,
info: [parent: d.v, wx: 0, wy: bottomY+createOptions.vSep,
wh: 1, ww: 1023, border: FALSE]];
d.feedBack _ VT.MakeNewTextViewer[paint: FALSE, info: [
parent: d.v, name: "FeedBack", border: FALSE,
wx: 0, wy: fPlace, ww: targetWidth, wh: createOptions.feedBackHeight]];
VT.InhibitUserEdits[d.feedBack];
bottomY _ fPlace + createOptions.feedBackHeight;
Containers.ChildYBound[d.v, d.feedBack];
Containers.ChildXBound[d.v, d.feedBack];
END
ELSE d.feedBack _ NIL;
d.rvParent _ IF parent # NIL THEN parent.data ELSE NIL;
IF vParent = NIL THEN
BEGIN
IF bottomY < 700 --don't confuse Viewers!-- THEN VO.SetOpenHeight[d.v, bottomY];
IF NOT paint THEN NULL
ELSE IF d.v.iconic THEN VO.PaintViewer[viewer: d.v, hint: all]
ELSE VO.ComputeColumn[d.v.column];
END
ELSE BEGIN
VO.MoveViewer[viewer: d.v, x: d.v.wx, y: d.v.wy,
w: (d.v.ww-d.v.cw)+MAX[rightX, bottomRightX],
h: (d.v.wh - d.v.ch) + bottomY,
paint: paint];
END;
IF sample THEN roots _ CONS[d, roots];
END;

RVQuaViewer: PUBLIC PROC [rv: RecordViewer] RETURNS [Viewer] =
{RETURN [rv.data.v]};

ViewerIsRV: PUBLIC PROC [v: Viewer] RETURNS [BOOLEAN] =
{RETURN [VO.FetchProp[v, $RecordViewerData] # NIL]};

ViewerQuaRV: PUBLIC PROC [v: Viewer] RETURNS [RecordViewer] =
{RETURN [NARROW[VO.FetchProp[v, $RecordViewerData]]]};

RVToData: PUBLIC PROC [rv: RecordViewer] RETURNS [Data] =
{RETURN [rv.data]};

Setup: PROC =
BEGIN
myIconFlavors[FALSE] _ Icons.NewIconFromFile["ViewRec.Icons", 0];
myIconFlavors[TRUE] _ Icons.NewIconFromFile["ViewRec.Icons", 1];
evClass _ NEW [ViewerClasses.ViewerClassRec _ [
flavor: $EltViewer,
destroy: DestroyEltViewer]];
VO.RegisterViewerClass[$EltViewer, evClass];
nameStyles _ [quiescent: $BlackOnWhite,
opened: $WhiteOnBlack, running: $WhiteOnBlack,
invariant: $BlackOnGrey, beingShown: $BlackOnGrey];
END;

Setup[];

END.

|FILE: ViewRecCreate
last edited by Spreitzer May 2, 1983 10:57 pm
Last Edited by: Maxwell, November 16, 1982 3:29 pm
Κ˜J˜Jš
œ™Jš
œ-™-Jš
œ2™2J˜
codeš
Οk	˜	Kšœ©
œ˜Β
K˜—šΠbx
œœ
˜Kš
œœ
œ	œ8œ&˜“
Kšœ˜Kšœ˜
K˜—Kšœ
œ˜K˜KšΟbœœ
œœ
˜$K˜Kšœœœ˜)Kšœœ
œœ˜3K˜K˜Kšœœ˜K˜Kšœœ
œ
œ˜1K˜Kšœœ
œ˜+Kšœœ
œ˜+Kšœ	œ
œœ	œ
œ˜5Kšœœ	œ
˜Kšœ
œ
œœ	œ
œ˜<K˜K˜#K˜šΟnœœ
œ*Οc
œ˜wKš
˜Kšœœ!˜Fšœ˜Kš
˜K˜,Kš
œ5˜5Kš
˜—šœ
˜
Kš	œœœœœ˜PKšœœ)˜;K˜Kš
œ0˜0Kšœ
˜—Kšœ
˜—K˜š "œœ
œ:˜iKš
˜Kš
œ?˜?Kšœ
˜—K˜š !œœ
œ!˜OKš
˜Kš
œ)˜)Kšœ
˜—K˜š 	œœ+œ˜PKš
˜Kšœ
œ
œœ	˜)Kš
œœ
œ
œœ˜"K˜	Kšœœ
œœ
˜,Kšœ
œ˜Kšœ
˜—K˜š 
œœ4˜DKš
˜šœ˜#Kšœœ
˜Kšœœ
˜—šœœ
œ ˜4K˜/K˜(K˜"Kšœœ ˜*K˜K˜Kšœœ
˜K˜>šœ˜Kš
˜K˜K˜K˜Kš
˜—šœ
œœ
œ
œ˜<K˜2Kšœœ
˜—Kšœ
˜—Kšœ
˜—K˜š
 	œœœœœ˜4Kš
œ
œœœ
œ
œ
œ˜1K˜—š œœ"˜;Kš
˜Kšœœ˜(šœœ
œ˜Kšœœ
˜KšœJœœ˜Zšœœ
˜Kš
˜K˜0Kš
œ%˜%Kšœ
˜—Kšœ
˜—Kšœ
˜—K˜š œœ
œ˜(Kšœœ
˜!Kšœœœ
˜Kšœœ
˜!Kšœœ
˜Kšœ
œ
œœ
˜Kšœœ
˜Kšœœœ
˜Kšœ	œœ
˜Kšœœœ
˜&K˜"K˜)Kšœœœ
˜Kšœ˜Kš
˜K˜š
 œœ$œœ#œ˜Š
Kš
˜Kšœœ˜&K˜#Kšœœ˜K˜K˜K˜K˜K˜K˜ Kšœœ(˜6K˜K˜K˜K˜Kšœœ
˜K˜K˜K˜šœ%œ
˜+šœ@œ
˜FKšœœ˜——šœ
œ	˜Kš
˜šœ#œ
˜)K˜(Kš
œ*˜*š
œ9˜9K˜——šœ%œ
˜+K˜)š
œ:˜:K˜7K˜——Kšœ3œ˜:KšœœZ˜bKšœœ*˜2Kšœ
˜—šœœ
˜Kš
˜˜%K˜K˜Kšœœ
˜K˜˜K˜K˜Kšœ˜Kšœœ˜—Kšœœ˜—K˜Kšœœ˜K˜#Kš
˜—šœ
˜
šœ˜#K˜(—Kšœ
˜—K˜šœ˜Kš
˜šœœ
˜šœœ
˜˜;Kšœœ˜!——K˜#Kšœ
˜—˜"K˜Kšœœ
˜K˜˜K˜K˜Kšœ˜Kšœœ˜—Kšœœ˜—K˜Kšœœ˜K˜#Kšœ
˜—šœœœ
˜!šœ&œ
˜.K˜K˜K˜%—Kšœœ˜Kšœ	œ+˜7Kšœœ
˜Kš
˜—šœ
˜
Kšœ)œ˜2Kšœœ
˜Kšœ
˜—šœœ
˜#K˜(K˜%K˜B—Kšœ˜Kšœ
˜K˜—š 	œœAœœ%œ
œœ˜ͺ
Kš
˜Kšœ
œ
˜Kšœ
œ
˜Kšœœ˜*K˜!K˜*šœœ)œ
˜5K˜[—K˜K˜K˜K˜K˜K˜K˜K˜Kšœœ œœ
˜RK˜K˜K˜!Kšœœœ
œ
˜@Kšœœœœ˜>K˜K˜K˜K˜šœœ
˜#K˜K˜šœ2œ
˜8K˜—K˜)—K˜-Kš
œ4˜4šœœ$œ
˜3šœœ˜:K˜*Kšœœ.˜5Kšœœ%˜@——Kšœ0˜2Kšœ˜Kšœ@œ1œ˜}Kšœ)œLœ˜
Kšœœ˜%Kšœœ˜Kšœ
˜—K˜š
 	œœ(œ#œœ˜|Kš
˜Kšœœ˜*K˜*K˜#Kšœœ
˜šœœ)œ
˜5K˜[—K˜K˜K˜K˜Kšœœ˜9š	œ
œœ
œ
œ
˜@Kšœ
œœœ˜1—K˜K˜K˜K˜šœœ
˜#K˜K˜Kšœ2œ˜9K˜)—K˜K˜-˜K˜K˜Kšœœ
˜K˜˜7K˜Kšœœ1˜8Kšœœ˜—Kšœœ˜—K˜šœ@˜BKšœœœ˜*—šœ%˜'Kšœ6œ˜=—Kšœ
˜—K˜š 
œœBœœ%œ
œœ˜¬
Kš
˜K˜,K˜*K˜#K˜K˜K˜K˜Kš
œ
˜
K˜K˜K˜K˜K˜Kšœœ ˜:š	œ
œœ
œ
œ
˜@Kšœ
œœœ˜1—K˜K˜K˜Kšœ
˜—K˜š œœ˜Kš
˜Kš	œœœœœ˜Ašœ
œ*˜?Kš
˜Kšœ	œ˜#˜Kšœ
œœœ˜/—K˜Kšœ
˜—šœ˜Kšœ;œ˜B—K˜Kšœœ
˜Kšœœ
˜Kšœ
˜K˜—K˜8Kšœœ
˜Kšœ+œ˜7Kšœ
œœ
˜Kšœ
œœ
˜Kšœ
œ
˜Kšœ
œ˜K˜$Kšœœ˜!K˜K˜K˜K˜K˜0šœ˜'Kšœœ
˜Kšœœ˜$—K˜Kšœœ
œ˜(šœ˜ Kšœ œ$˜F—Kšœœ˜8Kšœ%˜'š
œ˜šœ˜Kš	œ
œœ
œ
œ˜/—Kšœ
œœ
œ
œœ˜;Kšœ"˜&—šœ*œ
˜0š
œ1˜1Kšœœœ˜#——šœ˜Kš
˜Kšœœœ
˜šœ'˜-Kš
˜K˜.Kšœœ
˜Kšœ
˜—šœœ
˜!Kšœ)œ˜0K˜,—K˜Kšœ
˜—šœœ
˜Kš
˜Kšœœ
œ˜(Kšœ	œ
œ(œ
˜DKšœ
˜—K˜$šœœ
œ
˜K˜-K˜ K˜(K˜1Kšœœ$˜.K˜K˜!Kšœœ
˜#K˜K˜Kšœœ
œ
œ
˜Kšœœ˜-K˜išœ˜Kš
˜K˜K˜K˜Kšœ
˜—š	œ
œ	œ
œ
˜$Kš
˜Kšœœ
˜Kšœœ
œ
˜KšœZœ˜aKšœ˜
šœ
œ	œ
˜šœ˜K˜MKšœ
˜—šœ˜K˜aKšœ
˜—Kšœ˜—šœ
œ˜šœ˜Kšœœ
˜Kšœ
œ
˜K˜MKšœœœ<˜ZKšœ
˜—šœ
˜Kšœœ
˜K˜XKšœœL˜VKšœ
˜—Kšœ
˜—Kšœ
˜—Kšœ
˜—šœœœ
˜0Kšœ
œ
œœ
˜6Kšœ
˜—K˜šœ
˜Kš
˜šœœ
˜˜:Kšœœ˜!——K˜.šœ+œ
˜3K˜K˜2K˜1—K˜0Kš
˜—šœ
˜
Kšœ.œ˜7Kšœœ
˜Kšœ
˜—šœ"˜(Kš
˜Kšœœ$˜3šœœ
˜˜:Kšœœ˜!——šœ
œœ	˜7Kšœ'œ
˜-K˜G—Kšœ˜ K˜0K˜(K˜(Kš
˜—Kšœœ
˜Kšœ
œ
œ
œ
œ
œ
˜7šœœ
˜Kš
˜Kšœ‘œ
œ
œ˜PKšœ
œœ
˜Kšœ
œœ
œ$˜>Kšœ
œ˜"Kš
˜—šœ
˜
šœ.˜0Kšœœ˜-K˜K˜—Kšœ
˜—Kšœœ	œ˜&Kšœ
˜K˜—š œœ
œœ˜>Kšœ
œ˜K˜—š
 
œœ
œ
œœ˜7Kšœ
œœ#œ˜4K˜—š œœ
œ
œ˜=Kšœ
œœ
œ$˜6K˜—š œœ
œœ	˜9Kšœ
œ˜K˜—š œœ˜
Kš
˜Kšœœ.˜AKšœœ.˜@šœ
œ"˜/K˜K˜—Kšœ*˜,˜'K˜.K˜3—Kšœ
˜K˜—K˜K˜Kšœ
˜K˜—…—D,WΌ