DIRECTORY Basics, BiScrollers, Graphics, InputFocus, IO, OrderedSymbolTableRef, Rope, SchemeRep, SchemeEditing, TIPUser, ViewerClasses, ViewerOps, ViewRec;

SchemeViewing: CEDAR PROGRAM
IMPORTS BiScrollers, Graphics, InputFocus, IO, OrderedSymbolTableRef, Rope, SchemeEditing, TIPUser, ViewerOps, ViewRec
EXPORTS SchemeEditing =

BEGIN OPEN SchemeRep, SchemeEditing;

editorClasses: PUBLIC ARRAY SubjectClass OF BiScrollers.BiScrollerClass _ [
BiScrollers.NewBiScrollerClass[
flavor: $SchemeIconEditor,
extrema: PicExtrema,
notify: NotifyScheme,
paint: PaintScheme,
destroy: DestroyEditor,
tipTable: TIPUser.InstantiateNewTIPTable["SchemeIcon.TIP"]],
BiScrollers.NewBiScrollerClass[
flavor: $SchemeExpansionEditor,
extrema: PicExtrema,
notify: NotifyScheme,
paint: PaintScheme,
destroy: DestroyEditor,
tipTable: TIPUser.InstantiateNewTIPTable["SchemeExpansion.TIP"]]
];

PicExtrema: BiScrollers.ExtremaProc --PROC [clientData: REF ANY, direction: Vec] RETURNS [min, max: Geom2D.Vec]-- =
{editor: Editor _ NARROW[clientData];
smallestX:Coord _ PikCoord[editor.subjectPic.coordsByValue[X].LookupSmallest[]];
smallestY:Coord _ PikCoord[editor.subjectPic.coordsByValue[Y].LookupSmallest[]];
largestX: Coord _ PikCoord[editor.subjectPic.coordsByValue[X].LookupLargest[]];
largestY: Coord _ PikCoord[editor.subjectPic.coordsByValue[Y].LookupLargest[]];
min _ [
IF smallestX # NIL THEN smallestX.z ELSE -10,
IF smallestY # NIL THEN smallestY.z ELSE -10];
max _ [
IF largestX # NIL THEN largestX.z ELSE 10,
IF largestY # NIL THEN largestY.z ELSE 10];
};

PikCoord: PROC [any: REF ANY] RETURNS [coord: Coord] = {
coord _ IF any # NIL THEN WITH any SELECT FROM
c: Coord => c,
cl: LORA => NARROW[cl.first],
ENDCASE => ERROR
ELSE NIL};

PaintScheme: ViewerClasses.PaintProc --PROC [self: Viewer, context: Graphics.Context, whatChanged: REF ANY, clear: BOOL]-- =
BEGIN
editor: Editor _ NARROW[BiScrollers.QuaBiScroller[self].ClientDataOf[]];
[] _ Graphics.SetPaintMode[context, invert];
IF whatChanged = NIL THEN {
DrawPic[editor.subjectPic, context, [0, 0]];
SetBack[editor.primary]; DrawBack[editor.primary, context];
SetBack[editor.secondary]; DrawBack[editor.secondary, context]}
ELSE WITH whatChanged SELECT FROM
la: LORA => UpdateWhatever[la, context];
coord: Coord => UpdateCoord[coord, context];
pb: PointBack => IF pb.x # pb.sx OR pb.y # pb.sy THEN {DrawBack[pb, context]; SetBack[pb]; DrawBack[pb, context]};
line: Line => {SetLine[line]; DrawLine[line, context]};
text: Text => {SetText[text]; DrawText[text, context]};
pi: PictureInstance => {SetInstance[pi]; DrawPic[pi.of, context, pi.s]};
ENDCASE => ERROR;
END;

SetInstance: PROC [pi: PictureInstance] =
{pi.s[X] _ pi.org.c[X].z; pi.s[Y] _ pi.org.c[Y].z};

DrawPic: PROC [pic: PictureDef, context: Graphics.Context, at: VertexReals] =
BEGIN
DrawObject: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
{stop _ FALSE;
WITH any SELECT FROM
line: Line => {SetLine[line]; DrawLine[line, context]};
text: Text => {SetText[text]; DrawText[text, context]};
pi: PictureInstance => {IF pi.in # pic THEN ERROR;
SetInstance[pi]; DrawPic[pi.of, context, pi.s]};
ENDCASE => ERROR};
org: Graphics.Mark _ Graphics.Save[context];
Graphics.Translate[self: context, tx: at[X], ty: at[Y]];
pic.objects.EnumerateIncreasing[DrawObject];
Graphics.Restore[context, org];
END;

UpdateWhatever: PROC [l: LORA, context: Graphics.Context] =
BEGIN
WITH l.first SELECT FROM
a: ATOM => SELECT a FROM
$Labels => FOR ll: LORA _ l.rest, ll.rest WHILE ll # NIL DO
text: Text _ NARROW[ll.first];
IF text.sxy#[text.org.c[X].z, text.org.c[Y].z] OR NOT text.sr.Equal[text.rope]
THEN {DrawText[text, context]; SetText[text]; DrawText[text, context]};
ENDLOOP;
ENDCASE => ERROR;
ENDCASE => ERROR;
END;

UpdateCoord: PROC [coord: Coord, context: Graphics.Context] =
BEGIN
UpdatePIC: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
{c2: Coord _ NARROW[any]; stop _ FALSE;
IF c2.axis = coord.axis THEN UpdateCoord[c2, context]};
coord.z _ coord.dz + Org[coord];
IF coord.z = coord.sz THEN RETURN;
coord.sz _ coord.z;
FOR dl: LORA _ coord.dependents, dl.rest WHILE dl # NIL DO
WITH dl.first SELECT FROM
c2: Coord => UpdateCoord[c2, context];
pt: Point => FOR l: LORA _ pt.dependents, l.rest WHILE l # NIL DO
WITH l.first SELECT FROM
line: Line => IF line.sa # [line.a.c[X].z, line.a.c[Y].z] OR line.sb # [line.b.c[X].z, line.b.c[Y].z]
THEN {DrawLine[line, context]; SetLine[line]; DrawLine[line, context]};
text: Text => IF text.sxy # [text.org.c[X].z, text.org.c[Y].z]
THEN {DrawText[text, context]; SetText[text]; DrawText[text, context]};
pi: PictureInstance => IF pi.s # [pi.org.c[X].z, pi.org.c[Y].z] THEN {
DrawPic[pi.of, context, pi.s];
SetInstance[pi];
DrawPic[pi.of, context, pi.s];
pi.coords.EnumerateIncreasing[UpdatePIC]};
ENDCASE => ERROR;
ENDLOOP;
ENDCASE => ERROR;
ENDLOOP;
END;

Org: PROC [coord: Coord] RETURNS [z: REAL] =
{z _ IF coord.parent = NIL THEN 0 ELSE
WITH coord.parent SELECT FROM
c2: Coord => c2.z,
pi: PictureInstance => pi.org.c[coord.axis].z,
ENDCASE => ERROR};

SetLine: PROC [line: Line] = {
line.sa _ [line.a.c[X].z, line.a.c[Y].z];
line.sb _ [line.b.c[X].z, line.b.c[Y].z]};

DrawLine: PROC [line: Line, context: Graphics.Context] =
BEGIN
Graphics.SetCP[context, line.sa[X], line.sa[Y]];
Graphics.DrawTo[context, line.sb[X], line.sb[Y]];
END;

SetText: PROC [text: Text] =
{text.sxy _ [text.org.c[X].z, text.org.c[Y].z]; text.sr _ text.rope};

DrawText: PROC [text: Text, context: Graphics.Context] =
BEGIN
Graphics.SetCP[context, text.sxy[X], text.sxy[Y]];
Graphics.DrawRope[context, text.sr];
END;

SetBack: PROC [back: PointBack] = {back.sx _ back.x; back.sy _ back.y};

DrawBack: PROC [back: PointBack, context: Graphics.Context] =
BEGIN
org: Graphics.Mark _ Graphics.Save[context];
Graphics.Translate[self: context, tx: back.sx, ty: back.sy];
IF back.primary
THEN Graphics.DrawStroke[self: context, path: primaryPath]
ELSE Graphics.DrawBox[context, [-1.5, -1.5, 1.5, 1.5]];
Graphics.Restore[context, org];
END;

gray: CARDINAL = 257*18*5;

primaryPath: Graphics.Path _ Graphics.NewPath[];

NotifyScheme: ViewerClasses.NotifyProc --PROC [self: Viewer, input: LIST OF REF ANY]-- =
BEGIN
editor: Editor _ NARROW[BiScrollers.QuaBiScroller[self].ClientDataOf[]];
WHILE input # NIL DO
WITH input.first SELECT FROM
a: ATOM => SELECT a FROM
$StartSelect => input _ StartSelect[editor, FALSE, input];
$TrackSelect => input _ TrackSelect[editor, FALSE, input];
$FinalSelect => input _ FinalSelect[editor, FALSE, input];
$StartDraw => input _ StartSelect[editor, TRUE, input];
$TrackDraw => input _ TrackSelect[editor, TRUE, input];
$FinalDraw => input _ FinalSelect[editor, TRUE, input];
$Move => input _ Move[editor, input];
$EndMove => {EndMove[editor]; input _ input.rest};
$SetGoal => {editor.strandGoal _ editor.primary.point; input _ input.rest};
$FinishWire => {NewStrand[editor, TRUE]; input _ input.rest};
$BreakWire => input _ BreakWire[editor, input];
$JoinWire => input _ JoinWire[editor, input];
$DownShift => {editor.oldHor _ FALSE; input _ input.rest};
$DownCtrl => {editor.oldHor _ TRUE; input _ input.rest};
ENDCASE => ERROR;
ENDCASE => ERROR;
ENDLOOP;
END;

SetBackToPoint: PUBLIC PROC [editor: Editor, pb: PointBack, p: Point] =
BEGIN
pb.point _ p;
pb.x _ p.c[X].z;
pb.y _ p.c[Y].z;
NotifyBack[pb, editor];
END;

NotifyBack: PROC [pb: PointBack, editor: Editor] =
{ViewerOps.PaintViewer[viewer: editor.v, hint: client, clearClient: FALSE, whatChanged: pb]};

EndMove: PROC [editor: Editor] =
BEGIN
IF editor.moveSubject[X] # NIL THEN {RestoreCoords[editor.subjectPic, editor.moveSubject[X]]; editor.moveSubject[X] _ NIL};
IF editor.moveSubject[Y] # NIL THEN {RestoreCoords[editor.subjectPic, editor.moveSubject[Y]]; editor.moveSubject[Y] _ NIL};
END;

Move: PROC [editor: Editor, input: LORA] RETURNS [output: LORA] =
BEGIN
rawCoords: BiScrollers.ClientCoords = NARROW[input.rest.first];
moveX: BOOLEAN = DecodeBool[$NoShift, $Shift, input.rest.rest.first];
moveY: BOOLEAN = DecodeBool[$NoCtrl, $Ctrl, input.rest.rest.rest.first];
output _ input.rest.rest.rest.rest;
editor.session.mostRecentEditor _ editor;
IF editor.moveSubject # [editor.primary.cx, editor.primary.cy] THEN {
EndMove[editor];
editor.moveSubject _ [editor.primary.cx, editor.primary.cy];
UntableCoords[editor.subjectPic, editor.moveSubject[X]];
UntableCoords[editor.subjectPic, editor.moveSubject[Y]];
};
IF moveX THEN SetZ[editor, X, rawCoords.x];
IF moveY THEN SetZ[editor, Y, rawCoords.y];
END;

SetZ: PROC [editor: Editor, axis: Axis, z: REAL] =
BEGIN
c: Coord _ editor.moveSubject[axis];
IF c.parent # NIL AND ISTYPE[c.parent, PictureInstance] THEN {Complain[editor, IO.PutFR[" can't move in %g axis", IO.rope[axisNames[axis]]]]; RETURN};
c.z _ z; c.dz _ z - Org[c];
NotifyCoord[c, editor];
END;

NotifyCoord: PUBLIC PROC [coord: Coord, editor: Editor] =
BEGIN
ViewerOps.PaintViewer[viewer: editor.v, hint: client, clearClient: FALSE, whatChanged: coord];
END;

UntableCoords: PROC [pic: PictureDef, root: Coord] =
BEGIN
UntablePIC: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
{c2: Coord _ NARROW[any]; stop _ FALSE;
IF c2.axis = root.axis THEN UntableCoords[pic, c2]};
UntableCoord[pic.coordsByValue[root.axis], root];
FOR l: LORA _ root.dependents, l.rest WHILE l # NIL DO
WITH l.first SELECT FROM
c: Coord => UntableCoords[pic, c];
p: Point => FOR dl: LORA _ p.dependents, dl.rest WHILE dl # NIL DO
WITH dl.first SELECT FROM
pi: PictureInstance => pi.coords.EnumerateIncreasing[UntablePIC];
x: Line => NULL;
x: Text => NULL;
ENDCASE => ERROR;
ENDLOOP;
ENDCASE => ERROR;
ENDLOOP;
END;

UntableCoord: PROC [table: Table, coord: Coord] =
BEGIN
found: REF ANY _ table.Lookup[coord];
IF found = coord
THEN {IF table.Delete[coord] # coord THEN ERROR}
ELSE {cl: LORA _ NARROW[found];
cl2: LORA _ Filter[cl, coord];
IF cl2.rest = NIL THEN
{IF table.Delete[coord] # cl THEN ERROR; table.Insert[cl2.first]}
ELSE IF cl2 # cl THEN
{IF table.Delete[coord] # cl THEN ERROR; table.Insert[cl2]}
};
END;

Filter: PUBLIC PROC [list: LORA, elt: REF ANY] RETURNS [filtered: LORA] =
BEGIN
IF list.first = elt THEN RETURN [list.rest];
filtered _ list;
FOR list _ list, list.rest WHILE list.rest # NIL DO
IF list.rest.first = elt THEN {list.rest _ list.rest.rest; RETURN};
ENDLOOP;
ERROR;
END;

EntableCoord: PUBLIC PROC [table: Table, coord: Coord] =
BEGIN
old: REF ANY;
old _ table.Lookup[coord];
IF old # NIL THEN WITH old SELECT FROM
c: Coord => {IF table.Delete[coord] # c THEN ERROR; table.Insert[LIST[c, coord]]};
l: LORA => l.rest _ CONS[coord, l.rest];
ENDCASE => ERROR
ELSE table.Insert[coord];
END;

RestoreCoords: PROC [pic: PictureDef, root: Coord] =
BEGIN
EntablePIC: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
{c2: Coord _ NARROW[any]; stop _ FALSE;
IF c2.axis = root.axis THEN RestoreCoords[pic, c2]};
EntableCoord[pic.coordsByValue[root.axis], root];
FOR l: LORA _ root.dependents, l.rest WHILE l # NIL DO
WITH l.first SELECT FROM
c: Coord => RestoreCoords[pic, c];
p: Point => FOR dl: LORA _ p.dependents, dl.rest WHILE dl # NIL DO
WITH dl.first SELECT FROM
pi: PictureInstance => pi.coords.EnumerateIncreasing[EntablePIC];
x: Line => NULL;
x: Text => NULL;
ENDCASE => ERROR;
ENDLOOP;
ENDCASE => ERROR;
ENDLOOP;
END;

StartSelect: PROC [editor: Editor, drawing: BOOLEAN, input: LORA] RETURNS [output: LORA] =
BEGIN
editor.session.ctlRV.DisplayMessage[ViewRec.clearMessagePlace];
PushSelection[editor];
output _ TrackSelect[editor, drawing, input]
END;

PushSelection: PROC [editor: Editor] =
BEGIN
editor.secondary.x _ editor.primary.x;
editor.secondary.y _ editor.primary.y;
editor.secondary.cx _ editor.primary.cx;
editor.secondary.cy _ editor.primary.cy;
editor.secondary.point _ editor.primary.point;
NotifyBack[editor.secondary, editor];
END;

TrackSelect: PROC [editor: Editor, drawing: BOOLEAN, input: LORA] RETURNS [output: LORA] =
BEGIN
rawCoords: BiScrollers.ClientCoords = NARROW[input.rest.first];
snapX: BOOLEAN = DecodeBool[$NoShift, $Shift, input.rest.rest.first];
snapY: BOOLEAN = DecodeBool[$NoCtrl, $Ctrl, input.rest.rest.rest.first];
ctl: CtlPanel _ editor.session.ctlPanel;
output _ input.rest.rest.rest.rest;
editor.session.mostRecentEditor _ editor;
IF drawing AND editor.subjectClass = expansion AND ctl.expansionAction = strand AND ctl.action = create THEN --strange snapping
SnapWire[editor, snapX, snapY, rawCoords]
ELSE IF (editor.subjectClass = expansion AND NOT drawing) OR ctl.action = delete THEN --snap to point
SnapToPoint[editor, rawCoords, editor.primary]
ELSE BEGIN
IF snapX
THEN [editor.primary.x, editor.primary.cx] _ SnapToCoord[rawCoords.x, editor.subjectPic.coordsByValue[X]]
ELSE {editor.primary.x _ rawCoords.x; editor.primary.cx _ NIL};
IF snapY
THEN [editor.primary.y, editor.primary.cy] _ SnapToCoord[rawCoords.y, editor.subjectPic.coordsByValue[Y]]
ELSE {editor.primary.y _ rawCoords.y; editor.primary.cy _ NIL};
END;
NotifyBack[editor.primary, editor];
END;

SnapWire: PROC [editor: Editor, snapX, snapY: BOOLEAN, rawCoords: BiScrollers.ClientCoords] =
BEGIN
IF editor.secondary.cx = NIL OR editor.secondary.cy = NIL THEN {Complain[editor, " no secondary coordinates!"]; RETURN};
IF snapX AND snapY THEN {
IF editor.strandGoal = NIL THEN SnapToPoint[editor, rawCoords, editor.primary]
ELSE IF editor.oldHor THEN {
editor.primary.x _ (editor.primary.cx _ editor.secondary.cx).z;
editor.primary.y _ (editor.primary.cy _ editor.strandGoal.c[Y]).z}
ELSE {
editor.primary.x _ (editor.primary.cx _ editor.strandGoal.c[X]).z;
editor.primary.y _ (editor.primary.cy _ editor.secondary.cy).z}}
ELSE IF snapX THEN {
editor.primary.x _ (editor.primary.cx _ editor.secondary.cx).z;
editor.primary.y _ rawCoords.y; editor.primary.cy _ NIL}
ELSE IF snapY THEN {
editor.primary.x _ rawCoords.x; editor.primary.cx _ NIL;
editor.primary.y _ (editor.primary.cy _ editor.secondary.cy).z}
ELSE {
editor.primary.x _ rawCoords.x; editor.primary.cx _ NIL;
editor.primary.y _ rawCoords.y; editor.primary.cy _ NIL};
END;

SnapToPoint: PROC [editor: Editor, rawCoords: BiScrollers.ClientCoords, back: PointBack] =
BEGIN
Nearest: PROC [raw: REF ANY, r: REF REAL] RETURNS [p: Point, d: REAL] =
BEGIN
Account: PROC [deps: LORA] =
BEGIN
FOR deps _ deps, deps.rest WHILE deps # NIL DO
WITH deps.first SELECT FROM
point: Point => {dx, dy, d2: REAL;
dx _ point.c[X].z - rawCoords.x;
dy _ point.c[Y].z - rawCoords.y;
d2 _ dx*dx + dy*dy;
IF p = NIL OR d2 < d THEN {p _ point; d _ d2}};
c: Coord => NULL;
ENDCASE => ERROR;
ENDLOOP;
END;
p _ NIL;
d _ 0;
WITH raw SELECT FROM
c: Coord => {IF r # NIL THEN r^ _ c.z; Account[c.dependents]};
la: LORA => {
c: Coord;
FOR l: LORA _ la, l.rest WHILE l # NIL DO
c _ NARROW[l.first];
Account[c.dependents];
ENDLOOP;
IF r # NIL THEN r^ _ c.z};
ENDCASE => ERROR;
END;
rawHi, rawLo: REF ANY;
ans: Point _ NIL;
rr^ _ rl^ _ rawCoords.x;
IF (rawHi _ editor.subjectPic.coordsByValue[X].Lookup[rr]) # NIL
THEN [ans,] _ Nearest[rawHi, NIL];
WHILE ans = NIL DO
ansLo, ansHi: Point _ NIL;
dl, dr: REAL;
rawLo _ editor.subjectPic.coordsByValue[X].LookupNextSmaller[rl];
rawHi _ editor.subjectPic.coordsByValue[X].LookupNextLarger[rr];
IF rawLo = NIL AND rawHi = NIL THEN {Complain[editor, " no points!"]; RETURN};
IF rawLo # NIL THEN [ansLo, dl] _ Nearest[rawLo, rl];
IF rawHi # NIL THEN [ansHi, dr] _ Nearest[rawHi, rr];
IF ansLo # NIL AND ansHi = NIL THEN ans _ ansLo ELSE
IF ansLo = NIL AND ansHi # NIL THEN ans _ ansHi ELSE
IF ansLo # NIL AND ansHi # NIL THEN ans _ IF dl < dr THEN ansLo ELSE ansHi;
ENDLOOP;
back.x _ (back.cx _ ans.c[X]).z;
back.y _ (back.cy _ ans.c[Y]).z;
END;

DecodeBool: PROC [false, true: ATOM, any: REF ANY] RETURNS [BOOL] = {
IF any = false THEN RETURN [FALSE];
IF any = true THEN RETURN [TRUE];
ERROR};

rl: REF REAL _ NEW [REAL _ 86];
rr: REF REAL _ NEW [REAL _ 47];

SnapToCoord: PROC [raw: REAL, table: Table] RETURNS [nearest: REAL, coord: Coord] =
BEGIN
l, m, h: REF ANY;
low, high: Coord;
rr^ _ raw;
[l, m, h] _ table.Lookup3[rr];
IF m # NIL THEN {coord _ PikCoord[m]; RETURN [coord.z, coord]} ELSE
IF l = NIL AND h = NIL THEN RETURN [0, NIL];
low _ PikCoord[l];
high _ PikCoord[h];
IF low = NIL THEN coord _ high ELSE
IF high = NIL THEN coord _ low ELSE
IF raw-low.z < high.z-raw THEN coord _ low
ELSE coord _ high;
nearest _ coord.z;
END;

FinalSelect: PROC [editor: Editor, drawing: BOOLEAN, input: LORA] RETURNS [output: LORA] =
BEGIN
output _ TrackSelect[editor, drawing, input];
IF editor.primary.cx = NIL THEN editor.primary.cx _ NewCoord[X, editor.primary.x, editor.subjectPic];
IF editor.primary.cy = NIL THEN editor.primary.cy _ NewCoord[Y, editor.primary.y, editor.subjectPic];
editor.primary.point _ MakePoint[editor.subjectPic, [editor.primary.cx, editor.primary.cy]];
IF drawing THEN Draw[editor];
InputFocus.SetInputFocus[self: editor.v];
END;

Draw: PROC [editor: Editor] =
BEGIN
SELECT editor.session.ctlPanel.action FROM
create => SELECT editor.subjectClass FROM
icon => SELECT editor.session.ctlPanel.iconAction FROM
line => [] _ NewLine[editor.subjectPic, editor.secondary.point, editor.primary.point];
text => NewText[editor.subjectPic, editor.primary.point, editor.session.ctlPanel.name];
instance => NewInstance[editor.subjectPic, editor.primary.point, editor.session.ctlPanel.cellType, editor.session.ctlPanel.icon];
ENDCASE => ERROR;
expansion => SELECT editor.session.ctlPanel.expansionAction FROM
component => NewComponent[editor];
port => NewPort[editor];
strand => NewStrand[editor, FALSE];
ENDCASE => ERROR;
ENDCASE => ERROR;
delete => SELECT editor.subjectClass FROM
icon => SELECT editor.session.ctlPanel.iconAction FROM
line => [] _ DeleteLine[editor.subjectPic, editor.secondary.point, editor.primary.point];
text => DeleteText[editor.subjectPic, editor.primary.point];
instance => DeleteInstance[editor.subjectPic, editor.primary.point, NIL];
ENDCASE => ERROR;
expansion => SELECT editor.session.ctlPanel.expansionAction FROM
component => DeleteComponent[editor];
port => DeletePort[editor];
strand => DeleteStrand[editor];
ENDCASE => ERROR;
ENDCASE => ERROR;
ENDCASE => ERROR;
IF editor.subjectClass = expansion THEN CheckObjects[editor.subjectPic];
IF editor.primary.point # NIL AND editor.primary.point.deleted THEN editor.primary.point _ NIL;
IF editor.secondary.point # NIL AND editor.secondary.point.deleted THEN editor.secondary.point _ NIL;
END;

CheckObjects: PROC [pic: PictureDef] =
{Check: PROC [any: REF ANY] RETURNS [stop: BOOLEAN] =
{stop _ FALSE;
WITH any SELECT FROM
l: Line => IF NOT Member[l, l.net.stuff] THEN ERROR;
t: Text => NULL;
pi: PictureInstance => NULL;
ENDCASE => ERROR};
pic.objects.EnumerateIncreasing[Check]};

Member: PROC [elt: REF ANY, list: LORA] RETURNS [found: BOOLEAN] =
{found _ FALSE;
FOR list _ list, list.rest WHILE list # NIL DO
IF list.first = elt THEN RETURN [TRUE];
ENDLOOP;
found _ FALSE};

Start: PROC =
BEGIN
Graphics.MoveTo[primaryPath, -5, 5, TRUE];
Graphics.LineTo[primaryPath, 5, -5];
Graphics.MoveTo[primaryPath, -5, -5, FALSE];
Graphics.LineTo[primaryPath, 5, 5];
END;

Start[];

END.
VScheme>SchemeViewing.Mesa
Last Edited by: Spreitzer, February 12, 1984 10:14 pm
ΚR–

"cedar" style˜Icode™J™5K˜KšΟk	œ,œd˜›
K˜šΠbx
œœ
˜Kšœ$œI˜vKšœ˜—K˜Kšœ
œ˜$K˜šœœ
œœ ˜Kš
œ˜K˜K˜K˜K˜K˜K˜<—š
œ˜K˜K˜K˜K˜K˜K˜@—K˜—K˜šΟn
œΟcMœ˜sKšœœ
˜%Kšœ;
œ˜PKšœ;
œ˜PKšœ;
œ˜OKšœ;
œ˜O˜Kšœ
œ
œ
œ˜-Kšœ
œ
œ
œ˜.—š
œ˜Kšœœ
œœ˜*Kšœœ
œœ˜+—K˜—K˜š
Ÿœœœ
œœ˜8šœœœ
œ
œœ
˜.K˜Kšœœœ˜Kšœ˜—Kšœ
œ˜
—K˜šŸœ Uœ˜|Kš
˜Kšœœ1˜HK˜,šœœ
œ˜Kš
œ,˜,K˜;K˜?—šœ
œ
œ
˜!Kšœœ ˜(Kš
œ,˜,Kšœœœœ=˜rK˜7K˜7K˜HKšœœ
˜—Kšœ
˜—K˜šŸœœ˜)Kš	œ
œ

œ

œ

œ˜3—K˜šŸœœ@˜MKš
˜šŸ
œœœ
œœœ˜9Kšœœ
˜šœœ
˜K˜7K˜7šœœ
œ
œ
˜2Kš
œ0˜0—Kšœœ˜——K˜,Kšœ)
œ

œ˜8K˜,K˜Kšœ
˜—K˜šŸœœœ˜;Kš
˜šœ	œ
˜šœœœ˜š
œœœœœ
˜;Kšœ
œ˜š
œ
œ
œœ
œ˜NKšœC˜G—Kšœ
˜—Kšœœ
˜—Kšœœ
˜—Kšœ
˜—K˜šŸœœ,˜=Kš
˜šŸ	œœœ
œœœ˜8Kšœ
œœ
˜'Kšœœ˜7—K˜ Kšœœ
œ
˜"K˜š	œœœœ
˜:šœ
œ
˜K˜&š
œ
œœœœ
˜Ašœ	œ
˜š
œœ
œ
œœ
œ
œ˜eKšœC˜G—šœœ
œ
œ˜>KšœC˜G—š	œœ
œ
œœ˜FKš
œ˜Kš
œ˜Kš
œ˜Kš
œ*˜*—Kšœœ
˜—Kšœ
˜—Kšœœ
˜—Kšœ
˜—Kšœ
˜—K˜šŸœœœœ˜,Kšœœœ
œ˜&šœœ
˜K˜K˜.Kšœœ˜——K˜šŸœœ˜Kšœ
œ
œ˜)Kšœ
œ
œ˜*—K˜šŸœœ*˜8Kš
˜Kšœ 
œ
œ˜0Kšœ!
œ
œ˜1Kšœ
˜—K˜šŸœœ˜Kšœ
œ
œ˜E—K˜šŸœœ*˜8Kš
˜Kšœ!
œ
œ˜2Kš
œ$˜$Kšœ
˜—K˜KšŸœœ:˜GK˜šŸœœ/˜=Kš
˜K˜,K˜<šœ
˜Kšœ6˜:Kšœ3˜7—K˜Kšœ
˜—K˜Kšœœ˜K˜K˜0K˜šŸœ /œ˜XKš
˜Kšœœ1˜Hšœ	œ
˜šœ
œ
˜šœœœ˜Kšœ,œ	˜:Kšœ,œ	˜:Kšœ,œ	˜:Kšœ*œ	˜7Kšœ*œ	˜7Kšœ*œ	˜7K˜%K˜2K˜KKšœ"œ˜=K˜/K˜-Kšœœ˜:Kšœœ˜8Kšœœ
˜—Kšœœ
˜—Kšœ
˜—Kšœ
˜—K˜šŸœœ
œ,˜GKš
˜K˜
Kšœ
œ˜Kšœ
œ˜K˜Kšœ
˜—K˜šŸ
œœ"˜2KšœDœ˜]—K˜šŸœœ˜ Kš
˜Kšœ
œœ
œ6
œ
œœ˜{Kšœ
œœ
œ6
œ
œœ˜{Kšœ
˜—K˜š
Ÿœœœœ
œ˜AKš
˜Kšœ&œ˜?Kšœœ7˜EKšœœ:˜HK˜#K˜)šœ=œ˜EK˜K˜<Kšœ4
œ˜8Kšœ4
œ˜8K˜—Kšœœ
œ˜+Kšœœ
œ˜+Kšœ
˜—K˜šŸœœ!œ˜2Kš
˜K˜$Kšœœ
œ
œœœ!œœ˜–
K˜K˜Kšœ
˜—K˜šŸœœ
œ!˜9Kš
˜KšœCœ˜^Kšœ
˜—K˜šŸ
œœ!˜4Kš
˜šŸ
œœœ
œœœ˜9Kšœ
œœ
˜'Kšœœ˜4—Kš
œ1˜1š	œœœœ
˜6šœ	œ
˜K˜"š
œœœœœ
˜Bšœ
œ
˜K˜AKšœœ
˜Kšœœ
˜Kšœœ
˜—Kšœ
˜—Kšœœ
˜—Kšœ
˜—Kšœ
˜—K˜šŸœœ˜1Kš
˜Kšœœ
œ˜%šœ˜Kšœœœ
œ
˜0šœœœ˜Kšœœ˜šœœ
˜Kšœ
œœ
œ˜A—šœ
œ
˜Kšœ
œœ
œ˜;—Kš
œ˜——Kšœ
˜—K˜šŸœœ
œœœ
œœœ˜IKš
˜Kšœœ
œ
˜,K˜šœœ
œ
˜3Kšœœœ˜CKšœ
˜—Kšœ
˜Kšœ
˜—K˜šŸœœ
œ˜8Kš
˜Kšœœ
œ
˜
Kš
œ˜šœœ
œ
œœ
˜&Kš	œ
œœ
œœ
˜RKšœœ
œ˜(Kšœ˜—Kšœ˜Kšœ
˜—K˜šŸ
œœ!˜4Kš
˜šŸ
œœœ
œœœ˜9Kšœ
œœ
˜'Kšœœ˜4—Kš
œ1˜1š	œœœœ
˜6šœ	œ
˜Kš
œ"˜"š
œœœœœ
˜Bšœ
œ
˜K˜AKšœœ
˜Kšœœ
˜Kšœœ
˜—Kšœ
˜—Kšœœ
˜—Kšœ
˜—Kšœ
˜—K˜šŸœœœ	œœ
œ˜ZKš
˜Kš
œ?˜?K˜K˜,Kšœ
˜—K˜šŸ
œœ˜&Kš
˜Kš
œ&˜&Kš
œ&˜&Kš
œ(˜(Kš
œ(˜(K˜.Kš
œ%˜%Kšœ
˜—K˜šŸœœœ	œœ
œ˜ZKš
˜Kšœ&œ˜?Kšœœ7˜EKšœœ:˜HK˜(K˜#K˜)šœ	œ!œœœ
 ˜Kš
œ)˜)—š
œ
œ"œ
œ
œœ
 ˜eKš
œ.˜.—šœ
˜
šœ˜Kšœb
œ˜iKšœ6œ˜?—šœ˜Kšœb
œ˜iKšœ6œ˜?—Kšœ
˜—Kš
œ#˜#Kšœ
˜—K˜šŸœœ œ(˜]Kš
˜Kšœœ
œœ
œ2œ˜xšœœœ˜Kšœœ
œ/˜Nšœ
œœ˜Kš
œ?˜?Kšœ<
œ˜B—šœ˜Kšœ<
œ˜BKš
œ@˜@——šœ
œœ˜Kš
œ?˜?Kšœ4œ
˜8—šœ
œœ˜Kšœ4œ
˜8Kš
œ?˜?—šœ˜Kšœ4œ
˜8Kšœ4œ˜9—Kšœ
˜—K˜šŸœœI˜ZKš
˜šŸœœœ
œœ
œœœ˜GKš
˜šŸœœœ˜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šœ(
œ˜AKšœ(
œ˜@Kšœ	œ
œ	œ
œ#œ˜NKšœ	œ
œ"˜5Kšœ	œ
œ"˜5Kšœ	œ
œ	œ
œ
˜4Kšœ	œ
œ	œ
œ
˜4Kšœ	œ
œ	œ
œœ	œœ˜KKšœ
˜—Kšœ
œ˜ Kšœ
œ˜ Kšœ
˜—K˜šŸ
œœœœ
œœœ˜EKšœ
œ
œœ˜#Kšœœ
œœ˜!Kšœ˜—K˜Kš	œœ
œœœ˜Kš	œœ
œœœ˜K˜š
Ÿœœœœœ˜SKš
˜Kšœ	œ
œ
˜Kš
œ˜K˜
K˜Kš	œœ
œœ˜CKšœœ
œœ
œ
œœ˜,Kš
œ˜Kš
œ˜Kšœœ
œ˜#Kšœœ
œ
˜#Kšœœ˜*Kšœ˜K˜Kšœ
˜—K˜šŸœœœ	œœ
œ˜ZKš
˜K˜-Kšœœ
œ
œ'˜eKšœœ
œ
œ'˜eK˜\Kšœ	œ˜K˜)Kšœ
˜—K˜šŸœœ˜Kš
˜šœ ˜*šœ
œ˜)šœœ$˜6K˜VKš
œW˜WKš
œ
˜
Kšœœ
˜—šœ
œ)˜@K˜"Kš
œ˜Kšœœ˜#Kšœœ
˜—Kšœœ
˜—šœ
œ˜)šœœ$˜6K˜YKš
œ<˜<KšœDœ˜IKšœœ
˜—šœ
œ)˜@K˜%Kš
œ˜Kš
œ˜Kšœœ
˜—Kšœœ
˜—Kšœœ
˜—Kšœ!œ!˜HKš
œœ
œœœ
˜_Kš
œœ
œ œœ
˜eKšœ
˜—K˜šŸœœ˜&š
œ
Ÿœœœ
œœœ˜5Kšœœ
˜šœœ
˜Kš	œœ
œœ
œ
˜4Kšœœ
˜Kšœœ
˜Kšœœ˜——K˜(—K˜šŸœœœ
œœœ	œ˜BKšœ	œ
˜šœœœ
˜.Kšœœ
œœ˜'Kšœ
˜—Kšœœ˜—K˜šŸœœ˜
Kš
˜Kšœ$œ˜*K˜$Kšœ%œ˜,K˜#Kšœ
˜—K˜K˜K˜Kšœ
˜—…—IΖan