DIRECTORY
Atom,
CD,
CDInstances,
CDSimpleOps,
CDCells,
CDDraw,
CDEvents,
CDBasics,
CDOps,
CDOrient,
CDValue,
Rope USING [ROPE],
SymTab;

CDOpsImpl: CEDAR MONITOR 
IMPORTS Atom, CD, CDInstances, CDCells, CDSimpleOps, CDDraw, CDEvents, CDBasics, CDOps, CDOrient, CDValue, SymTab
EXPORTS CDOps
SHARES CD  = 
BEGIN
createEvent: CDEvents.EventRegistration=CDEvents.RegisterEventType[$CreateNewDesign];
resetDesignEvent: CDEvents.EventRegistration=CDEvents.RegisterEventType[$ResetDesign];

DelRec: TYPE = RECORD [
delayedList: LIST OF Remember_NIL,
length: INT _ 0
];

GetDelRec: PROC [design: CD.Design] RETURNS [REF DelRec] =
BEGIN
x: REF _ CDValue.Fetch[boundTo: design, key: $CDxDeleted, propagation: design];
IF x#NIL AND ISTYPE[x, REF DelRec] THEN RETURN [NARROW[x]]
ELSE {
dr: REF DelRec = NEW[DelRec_[NIL]];
CDValue.Store[design, $CDxDeleted, dr];
 RETURN [dr]
}
END;

Remember: TYPE = RECORD [area: CD.Rect, clear: BOOL];

InternalResetDesign: PROC[design: CD.Design] = 
BEGIN
dummy: CD.Object _ CDCells.CreateEmptyCell[];
dummy.size _ CDBasics.highposition;
design.cellDirectory _ SymTab.Create[101];
design^.actual _ LIST[CD.PushRec[
dummyCell: CDInstances.NewInstance[ob: dummy],
mightReplace: NIL,
specific: NARROW[dummy.specificRef]
]];
END;

CreateDesign: PUBLIC PROC [technology: CD.Technology] RETURNS [design: CD.Design] =
BEGIN
IF technology=NIL THEN ERROR CD.Error[callingError, "NIL technology"];
design _ NEW[CD.DesignRec];
design.technology _ technology;  
InternalResetDesign[design]; -- must not cause redraw since event not yet processed
[] _ CDEvents.ProcessEvent[createEvent, design]; 
END;

ResetDesign: PUBLIC PROC [design: CD.Design] =
BEGIN
InternalResetDesign[design];
[] _ CDEvents.ProcessEvent[resetDesignEvent, design]; 
CDValue.Store[design, $CDxDeleted, NIL];
Redraw[design];
END;

RemoveInstance: PUBLIC PROC [design: CD.Design, inst: CD.Instance, draw: BOOL_TRUE] =
BEGIN
il: CD.InstanceList _ CDOps.InstList[design];
IF il#NIL THEN 
IF il.first=inst THEN CDOps.SetInstList[design, il.rest]
ELSE
FOR l: CD.InstanceList _ il, l.rest WHILE l.rest#NIL DO
IF l.rest.first=inst THEN {l.rest_l.rest.rest; EXIT}
ENDLOOP;
IF draw THEN DelayedRedraw[design, CDInstances.InstRectO[inst]];
END;

SelectNewMode: PROC[design: CD.Design] RETURNS [BOOL] =
BEGIN
mode: INT = CDValue.FetchInt[boundTo: design, key: $CDxSelectNewMode, propagation: technology, ifNotFound: 0];
RETURN [mode=1]
END;

AddAnObject: PUBLIC PROC[design: CD.Design, ob: CD.Object, location: CD.Position, orientation: CD.Orientation] =
BEGIN
inst: CD.Instance;
IF ob#NIL THEN {
inst _ CDInstances.NewInstance[
ob: ob, 
location: location, 
orientation: orientation 
];
IF SelectNewMode[design] THEN {
CDSimpleOps.DeselectAll[design];
inst.selected _ TRUE;
};
IncludeInstance[design, inst];
}
END;

IncludeInstance: PUBLIC PROC [design: CD.Design, inst: CD.Instance, draw: BOOL_TRUE] =
BEGIN
IF inst=NIL THEN ERROR CD.Error[callingError, "Include of NIL application"];
IF inst.ob=NIL THEN ERROR CD.Error[callingError, "Include application with NIL object"];
CDOps.SetInstList[design, CONS[inst, CDOps.InstList[design]]];
IF draw THEN DelayedRedraw[design, CDInstances.InstRectO[inst], TRUE];
END;

IncludeInstanceList: PUBLIC PROC [design: CD.Design, il: CD.InstanceList, draw: BOOL_TRUE] =
BEGIN
FOR list: CD.InstanceList _ il, list.rest WHILE list#NIL DO
IncludeInstance[design, list.first, draw];
ENDLOOP;
END;

Redraw: PUBLIC PROC [design: CD.Design, r: CD.Rect_CDOps.all, eraseFirst: BOOL_TRUE] =
BEGIN
CDDraw.InsertCommandAll[design, 
CDDraw.Comm[cmd: rect, erase: eraseFirst, rect: r, ref: NIL]];
END;


CheckForShorten: PROC [dl: REF DelRec] = INLINE {
IF dl.length>20 THEN {
clear: BOOL _ FALSE;
r: CD.Rect _ CDBasics.empty;
FOR lst: LIST OF Remember _ dl.delayedList, lst.rest WHILE lst#NIL DO
clear _ clear OR lst.first.clear;
r _ CDBasics.Surround[r, lst.first.area]
ENDLOOP;
dl.delayedList _ LIST[Remember[area: r, clear: clear]];
dl.length _ 1
};
};

DelayedRedraw: PUBLIC ENTRY PROC [design: CD.Design, r: CD.Rect, eraseFirst: BOOL_TRUE] =
BEGIN
ENABLE UNWIND => NULL;
IF design#NIL THEN {
dl: REF DelRec = GetDelRec[design];
IF dl.delayedList=NIL THEN {
dl.delayedList _  LIST[Remember[area: r, clear: eraseFirst]];
dl.length _ 1
}
ELSE {
list: LIST OF Remember _ dl.delayedList;
DO
IF CDBasics.Intersect[list.first.area, r] THEN {
IF CDBasics.Inside[r, list.first.area] THEN { 
list.first.clear _ list.first.clear OR eraseFirst;
RETURN
}
ELSE IF CDBasics.Inside[list.first.area, r] THEN {
remember: LIST OF Remember _ list;
eraseFirst _ list.first.clear OR eraseFirst;
list.first.area _ r;
WHILE list.rest#NIL DO
IF CDBasics.Inside[list.rest.first.area, r] THEN {
eraseFirst _ list.rest.first.clear OR eraseFirst;
list.rest _ list.rest.rest; --does not change list -> keeps assertion3
dl.length _ dl.length-1;
}
ELSE list _ list.rest --since list.rest#NIL -> keeps assertion3
ENDLOOP;
remember.first.clear _ eraseFirst;
RETURN
}
};
IF list.rest#NIL THEN list_list.rest
ELSE {
list.rest _ LIST[Remember[area: r, clear: eraseFirst]];
dl.length _ dl.length+1;
CheckForShorten[dl];
RETURN
}
ENDLOOP;
} --of dl.delayedList#NIL
} --of design#NIL
END;

DoTheDelayedRedraws: PUBLIC ENTRY PROC [design: CD.Design] =
BEGIN
ENABLE UNWIND => NULL;
sq: REF DelRec = GetDelRec[design];
UNTIL sq.delayedList=NIL DO
CDDraw.InsertCommandAll[design, CDDraw.Comm[
cmd: rect, 
erase: sq.delayedList.first.clear, 
rect: sq.delayedList.first.area, 
ref: NIL
]];
sq.delayedList _ sq.delayedList.rest
ENDLOOP;
sq.length _ 0;
END;

DrawDesign: PUBLIC PROC[design: CD.Design, pr: CD.DrawRef] =
BEGIN
FOR w: LIST OF CD.PushRec _ design^.actual, w.rest WHILE w#NIL DO
IF pr.stopFlag^ THEN EXIT;
pr.drawChild[w.first.dummyCell, [0, 0], CDOrient.original, pr];
ENDLOOP;
END; 

QuickDrawDesign: PUBLIC PROC[design: CD.Design, pr: CD.DrawRef] =
BEGIN

SomeCommon: PROC[ob: CD.Object, pos: CD.Position, orient: CD.Orientation,
pr: CD.DrawRef] RETURNS [BOOLEAN] =
INLINE BEGIN
RETURN CDBasics.Intersect[CDOrient.RectAt[pos, ob.size, orient], pr.interestClip] 
END; 

DrawAndShowSelectionList: PROC [list: CD.InstanceList, pr: CD.DrawRef] =
INLINE BEGIN
FOR w: CD.InstanceList _ list, w.rest WHILE w#NIL DO
IF SomeCommon[w.first.ob, w.first.location, w.first.orientation, pr] THEN
BEGIN
IF pr.stopFlag^ THEN EXIT;
w.first.ob.class.quickDrawMe[w.first, w.first.location, w.first.orientation, pr];
IF w.first.selected THEN
w.first.ob.class.showMeSelected[w.first, w.first.location, w.first.orientation, pr];
END;
ENDLOOP;
END; 

pr.setGround[pr: pr, pushedOut: FALSE];
DrawAndShowSelectionList[CDOps.InstList[design], pr];
IF design^.actual.rest#NIL THEN {
pr.drawOutLine[
CDOrient.MapRect[
itemInCell: design^.actual.first.specific.ir,
cellSize: design^.actual.first.mightReplace.ob.size,
cellInstOrient: design^.actual.first.mightReplace.orientation,
cellInstPos: design^.actual.first.mightReplace.location
],
pr
];
IF pr.environment THEN { 
pr.setGround[pr: pr, pushedOut: TRUE];
FOR w: LIST OF CD.PushRec _ design^.actual.rest, w.rest WHILE w#NIL DO
IF pr.stopFlag^ THEN EXIT;
w.first.dummyCell.ob.class.quickDrawMe[w.first.dummyCell, [0, 0], CDOrient.original, pr];
ENDLOOP;
};
}
END; 

PointedInstance: PUBLIC PROC  [design: CD.Design, pos: CD.Position] 
RETURNS [CD.Instance] =
BEGIN
RETURN [ CDInstances.InstanceAt[CDOps.InstList[design], pos] ];
END;

SelectedInstance: PUBLIC PROC [design: CD.Design] 
RETURNS [first: CD.Instance_NIL, multiple: BOOL_FALSE] =
BEGIN
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF w.first.selected THEN
IF first=NIL THEN first_w.first
ELSE {multiple_TRUE; RETURN}
ENDLOOP;
END;

Info: PUBLIC PROC[ob: CD.Object] RETURNS [Rope.ROPE] =
BEGIN
IF ob=NIL THEN RETURN ["nil object"]
ELSE IF ob.class.describe#NIL THEN RETURN [ob.class.describe[ob]] 
ELSE RETURN [Atom.GetPName[ob.class.objectType]]
END;

LayerName: PUBLIC PROC[lev: CD.Layer] RETURNS [Rope.ROPE] =
BEGIN
uniqueKey: ATOM = CD.LayerKey[lev];
IF uniqueKey=NIL THEN RETURN ["bad layer"]; 
RETURN [Atom.GetPName[uniqueKey]]
END;

ReOrderInstance: PUBLIC PROC [design: CD.Design, inst: CD.Instance] =
BEGIN
il: CD.InstanceList _ CDOps.InstList[design];
found: BOOL _ FALSE;
IF inst=NIL THEN ERROR CD.Error[callingError, "Reorder of NIL application"];
WHILE il#NIL AND il.first=inst DO {found_TRUE; il _ il.rest} ENDLOOP;
IF il=NIL THEN {
IF found THEN il_LIST[inst] 
ELSE ERROR CD.Error[callingError, "Reorder of application not in design"];
}
ELSE 
FOR l: CD.InstanceList _ il, l.rest DO
WHILE l.rest#NIL AND l.rest.first=inst DO {found_TRUE; l.rest _ l.rest.rest} ENDLOOP;
IF l.rest=NIL THEN {
IF found THEN l.rest _ LIST[inst]
ELSE ERROR CD.Error[callingError, "Reorder of application not contained in design"];
EXIT
}
ENDLOOP;
CDOps.SetInstList[design, il];
END;

END. 


VCDOpsImpl.mesa       (part of ChipNDale)
Copyright c 1983, 1985 by Xerox Corporation.  All rights reserved.
by Christian Jacobi,  July 12, 1983 10:56 am 
last edited by Christian Jacobi,  September 2, 1985 1:50:47 pm PDT
--is local since it does not cause a redraw
--ASSERTION1: {list#NIL}
--ASSERTION2: {no list rectangle is completely covered by an other one}
--r is contained somewhere; we dont include it
--it is unlikely that a small area is cleared and a big one not
--assertion2 => no other elements could be removed
--r contains an element; we remove this element and all others
--		which are contained in r
--it is unlikely that a small area is cleared and a big one not
--remove all other element contained in r; to maintain assertion2
assert3: list#NIL
-- drawDesign
--first: returns ref to any selected application if there is one or more, otherwise nil.
--multiple: more than one application is selected
--on return: design has exactly one occurrence of inst, and it is at the end. 
--(includes inst if necessary and removes double occurences)
-- l#NIL AND l.first#inst holds at this point
�Ê
ô˜š
œ(™(Jšœ
Ïm
œ7™BJš
œ-™-Jš
œB™B—J˜š
Ïk	˜	Jš
œ˜Jšžœ
˜J˜Jš
œ˜J˜J˜J˜	Jš
œ	˜	Jš
œ˜J˜	Jš
œ˜Jšœžœžœ˜J˜J˜—šÏn	œžœ
žœ
˜Jšžœžœc˜qJšžœ˜
Jšžœ
žœ˜
—Jš
ž˜J˜UJ˜VJ˜šœžœžœ˜Jšœ
žœ
žœ
žœ
˜"Jšœžœ˜J˜—J˜š
Ÿ	œžœ
žœ	žœžœ
˜:Jš
ž˜JšœžœI˜OJšžœžœ
žœ
žœžœ	žœ
žœžœ˜:šžœ˜Jšœžœ
žœ	žœ˜#Jš
œ'˜'Jšœ
žœ˜J˜
—Jšžœ
˜J˜—Jš	œ
žœžœžœžœ˜5J˜šŸœžœ	žœ˜/Jš
œ+™+Jš
ž˜Jšœžœ$˜-Jš
œ#˜#J˜*šœžœ
žœ	˜!Jš
œ.˜.Jšœžœ
˜Jšœ
žœ˜#J˜—Jšžœ
˜—J˜šŸœžœ
žœžœ
žœ
žœ
˜SJš
ž˜Jš
žœžœ
žœ
žœ
žœ'˜FJšœ	žœ
žœ˜J˜!JšœÏc6˜SJ˜1Jšžœ
˜—J˜šŸœžœ
žœ
žœ
˜.Jš
ž˜Jš
œ˜J˜6Jšœ#žœ˜(Jš
œ˜Jšžœ
˜J˜—šŸœžœ
žœ
žœžœžœ
žœ˜UJš
ž˜Jšœžœ'˜-šžœžœ
žœ
˜Jšžœžœ#˜8š
ž˜š	žœžœžœžœ
ž˜7Jšžœžœžœ
˜4Jšžœ
˜———Jšžœžœ4˜@Jšžœ
˜—J˜š
Ÿ
œžœ	žœ	žœžœ˜7Jš
ž˜Jšœžœe˜nJšžœ	˜Jšžœ
˜—J˜šŸœžœ
žœ	žœ
žœžœžœ˜pJš
ž˜Jšœžœ
˜šžœžœ
žœ˜š
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—šžœžœ˜Jš
œ ˜ Jšœžœ
˜J˜—Jš
œ˜J˜
—Jšžœ
˜J˜—šŸœžœ
žœžœžœ
žœ˜VJš
ž˜Jš
žœžœ
žœ
žœ
žœ3˜LJš
žœ	žœ
žœ
žœ
žœ<˜XJšœžœ ˜>Jšžœžœ4žœ˜FJšžœ
˜—J˜šŸœžœ
žœ
žœ
žœžœ
žœ˜\Jš
ž˜š	žœžœžœžœ
ž˜;Jš
œ*˜*Jš
ž˜—Jšžœ
˜—J˜šŸœžœ
žœ
žœžœžœ
žœ˜VJš
ž˜˜ Jšœ8žœ˜>—Jšžœ
˜J˜—J˜šŸœžœžœžœ˜1šžœžœ˜Jšœžœžœ
˜Jšœžœ˜šžœžœ
žœ%žœžœ
ž˜EJšœžœ˜!Jš
œ(˜(Jšžœ
˜—Jšœžœ"˜7Jš
œ
˜
J˜—J˜—J˜šŸ
œžœ
žœ
žœ
žœžœžœ
žœ˜Yš
ž˜Jšžœ
žœžœ
˜—šžœžœ
žœ˜Jšœžœ˜#šžœžœ
žœ˜Jšœžœ'˜=Jš
œ
˜
Jš
œ
˜
—šžœ˜Jšœžœ
žœ˜(š
ž˜Jš
œ™Jš
œG™Gšžœ(žœ˜0šžœ%žœ˜.J™.Jš
œ?™?Jšœ$žœ˜2Jš
œ2™2Jš
ž˜J˜
—šžœ
žœ%žœ˜2J™>J™Jš
œ?™?Jšœ
žœ
žœ˜"Jšœžœ˜,Jš
œ˜Jš
œA™Ašžœžœ
ž˜Jš
œ™šžœ*žœ˜2Jšœ#žœ˜1Jšœ *˜FJš
œ˜J˜
—Jšžœ )˜?Jšžœ
˜—Jš
œ"˜"Jš
ž˜J˜
—J˜—Jšžœžœ
žœ˜$šžœ˜Jšœžœ'˜7Jš
œ˜Jš
œ˜Jš
ž˜J˜
—Jšžœ
˜—Jšœ ˜—Jšœ ˜—Jšžœ
˜—J˜š
Ÿœžœ
žœ
žœ
žœ
˜<š
ž˜Jšžœ
žœžœ
˜—Jšœžœ˜#šžœžœ
ž˜š
œ,˜,Jš
œ˜Jš
œ#˜#Jš
œ!˜!Jšœž˜Jš
œ˜—Jš
œ$˜$Jšžœ
˜—Jš
œ˜Jšžœ
˜—J˜š
Ÿ
œžœ
žœ	žœ
žœ˜<Jš
ž˜š
žœžœ
žœ
žœ"žœžœ
ž˜AJšžœžœ
žœ
˜Jš
œ?˜?Jšžœ
˜—Jšžœ˜J˜—š
Ÿœžœ
žœ	žœ
žœ˜AJš
ž˜J˜š
Ÿ
œžœžœžœžœ
˜IJšœžœ
žœžœ˜#šžœ
ž˜JšžœL˜R—Jšžœ˜—J˜šŸœžœžœžœ˜HJš
ž˜š	žœžœžœžœ
ž˜4šžœCž˜IJš
ž˜Jšžœžœ
žœ
˜J˜Qšžœž˜J˜T—Jšžœ
˜—Jšžœ
˜—Jšžœ˜—J˜Jš
œ
™
Jšœ žœ˜'Jš
œ5˜5šžœžœ
žœ˜!š
œ˜š
œ˜Jš
œ-˜-Jš
œ4˜4Jš
œ>˜>Jš
œ7˜7Jš
œ˜—J˜J˜—šžœžœ˜Jšœ žœ˜&š
žœžœ
žœ
žœ'žœžœ
ž˜FJšžœžœ
žœ
˜J˜YJšžœ
˜—J˜—J˜
—Jšžœ˜J˜—š
Ÿœžœ
žœžœžœ˜DJšžœžœ˜Jš
ž˜Jšžœ9˜?Jšžœ
˜—J˜šŸœžœ
žœ	˜2šžœ	žœž
œ˜8Jš
œX™XJš
œ1™1—Jš
ž˜š	žœžœ/žœžœ
ž˜Fšžœž˜Jšžœžœ
žœ˜Jšžœžœžœ
˜—Jšžœ
˜—Jšžœ
˜J˜—šŸœžœ
žœžœ	žœžœ˜6Jš
ž˜Jšžœžœ
žœ
žœ˜$Jš
žœ
žœžœ
žœ
žœ˜BJšžœ
žœ%˜0Jšžœ
˜—J˜šŸ	œžœ
žœžœžœžœ˜;Jš
ž˜Jšœžœžœ˜#Jšžœžœ
žœ
žœ˜,Jšžœ˜!Jšžœ
˜—J˜š
Ÿœžœ
žœ
žœžœ˜EJš
œN™NJ™<Jš
ž˜Jšœžœ'˜-Jšœžœžœ
˜Jš
žœžœ
žœ
žœ
žœ3˜LJšžœžœ
žœžœžœžœ
˜Ešžœžœ
žœ˜Jšžœžœžœ˜Jšžœ
žœ
žœ=˜JJ˜
—šžœ
˜šžœžœž˜&Jš
œ-™-Jšžœžœ
žœžœžœžœ
˜Ušžœžœ
žœ˜Jšžœžœ
žœ˜!Jšžœ
žœ
žœG˜TJš
ž˜Jš
œ
˜
—Jšžœ
˜——Jš
œ˜Jšžœ
˜—J˜Jšžœ˜J˜J˜—…—"D4Ž