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

CDHierarchyMarksImpl: CEDAR MONITOR
IMPORTS CD, CDInstances, CDBasics, CDCells, CDCommandOps, CDOps, CDProperties, CDRects, CDSequencer, 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];
CDProperties.PutProp[CDOps.RealTopCell[design], myKey, inst];
}
ELSE {
CDProperties.PutProp[ob, myKey, inst];
FOR list: LIST OF CD.PushRec _ design.actual, list.rest WHILE list#NIL DO
IF list.first.dummyCell.ob=ob THEN {
IF list.first.mightReplace=NIL THEN CDProperties.PutProp[design, myKey, inst] 
ELSE {
i2 _ CDInstances.DeComposed[inst, list.first.mightReplace.trans]; 
CDProperties.PutProp[list.first.mightReplace.ob, myKey, i2];
};
RETURN;
};
IF list.first.mightReplace#NIL AND list.first.mightReplace.ob=ob THEN {
i2 _ CDInstances.Composed[inst, list.first.mightReplace.trans]; 
CDProperties.PutProp[list.first.dummyCell.ob, myKey, i2];
RETURN;
};
ENDLOOP;
};
}; 
};

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 _ CDOps.TheInstance[comm.design, "place the hierarchy mark\n"];
IF selected#NIL THEN {
SetHierarchyMark[comm.design, CDOps.PushedTopCell[comm.design], selected];
TDisplayHierarchyMarkComm[comm];
};
};

SelectHierachyMarkComm: PROC [comm: CDSequencer.Command] = {
Match: PROC [i1, i2: CD.Instance] RETURNS [BOOL] = INLINE {
RETURN [i1.ob=i2.ob AND i1.trans=i2.trans]
};
inst: CD.Instance;  found: INT _ 0;
TerminalIO.PutRope["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.trans];
}
ELSE inst _ GetHierarchyMark[comm.design, NIL];
IF inst=NIL THEN TerminalIO.PutRope["no hierarchy mark is set\n"]
ELSE {
CDOps.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; found _ found+1;
CDOps.RedrawInstance[comm.design, il.first, FALSE];
};
ENDLOOP;
IF found#1 THEN TerminalIO.PutRope["hierarchy mark not unique\n"]
};
};

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, trans: [[-d, -d]]];
[] _ CDCells.IncludeOb[cell: mOb, ob: lineOb, trans: [[-d, mark.y2-mark.y1]]];
lineOb _ CDRects.CreateRect[size: [d, mark.y2-mark.y1], l: CD.shadeLayer];
[] _ CDCells.IncludeOb[cell: mOb, ob: lineOb, trans: [[-d, 0]]];
[] _ CDCells.IncludeOb[cell: mOb, ob: lineOb, trans: [[mark.x2-mark.x1, 0]]];
[] _ CDCells.ResizeCell[NIL, mOb];
[] _ CDCells.IncludeOb[cell: highlightInst.ob, ob: mOb, trans: [CDBasics.BaseOfRect[mark]]];
};

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

DontDrawRects: CD.DrawRectProc = {};
DontDrawContext: CD.DrawContextProc = {};

DrawChild: CD.DrawProc = {
searchInst: CD.Instance _ NARROW[pr.devicePrivate];
IF searchInst.ob=ob AND searchInst.trans=trans THEN {
ig: CD.Instance _ CDInstances.NewInst[ob, trans];
SIGNAL foundAndStop [ig]
};
};

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

GoDown: PROC [fromInst: CD.Instance] = {
foundInst: CD.Instance _ NIL; --will be in design coordinate system
markInst: CD.Instance _ NIL; --will be in fromInst.ob's coordinate system
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.trans]; --get design coords
fromInst.ob.class.drawMe[ob: fromInst.ob, trans: fromInst.trans, pr: pr ! 
foundAndStop => {
IF foundInst=NIL THEN {foundInst _ ig; RESUME}
ELSE {multiple _ TRUE; CONTINUE}
}
];
IF foundInst#NIL THEN { 
IF multiple THEN TerminalIO.PutRopes["****multiple hierarchymarks in ", CDOps.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,
drawContext: DontDrawContext
]];
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.PutRope["no hierarchy marks set\n"]
ELSE {
[] _ CDCells.ResizeCell[NIL, 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];
CDCommandOps.RegisterWithMenu[menu: $ProgramMenu, entry: "place hierarchy mark", proc: PutHierachyMarkComm, key: $CDHierarchyMarksPut];
CDCommandOps.RegisterWithMenu[menu: $ProgramMenu, entry: "display hierarchy marks top", proc: TDisplayHierarchyMarkComm, key: $CDHierarchyMarksTDisplay];
CDCommandOps.RegisterWithMenu[menu: $ProgramMenu, entry: "display hierarchy marks selected", proc: SDisplayHierarchyMarkComm, key: $CDHierarchyMarksSDisplay];
CDCommandOps.RegisterWithMenu[menu: $ProgramMenu, entry: "display hierarchy marks all", proc: ADisplayHierarchyMarkComm, key: $CDHierarchyMarksADisplay];
CDCommandOps.RegisterWithMenu[menu: $ProgramMenu, entry: "un-display hierarchy marks", proc: RemDisplayHierachyMarkComm, key: $CDHierarchyMarksUnDisplay];
CDCommandOps.RegisterWithMenu[menu: $ProgramMenu, entry: "select hierarchy mark", proc: SelectHierachyMarkComm, key: $CDHierarchyMarksSelect];
END.

~
CDHierarchyMarksImpl.mesa    (part of ChipNDale)
Copyright c 1986, 1987 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, July 16, 1986 8:09:57 pm PDT 
Last edited by Christian Jacobi, January 29, 1987 6:04:10 pm PST
--inst must be in the coordinate system of ob!
--put it to the design and to the real top level dummy cell
--put property to both, the mightReplace and the dummyCell, if it should go on either
--fancy cases when we are pushed in to this cell
--we assume inst to be in design coordinates
--we assume inst to be in cell coordinates

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

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

--########################
--########################
Κ
˜J™š
œ0™0Icodešœ
Οm
œ7™BKš
œ:™: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š
œ˜šžœžœ
žœ˜Kšžœžœ
žœ&˜4Kš
œ˜—šžœ˜šžœžœ
žœ˜K™;Kš
œ*˜*Kš
œ=˜=Kš
œ
˜
—šžœ˜K™UKš
œ&˜&K™0š
žœžœ
žœ
žœ$žœžœ
ž˜Išžœžœ˜$K™,Kšžœžœ
žœ+˜Nšžœ˜Kš
œB˜BKš
œ<˜<K˜—Kšžœ
˜K˜—šžœžœ
žœžœ˜GK™*Kš
œ@˜@Kš
œ9˜9Kšžœ
˜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šœ
žœI˜Ušžœ
žœ
žœ˜Kš
œJ˜JKš
œ ˜ Kš
œ˜—K˜—K˜šŸœžœ ˜<šŸœžœ
žœžœžœžœ˜;Kšžœžœ˜*Kš
œ˜—Kšœžœžœ˜#Kš
œ.˜.šžœ!žœ˜)Kšœžœ2˜8Kš
œ,˜,Kšžœžœ
žœ-˜=K˜
—Kšžœ&žœ˜/Kšžœžœ
žœ1˜Ašžœ˜Kš
œ˜š	žœžœ5žœžœ
ž˜Nšžœžœ˜Kšœžœ˜*Kšœ,žœ˜3K˜—Kšžœ
˜—Kšžœ	žœ2˜AK˜—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š
œA˜AKš
œN˜NKšœ;žœ
˜JKš
œ@˜@Kš
œM˜MKšœžœ˜"Kš
œ\˜\K˜—K˜šœžœžœ
žœ
˜.K™!—K˜KšŸ
œ˜$KšŸœžœ˜)K˜šŸ	œ˜Kšœžœžœ˜3šžœžœžœ˜5Kšœžœ+˜1Kšžœ˜K˜—Kš
œ˜—K˜š
Ÿœžœ
žœ
žœžœ˜YKš
œ'™'Kšœžœžœ
˜!K˜šŸœžœžœ˜(Kš
œ-™-Kšœžœžœ %˜CKšœ
žœžœ ,˜IKšœ
žœžœ
˜Kšžœ-žœ
žœ
žœ
˜?Kš
œ1˜1šžœ
žœ
žœ˜KšœC ˜VKš
œ™š
œJ˜Jš
œ˜Kšžœžœ
žœžœ
˜.Kšžœ
žœžœ
˜ Kš
œ
˜
—Kš
œ˜—šžœžœ
žœ˜Kšžœ
žœW˜gšžœ˜Kšžœžœ
žœ8˜QKš
œV˜VKš
œ˜K˜—K˜—K˜
—K˜—K˜šœžœžœ˜(Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—š	žœžœžœžœ
ž˜;Kš
œ˜Kšžœžœ
žœ
˜)Kšžœ
˜—Kšžœžœ
žœ/˜Hšžœ˜Kšœžœ˜/K˜—šžœCžœžœ
ž˜UKš
œU˜UKš
ž˜—K˜—K™Kš
œ™K˜Kš
œ=˜=Kš
œ0˜0K™Kš
œ™Kš
œ‡
˜‡
Kš
Ϫ
˜™
Kš
œž
˜ž
Kš
Ϫ
˜™
Kš
œš
˜š
Kš
œŽ
˜Ž
Kš
œ™Kšžœ
˜K˜—…— ή.d