RoseDisplayBrowsing.Mesa
Last Edited by: Spreitzer, October 7, 1984 4:29:22 pm PDT
Last Edited by: Barth, April 23, 1984 5:39:57 pm PST
Last Edited by: Gasbarro, August 16, 1984 4:15:14 pm PDT
DIRECTORY Asserting, Atom, Buttons, Graphs, GraphBrowsers, HierarchicalDisplays, IO, Menus, MessageWindow, OrderedSymbolTableRef, Rope, RoseConditions, RoseDisplayInsides, RoseEvents, RoseTypes, Trees, VFonts, ViewerClasses, ViewerOps, ViewerTools, ViewRec;
RoseDisplayBrowsing:
CEDAR
PROGRAM
IMPORTS Asserting, Atom, GraphBrowsers, HD: HierarchicalDisplays, OrderedSymbolTableRef, MessageWindow, Rope, RoseDisplayInsides, RoseEvents, RoseTypes, VF:VFonts, VO: ViewerOps, VR: ViewRec
EXPORTS RoseDisplayInsides =
BEGIN OPEN RoseDisplayInsides;
nodeDisplaysProp: PUBLIC ATOM ← Atom.MakeAtom["Spreitzer January 6, 1984 9:24 pm"];
cellStateDisplayProp: PUBLIC ATOM ← Atom.MakeAtom["January 6, 1984 9:24 pm Spreitzer"];
cellStateClass:
PUBLIC
HD.ChildClass ←
NEW [
HD.ChildClassRep ← [
buttonProc: CellStateButtonProc,
NotifyOnRemove: NoticeCellStateRemoval]];
roseType: Graphs.NodeType ←
NEW [Graphs.NodeTypeRep ← [
Expand: RoseExpand,
NameNeighbors: NIL,
GetNamedNeighbor: NIL,
GetIndexedNeighbor: NIL,
GetNeighborCount: RoseNeighborCount,
View: NIL]];
rosemaryBrowser: GraphBrowsers.BrowserClass ←
NEW [GraphBrowsers.BrowserClassRep ← [
cmds: [
GraphBrowsers.basicBrowserClass.cmds[red],
ALL[ALL[[BrowserClick]]],
ALL[ALL[[BrowserClick]]]] ]];
BrowseDisplay:
PROC [display: Display, info: ViewerClasses.ViewerRec ← [], paint:
BOOLEAN ←
TRUE]
RETURNS [v: ViewerClasses.Viewer] =
BEGIN
v ← GraphBrowsers.Browse[node: CellNode[display.rootCell, display], browserClass: rosemaryBrowser, browserData: display, viewerInit: info, paint: paint].BrowserQuaViewer[];
END;
CellNode:
PROC [cell: Cell, display: Display]
RETURNS [node: Graphs.Node] =
{node ← NEW [Graphs.NodeRep ← [type: roseType, rep: NEW [CellBrowserRep ← [cell, display]]]]};
StateNode:
PROC [cb: CellBrowser]
RETURNS [node: Graphs.Node] =
{node ← NEW [Graphs.NodeRep ← [type: roseType, rep: NEW [CellStateRep ← [cb]]]]};
InterfaceNode:
PROC [cb: CellBrowser]
RETURNS [node: Graphs.Node] =
{node ← NEW [Graphs.NodeRep ← [type: roseType, rep: NEW [InterfaceNodesRep ← [cb]]]]};
InternalNode:
PROC [cb: CellBrowser]
RETURNS [node: Graphs.Node] =
{node ← NEW [Graphs.NodeRep ← [type: roseType, rep: NEW [InternalNodesRep ← [cb]]]]};
ComponentsNode:
PROC [cb: CellBrowser]
RETURNS [node: Graphs.Node] =
{node ← NEW [Graphs.NodeRep ← [type: roseType, rep: NEW [ComponentsRep ← [cb]]]]};
NodeNode:
PROC [ne: NodeElt]
RETURNS [node: Graphs.Node] =
{node ← NEW [Graphs.NodeRep ← [type: roseType, rep: ne]]};
RoseNeighborCount: Graphs.NeighborCountProc
--PROC [node: Node] RETURNS [neighborCount: INT]-- =
BEGIN
WITH node.rep
SELECT
FROM
cb: CellBrowser => RETURN[4];
in: InterfaceNodes => RETURN[in.cb1.cell.type.ports.length];
in: InternalNodes => RETURN[in.cb2.cell.internalNodes.Size[]];
components: Components => RETURN[components.cb3.cell.components.Size[]];
cs: CellState => RETURN [0];
ne: NodeElt => RETURN [CountLinksFromNode[ne.node]];
ENDCASE => ERROR;
END;
RoseExpand: Graphs.ExpandProc
--PROC [node: Node, consume: LinkConsumer]-- =
BEGIN
WITH node.rep
SELECT
FROM
cb: CellBrowser => EnumerateCell[cb, consume];
in: InterfaceNodes => EnumerateInterfaceNodes[in, consume];
in: InternalNodes => EnumerateInternalNodes[in, consume];
components: Components => EnumerateComponents[components, consume];
cs: CellState => NULL;
ne: NodeElt => EnumerateFromNode[ne, consume];
ENDCASE => ERROR;
END;
CountLinksFromNode:
SAFE
PROC [node: Node]
RETURNS [count:
INT] =
BEGIN
Do:
PROC [sl: RoseTypes.SocketList] =
BEGIN
FOR sl ← sl, sl.rest
WHILE sl #
NIL
DO
count ← count + 1;
ENDLOOP;
END;
count ← 0;
Do[node.readers];
Do[node.writers];
Do[node.bidirs];
END;
EnumerateFromNode:
PROC [ne: NodeElt, to: Graphs.LinkConsumer] =
BEGIN
Do:
PROC [sl: RoseTypes.SocketList, how:
ROPE] =
BEGIN
FOR sl ← sl, sl.rest
WHILE sl #
NIL
DO
cc: Cell ← sl.first.cell;
cellName: ROPE ← NIL;
WHILE cc # ne.node.cellIn
DO
IF cellName # NIL THEN cellName ← Rope.Concat[".", cellName];
cellName ← cc.name.Concat[cellName];
cc ← cc.parent;
ENDLOOP;
to.proc[[
name: Rope.Cat[sl.first.cell.type.ports[sl.first.index].name, how, cellName],
otherSide: CellNode[cell: sl.first.cell, display: ne.org.display]], to.data];
ENDLOOP;
END;
Do[ne.node.readers, ">"];
Do[ne.node.writers, "<"];
Do[ne.node.bidirs, "="];
END;
EnumerateCell:
PROC [cb: CellBrowser, to: Graphs.LinkConsumer, interf, intern:
BOOLEAN ←
TRUE] =
BEGIN
canInterf: BOOLEAN ← cb.cell.interfaceNodes.length > 0;
canIntern: BOOLEAN ← cb.cell.internalNodes.Size[] > 0;
canBoth: BOOLEAN ← canInterf AND canIntern;
interf ← interf OR NOT canBoth;
intern ← intern OR NOT canBoth;
IF canInterf AND interf THEN to.proc[["Interface Nodes", InterfaceNode[cb]], to.data];
IF canIntern AND intern THEN to.proc[["Internal Nodes", InternalNode[cb]], to.data];
IF cb.cell.components.Size[] > 0 THEN to.proc[["Components", ComponentsNode[cb]], to.data];
IF (IF cb.cell.realCellStuff = NIL THEN FALSE ELSE IF cb.cell.realCellStuff.state = NIL THEN FALSE ELSE NOT ISTYPE[cb.cell.realCellStuff.state, RoseTypes.Structure]) THEN to.proc[["State", StateNode[cb]], to.data];
END;
EnumerateInterfaceNodes:
PROC [in: InterfaceNodes, to: Graphs.LinkConsumer] =
BEGIN
FOR ni:
CARDINAL
IN [0 .. in.cb1.cell.type.ports.length)
DO
port: RoseTypes.Port ← in.cb1.cell.type.ports[ni];
node: Node ← in.cb1.cell.interfaceNodes[ni];
ne: NodeElt ←
NEW [NodeEltRep ← [
name: port.name,
node: node,
org: [display: in.cb1.display, socket: [cell: in.cb1.cell, index: ni]],
parent: in.cb1,
format: node.type.procs.GetFormat[node.type, ""],
interfaceIndex: ni,
interfaceNode: TRUE
]];
IF ne.format = NIL THEN ERROR --type should supply default keyed by empty string--;
to.proc[[PortLinkName[port.name, node.name], NodeNode[ne]], to.data];
ENDLOOP;
END;
PortLinkName:
PROC [portName, nodeName:
ROPE]
RETURNS [linkName:
ROPE] =
BEGIN
linkName ← IF portName.Equal[nodeName] THEN portName ELSE portName.Cat[": ", nodeName];
END;
EnumerateInternalNodes:
PROC [in: InternalNodes, to: Graphs.LinkConsumer] =
BEGIN
FOR node: Node ← in.cb2.cell.firstInternalNode, node.next
WHILE node #
NIL
DO
ne: NodeElt ←
NEW [NodeEltRep ← [
node: node,
name: node.name,
org: [display: in.cb2.display, socket: [cell: in.cb2.cell, index: notFound]],
parent: in.cb2,
format: node.type.procs.GetFormat[node.type, ""],
interfaceIndex: notLookedFor]];
IF ne.format = NIL THEN ERROR;
to.proc[[node.name, NodeNode[ne]], to.data];
ENDLOOP;
END;
notFound: CARDINAL = RoseTypes.notFound;
notLookedFor: CARDINAL = notFound - 1;
EnumerateComponents:
PROC [components: Components, to: Graphs.LinkConsumer] =
BEGIN
FOR cell: Cell ← components.cb3.cell.leftChild, cell.rightSibling
WHILE cell #
NIL
DO
to.proc[[cell.name, CellNode[cell: cell, display: components.cb3.display]], to.data];
ENDLOOP;
END;
NDLSearch:
PUBLIC
PROC [ndl: NodeDisplayList, org: NodeOrigin, remove:
BOOLEAN]
RETURNS [newdl: NodeDisplayList, nd: NodeDisplay, found:
BOOLEAN] =
BEGIN
prev: NodeDisplayList ← NIL;
newdl ← ndl; found ← FALSE;
FOR ndl ← ndl, ndl.rest
WHILE ndl #
NIL
DO
IF ndl.first.org = org
THEN
BEGIN
IF found THEN ERROR ELSE found ← TRUE;
nd ← ndl.first;
IF remove
THEN
{IF prev = NIL THEN newdl ← ndl.rest ELSE prev.rest ← ndl.rest};
RETURN;
END;
prev ← ndl;
ENDLOOP;
END;
whatToDo: ARRAY Menus.MouseButton[yellow .. blue] OF ARRAY BOOL--ctl-- OF ARRAY BOOL--shift-- OF Graphs.LinkConsumerProc ← ALL[ALL[ALL[NIL]]];
BrowserClick: GraphBrowsers.BrowserCmdProc
--PROC [pane: Pane, index: CARDINAL- -origin 0- -, cmdData, browserData: REF ANY, button: Menus.MouseButton, ctl, shift, paint: BOOLEAN]-- =
BEGIN
n: Graphs.Node ← GraphBrowsers.GetPaneNode[pane];
d: Display ← GetDisplay[n];
d.mucking ← d.mucking + 1;
{ENABLE UNWIND => d.mucking ← d.mucking - 1;
whatToDo[button][ctl][shift][
[pane.GetChildName[index], pane.GetChildNode[index]],
NIL];
};
d.mucking ← d.mucking - 1;
END;
GetDisplay:
PROC [n: Graphs.Node]
RETURNS [d: Display] = {
d ←
WITH n.rep
SELECT
FROM
cb: CellBrowser => cb.display,
cs: CellState => cs.cb0.display,
in: InterfaceNodes => in.cb1.display,
in: InternalNodes => in.cb2.display,
c: Components => c.cb3.display,
ne: NodeElt => ne.org.display,
ENDCASE => ERROR};
LogSwitchery: Graphs.LinkConsumerProc =
BEGIN
WITH link.otherSide.rep
SELECT
FROM
ne: NodeElt => {
RoseEvents.RemoveWatcher[event: $NewNodeQ, watcher: [NotifyNodeQ, ne.org.display], watched: ne.node];
RoseEvents.AddWatcher[event: $NewNodeQ, watcher: [NotifyNodeQ, ne.org.display], watched: ne.node];
RoseEvents.RemoveWatcher[event: $NewNodeUD, watcher: [NotifyNodeUD, ne.org.display], watched: ne.node];
RoseEvents.AddWatcher[event: $NewNodeUD, watcher: [NotifyNodeUD, ne.org.display], watched: ne.node];
RoseEvents.RemoveWatcher[event: $Perturbed, watcher: [NotifyPerturb, ne.org.display], watched: ne.node];
RoseEvents.AddWatcher[event: $Perturbed, watcher: [NotifyPerturb, ne.org.display], watched: ne.node];
RoseEvents.RemoveWatcher[event: $Found, watcher: [NotifyFound, ne.org.display], watched: ne.node];
RoseEvents.AddWatcher[event: $Found, watcher: [NotifyFound, ne.org.display], watched: ne.node];
};
cs: CellState => NULL;
cb: CellBrowser => NULL;
in: InterfaceNodes => NULL;
in: InternalNodes => NULL;
components: Components => NULL;
ENDCASE => ERROR;
END;
DontLogSwitchery: Graphs.LinkConsumerProc =
BEGIN
WITH link.otherSide.rep
SELECT
FROM
ne: NodeElt => {
RoseEvents.RemoveWatcher[event: $NewNodeQ, watcher: [NotifyNodeQ, ne.org.display], watched: ne.node];
RoseEvents.RemoveWatcher[event: $NewNodeUD, watcher: [NotifyNodeUD, ne.org.display], watched: ne.node];
RoseEvents.RemoveWatcher[event: $Perturbed, watcher: [NotifyPerturb, ne.org.display], watched: ne.node];
RoseEvents.RemoveWatcher[event: $Found, watcher: [NotifyFound, ne.org.display], watched: ne.node];
};
cs: CellState => NULL;
cb: CellBrowser => NULL;
in: InterfaceNodes => NULL;
in: InternalNodes => NULL;
components: Components => NULL;
ENDCASE => ERROR;
END;
DisplayAllButState: Graphs.LinkConsumerProc =
BEGIN
WITH link.otherSide.rep
SELECT
FROM
ne: NodeElt => DisplayNode[ne, FALSE];
cs: CellState => NULL;
cb: CellBrowser => EnumerateCell[cb: cb, to: [DisplayAllButState], interf: FALSE];
in: InterfaceNodes => EnumerateInterfaceNodes[in, [DisplayAllButState]];
in: InternalNodes => EnumerateInternalNodes[in, [DisplayAllButState]];
components: Components => EnumerateComponents[components, [DisplayAllButState]];
ENDCASE => ERROR;
END;
UnDisplayAll: Graphs.LinkConsumerProc =
BEGIN
WITH link.otherSide.rep
SELECT
FROM
ne: NodeElt => UnDisplayNode[ne, FALSE];
cs: CellState => UnDisplayCellState[cs];
cb: CellBrowser => UnDisplayCell[cb];
in: InterfaceNodes => EnumerateInterfaceNodes[in, [UnDisplayAll]];
in: InternalNodes => EnumerateInternalNodes[in, [UnDisplayAll]];
components: Components => EnumerateComponents[components, [UnDisplayAll]];
ENDCASE => ERROR;
END;
DisplayAllState: Graphs.LinkConsumerProc =
BEGIN
WITH link.otherSide.rep
SELECT
FROM
ne: NodeElt => NULL;
cs: CellState => DisplayCellState[cs];
cb: CellBrowser => EnumerateCell[cb: cb, to: [DisplayAllState], interf: FALSE];
in: InterfaceNodes => NULL;
in: InternalNodes => NULL;
components: Components => EnumerateComponents[components, [DisplayAllState]];
ENDCASE => ERROR;
END;
UnDisplayAllState: Graphs.LinkConsumerProc =
BEGIN
WITH link.otherSide.rep
SELECT
FROM
ne: NodeElt => NULL;
cs: CellState => UnDisplayCellState[cs];
cb: CellBrowser => EnumerateCell[cb: cb, to: [UnDisplayAllState], interf: FALSE];
in: InterfaceNodes => NULL;
in: InternalNodes => NULL;
components: Components => EnumerateComponents[components, [UnDisplayAllState]];
ENDCASE => ERROR;
END;
DisplayCellState:
PROC [cs: CellState] =
BEGIN
dl: HD.Leaf ← NARROW[Asserting.FnVal[fn: cellStateDisplayProp, from: cs.cb0.cell.other]];
IF dl =
NIL
THEN
BEGIN
CreateValue:
HD.ValueCreater
--PROC [leaf: Leaf] RETURNS [value: Viewer]-- =
BEGIN
value ←
VR.ViewRef[
agg: cs.cb0.cell.realCellStuff.state,
viewerInit: [
parent: leaf.container,
wx: 10,
wy: leaf.nameButton.wy + leaf.nameButton.wh + 2,
ww: MAX[100, leaf.container.cw - 10],
wh: VF.FontHeight[] + 5,
iconic: FALSE,
border: TRUE,
scrollable: FALSE],
createOptions: [mayInitiateRelayout: FALSE, feedBackHeight: 0],
parent: cs.cb0.display.rv,
paint: FALSE].RVQuaViewer[];
END;
dp: HD.Parent ← EnsureDisplay[cs.cb0];
name: ROPE ← cs.cb0.cell.name.Cat["'s state:"];
dl ← HD.AddLeaf[parent: dp, before: NextCellChild[cs.cb0.display, cs.cb0.cell.leftChild], name: name, class: cellStateClass, instanceData: cs, CreateValue: CreateValue, paint: FALSE];
cs.cb0.cell.other ← Asserting.AssertFn1[fn: cellStateDisplayProp, val: dl, inAdditionTo: cs.cb0.cell.other];
END;
END;
UnDisplayCellState:
PROC [cs: CellState] =
BEGIN
dl: HD.Leaf ← NARROW[Asserting.FnVal[fn: cellStateDisplayProp, from: cs.cb0.cell.other]];
IF dl # NIL THEN HD.Remove[dl];
END;
NoticeCellStateRemoval:
HD.ChildNotifyProc
-- PROC [child: Child]-- =
BEGIN
cs: CellState ← NARROW[child.instanceData];
cs.cb0.cell.other ← Asserting.AssertFn1[fn: cellStateDisplayProp, val: NIL, inAdditionTo: cs.cb0.cell.other];
END;
CellStateButtonProc: Buttons.ButtonProc =
BEGIN
MessageWindow.Append[message: "Don't do that", clearFirst: TRUE];
END;
UnDisplayNode:
PROC [ne: NodeElt, noisy:
BOOLEAN] =
BEGIN
displays: NodeDisplayList ← NARROW[Asserting.FnVal[fn: nodeDisplaysProp, from: ne.node.other]];
nd: NodeDisplay;
found: BOOLEAN;
[displays, nd, found] ← NDLSearch[ndl: displays, org: ne.org, remove: FALSE];
IF
NOT found
THEN
{IF noisy THEN ne.org.display.rv.DisplayMessage[msg: "not displayed!"]}
ELSE
BEGIN
HD.Remove[nd.dc];
IF noisy THEN ne.org.display.rv.DisplayMessage[msg: "ok"];
END;
END;
EnsureInterfaceIndex:
PROC [ne: NodeElt] = {
IF ne.interfaceIndex = notLookedFor THEN ne.interfaceIndex ← RoseTypes.GetIndex[ne.org.socket.cell.type.ports, ne.name]};
DisplayNode:
PROC [ne: NodeElt, noisy:
BOOLEAN] =
BEGIN
displays: NodeDisplayList ← NARROW[Asserting.FnVal[fn: nodeDisplaysProp, from: ne.node.other]];
nd: NodeDisplay;
found: BOOLEAN;
[, nd, found] ← NDLSearch[ndl: displays, org: ne.org, remove: FALSE];
IF found
THEN
{IF noisy THEN ne.org.display.rv.DisplayMessage[msg: "already displayed!"]}
ELSE
IF ne.node.visible.cell #
NIL
THEN
BEGIN
CreateValue:
HD.ValueCreater =
BEGIN
value ←
VO.CreateViewer[flavor: $Text, paint:
FALSE,
info: [parent: leaf.container,
data:
IF ne.org.display.ctlPanel.mode = Value
THEN ne.format.FormatValue[
ne.node,
ne.format,
ne.node.ValWP[]]
ELSE ne.format.FormatTest[
ne.node.type,
ne.format,
ne.testProc,
ne.testData],
wx: leaf.nameButton.wx + leaf.nameButton.ww + 2,
ww: ne.format.MaxWidth[ne.node.type, ne.format, VF.defaultFont] + 20,
wh: VF.FontHeight[] + 5,
iconic: FALSE,
border: FALSE,
scrollable: FALSE]];
VO.AddProp[viewer: value, prop: leafProp, val: leaf];
END;
dp: HD.Parent ← EnsureDisplay[ne.parent];
dc: HD.Leaf;
name: ROPE ← ne.name;
IF NOT ne.interfaceNode THEN name ← name.Concat[":"];
EnsureInterfaceIndex[ne];
IF ne.interfaceIndex # notFound
THEN
BEGIN
name ← name.Concat[SELECT (IF ne.org.socket.cell.type.ports[ne.interfaceIndex].input THEN 1 ELSE 0) + (IF ne.org.socket.cell.type.ports[ne.interfaceIndex].output THEN 2 ELSE 0) FROM 1 => "<", 2 => ">", 3 => "=", ENDCASE => ERROR];
END;
dc ← HD.AddLeaf[parent: dp, before: NextNodeChild[ne], name: name, class: nodeClass, instanceData: ne, CreateValue: CreateValue, paint: FALSE];
displays ← CONS[[ne.org, dc], displays];
ne.node.other ← Asserting.AssertFn1[fn: nodeDisplaysProp, val: displays, inAdditionTo: ne.node.other];
RoseEvents.AddWatcher[watched: ne.node, watcher: [NotifyNodeView, dc], event: $ChangeEarly];
IF noisy THEN ne.org.display.rv.DisplayMessage[msg: "ok"];
END
ELSE ne.org.display.rv.DisplayMessage[ne.name.Cat[" can't be displayed"]];
END;
NextNodeChild:
PROC [ne: NodeElt]
RETURNS [child:
HD.Child] =
BEGIN
Displayed:
PROC [node: Node]
RETURNS [
BOOLEAN] =
BEGIN
displays: NodeDisplayList ← NARROW[Asserting.FnVal[fn: nodeDisplaysProp, from: node.other]];
nd: NodeDisplay;
found: BOOLEAN;
[, nd, found] ← NDLSearch[ndl: displays, org: ne.org, remove: FALSE];
IF found THEN child ← nd.dc;
RETURN [found];
END;
node: Node ← ne.node.next;
IF ne.interfaceNode
THEN
BEGIN
FOR c:
CARDINAL
IN (ne.interfaceIndex .. ne.org.socket.cell.interfaceNodes.length)
DO
IF Displayed[ne.org.socket.cell.interfaceNodes[c]] THEN RETURN;
ENDLOOP;
node ← ne.org.socket.cell.firstInternalNode;
END;
FOR node ← node, node.next
WHILE node #
NIL
DO
IF Displayed[node] THEN RETURN ENDLOOP;
child ← NARROW[Asserting.FnVal[fn: cellStateDisplayProp, from: ne.org.socket.cell.other]];
IF child # NIL THEN RETURN;
child ← NextCellChild[ne.org.display, ne.org.socket.cell.leftChild];
END;
UnDisplayCell:
PROC [cb: CellBrowser] =
BEGIN
dpAsAny: REF ANY ← Asserting.FnVal[from: cb.cell.other, fn: cb.display];
IF dpAsAny #
NIL
THEN
BEGIN
dp: HD.Parent ← NARROW[dpAsAny];
IF dp.asChild #
NIL
THEN
BEGIN
HD.Remove[dp.asChild];
END;
END;
END;
NextCellChild:
PROC [display: Display, start: Cell]
RETURNS [child:
HD.Child] =
BEGIN
FOR cell: Cell ← start, cell.rightSibling
WHILE cell #
NIL
DO
nextDPAsAny: REF ANY ← Asserting.FnVal[from: cell.other, fn: display];
IF nextDPAsAny #
NIL
THEN
{child ← NARROW[nextDPAsAny, HD.Parent].asChild; EXIT};
ENDLOOP;
END;
EnsureDisplay:
PROC [cb: CellBrowser]
RETURNS [dp:
HD.Parent] =
BEGIN
dpAsAny: REF ANY ← Asserting.FnVal[from: cb.cell.other, fn: cb.display];
IF dpAsAny =
NIL
THEN
BEGIN
pdp: HD.Parent ← IF cb.cell.parent = NIL THEN cb.display.rootDisplay ELSE EnsureDisplay[NEW [CellBrowserRep ← [cb.cell.parent, cb.display]]];
dc: HD.Child;
dp ← (dc ← HD.AddInternalNode[parent: pdp, before: NextCellChild[cb.display, cb.cell.rightSibling], name: cb.cell.name.Cat[": "], class: cellClass, instanceData: cb, paint: FALSE]).asParent;
cb.cell.other ← Asserting.AssertFn1[fn: cb.display, val: dp, inAdditionTo: cb.cell.other];
IF cb.cell.substantiality = Real
THEN
BEGIN
RoseEvents.AddWatcher[$Schedule, [NotifyCellView, dc], cb.cell];
NotifyCellView[$Schedule, cb.cell, dc, NIL];
END;
END
ELSE dp ← NARROW[dpAsAny];
END;
Setup:
PROC =
BEGIN
whatToDo[yellow][FALSE][FALSE] ← DisplayAllButState;
whatToDo[yellow][FALSE][TRUE] ← UnDisplayAll;
whatToDo[blue][FALSE][FALSE] ← DisplayAllState;
whatToDo[blue][FALSE][TRUE] ← UnDisplayAllState;
whatToDo[yellow][TRUE][FALSE] ← DisplayAllButState;
whatToDo[yellow][TRUE][TRUE] ← UnDisplayAll;
whatToDo[blue][TRUE][FALSE] ← LogSwitchery;
whatToDo[blue][TRUE][TRUE] ← DontLogSwitchery;
END;
Setup[];
END.