DIRECTORY 
CD,
CDBasics,
CDCells,
CDCommandOps,
CDCommandOpsExtras2,
CDHierarchyMarks,
CDInstances,
CDOps,
CDProperties,
CDRects,
CDSequencer,
CDSimpleOps,
CDViewer,
CDViewHighlight,
RuntimeError USING [UNCAUGHT],
TerminalIO,
ViewerClasses USING [Viewer];

CDHierarchyMarksImpl: CEDAR MONITOR
IMPORTS CD, CDInstances, CDBasics, CDCells, CDCommandOps, CDCommandOpsExtras2, CDOps, CDProperties, CDRects, CDSequencer, CDSimpleOps, CDViewer, CDViewHighlight, RuntimeError, TerminalIO
EXPORTS CDHierarchyMarks =
BEGIN

SetHierarchyMarkProc: TYPE = CDHierarchyMarks.SetHierarchyMarkProc;

myKey: ATOM _ $CDHierarchyMark;

GetHierarchyMark: PUBLIC PROC [design: CD.Design_NIL, ob: CD.Object_NIL] RETURNS [inst: CD.Instance_NIL] = {
GetFrom: PROC [x: REF] RETURNS [inst: CD.Instance_NIL] = {
WITH CDProperties.GetProp[x, myKey] SELECT FROM
i: CD.Instance => RETURN [i];
ENDCASE => NULL;
};
IF ob#NIL THEN inst _ GetFrom[ob]
ELSE IF design#NIL THEN inst _ GetFrom[design];
};

ReallySetHierarchyMark: PROC [design: CD.Design, ob: CD.Object_NIL, inst: CD.Instance] = {
i2: CD.Instance;
inst _ CDInstances.Copy[inst];
IF design=NIL THEN {
IF ob#NIL THEN CDProperties.PutProp[ob, myKey, inst]
} 
ELSE {
IF ob=NIL THEN {
CDProperties.PutProp[design, myKey, inst];
FOR list: LIST OF CD.PushRec _ design.actual, list.rest WHILE list#NIL DO
IF list.first.mightReplace=NIL THEN 
CDProperties.PutProp[list.first.dummyCell.ob, myKey, inst]
ENDLOOP;
}
ELSE {
FOR list: LIST OF CD.PushRec _ design.actual, list.rest WHILE list#NIL DO
IF list.first.dummyCell.ob=ob THEN {
CDProperties.PutProp[ob, myKey, inst];
IF list.first.mightReplace=NIL THEN CDProperties.PutProp[design, myKey, inst] 
ELSE {
i2 _ CDInstances.DeComposed[inst, list.first.mightReplace.location, list.first.mightReplace.ob.size, list.first.mightReplace.orientation]; 
CDProperties.PutProp[list.first.mightReplace.ob, myKey, i2];
};
RETURN;
}
ENDLOOP;
FOR list: LIST OF CD.PushRec _ design.actual, list.rest WHILE list#NIL DO
IF list.first.mightReplace#NIL AND list.first.mightReplace.ob=ob THEN {
CDProperties.PutProp[ob, myKey, inst];
i2 _ CDInstances.Composed[inst, list.first.mightReplace.location, list.first.mightReplace.ob.size, list.first.mightReplace.orientation]; 
CDProperties.PutProp[list.first.dummyCell.ob, myKey, i2];
RETURN;
}
ENDLOOP;
CDProperties.PutProp[ob, myKey, inst]
};
}; 
};

SetHierarchyMark: PUBLIC PROC [design: CD.Design, ob: CD.Object_NIL, inst: CD.Instance] = {
FOR list: LIST OF SetHierarchyMarkProc _ regList, list.rest WHILE list#NIL DO
list.first[design, ob, inst ! RuntimeError.UNCAUGHT => CONTINUE];
ENDLOOP;
};

regList: LIST OF SetHierarchyMarkProc; 

RegisterHierarchyMarker: PUBLIC ENTRY PROC [setHierarchyMark: SetHierarchyMarkProc] = {
IF setHierarchyMark#NIL THEN {
IF regList=NIL THEN regList _ LIST[setHierarchyMark]
ELSE 
FOR list: LIST OF SetHierarchyMarkProc _ regList, list.rest DO
IF list.rest=NIL THEN {list.rest _ LIST[setHierarchyMark]; EXIT}
ENDLOOP
};
};

RemDisplayHierachyMarkComm: PROC [comm: CDSequencer.Command] = {
viewer: ViewerClasses.Viewer _ CDViewer.GetViewer[comm];
IF viewer#NIL THEN CDViewHighlight.ShowInstance[v: viewer, key: myViewKey]
};

PutHierachyMarkComm: PROC [comm: CDSequencer.Command] = {
selected: CD.Instance _ CDCommandOps.TheInstance[comm, "place the hierarchy mark"];
IF selected#NIL THEN {
IF ~CDCells.IsPushedIn[comm.design] THEN SetHierarchyMark[comm.design, NIL, selected]
ELSE SetHierarchyMark[comm.design, comm.design.actual.first.dummyCell.ob, selected];
TDisplayHierarchyMarkComm[comm];
};
};

SelectHierachyMarkComm: PROC [comm: CDSequencer.Command] = {
Match: PROC [i1, i2: CD.Instance] RETURNS [BOOL] = INLINE {
RETURN [i1.ob=i2.ob AND i1.location=i2.location AND i1.orientation=i2.orientation]
};
inst: CD.Instance;  
TerminalIO.WriteRope["Select hierarchy mark\n"];
IF CDCells.IsPushedIn[comm.design] THEN {
mr: CD.Instance _ comm.design.actual.first.mightReplace;
inst _ GetHierarchyMark[comm.design, mr.ob];
IF inst#NIL THEN 
inst _ CDInstances.Composed[inst, mr.location, mr.ob.size, mr.orientation];
}
ELSE inst _ GetHierarchyMark[comm.design, NIL];
IF inst=NIL THEN TerminalIO.WriteRope["no hierarchy mark is set\n"]
ELSE {
CDSimpleOps.DeselectAll[comm.design];
FOR il: CD.InstanceList _ CDOps.InstList[comm.design], il.rest WHILE il#NIL DO
IF Match[il.first, inst] THEN {
il.first.selected _ TRUE;
CDOps.RedrawInstance[comm.design, il.first, FALSE];
};
ENDLOOP;
};
};

TDisplayHierarchyMarkComm: PROC [comm: CDSequencer.Command] = {
startInst: CD.Instance _ comm.design.actual.first.mightReplace;
IF startInst=NIL THEN startInst _ comm.design.actual.first.dummyCell;
DisplayHierarchyMarks[comm.design, LIST[startInst], comm];
};

ADisplayHierarchyMarkComm: PROC [comm: CDSequencer.Command] = {
DisplayHierarchyMarks[comm.design, CDOps.InstList[comm.design], comm];
};

SDisplayHierarchyMarkComm: PROC [comm: CDSequencer.Command] = {
DisplayHierarchyMarks[comm.design, CDInstances.SplitSelected[CDOps.InstList[comm.design]].selected, comm];
};


myViewKey: ATOM _ NIL; --$CDHierarchyMark;

CreateEmptyCell: PROC [] RETURNS [cell: CD.Object] = {
cell _ CDCells.CreateEmptyCell[];
CDCells.SetSimplificationTreshhold[cell, 0];
};

MakeMarker: PROC [highlightInst: CD.Instance, mark: CD.Rect, lambda: CD.Number_2] = {
mOb: CD.Object _ CreateEmptyCell[];
d: CD.Number _ MAX[lambda, MIN[mark.x2-mark.x1, mark.y2-mark.y1]/20];
lineOb: CD.Object;
lineOb _ CDRects.CreateRect[size: [mark.x2-mark.x1+2*d, d], l: CD.shadeLayer];
[] _ CDCells.IncludeOb[cell: mOb, ob: lineOb, position: [-d, -d]];
[] _ CDCells.IncludeOb[cell: mOb, ob: lineOb, position: [-d, mark.y2-mark.y1]];
lineOb _ CDRects.CreateRect[size: [d, mark.y2-mark.y1], l: CD.shadeLayer];
[] _ CDCells.IncludeOb[cell: mOb, ob: lineOb, position: [-d, 0]];
[] _ CDCells.IncludeOb[cell: mOb, ob: lineOb, position: [mark.x2-mark.x1, 0]];
[] _ CDCells.RepositionCell[mOb, NIL];
[] _ CDCells.IncludeOb[cell: highlightInst.ob, ob: mOb, position: CDBasics.BaseOfRect[mark]];
};

foundAndStop: SIGNAL [ig: CD.Instance] = CODE;

DontDrawRects: PROC [r: CD.Rect, l: CD.Layer, pr: CD.DrawRef] = {};

DrawChild: PROC [inst: CD.Instance, pos: CD.Position, orient: CD.Orientation, pr: REF CD.DrawInformation] = {
searchInst: CD.Instance _ NARROW[pr.devicePrivate];
IF searchInst.ob=inst.ob AND searchInst.location=pos AND searchInst.orientation=orient THEN {
ig: CD.Instance _ CDInstances.NewInst[inst.ob, pos, orient];
SIGNAL foundAndStop [ig]
};
};

DisplayHierarchyMarks: PROC [design: CD.Design, il: CD.InstanceList, viewerHint: REF] = {
highlightInst: CD.Instance _ NIL;

GoDown: PROC [fromInst: CD.Instance] = {
foundInst, markInst: CD.Instance _ NIL; multiple: BOOL _ FALSE;
IF CDProperties.GetProp[fromInst.ob, $IconFor]#NIL THEN RETURN;
markInst _ GetHierarchyMark[design, fromInst.ob];
IF markInst#NIL THEN { 
pr.devicePrivate _ CDInstances.Composed[markInst, fromInst.location, fromInst.ob.size, fromInst.orientation];
fromInst.ob.class.drawMe[inst: fromInst, pos: fromInst.location, orient: fromInst.orientation, pr: pr ! 
foundAndStop => {
IF foundInst=NIL THEN {foundInst _ ig; RESUME}
ELSE {multiple _ TRUE; CONTINUE}
}
];
IF foundInst#NIL THEN { 
IF multiple THEN TerminalIO.WriteRopes["****multiple hierarchymarks in ", CDCommandOps.InstRope[fromInst], "\n"]
ELSE {
IF highlightInst=NIL THEN highlightInst _ CDInstances.NewInst[CreateEmptyCell[]];
MakeMarker[highlightInst, CDInstances.InstRectI[foundInst], design.technology.lambda];
GoDown[foundInst];
};
};
}
};

pr: CD.DrawRef _ CD.CreateDrawRef[inf: [
design: design,
drawChild: DrawChild,
drawRect: DontDrawRects
]];
FOR list: CD.InstanceList _ il, list.rest WHILE list#NIL DO
GoDown[list.first];
IF CDSequencer.Aborted[design] THEN EXIT;
ENDLOOP;
IF highlightInst=NIL THEN TerminalIO.WriteRope["no hierarchy marks set\n"]
ELSE {
[] _ CDCells.RepositionCell[highlightInst.ob, NIL];
highlightInst.location _ CDBasics.NegOffset[CD.ClientOrigin[highlightInst.ob]];
};
FOR vL: CDViewer.ViewerList _ CDViewer.ViewersOf[viewerHint], vL.rest WHILE vL#NIL DO
CDViewHighlight.ShowInstance[v: vL.first, instOrList: highlightInst, key: myViewKey];
ENDLOOP
};

[] _ CDProperties.RegisterProperty[myKey, $CDHierarchyMarks];
RegisterHierarchyMarker[ReallySetHierarchyMark];
CDCommandOpsExtras2.RegisterWithMenu[menu: $ProgramMenu, entry: "Place hierarchy mark", proc: PutHierachyMarkComm, key: $CDHierarchyMarksPut];
CDCommandOpsExtras2.RegisterWithMenu[menu: $ProgramMenu, entry: "Display hierarchy marks top", proc: TDisplayHierarchyMarkComm, key: $CDHierarchyMarksTDisplay];
CDCommandOpsExtras2.RegisterWithMenu[menu: $ProgramMenu, entry: "Display hierarchy marks selected", proc: SDisplayHierarchyMarkComm, key: $CDHierarchyMarksSDisplay];
CDCommandOpsExtras2.RegisterWithMenu[menu: $ProgramMenu, entry: "Display hierarchy marks all", proc: ADisplayHierarchyMarkComm, key: $CDHierarchyMarksADisplay];
CDCommandOpsExtras2.RegisterWithMenu[menu: $ProgramMenu, entry: "Un-display hierarchy marks", proc: RemDisplayHierachyMarkComm, key: $CDHierarchyMarksUnDisplay];
CDCommandOpsExtras2.RegisterWithMenu[menu: $ProgramMenu, entry: "Select hierarchy mark", proc: SelectHierachyMarkComm, key: $CDHierarchyMarksSelect];
END.

Š
CDHierarchyMarksImpl.mesa    (part of ChipNDale)
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Christian Jacobi, July 16, 1986 8:09:57 pm PDT 
last edited by Christian Jacobi, July 17, 1986 11:29:46 am PDT
--put it also to the real top level cell
--put property to both, the mightReplace and the dummyCell, if it should go on either
--an ordinary cell; no pushed in state...

--########################
--T=>Top
--A=>Selected from top level
--S=>All from top level
--ig in global design coordinates
--fromInst in global world coordinate system

--########################

--########################
--########################
Κ
‰˜J™š
œ0™0Icodešœ
Οm
œ1™<Kš
œ/™/Kš
œ>™>—K˜šΟk	œ
˜
Kšžœ
˜Kš
œ	˜	Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kšœ
žœžœ˜Kš
œ˜Kšœžœ
˜—K˜šΟnœžœ
ž˜#Kšžœžœ‘
˜Ί
Kšžœ˜—Kš
ž˜K˜Kšœžœ)˜CK˜Kšœžœ˜K˜šŸœžœ
žœ
žœžœžœžœžœžœ
žœ˜lšŸœžœžœžœžœ
žœ˜:šžœ žœ
ž˜/Kšœžœ
žœ˜Kšžœž˜—K˜—Kšžœžœ
žœ˜!Kšžœ
žœžœ
žœ˜/K˜K˜—šŸœžœ
žœ
žœžœžœ˜ZKšœžœ
˜Kš
œ˜šžœžœ
žœ˜Kšžœžœ
žœ&˜4Kš
œ˜—šžœ˜šžœžœ
žœ˜Kš
œ*˜*K™(š
žœžœ
žœ
žœ$žœžœ
ž˜Išžœžœ
žœ
˜$Kš
œ:˜:—Kšžœ
˜—Kš
œ
˜
—šžœ˜K™Uš
žœžœ
žœ
žœ$žœžœ
ž˜Išžœžœ˜$Kš
œ&˜&Kšžœžœ
žœ+˜Nšžœ˜Kš
œ‹
˜‹
Kš
œ<˜<K˜—Kšžœ
˜K˜
—Kš
ž˜—š
žœžœ
žœ
žœ$žœžœ
ž˜Išžœžœ
žœžœ˜GKš
œ&˜&Kš
œ‰
˜‰
Kš
œ9˜9Kšžœ
˜K˜
—Kš
ž˜—K™)Kš
œ%˜%Kš
œ˜—Kš
œ˜—Kš
œ˜—K˜šŸœžœ
žœ
žœ
žœžœžœ˜[šžœžœ
žœ+žœžœ
ž˜MKšœ+ž	œžœ˜AKšžœ
˜—Kš
œ˜—K˜Kšœ	žœ
žœ˜'K˜šŸœžœ
žœ
žœ-˜Wšžœžœ
žœ˜Jšžœ	žœ
žœžœ˜4šžœ
˜šžœžœ
žœ+ž˜>Jš
žœžœ
žœ
žœžœ
˜@Jš
ž˜——K˜—Kš
œ˜K™—Kš
œ™K˜šŸœžœ ˜@Kš
œ8˜8Kšžœžœ
žœ8˜JKš
œ˜—K˜šŸœžœ ˜9Kšœ
žœG˜Sšžœ
žœ
žœ˜Kšžœ"žœžœ˜UKšžœP˜TKš
œ ˜ Kš
œ˜—K˜—K˜šŸœžœ ˜<šŸœžœ
žœžœžœžœ˜;Kšžœžœžœ˜RKš
œ˜—Kšœžœ˜Kš
œ0˜0šžœ!žœ˜)Kšœžœ2˜8Kš
œ,˜,šžœžœ
žœ
˜Kš
œK˜K—K˜
—Kšžœ&žœ˜/Kšžœžœ
žœ3˜Cšžœ˜Kš
œ%˜%š	žœžœ5žœžœ
ž˜Nšžœžœ˜Kšœžœ
˜Kšœ,žœ˜3K˜—Kšžœ
˜—K˜—K˜—K˜šŸœžœ ˜?Kš
œ™Kšœžœ2˜?Kšžœžœ
žœ0˜EKšœ#žœ˜:K˜—K˜šŸœžœ ˜?Kš
œ™Kš
œF˜FK˜—K˜šŸœžœ ˜?Kš
œ™Kš
œj˜jK˜—K˜K˜KšœžœžœΟc˜*K˜šŸœžœžœžœ˜6Kš
œ!˜!Kš
œ,˜,Kš
œ˜—K˜š
Ÿ
œžœžœžœžœ˜UKšœžœ˜#Kšœžœ
žœ	žœ'˜EKšœžœ˜Kšœ?žœ
˜NKš
œB˜BKš
œO˜OKšœ;žœ
˜JKš
œA˜AKš
œN˜NKšœ!žœ˜&Kš
œ]˜]K˜—K˜šœžœžœ
žœ
˜.K™!—K˜Kš
Ÿ
œžœžœ
žœžœ˜CK˜šŸ	œžœžœžœžœžœ
žœ˜mKšœžœžœ˜3šžœžœžœžœ˜]Kšœžœ6˜<Kšžœ˜K˜—Kš
œ˜—K˜š
Ÿœžœ
žœ
žœžœ˜YKšœžœžœ
˜!K˜šŸœžœžœ˜(Kš
œ,™,Kš	œžœžœžœžœ
˜?Kšžœ-žœ
žœ
žœ
˜?Kš
œ1˜1šžœ
žœ
žœ˜Kš
œm˜mš
œh˜hš
œ˜Kšžœžœ
žœžœ
˜.Kšžœ
žœžœ
˜ Kš
œ
˜
—Kš
œ˜—šžœžœ
žœ˜Kšžœ
žœ`˜pšžœ˜Kšžœžœ
žœ8˜QKš
œV˜VKš
œ˜K˜—K˜—K˜
—K˜—K˜šœžœžœ˜(Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—š	žœžœžœžœ
ž˜;Kš
œ˜Kšžœžœ
žœ
˜)Kšžœ
˜—Kšžœžœ
žœ1˜Jšžœ˜Kšœ.žœ˜3Kšœ,žœ!˜OK˜—šžœCžœžœ
ž˜UKš
œU˜UKš
ž˜—K˜—K™Kš
œ™K˜Kš
œ=˜=Kš
œ0˜0K™Kš
œ™Kš
œŽ
˜Ž
Kš
œ 
˜ 
Kš
œ₯
˜₯
Kš
œ 
˜ 
Kš
œ‘
˜‘
Kš
ϥ
˜•
Kš
œ™Kšžœ
˜K˜—…—#Τ0η