
<<CDExtraCommands.mesa   (part of ChipNDale)>>
<<Copyright © 1983, 1985 by Xerox Corporation.  All rights reserved.>>
<<by Christian Jacobi, July 11, 1983 3:42 pm >>
<<last edited Christian Jacobi, August 16, 1985 10:42:05 am PDT>>

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

CDExtraCommands: CEDAR PROGRAM
IMPORTS CDInstances, CDCommandOps, CDBasics, CDOps, CDPanel, CDProperties, CDSequencer, CDValue, TerminalIO, CDCallSpecific, 
CDExtras, CDVScale, CDViewer, Rope = 
BEGIN

verbosity: INT _ 1;  

WriteInLambda: PROC [n: CD.Number] = 
BEGIN
TerminalIO.WriteRope[CDExtras.ToLambda[n]]
END;

CoordinatesCommand: PROC [comm: CDSequencer.Command] =
BEGIN
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
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
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
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.WriteInt[countTot]; TerminalIO.WriteRope[" objects;"]; 
TerminalIO.WriteInt[countSel]; TerminalIO.WriteRope[" selected"]; 
TerminalIO.WriteLn[];
IF countSel=1 THEN {
CDCommandOps.WriteInfo[inst, verbosity];
IF verbosity>0 THEN {
TerminalIO.WriteRope["  at: ("];
WriteInLambda[inst.location.x];
TerminalIO.WriteRope[","];
WriteInLambda[inst.location.y];
TerminalIO.WriteRope[")\024  size: ("]; --\024 prints as greek lambda
WriteInLambda[inst.ob.size.x];
TerminalIO.WriteRope[","];
WriteInLambda[inst.ob.size.y];
TerminalIO.WriteRope[")\024  orientation-code:"]; --\024 prints as greek lambda
TerminalIO.WriteInt[inst.orientation];
};
TerminalIO.WriteLn[];
};
ArrowInformation[comm];
IF countInvis#0 THEN {
TerminalIO.WriteRope["  **** "]; TerminalIO.WriteInt[countInvis]; 
TerminalIO.WriteRope[" invisible selected object(s)"]; 
TerminalIO.WriteLn[];
};
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
n: INT;
reflev: REF CD.Layer _ NEW[CD.Layer_CDPanel.FetchDefaultLayer[comm.design]];
TerminalIO.WriteRope["select all of current layer: ("];
n _ CDCallSpecific.CallForAll[design: comm.design, whatElse: SelectIfLayer, x: reflev];
TerminalIO.WriteInt[n]; 
TerminalIO.WriteRope[") objects\n"];
END;

SpecifyAlter: PROC [] RETURNS [code: ATOM_NIL, x: REF_NIL] =
BEGIN
step: CD.Number = CD.lambda;
SELECT TerminalIO.RequestSelection["alter", LIST["dec w", "dec l", "inc w", "inc l", "dec par", "inc par"]] FROM
1 => {code _ $ChangeExt; x _ NEW[CD.Position_[-step, 0]]};
2 => {code _ $ChangeExt; x _ NEW[CD.Position_[0, -step]]};
3 => {code _ $ChangeExt; x _ NEW[CD.Position_[step, 0]]};
4 => {code _ $ChangeExt; x _ NEW[CD.Position_[0, step]]};
5 => {code _ $ChangeParam; x _ NEW[CD.Number_-step]};
6 => {code _ $ChangeParam; x _ NEW[CD.Number_step]};
ENDCASE => {code _ NIL}
END;

AlterSelected: PROC [comm: CDSequencer.Command] =
BEGIN
code: ATOM;
x: REF;
n: CARDINAL;
TerminalIO.WriteRope["alter selected: "];
[code, x] _ SpecifyAlter[];
n _ CDCallSpecific.CallForSelected[design: comm.design, objectSpecific: code, x: x];
TerminalIO.WriteInt[n]; TerminalIO.WriteRope[" objects altered\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"]];
CDPanel.StoreDefaultLayer[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.MyGraphicRef => 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.MyGraphicRef => 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;

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[$AlterS, AlterSelected];
CDSequencer.ImplementCommand[$EnforcePanel, EnforcePanel,, doQueue];
CDSequencer.ImplementCommand[$MoveToGrid, GridComm,, doQueue];
CDCommandOps.ImplementSpecificCommand[specificAtom: $Expand, useFor: "SPFXA"];
CDCommandOps.ImplementSpecificCommand[specificAtom: $Lengthen, tipBase: "Widen", useFor: "SPFXA", x: NEW[CD.Position_[CD.lambda, 
0]]];
CDCommandOps.ImplementSpecificCommand[specificAtom: $Lengthen, tipBase: "Narrow", useFor: "SPFXA", x: NEW[CD.Position_[-CD.lambda, 
0]]];
CDCommandOps.ImplementSpecificCommand[specificAtom: $Lengthen, tipBase: "Shorten", useFor: "SPFXA", x: NEW[CD.Position_[0, 
-CD.lambda]]];
CDCommandOps.ImplementSpecificCommand[specificAtom: $Lengthen, tipBase: "Lengthen", useFor: "SPFXA", x: NEW[CD.Position_[0, 
CD.lambda]]];
CDCommandOps.ImplementSpecificCommand[specificAtom: $Default, useFor: "SPFXA"];
CDCommandOps.ImplementSpecificCommand[specificAtom: $IncCount, text: "Inc count", useFor: "SPFXA"];
CDCommandOps.ImplementSpecificCommand[specificAtom: $DecCount, text: "Dec count", useFor: "SPFXA"];
END.