DIRECTORY
BasicTime,
CD,
CDBasics,
CDInstances,
CDLayers,
CDOps,
CDRects,
CDSequencer,
CDValue,
IO,
PopUpSelection,
Rope,
TerminalIO;

CDBasicCommands: CEDAR PROGRAM
IMPORTS BasicTime, CDInstances, CDLayers, CDOps, CDSequencer, CDValue, PopUpSelection, TerminalIO, CDRects, CDBasics = 
BEGIN

DescribeInst: PROC [inst: CD.Instance, design: CD.Design_NIL] RETURNS [r: Rope.ROPE] = {
r _ CDOps.InstRope[inst, design];
};


MatchLayer: PROC [template, found: CD.Layer] RETURNS [BOOL] = INLINE {
IF template#CD.undefLayer THEN
IF CDLayers.AbstractToPaint[template]#CDLayers.AbstractToPaint[found] THEN RETURN [FALSE];
RETURN [TRUE]
};

RectDist: PROC [pos: CD.Position, r: CD.Rect] RETURNS [CD.Number] = {
RETURN [MAX[
(IF pos.x<r.x1 THEN (r.x1-pos.x) ELSE IF pos.x>r.x2 THEN (pos.x-r.x2) ELSE 0),
(IF pos.y<r.y1 THEN (r.y1-pos.y) ELSE IF pos.y>r.y2 THEN (pos.y-r.y2) ELSE 0)
]]
};

ComputeBB: PROC [list: CD.InstanceList, selectedOnly: BOOL_FALSE] RETURNS [bound: CD.Rect_CDBasics.empty, cnt: INT_0] = {
FOR l: LIST OF CD.Instance _ list, l.rest WHILE l#NIL DO
IF selectedOnly AND NOT l.first.selected THEN LOOP;
cnt _ cnt+1;
bound _ CDBasics.Surround[bound, CDInstances.InstRectO[l.first]]
ENDLOOP;
};


lastPos: CD.Position; 
lastKey: REF _ NIL;
lastTime: BasicTime.GMT _ BasicTime.earliestGMT;

ReUseSameSelection: PROC [comm: CDSequencer.Command] RETURNS [yes: BOOL] = {
lambda: CD.Number = comm.design.technology.lambda;
ReallyClose: PROC [p1, p2: CD.Position] RETURNS [BOOL] = INLINE {
RETURN [ABS[p1.x-p2.x]<=lambda AND ABS[p1.y-p2.y]<=lambda]
};
now: BasicTime.GMT _ BasicTime.Now[];
yes _ ReallyClose[lastPos, comm.pos] AND lastKey=comm.key AND BasicTime.Period[lastTime, now]<=2;
lastPos _ comm.pos;
lastKey _ comm.key;
lastTime _ now;
};

Select: PROC [design: CD.Design, pos: CD.Position] = {
sel: CD.Instance _ NIL;
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF ~w.first.selected THEN { 
IF CDInstances.PointToI[pos, w.first] THEN {sel _ w.first; EXIT}
};
ENDLOOP;
IF sel#NIL THEN {
sel.selected _ TRUE;
CDOps.ReOrderInstance[design, sel];
CDOps.RedrawInstance[design, sel];
TerminalIO.PutRope[DescribeInst[sel, design]];
}
ELSE {
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF w.first.selected THEN { 
IF CDInstances.PointToI[pos, w.first] THEN {
TerminalIO.PutRopes[DescribeInst[w.first, design], " again"];
RETURN
}
};
ENDLOOP;
TerminalIO.PutRope[" no pointed object"];
}
};

DeSelect: PROC [design: CD.Design, pos: CD.Position] = {
inst: CD.Instance _ CDInstances.InstanceAt[CDOps.InstList[design], pos, TRUE];
IF inst#NIL THEN { 
inst.selected _ FALSE;
CDOps.RedrawInstance[design, inst];
CDOps.ReOrderInstance[design, inst];
};
TerminalIO.PutRope[DescribeInst[inst, design]];
};

AreaSelect: PROC [design: CD.Design, area: CD.Rect, includePartial: BOOL_FALSE] = {
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF ~w.first.selected THEN { 
IF CDBasics.Intersect[area, CDInstances.InstRectI[w.first]] THEN 
IF includePartial OR CDBasics.Inside[CDInstances.InstRectI[w.first], area] THEN {
w.first.selected _ TRUE;
CDOps.RedrawInstance[design, w.first, FALSE];
};
};
ENDLOOP;
};

AreaDeSelect: PROC [design: CD.Design, area: CD.Rect, includePartial: BOOL_FALSE] = {
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF w.first.selected THEN { 
IF CDBasics.Intersect[area, CDInstances.InstRectI[w.first]] THEN 
IF includePartial OR CDBasics.Inside[CDInstances.InstRectI[w.first], area] THEN {
w.first.selected _ FALSE;
CDOps.RedrawInstance[design, w.first];
};
};
ENDLOOP;
};

SelectExclusiveComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["select pointed "];
CDOps.DeselectAll[comm.design, FALSE];
Select[comm.design, comm.pos];
TerminalIO.PutRope["\n"];
};

ReSelectExclusive: PROC [design: CD.Design, pos: CD.Position, verbose: BOOL_TRUE, layer: CD.Layer_CD.undefLayer] RETURNS [done: BOOL_TRUE] = {
Deselect: PROC [i: CD.Instance] = INLINE {
IF i.selected THEN {
i.selected _ FALSE;
CDOps.RedrawInstance[design, i]
}
};
DeselectList: PROC [list: CD.InstanceList] = {
FOR w: CD.InstanceList _ list, w.rest WHILE w#NIL DO
Deselect[w.first]
ENDLOOP
};
ValidForSelection: PROC [inst: CD.Instance] RETURNS [BOOL] = INLINE {
 RETURN [ CDInstances.PointToI[pos, inst] AND MatchLayer[layer, inst.ob.layer] ];
};
inst: CD.Instance _ NIL; --any instance where pos points to
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF ValidForSelection[w.first] THEN {
IF w.first.selected THEN {
DeselectList[w.rest]; 
CDOps.ReOrderInstance[design, w.first];
IF verbose THEN TerminalIO.PutRope[DescribeInst[w.first, design]];
RETURN
}
ELSE IF inst=NIL THEN inst _ w.first
}
ELSE Deselect[w.first]
ENDLOOP;
IF inst#NIL THEN {
inst.selected _ TRUE; 
CDOps.ReOrderInstance[design, inst];
CDOps.RedrawInstance[design, inst, FALSE];
IF verbose THEN TerminalIO.PutRope[DescribeInst[inst, design]]
}
ELSE {
done _ FALSE;
IF verbose THEN TerminalIO.PutRope[" (no object)"];
}
};

CloseReSelectExclusive: PROC [design: CD.Design, pos: CD.Position, verbose: BOOL_TRUE, dist: CD.Number_100, layer: CD.Layer_CD.undefLayer] = {
IF ~ReSelectExclusive[design, pos, verbose, layer] THEN {
inst: CD.Instance _ NIL;
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
d: CD.Number = RectDist[pos, CDInstances.InstRectI[w.first]];
IF d<dist AND MatchLayer[layer, w.first.ob.layer] THEN {inst _ w.first; dist _ d}
ENDLOOP;
IF inst#NIL THEN {
inst.selected _ TRUE;
CDOps.RedrawInstance[design, inst, FALSE];
IF verbose THEN TerminalIO.PutRopes[" found close object ", DescribeInst[inst, design]];
}
}
};

ReSelectExclusiveComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["select "];
[] _ ReSelectExclusive[comm.design, comm.pos];
TerminalIO.PutRope["\n"];
};

ReSelectExclusiveWithLayerComm: PROC [comm: CDSequencer.Command] = {
layer: CD.Layer _ CDLayers.AbstractToPaint[CDLayers.PlaceholderToAbstract[comm.design, CDLayers.CurrentLayer[comm.design]]];
TerminalIO.PutF["select with layer %g ", [rope[CDOps.LayerRope[layer]]]];
[] _ ReSelectExclusive[comm.design, comm.pos, TRUE, layer];
TerminalIO.PutRope["\n"];
};

CloseReSelectComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["select "];
IF ReUseSameSelection[comm] THEN CDOps.DeselectAll[comm.design, FALSE]; 
[] _ CloseReSelectExclusive[comm.design, comm.pos, TRUE, 50];
TerminalIO.PutRope["\n"];
};

MultiOnlySelectComm: PROC [comm: CDSequencer.Command] = {
ReallyClose: PROC [p1, p2: CD.Position] RETURNS [BOOL] = INLINE {
RETURN [ABS[p1.x-p2.x]<=lambda OR ABS[p1.y-p2.y]<=lambda]
};
lambda: CD.Number = comm.design.technology.lambda;
IF ReallyClose[comm.pos, comm.sPos] 
THEN CloseReSelectComm[comm] 
ELSE AreaOnlySelectComm[comm];
};

DoubleAddSelectComm: PROC [comm: CDSequencer.Command] = {
IF ReUseSameSelection[comm] THEN {
TerminalIO.PutRope["change selection  "]; 
[] _ DeSelectLast[comm.design, comm.pos, TRUE];
}
ELSE TerminalIO.PutRope["add selection  "];
Select[comm.design, comm.pos];
TerminalIO.PutRope["\n"];
};

DeselectPointedComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["remove selection "]; 
DeSelect[comm.design, comm.pos];
TerminalIO.PutRope["\n"];
};

DeSelectLast: PROC [design: CD.Design, pos: CD.Position, usePos: BOOL_TRUE] RETURNS [done: BOOL_FALSE] = {
sel: CD.Instance _ NIL;
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF w.first.selected THEN { 
IF ~usePos OR CDInstances.PointToI[pos, w.first] THEN sel _ w.first;
};
ENDLOOP;
IF sel#NIL THEN {
sel.selected _ FALSE;
done _ TRUE;
CDOps.RedrawInstance[design, sel]
}
};

DeselectLastSelectedComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["remove selection "]; 
[] _ DeSelectLast[comm.design, comm.pos, TRUE];
TerminalIO.PutRope["\n"];
};

AddSelectionComm: PROC [comm: CDSequencer.Command] = { 
TerminalIO.PutRope["add selection  "]; 
Select[comm.design, comm.pos];
TerminalIO.PutRope["\n"];
};

DeselectAllComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["de-select all\n"]; 
CDOps.DeselectAll[comm.design, FALSE]
};

SelectAllComm: PROC [comm: CDSequencer.Command] = {
cnt: INT _ 0;
TerminalIO.PutRope["select all: "]; 
CDOps.DeselectAll[comm.design, TRUE];
FOR w: CD.InstanceList _ CDOps.InstList[comm.design], w.rest WHILE w#NIL DO
cnt _ cnt+1;
ENDLOOP;
TerminalIO.PutF1["%g selected objects\n", [integer[cnt]]]; 
};

AreaAddSelectComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["inclusive select area\n"]; 
AreaSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]]
};

MultiAddSelectComm: PROC [comm: CDSequencer.Command] = {
NotRect: PROC [p1, p2: CD.Position] RETURNS [BOOL] = INLINE {
RETURN [ABS[p1.x-p2.x]<=lambda OR ABS[p1.y-p2.y]<=lambda]
};
lambda: CD.Number = comm.design.technology.lambda;
IF NotRect[comm.pos, comm.sPos] THEN DoubleAddSelectComm[comm]
ELSE {
TerminalIO.PutRope["select inclusive area\n"]; 
AreaSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]]
}
};

AreaAddSelectTouchingComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["select inclusive touching\n"]; 
AreaSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos], TRUE]
};

AreaOnlySelectComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["select area\n"]; 
CDOps.DeselectAll[comm.design, FALSE];
AreaSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]]
};

ADeSelectComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["de-select "]; 
IF comm.pos=comm.sPos THEN DeSelect[comm.design, comm.pos]
ELSE AreaDeSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]];
TerminalIO.PutRope["\n"];
};

AreaDeSelectComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["de-select area\n"]; 
AreaDeSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]]
};

AreaDeSelectTouchingComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["de-select touching\n"]; 
AreaDeSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos], TRUE]
};


DeleteSelected: PROC [design: CD.Design] = {
toDelete, newContents: CD.InstanceList; count: INT _ 0;
[selected: toDelete, others: newContents] _ CDInstances.SplitSelected[CDOps.InstList[design]];
CDOps.SetInstList[design, newContents];
CDOps.Remember[design, toDelete];
FOR w: CD.InstanceList _ toDelete, w.rest WHILE w#NIL DO
count _ count+1;
CDOps.RedrawInstance[design, w.first, TRUE];
ENDLOOP;
IF count#1 THEN TerminalIO.PutF1["%g objects", [integer[count]]]
ELSE TerminalIO.PutRope[DescribeInst[toDelete.first, design]]
};

DeleteSelectedComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["delete selected "]; 
DeleteSelected[comm.design];
TerminalIO.PutRope["\n"]; 
};

UndeleteComm: PROC [comm: CDSequencer.Command] = {
il: CD.InstanceList _ CDOps.GetRemembered[comm.design];
TerminalIO.PutRope["un-delete\n"]; 
CDOps.IncludeInstanceList[comm.design, il];
};

AbortComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["try to abort current command\n"]; 
CDSequencer.AbortDesignsCommand[comm.design]
};


AddARect: PROC [design: CD.Design, r: CD.Rect,  l: CD.Layer] = {
IF ~CDBasics.NonEmpty[r] THEN TerminalIO.PutRope["empty rect not included\n"]
ELSE {
orient: CD.Orientation _ original;
sz: CD.Position _ CDBasics.SizeOfRect[r];
IF sz.y<sz.x THEN {
w: CD.Number _ sz.x; sz.x _ sz.y; sz.y _ w; 
orient _ rotate90
};
[] _ CDOps.IncludeObjectI[design: design, ob: CDRects.CreateRect[sz, l], location: CDBasics.BaseOfRect[r], orientation: orient]
}
};

InternalAddWire: PROC [comm: CDSequencer.Command, firstOnly: BOOL_FALSE] = {
start: CD.Position _ comm.sPos; 
stop: CD.Position _ comm.pos;
wireWidth: CD.Number _ comm.n;
IF wireWidth=0 THEN {AddRectComm[comm]; RETURN};
TerminalIO.PutRope["draw wire\n"]; 
IF --firstHorizontal-- comm.b THEN {
IF stop.x<=start.x AND stop.x>=start.x-wireWidth
AND (stop.y<start.y OR stop.y>start.y+wireWidth) THEN { --crazy vertical wire
IF ABS[start.y-stop.y]<comm.design.technology.lambda THEN { 
TerminalIO.PutRope[" empty wire not added\n"]; RETURN
};
stop.x _ start.x+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l];
RETURN
};
IF stop.y>=start.y AND stop.y<=start.y+wireWidth THEN { --horizontal wire
stop.y _ start.y+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l]
}
ELSE { --L shaped (firsthorizontal)
IF start.x<=stop.x THEN {stop.x _ stop.x+wireWidth}
ELSE {t: CD.Number=stop.x; stop.x _ start.x; start.x _ t}; 
stop.y _ start.y+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l];
IF firstOnly THEN RETURN;
start.x _ comm.pos.x; stop.y _ comm.pos.y; stop.x _ start.x+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l];
}
}
ELSE { -- NOT firstHorizontalVC --
IF stop.y<=start.y AND stop.y>=start.y-wireWidth 
AND (stop.x<start.x OR stop.x>start.x+wireWidth) THEN { --crazy horizontal wire
IF ABS[stop.x-start.x]<comm.design.technology.lambda THEN { 
TerminalIO.PutRope[" empty wire not added\n"]; RETURN
};
stop.y _ start.y+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l];
RETURN
};
IF stop.x>=start.x AND stop.x<=start.x+wireWidth THEN { --vertical wire
stop.x _ start.x+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l]
}
ELSE { --L shaped (firstVertical)
IF start.y<=stop.y THEN {stop.y _ stop.y+wireWidth}
ELSE {t: CD.Number = stop.y; stop.y _ start.y; start.y _ t}; 
stop.x _ start.x+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l];
IF firstOnly THEN RETURN;
start.y _ comm.pos.y; stop.y _ start.y+wireWidth; stop.x _ comm.pos.x;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l];
}
}
};

AddRectComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["draw rect\n"]; 
AddARect[comm.design, CDBasics.ToRect[comm.sPos, comm.pos], comm.l];
};

AddWireComm: PROC [comm: CDSequencer.Command] = {
InternalAddWire[comm: comm, firstOnly: FALSE]
};

ContinueWireComm: PROC [comm: CDSequencer.Command] = {
InternalAddWire[comm: comm, firstOnly: TRUE]
};


RedrawMoved: PROC [design: CD.Design, r: CD.Rect, offset: CD.Position] = {
moved: CD.Rect _ CDBasics.MoveRect[r, offset];
IF CDBasics.Intersect[r, moved] THEN
CDOps.Redraw[design, CDBasics.Surround[r, moved], TRUE]
ELSE {
CDOps.Redraw[design, r];
CDOps.Redraw[design, moved]; -- use eraseFirst because also used by copy
}
};

OrientSelected: PROC [design: CD.Design, transform: CD.Orientation, base: CD.Rect_[0,0,-1,-1]] = {
ib, is, orientOff: CD.Position; r, oldbb: CD.Rect; oldPseudoCellT, newPseudoCellT: CD.Transformation;
sel: CD.InstanceList = CDInstances.OnlySelected[CDOps.InstList[design]];
IF sel=NIL THEN RETURN;
oldbb _ CDInstances.BoundingRectO[sel];
IF ~CDBasics.NonEmpty[base] THEN base _ CDInstances.BoundingRectI[sel];
ib _ CDBasics.BaseOfRect[base];
is _ CDBasics.SizeOfRect[base];
oldPseudoCellT _ [ib, original];
r _ CDBasics.MapRect[CDBasics.RectAt[[0,0], is], [[0,0], transform]];
orientOff _ CDBasics.BaseOfRect[r];
newPseudoCellT _ [CDBasics.SubPoints[ib, orientOff], transform];
FOR w: CD.InstanceList _ sel, w.rest WHILE w#NIL DO
pseudoCellRel: CD.Transformation _ CDBasics.DecomposeTransform[w.first.trans, oldPseudoCellT];
w.first.trans _ CDBasics.ComposeTransform[pseudoCellRel, newPseudoCellT]
ENDLOOP;
CDOps.Redraw[design, oldbb];
CDOps.Redraw[design, CDBasics.MapRect[CDBasics.DeMapRect[oldbb, oldPseudoCellT], newPseudoCellT]]
};

MoveSelected: PROC [design: CD.Design, offset: CD.Position] = {
sel: CD.InstanceList = CDInstances.OnlySelected[CDOps.InstList[design]];
bounding: CD.Rect _ CDBasics.empty;
FOR w: CD.InstanceList _ sel, w.rest WHILE w#NIL DO
inst: CD.Instance _ w.first;
bounding _ CDBasics.Surround[bounding, CDInstances.InstRectO[inst]];
inst.trans.off _ CDBasics.AddPoints[inst.trans.off, offset];
ENDLOOP;
RedrawMoved[design, bounding, offset]
};

CopySelected: PUBLIC PROC [design: CD.Design, offset: CD.Position] = {
new: CD.InstanceList_NIL;
sel: CD.InstanceList = CDInstances.OnlySelected[CDOps.InstList[design]];
bounding: CD.Rect _ CDInstances.BoundingRectO[sel]; 
FOR w: CD.InstanceList _ sel, w.rest WHILE w#NIL DO
inst: CD.Instance _ CDInstances.Copy[w.first];
inst.trans.off _ CDBasics.AddPoints[inst.trans.off, offset];
inst.selected _ TRUE;
new _ CONS[inst, new];
w.first.selected _ FALSE;
ENDLOOP;
CDOps.IncludeInstanceList[design, new, FALSE];
RedrawMoved[design, bounding, offset];
};

TransformS: PROC [comm: CDSequencer.Command] = {
n: CARDINAL;
TerminalIO.PutRope["transform: "];
n _ PopUpSelection.Request[
header: "transform",
choice: LIST["mirror x", "mirror y", "rot  90", "rot 180", "rot 270"]];
SELECT n FROM
1 => {TerminalIO.PutRope["mirror x\n"]; 
OrientSelected[comm.design, mirrorX]};
2 => {TerminalIO.PutRope["mirror y\n"]; 
OrientSelected[comm.design, rotate180];
OrientSelected[comm.design, mirrorX]};
3 => {TerminalIO.PutRope["rot  90\n"]; 
OrientSelected[comm.design, rotate90]};
4 => {TerminalIO.PutRope["rot 180\n"]; 
OrientSelected[comm.design, rotate180]};
5 => {TerminalIO.PutRope["rot 270\n"]; 
OrientSelected[comm.design, rotate270]};
ENDCASE => TerminalIO.PutRope["Skipped\n"];
};

RotS: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["rotate counterclockwise\n"];
OrientSelected[comm.design, rotate90]
};

MirrorS: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["mirror on x axis\n"];
OrientSelected[comm.design, mirrorX]
};

MirrorYS: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["mirror on y axis\n"];
OrientSelected[comm.design, CD.mirrorY];
};

SimpleMoveSCommand: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["move (no stretch)\n"];
MoveSelected[design: comm.design, offset: CD.Position[comm.pos.x-comm.sPos.x, comm.pos.y-comm.sPos.y]]
};

CopySCommand: PROC [comm: CDSequencer.Command] = {
IF comm.pos.x#comm.sPos.x OR comm.pos.y#comm.sPos.y THEN { 
IF comm.data#NIL AND comm.data#comm.design AND ISTYPE[comm.data, CD.Design] THEN {
p: CDSequencer.CommandProc _ CDSequencer.FetchCommand[$UnqueuedCopyInterDesign].proc;
IF p=NIL 
THEN TerminalIO.PutRope["failed, command issued in other design\n"]
ELSE CDSequencer.ExecuteProc[p, comm.design, dontQueue, comm];
RETURN
};
TerminalIO.PutRope["copy\n"];
CopySelected[comm.design, CD.Position[comm.pos.x-comm.sPos.x, comm.pos.y-comm.sPos.y]]
}
ELSE TerminalIO.PutRope["no copy in place\n"];
};

StepSize: PROC [comm: CDSequencer.Command] RETURNS [n: CD.Number] = {
design: CD.Design _ comm.design;
n _ CDValue.FetchInt[boundTo: design, key: $CDxStepValue, propagation: design];
IF n<=0 THEN {
n _ CDOps.GetGrid[design, comm];
IF n<=0 THEN n _ design.technology.lambda
}
};

LambdaUpS: PROC [comm: CDSequencer.Command] = {
MoveSelected[comm.design, [0, StepSize[comm]]]
};

LambdaDownS: PROC [comm: CDSequencer.Command] = {
MoveSelected[comm.design, [0, -StepSize[comm]]]
};

LambdaLeftS: PROC [comm: CDSequencer.Command] = {
MoveSelected[comm.design, [-StepSize[comm], 0]]
};

LambdaRightS: PROC [comm: CDSequencer.Command] = {
MoveSelected[comm.design, [StepSize[comm], 0]]
};

RenameDesign: PROC [comm: CDSequencer.Command] = {
name: Rope.ROPE; done: BOOL;
TerminalIO.PutRopes["rename design ", comm.design.name, "\n"]; 
name _ TerminalIO.RequestRope["enter name: "];
done _ CDOps.RenameDesign[comm.design, name];
IF done THEN TerminalIO.PutRope["done\n"] ELSE TerminalIO.PutRope["not done\n"];
};


CDValue.StoreInt[boundTo: NIL, key: $CDxStepValue, value: 0];

CDSequencer.ImplementCommand[$DrawRect, AddRectComm];
CDSequencer.ImplementCommand[$DrawWire, AddWireComm];
CDSequencer.ImplementCommand[$ContinueWire, ContinueWireComm];
CDSequencer.ImplementCommand[$DeleteS, DeleteSelectedComm];
CDSequencer.ImplementCommand[$Undel, UndeleteComm];
CDSequencer.ImplementCommand[$AbortCommand, AbortComm,, dontQueue];

CDSequencer.ImplementCommand[$OnlySelectP, SelectExclusiveComm,, doQueue];
CDSequencer.ImplementCommand[$ReSelectOnlyP, ReSelectExclusiveComm,, doQueue];
CDSequencer.ImplementCommand[$ReSelectOnlyWithLayerP, ReSelectExclusiveWithLayerComm,, doQueue];
CDSequencer.ImplementCommand[$CloseReSelectOnlyP, CloseReSelectComm,, doQueue];
CDSequencer.ImplementCommand[$AddSelectP, AddSelectionComm,, doQueue];

CDSequencer.ImplementCommand[$DeSelectLP, DeselectLastSelectedComm,, doQueue];
CDSequencer.ImplementCommand[$DeSelectFP, DeselectPointedComm,, doQueue];
CDSequencer.ImplementCommand[$DeSelectS, DeselectAllComm,, doQueue];
CDSequencer.ImplementCommand[$SelectAll, SelectAllComm,, doQueue];
CDSequencer.ImplementCommand[$AreaOnlySelect, AreaOnlySelectComm,, doQueue];
CDSequencer.ImplementCommand[$MultiOnlySelect, MultiOnlySelectComm,, doQueue];

CDSequencer.ImplementCommand[$AreaAddSelect, AreaAddSelectComm,, doQueue];
CDSequencer.ImplementCommand[$AreaAddSelectTouching, AreaAddSelectTouchingComm,, doQueue];
CDSequencer.ImplementCommand[$MultiAddSelect, MultiAddSelectComm,, doQueue];
CDSequencer.ImplementCommand[$DoubleAddSelect, DoubleAddSelectComm,, doQueue];

CDSequencer.ImplementCommand[$AreaDeSelect, AreaDeSelectComm,, doQueue];
CDSequencer.ImplementCommand[$AreaDeSelectTouching, AreaDeSelectTouchingComm,, doQueue];
CDSequencer.ImplementCommand[$ADeSelect, ADeSelectComm,, doQueue];

CDSequencer.ImplementCommand[$MoveS, SimpleMoveSCommand];
CDSequencer.ImplementCommand[$CopyS, CopySCommand];
CDSequencer.ImplementCommand[$LambdaUpS, LambdaUpS];
CDSequencer.ImplementCommand[$LambdaDownS, LambdaDownS];
CDSequencer.ImplementCommand[$LambdaLeftS, LambdaLeftS];
CDSequencer.ImplementCommand[$LambdaRightS, LambdaRightS];
CDSequencer.ImplementCommand[$RotS, RotS];
CDSequencer.ImplementCommand[$MirrorYS, MirrorYS];
CDSequencer.ImplementCommand[$MirrorS, MirrorS];
CDSequencer.ImplementCommand[$TransformS, TransformS];
CDSequencer.ImplementCommand[$RenameDesign, RenameDesign];
END.
	HCDBasicCommands.mesa   (part of ChipNDale)
Copyright c 1983, 1986, 1987 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, June 29, 1983 4:44 pm 
Last edited by: Christian Jacobi, April 2, 1987 3:27:41 pm PST
-- common xxxxxxxxxxxxxxxxxxxxxx

IF inst#NIL AND inst.ob.class.composed THEN {
r _ IO.PutFR["%g [%g]", [rope[r]], [cardinal[LOOPHOLE[inst.ob]]]];
};

-- selections xxxxxxxxxxxxxxxxxxxxxx
--Distance between a point and a rectangle
--Crazy heuristics to determine which kind of selection is wanted 
--these variables are used by PROC ReUseSameSelection only
--Select an instance at position pos
--check whether a different instances should be selected
--a new instance will be selected
--reorder list, future selection will selects next lower instance
--no new instance found; can we select an already selected one?
--Deselect an instance at position pos
--reorder list, future selection will find next instance
--hit
--if a selected inst is pointed we already did return
--select pointed instance exclusive;
--(but dont select an other instance if the pointed one is already the right one)
--select pointed instance of right layer exclusive
--select pointed instance exclusive;
--(but dont select an other instance if the pointed one is already the right one)
--if there is none, select closest
--cycle through if exactly sme position
--Auto select area or pointed or changed
--Auto deselect area or pointed
-- xx delete, abort xxxxxxxxxxxxxxxxxxxxxx

-- xx wires xxxxxxxxxxxxxxxxxxxxxx
--this procedure knows EXACTLY the algorithm used for drawing
--temporary wires in the rubber banding part
--not only crazy vertical
-- not only crazy horizontal 
--uses pos, sPos, n (for width), b (for firstHorizontal), l (for layer)
-- moves and copies xxxxxxxxxxxxxxxxxxxxxx
--Orientates the selection such that:
--takes the base rectangle, transforms orientation and translates the transformed rectangle 
--to fit its lower left point [after transformation] to be at the same point as the lower left 
--point of the base rectangle before the transformation. 
--If base is empty, use bbox of selection. 
--we dont want to import fancy imports; copy is logically deeper in hierachy
--TerminalIO.PutRope["step move up\n"];
--TerminalIO.PutRope["step move down\n"];
--TerminalIO.PutRope["step move left\n"];
--TerminalIO.PutRope["step move right\n"];
Κ-˜
codeš
œ*™*Kšœ
Οm
œ=™HKš
œ3™3K™>—K˜š
Οk	˜	Kš
œ
˜
Kšžœ
˜K˜	Kš
œ˜Kš
œ	˜	K˜K˜K˜K˜K˜K˜Kš
œ˜Kš
œ˜K˜—šΟnœžœ
ž˜Kšžœp˜w—Kš
ž˜K˜Kš
œ ™ K™šŸœžœžœžœžœžœ
žœ˜XKš
œ!˜!šžœžœ
žœžœ™-Kšœžœ'žœ
™BK™—Kš
œ˜—K™Kš
œ$™$K˜K˜šŸ
œžœžœžœžœžœ˜Fšžœ
žœž˜KšžœDžœžœ˜Z—Kšžœžœ
˜
Kš
œ˜—K˜šŸœžœžœžœžœžœ˜EK™*šžœžœ
˜Kš
œ
žœžœžœ
žœžœžœ˜NKš
œ
žœžœžœ
žœžœžœ˜MK˜—Kš
œ˜—K˜šŸ	œžœžœžœ
žœžœ	žœžœ˜yš
žœžœ
žœ
žœžœžœ
ž˜8Kš
žœžœ
žœžœ
žœ
˜3K˜Kš
œ@˜@Kšžœ
˜—Kš
œ˜—K˜š
œB™BKš
œ:™:K˜Kšœ	žœ˜Kšœ	žœžœ
˜Kšœžœ˜0—K˜šŸœžœžœžœ˜LKšœžœ(˜2šŸœžœ
žœžœžœžœ˜AKšžœžœžœ
žœ˜:Kš
œ˜—Kšœžœ˜%Kšœ%žœžœ$˜aKš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜šŸœžœ
žœžœ˜6Kš
œ$™$Kšœžœžœ
˜K™8š	žœžœ/žœžœ
ž˜Fšžœžœ˜Kšžœ$žœžœ
˜@K˜—Kšžœ
˜—šžœžœ
žœ˜K™!Kšœžœ
˜Kš
œA™AKš
œ#˜#Kš
œ"˜"Kš
œ.˜.Kš
œ
˜
—šžœ˜K™?š	žœžœ/žœžœ
ž˜Fšžœžœ˜šžœ$žœ˜,Kš
œ=˜=Kš
ž˜Kš
œ
˜
—K˜—Kšžœ
˜—Kš
œ)˜)K˜
—Kš
œ˜K˜—šŸœžœ
žœžœ˜8Kš
œ&™&Kšœžœ@žœ˜Nšžœžœ
žœ˜Kšœžœ
˜Kš
œ#˜#Kš
œ8™8Kš
œ$˜$Kš
œ˜—Kš
œ/˜/Kš
œ˜K˜—šŸ
œžœ
žœžœžœ
žœ˜Sš	žœžœ/žœžœ
ž˜Fšžœžœ˜šžœ:žœ
˜Ašžœžœ7žœ˜QKšœžœ
˜Kšœ&žœ˜-K˜——K˜—Kšžœ
˜—Kš
œ˜K˜—šŸœžœ
žœžœžœ
žœ˜Uš	žœžœ/žœžœ
ž˜Fšžœžœ˜šžœ:žœ
˜Ašžœžœ7žœ˜QKšœžœ
˜Kš
œ&˜&K˜——K˜—Kšžœ
˜—Kš
œ˜—K˜šŸœžœ ˜9Kš
œ&˜&Kšœžœ˜&Kš
œ˜Kš
œ˜Kš
œ˜K˜—šŸœžœ
žœžœžœ
žœ	žœžœ
žœžœ
žœ˜Ž
šŸœžœžœ
žœ˜*šžœžœ˜Kšœ
žœ
˜Kš
œ˜K˜
—Kš
œ˜—šŸœžœžœ˜.š	žœžœžœžœ
ž˜4Kš
œ˜Kš
ž˜—Kš
œ˜—šŸœžœžœžœžœžœ˜EKšœ
žœ#žœ$˜QK˜—KšœžœžœΟc"˜;š	žœžœ/žœžœ
ž˜Fšžœžœ˜$Kš
 ™šžœžœ˜Kš
œ˜Kš
œ'˜'Kšžœ	žœ3˜BKš
ž˜Kš
œ
˜
—Kšžœ
žœžœ
žœ˜$Kš
œ
˜
—Kšžœ˜Kšžœ
˜—Kš
 5™5šžœžœ
žœ˜Kšœžœ˜Kš
œ$˜$Kšœ#žœ˜*Kšžœ	žœ/˜>K˜
—šžœ˜Kšœžœ
˜
Kšžœ	žœ$˜3K˜
—Kš
œ˜K˜—šŸœžœ
žœžœžœ
žœžœžœžœ˜Ž
šžœ1žœ˜9Kšœžœžœ
˜š	žœžœ/žœžœ
ž˜FKšœžœ8˜=Kšžœžœ%žœ˜QKšžœ
˜—šžœžœ
žœ˜Kšœžœ
˜Kšœ#žœ˜*Kšžœ	žœI˜XK˜
—K˜
—Kš
œ˜K˜—šŸœžœ ˜;Kš
œ$™$Kš
œQ™QKš
œ˜Kš
œ.˜.Kš
œ˜Kš
œ˜K˜—šŸœžœ ˜DKš
 2™2Kšœžœs˜|Kš
œI˜IKšœ.žœ	˜;Kš
œ˜Kš
œ˜K˜—šŸœžœ ˜7Kš
œ$™$Kš
œQ™QK™"K™'Kš
œ˜Kšžœžœ žœ˜HKšœ3žœ˜=Kš
œ˜Kš
œ˜—K˜šΠbnœžœ ˜9šŸœžœ
žœžœžœžœ˜AKšžœžœžœ
žœ˜9Kš
œ˜—Kšœžœ(˜2šžœ"˜$Kšžœ˜Kšžœ˜—Kš
œ˜K˜—š‘œžœ ˜9šžœžœ˜"Kš
œ*˜*Kšœ)žœ˜/K˜
—Kšžœ'˜+Kš
œ˜Kš
œ˜Kš
œ˜K˜—šŸœžœ ˜9Kš
œ)˜)Kš
œ ˜ Kš
œ˜Kš
œ˜K˜—šŸœžœ
žœžœžœ
žœžœžœ
žœ˜jKšœžœžœ
˜š	žœžœ/žœžœ
ž˜Fšžœžœ˜Kšžœ	žœ$žœ˜DK˜—Kšžœ
˜—šžœžœ
žœ˜Kšœžœ
˜Kšœžœ
˜Kš
œ!˜!K˜
—Kš
œ˜—K˜šŸœžœ ˜>Kš
œ)˜)Kšœ)žœ˜/Kš
œ˜Kš
œ˜K˜—šŸœžœ!˜7Kš
œ'˜'Kš
œ˜Kš
œ˜Kš
œ˜K˜—šŸœžœ ˜5Kš
œ'˜'Kšœžœ
˜%Kš
œ˜K˜—šŸ
œžœ ˜3Kšœžœ˜
Kš
œ$˜$Kšœžœ˜%š	žœžœ4žœžœ
ž˜KKš
œ˜Kšžœ
˜—Kš
œ;˜;Kš
œ˜—K˜šŸœžœ ˜7Kš
œ/˜/Kš
œ=˜=Kš
œ˜—K˜šŸœžœ ˜8Kš
œ(™(šŸœžœ
žœžœžœžœ˜=Kšžœžœžœ
žœ˜9Kš
œ˜—Kšœžœ(˜2Kšžœžœ˜>šžœ˜Kš
œ/˜/Kš
œ=˜=K˜
—Kš
œ˜—K˜šŸœžœ ˜?Kš
œ3˜3Kšœ>žœ
˜CKš
œ˜—K˜šŸœžœ ˜8Kš
œ%˜%Kšœžœ˜&Kš
œ=˜=Kš
œ˜—K˜šŸ
œžœ ˜3Kš
œ™Kš
œ"˜"Kšžœžœ ˜:KšžœA˜EKš
œ˜Kš
œ˜—K˜šŸœžœ ˜6Kš
œ(˜(Kš
œ?˜?Kš
œ˜—K˜šŸœžœ ˜>Kš
œ,˜,Kšœ@žœ
˜EKš
œ˜—K˜K˜Kš
œ*™*K™šŸœžœ
žœ˜,Kšœžœžœ˜7Kš
œ^˜^Kš
œ'˜'K˜!š	žœžœ!žœžœ
ž˜8Kš
œ˜Kšœ&žœ˜,Kšžœ
˜—Kšžœ	žœ1˜@Kšžœ9˜=Kš
œ˜K˜—šŸœžœ ˜8Kš
œ(˜(Kš
œ˜Kš
œ˜Kš
œ˜K˜—šŸœžœ ˜2Kšœžœ1˜7Kš
œ#˜#Kš
œ+˜+Kš
œ˜K˜—šŸ	œžœ ˜/Kš
œ6˜6Kš
œ,˜,Kš
œ˜—K˜Kš
œ"™"K˜š
Ÿœžœ
žœžœžœ˜@Kšžœžœ0˜Mšžœ˜Kšœžœ˜"Kšœžœ#˜)šžœžœ˜Kšœžœ'˜,Kš
œ˜Kš
œ˜—Kš
œ˜K˜
—Kš
œ˜K˜—šŸœžœ(žœ
žœ˜LKš
œ=™=Kš
œ,™,Kšœžœ˜ Kšœžœ˜Kšœžœ˜Kšžœ
žœžœ˜0Kš
œ#˜#šžœ
 œžœ˜$šžœžœ˜0Kšžœžœžœ ˜Mšžœ
žœ/žœ
˜<Kšœ/ž˜5Kš
œ˜—Kš
œ˜Kš
œ<˜<Kš
ž˜Kš
œ˜—Kšœ œ	™šžœžœžœ ˜IKš
œ˜Kš
œ;˜;Kš
œ
˜
—šžœ ˜#Kšžœžœ˜3Kšžœžœ0˜;Kš
œ˜Kš
œ<˜<Kšžœžœ
žœ
˜Kš
œF˜FKš
œ<˜<Kš
œ
˜
—K˜
—šžœ ˜"šžœžœ˜1Kšžœžœžœ ˜Ošžœ
žœ/žœ
˜<Kšœ/ž˜5Kš
œ˜—Kš
œ˜Kš
œ<˜<Kš
ž˜K˜—Kšœ œ
 
œ
™šžœžœžœ ˜GKš
œ˜Kš
œ;˜;Kš
œ
˜
—šžœ ˜!Kšžœžœ˜3Kšžœžœ2˜=Kš
œ˜Kš
œ<˜<Kšžœžœ
žœ
˜Kš
œF˜FKš
œ<˜<Kš
œ
˜
—K˜
—Kš
œ˜—K˜šŸœžœ ˜1Kš
œ#˜#Kš
œD˜DKš
œ˜—K˜šŸœžœ ˜1Kš
œG™GKšœ'žœ
˜-Kš
œ˜—K˜šŸœžœ ˜6Kšœ'žœ
˜,Kš
œ˜—K˜Kš
œ*™*K˜š
Ÿœžœ
žœžœžœ˜JKšœžœ%˜.šžœž˜$Kšœ2žœ
˜7—šžœ˜Kš
œ˜Kšœ +˜HKš
œ
˜
—Kš
œ˜—K˜š
Ÿœžœ
žœžœžœ˜bKš
œ%™%Kš
œ\™\Kš
œ_™_Kš
œ9™9Kš
œ+™+Kšœžœžœ'žœ˜eKšœžœA˜HKšžœžœ
žœ
žœ
˜Kš
œ'˜'Kšžœžœ'˜GKš
œ˜Kš
œ˜Jš
œ ˜ Jš
œE˜EKš
œ#˜#Jš
œ@˜@š	žœžœžœžœ
ž˜3KšœžœM˜^Kš
œH˜HKšžœ
˜—Kš
œ˜Kš
œa˜aKš
œ˜K˜—šŸœžœ
žœžœ˜?KšœžœA˜HKšœ
žœ˜#š	žœžœžœžœ
ž˜3Kšœžœ˜Kš
œD˜DKš
œ<˜<Kšžœ
˜—K˜%Kš
œ˜K˜—š
Ÿœžœ
žœ
žœžœ˜FKšœžœžœ
˜KšœžœA˜HKšœ
žœ(˜4š	žœžœžœžœ
ž˜3Kšœžœ&˜.Kš
œ<˜<Kšœž˜Kšœžœ˜Kšœžœ
˜Kšžœ
˜—Kšœ'žœ˜.Kš
œ&˜&Kš
œ˜K˜—šŸ
œžœ ˜0Kšœžœ
˜Kš
œ"˜"˜Kš
œ˜Kšœžœ;˜G—šžœž˜
š
œ(˜(Kš
œ&˜&—š
œ(˜(Kš
œ'˜'Kš
œ&˜&—š
œ'˜'Kš
œ'˜'—š
œ'˜'Kš
œ(˜(—š
œ'˜'Kš
œ(˜(—Kšžœ$˜+—Kš
œ˜K˜—šŸœžœ ˜*Kš
œ0˜0Kš
œ%˜%Kš
œ˜K˜—šŸœžœ ˜-Kš
œ)˜)Kš
œ$˜$Kš
œ˜K˜—šŸœžœ ˜.Kš
œ)˜)Kš
œ(˜(Kš
œ˜K˜—šŸœžœ ˜8Kš
œ*˜*Kšœ*žœ:˜fKš
œ˜—K˜šŸœžœ ˜2šžœžœžœ˜;šžœžœ
žœžœ
žœžœ	žœ˜RKš
 L™LJš
œU˜Ušžœžœ
˜	Kšžœ?˜CKšžœ:˜>—Kš
ž˜K˜—Kš
œ˜Kšœžœ:˜VK˜
—Kšžœ*˜.Kš
œ˜K˜—šŸœžœžœžœ˜EKšœžœ˜ Kš
œO˜Ošžœžœ˜Kš
œ ˜ Kšžœžœ˜)Kš
œ
˜
—Kš
œ˜—K˜šŸ	œžœ ˜/Kš
œ'™'Kš
œ.˜.Kš
œ˜K˜—šŸœžœ ˜1Kš
œ)™)Kš
œ/˜/Kš
œ˜K˜—šŸœžœ ˜1Kš
œ)™)Kš
œ/˜/Kš
œ˜K˜—šŸœžœ ˜2Kš
œ*™*Kš
œ.˜.Kš
œ˜—K˜šŸœžœ ˜2Kšœžœžœ
˜Kš
œ?˜?K˜.Kš
œ-˜-Kšžœžœžœ"˜PKš
œ˜K˜—K˜Kšœžœ ˜=K˜K˜5Kš
œ5˜5K˜>K˜;K˜3Kš
œC˜CK˜Kš
œJ˜JKš
œN˜NKš
œ`˜`Kš
œO˜OKš
œF˜FK˜Kš
œN˜NKš
œI˜IKš
œD˜DKš
œB˜BKš
œL˜LKš
œN˜NK˜Kš
œJ˜JKš
œZ˜ZKš
œL˜LKš
œN˜NK˜Kš
œH˜HKš
œX˜XKš
œB˜BK˜Kš
œ9˜9K˜3Kš
œ4˜4Kš
œ8˜8Kš
œ8˜8Kš
œ:˜:K˜*K˜2K˜0K˜6Kš
œ:˜:Kšžœ
˜—…—T’w