DIRECTORY
CD,
CDBasics,
CDCells,
CDDirectory,
CDErrors,
CDMarks,
CDOps,
CDProperties,
CDRects,
Rope;

CDErrorsImpl: CEDAR PROGRAM
IMPORTS CD, CDBasics, CDCells, CDDirectory, CDMarks, CDProperties, CDOps, CDRects, Rope
EXPORTS CDErrors =
BEGIN

InstancePredicate: TYPE = CDErrors.InstancePredicate;

WhereFound: TYPE = {itself, cell, design, none};

foundAndStop: SIGNAL = CODE;
foundInFirstPlace: SIGNAL = CODE;

MyDevice: TYPE = RECORD [
mark: CDMarks.MarkRange,
searchOb: CD.Object,
found: BOOL_FALSE, 
trans: CD.Transformation_[[0, 0], original],
cell: CD.Object_NIL,
cellFound: BOOL_FALSE,
cellTrans: CD.Transformation_[[0, 0], original]
];

MyDrawChild: CD.DrawProc = {
device: REF MyDevice = NARROW[pr.devicePrivate];
IF inst.ob.marked = device.mark THEN RETURN;
inst.ob.marked _ device.mark;
IF inst.ob=device.searchOb THEN {
device.trans _ trans;
device.found _ TRUE;
SIGNAL foundInFirstPlace;
RETURN
};
inst.ob.class.drawMe[inst: inst, trans: trans, pr: pr ! 
foundInFirstPlace => {
IF CDCells.IsCell[inst.ob] THEN {
device.cell _ inst.ob;
device.cellTrans _ trans;
device.cellFound _ TRUE;
SIGNAL foundAndStop;
ERROR
};
REJECT
}
]; 
};

FindAnInstance: PROC [design: CD.Design, ob: CD.Object] RETURNS [where: WhereFound _ none, cell: CD.Object_NIL, pos: CD.Position_[0, 0], orientation: CD.Orientation_original] = {

ProtectedDrawDesign: PROC [mark: CDMarks.MarkRange] = {
myDrawRef.devicePrivate _ myDevice _ NEW[MyDevice _ [searchOb: ob, mark: mark]];
CDOps.DrawDesign[design, myDrawRef ! 
foundAndStop, foundInFirstPlace => CONTINUE;
];
};

failed: BOOL _ FALSE;
myDrawRef: REF CD.DrawInformation;
myDevice: REF MyDevice;
IF ob=NIL THEN RETURN [where _ design];
IF CDCells.IsCell[ob] THEN RETURN [where _ itself, cell _ ob];
myDrawRef _ CD.CreateDrawRef[[
design: design,
interestClip: CDBasics.universe,
drawChild: MyDrawChild
]];
CDMarks.DoWithMark[design, ProtectedDrawDesign];
IF myDevice.found THEN {
IF myDevice.cellFound AND ~CDCells.IsDummyCell[cell] THEN {
r: CD.Rect;
cell _ myDevice.cell;
where _ WhereFound[cell];
r _ CDBasics.DeMapRect[myDevice.searchOb.bbox, myDevice.trans];--???
pos _ CDBasics.BaseOfRect[r];
orientation _ CDBasics.DecomposeOrient[itemInWorld: myDevice.trans.orient, cellInWorld: myDevice.cellTrans.orient].itemInCell;
}
ELSE {
where _ WhereFound[design];
pos _ myDevice.trans.off;
orientation _ myDevice.trans.orient;
}
}  
};

FancyClip: PROC [r: CD.Rect, into: CD.Object, msg: Rope.ROPE] RETURNS [cr: CD.Rect, text: Rope.ROPE] = {

EasyChangeAbleRect: PROC [ob: CD.Object] RETURNS [CD.Rect] = {
WITH ob.specific SELECT FROM
cp: CD.CellSpecific => 
IF ~cp.specifiedIr THEN RETURN [CD.InterestRect[ob]];
ENDCASE => NULL;
RETURN [ob.bbox]
};

text _ msg;
cr _ r;
IF into#NIL THEN {
ir: CD.Rect _ EasyChangeAbleRect[into];
cr _ CDBasics.Intersection[cr, ir];
IF ~CDBasics.NonEmpty[cr] THEN {
text _ Rope.Concat[msg, "(outside object)"];
IF cr.x1>=cr.x2 THEN { --x dimension problem
IF cr.x1>=ir.x2 THEN {cr.x2 _ ir.x2; cr.x1 _ MAX[ir.x1, ir.x2-(ir.x2-ir.x1)/16-2]}
ELSE {cr.x1 _ ir.x1; cr.x2 _ MIN[ir.x2, ir.x1+(ir.x2-ir.x1)/8+2]}
};
IF cr.y1<=cr.y2 THEN {
IF cr.y1>ir.y2 THEN {cr.y2 _ ir.y2; cr.y1 _ MAX[ir.y1, ir.y2-(ir.y2-ir.y1)/16-2]}
ELSE {cr.y1 _ ir.y1; cr.y2 _ MIN[ir.y2, ir.y1+(ir.y2-ir.y1)/8+2]}
};
IF ~CDBasics.NonEmpty[cr] THEN cr _ ir;
};
};
};

IncludeMessage: PUBLIC PROC [design: CD.Design, ob: CD.Object, rect: CD.Rect, message: Rope.ROPE_NIL, owner: ATOM_NIL] RETURNS [done: BOOL_TRUE, into: CD.Object_NIL, inst: CD.Instance_NIL] = {
mappedRect: CD.Rect;
where: WhereFound;
cell: CD.Object;
pos: CD.Position;
orientation: CD.Orientation;
from: Rope.ROPE _ NIL;
IF design=NIL OR ~CDBasics.NonEmpty[rect] THEN RETURN [done_FALSE];
[where: where, cell: cell, pos: pos, orientation: orientation] _ FindAnInstance[design, ob];
IF where=none THEN RETURN [done_FALSE]
ELSE IF where=itself THEN {mappedRect _ rect; into _ ob} 
ELSE {
cellRep: REF;  
IF where=design THEN {mappedRect _ rect; cellRep _ $design} 
ELSE IF cell#NIL THEN {
mappedRect _ CDBasics.MapRect[rect, [pos, orientation]];
cellRep _ CDDirectory.Name[cell];
into _ cell;
IF cellRep=NIL THEN {cellRep _ $design; into _ NIL};
}
ELSE ERROR;
IF ob#NIL AND ob.class.inDirectory THEN { 
x: REF = CDProperties.GetObjectProp[ob, hasErrorsInOtherCellsKey];
IF x=NIL THEN CDProperties.PutObjectProp[ob, hasErrorsInOtherCellsKey, cellRep]
ELSE IF x#$many AND x#cellRep THEN {
IF ~ISTYPE[x, Rope.ROPE] OR ~Rope.Equal[NARROW[x, Rope.ROPE], CDDirectory.Name[ob]] THEN 
CDProperties.PutObjectProp[ob, hasErrorsInOtherCellsKey, $many] 
}
};
IF ob#NIL THEN {
from _ CDDirectory.Name[ob];
IF from=NIL THEN from _ CDOps.ObjectRope[ob];
message _ Rope.Cat[message, " [local to ", from, "]"];
}
};
IF where#design THEN [mappedRect, message] _ FancyClip[mappedRect, cell, message];
inst _ CDCells.IncludeOb[design: design, 
cell: cell, 
ob: CDRects.CreateRect[CDBasics.SizeOfRect[mappedRect], CD.errorLayer], 
trans: [CDBasics.BaseOfRect[mappedRect], original],
mode: dontResize
].newInst;
CDOps.Redraw[design, (IF cell=NIL THEN mappedRect ELSE CDBasics.universe)];
IF owner#NIL THEN CDProperties.PutInstanceProp[inst, ownerKey, owner];
IF message#NIL THEN CDProperties.PutInstanceProp[inst, messageKey, message];
IF from#NIL THEN CDProperties.PutInstanceProp[inst, showErrorsForOtherKey, from];
};

EqualXR: PROC [x: REF, r: Rope.ROPE] RETURNS [BOOL] = INLINE {
WITH x SELECT FROM
xr: Rope.ROPE => RETURN [Rope.Equal[xr, r]];
ENDCASE  => RETURN [x=r] --both NIL
};

RemFromCellOrTopLevel: PROC [design: CD.Design, owner: ATOM, cell: CD.Object, removeIt: InstancePredicate, restricted: Rope.ROPE_NIL, all: BOOL_FALSE] RETURNS [others: BOOL] = {
redraw: BOOL_FALSE;
removeList: CD.InstanceList _ NIL;
countAll, countRemove: INT _ 0;
EachInst: CDCells.InstEnumerator = {
IF ~IsError[inst.ob] THEN RETURN; 
countAll _ countAll+1;
IF owner=NIL OR owner=CDProperties.GetInstanceProp[inst, ownerKey] THEN { 
IF all OR EqualXR[CDProperties.GetInstanceProp[inst, showErrorsForOtherKey], restricted] THEN {
IF cell#NIL OR ~inst.selected THEN { --dont remove selected messages
IF removeIt=NIL OR removeIt[inst] THEN { 
countRemove _ countRemove+1;
removeList _ CONS[inst, removeList] 
} 
}
}
}
};
IF cell=NIL THEN cell _ CDOps.PushedTopCell[design];
[] _ CDCells.EnumerateInstances[cell, EachInst];
FOR list: CD.InstanceList _ removeList, list.rest WHILE list#NIL DO
[] _ CDCells.RemoveInstance[design, cell, list.first, doit]
ENDLOOP;
IF countRemove>0 AND cell#NIL THEN CDOps.Redraw[design];
others _ countAll#countRemove; 
};

RemoveMessages: PUBLIC PROC [design: CD.Design, ob: CD.Object, owner: ATOM, alsoOthers: BOOL, removeIt: InstancePredicate] = {

RemoveMessFromEveryWhere: PROC [restricted: Rope.ROPE_NIL] RETURNS [others: BOOL_ FALSE] = {
EachEntry: PROC [name: Rope.ROPE, ob: CD.Object] RETURNS [quit: BOOL_FALSE] = {
IF CDCells.IsCell[ob] THEN 
others _ others OR RemFromCellOrTopLevel[design, owner, ob, removeIt, restricted];
};
[] _ CDDirectory.Enumerate[design, EachEntry];
others _ others OR RemFromCellOrTopLevel[design, owner, NIL, removeIt, restricted];
};

IF ob=NIL OR CDCells.IsCell[ob] THEN [] _ RemFromCellOrTopLevel[design, owner, ob, removeIt, NIL, alsoOthers]
ELSE IF ob.class.inDirectory THEN { 
others: BOOL _ TRUE; -- found error messages of other owners
x: REF = CDProperties.GetObjectProp[ob, hasErrorsInOtherCellsKey];
IF x#NIL THEN {
obName: Rope.ROPE = CDDirectory.Name[ob];
IF x=$design THEN 
others _ RemFromCellOrTopLevel[design, owner, NIL, removeIt, obName]
ELSE
WITH x SELECT FROM
r: Rope.ROPE => {
other: CD.Object _ CDDirectory.Fetch[design, r].object;
IF other#NIL AND CDCells.IsCell[other] THEN 
others _ RemFromCellOrTopLevel[design, owner, other, removeIt, obName]
};
ENDCASE => others _ RemoveMessFromEveryWhere[obName];
IF owner=NIL OR ~others THEN
CDProperties.PutObjectProp[ob, hasErrorsInOtherCellsKey, NIL];
};
}
ELSE [] _ RemoveMessFromEveryWhere[CDOps.ObjectRope[ob]];
};

RemoveAllMessages: PUBLIC PROC [design: CD.Design, owner: ATOM, removeIt: InstancePredicate] = {
EachEntry: PROC [name: Rope.ROPE, ob: CD.Object] RETURNS [quit: BOOL_FALSE] = {
IF CDCells.IsCell[ob] THEN 
[] _ RemFromCellOrTopLevel[design, owner, ob, removeIt, NIL, TRUE]
};
[] _ CDDirectory.Enumerate[design, EachEntry];
[] _ RemFromCellOrTopLevel[design, owner, NIL, removeIt, NIL, TRUE];
};

IsError: PROC [ob: CD.Object] RETURNS [BOOL] = INLINE {
RETURN [ob.layer=CD.errorLayer AND ob.class.wireTyped]
};

messageKey: PUBLIC ATOM _ $SignalName; 
ownerKey: ATOM = $ErrorOwner; 
hasErrorsInOtherCellsKey: ATOM = $showErrorsElseWhere; 
showErrorsForOtherKey: ATOM = $showErrorsForOthers; 
[] _ CDProperties.RegisterProperty[hasErrorsInOtherCellsKey, $chj];
[] _ CDProperties.RegisterProperty[showErrorsForOtherKey, $chj];
[] _ CDProperties.RegisterProperty[ownerKey, $chj];
END. 



CDErrorsImpl.mesa        (part of ChipNDale)
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi,  March 1, 1985 9:40:12 am PST 
Last edited by: Christian Jacobi, October 30, 1986 2:55:36 pm PST
--PROC [inst: CD.Instance] RETURNS [yes: BOOL_TRUE];
--get an instance
--mapp the error rectangle
--make ob pointing to errormessage places if of any value and possible
--include the error rectangle
--properties
--all: whether we want restricted to be applied
--restricted: whether only messages with Name(origin)=restricted will be removed
--to improve, handle innerrect crap, removing and repositioning inside
Κ^˜
codeš
œ,™,Kšœ
Οm
œ7™BKš
œ;™;K™AK˜—š
Οk	˜	Kšžœ
˜Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜—K˜šΟnœžœ
ž˜Kšžœ
žœM˜WKšžœ˜—Kš
ž˜K˜šœžœ˜5Kš
œ4™4—K˜Kšœžœ ˜0K˜Kšœžœžœ
˜Kšœžœžœ
˜!K˜šœ
žœžœ˜Kš
œ˜Kšœ
žœ˜Kšœžœ
žœ˜Kšœžœ#˜,Kšœžœžœ
˜Kšœžœ
žœ
˜Kšœžœ"˜/Kš
œ˜—K˜šΟbœžœ
˜Kšœžœžœ˜0Kšžœžœ
žœ
˜,Kš
œ˜šžœžœ˜!Kš
œ˜Kšœž˜Kšžœ˜Kš
ž˜K˜—š
œ8˜8š
œ˜šžœžœ˜!Kš
œ˜Kš
œ˜Kšœžœ
˜Kšžœ˜Kš
ž˜Kš
œ˜—Kš
ž˜Kš
œ
˜
—Kš
œ˜—Kš
œ˜—K˜šŸœžœ
žœ
žœ	žœ"žœžœžœžœ˜²
K˜šŸœžœ˜7Kšœ%žœ(˜Pš
œ%˜%Kšœ#žœ
˜,Kš
œ˜—Kš
œ˜—K˜Kšœžœžœ
˜Kšœžœ
žœ˜"Kšœ
žœ
˜Kšžœžœ
žœ
žœ˜'Kšžœžœ
žœ˜>šœžœ˜Kš
œ˜Kš
œ ˜ Kš
œ˜Kš
œ˜—Kš
œ0˜0šžœžœ˜šžœžœžœ˜;Kšœžœ˜Kš
œ˜Kš
œ˜Kš
œD˜DKš
œ˜Kš
œ~˜~K˜
—šžœ˜Kš
œ˜Kš
œ˜Kš
œ$˜$K˜
—Kš
œ˜—Kš
œ˜—K˜šŸ	œžœžœ
žœžœžœžœžœ˜hK˜š
Ÿœžœžœ	žœžœ
˜>šžœ
žœ
ž˜šœžœ˜Kšžœžœ
žœžœ˜5—Kšžœžœ
˜—Kšžœ
˜K˜—K˜Kš
œ˜Kš
œ˜šžœžœ
žœ˜Kšœžœ!˜'Kš
œ#˜#šžœžœ˜ Kš
œ,˜,šžœžœΟc˜,Kšžœžœžœ"˜RKšžœžœ!˜AK˜—šžœžœ˜Kšžœ
žœžœ"˜QKšžœžœ!˜AK˜—Kšžœžœ	˜'K˜—K˜—Kš
œ˜—K˜š"Πbnœžœ
žœ
žœ
žœžœžœ
žœ	žœ
žœžœžœ
žœžœžœžœ	žœ˜ΐ
Kšœžœ˜Kš
œ˜Kšœžœ˜Kšœžœ
˜Kšœ
žœ
˜Kšœžœžœ
˜Kšžœžœ
žœžœ
žœžœ˜CKš
œ™Kš
œ\˜\Kš
œ™Kšžœžœ
žœžœ
˜&Kšžœ
žœžœ ˜9šžœ˜Kšœ	žœ˜Kšžœžœ(˜<šžœ
žœžœ
žœ˜Kš
œ8˜8Kš
œ!˜!Kš
œ˜Kšžœ	žœ
žœžœ˜4K˜
—Kšžœ
žœ
˜Kš
œF™Fšžœžœ
žœžœ˜*Kšœžœ<˜BKšžœžœ
žœB˜Ošžœ
žœ	žœžœ˜$šžœžœ	žœžœ
žœ	žœžœ
˜YKš
œ@˜@—K˜
—K˜—šžœžœ
žœ˜Kš
œ˜Kšžœžœ
žœ˜-Kš
œ6˜6K˜
—K˜—Kšžœžœ>˜RKš
œ™š
œ)˜)Kš
œ˜Kšœ8žœ˜HKš
œ3˜3Kš
œ˜Kš
œ
˜
—Kš	œžœžœ
žœžœ˜KKš
œ™Kšžœžœ
žœ5˜FKšžœ	žœ
žœ9˜LKšžœžœ
žœA˜QKš
œ˜—K˜šŸœžœžœ
žœžœžœžœ˜>šžœžœ
ž˜Kšœ	žœžœ˜,Kšžœžœ‘
˜#—Kš
œ˜—K˜šŸœžœ
žœžœžœ7žœ
žœžœ
žœžœ
žœ˜±
Kš
‘/™/Kš
‘P™PKšœžœ
žœ
˜Kšœžœžœ
˜"Kšœžœ˜šŸœ˜$Kšžœžœ
žœ˜"Kš
œ˜šžœžœ
žœ4žœ˜JšžœžœPžœ˜_š	žœžœ
žœžœ‘˜Dšžœ
žœ
žœžœ˜)Kš
œ˜Kšœ
žœ˜$Kš
œ˜—K˜
—K˜
—K˜
—K˜—Kšžœžœ
žœ$˜4Kš
‘F™FKš
œ0˜0š	žœžœ&žœžœ
ž˜CKš
œ;˜;Kšžœ
˜—Kšžœžœžœ
žœ˜8Kš
œ˜Kš
œ˜K˜—šŸœžœ
žœ
žœ
žœžœžœ"˜~K˜šŸœžœžœ
žœžœ
žœžœ˜\šŸ	œžœ
žœžœ	žœžœ
žœ˜Ošžœžœ
˜Kšœžœ@˜R—Kš
œ˜—Kš
œ.˜.Kšœžœ&žœ˜SKš
œ˜K˜—Kš
žœžœ
žœžœ9žœ
˜mšžœ
žœžœ˜$Kšœžœžœ
‘(˜<Kšœžœ<˜Bšžœžœ
žœ˜Kšœ
žœ˜)šžœžœ
˜Kšœ.žœ˜D—š
ž˜šžœžœ
ž˜šœžœ˜Kšœžœ.˜7šžœžœ
žœžœ
˜,Kš
œF˜F—Kš
œ˜—Kšžœ.˜5——šžœžœ
žœ	ž˜Kšœ9žœ˜>—Kš
œ˜—Kš
œ
˜
—Kšžœ5˜9Kš
œ˜—K˜š
Ÿœžœ
žœ
žœžœ"˜`šŸ	œžœ
žœžœ	žœžœ
žœ˜Ošžœžœ
˜Kšœ8žœžœ
˜B—Kš
œ˜—Kš
œ.˜.Kšœ*žœžœžœ˜DKš
œ˜K˜—šŸœžœžœ	žœžœžœ˜7Kšžœžœžœ˜6Kš
œ˜—K˜Kšœžœ
žœ˜'Kšœ
žœ˜Kšœžœ˜7Kšœžœ˜4Kš
œC˜CKš
œ@˜@Kš
œ3˜3Kšžœ˜K˜K˜K˜—…—"f1T