DIRECTORY
CD,
CDBasics,
CDDrawQueue,
CDCells,
CDEnvironment,
CDEvents,
CDInstances,
CDOps, 
CDPanel,
CDProperties,
CDSequencer,
CDValue,
CDViewer,
CDViewerInternals,
CDVPrivate,
CDVScale,
IO,
PopUpSelection,
Process,
Rope,
TerminalIO,
UserProfile,
ViewerClasses USING [Viewer],
ViewerOps USING [PaintViewer, GetViewer, SetViewer, OpenIcon, BlinkIcon];

CDVCommands: CEDAR PROGRAM
IMPORTS CDBasics, CDDrawQueue, CDCells, CDEnvironment, CDEvents, CDInstances, CDOps, CDPanel, CDProperties, CDSequencer, CDValue, CDViewer, CDVScale, IO, PopUpSelection, Process, Rope, TerminalIO, UserProfile, ViewerOps
EXPORTS CDViewerInternals = 
BEGIN

VRef: TYPE = CDVPrivate.VRef;


DoWithVRef: PROC [comm: CDSequencer.Command, proc: PROC[vRef: VRef]] = {
v: ViewerClasses.Viewer _ CDViewer.GetViewer[comm];
IF v=NIL THEN TerminalIO.PutRope["failed: no viewer\n"]
ELSE WITH v.data SELECT FROM
vRef: VRef => IF ~vRef.viewer.destroyed THEN proc[vRef];
ENDCASE => NULL;
}; 

AddCR: PROC [r: Rope.ROPE] RETURNS [Rope.ROPE] = {
ml: INT _ Rope.Length[r];
IF Rope.Fetch[r, ml-1]#'\n THEN RETURN[Rope.Concat[r, "\n"]];
RETURN [r];
};

MsgAndVRef: PROC [comm: CDSequencer.Command, msg: Rope.ROPE] RETURNS [vRef: VRef_NIL] = {
v: ViewerClasses.Viewer _ CDViewer.GetViewer[comm];
TerminalIO.PutRope[AddCR[msg]];
IF v=NIL THEN TerminalIO.PutRope[" failed: no viewer\n"]
ELSE WITH v.data SELECT FROM
vr: VRef => 
IF ~vr.viewer.destroyed THEN vRef _ vr 
ELSE TerminalIO.PutRope[" failed: viewer destroyed\n"];
ENDCASE => TerminalIO.PutRope[" failed: no ChipNDale viewer\n"];
};

Repaint: PROC [v: REF] = {
WITH v SELECT FROM
vRef: VRef => {
CDDrawQueue.Flush[vRef.ct];
CDDrawQueue.QueueInsertDrawCommand[vRef.ct, CDDrawQueue.Request[$changeScale, CDBasics.universe]];
};
viewer: ViewerClasses.Viewer => Repaint[viewer.data];
comm: CDSequencer.Command => Repaint[comm.ref];
ENDCASE => NULL;
};

SaveScale: PUBLIC PROC [viewer: ViewerClasses.Viewer] = {
IF viewer#NIL THEN 
WITH viewer.data SELECT FROM
vRef: VRef => CDProperties.PutProp[vRef.properties, $CDxSavedScale, NEW[CDVScale.ScaleRec _ vRef.scale]];
ENDCASE => NULL;
};

RestoreScale: PUBLIC PROC [viewer: ViewerClasses.Viewer] = {
IF viewer#NIL THEN 
WITH viewer.data SELECT FROM
vRef: VRef => {
GetScale: PROC [key: ATOM] RETURNS [CDVScale.ScaleRec] = {
WITH CDProperties.GetProp[vRef.properties, key] SELECT FROM
sr: REF CDVScale.ScaleRec => RETURN [sr^];
ENDCASE => RETURN [CDVScale.MakeScale[]];
};
scale: CDVScale.ScaleRec _ GetScale[$CDxSavedScale];
CDDrawQueue.Flush[vRef.ct];
IF vRef.scale.off=scale.off AND vRef.scale.nscale=scale.nscale THEN 
scale _ GetScale[$CDxSecondaryScale];
CDProperties.PutProp[vRef.properties, $CDxSecondaryScale, NEW[CDVScale.ScaleRec _ vRef.scale]];
vRef.intendedScale _ CDVScale.MakeScale[off: scale.off, nscale: scale.nscale, grid: vRef.scale.grid];
Repaint[vRef];
};
ENDCASE => NULL;
};

WriteLnScale: PROC [v: REF] = {
WITH v SELECT FROM
vRef: VRef => TerminalIO.PutF1[" (scale: %g)\n", IO.int[vRef.scale.nscale]];
viewer: ViewerClasses.Viewer => WriteLnScale[viewer.data];
comm: CDSequencer.Command => WriteLnScale[comm.ref];
ENDCASE => TerminalIO.PutRope["\n"];
};

ChangeScale: PROC [vRef: VRef, newScale: INT] = {
newScale _ MIN[MAX[0, newScale],  CDVScale.scaleNum-1];
IF vRef.scale.nscale = newScale THEN 
TerminalIO.PutRope["no scale change"]
ELSE {
oldDesignCenterOffset, newDesignCenterOffset: CD.Position;
viewerCenterOffset: CD.Position _ [vRef.viewer.cw/2, vRef.viewer.ch/2];
off: CD.Position _ vRef.scale.off;
dscale: CDVScale.ScaleRec;
CDDrawQueue.Flush[vRef.ct];
TerminalIO.PutRope["change scale"];
dscale _ CDVScale.MakeScale[nscale: vRef.scale.nscale, grid: vRef.scale.grid];
oldDesignCenterOffset _ CDVScale.ViewerToDesignPosition[dscale, viewerCenterOffset];
dscale _ CDVScale.MakeScale[nscale: newScale, grid: vRef.scale.grid];
newDesignCenterOffset _ CDVScale.ViewerToDesignPosition[dscale, viewerCenterOffset];
off _ CDBasics.SubPoints[
CDBasics.AddPoints[off, oldDesignCenterOffset], 
newDesignCenterOffset
];
dscale _ CDVScale.MakeScale[off: off, nscale: newScale, grid: vRef.scale.grid];
vRef.intendedScale _ dscale;
Repaint[vRef];
};
WriteLnScale[vRef.viewer];
};

ScaleUp: PROC [comm: CDSequencer.Command] = {
Do: PROC[vRef: VRef] = {
i: INT _ vRef.scale.nscale;
i _ IF i>0 THEN i-1 ELSE 0;
ChangeScale[vRef, i];
};
DoWithVRef[comm, Do]
};

ScaleDown: PROC [comm: CDSequencer.Command] = {
Do: PROC[vRef: VRef] = {ChangeScale[vRef, vRef.scale.nscale+1]}; 
DoWithVRef[comm, Do]
};

MoveScreen: PROC [comm: CDSequencer.Command] = {
Do: PROC[vRef: VRef] = {
off: CD.Position;
CDDrawQueue.Flush[vRef.ct];
off.x _ vRef.scale.off.x-(comm.pos.x-comm.sPos.x);
off.y _ vRef.scale.off.y-(comm.pos.y-comm.sPos.y); 
vRef.intendedScale _ CDVScale.MakeScale[off: off,nscale: vRef.scale.nscale,grid: vRef.scale.grid];
Repaint[vRef];
};
TerminalIO.PutRope["move window\n"];
DoWithVRef[comm, Do]
};

GetViewerInt: PROC [viewer: ViewerClasses.Viewer, at: ATOM] RETURNS [i: INT _ -1] = {
WITH ViewerOps.GetViewer[viewer, at] SELECT FROM
ri: REF INT => i _ ri^;
ENDCASE => NULL;
};

GridInfoComm: PROC [comm: CDSequencer.Command] = {
GridRope: PROC [v: ViewerClasses.Viewer] RETURNS [r: Rope.ROPE] = {
r _ CDOps.LambdaRope[GetViewerInt[viewer, $Grid], lambda]
};
g: INT _ -1;
lambda: INT _ comm.design.technology.lambda;
viewer: ViewerClasses.Viewer _ CDViewer.GetViewer[comm];
IF viewer=NIL THEN TerminalIO.PutRope["no viewer\n"]
ELSE {
TerminalIO.PutF1["set grid (currently %g)\n", [rope[GridRope[viewer]]]];
SELECT PopUpSelection.Request[
choice: LIST["1", " 2", " 4", " 8", "16", "1/2", "default", "type lambda", "type int"], 
header: "grid",
headerDoc: "distance used for snapping the cursor"] FROM
1 => g _ lambda; 
2 => g _ 2*lambda;
3 => g _ 4*lambda;
4 => g _ 8*lambda;
5 => g _ 16*lambda;
6 => g _ lambda/2;
7 => g _ CDValue.FetchInt[boundTo: CDViewer.DesignOf[viewer], key: $CDxInitGrid, propagation: global];
8 => g _ MIN[INT[2600/lambda], TerminalIO.RequestInt["grid: "]]*lambda;
9 => g _ MIN[INT[2600], TerminalIO.RequestInt["grid: "]];
ENDCASE => g _ -1;
IF g>0 AND g<=2600 THEN { 
ViewerOps.SetViewer[viewer: viewer, data: NEW[INT_g], op: $Grid];
TerminalIO.PutF1["   grid set to %g \n", IO.rope[CDOps.LambdaRope[g, lambda]]];
}
ELSE TerminalIO.PutRope["   failed \n"];
};
};

SetSimplificationComm: PROC[comm: CDSequencer.Command] = {
Do: PROC[vRef: VRef] = {
n: INT;
CDDrawQueue.Flush[vRef.ct];
n _ PopUpSelection.Request[
choice: LIST["very simplified", "simplified", "standard", "detailed", "very detailed", "show all"],
header: "viewer simplification treshold",
headerDoc: "the viewer simplification treshold is multiplied with the cell simplification treshold"
];
SELECT n FROM
1 => vRef.suppressFactorForCells _ 0.4;
2 => vRef.suppressFactorForCells _ 0.7; 
3 => vRef.suppressFactorForCells _ 1; 
4 => vRef.suppressFactorForCells _ 1.6;
5 => vRef.suppressFactorForCells _ 2.6;
6 => vRef.suppressFactorForCells _ 0;
ENDCASE => RETURN;
Repaint[vRef]
};
TerminalIO.PutRope["set viewer simplification threshold\n"];
DoWithVRef[comm, Do]
};

TicksInfoComm: PROC[comm: CDSequencer.Command] = {
ticks, n: INT _ -2;
lambda: INT _ comm.design.technology.lambda;
viewer: ViewerClasses.Viewer _ CDViewer.GetViewer[comm];
IF viewer=NIL THEN TerminalIO.PutRope["no viewer\n"]
ELSE {
ticks _ GetViewerInt[viewer, $Ticks];
TerminalIO.PutF1["input tick (currently%g)\n", IO.rope[CDOps.LambdaRope[ticks, lambda]]];
n _ PopUpSelection.Request[
choice: LIST["off", "  4", "  8", " 16", " 32", "type", "type int"], 
header: "Ticks",
headerDoc: "dots to help positioning; number for spacing of dots"
];
ticks _ -2;
SELECT n FROM
1 => ticks _ 0;
2 => ticks _ 4*lambda; 
3 => ticks _ 8*lambda; 
4 => ticks _ 16*lambda;
5 => ticks _ 32*lambda;
6 => {
n: INT _ TerminalIO.RequestInt["ticks: "];
IF n>=0 AND n<=LAST[INTEGER]/lambda-1 THEN ticks _ n*lambda
};
7 => {
n: INT _ TerminalIO.RequestInt["ticks (int): "];
IF n>=0 AND n<=LAST[INTEGER]-1 THEN ticks _ n
};
ENDCASE => NULL;
ViewerOps.SetViewer[viewer: viewer, data: NEW[INT_ticks], op: $Ticks];
IF ticks<-1 THEN TerminalIO.PutRope["   failed\n"] 
ELSE IF ticks<=0 THEN TerminalIO.PutRope["   ticks off\n"]
ELSE TerminalIO.PutF1["   ticks set to %g \n", IO.rope[CDOps.LambdaRope[ticks, lambda]]]
};
};

InstanceNames: PROC [comm: CDSequencer.Command] = {
v: ViewerClasses.Viewer ~ CDViewer.GetViewer[comm];
TerminalIO.PutRope["display instance names\n"]; 
IF v#NIL THEN 
ViewerOps.PaintViewer[v, client, FALSE, $DrawInstanceNames]
};

SignalNames: PROC [comm: CDSequencer.Command] = {
v: ViewerClasses.Viewer = CDViewer.GetViewer[comm];
TerminalIO.PutRope["display signal names\n"]; 
IF v#NIL THEN 
ViewerOps.PaintViewer[v, client, FALSE, $DrawSignalNames]
};

GetOppositViewer: PROC [comm: CDSequencer.Command] RETURNS [ViewerClasses.Viewer] = {
vl: CDViewer.ViewerList = CDViewer.ViewersOf[comm.design];
viewer: ViewerClasses.Viewer = CDViewer.GetViewer[comm];
onColor: BOOL = (viewer=NIL OR viewer.column=color);
FOR l: CDViewer.ViewerList _ vl, l.rest WHILE l#NIL DO
IF ~l.first.iconic THEN 
IF (l.first.column=color)#onColor THEN RETURN [l.first];
ENDLOOP;
FOR l: CDViewer.ViewerList _ vl, l.rest WHILE l#NIL DO
IF ~l.first.iconic THEN 
IF l.first.column#viewer.column THEN RETURN [l.first];
ENDLOOP;
FOR l: CDViewer.ViewerList _ vl, l.rest WHILE l#NIL DO
IF ~l.first.iconic THEN 
IF l.first#viewer THEN RETURN [l.first];
ENDLOOP;
RETURN [viewer];
};

ShowRectX: PROC [comm: CDSequencer.Command] = {

SmallScale: PROC [comm: CDSequencer.Command] RETURNS [BOOL] = {
min: CD.Number = 30;
RETURN [min>ABS[comm.pos.x-comm.sPos.x] AND min>ABS[comm.pos.y-comm.sPos.y]]
};

viewer: ViewerClasses.Viewer ~ GetOppositViewer[comm];
TerminalIO.PutRope["position a viewer\n"];
IF viewer#NIL THEN 
IF SmallScale[comm] THEN CDViewer.ShowPosition[viewer: viewer, pos: comm.sPos]
ELSE CDViewer.ShowAndScale[viewer: viewer, rect: CDBasics.ToRect[comm.pos, comm.sPos]];
};

RestoreViewComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["restore previous scale\n"];
RestoreScale[CDViewer.GetViewer[comm]];
};

ShowRect: PROC [comm: CDSequencer.Command] = {
viewer: ViewerClasses.Viewer ~ CDViewer.GetViewer[comm];
TerminalIO.PutRope["scale viewer"];
SaveScale[viewer];
IF comm.pos=comm.sPos THEN CDViewer.ShowPosition[viewer, comm.pos]
ELSE CDViewer.ShowAndScale[viewer, CDBasics.ToRect[comm.pos, comm.sPos]];
WriteLnScale[viewer];
};

ResetScaleComm: PROC [comm: CDSequencer.Command] = {

ResetScaleAll: PROC [viewer: ViewerClasses.Viewer] = {
b: CD.Rect;
TerminalIO.PutRope["reset scale (view all)"];
b _ CDOps.BoundingBox[CDViewer.DesignOf[viewer]];
IF CDBasics.NonEmpty[b] THEN CDViewer.ShowAndScale[viewer, b];
WriteLnScale[viewer];
};

viewer: ViewerClasses.Viewer _ CDViewer.GetViewer[comm];
IF viewer#NIL THEN {
SaveScale[viewer];
ResetScaleAll[viewer];
};
};

ResetScaleToSelectedComm: PROC [comm: CDSequencer.Command] = {
viewer: ViewerClasses.Viewer = CDViewer.GetViewer[comm];
TerminalIO.PutRope["reset scale to selection"];
IF viewer#NIL THEN {
b: CD.Rect _ CDInstances.BoundingRectO[list: CDOps.InstList[comm.design], selectedOnly: TRUE];
IF CDBasics.NonEmpty[b] THEN {
SaveScale[viewer];
CDViewer.ShowAndScale[viewer: viewer, rect: b];
WriteLnScale[viewer];
RETURN;
};
};
TerminalIO.PutRope["  no selection\n"];
};

ResetScaleToPushedComm: PROC [comm: CDSequencer.Command] = {
viewer: ViewerClasses.Viewer = CDViewer.GetViewer[comm];
IF viewer#NIL THEN {
b: CD.Rect;
SaveScale[viewer];
TerminalIO.PutRope["reset scale (to view all of pushed cell)"];
b _ CDInstances.BoundingRectO[list: CDOps.InstList[comm.design], selectedOnly: FALSE];
IF CDBasics.NonEmpty[b] THEN CDViewer.ShowAndScale[viewer, b];
WriteLnScale[viewer];
};
};

ShowViewers: PROC [comm: CDSequencer.Command] = {
Do: PROC[vRef: VRef] = {
CDDrawQueue.QueueInsertDrawCommand[vRef.ct, CDDrawQueue.Request[$ShowViewers,  CDBasics.universe]];
};
TerminalIO.PutRope["show viewers\n"];
DoWithVRef[comm, Do]
};

SplitViewer: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["split viewer\n"];
[] _ CDViewer.CreateViewer[comm.design, FALSE, FALSE]
};

SetCellSimplification: PROC [comm: CDSequencer.Command] = {
Do: PROC[vRef: VRef] =  {
scale: CDVScale.ScaleRec _ vRef.scale;
FOR l: CD.InstanceList _ CDOps.InstList[comm.design], l.rest WHILE l#NIL DO
IF l.first.selected AND CDCells.IsCell[l.first.ob] THEN {
simplifyOn: CD.Number _ CDVScale.DesignToViewerScalar[scale, l.first.ob.bbox.y2-l.first.ob.bbox.y1];
CDCells.SetSimplificationTreshhold[l.first.ob, simplifyOn, TRUE];
CDOps.RedrawInstance[comm.design, l.first];
};
ENDLOOP;
};
TerminalIO.PutRope["put visibility threshold to current scale\n"]; 
DoWithVRef[comm, Do]
};

EnforcePanel: PROC [comm: CDSequencer.Command] = {
v: ViewerClasses.Viewer;
TerminalIO.PutRope["enforce a control panel\n"];
v _ CDPanel.CreatePanel[comm.design];
IF v#NIL THEN {
IF v.iconic THEN ViewerOps.OpenIcon[v]
ELSE ViewerOps.BlinkIcon[v, 1, 1, 200]
};
};

FontSubstOnComm: PROC [comm: CDSequencer.Command] = {
vRef: VRef _ MsgAndVRef[comm, "viewer drawmode: substitute tioga fonts"];
IF vRef#NIL THEN {
vRef.specialFonts _ TRUE;
CDProperties.PutProp[comm.design, $CDxSubstituteFonts, $TRUE];
Repaint[vRef];
};
};

FontSubstOffComm: PROC [comm: CDSequencer.Command] = {
vRef: VRef _ MsgAndVRef[comm, "viewer drawmode: don't substitute tioga fonts"];
IF vRef#NIL THEN {
vRef.specialFonts _ FALSE;
CDProperties.PutProp[comm.design, $CDxSubstituteFonts, NIL];
Repaint[vRef];
};
};

DrawEnvComm: PROC [comm: CDSequencer.Command] = {
vRef: VRef _ MsgAndVRef[comm, "viewer drawmode: draw environment of pushed cells"];
IF vRef#NIL THEN {
vRef.environment _ TRUE;
CDProperties.PutProp[comm.design, $CDxDrawEnvironment, NIL];
Repaint[vRef];
};
};

DontDrawEnvComm: PROC [comm: CDSequencer.Command] = {
vRef: VRef _ MsgAndVRef[comm, "viewer drawmode: don't draw environment of pushed cells"];
IF vRef#NIL THEN {
vRef.environment _ FALSE;
CDProperties.PutProp[comm.design, $CDxDrawEnvironment, $FALSE];
Repaint[vRef];
};
};

DrawSymbolicsComm: PROC [comm: CDSequencer.Command] = {
vRef: VRef _ MsgAndVRef[comm, "viewer drawmode: draw symbolic objects"];
IF vRef#NIL THEN {
vRef.symbolics _ TRUE; 
CDProperties.PutProp[comm.design, $CDxDrawSymbolics, NIL];
Repaint[vRef];
};
};

DontDrawSymbolicsComm: PROC [comm: CDSequencer.Command] = {
vRef: VRef _ MsgAndVRef[comm, "viewer drawmode: don't draw symbolic objects"];
IF vRef#NIL THEN {
vRef.symbolics _ FALSE;
CDProperties.PutProp[comm.design, $CDxDrawSymbolics, $FALSE];
Repaint[vRef];
};
};

DrawBordersComm: PROC [comm: CDSequencer.Command] = {
vRef: VRef _ MsgAndVRef[comm, "viewer drawmode: draw with borders"];
IF vRef#NIL THEN {
vRef.borders _ TRUE;
CDProperties.PutProp[comm.design, $CDxSkipBorder, $FALSE];
Repaint[vRef];
};
};

DontDrawBordersComm: PROC [comm: CDSequencer.Command] = {
vRef: VRef _ MsgAndVRef[comm, "viewer drawmode: don't draw borders"];
IF vRef#NIL THEN {
vRef.borders _ FALSE;
CDProperties.PutProp[comm.design, $CDxSkipBorder, NIL];
Repaint[vRef];
};
};

CheckEdited: PROC [design: CD.Design] = {
IF design#NIL THEN {
edited: BOOL _ design.edited;
FOR vl: CDViewer.ViewerList _ CDViewer.ViewersOf[design], vl.rest WHILE vl#NIL DO
IF vl.first.newVersion#edited THEN {
vl.first.newVersion _ edited;
ViewerOps.PaintViewer[vl.first, caption]
};
ENDLOOP
}
};

CheckEditedEvent: CDEvents.EventProc = {
TRUSTED {Process.Detach[FORK CheckEdited[design]]};
};

NoteProfileChange: UserProfile.ProfileChangedProc = {
IF reason=edit THEN {
FOR vl: CDViewer.ViewerList _ CDViewer.ViewersOf[NIL], vl.rest WHILE vl#NIL DO
d: CD.Design _ CDViewer.DesignOf[vl.first];
IF d#NIL THEN vl.first.tipTable _ CDEnvironment.GetTipTable[d];
ENDLOOP
};
}; 

UserProfile.CallWhenProfileChanges[NoteProfileChange];
CDPanel.DefineButton[tech: NIL, name: " new view ", proc: SplitViewer, queue: dontQueue, topLine: TRUE];
CDSequencer.ImplementCommand[$ScaleLessDetail, ScaleDown,, dontQueue];
CDSequencer.ImplementCommand[$ScaleMoreDetail, ScaleUp,, dontQueue];
CDSequencer.ImplementCommand[$MoveScreen, MoveScreen,, dontQueue];
CDSequencer.ImplementCommand[$DisplayNames, SignalNames,, doQueue];
CDSequencer.ImplementCommand[$DisplayInstanceNames, InstanceNames,, doQueue];
CDSequencer.ImplementCommand[$ShowRectX, ShowRectX,, dontQueue];
CDSequencer.ImplementCommand[$ShowRect, ShowRect,, dontQueue];
CDSequencer.ImplementCommand[$ResetScaleAll, ResetScaleComm,, dontQueue];
CDSequencer.ImplementCommand[$ResetScaleTop, ResetScaleToPushedComm,, dontQueue];
CDSequencer.ImplementCommand[$ResetScaleSel, ResetScaleToSelectedComm,, dontQueue];
CDSequencer.ImplementCommand[$DisplayViewers, ShowViewers,, doQueue];
CDSequencer.ImplementCommand[$SplitViewer, SplitViewer,, dontQueue];
CDSequencer.ImplementCommand[$GridInfo, GridInfoComm,, dontQueue];
CDSequencer.ImplementCommand[$TicksInfo, TicksInfoComm,, doQueue];
CDSequencer.ImplementCommand[$SetSimplification, SetSimplificationComm,, dontQueue];
CDSequencer.ImplementCommand[$RestoreScale, RestoreViewComm,, dontQueue];
CDSequencer.ImplementCommand[$SetCellSimplification, SetCellSimplification];
CDSequencer.ImplementCommand[$EnforcePanel, EnforcePanel,, doQueue];

CDSequencer.ImplementCommand[$ViewFSub, FontSubstOnComm,, dontQueue];
CDSequencer.ImplementCommand[$ViewNFSub, FontSubstOffComm,, dontQueue];
CDSequencer.ImplementCommand[$ViewEnv, DrawEnvComm,, dontQueue];
CDSequencer.ImplementCommand[$ViewNEnv, DontDrawEnvComm,, dontQueue];
CDSequencer.ImplementCommand[$ViewSym, DrawSymbolicsComm,, dontQueue];
CDSequencer.ImplementCommand[$ViewNSym, DontDrawSymbolicsComm,, dontQueue];
CDSequencer.ImplementCommand[$ViewBord, DrawBordersComm,, dontQueue];
CDSequencer.ImplementCommand[$ViewNBord, DontDrawBordersComm,, dontQueue];

CDEvents.RegisterEventProc[event: $AfterOutput, proc: CheckEditedEvent];
CDEvents.RegisterEventProc[event: $CheckEdited, proc: CheckEditedEvent];
END.



ΊCDVCommands.mesa   (part of ChipNDale)
Copyright c 1983, 1985, 1986 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, June 29, 1983 4:44 pm 
Last Edited by: Christian Jacobi, December 4, 1986 5:25:20 pm PST
--Utilities and public
--if r does not already has a CR 
--NO SaveScale[viewer]; it is better to have one fixed point
--gets viewer on different screen if possible,
--else different viewer, if possible...
ΚQ–

"cedar" style˜
codeš
œ&™&Kšœ
Οm
œ=™HKš
œ3™3Kš
œA™AK˜—š
Ο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šœ
žœ:˜I—K˜šΟnœžœ
ž˜Kšžœ
žœC˜Ϋ
Kšžœ˜—Kš
ž˜K˜Kšœžœ˜K˜Kš
Οc™K˜šŸ
œžœ#žœ˜HKš
œ3˜3Kšžœžœ
žœ*˜7šžœ
žœžœ
ž˜Kšœžœžœ˜8Kšžœžœ
˜—Kš
œ˜—K˜š
Ÿœžœ
žœžœžœ˜2Kš
 !™!Kšœžœ˜Kšžœžœ
žœ˜=Kšžœ˜K˜—K˜š
Ÿ
œžœ'žœžœ
žœ˜YKš
œ3˜3Kš
œ˜Kšžœžœ
žœ+˜8šžœ
žœžœ
ž˜š
œ˜Kšžœžœ˜'Kšžœ3˜7—Kšžœ9˜@—Kš
œ˜—K˜šŸœžœžœ˜šžœžœ
ž˜š
œ˜Kš
œ˜Kš
œb˜bK˜—Kš
œ5˜5Kš
œ/˜/Kšžœžœ
˜—Kš
œ˜K˜—šŸ	œžœ
žœ#˜9šžœžœ
žœ
˜šžœ
žœ
ž˜KšœDžœ"˜iKšžœžœ
˜——Kš
œ˜—K˜šŸœžœ
žœ#˜<šžœžœ
žœ
˜šžœ
žœ
ž˜š
œ˜šŸœžœžœžœ˜:šžœ,žœ
ž˜;Kšœžœžœ˜*Kšžœžœ˜)—K˜—Kš
œ4˜4Kš
œ˜Kš
 <™<šžœžœ žœ
˜DKš
œ%˜%—Kšœ:žœ"˜_Kš
œe˜eKš
œ˜Kš
œ˜—Kšžœžœ
˜——Kš
œ˜—K˜šŸœžœžœ˜šžœžœ
ž˜Kšœ1žœ˜LKš
œ:˜:Kš
œ4˜4Kšžœ˜$—Kš
œ˜—K˜šŸœžœžœ˜1Kšœžœ
žœ%˜7šžœžœ
˜%Kš
œ%˜%—šžœ˜Kšœ.žœ
˜:Kšœžœ1˜GKšœžœ˜"Kš
œ˜Kš
œ˜Kš
œ#˜#Kš
œN˜NKš
œT˜TKš
œE˜EKš
œT˜Tš
œ˜Kš
œ0˜0Kš
œ˜Kš
œ˜—Kš
œO˜OKš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜K˜—šŸœžœ ˜-šŸœžœ˜Kšœžœ˜Kšœžœžœžœ˜K˜K˜—Kš
œ˜Kš
œ˜K˜—šŸ	œžœ ˜/KšŸœžœ9˜AKš
œ˜Kš
œ˜K˜—šŸ
œžœ ˜0šŸœžœ˜Kšœžœ
˜Kš
œ˜K˜2K˜3Kš
œb˜bKš
œ˜K˜—Kš
œ$˜$Kš
œ˜Kš
œ˜K˜—š
Ÿœžœ$žœžœžœ
˜Ušžœ!žœ
ž˜0Kšœžœ
žœ˜Kšžœžœ
˜—K˜K˜—šŸœžœ ˜2šŸœžœžœ
žœ˜CKš
œ9˜9Kš
œ˜—Kšœžœ˜Kšœžœ!˜,Kš
œ8˜8Kšžœžœ
žœ"˜4šžœ˜Kš
œH˜Hšžœ˜KšœžœL˜XKš
œ˜Kšœ4ž˜8K˜K˜K˜K˜K˜K˜Kš
œf˜fKšœ	žœ
žœ7˜GKšœ	žœ
žœ)˜9Kšžœ˜—šžœžœ	žœ˜Kšœ*žœ
žœ˜AKšœ)žœ$˜OK˜
—Kšžœ$˜(K˜—Kš
œ˜K˜—šŸœžœ˜:šŸœžœ˜Kšœžœ
˜Kš
œ˜š
œ˜KšœžœW˜cKš
œ)˜)Kš
œc˜cK˜—šžœž˜
Kš
œ'˜'Kš
œ(˜(Kš
œ&˜&Kš
œ'˜'Kš
œ'˜'Kš
œ%˜%Kšžœžœ
˜—Kš
œ
˜
K˜—Kš
œ<˜<Kš
œ˜Kš
œ˜K˜—šŸ
œžœ˜2Kšœ
žœ˜Kšœžœ!˜,Kš
œ8˜8Kšžœžœ
žœ"˜4šžœ˜Kš
œ%˜%Kšœ/žœ(˜Yš
œ˜Kšœžœ9˜EKš
œ˜Kš
œA˜AKš
œ˜—Kš
œ˜šžœž˜
K˜K˜K˜K˜K˜š
œ˜Kšœžœ$˜*Kš
žœžœžœ
žœžœ˜;Kš
œ˜—š
œ˜Kšœžœ*˜0Kš
žœžœžœ
žœžœ
˜-Kš
œ˜—Kšžœžœ
˜—Kšœ*žœ
žœ˜FKšžœ
žœ#˜3Kšžœ
žœ
žœ%˜:Kšžœ+žœ'˜XK˜—Kš
œ˜K˜—šŸ
œžœ ˜3Kš
œ3˜3Kš
œ0˜0šžœžœ
žœ
˜Kšœ!žœ˜;—Kš
œ˜K˜—šŸœžœ ˜1Kš
œ3˜3Kš
œ.˜.šžœžœ
žœ
˜Kšœ!žœ˜9—Kš
œ˜K˜—šŸœžœžœ˜UKš
 .™.Kš
 '™'Kš
œ:˜:Kš
œ8˜8Kšœ	žœžœ
žœ˜4šžœ%žœžœ
ž˜6šžœžœ
˜Kšžœ žœ
žœ˜8—Kšžœ
˜—šžœ%žœžœ
ž˜6šžœžœ
˜Kšžœžœ
žœ˜6—Kšžœ
˜—šžœ%žœžœ
ž˜6šžœžœ
˜Kšžœžœ
žœ˜(—Kšžœ
˜—Kšžœ
˜Kš
œ˜K˜—šΠbn	œžœ ˜/K˜šŸ
œžœžœžœ˜?Kšœžœ
˜Kšžœžœžœžœ˜LKš
œ˜—K˜Kš
œ6˜6Kš
œ*˜*šžœžœ
žœ
˜Kšžœžœ6˜NKšžœS˜W—Kš
œ˜—K˜šŸœžœ ˜5Kš
œ/˜/Kš
œ'˜'Kš
œ˜—K˜šŸœžœ ˜.Kš
œ8˜8Kš
œ#˜#Kš
œ˜Kšžœžœ(˜BKšžœE˜IKš
œ˜Kš
œ˜—K˜š‘œžœ ˜4K˜š‘
œžœ#˜6Kšœžœ˜Kš
œ-˜-Kš
œ1˜1Kšžœžœ"˜>Kš
œ˜Kš
œ˜K˜—Kš
œ8˜8šžœžœ
žœ˜Kš
œ˜Kš
œ˜K˜—Kš
œ˜—K˜š‘œžœ ˜>Kš
œ8˜8Kš
œ/˜/šžœžœ
žœ˜KšœžœSžœ˜^šžœžœ˜Kš
œ˜Kš
œ/˜/Kš
œ˜Kšžœ
˜K˜—K˜—Kš
œ'˜'Kš
œ˜—K˜š‘œžœ ˜<Kš
œ8˜8šžœžœ
žœ˜Kšœžœ˜Kš
œ˜Kš
œ?˜?KšœOžœ˜VKšžœžœ"˜>Kš
œ˜K˜—Kš
œ˜—K˜š‘œžœ ˜1šŸœžœ˜Kš
œc˜cKš
œ˜—Kš
œ%˜%Kš
œ˜Kš
œ˜—K˜š‘œžœ ˜1Kš
œ%˜%Kšœ(žœžœ
˜5Kš
œ˜—K˜šŸœžœ ˜;šŸœžœ˜Kš
œ&˜&š	žœžœ4žœžœ
ž˜Kšžœžœžœ˜9KšœžœV˜dKšœ;žœ˜AKš
œ+˜+Kš
œ˜—Kšžœ
˜—Kš
œ˜—Kš
œC˜CKš
œ˜Kš
œ˜—K˜šŸœžœ ˜2Kš
œ˜Kš
œ0˜0Kš
œ%˜%šžœžœ
žœ˜Kšžœ
žœ˜&Kšžœ"˜&K˜—Kš
œ˜K˜—šŸœžœ ˜5Kš
œI˜Išžœžœ
žœ˜Kšœžœ
˜Kš
œ>˜>Kš
œ˜K˜—Kš
œ˜—K˜šŸœžœ ˜6Kš
œO˜Ošžœžœ
žœ˜Kšœžœ
˜Kšœ7žœ˜<Kš
œ˜K˜—Kš
œ˜—K˜šŸœžœ ˜1Kš
œS˜Sšžœžœ
žœ˜Kšœžœ
˜Kšœ7žœ˜<Kš
œ˜K˜—Kš
œ˜—K˜šŸœžœ ˜5Kš
œY˜Yšžœžœ
žœ˜Kšœžœ
˜Kš
œ?˜?Kš
œ˜K˜—Kš
œ˜—K˜šŸœžœ ˜7Kš
œH˜Hšžœžœ
žœ˜Kšœžœ˜Kšœ5žœ˜:Kš
œ˜K˜—Kš
œ˜—K˜šŸœžœ ˜;Kš
œN˜Nšžœžœ
žœ˜Kšœžœ
˜Kš
œ=˜=Kš
œ˜Kš
œ˜—Kš
œ˜—K˜šŸœžœ ˜5Kš
œD˜Dšžœžœ
žœ˜Kšœžœ
˜Kš
œ:˜:Kš
œ˜K˜—Kš
œ˜—K˜šŸœžœ ˜9Kš
œE˜Ešžœžœ
žœ˜Kšœžœ
˜Kšœ2žœ˜7Kš
œ˜K˜—Kš
œ˜—K˜šŸœžœ
žœ˜)šžœžœ
žœ˜Kšœžœ˜šžœ?žœžœ
ž˜Qšžœžœ˜$Kš
œ˜Kš
œ(˜(Kš
œ˜—Kš
ž˜—K˜
—Kš
œ˜—K˜šŸœ˜(Kšžœžœ˜3Kš
œ˜—K˜š‘œ$˜5šžœ
žœ˜š	žœ.žœžœžœ
ž˜NKšœžœ&˜+Kšžœžœ
žœ2˜?Kš
ž˜—Kš
œ˜—Kš
œ˜—K˜Kš
œ6˜6KšœžœDžœ˜hKš
œF˜FKš
œD˜DKš
œB˜BKš
œC˜CKš
œM˜MKš
œ@˜@Kš
œ>˜>Kš
œI˜IKš
œQ˜QKš
œS˜SKš
œE˜EKš
œD˜DKš
œB˜BKš
œB˜BKš
œT˜TKš
œI˜IKš
œL˜LK˜DK˜Kš
œE˜EKš
œG˜GKš
œ@˜@Kš
œE˜EKš
œF˜FKš
œK˜KKš
œE˜EKš
œJ˜JK˜Kš
œH˜HKš
œH˜HKšžœ
˜K˜K˜—…—E€Z―