<> <> <> <> 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] = <<--is local since it does not cause a redraw>> 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 <<--ASSERTION1: {list#NIL}>> <<--ASSERTION2: {no list rectangle is completely covered by an other one}>> IF CDBasics.Intersect[list.first.area, r] THEN { IF CDBasics.Inside[r, list.first.area] THEN { <<--r is contained somewhere; we dont include it>> <<--it is unlikely that a small area is cleared and a big one not>> list.first.clear _ list.first.clear OR eraseFirst; <<--assertion2 => no other elements could be removed>> RETURN } ELSE IF CDBasics.Inside[list.first.area, r] THEN { <<--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>> remember: LIST OF Remember _ list; eraseFirst _ list.first.clear OR eraseFirst; list.first.area _ r; <<--remove all other element contained in r; to maintain assertion2>> 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; <<-- drawDesign>> 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] = <<--first: returns ref to any selected application if there is one or more, otherwise nil.>> <<--multiple: more than one application is selected>> 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] = <<--on return: design has exactly one occurrence of inst, and it is at the end. >> <<--(includes inst if necessary and removes double occurences)>> 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 <<-- l#NIL AND l.first#inst holds at this point>> 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.