CDCellCommands.mesa (part of ChipNDale)
Copyright © 1983, 1986 by Xerox Corporation. All rights reserved.
Created by Christian Jacobi, July 11, 1983 3:42 pm
Last Edited by: Christian Jacobi, December 17, 1986 8:50:51 pm PST
DIRECTORY
Ascii,
CD,
CDBasics,
CDCells,
CDCellsInteractions,
CDDirectory,
CDDirectoryOps,
CDInstances,
CDMarks,
CDOps,
CDPanel,
CDProperties,
CDSequencer,
CDValue,
IO,
PopUpSelection,
Real,
Rope,
RopeList,
TerminalIO,
UserProfile,
ViewerClasses,
ViewerOps,
ViewerTools;
CDCellCommands:
CEDAR
PROGRAM
IMPORTS Ascii, CD, CDOps, CDCells, CDCellsInteractions, CDDirectory, CDDirectoryOps, CDInstances, CDMarks, CDPanel, CDProperties, CDSequencer, CDValue, IO, PopUpSelection, Real, Rope, RopeList, TerminalIO, UserProfile, ViewerOps, ViewerTools =
BEGIN
interactiveKey: Rope.ROPE ~ "← interactive";
DesignRope:
PROC [design:
CD.Design]
RETURNS [Rope.
ROPE] = {
RETURN [IF design.name#NIL THEN design.name ELSE "un-named design"]
};
GetObjectName:
PROC [design:
CD.Design, prompt: Rope.
ROPE]
RETURNS [name: Rope.
ROPE] = {
name ← CDPanel.FromDisplayRope[design, $ObjectName];
IF Rope.IsEmpty[name]
OR Rope.Equal[name, interactiveKey,
FALSE]
THEN
name ← TerminalIO.RequestRope[prompt];
};
DrawObjectByNameComm:
PROC [comm: CDSequencer.Command] = {
name: Rope.ROPE; ob: CD.Object;
TerminalIO.PutRope["draw object; "];
name ← GetObjectName[comm.design, "object name>\n"];
ob ← CDDirectory.Fetch[comm.design, name].object;
IF ob=NIL THEN TerminalIO.PutRopes[name, " not found\n"]
ELSE {
CDOps.IncludeObjectI[comm.design, ob, comm.pos];
TerminalIO.PutRopes[name, " inserted\n"];
};
};
RemoveObFromDirComm:
PROC [comm: CDSequencer.Command] = {
name, msg: Rope.ROPE←NIL; done: BOOL←FALSE; ob: CD.Object;
TerminalIO.PutRope["remove object from directory; "];
name ← GetObjectName[comm.design, "object name>\n"];
ob ← CDDirectory.Fetch[comm.design, name].object;
IF ob=NIL THEN TerminalIO.PutRopes[name, " not found\n"]
ELSE {
IF TerminalIO.Confirm[Rope.Cat["remove ", name]]
THEN {
[done, msg] ← CDDirectoryOps.RemoveIfUnused[comm.design, ob];
CDSequencer.MarkChangedIOOnly[comm.design];
TerminalIO.PutRope[msg];
};
IF ~done THEN TerminalIO.PutRope[" not "];
TerminalIO.PutRope["done\n"];
};
};
DisplayCellNames:
PROC [comm: CDSequencer.Command] = {
EachEntry: CDDirectory.EachEntryAction = {
--[name: Rope.ROPE, ob: CD.Object] RETURNS [quit: BOOL] --
quit ← FALSE;
count ← count+1;
IF comm.key=$RestricedDisplayCellNames
THEN {
IF Rope.Length[name]<=0 THEN RETURN
ELSE {
ch: CHAR = Rope.Fetch[name];
IF ~Ascii.Letter[ch] AND ~Ascii.Digit[ch] THEN RETURN
}
};
displayed ← displayed+1;
WITH ob.specific
SELECT
FROM
cp: CD.CellSpecific => list ← CONS[cp.name, list];
ENDCASE => list ← CONS[Rope.Cat[name, " [", CDOps.ObjectRope[ob], "]"], list];
};
sz: INT ← CDDirectory.DirSize[comm.design];
extraViewer: BOOL ← sz>9;
trailer, contents: Rope.ROPE ← NIL;
list: LIST OF Rope.ROPE ← NIL; count: INT ← 0; displayed: INT ← 0;
header: Rope.ROPE ← Rope.Cat["Directory of ", DesignRope[comm.design]];
IF extraViewer THEN TerminalIO.PutRope["open directory viewer\n"];
[] ← CDDirectory.Enumerate[comm.design, EachEntry];
list ← RopeList.Sort[list, RopeList.Compare];
FOR l:
LIST
OF Rope.
ROPE ← list, l.rest
WHILE l#
NIL
DO
contents ← Rope.Cat[contents, " ", l.first, "\n"];
ENDLOOP;
trailer ← IO.PutFR["%g objects counted ", IO.int[count]];
IF count#displayed
THEN
trailer ← IO.PutFR["%g %g displayed", IO.rope[trailer], IO.int[displayed]];
trailer ← Rope.Cat[trailer, "\n"];
contents ← Rope.Cat[header, "\n", contents, trailer];
IF extraViewer
THEN {
TerminalIO.PutRopes["open directory viewer\n", " ", trailer];
ViewerOps.OpenIcon[ViewerTools.MakeNewTextViewer[info: [name: header, data: contents]]];
}
ELSE TerminalIO.PutRopes[contents];
};
CreateCellAndName:
PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["create cell "];
IF ~CDCellsInteractions.CreateCellSelected[comm.design].done
THEN
TerminalIO.PutRope[" not done\n"];
};
CreateCellDefaultName:
PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["create cell without name\n"];
IF ~CDCellsInteractions.CreateCellSelected[comm.design, "-no name-"].done
THEN
TerminalIO.PutRope[" not done\n"];
};
PushIntoCellS:
PROC [comm: CDSequencer.Command] = {
inst: CD.Instance ← CDOps.TheInstance[design: comm.design, text: "push into "];
IF inst#
NIL
THEN {
TerminalIO.PutRope[CDOps.ObjectRope[inst.ob]];
IF ~CDCells.IsCell[inst.ob]
THEN {
TerminalIO.PutRope[" **is not cell; object expanded**"];
IF ~ inst.ob.class.inDirectory THEN CDSequencer.Quit[" not done"];
};
TerminalIO.PutRope["\n"];
IF CDCellsInteractions.PushInCellInstance[comm.design, inst, TRUE] THEN TerminalIO.PutRope["done\n"]
ELSE TerminalIO.PutRope["not done\n"];
};
};
PushIntoCellSIconic:
PROC [comm: CDSequencer.Command] = {
done: BOOL;
name: Rope.ROPE ← NIL;
inst: CD.Instance ← CDOps.TheInstance[design: comm.design, text: "push into representant "];
IF inst#
NIL
THEN {
TerminalIO.PutRopes[CDOps.ObjectRope[inst.ob], "\n"];
WITH CDProperties.GetProp[inst.ob, $IconFor]
SELECT
FROM
r: Rope.ROPE => name ← r;
ENDCASE => NULL;
IF name=
NIL
THEN
WITH CDProperties.GetProp[inst, $IconFor]
SELECT
FROM
r: Rope.ROPE => name ← r;
ENDCASE => NULL;
IF Rope.IsEmpty[name] THEN TerminalIO.PutRope[" no iconic property; not done\n"]
ELSE {
TerminalIO.PutRopes[" pushing into ", name, "\n"];
done ← PushByName[comm.design, name, comm];
IF done THEN TerminalIO.PutRope["done\n"] ELSE TerminalIO.PutRope["failed\n"];
};
};
};
ExpandComm:
PROC [comm: CDSequencer.Command] = {
instances: CD.InstanceList ← NIL; --this will be the instances of the design
cnt: INT ← 0;
someOb: CD.Object ← NIL; --if a single object is expanded we need it for its name
ExpandIncludeOneCell:
PROC [instOfCell:
CD.Instance, cell:
CD.Object] = {
--replace the instance by an instance of the expanded cell
--and include the instance into "instances"
EachCellInst: CDCells.InstEnumerator = {
new: CD.Instance ← CDInstances.Composed[inst, instOfCell.trans];
new.selected ← TRUE;
instances ← CONS[new, instances];
};
[] ← CDCells.EnumerateInstances[cell, EachCellInst];
CDOps.RedrawInstance[comm.design, instOfCell]; --delayed!
cnt ← cnt+1;
someOb ← instOfCell.ob;
};
CantAndPutBack:
PROC [inst:
CD.Instance, msg: Rope.
ROPE] = {
instances ← CONS[inst, instances];
inst.selected ← FALSE;
CDOps.RedrawInstance[comm.design, inst];
TerminalIO.PutRopes[CDOps.ObjectRope[inst.ob], " "];
TerminalIO.PutRopes[msg, "; deselected\n"];
};
selected: CD.InstanceList ← NIL;
TerminalIO.PutRope["expand\n"];
[selected, instances] ← CDInstances.SplitSelected[CDOps.InstList[comm.design]];
FOR il:
CD.InstanceList ← selected, il.rest
WHILE il#
NIL
DO
IF ~il.first.ob.class.inDirectory THEN CantAndPutBack[il.first, "atomic, can not be expanded"]
ELSE {
ob: CD.Object ← il.first.ob;
WHILE ob#
NIL
AND ~CDCells.IsCell[ob]
DO
ob ← CDDirectory.ExpandComplete[ob, comm.design, comm.design];
IF ob=il.first.ob THEN ob ← NIL; --to exit loop
IF ob#
NIL
AND CDCells.IsCell[ob]
THEN {
TerminalIO.PutRopes[CDOps.ObjectRope[il.first.ob], " converted to cell\n"];
[] ← CDDirectoryOps.RemoveIfUnused[comm.design, ob];
}
ENDLOOP;
IF ob#NIL AND CDCells.IsCell[ob] THEN ExpandIncludeOneCell[il.first, ob]
ELSE CantAndPutBack[il.first, "can not be converted to cell to expand"]
}
ENDLOOP;
IF cnt>0 THEN CDOps.SetInstList[comm.design, instances];
IF cnt=1 AND someOb#NIL THEN TerminalIO.PutRopes[CDOps.ObjectRope[someOb], " expanded"]
ELSE TerminalIO.PutF1["%g objects expanded\n", IO.int[cnt]];
};
PopFromCellMenu:
PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["pop\n"];
IF ~CDCellsInteractions.PopFromCell[comm.design, interactive]
THEN
TerminalIO.PutRope[" not done\n"];
};
PopFromCellFlush:
PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["pop and flush\n"];
IF ~CDCellsInteractions.PopFromCell[comm.design, flush]
THEN
TerminalIO.PutRope[" not done\n"];
};
PopFromCellReplace:
PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["pop and replace\n"];
IF ~CDCellsInteractions.PopFromCell[comm.design, replace]
THEN
TerminalIO.PutRope[" not done\n"];
};
PopFromCellNew:
PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["pop and new\n"];
IF ~CDCellsInteractions.PopFromCell[comm.design, newcell]
THEN
TerminalIO.PutRope[" not done\n"];
};
PruneDirComm:
PROC [comm: CDSequencer.Command] = {
autoOnly: BOOL ← comm.key#$DeleteUnUsedObjects;
TerminalIO.PutRope["prune directory\n"];
CDDirectoryOps.PruneDirectory[design: comm.design, autoOnly: autoOnly, askFirst: TRUE];
};
DrawWithBorder:
PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["set cells(s) draw mode: draw with border\n"];
FOR l:
CD.InstanceList ← CDOps.InstList[comm.design], l.rest
WHILE l#
NIL
DO
IF l.first.selected
THEN {
CDCells.SetBorderMode[l.first.ob, TRUE];
CDOps.RedrawInstance[comm.design, l.first, FALSE];
}
ENDLOOP;
};
DrawWithoutBorder:
PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["set cells(s) draw mode: draw without border\n"];
FOR l:
CD.InstanceList ← CDOps.InstList[comm.design], l.rest
WHILE l#
NIL
DO
IF l.first.selected
THEN {
CDCells.SetBorderMode[l.first.ob, FALSE];
CDOps.RedrawInstance[comm.design, l.first];
}
ENDLOOP;
};
SetCellSimplificationComm:
PROC [comm: CDSequencer.Command] = {
inst: CD.Instance; multiple: BOOL;
TerminalIO.PutRope["set cell simplification #\n"];
[inst, multiple] ← CDOps.SelectedInstance[comm.design];
IF multiple THEN TerminalIO.PutRope[" multiple selection; not done\n"]
ELSE IF inst=NIL THEN TerminalIO.PutRope[" no selection; not done\n"]
ELSE {
TerminalIO.PutRope[inst.ob.class.describe[inst.ob]];
IF
ISTYPE[inst.ob.specific,
CD.CellSpecific]
THEN {
cptr: CD.CellSpecific ~ NARROW[inst.ob.specific];
h: CD.Number ← MAX[1, inst.ob.bbox.x2-inst.ob.bbox.x1];
TerminalIO.PutF[" [currently: simplification if height < %g pixels", [integer[Real.Round[cptr.simplifyOn*h]]]];
cptr.simplifyOn ← MIN[MAX[TerminalIO.RequestInt[" pixels] type > "], 0], LAST[NAT]]/h;
CDOps.RedrawInstance[comm.design, inst];
TerminalIO.PutRope[" done\n"];
}
ELSE TerminalIO.PutRope[" not a cell; not done\n"];
}
};
RenameObjectComm:
PROC [comm: CDSequencer.Command] = {
desc: Rope.ROPE;
inst: CD.Instance ← CDOps.TheInstance[comm.design];
IF inst#
NIL
THEN {
desc ← CDOps.ObjectRope[inst.ob];
IF ~inst.ob.class.inDirectory
THEN
TerminalIO.PutRopes[" ", desc, " can not have name\n"]
ELSE {
newName: Rope.ROPE ← GetObjectName[comm.design, " new name > "];
IF Rope.IsEmpty[newName] THEN newName ← "-";
IF CDDirectory.Rename[comm.design, inst.ob, newName]
THEN {
CDSequencer.MarkChangedIOOnly[comm.design];
TerminalIO.PutRope[Rope.Cat[" ", desc, " renamed to ", CDDirectory.Name[inst.ob], "\n"]];
}
ELSE TerminalIO.PutRope[" not done\n"]
};
};
};
ReplaceObjectComm:
PROC [comm: CDSequencer.Command] = {
newName, oldName: Rope.ROPE; old, new: CD.Object; found: BOOL;
offset: CD.Position ← [0, 0];
lambda: CD.Number ← comm.design.technology.lambda;
TerminalIO.PutRope["replace object allover in design\n"];
oldName ← TerminalIO.RequestRope[" replace (name) > "];
[found, old] ← CDDirectory.Fetch[comm.design, oldName];
IF ~found THEN {TerminalIO.PutRopes[" ", oldName, " not found\n"]; RETURN};
newName ← TerminalIO.RequestRope[" by (name) > "];
[found, new] ← CDDirectory.Fetch[comm.design, newName];
IF ~found THEN {TerminalIO.PutRopes[" ", newName, " not found\n"]; RETURN};
TerminalIO.PutRope[" do you want to specify an offset?\n"];
SELECT PopUpSelection.Request[header: "offset",
choice: LIST["lambda", "ints", "none"]] FROM
1 => {
offset.x ← TerminalIO.RequestInt[" x in lambda >"]*lambda;
offset.y ← TerminalIO.RequestInt[" y in lambda >"]*lambda;
};
2 => {
offset.x ← TerminalIO.RequestInt[" x in ints >"];
offset.y ← TerminalIO.RequestInt[" y in ints >"];
};
ENDCASE => offset ← [0, 0];
CDDirectory.ReplaceObject[design: comm.design, old: old, new: new, trans: [offset, original]];
SELECT PopUpSelection.Request[header: "cleanup ?",
choice: LIST["remove replaced ob from dir", "remove replaced ob from dir and rename other", "no"]] FROM
1 => [] ← CDDirectoryOps.RemoveIfUnused[comm.design, old];
2 => CDDirectoryOps.RenameNRemove[comm.design, new, oldName];
ENDCASE => NULL;
TerminalIO.PutRope[" end replace\n"];
};
PushNamedComm:
PROC [comm: CDSequencer.Command] = {
done: BOOL;
name: Rope.ROPE;
TerminalIO.PutRope["push into cell by name\n"];
WITH comm.data
SELECT
FROM
r: Rope.
ROPE => {
TerminalIO.PutRopes["push into cell", r, "\n"];
name ← r;
};
ENDCASE => {
TerminalIO.PutRope["push into cell by name\n"];
name ← GetObjectName[comm.design, " cell name >"];
TerminalIO.PutRopes[" for: ", name, "\n"];
};
done ← PushByName[comm.design, name, comm];
IF done THEN TerminalIO.PutRope["done\n"] ELSE TerminalIO.PutRopes["failed\n"]
};
--**PushByName ************************
foundAndStop: SIGNAL = CODE;
HandleRec:
TYPE =
RECORD [
stopFlag: REF BOOL ← NIL,
iDidIt: BOOL ← FALSE,
gMark: CDMarks.MarkRange,
cell: CD.Object ← NIL,
drawStack: CD.InstanceList ← NIL
];
MyDrawChild:
CD.DrawProc = {
IF inst.ob.class.inDirectory
THEN {
h: REF HandleRec ← NARROW[pr.devicePrivate];
IF inst.ob=h.cell
THEN {
h.drawStack ← CONS[inst, h.drawStack];
h.iDidIt ← TRUE;
SIGNAL foundAndStop
};
WITH inst.ob.specific
SELECT
FROM
cp:
CD.CellSpecific => {
IF inst.ob.marked#h.gMark
THEN {
inst.ob.marked ← h.gMark;
h.drawStack ← CONS[inst, h.drawStack];
inst.ob.class.drawMe[inst: inst, trans: inst.trans, pr: pr];
h.drawStack ← h.drawStack.rest;
};
};
ENDCASE => NULL;
}
};
PushByName:
PROC [design:
CD.Design, name: Rope.
ROPE, comm: CDSequencer.Command←
NIL]
RETURNS [done:
BOOL←
FALSE] = {
--comm is used to find a viewer used for scale changes...
-- [using the viewer command enables its undo on the scale change]
h:
REF HandleRec =
NEW[HandleRec←[
stopFlag: NEW[BOOL],
gMark: 0
]];
myDrawRef:
CD.DrawRef ←
CD.CreateDrawRef[[
design: design,
interestClip: CDBasics.universe,
drawChild: MyDrawChild,
devicePrivate: h
]];
pushStack: CD.InstanceList ← NIL; --will be draw stack in reversed order
MyDrawWithMark:
PROC [mark: CDMarks.MarkRange] = {
h.gMark ← mark;
--draw only from pushed in cell point in hierarchy
design.actual.first.dummyCell.ob.class.drawMe[inst: design.actual.first.dummyCell, trans: [[0, 0], original], pr: myDrawRef ! foundAndStop => CONTINUE];
};
ReverseInstanceList:
PROC [list:
CD.InstanceList]
RETURNS[val:
CD.InstanceList] = {
val ← NIL;
UNTIL list =
NIL
DO
val ← CONS[list.first, val];
list ← list.rest;
ENDLOOP;
RETURN[val];
};
--set up
h.cell ← CDDirectory.Fetch[design, name].object;
IF h.cell=
NIL
THEN {
TerminalIO.PutRopes["design does not have object ", name, "\n"];
RETURN
};
--if we are already pushed in, it would not harm the program,
--but it is checked because it would confuse the designer
FOR pl:
LIST
OF
CD.PushRec ← design.actual, pl.rest
WHILE pl#
NIL
DO
IF pl.first.mightReplace#
NIL
AND pl.first.mightReplace.ob=h.cell
THEN {
TerminalIO.PutRopes["design is already pushed into", name, "\n"];
RETURN
}
ENDLOOP;
--check if a path to the cell exists, and build the path
BEGIN
markFailed: BOOL ← FALSE;
TryFromCurrentLevel:
PROC [] = {
--check first if it exists in an easy accessible position on top level
FOR il:
CD.InstanceList ← CDOps.InstList[design], il.rest
WHILE il#
NIL
DO
IF il.first.ob=h.cell
THEN {
h.iDidIt ← TRUE; h.drawStack ← LIST[il.first]; EXIT
};
ENDLOOP;
--now try really hard
IF ~ h.iDidIt
THEN
CDMarks.DoWithMark[design, MyDrawWithMark
! CDMarks.MarkOccupied => {markFailed ← TRUE; CONTINUE}
];
};
TryFromCurrentLevel[];
WHILE ~h.iDidIt
AND ~markFailed
AND CDCells.IsPushedIn[design]
DO
TerminalIO.PutRope["not found in accessible position\n try to pop\n"];
IF ~CDCellsInteractions.PopFromCell[design, interactive]
THEN {
TerminalIO.PutRope["failed: user did not allow pop out\n"];
RETURN
};
TryFromCurrentLevel[];
ENDLOOP;
IF markFailed
THEN {
TerminalIO.PutRope["**inconsistent use of mark\n"];
RETURN
};
IF ~h.iDidIt
THEN {
h.drawStack ← LIST[CDOps.PlaceInst[design, h.cell, comm]];
TerminalIO.PutRopes["**object ", CDDirectory.Name[h.cell], " drawn**\n"];
};
END;
--there is a path
--make pushStack in push order; (reverse order as drawStack)
pushStack ← ReverseInstanceList[h.drawStack]; --Don't trust that silly List module;
--do the pushes
WHILE pushStack#
NIL
DO
--select exclusively the application we want to push in
--pushing in makes a copy of the application list! check for the right object
inst: CD.Instance ← NIL;
CDSequencer.CheckAborted[design];
FOR il:
CD.InstanceList ← CDOps.InstList[design], il.rest
WHILE il#
NIL
DO
IF il.first.ob=pushStack.first.ob
THEN {
inst ← il.first;
EXIT
};
REPEAT
FINISHED => {
TerminalIO.PutRope["finding cell failed\n"];
RETURN
}
ENDLOOP;
IF ~CDCellsInteractions.PushInCellInstance[design, inst]
THEN {
TerminalIO.PutRope["push failed\n"];
IF comm#
NIL
THEN
CDSequencer.ExecuteCommand[$ResetScaleTop, design, dontQueue, comm];
RETURN
};
pushStack ← pushStack.rest
ENDLOOP;
--we are successully pushed in
done ← TRUE;
--position the viewer
IF comm#
NIL
THEN
CDSequencer.ExecuteCommand[$ResetScaleTop, design, dontQueue, comm];
--help the garbage collector
h.drawStack ← NIL; myDrawRef.viewerPrivate ← NIL; myDrawRef ← NIL; pushStack ← NIL;
};
TransformToCellS:
PROC [comm: CDSequencer.Command] = {
n: INT ← 0;
selection: CD.InstanceList ← CDInstances.OnlySelected[CDOps.InstList[comm.design]];
TerminalIO.PutRope["transform to cell\n"];
FOR l:
CD.InstanceList ← selection, l.rest
WHILE l#
NIL
DO
IF l.first.selected
AND l.first.ob.class.inDirectory
AND ~CDCells.IsCell[l.first.ob]
THEN {
cob: CD.Object ← CDDirectory.ExpandComplete[l.first.ob, comm.design, comm.design];
IF cob#
NIL
AND cob#l.first.ob
THEN {
l.first.ob ← cob; n ← n+1;
}
};
ENDLOOP;
TerminalIO.PutF1["%g objects transformed to cells\n", [integer[n]]];
};
CDSequencer.ImplementCommand[$PopMenu, PopFromCellMenu,, doQueue];
CDSequencer.ImplementCommand[$PopNew, PopFromCellNew,, doQueue];
CDSequencer.ImplementCommand[$PopFlush, PopFromCellFlush,, doQueue];
CDSequencer.ImplementCommand[$PopReplace, PopFromCellReplace,, doQueue];
CDSequencer.ImplementCommand[$PushS, PushIntoCellS,, doQueue];
CDSequencer.ImplementCommand[$PushSIconic, PushIntoCellSIconic,, doQueue];
CDSequencer.ImplementCommand[$ExpandS, ExpandComm];
CDSequencer.ImplementCommand[$CreateCellSAndName, CreateCellAndName];
CDSequencer.ImplementCommand[$CreateCellSUnNamed, CreateCellDefaultName];
CDSequencer.ImplementCommand[$DisplayCellNames, DisplayCellNames,, doQueue];
CDSequencer.ImplementCommand[$RestricedDisplayCellNames, DisplayCellNames,, doQueue];
CDSequencer.ImplementCommand[$DrawCell, DrawObjectByNameComm];
CDSequencer.ImplementCommand[$RemoveCell, RemoveObFromDirComm,, doQueue];
CDSequencer.ImplementCommand[$DeleteUnUsedObjects, PruneDirComm,, doQueue];
CDSequencer.ImplementCommand[$DeleteUnUsedAutoObs, PruneDirComm,, doQueue];
CDSequencer.ImplementCommand[$CellSimplification, SetCellSimplificationComm,, doQueue];
CDSequencer.ImplementCommand[$RenameS, RenameObjectComm,, doQueue];
CDSequencer.ImplementCommand[$Replace, ReplaceObjectComm];
CDSequencer.ImplementCommand[$DrawWithoutBorder, DrawWithoutBorder];
CDSequencer.ImplementCommand[$DrawWithBorder, DrawWithBorder];
CDSequencer.ImplementCommand[$PushNamed, PushNamedComm,, doQueue];
CDSequencer.ImplementCommand[$TransformToCellS, TransformToCellS];
CDValue.RegisterKey[$ObjectName, NIL, $chj];
CDValue.Store[NIL, $ObjectName, interactiveKey];
IF UserProfile.Boolean["ChipNDale.ObjectPrefix",
FALSE]
THEN {
CDPanel.DefineRopeEntry[cdValueKey: $ObjectName, button: "object name:"];
CDPanel.DefineNewLine[];
};
END.