DIRECTORY
CD,
CDApplications,
CDCommands,
CDCommandOps,
CDOps,
CDOrient,
CDRects,
CDSequencer,
TerminalIO,
CDInline;

CDWireAndSelectCommands: CEDAR PROGRAM
IMPORTS CDApplications, CDCommandOps, CDCommands, CDOps, CDSequencer, TerminalIO, CDRects, CDInline = 
BEGIN

AddARect: PROC[design: CD.Design, r: CD.DesignRect,  l: CD.Level] =
BEGIN
ob: CD.ObPtr;
sz: CD.DesignPosition _ CDInline.SizeOfRect[r];
orient: CD.Orientation _ CDOrient.original;
IF sz.y<sz.x THEN {
w: CD.DesignNumber _ sz.x; 
sz.x _ sz.y; 
sz.y _ w; 
orient _ CDOrient.rotate90
};
IF sz.x<=0 THEN {TerminalIO.WriteRope["Empty object not included\n"]; RETURN};
ob _ CDRects.CreateRect[sz, l];
CDOps.AddAnObject[
design: design, 
ob: ob, 
location: CDInline.BaseOfRect[r], 
orientation: orient]
END;

SelectExclusive: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Select pointed"];
CDCommands.DeselectAll[comm.design];
CDCommands.Select[comm.design, comm.pos];
TerminalIO.WriteLn[];
END;

ReSelect: PROC [design: CD.Design, pos: CD.DesignPosition, verbose: BOOL_TRUE] RETURNS [done: BOOL_TRUE] =
BEGIN
Deselect: PROC[a: CD.ApplicationPtr] = 
INLINE BEGIN
IF a.selected THEN {
a.selected _ FALSE;
CDOps.DelayedRedraw[design, CDApplications.ARectO[a], TRUE]
}
END;
DeselectList: PROC[list: CD.ApplicationList] = 
BEGIN
FOR w: CD.ApplicationList _ list, w.rest WHILE w#NIL DO
Deselect[w.first]
ENDLOOP
END;
ap: CD.ApplicationPtr _ NIL; --any application where pos points to
FOR w: CD.ApplicationList _ CDOps.AppList[design], w.rest WHILE w#NIL DO
IF CDApplications.PointToO[pos, w.first] AND CDApplications.PointToI[pos, w.first] THEN {
IF w.first.selected THEN {
DeselectList[w.rest]; 
CDOps.ReOrderApplication[design, w.first];
IF verbose THEN CDCommandOps.WriteInfo[w.first];
RETURN
}
ELSE IF ap=NIL THEN ap _ w.first
}
ELSE Deselect[w.first]
ENDLOOP;
IF ap#NIL THEN {
ap.selected _ TRUE; 
CDOps.ReOrderApplication[design, ap];
CDOps.DelayedRedraw[design, CDApplications.ARectO[ap], FALSE];
IF verbose THEN CDCommandOps.WriteInfo[ap]
}
ELSE {
done _ FALSE;
IF verbose THEN TerminalIO.WriteRope["  (no object)"];
}
END;

RectDist: PROC[pos: CD.DesignPosition, r: CD.Rect] RETURNS [CD.DesignNumber] =
BEGIN
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)
]]
END;

CloseReSelect: PROC [design: CD.Design, pos: CD.DesignPosition, verbose: BOOL_TRUE, dist: CD.DesignNumber_100] =
BEGIN
IF ~ReSelect[design, pos, verbose] THEN {
ap: CD.ApplicationPtr _ NIL;
FOR w: CD.ApplicationList _ CDOps.AppList[design], w.rest WHILE w#NIL DO
d: CD.DesignNumber = RectDist[pos, CDApplications.ARectI[w.first]];
IF d<dist THEN {ap _ w.first; dist _ d}
ENDLOOP;
IF ap#NIL THEN {
ap.selected _ TRUE;
CDOps.DelayedRedraw[design, CDApplications.ARectO[ap], FALSE];
IF verbose THEN {
TerminalIO.WriteRope["found close object"];
CDCommandOps.WriteInfo[ap]
}
}
}
END;

ReSelectExclusive: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["(Re)Select pointed"];
[] _ ReSelect[comm.design, comm.pos];
TerminalIO.WriteLn[];
END;

CloseReSelectCommand: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Select (most close)"];
[] _ CloseReSelect[comm.design, comm.pos, TRUE, 50];
TerminalIO.WriteLn[];
END;

AddRect: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Add rect\n"]; 
AddARect[comm.design, CDInline.ToRect[comm.sPos, comm.pos], comm.l];
END;

AddWire: PROC [comm: CDSequencer.Command] =
BEGIN
InternalAddWire[comm: comm, firstOnly: FALSE]
END;

ContinueWire: PROC [comm: CDSequencer.Command] =
BEGIN
InternalAddWire[comm: comm, firstOnly: TRUE]
END;

InternalAddWire: PROC [comm: CDSequencer.Command, firstOnly: BOOL_FALSE] =
BEGIN
start: CD.DesignPosition _ comm.sPos; 
stop: CD.DesignPosition _ comm.pos;
wireWidth: CD.DesignNumber _ comm.n;
IF wireWidth=0 THEN {AddRect[comm]; RETURN};
TerminalIO.WriteRope["Add 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]<CD.lambda THEN 
{TerminalIO.WriteRope[" Empty Wire not added\n"]; RETURN};
stop.x _ start.x+wireWidth;
AddARect[comm.design, CDInline.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, CDInline.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, CDInline.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, CDInline.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]<CD.lambda THEN 
{TerminalIO.WriteRope[" Empty Wire not added\n"]; RETURN};
stop.y _ start.y+wireWidth;
AddARect[comm.design, CDInline.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, CDInline.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, CDInline.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, CDInline.ToRect[start, stop], comm.l];
}
}
END;

DeselectPointed: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Remove selection\n"]; 
CDCommands.DeSelect[comm.design, comm.pos]
END;

DeSelectLast: PROC [design: CD.Design, pos: CD.DesignPosition, usePos: BOOL_TRUE] RETURNS [done: BOOL_FALSE] =
BEGIN 
sel: CD.ApplicationPtr _ NIL;
FOR w: CD.ApplicationList _ CDOps.AppList[design], w.rest WHILE w#NIL DO
IF w.first.selected THEN { 
IF ~usePos OR CDApplications.PointToI[pos, w.first] THEN sel _ w.first;
};
ENDLOOP;
IF sel#NIL THEN {
sel.selected _ FALSE;
done _ TRUE;
CDOps.DelayedRedraw[design, CDApplications.ARectO[sel]];
}
END;

DeselectLastSelected: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Remove selection\n"]; 
[] _ DeSelectLast[comm.design, comm.pos, TRUE]
END;

AddSelection: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Add selection  "]; 
CDCommands.Select[comm.design, comm.pos];
TerminalIO.WriteLn[];
END;

DeselectAll: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Deselect all\n"]; 
CDCommands.DeselectAll[comm.design]
END;

DeleteSelected: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Delete selected\n"]; 
CDCommands.DeleteSelected[comm.design]
END;

DeletePointed: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Delete pointed\n"]; 
CDCommands.DeletePointed[comm.design, comm.pos]
END;

Undelete: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Undelete\n"]; 
CDCommands.Undelete[comm.design]
END;

SelectAll: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Select all\n"]; 
CDCommands.SelectAll[comm.design]
END;

AreaAddSelect: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Inclusive select area\n"]; 
CDCommands.AreaSelect[comm.design, CDInline.ToRect[comm.pos, comm.sPos]]
END;

AAddSelect: PROC [comm: CDSequencer.Command] =
BEGIN
IF comm.pos=comm.sPos THEN {
TerminalIO.WriteRope["select inclusive  "]; 
CDCommands.Select[comm.design, comm.pos];
TerminalIO.WriteLn[];
}
ELSE {
TerminalIO.WriteRope["select inclusive\n"]; 
CDCommands.AreaSelect[comm.design, CDInline.ToRect[comm.pos, comm.sPos]]
}
END;

AreaAddSelectTouching: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["select inclusive touching\n"]; 
CDCommands.AreaSelect[comm.design, CDInline.ToRect[comm.pos, comm.sPos], TRUE]
END;

AreaOnlySelect: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Exclusive select area\n"]; 
CDCommands.DeselectAll[comm.design];
CDCommands.AreaSelect[comm.design, CDInline.ToRect[comm.pos, comm.sPos]]
END;

ADeSelect: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["deselect\n"]; 
IF comm.pos=comm.sPos THEN CDCommands.DeSelect[comm.design, comm.pos]
ELSE CDCommands.AreaDeSelect[comm.design, CDInline.ToRect[comm.pos, comm.sPos]]
END;

AreaDeSelect: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Deselect area\n"]; 
CDCommands.AreaDeSelect[comm.design, CDInline.ToRect[comm.pos, comm.sPos]]
END;

AreaDeSelectTouching: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Deselect touching\n"]; 
CDCommands.AreaDeSelect[comm.design, CDInline.ToRect[comm.pos, comm.sPos], TRUE]
END;

AbortCommand: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Try to abort current command\n"]; 
CDSequencer.AbortTheCommand[comm.design]
END;

Impl: PROC [] =
BEGIN
CDSequencer.ImplementCommand[$AbortCommand, AbortCommand,, dontQueue];

CDSequencer.ImplementCommand[$DrawRect, AddRect];
CDSequencer.ImplementCommand[$DrawWire, AddWire];
CDSequencer.ImplementCommand[$ContinueWire, ContinueWire];
CDSequencer.ImplementCommand[$DeleteS, DeleteSelected];
CDSequencer.ImplementCommand[$DeleteP, DeletePointed];
CDSequencer.ImplementCommand[$Undel, Undelete];

CDSequencer.ImplementCommand[$OnlySelectP, SelectExclusive,, doQueue];
CDSequencer.ImplementCommand[$ReSelectOnlyP, ReSelectExclusive,, doQueue];
CDSequencer.ImplementCommand[$CloseReSelectOnlyP, CloseReSelectCommand,, doQueue];
CDSequencer.ImplementCommand[$AddSelectP, AddSelection,, doQueue];
CDSequencer.ImplementCommand[$DeSelectLP, DeselectLastSelected,, doQueue];
CDSequencer.ImplementCommand[$DeSelectFP, DeselectPointed,, doQueue];
--oldy--CDSequencer.ImplementCommand[$DeSelectP, DeselectPointed,, doQueue];
CDSequencer.ImplementCommand[$DeSelectS, DeselectAll,, doQueue];
CDSequencer.ImplementCommand[$SelectAll, SelectAll,, doQueue];
CDSequencer.ImplementCommand[$AreaOnlySelect, AreaOnlySelect,, doQueue];

CDSequencer.ImplementCommand[$AreaAddSelect, AreaAddSelect,, doQueue];
CDSequencer.ImplementCommand[$AreaAddSelectTouching, AreaAddSelectTouching,, doQueue];
CDSequencer.ImplementCommand[$AAddSelect, AAddSelect,, doQueue];

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

END;

Impl[];
END.
BCDWireAndSelectCommands.mesa   (part of Chipndale)
by Christian Jacobi   June 29, 1983 4:44 pm 
last edited Christian Jacobi   February 3, 1984 7:19 pm
--hit
--if a selected ap is pointed we already did return
--Distance between a point and a rectangle
--select pointed application exclusive;
--(but dont select an other application if the pointed one is already the right one)
--select pointed application exclusive;
--(but dont select an other application if the pointed one is already the right one)
--if there is none, select closest
--uses pos, sPos, n (for width), b (for firstHorizontal), l (for level)
--this procedure knows EXACTLY the algorithm used for showing
--temporary wires in the cursor part
--not only crazy vertical
-- not only crazy horizontal 
--Auto select area or pointed
--Auto deselect area or pointed
�Ê”˜Jš
œ2™2Jš
œ,™,Jš
œ7™7J˜š
Ïk	˜	Jš�œ
˜J˜J˜J˜
J˜J˜	J˜J˜J˜J˜	J˜—šÏnœ�œ
�˜&Jš�œ_˜f—Jš
�˜J˜š
žœ�œ	�œ�œ�œ	˜CJš
�˜Jšœ�œ˜
Jšœ�œ)˜/Jšœ�œ!˜+š�œ�œ˜Jšœ�œ˜Jš
œ
˜
Jš
œ
˜
Jš
œ˜Jš
œ˜—Jš�œ	�œ7�œ˜NJš
œ˜˜J˜J˜J˜"Jš
œ˜—Jš�œ
˜J˜—šžœ�œ˜3Jš
�˜J˜'J˜$J˜)J˜Jš�œ
˜J˜—šžœ�œ
�œ�œ�œ
�œ�œ�	œ˜jJš
�˜šžœ�œ�œ˜'Jš�œ
�˜š�œ�œ˜Jšœ
�œ
˜Jšœ6�œ
˜;J˜
—Jš�œ
˜—šžœ�œ�œ˜/Jš
�˜š	�œ�œ �œ�œ
�˜7Jš
œ˜Jš
�˜—Jš�œ
˜—Jšœ�œ�œÏc%˜Bš	�œ�œ1�œ�œ
�˜Hš�œ'�œ'�œ˜YJš
œ™š�œ�œ˜Jš
œ˜Jš
œ*˜*Jš�œ	�œ!˜0Jš
�˜Jš
œ
˜
—Jš�œ
�œ�œ
�œ
˜ Jš
œ
˜
—Jš�œ˜Jš�œ
˜—Jš
œ3™3š�œ�œ
�œ˜Jšœ�œ˜Jš
œ%˜%Jšœ7�œ˜>Jš�œ	�œ˜*J˜
—š�œ˜Jšœ�œ
˜
Jš�œ	�œ'˜6J˜
—Jš�œ
˜J˜—šžœ�œ�œ�œ�œ�œ˜NJ™*Jš
�˜š�œ�œ
˜Jš
œ
�œ�œ�œ
�œ�œ�œ˜NJš
œ
�œ�œ�œ
�œ�œ�œ˜MJ˜—Jš�œ
˜—J˜šž
œ�œ
�œ�œ�œ
�œ�œ˜pJš
�˜š�œ!�œ˜)Jšœ�œ�œ
˜š	�œ�œ1�œ�œ
�˜HJšœ�œ>˜CJš�œ�œ˜'Jš�œ
˜—š�œ�œ
�œ˜Jšœ�œ
˜Jšœ7�œ˜>š�œ	�œ˜Jš
œ+˜+Jš
œ˜J˜
—J˜
—J˜
—Jš�œ
˜J˜—šžœ�œ˜5Jš
œ'™'J™TJš
�˜J˜+Jš
œ%˜%J˜Jš�œ
˜J˜—šžœ�œ˜8Jš
œ'™'J™TJ™"Jš
�˜J˜,Jšœ*�œ˜4J˜Jš�œ
˜J˜—šžœ�œ˜+Jš
�˜J˜$Jš
œD˜DJš�œ
˜—J˜šžœ�œ˜+Jš
œG™GJš
�˜Jšœ'�œ
˜-Jš
�˜—J˜šžœ�œ˜0Jš
�˜Jšœ'�œ
˜,Jš�œ
˜—J˜šžœ�œ(�œ
�œ˜JJš
œ=™=Jš
œ$™$Jš
�˜Jšœ�œ˜&Jšœ�œ˜#Jšœ�œ˜$Jš�œ
�œ�œ˜,J˜$š�œ
Ÿœ�œ˜$š�œ�œ˜0Jš�œ�œ�œ
Ÿ˜Mš�œ
�œ�œ�œ
˜&Jšœ2�œ˜:—Jš
œ˜Jš
œ<˜<Jš
�˜Jš
œ˜—JšœŸœ	™š	�œ�œ�œ
�
œ
Ÿ˜IJš
œ˜Jš
œ;˜;Jš
œ
˜
—š�œ
Ÿ˜#Jš�œ�œ˜3Jš�œ�œ0˜;Jš
œ˜Jš
œ<˜<Jš�œ�œ
�œ
˜Jš
œF˜FJš
œ<˜<Jš
œ
˜
—J˜
—š�œ
Ÿ˜"š�œ�œ˜1Jš�œ�œ�œ
Ÿ˜Oš�œ
�œ�œ�œ
˜&Jšœ2�œ˜:—Jš
œ˜Jš
œ<˜<Jš
�˜J˜—JšœŸœ
Ÿ
œ
™š	�œ�œ�œ
�
œ
Ÿ˜GJš
œ˜Jš
œ;˜;Jš
œ
˜
—š�œ
Ÿ˜!Jš�œ�œ˜3Jš�œ�œ2˜=Jš
œ˜Jš
œ<˜<Jš�œ�œ
�œ
˜Jš
œF˜FJš
œ<˜<Jš
œ
˜
—J˜
—Jš�œ
˜J˜—šžœ�œ˜3Jš
�˜J˜,J˜*Jš�œ
˜J˜—šžœ�œ
�œ�œ�œ
�œ�œ�œ
�œ˜nJš�œ
˜Jšœ�œ�œ
˜š	�œ�œ1�œ�œ
�˜Hš�œ�œ˜Jš�œ	�œ'�œ˜GJ˜—Jš�œ
˜—š�œ�œ
�œ˜Jšœ�œ
˜Jšœ�œ
˜Jš
œ8˜8J˜
—Jš�œ
˜J˜—šžœ�œ˜8Jš
�˜J˜,Jšœ)�œ
˜.Jš�œ
˜J˜—šžœ�œ˜0Jš
�˜J˜)J˜)J˜Jš�œ
˜J˜—šžœ�œ˜/Jš
�˜J˜(J˜#Jš�œ
˜J˜—šžœ�œ˜2Jš
�˜J˜+J˜&Jš�œ
˜J˜—šž
œ�œ˜1Jš
�˜J˜*J˜/Jš�œ
˜J˜—šžœ�œ˜,Jš
�˜J˜$J˜ Jš�œ
˜J˜—šž	œ�œ˜-Jš
�˜J˜&J˜!Jš�œ
˜—J˜šž
œ�œ˜1Jš
�˜J˜1Jš
œH˜HJš�œ
˜—J˜šž
œ�œ˜.Jš
œ™Jš
�˜š�œ�œ˜J˜,Jš
œ)˜)J˜Jš
œ
˜
—š�œ˜J˜,Jš
œH˜HJ˜
—Jš�œ
˜—J˜šžœ�œ˜9Jš
�˜J˜5JšœI�œ
˜NJš�œ
˜—J˜šžœ�œ˜2Jš
�˜J˜1Jš
œ$˜$Jš
œH˜HJš�œ
˜—J˜šž	œ�œ˜-Jš
œ™Jš
�˜J˜$Jš�œ�œ+˜EJš�œK˜OJš�œ
˜—J˜šžœ�œ˜0Jš
�˜J˜)Jš
œJ˜JJš�œ
˜—J˜šžœ�œ˜8Jš
�˜J˜-JšœK�œ
˜PJš�œ
˜—J˜šžœ�œ˜0Jš
�˜J˜8Jš
œ(˜(Jš�œ
˜—J˜šžœ�œ˜Jš
�˜Jš
œF˜FJ˜J˜1Jš
œ1˜1J˜:J˜7J˜6J˜/J˜Jš
œF˜FJš
œJ˜JJš
œR˜RJš
œB˜BJš
œJ˜JJš
œE˜EJšŸœD˜LJš
œ@˜@Jš
œ>˜>Jš
œH˜HJ˜Jš
œF˜FJš
œV˜VJš
œ@˜@J˜Jš
œD˜DJš
œT˜TJš
œ>˜>J˜Jš�œ
˜—J˜Jš
œ˜Jš�œ
˜—…—)ö9Ì