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

CDOpsImpl: CEDAR MONITOR 
IMPORTS Atom, CD, CDApplications, 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.DesignRect, clear: BOOL];

InternalResetDesign: PROC[design: CD.Design] = 
BEGIN
dummy: CD.ObPtr _ CDCells.CreateEmptyCell[];
dummy.size _ CDBasics.highposition;
design.cellDirectory _ SymTab.Create[97];
design^.actual _ LIST[CD.PushRec[
dummyCell: CDApplications.NewApplicationI[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;

RemoveApplication: PUBLIC PROC [design: CD.Design, aptr: CD.ApplicationPtr, draw: BOOL_TRUE] =
BEGIN
al: CD.ApplicationList _ CDOps.AppList[design];
IF al#NIL THEN 
IF al.first=aptr THEN CDOps.SetAppList[design, al.rest]
ELSE
FOR l: CD.ApplicationList _ al, l.rest WHILE l.rest#NIL DO
IF l.rest.first=aptr THEN {l.rest_l.rest.rest; EXIT}
ENDLOOP;
IF draw THEN DelayedRedraw[design, CDApplications.ARectO[aptr]];
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.ObPtr, location: CD.DesignPosition, orientation: CD.Orientation] =
BEGIN
aptr: CD.ApplicationPtr;
IF ob#NIL THEN {
aptr _ CDApplications.NewApplicationI[
ob: ob, 
location: location, 
orientation: orientation 
];
IF SelectNewMode[design] THEN {
CDSimpleOps.DeselectAll[design];
aptr.selected _ TRUE;
};
IncludeApplication[design, aptr];
}
END;

IncludeApplication: PUBLIC PROC [design: CD.Design, aptr: CD.ApplicationPtr, draw: BOOL_TRUE] =
BEGIN
IF aptr=NIL THEN ERROR CD.Error[callingError, "Include of NIL application"];
IF aptr.ob=NIL THEN ERROR CD.Error[callingError, "Include application with NIL object"];
CDOps.SetAppList[design, CONS[aptr, CDOps.AppList[design]]];
IF draw THEN DelayedRedraw[design, CDApplications.ARectO[aptr], TRUE];
END;

IncludeApplicationList: PUBLIC PROC [design: CD.Design, al: CD.ApplicationList, draw: BOOL_TRUE] =
BEGIN
FOR list: CD.ApplicationList _ al, list.rest WHILE list#NIL DO
IncludeApplication[design, list.first, draw];
ENDLOOP;
END;

Redraw: PUBLIC PROC [design: CD.Design, r: CD.DesignRect_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.DesignRect _ 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.DesignRect, 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;

PrepareDepht: PROC [design: CD.Design, pr: CD.DrawRef] RETURNS [depht: INT_0] = INLINE
BEGIN
d: INT;
FOR w: LIST OF CD.PushRec _ design^.actual, w.rest WHILE w#NIL DO
depht _ depht+1;
ENDLOOP;
d _ depht;
FOR w: LIST OF CD.PushRec _ design^.actual, w.rest WHILE w#NIL DO
d _ d-1;
pr.nesting.table[d] _ w.first.dummyCell;
ENDLOOP;
END;

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

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

SomeCommon: PROC[ob: CD.ObPtr, pos: CD.DesignPosition, 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.ApplicationList, pr: CD.DrawRef] =
BEGIN
FOR w: CD.ApplicationList _ 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.p.quickDrawMe[w.first, w.first.location, w.first.orientation, pr];
IF w.first.selected THEN
w.first.ob.p.showMeSelected[w.first, w.first.location, w.first.orientation, pr];
END;
ENDLOOP;
END; 

depht: INT _ PrepareDepht[design, pr];
pr.nestDepth _ depht;
pr.setGround[pr: pr, pushedOut: FALSE];
DrawAndShowSelectionList[CDOps.AppList[design], 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;
depht _ depht-1;
pr.nestDepth _ depht;
w.first.dummyCell.ob.p.quickDrawMe[w.first.dummyCell, [0, 0], CDOrient.original, pr];
ENDLOOP;
}
END; 

PointedApplication: PUBLIC PROC  [design: CD.Design, pos: CD.DesignPosition] 
RETURNS [CD.ApplicationPtr] =
BEGIN
RETURN [ CDApplications.AplicationAt[CDOps.AppList[design], pos] ];
END;

SelectedApplication: PUBLIC PROC [design: CD.Design] 
RETURNS [first: CD.ApplicationPtr_NIL, multiple: BOOL_FALSE] =
BEGIN
FOR w: CD.ApplicationList _ CDOps.AppList[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.ObPtr] RETURNS [Rope.ROPE] =
BEGIN
IF ob=NIL THEN RETURN ["nil object"]
ELSE IF ob.p.describe#NIL THEN RETURN [ob.p.describe[ob]] 
ELSE RETURN [Atom.GetPName[ob.p.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;

ReOrderApplication: PUBLIC PROC [design: CD.Design, aptr: CD.ApplicationPtr] =
BEGIN
al: CD.ApplicationList _ CDOps.AppList[design];
found: BOOL _ FALSE;
IF aptr=NIL THEN ERROR CD.Error[callingError, "Reorder of NIL application"];
WHILE al#NIL AND al.first=aptr DO {found_TRUE; al _ al.rest} ENDLOOP;
IF al=NIL THEN {
IF found THEN al_LIST[aptr] 
ELSE ERROR CD.Error[callingError, "Reorder of application not in design"];
}
ELSE 
FOR l: CD.ApplicationList _ al, l.rest DO
WHILE l.rest#NIL AND l.rest.first=aptr DO {found_TRUE; l.rest _ l.rest.rest} ENDLOOP;
IF l.rest=NIL THEN {
IF found THEN l.rest _ LIST[aptr]
ELSE ERROR CD.Error[callingError, "Reorder of application not contained in design"];
EXIT
}
ENDLOOP;
CDOps.SetAppList[design, al];
END;

END. 


ˆCDOpsImpl.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,  April 11, 1985 3:22:55 pm PST
Last Edited by: Beretta, July 1, 1985 4:20:10 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 aptr, and it is at the end. 
--(includes aptr if necessary and removes double occurences)
-- l#NIL AND l.first#aptr holds at this point
�Ê‹˜š
œ(™(Jšœ
Ïm
œ7™BJš
œ-™-Jš
œ?™?—J™4J˜š
Ïk	˜	Jš
œ˜Jšžœ
˜J˜Jš
œ˜J˜J˜J˜	Jš
œ	˜	Jš
œ˜J˜	Jš
œ˜Jšœžœžœ˜J˜J˜—šÏn	œžœ
žœ
˜Jšžœžœf˜tJšžœ˜
Jšžœ
žœ˜
—Jš
ž˜J˜UJ˜VJ˜šœžœžœ˜Jšœ
žœ
žœ
žœ
˜"Jšœžœ˜J˜—J˜š
Ÿ	œžœ
žœ	žœžœ
˜:Jš
ž˜JšœžœI˜OJšžœžœ
žœ
žœžœ	žœ
žœžœ˜:šžœ˜Jšœžœ
žœ	žœ˜#Jš
œ'˜'Jšœ
žœ˜J˜
—Jšžœ
˜J˜—Jš	œ
žœžœžœžœ˜;J˜šŸœžœ	žœ˜/Jš
œ+™+Jš
ž˜Jšœžœ#˜,Jš
œ#˜#J˜)šœžœ
žœ	˜!Jš
œ5˜5Jšœžœ
˜Jšœ
žœ˜#J˜—Jšžœ
˜—J˜šŸœžœ
žœžœ
žœ
žœ
˜SJš
ž˜Jš
žœžœ
žœ
žœ
žœ'˜FJšœ	žœ
žœ˜J˜!JšœÏc6˜SJ˜1Jšžœ
˜—J˜šŸœžœ
žœ
žœ
˜.Jš
ž˜Jš
œ˜J˜6Jšœ#žœ˜(Jš
œ˜Jšžœ
˜J˜—šŸœžœ
žœ
žœžœžœ
žœ˜^Jš
ž˜Jšœžœ)˜/šžœžœ
žœ
˜Jšžœžœ"˜7š
ž˜š	žœžœžœžœ
ž˜:Jšžœžœžœ
˜4Jšžœ
˜———Jšžœžœ4˜@Jšžœ
˜—J˜š
Ÿ
œžœ	žœ	žœžœ˜7Jš
ž˜Jšœžœe˜nJšžœ	˜Jšžœ
˜—J˜šŸœžœ
žœ	žœ
žœžœžœ˜uJš
ž˜Jšœžœ˜šžœžœ
žœ˜š
œ&˜&Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—šžœžœ˜Jš
œ ˜ Jšœžœ
˜J˜—Jš
œ!˜!J˜
—Jšžœ
˜J˜—šŸœžœ
žœžœžœ
žœ˜_Jš
ž˜Jš
žœžœ
žœ
žœ
žœ3˜LJš
žœ	žœ
žœ
žœ
žœ<˜XJšœžœ˜<Jšžœžœ4žœ˜FJšžœ
˜—J˜šŸœžœ
žœ
žœ
žœžœ
žœ˜bJš
ž˜š	žœžœ!žœžœ
ž˜>Jš
œ-˜-Jš
ž˜—Jšžœ
˜—J˜šŸœžœ
žœ
žœžœ#žœ
žœ˜\Jš
ž˜˜ Jšœ8žœ˜>—Jšžœ
˜J˜—J˜šŸœžœžœžœ˜1šžœžœ˜Jšœžœžœ
˜Jšœžœ˜"šžœžœ
žœ%žœžœ
ž˜EJšœžœ˜!Jš
œ(˜(Jšžœ
˜—Jšœžœ"˜7Jš
œ
˜
J˜—J˜—J˜šŸ
œžœ
žœ
žœ
žœžœžœ
žœ˜_š
ž˜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˜š
Ÿœžœ
žœ
žœ
žœ	žœž˜VJš
ž˜Jšœžœ
˜š
žœžœ
žœ
žœ"žœžœ
ž˜AJš
œ˜Jšžœ
˜—Jš
œ
˜
š
žœžœ
žœ
žœ"žœžœ
ž˜AJš
œ˜Jš
œ(˜(Jšžœ
˜—Jšžœ
˜J˜—š
Ÿ
œžœ
žœ	žœ
žœ˜<Jš
ž˜Jšœžœ˜&š
žœžœ
žœ
žœ"žœžœ
ž˜AJšžœžœ
žœ
˜Jš
œ˜Jš
œ?˜?Jš
œ˜Jšžœ
˜—Jšžœ˜J˜—š
Ÿœžœ
žœ	žœ
žœ˜AJš
ž˜J˜š
Ÿ
œžœžœ
žœžœ
˜NJšœžœ
žœžœ˜#šžœ
ž˜JšžœL˜R—Jšžœ˜—J˜šŸœžœžœžœ˜KJš
ž˜š	žœžœ žœžœ
ž˜7šžœCž˜IJš
ž˜Jšžœžœ
žœ
˜J˜Mšžœž˜J˜P—Jšžœ
˜—Jšžœ
˜—Jšžœ˜—J˜Jš
œ
™
Jšœžœ˜&Jš
œ˜Jšœ žœ˜'Jš
œ4˜4šžœžœ˜Jšœ žœ˜&š
žœžœ
žœ
žœ'žœžœ
ž˜FJšžœžœ
žœ
˜Jš
œ˜Jš
œ˜J˜UJšžœ
˜—J˜
—Jšžœ˜J˜—š
Ÿœžœ
žœžœžœ˜MJšžœžœ˜Jš
ž˜Jšžœ=˜CJšžœ
˜—J˜šŸœžœ
žœ	˜5šžœ	žœž
œ˜>Jš
œX™XJš
œ1™1—Jš
ž˜š	žœžœ1žœžœ
ž˜Hšžœž˜Jšžœžœ
žœ˜Jšžœžœžœ
˜—Jšžœ
˜—Jšžœ
˜J˜—šŸœžœ
žœžœžœžœ˜5Jš
ž˜Jšžœžœ
žœ
žœ˜$Jš
žœ
žœžœ
žœ
žœ˜:Jšžœ
žœ!˜,Jšžœ
˜—J˜šŸ	œžœ
žœžœžœžœ˜;Jš
ž˜Jšœžœžœ˜#Jšžœžœ
žœ
žœ˜,Jšžœ˜!Jšžœ
˜—J˜š
Ÿœžœ
žœ
žœžœ˜NJš
œ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˜
—…—#ˆ6›