DIRECTORY
CD, 
CDApplications,
CDCallSpecific,
CDCells,
CDDirectory,
CDEvents,
CDInline,
CDIO,
CDMarks,
CDOps,
CDOrient,
CDProperties,
Rope,
TokenIO,
TerminalIO;

CDCellsImpl: CEDAR MONITOR 
IMPORTS CD, CDApplications, CDCallSpecific, CDIO, CDDirectory, CDEvents, CDInline, CDMarks, CDOps, CDOrient, CDProperties, Rope, TokenIO, TerminalIO
EXPORTS CDCells
SHARES CDDirectory = 
BEGIN

-- -- -- -- -- -- -- -- -- -- -- --

pForCells: REF CD.ObjectProcs ~ CD.RegisterObjectType[$Cell];
beforeReplacement: CDEvents.EventRegistration
~ CDEvents.RegisterEventType[$BeforeCellReplacement];
afterReplacement: CDEvents.EventRegistration
~ CDEvents.RegisterEventType[$AfterCellReplacement];
pushEvent: CDEvents.EventRegistration ~ CDEvents.RegisterEventType[$AfterPush];
popEvent: CDEvents.EventRegistration ~ CDEvents.RegisterEventType[$AfterPop];

Init: PROC [] =
BEGIN
dp: REF CDDirectory.DirectoryProcs ~ CDDirectory.InstallDirectoryProcs[pForCells];
dp.enumerateChildObjects _ EnumerateChildObjects;
dp.adjustItself _ AdjustItself;
dp.repositionElements _ RepositionElements;
dp.computeBounds _ ComputeBounds;
dp.key _ Key;
dp.name _ Name;
dp.setName _ SetName;
pForCells.drawMe _ DrawMeForCells;
pForCells.quickDrawMe _ QuickDrawMeForCells;
pForCells.showMeSelected _ DrawCellSelection;
pForCells.internalRead _ ReadCell;
pForCells.internalWrite _ WriteCell;
pForCells.describe _ Describe;
CDCallSpecific.Register[$Expand, pForCells, Expand];
END; 

SetName: PROC [me: CD.ObPtr, r: Rope.ROPE] =
BEGIN
cptr: CD.CellPtr = NARROW[me.specificRef];
cptr.name _ r
END;

Name: PROC [me: CD.ObPtr] RETURNS [Rope.ROPE] =
BEGIN
cptr: CD.CellPtr = NARROW[me.specificRef];
RETURN [cptr.name]
END;

Key: PROC [me: CD.ObPtr] RETURNS [Rope.ROPE] =
BEGIN
cptr: CD.CellPtr = NARROW[me.specificRef];
RETURN [cptr.key]
END;

EnumerateChildObjects: PROC [me: CD.ObPtr, p: CDDirectory.EnumerateObjectsProc, x: REF] = 
BEGIN
cptr: CD.CellPtr = NARROW[me.specificRef];
FOR w: CD.ApplicationList _ cptr.contents, w.rest WHILE w#NIL DO
p[w.first.ob, x]
ENDLOOP
END;

DrawMeForCells: PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation,
pr: CD.DrawRef] =
BEGIN
ENABLE UNWIND => IF pr.nesting.first=aptr THEN pr.nesting _ pr.nesting.rest;
cptr: CD.CellPtr ~ NARROW[aptr.ob.specificRef];
r: CD.DesignRect;
pr.nesting _ CONS[aptr, pr.nesting];
FOR w: CD.ApplicationList _ cptr.contents, w.rest WHILE w#NIL DO
r _ CDOrient.MapRect[
itemInCell: CDOrient.RectAt[w.first.location, w.first.ob.size, w.first.orientation],  
cellSize: aptr.ob.size, 
cellInstOrient: orient,
cellInstPos: pos];
IF CDInline.Intersect[r, pr.worldClip] THEN {
o: CD.Orientation ~ CDOrient.ComposeOrient[w.first.orientation, orient];
IF pr.stopFlag^ THEN EXIT;
pr.drawChild[w.first, CDInline.BaseOfRect[r], o, pr];
}
ENDLOOP;
IF pr.nesting.first=aptr THEN pr.nesting _ pr.nesting.rest
END; 

QuickDrawMeForCells: PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation,
pr: CD.DrawRef] =
BEGIN
ENABLE UNWIND => IF pr.nesting.first=aptr THEN pr.nesting _ pr.nesting.rest;
cptr: CD.CellPtr ~ NARROW[aptr.ob.specificRef];
r: REAL;
IF (r _ pr.scaleHint*aptr.ob.size.y)<cptr.simplifyOn AND pr.scaleHint>0 THEN { 
pr.outLineProc[CDOrient.RectAt[pos, aptr.ob.size, orient], pr];
IF r>9 THEN pr.drawComment[CDOrient.RectAt[pos, aptr.ob.size, orient], cptr.name, pr];
}
ELSE {
r: CD.DesignRect;
pr.nesting _ CONS[aptr, pr.nesting];
FOR w: CD.ApplicationList _ cptr.contents, w.rest WHILE w#NIL DO
r _ CDOrient.MapRect[
itemInCell: CDOrient.RectAt[w.first.location, w.first.ob.size, w.first.orientation],  
cellSize: aptr.ob.size, 
cellInstOrient: orient,
cellInstPos: pos];
IF CDInline.Intersect[r, pr.worldClip] THEN {
o: CD.Orientation ~ CDOrient.ComposeOrient[w.first.orientation, orient];
IF pr.stopFlag^ THEN EXIT;
w.first.ob.p.quickDrawMe[w.first, CDInline.BaseOfRect[r], o, pr];
}
ENDLOOP;
IF pr.nesting.first=aptr THEN pr.nesting _ pr.nesting.rest
}
END; 

DrawCellSelection: PROC [aptr: CD.ApplicationPtr, pos: CD.DesignPosition, orient: CD.Orientation,
pr: CD.DrawRef] =
BEGIN
IF (pr.scaleHint*aptr.ob.size.y)<NARROW[aptr.ob.specificRef, CD.CellPtr].simplifyOn 
AND pr.scaleHint>0 THEN pr.drawRect[CDOrient.RectAt[pos, aptr.ob.size, orient], CD.highLightShade, pr]
ELSE pr.outLineProc[CDOrient.RectAt[pos, aptr.ob.size, orient], pr]
END; 

RemoveSelectedFromWorld: PROC [design: CD.Design] RETURNS [CD.ApplicationList] =
BEGIN
remove, keep: CD.ApplicationList _ NIL;
[others: keep, selected: remove] _ CDApplications.SplitSelected[CDOps.AppList[design]];
CDOps.SetAppList[design, keep];
RETURN [remove]
END;

CreateEmptyCell: PUBLIC PROC [] RETURNS [CD.ObPtr] =
BEGIN
ob: CD.ObPtr ~ NEW[CD.ObjectDefinition];
cp: CD.CellPtr ~ NEW[CD.CellRecord];
ob.p _ pForCells;
ob.size _ CDInline.highposition;
ob.specificRef _ cp;
cp.simplifyOn _ 50;
RETURN [ob]
END;

CreateCellObject: PROC [use: CD.ApplicationList, orient: CD.Orientation_CDOrient.original] RETURNS [CD.ObPtr] =
BEGIN
ob: CD.ObPtr ~ CreateEmptyCell[];
cp: CD.CellPtr ~ NARROW[ob.specificRef];
b: CD.DesignRect ~ CDApplications.BoundingRect[use]; -- coordsys of use, non oriented
ob.size _ CDOrient.OrientedSize[CDInline.SizeOfRect[b], orient];
cp.name _ NIL;
cp.contents _ CDApplications.DeComposedCopy[use, CDInline.BaseOfRect[b], ob.size, orient];
RETURN [ob]
END;

IncludeAndNameCell: PROC [design: CD.Design, cp: CD.ObPtr] =
BEGIN
aborted: BOOL _ FALSE;
name: Rope.ROPE;
cptr: CD.CellPtr ~ NARROW[cp.specificRef];
DO 
ENABLE TerminalIO.UserAbort => {aborted _ TRUE; CONTINUE};
IF aborted THEN {
name _ "-no name";
TerminalIO.WriteRope[" **name input aborted\n"];
}
ELSE name _ TerminalIO.RequestRope["enter name for cell: "];
IF CDDirectory.Include[design: design, object: cp, alternateName: name, fiddleName: aborted OR Rope.IsEmpty[name]] THEN { 
TerminalIO.WriteRope["Cell "]; TerminalIO.WriteRope[cptr.name]; 
TerminalIO.WriteRope[" included\n"];
RETURN;
};
TerminalIO.WriteRope["Cell "]; TerminalIO.WriteRope[cptr.name]; 
TerminalIO.WriteRope[" does already exist\n"];
TerminalIO.WriteRope["name not accepted, please repeat\n"];
aborted _ FALSE;
ENDLOOP;
END;

CreateCellSelected: PUBLIC PROC [design: CD.Design, name: Rope.ROPE_NIL] 
RETURNS [done: BOOL, cellOb: CD.ObPtr] =
BEGIN
sel: CD.ApplicationList ~ RemoveSelectedFromWorld[design];
app: CD.ApplicationPtr ~ NEW[CD.Application];
b: CD.DesignRect ~ CDApplications.BoundingRect[sel];
cptr: CD.CellPtr;
app.ob _ cellOb _ CreateCellObject[use: sel];
cptr _ NARROW[cellOb.specificRef];
cptr.name _ name;
app.location _ CDInline.BaseOfRect[b];
app.selected _ TRUE;
IF NOT CDInline.NonEmpty[b] THEN {
TerminalIO.WriteRope["no empty cell\n"]; 
RETURN [done: FALSE, cellOb: NIL]
};
IF name=NIL THEN IncludeAndNameCell[design, cellOb]
ELSE [] _ CDDirectory.Include[design, cellOb];
CDOps.IncludeApplication[design, app, TRUE]; -- redraw removes seletion
RETURN [done: TRUE, cellOb: cellOb]
END;

IsCell: PROC [aptr: CD.ApplicationPtr] RETURNS [yes: BOOL _ FALSE] =
BEGIN
IF aptr=NIL THEN TerminalIO.WriteRope[" no object\n"] 
ELSE IF aptr.ob=NIL OR aptr.ob.specificRef=NIL THEN TerminalIO.WriteRope[" bad object\n"] 
ELSE IF NOT ISTYPE[aptr.ob.specificRef, CD.CellPtr] THEN {
TerminalIO.WriteRope[" object is not cell but "];
TerminalIO.WriteRope[CDOps.Info[aptr.ob]];
TerminalIO.WriteLn[];
}
ELSE yes_TRUE
END;

PushInCellSelected: PUBLIC PROC [design: CD.Design] RETURNS [done: BOOL _ FALSE] =
BEGIN
first: CD.ApplicationPtr;
multiple: BOOL;
[first, multiple] _ CDOps.SelectedApplication[design];
IF multiple THEN TerminalIO.WriteRope[" multiple selected object\n"] 
ELSE done _ DoPushInCell[design, first];
END;

PushInCellPointed: PUBLIC PROC [design: CD.Design, pos: CD.DesignPosition] RETURNS [done: BOOL _ FALSE] =
BEGIN
done _ DoPushInCell[design, CDOps.PointedApplication[design, pos]]
END;

DoPushInCell: PROC [design: CD.Design, originalApp: CD.ApplicationPtr] 
RETURNS [done: BOOL_FALSE] =
BEGIN
IF IsCell[originalApp] THEN {
cptr: CD.CellPtr ~ NARROW[originalApp.ob.specificRef];
dummy: CD.ObPtr ~ CreateEmptyCell[];
newCptr: CD.CellPtr ~ NARROW[dummy.specificRef];
dummyCellAp: CD.ApplicationPtr;
FOR l: LIST OF CD.PushRec _ design.actual, l.rest WHILE l#NIL DO
IF l.first.mightReplace#NIL AND l.first.mightReplace.ob=originalApp.ob THEN {
TerminalIO.WriteRope[" push not possible; [already pushed in "]; 
TerminalIO.WriteRope[CDOps.Info[l.first.mightReplace.ob]];
TerminalIO.WriteRope["]\n"];
RETURN [FALSE]
}
ENDLOOP;
newCptr.name _ cptr.name;
newCptr.contents _ CDApplications.ComposedCopy[
al: cptr.contents, 
cellPos: originalApp.location, 
cellSize: originalApp.ob.size, 
cellOrient: originalApp.orientation
];
dummyCellAp _ CDApplications.NewApplicationI[
ob: dummy, 
properties: CDProperties.CopyProps[originalApp.properties]
];
dummy.properties _ CDProperties.CopyProps[originalApp.ob.properties];
CDOps.RemoveApplication[design, originalApp]; 
design^.actual _ CONS[
CD.PushRec[dummyCell: dummyCellAp, specific: newCptr, mightReplace: originalApp], 
design^.actual];
[] _ CDEvents.ProcessEvent[pushEvent, design];
RETURN [TRUE];
}
END;

PopFromCell: PUBLIC PROC [design: CD.Design, 
m: CDCells.Method_interactive, name: Rope.ROPE_NIL] 
RETURNS [done: BOOL] =
BEGIN
done _ IPopFromCell[design, m, name];
IF done THEN [] _ CDEvents.ProcessEvent[popEvent, design];
END;

IPopFromCell: PROC [design: CD.Design, m: CDCells.Method, name: Rope.ROPE] 
RETURNS [done: BOOL_FALSE] =
BEGIN
c: CARDINAL;
currentRect, pushedRect: CD.DesignRect;
currentAptr, pushedAptr: CD.ApplicationPtr;
currentCellOb: CD.ObPtr;
currentCellPtr, pushedCellPtr: CD.CellPtr;
recursive: BOOL_FALSE;

DoFlush: PROC [] =
BEGIN
b: BOOL _ design^.actual.first.indirectlyChanged;
TerminalIO.WriteRope["flush\n"];
design^.actual _ design^.actual.rest;
design^.actual.first.indirectlyChanged _ TRUE;
IF b THEN design^.actual.first.indirectlyChanged _ TRUE;
CDOps.IncludeApplication[design, pushedAptr, FALSE];
END;

DoReplace: PROC [] =
BEGIN
p: CD.Properties;
[] _ CDEvents.ProcessEvent[beforeReplacement, design, pushedAptr.ob];
TerminalIO.WriteRope["replace\n"];
p _ currentCellOb.properties;
CDProperties.PutPropOnObject[onto: currentCellOb, prop: $Owner, val: design];
p _ currentCellOb.properties;
currentAptr.ob _ pushedAptr.ob;
currentAptr.ob.properties _ p;
design^.actual _ design^.actual.rest;
design^.actual.first.indirectlyChanged _ TRUE;
pushedCellPtr.contents _ currentCellPtr.contents;
IF pushedRect#currentRect THEN { -- both in design coordinates
newRectInPushedCellCoords: CD.DesignRect ~ CDOrient.DeMapRect[
itemInWorld: currentRect, 
cellSize: CDOrient.OrientedSize[CDInline.SizeOfRect[pushedRect],
pushedAptr.orientation],
cellInstOrient: pushedAptr.orientation, 
cellInstPos: pushedAptr.location];
CDApplications.TranslateList[currentCellPtr.contents,
CDInline.BaseOfRect[newRectInPushedCellCoords]];
CDDirectory.RepositionAnObject[design, currentAptr.ob];
};
design^.actual.first.indirectlyChanged _ TRUE;
CDOps.IncludeApplication[design, currentAptr, FALSE];
[] _ CDEvents.ProcessEvent[afterReplacement, design, currentAptr.ob];
END;

DoNewCellInteractive: PROC [] =
BEGIN
TerminalIO.WriteRope["new cell\n"];
currentAptr.ob _ currentCellOb; 
design^.actual _ design^.actual.rest;
design^.actual.first.indirectlyChanged _ TRUE;
design^.actual.first.changed _ TRUE;
IncludeAndNameCell[design, currentCellOb];
CDOps.IncludeApplication[design, currentAptr, FALSE];
END;

DoNewCell: PROC [] =
BEGIN
TerminalIO.WriteRope["new cell\n"];
currentAptr.ob _ currentCellOb; 
currentCellPtr.name _ name;
design^.actual _ design^.actual.rest;
design^.actual.first.indirectlyChanged _ TRUE;
[] _ CDDirectory.Include[design, currentCellOb];
CDOps.IncludeApplication[design, currentAptr, FALSE];
END;


IF design^.actual.rest=NIL THEN {TerminalIO.WriteRope["not in cell\n"]; RETURN [FALSE]};
pushedAptr _ design^.actual.first.mightReplace;
pushedCellPtr _ NARROW[pushedAptr.ob.specificRef];
pushedRect _ CDOrient.RectAt[pushedAptr.location, 
pushedAptr.ob.size, pushedAptr.orientation]; -- design cordinates
TerminalIO.WriteRope["Pop from cell "];
TerminalIO.WriteRope[pushedCellPtr.name]; 
TerminalIO.WriteLn[];
CDApplications.DeSelectList[CDOps.AppList[design]];
currentRect _ CDApplications.BoundingRect[CDOps.AppList[design]]; -- design coordinates
currentCellOb _ CreateCellObject[use: CDOps.AppList[design], orient: pushedAptr.orientation];
currentCellPtr _ NARROW[currentCellOb.specificRef];
currentAptr _ CDApplications.NewApplicationI[ob: currentCellOb,
location: CDInline.BaseOfRect[currentRect],  -- might need reposition
orientation: pushedAptr.orientation,
properties: CDProperties.CopyProps[pushedAptr.properties]
];
currentCellOb.properties _ CDProperties.CopyProps[pushedAptr.ob.properties];
IF m=flush OR (m=interactive AND ~design^.actual.first.changed) THEN {
DoFlush[]; 
RETURN [TRUE]
};
IF CDInline.NonEmpty[currentRect] THEN { 
mark: CDMarks.MarkRange = CDMarks.GetNewMark[design! CD.Error => GOTO markProblem];
CDMarks.MarkUnMarkedInclusiveChildren[design, currentCellOb, mark];
recursive _ (pushedAptr.ob.marked=mark);
IF recursive THEN {
IF m=newcell THEN DoNewCell[]
ELSE {
TerminalIO.WriteRope[" Original cell used inside, replace not possible\n"];
IF m=replace THEN RETURN[FALSE];
c _ TerminalIO.RequestSelection[
label: "Pop from cell",
choice: LIST["flush", "new cell"],
text: Rope.Cat["    flush: undo modifications\n",
"    new cell: Create a new cell\n"] ! TerminalIO.UserAbort => {c_0; CONTINUE}];
}
}
ELSE {
IF m=newcell THEN {DoNewCell[]; RETURN [TRUE]};
IF m=replace THEN {DoReplace[]; RETURN [TRUE]};
c _ TerminalIO.RequestSelection[
label: "Pop from cell",
choice: LIST["flush", "new cell", "replace"],
text: Rope.Cat["    flush: undo modifications\n",
"    new cell: Create a new cell\n",
"    replace: Replace the original cell\n"] ! 
TerminalIO.UserAbort => {c_0; CONTINUE}];
}
}
ELSE {  -- empty
TerminalIO.WriteRope[" create empty cell not possible\n"];
IF m#interactive THEN c _ 0
ELSE c _ TerminalIO.RequestSelection[
label: "Pop from empty cell",
choice: LIST["flush"],
text: "    flush: undo modifications\n"  
! TerminalIO.UserAbort => {c_0; CONTINUE}]
};
SELECT c FROM
1 => DoFlush[];
3 => DoReplace[];
2 => DoNewCellInteractive[];
ENDCASE => {TerminalIO.WriteRope["skipped\n"]; RETURN [FALSE]};
RETURN [TRUE];
EXITS
markProblem => TerminalIO.WriteRope["internal problem; not done\n"]; 
END;


Expand: CDCallSpecific.CallProc =
BEGIN
cptr: CD.CellPtr ~ NARROW[aptr.ob.specificRef];
removeMe _ TRUE;
repaintMe _ TRUE;
include _ CDApplications.ComposedCopy[ 
cptr.contents, aptr.location, aptr.ob.size, aptr.orientation];
repaintInclude _ TRUE;
END;


ComputeBounds: PROC [ob: CD.ObPtr] RETURNS [CD.DesignRect] =
BEGIN
WITH ob.specificRef SELECT FROM
cptr: CD.CellPtr => RETURN [CDApplications.BoundingRect[cptr.contents]]; 
ENDCASE => ERROR;
END;

AdjustItself: PROC [objToReposition: CD.ObPtr, newBound: CD.DesignRect] =
BEGIN
objToReposition.size _ CDInline.SizeOfRect[newBound];
WITH objToReposition.specificRef SELECT FROM
cptr: CD.CellPtr => 
CDApplications.TranslateList[cptr.contents,
CDInline.NegOffset[CDInline.BaseOfRect[newBound]]]; 
ENDCASE => ERROR;
END;

RepositionElements: PROC [me: CD.ObPtr, 
objToReposition: CD.ObPtr, 
oldSize: CD.DesignPosition,  -- of objToReposition
newBound: CD.DesignRect, -- of objToReposition
design: CD.Design] =
BEGIN

RepositionApplicationList: PROC [list: CD.ApplicationList] = INLINE
BEGIN
FOR w: CD.ApplicationList _ list, w.rest WHILE w#NIL DO
--IF w.first.ob=objToReposition THEN-- RepositionApplication[w.first];
ENDLOOP;
END;

RepositionApplication: PROC [aptr: CD.ApplicationPtr] = INLINE
BEGIN
IF aptr#NIL AND aptr.ob=objToReposition THEN {
aptr.location _ CDOrient.MapPosition[
itemInCell: newBound,
cellSize: oldSize,
cellInstOrient: aptr.orientation,
cellInstPos: aptr.location];
}
END;

WITH me.specificRef SELECT FROM
cptr: CD.CellPtr => {
RepositionApplicationList[cptr.contents];
IF CDInline.RectAt[[0, 0], me.size]#CDApplications.BoundingRect[cptr.contents] THEN
CDDirectory.RepositionAnObject[design, me];
};
ENDCASE => ERROR;
END;

-- -- -- -- -- -- -- -- -- -- -- --
ReadCell: CD.InternalReadProc --PROC [] RETURNS [ObPtr]-- =
BEGIN
ob: CD.ObPtr ~ CreateEmptyCell[];
specific: CD.CellPtr ~ NARROW[ob.specificRef];
ob.size.x _ TokenIO.ReadInt[];
ob.size.y _ TokenIO.ReadInt[];
IF CDIO.VersionKey[]<1 THEN {
specific.name _ TokenIO.ReadRope[];
}
ELSE {
specific.simplifyOn _ TokenIO.ReadInt[];
};
specific.contents _ CDIO.ReadApplicationList[];
RETURN [ob];
END;

WriteCell: CD.InternalWriteProc -- PROC [me: ObPtr] -- =
BEGIN
specific: CD.CellPtr ~ NARROW[me.specificRef];
TokenIO.WriteInt[me.size.x];
TokenIO.WriteInt[me.size.y];
TokenIO.WriteInt[specific.simplifyOn];
CDIO.WriteApplicationList[specific.contents];
END;

Describe: PROC[me: CD.ObPtr] RETURNS [Rope.ROPE] =
BEGIN
specific: CD.CellPtr = NARROW[me.specificRef];
RETURN [Rope.Concat["cell  ", specific.name]]
END;

-- -- -- -- -- -- -- -- -- -- -- --

RemoveApplication: PUBLIC PROC [design: CD.Design, cell: CD.ObPtr, aptr: CD.ApplicationPtr, draw: BOOL_TRUE] RETURNS [removed: CD.ApplicationPtr_NIL, repositioned: BOOL_FALSE] =
BEGIN
cp: CD.CellPtr = NARROW[cell.specificRef];
IF aptr=NIL THEN RETURN;
IF cp.contents#NIL THEN {
IF cp.contents.first=aptr THEN {
removed _ cp.contents.first; 
cp.contents _ cp.contents.rest
}
ELSE
FOR list: CD.ApplicationList _ cp.contents, list.rest WHILE list.rest#NIL DO
IF list.rest.first=aptr THEN {
removed _ list.rest.first; 
list.rest _ list.rest.rest; 
EXIT
}
ENDLOOP;
};
IF aptr.ob=NIL THEN RETURN [NIL];
IF draw AND design#NIL THEN CDOps.DelayedRedraw[design: design, eraseFirst: TRUE];
IF ~CDInline.Inside[CDApplications.ARectO[aptr], CDApplications.BoundingRect[cp.contents]] THEN {
repositioned _ TRUE;
CDDirectory.RepositionAnObject[design, cell];
};
RETURN [removed]
END;

IncludeApplication: PUBLIC PROC [design: CD.Design, cell: CD.ObPtr, aptr: CD.ApplicationPtr, draw: BOOL_TRUE, relativeTo: CD.ApplicationPtr_NIL] RETURNS [repositioned: BOOL_FALSE] =
BEGIN
cp: CD.CellPtr = NARROW[cell.specificRef];
IF aptr=NIL OR aptr.ob=NIL OR aptr=relativeTo THEN ERROR;
FOR list: CD.ApplicationList _ cp.contents, list.rest WHILE list#NIL DO
IF list.first=aptr THEN RETURN
ENDLOOP;
IF relativeTo#NIL THEN 
aptr.location _ CDInline.AddPoints[relativeTo.location, aptr.location];
cp.contents _ CONS[aptr, cp.contents];
IF draw AND design#NIL THEN CDOps.DelayedRedraw[design: design, eraseFirst: FALSE];
IF ~CDInline.Inside[CDApplications.ARectO[aptr], CDInline.RectAt[[0, 0], cell.size]] THEN {
repositioned _ TRUE;
CDDirectory.RepositionAnObject[design, cell];
};
END;

-- -- -- -- -- -- -- -- -- -- -- --

Init[];
END.


¶CDCellsImpl.mesa   (part of Chipndale)
by Christian Jacobi   June 24, 1983 5:00 pm 
last edited Christian Jacobi   February 16, 1984 12:44 pm
-- removes the selected applications from design and returns them
-- does not includes the cell into any design or celldirectory
-- does not name the cell
-- not yet included in design
-- if name is NIL: interactive read for name
-- cell is included in directory
--verbose if aptr is not a cell
--HACK for CDDirectory XXX
-- Move the new cell such that repositioning its call
-- will put it back to its proper location
-- Do not here adjust size! this is made by repositioning if necessary
CDMarks.ReturnMark[design];
-- -- -- -- -- -- -- -- -- -- -- --
-- -- -- -- -- -- -- -- -- -- -- --
--returns bounds in coordinate system of ob itself
--newBound is expected to be in coordinate system of objToReposition itself
-- repositions all applications which call objToReposition
-- oldSize: size of the original rePositionList.first 
-- objToReposition object needing reposition
-- newBound: bound of new objToReposition in coords of old rePositionList.first
-- (oldSize, newBound used by dynamic inner proc)
-- objToReposition.size is NOT used
-- repositions an application if it calls objToReposition
-- oldSize: size of the original objToReposition 
-- objToReposition object needing reposition
-- newBound: bound of new objToReposition in coords of old objToReposition
--XXX This could be determined faster.
--If necessary, modifies the boundary and translates all applications of the cell,
--	and further, translates all the instances of the cell.  This changes the
--	parent cells, which therefore may be repositioned recursively too.  
--noop if cell does not contain aptr (directly).
--Do not assume aptr^ to be freed for other use but use removed; 
--	removed=NIL: aptr has not successfully been removed
--	removed#NIL: aptr is removed, removed is a copy of aptr for arbitrary re-use. 
--aptr^ is supposed to be referenced by aptr exclusively, and aptr^ may be changed by
--	IncludeApplication.
--If necessary, modifies the boundary and translates all applications of the cell,
--	and further, translates all the instances of the cell.  This changes the
--	parent cells, which therefore may be repositioned recursively too.  
--relativeTo#NIL: handy but trivial hook for clients which fear that repositioning  
--	fools their origin: aptr is first translated by relativeTo.location: if relativeTo 
--	points to an application of the cell itself, repositioning changes relativeTo^ 
--	exactly the right amount to compensate for the repositioning.  It is the clients 
--	responsibility that relativeTo is actual contained by cell.
--check first if application is already contained by cell
�ÊŠ˜Jš
œ&™&Jš
œ,™,Jš
œ9™9J˜š
Ïk	˜	Jš�œ˜J˜J˜J˜J˜J˜	J˜	J˜J˜J˜J˜	Jš
œ
˜
Jš
œ˜J˜Jš
œ˜J˜—šÏbœ�œ
�œ
˜Jš�œ
�œ �œd˜”
Jš�œ˜Jš�œ˜—Jš
�˜J˜Jš
Ïn#˜#J˜Jšœ�œ�œ˜=˜-J˜5—˜,J˜4—J˜OJ˜MJ˜šŸœ�œ˜Jš
�˜Jšœ�œK˜RJš
œ1˜1Jš
œ˜Jš
œ+˜+Jš
œ!˜!Jš
œ
˜
Jš
œ˜Jš
œ˜Jš
œ"˜"Jš
œ,˜,J˜-Jš
œ"˜"Jš
œ$˜$Jš
œ˜Jš
œ4˜4Jš�œ˜—J˜šŸœ�œ�œ�œ˜,Jš
�˜Jšœ�œ�œ˜*Jš
œ
˜
Jš�œ
˜—J˜š
Ÿœ�œ�œ�œ�œ˜/Jš
�˜Jšœ�œ�œ˜*Jš�œ˜Jš�œ
˜—J˜š
Ÿœ�œ�œ�œ�œ˜.Jš
�˜Jšœ�œ�œ˜*Jš�œ˜Jš�œ
˜—J˜šŸœ�œ�œ0�œ˜ZJš
�˜Jšœ�œ�œ˜*š	�œ�œ)�œ�œ
�˜@J˜Jš
�˜—Jš�œ
˜—J˜š
Ÿœ�œ�œ�œ�œ
˜^Jšœ�œ˜š
�˜Jš�œ
�œ�œ�œ˜L—Jšœ�œ�œ˜/Jšœ�œ˜Jšœ
�œ˜$š	�œ�œ)�œ�œ
�˜@˜J˜VJš
œ˜J˜J˜—š�œ%�œ˜-Jšœ�œC˜HJš�œ�œ
�œ
˜J˜5Jš
œ
˜
—Jš�œ
˜—Jš�œ�œ˜:Jš�œ˜—J˜š
Ÿœ�œ�œ�œ�œ
˜cJšœ�œ˜š
�˜Jš�œ
�œ�œ�œ˜L—Jšœ�œ�œ˜/Jšœ�œ
˜š�œ3�œ�œ˜OJš
œ?˜?Jš�œ�œK˜VJ˜
—š�œ˜Jšœ�œ˜Jšœ
�œ˜$š	�œ�œ)�œ�œ
�˜@˜J˜VJš
œ˜J˜J˜—š�œ%�œ˜-Jšœ�œC˜HJš�œ�œ
�œ
˜J˜AJš
œ
˜
—Jš�œ
˜—Jš�œ�œ˜:Jš
œ
˜
—Jš�œ˜—J˜š
Ÿœ�œ�œ�œ�œ
˜aJšœ�œ˜Jš
�˜š�œ�œ�œ˜TJš�œ�œ9�œ˜f—Jš�œ?˜CJš�œ˜—J˜š
Ÿœ�œ
�œ	�œ�œ˜PJš
œA™AJš
�˜Jšœ�œ�œ
˜'Jš
œW˜WJš
œ˜Jš�œ	˜Jš�œ
˜—J˜š
Ÿœ�œ
�œ�œ�œ	˜4Jš
œ>™>Jš
œ™Jš
�˜Jšœ�œ	�œ
�œ˜(Jšœ�œ
�œ
˜$J˜J˜ Jš
œ˜Jš
œ˜Jš�œ˜Jš�œ
˜—J˜šŸœ�œ�œ�œ �œ�œ	˜oJš
œ™Jš
�˜Jšœ�œ˜!Jšœ�œ�œ˜(Jšœ�œ/Ïc!˜UJ˜@Jšœ
�œ
˜J˜ZJš�œ˜Jš�œ
˜—J˜šŸœ�œ
�œ
�œ	˜<Jš
�˜Jšœ	�œ�œ
˜Jš
œ˜Jšœ�œ�œ˜*š�œ
˜Jš�œ#�œ�œ˜:š�œ	�œ˜Jš
œ˜Jš
œ0˜0J˜
—Jš�œ8˜<š�œZ�œ�œ˜zJ˜@J˜$Jš�œ
˜J˜—J˜@J˜.J˜;Jšœ�	˜Jš�œ
˜—Jš�œ
˜—J˜šŸœ�œ
�œ
�œ�œ
�œ˜IJš�œ�œ
�œ	˜(Jš
œ,™,Jš
œ ™ Jš
�˜Jšœ�œ3˜:Jšœ�œ�œ
�œ˜-Jšœ�œ/˜4Jšœ�œ	˜Jš
œ-˜-Jšœ�œ˜"J˜J˜&Jšœ�œ
˜š�œ
�œ�œ˜"Jš
œ)˜)Jš�œ�œ
�œ
˜!Jš
œ˜—Jš�œ�œ
�œ#˜3Jš�œ*˜.Jšœ&�œ ˜GJš�œ�œ˜#Jš�œ
˜—J˜šŸœ�œ�œ�œ�œ�œ˜DJš
œ™Jš
�˜Jš�œ�œ
�œ&˜6Jš�œ
�œ	�œ
�œ�œ
�œ'˜Zš
�œ
�œ
�œ�œ
�œ˜:Jš
œ1˜1Jš
œ*˜*Jš
œ˜J˜
—Jš�œ�˜
Jš�œ
˜J˜—šŸœ�œ
�œ
�œ	�œ�œ
�œ˜RJš
�˜Jšœ�œ˜Jšœ
�œ
˜Jš
œ6˜6Jš�œ
�œ5˜EJš�œ$˜(Jš�œ
˜—J˜šŸœ�œ
�œ
�œ�œ�œ�œ�œ˜iJš
�˜Jš
œB˜BJš�œ
˜—J˜šŸœ�œ
�œ�œ˜GJš�œ�œ
�œ˜Jš
�˜š�œ�œ˜Jšœ�œ�œ˜6Jšœ�œ˜$Jšœ	�œ�œ˜0Jšœ
�œ˜š
�œ�œ
�œ
�œ!�œ�œ
�˜@š�œ�œ
�œ(�œ˜MJš
œA˜AJš
œ:˜:Jš
œ˜Jš�œ�œ
˜Jš
œ
˜
—Jš�œ
˜—J˜˜/J˜J˜J˜J˜#J˜—š
œ-˜-Jš
œ˜Jš
œ:˜:Jš
œ˜—Jš
œE˜EJš
œ.˜.šœ�œ
˜Jš�œP˜RJ˜—J˜.Jš�œ�œ˜J˜
—Jš�œ
˜—J˜šŸœ�œ
�œ
�œ	˜-Jšœ*�œ
�œ˜4š�œ�œ˜Jš
�˜J˜%Jš�œ�œ.˜:Jš�œ
˜——J˜šŸœ�œ
�œ'�œ˜Kš�œ�
œ˜Jš
�˜Jšœ�œ
˜Jšœ�œ˜'Jšœ�œ˜+Jšœ�œ˜Jšœ�œ	˜*Jšœ�œ
�œ
˜J˜šŸœ�œ˜Jš
�˜Jšœ�œ*˜1J˜ J˜%Jšœ)�œ
˜.Jš�œ�œ*�˜8Jšœ-�œ˜4Jš�œ
˜J˜—šŸ	œ�œ˜Jš
�˜Jšœ�œ˜J˜EJ˜"Jš
œ˜š
ž™Jš
œM˜M—Jš
œ˜Jš
œ˜Jš
œ˜J˜%Jšœ)�œ
˜.J˜1š�œ�œ ˜>šœ�œ!˜>J˜˜@J˜—J˜(J˜"—Jš
œ5™5Jš
œ*™*˜5J˜0—Jš
œF™FJš
œ7˜7Jš
œ˜—Jšœ)�˜.Jšœ.�œ˜5J˜EJš�œ
˜—J˜šŸœ�œ˜Jš
�˜J˜#J˜ J˜%Jšœ)�œ
˜.Jšœ�œ
˜$J˜*Jšœ.�œ˜5Jš�œ
˜—J˜šŸ	œ�œ˜Jš
�˜J˜#J˜ J˜J˜%Jšœ)�œ
˜.J˜0Jšœ.�œ˜5Jš�œ
˜—J˜J˜Jš
�œ�œ
�œ)�œ�œ˜XJ˜/Jšœ�œ˜2˜2Jšœ- ˜A—J˜'J˜*J˜Jš
œ3˜3JšœB ˜WJš
œ]˜]Jšœ�œ˜3˜?Jšœ- ˜EJ˜$Jš
œ9˜9J˜—Jš
œL˜Lš�œ	�œ�œ �œ˜FJš
œ˜Jš�œ�œ
˜
Jš
œ˜—š�œ �œ˜)Jšœ5�œ
�œ˜SJš
œC˜CJš
œ(˜(Jš
œ™š�œ�œ˜Jš�œ�œ˜š�œ˜J˜KJš�œ�œ
�œ
�œ˜ ˜ J˜Jšœ�œ˜"˜1JšœE�œ˜P——Jš
œ
˜
—Jš
œ
˜
—š�œ˜Jš�œ�œ�œ�œ˜/Jš�œ�œ�œ�œ˜/˜ J˜Jšœ�œ!˜-˜1J˜$˜.Jšœ�œ˜)———Jš
œ
˜
—Jš
œ
˜
—š�œ
 	˜J˜:Jš�œ�œ˜š�œ!˜%J˜Jšœ�œ
˜J˜)Jšœ �œ˜*—Jš
œ˜—š�œ�˜
J˜J˜J˜Jš�œ(�œ�œ˜?—Jš�œ�œ˜š
�˜Jš
œE˜E—Jš�œ
˜——J˜Jš
œ#™#J˜šžœ˜!Jš
�˜Jšœ�œ�œ˜/Jšœ
�œ
˜Jšœ�œ
˜˜'J˜>—Jšœ�œ
˜Jš�œ
˜—J˜Jš
œ#™#J˜š
Ÿ
œ�œ�œ�œ�œ˜<Jš
œ2™2Jš
�˜š�œ�œ
�˜Jšœ�œ�œ/˜IJš�œ�œ
˜—Jš�œ
˜—J˜šŸœ�œ�œ�œ˜IJš
œK™KJš
�˜J˜5š�œ�œ
�˜,šœ�œ˜˜+J˜4——Jš�œ�œ
˜—Jš�œ
˜—J˜šŸœ�œ�œ˜(Jšœ�œ˜Jšœ	�œ ˜2Jšœ
�œ
 ˜.Jšœ�œ
˜Jš
�˜J˜šŸœ�œ�œ�˜CJš
œ:™:Jš
œ6™6Jš
œ,™,Jš
œO™OJš
œ1™1Jš
œ#™#Jš
�˜š	�œ�œ �œ�œ
�˜7Jš &œ ˜FJš�œ
˜—Jš�œ
˜—J˜šŸœ�œ�œ�˜>Jš
œ9™9Jš
œ1™1Jš
œ,™,Jš
œJ™JJš
�˜š�œ�œ
�œ�œ˜.š
œ%˜%Jš
œ˜Jš
œ˜J˜!J˜—Jš
œ
˜
—Jš�œ
˜—J˜š�œ�œ
�˜šœ�œ
˜Jš
œ)˜)Jš
œ&™&š�œM�˜SJš
œ+˜+—J˜—Jš�œ�œ
˜—Jš�œ
˜—J˜Jš
Ÿ#˜#šžœ�œ œ˜;Jš
�˜Jšœ�œ˜!Jšœ
�œ�œ˜.J˜J˜š�œ
�œ�œ˜Jš
œ#˜#J˜
—š�œ˜Jš
œ(˜(J˜—Jšœ�œ˜/Jš�œ˜Jš�œ
˜—J˜šž	œ�œ œ˜8Jš
�˜Jšœ
�œ�œ˜.Jš
œ˜Jš
œ˜Jš
œ&˜&Jš�œ)˜-Jš�œ
˜—J˜š
Ÿœ�œ�œ�œ�œ˜2Jš
�˜Jšœ
�œ�œ˜.Jš�œ'˜-Jš�œ
˜—J˜Jš
Ÿ#˜#J˜šŸœ�œ
�œ�œ�œ�œ
�œ�œ�œ�œ�œ
�œ˜±
J™RJ™KJ™GJš
œ0™0Jš
œA™AJš
œ6™6Jš
œQ™QJš
�˜Jšœ�œ�œ˜*Jš�œ�œ
�œ
�œ
˜š�œ
�œ
�œ˜š�œ�œ˜ Jš
œ˜Jš
œ˜J˜
—š
�˜š	�œ�œ*�œ�œ
�˜Lš�œ�œ˜Jš
œ˜Jš
œ˜Jš
�˜Jš
œ
˜
—Jš�œ
˜——J˜—Jš
�œ	�œ
�œ
�œ�œ˜!Jš
�œ�œ�œ
�œ1�œ˜Rš�œY�œ˜aJšœ�œ
˜Jš
œ-˜-J˜—Jš�œ
˜Jš�œ
˜—J˜šŸœ�œ
�œ�œ�œ�œ
�œ�œ�œ�œ�œ
�œ˜µ
J™UJ™J™RJ™KJ™GJš
œT™TJš
œV™VJš
œR™RJš
œT™TJš
œ>™>Jš
�˜Jšœ�œ�œ˜*Jš�œ�œ
�œ	�œ
�œ�œ
�œ
˜9Jš
œ9™9š	�œ�œ*�œ�œ
�˜GJš�œ�œ
�˜Jš�œ
˜—š�œ�œ
�œ
˜Jš
œG˜G—Jšœ�œ˜&Jš
�œ�œ�œ
�œ1�œ˜Sš�œS�œ˜[Jšœ�œ
˜Jš
œ-˜-J˜—Jš�œ
˜J˜—Jš
Ÿ#˜#J˜J˜Jš�œ
˜J˜—…—HÌj