DIRECTORY
CD,
CDBasics,
CDCallSpecific,
CDCommandOps,
CDExtras,
CDInstances,
CDLayers,
CDMenus,
CDOps,
CDPanel, 
CDProperties,
CDRects,
CDSequencer,
CDSimpleOps,
CDValue,
CDViewer,
CDVPrivate,
CDVScale,
IO,
Rope,
TerminalIO,
ViewerClasses USING [Viewer];

CDExtraCommands: CEDAR PROGRAM
IMPORTS CD, CDBasics, CDCallSpecific, CDCommandOps, CDExtras, CDInstances, CDLayers, CDMenus, CDOps, CDPanel, CDProperties, CDRects, CDSequencer, CDSimpleOps, CDValue, CDViewer, CDVScale, IO, Rope, TerminalIO = 
BEGIN

verbosity: INT _ 1;  

CoordinatesCommand: PROC [comm: CDSequencer.Command] =
BEGIN
WriteInLambda: PROC [n: CD.Number] = {
TerminalIO.WriteRope[CDExtras.ToLambda[n, lambda]]
};
lambda: INT _ comm.design.technology.lambda;
TerminalIO.WriteRope["Coordinates [\024]"]; -- \024 prints as greek lambda
TerminalIO.WriteRope["   down: ("];
WriteInLambda[comm.sPos.x];
TerminalIO.WriteRope[","];
WriteInLambda[comm.sPos.y];
TerminalIO.WriteRope[")   up: ("];
WriteInLambda[comm.pos.x];
TerminalIO.WriteRope[","];
WriteInLambda[comm.pos.y];
TerminalIO.WriteRope[")   dist: ("];
WriteInLambda[comm.pos.x-comm.sPos.x];
TerminalIO.WriteRope[","];
WriteInLambda[comm.pos.y-comm.sPos.y];
TerminalIO.WriteRope[")\n"];
END;

SetArrow: PROC [comm: CDSequencer.Command] =
BEGIN
WriteInLambda: PROC [n: CD.Number] = {
TerminalIO.WriteRope[CDExtras.ToLambda[n, lambda]]
};
lambda: INT _ comm.design.technology.lambda;
TerminalIO.WriteRope["set arrow at  ("];
WriteInLambda[comm.pos.x];
TerminalIO.WriteRope[","];
WriteInLambda[comm.pos.y];
TerminalIO.WriteRope[")\024\n"];
CDViewer.ShowArrow[comm.design, comm.pos];
END;

RemoveArrow: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["remove arrow\n"];
CDViewer.RemoveArrow[comm.design];
END;

ArrowInformation: PROC [comm: CDSequencer.Command] =
BEGIN
WriteInLambda: PROC [n: CD.Number] = {
TerminalIO.WriteRope[CDExtras.ToLambda[n, lambda]]
};
lambda: INT _ comm.design.technology.lambda;
WITH CDValue.Fetch[comm.design, $arrow, design] SELECT FROM
class: REF CD.Position => {
TerminalIO.WriteRope["  arrow at: ("];
WriteInLambda[class.x];
TerminalIO.WriteRope[","];
WriteInLambda[class.y];
TerminalIO.WriteRope[")   up: ("];
WriteInLambda[comm.pos.x];
TerminalIO.WriteRope[","];
WriteInLambda[comm.pos.y];
TerminalIO.WriteRope[")   dist: ("];
WriteInLambda[class.x-comm.pos.x];
TerminalIO.WriteRope[","];
WriteInLambda[class.y-comm.pos.y];
TerminalIO.WriteRope[")\n"];
}
ENDCASE => NULL;
END;

StatisticCommand: PROC [comm: CDSequencer.Command] =
BEGIN
WriteInLambda: PROC [n: CD.Number] = {
TerminalIO.WriteRope[CDExtras.ToLambda[n, lambda]]
};
lambda: INT _ comm.design.technology.lambda;
countTot: INT _ 0;
countSel: INT _ 0;
countInvis: INT _ 0;
isDesign: BOOL _ FALSE;
rect: CD.Rect _ CDBasics.universe;
v: ViewerClasses.Viewer _ CDViewer.GetViewer[comm];
inst: CD.Instance;
TerminalIO.WriteRope["statistic "];
IF v#NIL THEN rect _ CDViewer.VisibleRect[v];
IF ~CDBasics.NonEmpty[rect] THEN rect _ CDBasics.universe;
FOR l: CD.InstanceList _ CDOps.InstList[comm.design], l.rest WHILE l#NIL DO
countTot _ countTot+1;
IF l.first.selected THEN {
IF ~CDBasics.Intersect[rect, CDInstances.InstRectI[l.first]] THEN countInvis _ countInvis+1;
countSel _ countSel+1; 
inst _ l.first
}
ENDLOOP;
TerminalIO.WriteF["%g objects; %g  selected\n", IO.int[countTot], IO.int[countSel]];
IF countSel=1 THEN {
CDCommandOps.WriteInfo[inst, verbosity];
IF verbosity>0 THEN {
ir: CD.Position _ CD.InterestSize[inst.ob];
TerminalIO.WriteRope["  at: ("];
WriteInLambda[inst.location.x];
TerminalIO.WriteRope[","];
WriteInLambda[inst.location.y];
TerminalIO.WriteRope[")\024  i-size: ("]; --\024 prints as greek lambda
WriteInLambda[ir.x];
TerminalIO.WriteRope[","];
WriteInLambda[ir.y];
TerminalIO.WriteRope[")\024  orientation-code:"]; --\024 prints as greek lambda
TerminalIO.WriteInt[inst.orientation];
};
TerminalIO.WriteLn[];
};
ArrowInformation[comm];
IF countInvis#0 THEN 
TerminalIO.WriteF1["  **** %g invisible selected object(s)\n", IO.int[countInvis]];
END;

SelectIfLayer: CDCallSpecific.CallProc =
BEGIN
IF inst.ob.layer#NARROW[x, REF CD.Layer]^ THEN {done_FALSE; RETURN};
IF inst.selected THEN RETURN;
inst.selected _ TRUE;
repaintMe _ TRUE
END;

AddSelectLayer: PROC [comm: CDSequencer.Command] =
BEGIN
reflev: REF CD.Layer _ NEW[CD.Layer _ CDLayers.CurrentLayer[comm.design]];
n: INT _ CDCallSpecific.CallForAll[design: comm.design, whatElse: SelectIfLayer, x: reflev];
TerminalIO.WriteF["select all %g objects: (%g)\n", IO.rope[CDOps.LayerName[reflev^]], IO.int[n]];
END;

SetLayerCommand: PROC [comm: CDSequencer.Command] =
BEGIN
inst: CD.Instance = CDCommandOps.TheInstance[comm, "Set default layer"];
IF inst#NIL THEN {
layer: CD.Layer = inst.ob.layer;
IF inst.ob.class.wireTyped AND CDProperties.GetPropFromLayer[layer, $DontUse]=NIL THEN {
TerminalIO.WriteRope[Rope.Cat["  ", CDOps.LayerName[layer], "\n"]];
CDLayers.SetCurrentLayer[comm.design, layer];
}
ELSE TerminalIO.WriteRope["  NOT DONE\n"];
CDOps.ReOrderInstance[comm.design, inst]
}
END;

EnforcePanel: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["enforce a control panel\n"];
[] _ CDPanel.CreatePanel[comm.design]
END;

GetScaleRec: PROC [x: REF] RETURNS [CDVScale.ScaleRec] =
BEGIN
WITH x SELECT FROM
my: CDVPrivate.VRef => RETURN [my.scale]
ENDCASE => ERROR
END;

GridComm: PROC [comm: CDSequencer.Command] =
BEGIN
GetScaleRec: PROC [x: REF] RETURNS [CDVScale.ScaleRec] =
BEGIN
WITH x SELECT FROM
my: CDVPrivate.VRef => RETURN [my.scale]
ENDCASE => {
TerminalIO.WriteRope["no viewer\n"]; 
ERROR ABORTED
}
END;
scale: CDVScale.ScaleRec;
TerminalIO.WriteRope["move to grid positions\n"];
scale _ GetScaleRec[comm.ref];
FOR l: CD.InstanceList _ CDOps.InstList[comm.design], l.rest WHILE l#NIL DO
IF l.first.selected THEN {
pos: CD.Position _ CDBasics.BaseOfRect[CDInstances.InstRectI[l.first]];
vPos: CD.Position _ CDVScale.DesignToViewerPosition[scale, pos];
gridded: CD.Position _ CDVScale.ViewerToDesignPosition[scale, vPos];
CDCommandOps.RedrawInstance[comm.design, l.first];
l.first.location _ CDBasics.AddPoints[l.first.location, CDBasics.SubPoints[gridded, pos]];
CDCommandOps.RedrawInstance[comm.design, l.first, FALSE];
};
ENDLOOP;
END;

IncreaseByWidthComm: PROC [comm: CDSequencer.Command] =
BEGIN
cnt: INT _ 0;
TerminalIO.WriteRope["increase wire length by width: "];
FOR l: CD.InstanceList _ CDOps.InstList[comm.design], l.rest WHILE l#NIL DO
IF l.first.selected AND l.first.ob.class.wireTyped AND ~l.first.ob.class.symbolic THEN {
oldSize: CD.Position _ l.first.ob.size;
newSize: CD.Position _ [x: oldSize.x, y: oldSize.x+oldSize.y];
newOb: CD.Object _ CDRects.CreateRect[newSize, l.first.ob.layer];
IF newOb#NIL THEN {l.first.ob _ newOb; cnt _ cnt+1};
CDCommandOps.RedrawInstance[comm.design, l.first, TRUE];
};
ENDLOOP;
TerminalIO.WriteF1["  %g objects\n", IO.int[cnt]];
END;

ShowErrorComm: PROCEDURE [comm: CDSequencer.Command] = 
BEGIN
applList: CD.InstanceList = CDOps.InstList[comm.design];
foundSome: BOOL _ FALSE;
TerminalIO.WriteRope[ "Show error "];
FOR a: CD.InstanceList _ applList, a.rest WHILE a#NIL DO
IF a.first.ob.layer=CD.highLightError THEN {
inst: CD.Instance = a.first;
foundSome _ TRUE;
IF ~inst.selected THEN {
eRect: CD.Rect = CDInstances.InstRectI[inst];
inst.selected _ TRUE;
CDOps.DelayedRedraw[comm.design, eRect, FALSE];
CDCommandOps.WriteInfo[inst];
TerminalIO.WriteLn[];
FOR vl: CDViewer.ViewerList _ CDViewer.ViewersOf[comm], vl.rest  WHILE vl#NIL DO
CDViewer.ShowAndScale[viewer: vl.first, rect: CDBasics.Extend[eRect, 30*comm.design.technology.lambda] ];
ENDLOOP;
CDOps.ReOrderInstance[comm.design, inst];
EXIT
}
};
REPEAT FINISHED =>
IF foundSome THEN TerminalIO.WriteRope["All errors in this cell are already selected\n"]
ELSE TerminalIO.WriteRope[ "No errors in this cell\n"]
ENDLOOP;
END;

SelectAllErrorsComm: PROC [comm: CDSequencer.Command] =
BEGIN
cnt: INT _ 0;
CDSimpleOps.DeselectAll[comm.design];
FOR l: CD.InstanceList _ CDOps.InstList[comm.design], l.rest WHILE l#NIL DO
IF l.first.ob.layer=CD.highLightError THEN {
cnt _ cnt+1;
l.first.selected _ TRUE;
CDCommandOps.RedrawInstance[comm.design, l.first, FALSE]
}
ENDLOOP;
TerminalIO.WriteF["%g error(s) selected\n", IO.int[cnt]];
END;

lambda: CD.Number = 1;
CDSequencer.ImplementCommand[$SetLayerP, SetLayerCommand,, doQueue];
CDSequencer.ImplementCommand[$AddSelectLayer, AddSelectLayer,, doQueue];
CDSequencer.ImplementCommand[$Coordinates, CoordinatesCommand,, doQueue];
CDSequencer.ImplementCommand[$Statistic, StatisticCommand,, doQueue];
CDSequencer.ImplementCommand[$SetArrow, SetArrow,, doQueue];
CDSequencer.ImplementCommand[$RemoveArrow, RemoveArrow,, doQueue];
CDSequencer.ImplementCommand[$EnforcePanel, EnforcePanel,, doQueue];
CDSequencer.ImplementCommand[$MoveToGrid, GridComm,, doQueue];
CDSequencer.ImplementCommand[$IncreaseByWidth, IncreaseByWidthComm];
CDCommandOps.ImplementSpecificCommand[specificAtom: $Lengthen, tipBase: "Widen", useFor: "SFXA", x: NEW[CD.Position_[lambda, 0]]];
CDCommandOps.ImplementSpecificCommand[specificAtom: $Lengthen, tipBase: "Narrow", useFor: "SFXA", x: NEW[CD.Position_[-lambda, 0]]];
CDCommandOps.ImplementSpecificCommand[specificAtom: $Lengthen, tipBase: "Shorten", useFor: "SFXA", x: NEW[CD.Position_[0, -lambda]]];
CDCommandOps.ImplementSpecificCommand[specificAtom: $Lengthen, tipBase: "Lengthen", useFor: "SFXA", x: NEW[CD.Position_[0, lambda]]];
CDCommandOps.ImplementSpecificCommand[specificAtom: $Default, useFor: "SFXA"];
CDCommandOps.ImplementSpecificCommand[specificAtom: $IncCount, text: "Inc count", useFor: "SFXA"];
CDCommandOps.ImplementSpecificCommand[specificAtom: $DecCount, text: "Dec count", useFor: "SFXA"];
CDSequencer.ImplementCommand[$ShowErrors, ShowErrorComm,, doQueue];
CDMenus.CreateEntry[menu: $SpecialMenu, entry: "select next error", key: $ShowErrors];
CDSequencer.ImplementCommand[a: $SelectAllErrors, p: SelectAllErrorsComm, queue: doQueue];
CDMenus.CreateEntry[menu: $SpecialMenu, entry: "select all error msg's", key: $SelectAllErrors];
END.
ήCDExtraCommands.mesa   (part of ChipNDale)
Copyright c 1983, 1985 by Xerox Corporation.  All rights reserved.
by Christian Jacobi, July 11, 1983 3:42 pm 
last edited Christian Jacobi, January 2, 1986 11:57:15 am PST
Κ
Θ˜
codeš
œ*™*Kšœ
Οm
œ7™BKš
œ+™+Kš
œ=™=K˜—š
Οk	˜	Kšžœ
˜Kš
œ	˜	K˜Kš
œ
˜
Kš
œ	˜	Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ
˜
Kš
œ˜K˜Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ	˜	Kšžœ
˜Kš
œ˜K˜Kšœžœ
˜—K˜šΠlnœžœ
ž˜Kšžœ΅
žœ˜Σ
—Kš
ž˜K˜Kšœžœ˜K˜šΟnœžœ˜6Kš
ž˜š 
œžœžœ˜&Kš
œ2˜2Kšž
œ
˜—Kšœžœ!˜,Kšœ,Οc˜JK˜#Kš
œ˜K˜Kš
œ˜K˜"Kš
œ˜K˜Kš
œ˜K˜$Kš
œ&˜&K˜Kš
œ&˜&K˜Kšžœ
˜K˜—š œžœ˜,Kš
ž˜š 
œžœžœ˜&Kš
œ2˜2Kšž
œ
˜—Kšœžœ!˜,Kš
œ(˜(Kš
œ˜K˜Kš
œ˜K˜ Kš
œ*˜*Kšžœ
˜—K˜š œžœ˜/Kš
ž˜Kš
œ'˜'Kš
œ"˜"Kšžœ
˜—K˜š œžœ˜4Kš
ž˜š 
œžœžœ˜&Kš
œ2˜2Kšž
œ
˜—Kšœžœ!˜,šžœ,žœ
ž˜;šœžœ
žœ˜K˜&Kš
œ˜K˜Kš
œ˜K˜"Kš
œ˜K˜Kš
œ˜K˜$Kš
œ"˜"K˜Kš
œ"˜"K˜Kš
œ
˜
—Kšžœžœ
˜—Kšžœ
˜—K˜š œžœ˜4Kš
ž˜š 
œžœžœ˜&Kš
œ2˜2Kšž
œ
˜—Kšœžœ!˜,Kšœ
žœ˜Kšœ
žœ˜Kšœžœ˜Kšœ
žœ
žœ
˜Kšœžœ˜"Kš
œ3˜3Kšœžœ
˜Kš
œ#˜#Kšžœžœ
žœ ˜-Kšžœžœ˜:š	žœžœ4žœžœ
ž˜KKš
œ˜šžœžœ˜Kšžœ;žœ˜\Kš
œ˜Kš
œ˜Kš
œ
˜
—Kšžœ
˜—Kšœ0žœžœ˜Tšžœžœ˜Kš
œ(˜(šžœ
žœ˜Kš
œ+˜+Kš
œ ˜ Kš
œ˜K˜Kš
œ˜Kšœ*‘˜GKš
œ˜K˜Kš
œ˜Kšœ2‘˜OKš
œ&˜&K˜—Kš
œ˜Kš
œ˜—Kš
œ˜šžœžœ
˜Kšœ?žœ˜S—Kšžœ
˜K˜—š 
œ˜(Kš
ž˜Kšžœžœžœ
žœ	žœžœžœ˜DKšžœžœ
žœ
˜Kšœžœ
˜Kšœž˜Kšžœ
˜K˜—š œžœ˜2Kš
ž˜Kš	œžœ
žœ	žœ
žœ-˜JKšœžœV˜\Kšœ3žœžœ	˜aKšžœ
˜—K˜š œžœ˜3Kš
ž˜Kšœžœ@˜Hšžœžœ
žœ˜Kšœžœ˜ šžœžœ0žœ
žœ˜XKš
œC˜CKš
œ-˜-K˜
—Kšžœ&˜*Kš
œ(˜(Kš
œ
˜
—Kšžœ
˜—K˜š œžœ˜0Kš
ž˜Kš
œ2˜2Kš
œ%˜%Kšžœ
˜—K˜š œžœ
žœ˜8Kš
ž˜šžœžœ
ž˜Kšœžœ˜(Kšžœž˜—Kšžœ
˜—K˜š œžœ˜,Kš
ž˜š œžœžœžœ˜8Kš
ž˜šžœžœ
ž˜Kšœžœ˜(šžœ˜Kš
œ%˜%Kšžœ
ž˜
K˜
——Kšžœ
˜—Kš
œ˜Kš
œ1˜1Kš
œ˜š	žœžœ4žœžœ
ž˜Kšžœžœ˜Kšœžœ@˜GKšœžœ8˜@Kšœ	žœ9˜DKš
œ2˜2Kš
œZ˜ZKšœ2žœ˜9Kš
œ˜—Kšžœ
˜—Kšžœ
˜—K˜š œžœ˜7Kš
ž˜Kšœžœ˜
Kš
œ8˜8š	žœžœ4žœžœ
ž˜Kšžœžœžœžœ˜XKšœ	žœ˜'Kšœ	žœ3˜>Kšœžœ8˜AKšžœžœ
žœ#˜4Kšœ2žœ˜8Kš
œ˜—Kšžœ
˜—Kšœ%žœ˜2Kšžœ
˜—K˜š 
œž	œ˜7Kš
ž˜Kšœ
žœ,˜8Kšœžœžœ
˜Kš
œ%˜%š	žœžœ!žœžœ
ž˜8šžœžœžœ˜,Kšœžœ˜Kšœžœ
˜šžœžœ˜Kšœžœ$˜-Kšœžœ
˜Kšœ(žœ˜/Kš
œ˜Kš
œ˜šžœ>žœžœ
ž˜PKš
œi˜iKšžœ
˜—Kš
œ)˜)Kš
ž˜K˜
—K˜—šžœ
žœ˜KšžœžœG˜XKšžœ2˜6—Kšžœ
˜—Kšžœ
˜—K˜š œžœ˜7Kš
ž˜Kšœžœ˜
Kš
œ%˜%š	žœžœ4žœžœ
ž˜Kšžœžœžœ˜,Kš
œ˜Kšœžœ
˜Kšœ2žœ
˜8K˜
—Kšžœ
˜—Kšœ,žœ˜9Kšžœ
˜—K˜Kšœžœ˜Kš
œD˜DKš
œH˜HKš
œI˜IKš
œE˜EKš
œ<˜<Kš
œB˜BK˜DKš
œ>˜>Kš
œD˜DKšœdžœ
žœ˜‚
Kšœežœ
žœž
œ
˜„
Kšœfžœ
žœ˜…
Kšœgžœ
žœ˜…
Kš
œN˜NKš
œb˜bKš
œb˜bKš
œC˜CKš
œV˜VKš
œZ˜ZKš
œ`˜`Kšžœ
˜—…—&ϊ2